* de.po: Update.
[official-gcc.git] / gcc / gcc.c
blob86077f8cf321ad1ed3a3897b1259ddc06d71eeca
1 /* Compiler driver program that can handle many languages.
2 Copyright (C) 1987-2013 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 /* This program is the user interface to the C compiler and possibly to
21 other compilers. It is used because compilation is a complicated procedure
22 which involves running several programs and passing temporary files between
23 them, forwarding the users switches to those programs selectively,
24 and deleting the temporary files at the end.
26 CC recognizes how to compile each input file by suffixes in the file names.
27 Once it knows which kind of compilation to perform, the procedure for
28 compilation is specified by a string called a "spec". */
30 #include "config.h"
31 #include "system.h"
32 #include "coretypes.h"
33 #include "multilib.h" /* before tm.h */
34 #include "tm.h"
35 #include "xregex.h"
36 #include "obstack.h"
37 #include "intl.h"
38 #include "prefix.h"
39 #include "gcc.h"
40 #include "diagnostic.h"
41 #include "flags.h"
42 #include "opts.h"
43 #include "params.h"
44 #include "vec.h"
45 #include "filenames.h"
47 /* By default there is no special suffix for target executables. */
48 /* FIXME: when autoconf is fixed, remove the host check - dj */
49 #if defined(TARGET_EXECUTABLE_SUFFIX) && defined(HOST_EXECUTABLE_SUFFIX)
50 #define HAVE_TARGET_EXECUTABLE_SUFFIX
51 #endif
53 /* By default there is no special suffix for host executables. */
54 #ifdef HOST_EXECUTABLE_SUFFIX
55 #define HAVE_HOST_EXECUTABLE_SUFFIX
56 #else
57 #define HOST_EXECUTABLE_SUFFIX ""
58 #endif
60 /* By default, the suffix for target object files is ".o". */
61 #ifdef TARGET_OBJECT_SUFFIX
62 #define HAVE_TARGET_OBJECT_SUFFIX
63 #else
64 #define TARGET_OBJECT_SUFFIX ".o"
65 #endif
67 static const char dir_separator_str[] = { DIR_SEPARATOR, 0 };
69 /* Most every one is fine with LIBRARY_PATH. For some, it conflicts. */
70 #ifndef LIBRARY_PATH_ENV
71 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
72 #endif
74 /* If a stage of compilation returns an exit status >= 1,
75 compilation of that file ceases. */
77 #define MIN_FATAL_STATUS 1
79 /* Flag set by cppspec.c to 1. */
80 int is_cpp_driver;
82 /* Flag set to nonzero if an @file argument has been supplied to gcc. */
83 static bool at_file_supplied;
85 /* Definition of string containing the arguments given to configure. */
86 #include "configargs.h"
88 /* Flag saying to print the command line options understood by gcc and its
89 sub-processes. */
91 static int print_help_list;
93 /* Flag saying to print the version of gcc and its sub-processes. */
95 static int print_version;
97 /* Flag indicating whether we should ONLY print the command and
98 arguments (like verbose_flag) without executing the command.
99 Displayed arguments are quoted so that the generated command
100 line is suitable for execution. This is intended for use in
101 shell scripts to capture the driver-generated command line. */
102 static int verbose_only_flag;
104 /* Flag indicating how to print command line options of sub-processes. */
106 static int print_subprocess_help;
108 /* Whether we should report subprocess execution times to a file. */
110 FILE *report_times_to_file = NULL;
112 /* Nonzero means place this string before uses of /, so that include
113 and library files can be found in an alternate location. */
115 #ifdef TARGET_SYSTEM_ROOT
116 static const char *target_system_root = TARGET_SYSTEM_ROOT;
117 #else
118 static const char *target_system_root = 0;
119 #endif
121 /* Nonzero means pass the updated target_system_root to the compiler. */
123 static int target_system_root_changed;
125 /* Nonzero means append this string to target_system_root. */
127 static const char *target_sysroot_suffix = 0;
129 /* Nonzero means append this string to target_system_root for headers. */
131 static const char *target_sysroot_hdrs_suffix = 0;
133 /* Nonzero means write "temp" files in source directory
134 and use the source file's name in them, and don't delete them. */
136 static enum save_temps {
137 SAVE_TEMPS_NONE, /* no -save-temps */
138 SAVE_TEMPS_CWD, /* -save-temps in current directory */
139 SAVE_TEMPS_OBJ /* -save-temps in object directory */
140 } save_temps_flag;
142 /* Output file to use to get the object directory for -save-temps=obj */
143 static char *save_temps_prefix = 0;
144 static size_t save_temps_length = 0;
146 /* The compiler version. */
148 static const char *compiler_version;
150 /* The target version. */
152 static const char *const spec_version = DEFAULT_TARGET_VERSION;
154 /* The target machine. */
156 static const char *spec_machine = DEFAULT_TARGET_MACHINE;
158 /* Nonzero if cross-compiling.
159 When -b is used, the value comes from the `specs' file. */
161 #ifdef CROSS_DIRECTORY_STRUCTURE
162 static const char *cross_compile = "1";
163 #else
164 static const char *cross_compile = "0";
165 #endif
167 /* Greatest exit code of sub-processes that has been encountered up to
168 now. */
169 static int greatest_status = 1;
171 /* This is the obstack which we use to allocate many strings. */
173 static struct obstack obstack;
175 /* This is the obstack to build an environment variable to pass to
176 collect2 that describes all of the relevant switches of what to
177 pass the compiler in building the list of pointers to constructors
178 and destructors. */
180 static struct obstack collect_obstack;
182 /* Forward declaration for prototypes. */
183 struct path_prefix;
184 struct prefix_list;
186 static void init_spec (void);
187 static void store_arg (const char *, int, int);
188 static void insert_wrapper (const char *);
189 static char *load_specs (const char *);
190 static void read_specs (const char *, bool, bool);
191 static void set_spec (const char *, const char *, bool);
192 static struct compiler *lookup_compiler (const char *, size_t, const char *);
193 static char *build_search_list (const struct path_prefix *, const char *,
194 bool, bool);
195 static void xputenv (const char *);
196 static void putenv_from_prefixes (const struct path_prefix *, const char *,
197 bool);
198 static int access_check (const char *, int);
199 static char *find_a_file (const struct path_prefix *, const char *, int, bool);
200 static void add_prefix (struct path_prefix *, const char *, const char *,
201 int, int, int);
202 static void add_sysrooted_prefix (struct path_prefix *, const char *,
203 const char *, int, int, int);
204 static char *skip_whitespace (char *);
205 static void delete_if_ordinary (const char *);
206 static void delete_temp_files (void);
207 static void delete_failure_queue (void);
208 static void clear_failure_queue (void);
209 static int check_live_switch (int, int);
210 static const char *handle_braces (const char *);
211 static inline bool input_suffix_matches (const char *, const char *);
212 static inline bool switch_matches (const char *, const char *, int);
213 static inline void mark_matching_switches (const char *, const char *, int);
214 static inline void process_marked_switches (void);
215 static const char *process_brace_body (const char *, const char *, const char *, int, int);
216 static const struct spec_function *lookup_spec_function (const char *);
217 static const char *eval_spec_function (const char *, const char *);
218 static const char *handle_spec_function (const char *);
219 static char *save_string (const char *, int);
220 static void set_collect_gcc_options (void);
221 static int do_spec_1 (const char *, int, const char *);
222 static int do_spec_2 (const char *);
223 static void do_option_spec (const char *, const char *);
224 static void do_self_spec (const char *);
225 static const char *find_file (const char *);
226 static int is_directory (const char *, bool);
227 static const char *validate_switches (const char *, bool);
228 static void validate_all_switches (void);
229 static inline void validate_switches_from_spec (const char *, bool);
230 static void give_switch (int, int);
231 static int used_arg (const char *, int);
232 static int default_arg (const char *, int);
233 static void set_multilib_dir (void);
234 static void print_multilib_info (void);
235 static void perror_with_name (const char *);
236 static void display_help (void);
237 static void add_preprocessor_option (const char *, int);
238 static void add_assembler_option (const char *, int);
239 static void add_linker_option (const char *, int);
240 static void process_command (unsigned int, struct cl_decoded_option *);
241 static int execute (void);
242 static void alloc_args (void);
243 static void clear_args (void);
244 static void fatal_signal (int);
245 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
246 static void init_gcc_specs (struct obstack *, const char *, const char *,
247 const char *);
248 #endif
249 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
250 static const char *convert_filename (const char *, int, int);
251 #endif
253 static const char *getenv_spec_function (int, const char **);
254 static const char *if_exists_spec_function (int, const char **);
255 static const char *if_exists_else_spec_function (int, const char **);
256 static const char *replace_outfile_spec_function (int, const char **);
257 static const char *remove_outfile_spec_function (int, const char **);
258 static const char *version_compare_spec_function (int, const char **);
259 static const char *include_spec_function (int, const char **);
260 static const char *find_file_spec_function (int, const char **);
261 static const char *find_plugindir_spec_function (int, const char **);
262 static const char *print_asm_header_spec_function (int, const char **);
263 static const char *compare_debug_dump_opt_spec_function (int, const char **);
264 static const char *compare_debug_self_opt_spec_function (int, const char **);
265 static const char *compare_debug_auxbase_opt_spec_function (int, const char **);
266 static const char *pass_through_libs_spec_func (int, const char **);
267 static const char *replace_extension_spec_func (int, const char **);
268 static char *convert_white_space (char *);
270 /* The Specs Language
272 Specs are strings containing lines, each of which (if not blank)
273 is made up of a program name, and arguments separated by spaces.
274 The program name must be exact and start from root, since no path
275 is searched and it is unreliable to depend on the current working directory.
276 Redirection of input or output is not supported; the subprograms must
277 accept filenames saying what files to read and write.
279 In addition, the specs can contain %-sequences to substitute variable text
280 or for conditional text. Here is a table of all defined %-sequences.
281 Note that spaces are not generated automatically around the results of
282 expanding these sequences; therefore, you can concatenate them together
283 or with constant text in a single argument.
285 %% substitute one % into the program name or argument.
286 %i substitute the name of the input file being processed.
287 %b substitute the basename of the input file being processed.
288 This is the substring up to (and not including) the last period
289 and not including the directory unless -save-temps was specified
290 to put temporaries in a different location.
291 %B same as %b, but include the file suffix (text after the last period).
292 %gSUFFIX
293 substitute a file name that has suffix SUFFIX and is chosen
294 once per compilation, and mark the argument a la %d. To reduce
295 exposure to denial-of-service attacks, the file name is now
296 chosen in a way that is hard to predict even when previously
297 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
298 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
299 the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
300 had been pre-processed. Previously, %g was simply substituted
301 with a file name chosen once per compilation, without regard
302 to any appended suffix (which was therefore treated just like
303 ordinary text), making such attacks more likely to succeed.
304 %|SUFFIX
305 like %g, but if -pipe is in effect, expands simply to "-".
306 %mSUFFIX
307 like %g, but if -pipe is in effect, expands to nothing. (We have both
308 %| and %m to accommodate differences between system assemblers; see
309 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
310 %uSUFFIX
311 like %g, but generates a new temporary file name even if %uSUFFIX
312 was already seen.
313 %USUFFIX
314 substitutes the last file name generated with %uSUFFIX, generating a
315 new one if there is no such last file name. In the absence of any
316 %uSUFFIX, this is just like %gSUFFIX, except they don't share
317 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
318 would involve the generation of two distinct file names, one
319 for each `%g.s' and another for each `%U.s'. Previously, %U was
320 simply substituted with a file name chosen for the previous %u,
321 without regard to any appended suffix.
322 %jSUFFIX
323 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
324 writable, and if save-temps is off; otherwise, substitute the name
325 of a temporary file, just like %u. This temporary file is not
326 meant for communication between processes, but rather as a junk
327 disposal mechanism.
328 %.SUFFIX
329 substitutes .SUFFIX for the suffixes of a matched switch's args when
330 it is subsequently output with %*. SUFFIX is terminated by the next
331 space or %.
332 %d marks the argument containing or following the %d as a
333 temporary file name, so that that file will be deleted if GCC exits
334 successfully. Unlike %g, this contributes no text to the argument.
335 %w marks the argument containing or following the %w as the
336 "output file" of this compilation. This puts the argument
337 into the sequence of arguments that %o will substitute later.
338 %V indicates that this compilation produces no "output file".
339 %W{...}
340 like %{...} but mark last argument supplied within
341 as a file to be deleted on failure.
342 %o substitutes the names of all the output files, with spaces
343 automatically placed around them. You should write spaces
344 around the %o as well or the results are undefined.
345 %o is for use in the specs for running the linker.
346 Input files whose names have no recognized suffix are not compiled
347 at all, but they are included among the output files, so they will
348 be linked.
349 %O substitutes the suffix for object files. Note that this is
350 handled specially when it immediately follows %g, %u, or %U
351 (with or without a suffix argument) because of the need for
352 those to form complete file names. The handling is such that
353 %O is treated exactly as if it had already been substituted,
354 except that %g, %u, and %U do not currently support additional
355 SUFFIX characters following %O as they would following, for
356 example, `.o'.
357 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
358 (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
359 and -B options) and -imultilib as necessary.
360 %s current argument is the name of a library or startup file of some sort.
361 Search for that file in a standard list of directories
362 and substitute the full name found.
363 %eSTR Print STR as an error message. STR is terminated by a newline.
364 Use this when inconsistent options are detected.
365 %nSTR Print STR as a notice. STR is terminated by a newline.
366 %x{OPTION} Accumulate an option for %X.
367 %X Output the accumulated linker options specified by compilations.
368 %Y Output the accumulated assembler options specified by compilations.
369 %Z Output the accumulated preprocessor options specified by compilations.
370 %a process ASM_SPEC as a spec.
371 This allows config.h to specify part of the spec for running as.
372 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
373 used here. This can be used to run a post-processor after the
374 assembler has done its job.
375 %D Dump out a -L option for each directory in startfile_prefixes.
376 If multilib_dir is set, extra entries are generated with it affixed.
377 %l process LINK_SPEC as a spec.
378 %L process LIB_SPEC as a spec.
379 %M Output multilib_os_dir.
380 %G process LIBGCC_SPEC as a spec.
381 %R Output the concatenation of target_system_root and
382 target_sysroot_suffix.
383 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
384 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
385 %C process CPP_SPEC as a spec.
386 %1 process CC1_SPEC as a spec.
387 %2 process CC1PLUS_SPEC as a spec.
388 %* substitute the variable part of a matched option. (See below.)
389 Note that each comma in the substituted string is replaced by
390 a single space.
391 %<S remove all occurrences of -S from the command line.
392 Note - this command is position dependent. % commands in the
393 spec string before this one will see -S, % commands in the
394 spec string after this one will not.
395 %>S Similar to "%<S", but keep it in the GCC command line.
396 %<S* remove all occurrences of all switches beginning with -S from the
397 command line.
398 %:function(args)
399 Call the named function FUNCTION, passing it ARGS. ARGS is
400 first processed as a nested spec string, then split into an
401 argument vector in the usual fashion. The function returns
402 a string which is processed as if it had appeared literally
403 as part of the current spec.
404 %{S} substitutes the -S switch, if that switch was given to GCC.
405 If that switch was not specified, this substitutes nothing.
406 Here S is a metasyntactic variable.
407 %{S*} substitutes all the switches specified to GCC whose names start
408 with -S. This is used for -o, -I, etc; switches that take
409 arguments. GCC considers `-o foo' as being one switch whose
410 name starts with `o'. %{o*} would substitute this text,
411 including the space; thus, two arguments would be generated.
412 %{S*&T*} likewise, but preserve order of S and T options (the order
413 of S and T in the spec is not significant). Can be any number
414 of ampersand-separated variables; for each the wild card is
415 optional. Useful for CPP as %{D*&U*&A*}.
417 %{S:X} substitutes X, if the -S switch was given to GCC.
418 %{!S:X} substitutes X, if the -S switch was NOT given to GCC.
419 %{S*:X} substitutes X if one or more switches whose names start
420 with -S was given to GCC. Normally X is substituted only
421 once, no matter how many such switches appeared. However,
422 if %* appears somewhere in X, then X will be substituted
423 once for each matching switch, with the %* replaced by the
424 part of that switch that matched the '*'.
425 %{.S:X} substitutes X, if processing a file with suffix S.
426 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
427 %{,S:X} substitutes X, if processing a file which will use spec S.
428 %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
430 %{S|T:X} substitutes X if either -S or -T was given to GCC. This may be
431 combined with '!', '.', ',', and '*' as above binding stronger
432 than the OR.
433 If %* appears in X, all of the alternatives must be starred, and
434 only the first matching alternative is substituted.
435 %{S:X; if S was given to GCC, substitutes X;
436 T:Y; else if T was given to GCC, substitutes Y;
437 :D} else substitutes D. There can be as many clauses as you need.
438 This may be combined with '.', '!', ',', '|', and '*' as above.
440 %(Spec) processes a specification defined in a specs file as *Spec:
442 The conditional text X in a %{S:X} or similar construct may contain
443 other nested % constructs or spaces, or even newlines. They are
444 processed as usual, as described above. Trailing white space in X is
445 ignored. White space may also appear anywhere on the left side of the
446 colon in these constructs, except between . or * and the corresponding
447 word.
449 The -O, -f, -g, -m, and -W switches are handled specifically in these
450 constructs. If another value of -O or the negated form of a -f, -m, or
451 -W switch is found later in the command line, the earlier switch
452 value is ignored, except with {S*} where S is just one letter; this
453 passes all matching options.
455 The character | at the beginning of the predicate text is used to indicate
456 that a command should be piped to the following command, but only if -pipe
457 is specified.
459 Note that it is built into GCC which switches take arguments and which
460 do not. You might think it would be useful to generalize this to
461 allow each compiler's spec to say which switches take arguments. But
462 this cannot be done in a consistent fashion. GCC cannot even decide
463 which input files have been specified without knowing which switches
464 take arguments, and it must know which input files to compile in order
465 to tell which compilers to run.
467 GCC also knows implicitly that arguments starting in `-l' are to be
468 treated as compiler output files, and passed to the linker in their
469 proper position among the other output files. */
471 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
473 /* config.h can define ASM_SPEC to provide extra args to the assembler
474 or extra switch-translations. */
475 #ifndef ASM_SPEC
476 #define ASM_SPEC ""
477 #endif
479 /* config.h can define ASM_FINAL_SPEC to run a post processor after
480 the assembler has run. */
481 #ifndef ASM_FINAL_SPEC
482 #define ASM_FINAL_SPEC \
483 "%{gsplit-dwarf: \n\
484 objcopy --extract-dwo \
485 %{c:%{o*:%*}%{!o*:%b%O}}%{!c:%U%O} \
486 %{c:%{o*:%:replace-extension(%{o*:%*} .dwo)}%{!o*:%b.dwo}}%{!c:%b.dwo} \n\
487 objcopy --strip-dwo \
488 %{c:%{o*:%*}%{!o*:%b%O}}%{!c:%U%O} \
490 #endif
492 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
493 or extra switch-translations. */
494 #ifndef CPP_SPEC
495 #define CPP_SPEC ""
496 #endif
498 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
499 or extra switch-translations. */
500 #ifndef CC1_SPEC
501 #define CC1_SPEC ""
502 #endif
504 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
505 or extra switch-translations. */
506 #ifndef CC1PLUS_SPEC
507 #define CC1PLUS_SPEC ""
508 #endif
510 /* config.h can define LINK_SPEC to provide extra args to the linker
511 or extra switch-translations. */
512 #ifndef LINK_SPEC
513 #define LINK_SPEC ""
514 #endif
516 /* config.h can define LIB_SPEC to override the default libraries. */
517 #ifndef LIB_SPEC
518 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
519 #endif
521 /* mudflap specs */
522 #ifndef MFWRAP_SPEC
523 /* XXX: valid only for GNU ld */
524 /* XXX: should exactly match hooks provided by libmudflap.a */
525 #define MFWRAP_SPEC " %{static: %{fmudflap|fmudflapth: \
526 --wrap=malloc --wrap=free --wrap=calloc --wrap=realloc\
527 --wrap=mmap --wrap=mmap64 --wrap=munmap --wrap=alloca\
528 } %{fmudflapth: --wrap=pthread_create\
529 }} %{fmudflap|fmudflapth: --wrap=main}"
530 #endif
531 #ifndef MFLIB_SPEC
532 #define MFLIB_SPEC "%{fmudflap|fmudflapth: -export-dynamic}"
533 #endif
535 /* When using -fsplit-stack we need to wrap pthread_create, in order
536 to initialize the stack guard. We always use wrapping, rather than
537 shared library ordering, and we keep the wrapper function in
538 libgcc. This is not yet a real spec, though it could become one;
539 it is currently just stuffed into LINK_SPEC. FIXME: This wrapping
540 only works with GNU ld and gold. FIXME: This is incompatible with
541 -fmudflap when linking statically, which wants to do its own
542 wrapping. */
543 #define STACK_SPLIT_SPEC " %{fsplit-stack: --wrap=pthread_create}"
545 #ifndef LIBASAN_SPEC
546 #ifdef STATIC_LIBASAN_LIBS
547 #define ADD_STATIC_LIBASAN_LIBS \
548 " %{static-libasan:" STATIC_LIBASAN_LIBS "}"
549 #else
550 #define ADD_STATIC_LIBASAN_LIBS
551 #endif
552 #ifdef LIBASAN_EARLY_SPEC
553 #define LIBASAN_SPEC ADD_STATIC_LIBASAN_LIBS
554 #elif defined(HAVE_LD_STATIC_DYNAMIC)
555 #define LIBASAN_SPEC "%{static-libasan:" LD_STATIC_OPTION \
556 "} -lasan %{static-libasan:" LD_DYNAMIC_OPTION "}" \
557 ADD_STATIC_LIBASAN_LIBS
558 #else
559 #define LIBASAN_SPEC "-lasan" ADD_STATIC_LIBASAN_LIBS
560 #endif
561 #endif
563 #ifndef LIBASAN_EARLY_SPEC
564 #define LIBASAN_EARLY_SPEC ""
565 #endif
567 #ifndef LIBTSAN_SPEC
568 #ifdef STATIC_LIBTSAN_LIBS
569 #define ADD_STATIC_LIBTSAN_LIBS \
570 " %{static-libtsan:" STATIC_LIBTSAN_LIBS "}"
571 #else
572 #define ADD_STATIC_LIBTSAN_LIBS
573 #endif
574 #ifdef LIBTSAN_EARLY_SPEC
575 #define LIBTSAN_SPEC ADD_STATIC_LIBTSAN_LIBS
576 #elif defined(HAVE_LD_STATIC_DYNAMIC)
577 #define LIBTSAN_SPEC "%{static-libtsan:" LD_STATIC_OPTION \
578 "} -ltsan %{static-libtsan:" LD_DYNAMIC_OPTION "}" \
579 ADD_STATIC_LIBTSAN_LIBS
580 #else
581 #define LIBTSAN_SPEC "-ltsan" ADD_STATIC_LIBTSAN_LIBS
582 #endif
583 #endif
585 #ifndef LIBTSAN_EARLY_SPEC
586 #define LIBTSAN_EARLY_SPEC ""
587 #endif
589 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
590 included. */
591 #ifndef LIBGCC_SPEC
592 #if defined(REAL_LIBGCC_SPEC)
593 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
594 #elif defined(LINK_LIBGCC_SPECIAL_1)
595 /* Have gcc do the search for libgcc.a. */
596 #define LIBGCC_SPEC "libgcc.a%s"
597 #else
598 #define LIBGCC_SPEC "-lgcc"
599 #endif
600 #endif
602 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
603 #ifndef STARTFILE_SPEC
604 #define STARTFILE_SPEC \
605 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
606 #endif
608 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
609 #ifndef ENDFILE_SPEC
610 #define ENDFILE_SPEC ""
611 #endif
613 #ifndef LINKER_NAME
614 #define LINKER_NAME "collect2"
615 #endif
617 #ifdef HAVE_AS_DEBUG_PREFIX_MAP
618 #define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
619 #else
620 #define ASM_MAP ""
621 #endif
623 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
624 to the assembler. */
625 #ifndef ASM_DEBUG_SPEC
626 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
627 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
628 # define ASM_DEBUG_SPEC \
629 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
630 ? "%{!g0:%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}}" ASM_MAP \
631 : "%{!g0:%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}}" ASM_MAP)
632 # else
633 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
634 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gstabs}}" ASM_MAP
635 # endif
636 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
637 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gdwarf2}}" ASM_MAP
638 # endif
639 # endif
640 #endif
641 #ifndef ASM_DEBUG_SPEC
642 # define ASM_DEBUG_SPEC ""
643 #endif
645 /* Here is the spec for running the linker, after compiling all files. */
647 /* This is overridable by the target in case they need to specify the
648 -lgcc and -lc order specially, yet not require them to override all
649 of LINK_COMMAND_SPEC. */
650 #ifndef LINK_GCC_C_SEQUENCE_SPEC
651 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
652 #endif
654 #ifndef LINK_SSP_SPEC
655 #ifdef TARGET_LIBC_PROVIDES_SSP
656 #define LINK_SSP_SPEC "%{fstack-protector:}"
657 #else
658 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all:-lssp_nonshared -lssp}"
659 #endif
660 #endif
662 #ifndef LINK_PIE_SPEC
663 #ifdef HAVE_LD_PIE
664 #define LINK_PIE_SPEC "%{pie:-pie} "
665 #else
666 #define LINK_PIE_SPEC "%{pie:} "
667 #endif
668 #endif
670 #ifndef LINK_BUILDID_SPEC
671 # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
672 # define LINK_BUILDID_SPEC "%{!r:--build-id} "
673 # endif
674 #endif
676 /* Conditional to test whether the LTO plugin is used or not.
677 FIXME: For slim LTO we will need to enable plugin unconditionally. This
678 still cause problems with PLUGIN_LD != LD and when plugin is built but
679 not useable. For GCC 4.6 we don't support slim LTO and thus we can enable
680 plugin only when LTO is enabled. We still honor explicit
681 -fuse-linker-plugin if the linker used understands -plugin. */
683 /* The linker has some plugin support. */
684 #if HAVE_LTO_PLUGIN > 0
685 /* The linker used has full plugin support, use LTO plugin by default. */
686 #if HAVE_LTO_PLUGIN == 2
687 #define PLUGIN_COND "!fno-use-linker-plugin:%{flto|flto=*|fuse-linker-plugin"
688 #define PLUGIN_COND_CLOSE "}"
689 #else
690 /* The linker used has limited plugin support, use LTO plugin with explicit
691 -fuse-linker-plugin. */
692 #define PLUGIN_COND "fuse-linker-plugin"
693 #define PLUGIN_COND_CLOSE ""
694 #endif
695 #define LINK_PLUGIN_SPEC \
696 "%{"PLUGIN_COND": \
697 -plugin %(linker_plugin_file) \
698 -plugin-opt=%(lto_wrapper) \
699 -plugin-opt=-fresolution=%u.res \
700 %{!nostdlib:%{!nodefaultlibs:%:pass-through-libs(%(link_gcc_c_sequence))}} \
701 }"PLUGIN_COND_CLOSE
702 #else
703 /* The linker used doesn't support -plugin, reject -fuse-linker-plugin. */
704 #define LINK_PLUGIN_SPEC "%{fuse-linker-plugin:\
705 %e-fuse-linker-plugin is not supported in this configuration}"
706 #endif
708 /* Linker command line options for -fsanitize= early on the command line. */
709 #ifndef SANITIZER_EARLY_SPEC
710 #define SANITIZER_EARLY_SPEC "\
711 %{!nostdlib:%{!nodefaultlibs:%{fsanitize=address:" LIBASAN_EARLY_SPEC "} \
712 %{fsanitize=thread:" LIBTSAN_EARLY_SPEC "}}}"
713 #endif
715 /* Linker command line options for -fsanitize= late on the command line. */
716 #ifndef SANITIZER_SPEC
717 #define SANITIZER_SPEC "\
718 %{!nostdlib:%{!nodefaultlibs:%{fsanitize=address:" LIBASAN_SPEC "\
719 %{static:%ecannot specify -static with -fsanitize=address}}\
720 %{fsanitize=thread:" LIBTSAN_SPEC "\
721 %{!pie:%{!shared:%e-fsanitize=thread linking must be done with -pie or -shared}}}}}"
722 #endif
724 /* -u* was put back because both BSD and SysV seem to support it. */
725 /* %{static:} simply prevents an error message if the target machine
726 doesn't handle -static. */
727 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
728 scripts which exist in user specified directories, or in standard
729 directories. */
730 /* We pass any -flto flags on to the linker, which is expected
731 to understand them. In practice, this means it had better be collect2. */
732 /* %{e*} includes -export-dynamic; see comment in common.opt. */
733 #ifndef LINK_COMMAND_SPEC
734 #define LINK_COMMAND_SPEC "\
735 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
736 %(linker) " \
737 LINK_PLUGIN_SPEC \
738 "%{flto|flto=*:%<fcompare-debug*} \
739 %{flto} %{flto=*} %l " LINK_PIE_SPEC \
740 "%{fuse-ld=*:-fuse-ld=%*}\
741 %X %{o*} %{e*} %{N} %{n} %{r}\
742 %{s} %{t} %{u*} %{z} %{Z} %{!nostdlib:%{!nostartfiles:%S}}\
743 %{static:} %{L*} %(mfwrap) %(link_libgcc) " SANITIZER_EARLY_SPEC " %o\
744 %{fopenmp|ftree-parallelize-loops=*:%:include(libgomp.spec)%(link_gomp)}\
745 %{fgnu-tm:%:include(libitm.spec)%(link_itm)}\
746 %(mflib) " STACK_SPLIT_SPEC "\
747 %{fprofile-arcs|fprofile-generate*|coverage:-lgcov} " SANITIZER_SPEC " \
748 %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\
749 %{!nostdlib:%{!nostartfiles:%E}} %{T*} }}}}}}"
750 #endif
752 #ifndef LINK_LIBGCC_SPEC
753 /* Generate -L options for startfile prefix list. */
754 # define LINK_LIBGCC_SPEC "%D"
755 #endif
757 #ifndef STARTFILE_PREFIX_SPEC
758 # define STARTFILE_PREFIX_SPEC ""
759 #endif
761 #ifndef SYSROOT_SPEC
762 # define SYSROOT_SPEC "--sysroot=%R"
763 #endif
765 #ifndef SYSROOT_SUFFIX_SPEC
766 # define SYSROOT_SUFFIX_SPEC ""
767 #endif
769 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
770 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
771 #endif
773 static const char *asm_debug = ASM_DEBUG_SPEC;
774 static const char *cpp_spec = CPP_SPEC;
775 static const char *cc1_spec = CC1_SPEC;
776 static const char *cc1plus_spec = CC1PLUS_SPEC;
777 static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC;
778 static const char *link_ssp_spec = LINK_SSP_SPEC;
779 static const char *asm_spec = ASM_SPEC;
780 static const char *asm_final_spec = ASM_FINAL_SPEC;
781 static const char *link_spec = LINK_SPEC;
782 static const char *lib_spec = LIB_SPEC;
783 static const char *mfwrap_spec = MFWRAP_SPEC;
784 static const char *mflib_spec = MFLIB_SPEC;
785 static const char *link_gomp_spec = "";
786 static const char *libgcc_spec = LIBGCC_SPEC;
787 static const char *endfile_spec = ENDFILE_SPEC;
788 static const char *startfile_spec = STARTFILE_SPEC;
789 static const char *linker_name_spec = LINKER_NAME;
790 static const char *linker_plugin_file_spec = "";
791 static const char *lto_wrapper_spec = "";
792 static const char *lto_gcc_spec = "";
793 static const char *link_command_spec = LINK_COMMAND_SPEC;
794 static const char *link_libgcc_spec = LINK_LIBGCC_SPEC;
795 static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC;
796 static const char *sysroot_spec = SYSROOT_SPEC;
797 static const char *sysroot_suffix_spec = SYSROOT_SUFFIX_SPEC;
798 static const char *sysroot_hdrs_suffix_spec = SYSROOT_HEADERS_SUFFIX_SPEC;
799 static const char *self_spec = "";
801 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
802 There should be no need to override these in target dependent files,
803 but we need to copy them to the specs file so that newer versions
804 of the GCC driver can correctly drive older tool chains with the
805 appropriate -B options. */
807 /* When cpplib handles traditional preprocessing, get rid of this, and
808 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
809 that we default the front end language better. */
810 static const char *trad_capable_cpp =
811 "cc1 -E %{traditional|traditional-cpp:-traditional-cpp}";
813 /* We don't wrap .d files in %W{} since a missing .d file, and
814 therefore no dependency entry, confuses make into thinking a .o
815 file that happens to exist is up-to-date. */
816 static const char *cpp_unique_options =
817 "%{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\
818 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
819 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
820 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
821 %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
822 %{remap} %{g3|ggdb3|gstabs3|gcoff3|gxcoff3|gvms3:-dD}\
823 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
824 %{H} %C %{D*&U*&A*} %{i*} %Z %i\
825 %{fmudflap:-D_MUDFLAP -include mf-runtime.h}\
826 %{fmudflapth:-D_MUDFLAP -D_MUDFLAPTH -include mf-runtime.h}\
827 %{E|M|MM:%W{o*}}";
829 /* This contains cpp options which are common with cc1_options and are passed
830 only when preprocessing only to avoid duplication. We pass the cc1 spec
831 options to the preprocessor so that it the cc1 spec may manipulate
832 options used to set target flags. Those special target flags settings may
833 in turn cause preprocessor symbols to be defined specially. */
834 static const char *cpp_options =
835 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
836 %{f*} %{g*:%{!g0:%{g*} %{!fno-working-directory:-fworking-directory}}} %{O*}\
837 %{undef} %{save-temps*:-fpch-preprocess}";
839 /* This contains cpp options which are not passed when the preprocessor
840 output will be used by another program. */
841 static const char *cpp_debug_options = "%{d*}";
843 /* NB: This is shared amongst all front-ends, except for Ada. */
844 static const char *cc1_options =
845 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
846 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
847 %1 %{!Q:-quiet} %{!dumpbase:-dumpbase %B} %{d*} %{m*} %{aux-info*}\
848 %{fcompare-debug-second:%:compare-debug-auxbase-opt(%b)} \
849 %{!fcompare-debug-second:%{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}}%{!c:%{!S:-auxbase %b}} \
850 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
851 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
852 %{Qn:-fno-ident} %{Qy:} %{-help:--help}\
853 %{-target-help:--target-help}\
854 %{-version:--version}\
855 %{-help=*:--help=%*}\
856 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
857 %{fsyntax-only:-o %j} %{-param*}\
858 %{fmudflap|fmudflapth:-fno-builtin -fno-merge-constants}\
859 %{coverage:-fprofile-arcs -ftest-coverage}";
861 static const char *asm_options =
862 "%{-target-help:%:print-asm-header()} "
863 #if HAVE_GNU_AS
864 /* If GNU AS is used, then convert -w (no warnings), -I, and -v
865 to the assembler equivalents. */
866 "%{v} %{w:-W} %{I*} "
867 #endif
868 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
870 static const char *invoke_as =
871 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
872 "%{!fwpa:\
873 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
874 %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
876 #else
877 "%{!fwpa:\
878 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
879 %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
881 #endif
883 /* Some compilers have limits on line lengths, and the multilib_select
884 and/or multilib_matches strings can be very long, so we build them at
885 run time. */
886 static struct obstack multilib_obstack;
887 static const char *multilib_select;
888 static const char *multilib_matches;
889 static const char *multilib_defaults;
890 static const char *multilib_exclusions;
891 static const char *multilib_reuse;
893 /* Check whether a particular argument is a default argument. */
895 #ifndef MULTILIB_DEFAULTS
896 #define MULTILIB_DEFAULTS { "" }
897 #endif
899 static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
901 #ifndef DRIVER_SELF_SPECS
902 #define DRIVER_SELF_SPECS ""
903 #endif
905 /* Adding -fopenmp should imply pthreads. This is particularly important
906 for targets that use different start files and suchlike. */
907 #ifndef GOMP_SELF_SPECS
908 #define GOMP_SELF_SPECS "%{fopenmp|ftree-parallelize-loops=*: -pthread}"
909 #endif
911 /* Likewise for -fgnu-tm. */
912 #ifndef GTM_SELF_SPECS
913 #define GTM_SELF_SPECS "%{fgnu-tm: -pthread}"
914 #endif
916 static const char *const driver_self_specs[] = {
917 "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
918 DRIVER_SELF_SPECS, CONFIGURE_SPECS, GOMP_SELF_SPECS, GTM_SELF_SPECS
921 #ifndef OPTION_DEFAULT_SPECS
922 #define OPTION_DEFAULT_SPECS { "", "" }
923 #endif
925 struct default_spec
927 const char *name;
928 const char *spec;
931 static const struct default_spec
932 option_default_specs[] = { OPTION_DEFAULT_SPECS };
934 struct user_specs
936 struct user_specs *next;
937 const char *filename;
940 static struct user_specs *user_specs_head, *user_specs_tail;
943 /* Record the mapping from file suffixes for compilation specs. */
945 struct compiler
947 const char *suffix; /* Use this compiler for input files
948 whose names end in this suffix. */
950 const char *spec; /* To use this compiler, run this spec. */
952 const char *cpp_spec; /* If non-NULL, substitute this spec
953 for `%C', rather than the usual
954 cpp_spec. */
955 const int combinable; /* If nonzero, compiler can deal with
956 multiple source files at once (IMA). */
957 const int needs_preprocessing; /* If nonzero, source files need to
958 be run through a preprocessor. */
961 /* Pointer to a vector of `struct compiler' that gives the spec for
962 compiling a file, based on its suffix.
963 A file that does not end in any of these suffixes will be passed
964 unchanged to the loader and nothing else will be done to it.
966 An entry containing two 0s is used to terminate the vector.
968 If multiple entries match a file, the last matching one is used. */
970 static struct compiler *compilers;
972 /* Number of entries in `compilers', not counting the null terminator. */
974 static int n_compilers;
976 /* The default list of file name suffixes and their compilation specs. */
978 static const struct compiler default_compilers[] =
980 /* Add lists of suffixes of known languages here. If those languages
981 were not present when we built the driver, we will hit these copies
982 and be given a more meaningful error than "file not used since
983 linking is not done". */
984 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0},
985 {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
986 {".mii", "#Objective-C++", 0, 0, 0},
987 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
988 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
989 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
990 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
991 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
992 {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
993 {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
994 {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
995 {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
996 {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
997 {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
998 {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
999 {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
1000 {".r", "#Ratfor", 0, 0, 0},
1001 {".p", "#Pascal", 0, 0, 0}, {".pas", "#Pascal", 0, 0, 0},
1002 {".java", "#Java", 0, 0, 0}, {".class", "#Java", 0, 0, 0},
1003 {".zip", "#Java", 0, 0, 0}, {".jar", "#Java", 0, 0, 0},
1004 {".go", "#Go", 0, 1, 0},
1005 /* Next come the entries for C. */
1006 {".c", "@c", 0, 0, 1},
1007 {"@c",
1008 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1009 external preprocessor if -save-temps is given. */
1010 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1011 %{!E:%{!M:%{!MM:\
1012 %{traditional:\
1013 %eGNU C no longer supports -traditional without -E}\
1014 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1015 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1016 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1017 %(cc1_options)}\
1018 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1019 cc1 %(cpp_unique_options) %(cc1_options)}}}\
1020 %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 1},
1021 {"-",
1022 "%{!E:%e-E or -x required when input is from standard input}\
1023 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
1024 {".h", "@c-header", 0, 0, 0},
1025 {"@c-header",
1026 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1027 external preprocessor if -save-temps is given. */
1028 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1029 %{!E:%{!M:%{!MM:\
1030 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1031 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1032 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1033 %(cc1_options)\
1034 %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
1035 %W{o*:--output-pch=%*}}%V}\
1036 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1037 cc1 %(cpp_unique_options) %(cc1_options)\
1038 %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
1039 %W{o*:--output-pch=%*}}%V}}}}}}", 0, 0, 0},
1040 {".i", "@cpp-output", 0, 0, 0},
1041 {"@cpp-output",
1042 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 0},
1043 {".s", "@assembler", 0, 0, 0},
1044 {"@assembler",
1045 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 0, 0},
1046 {".sx", "@assembler-with-cpp", 0, 0, 0},
1047 {".S", "@assembler-with-cpp", 0, 0, 0},
1048 {"@assembler-with-cpp",
1049 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1050 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1051 %{E|M|MM:%(cpp_debug_options)}\
1052 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1053 as %(asm_debug) %(asm_options) %|.s %A }}}}"
1054 #else
1055 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1056 %{E|M|MM:%(cpp_debug_options)}\
1057 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1058 as %(asm_debug) %(asm_options) %m.s %A }}}}"
1059 #endif
1060 , 0, 0, 0},
1062 #include "specs.h"
1063 /* Mark end of table. */
1064 {0, 0, 0, 0, 0}
1067 /* Number of elements in default_compilers, not counting the terminator. */
1069 static const int n_default_compilers = ARRAY_SIZE (default_compilers) - 1;
1071 typedef char *char_p; /* For DEF_VEC_P. */
1073 /* A vector of options to give to the linker.
1074 These options are accumulated by %x,
1075 and substituted into the linker command with %X. */
1076 static vec<char_p> linker_options;
1078 /* A vector of options to give to the assembler.
1079 These options are accumulated by -Wa,
1080 and substituted into the assembler command with %Y. */
1081 static vec<char_p> assembler_options;
1083 /* A vector of options to give to the preprocessor.
1084 These options are accumulated by -Wp,
1085 and substituted into the preprocessor command with %Z. */
1086 static vec<char_p> preprocessor_options;
1088 static char *
1089 skip_whitespace (char *p)
1091 while (1)
1093 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1094 be considered whitespace. */
1095 if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
1096 return p + 1;
1097 else if (*p == '\n' || *p == ' ' || *p == '\t')
1098 p++;
1099 else if (*p == '#')
1101 while (*p != '\n')
1102 p++;
1103 p++;
1105 else
1106 break;
1109 return p;
1111 /* Structures to keep track of prefixes to try when looking for files. */
1113 struct prefix_list
1115 const char *prefix; /* String to prepend to the path. */
1116 struct prefix_list *next; /* Next in linked list. */
1117 int require_machine_suffix; /* Don't use without machine_suffix. */
1118 /* 2 means try both machine_suffix and just_machine_suffix. */
1119 int priority; /* Sort key - priority within list. */
1120 int os_multilib; /* 1 if OS multilib scheme should be used,
1121 0 for GCC multilib scheme. */
1124 struct path_prefix
1126 struct prefix_list *plist; /* List of prefixes to try */
1127 int max_len; /* Max length of a prefix in PLIST */
1128 const char *name; /* Name of this list (used in config stuff) */
1131 /* List of prefixes to try when looking for executables. */
1133 static struct path_prefix exec_prefixes = { 0, 0, "exec" };
1135 /* List of prefixes to try when looking for startup (crt0) files. */
1137 static struct path_prefix startfile_prefixes = { 0, 0, "startfile" };
1139 /* List of prefixes to try when looking for include files. */
1141 static struct path_prefix include_prefixes = { 0, 0, "include" };
1143 /* Suffix to attach to directories searched for commands.
1144 This looks like `MACHINE/VERSION/'. */
1146 static const char *machine_suffix = 0;
1148 /* Suffix to attach to directories searched for commands.
1149 This is just `MACHINE/'. */
1151 static const char *just_machine_suffix = 0;
1153 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1155 static const char *gcc_exec_prefix;
1157 /* Adjusted value of standard_libexec_prefix. */
1159 static const char *gcc_libexec_prefix;
1161 /* Default prefixes to attach to command names. */
1163 #ifndef STANDARD_STARTFILE_PREFIX_1
1164 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1165 #endif
1166 #ifndef STANDARD_STARTFILE_PREFIX_2
1167 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1168 #endif
1170 #ifdef CROSS_DIRECTORY_STRUCTURE /* Don't use these prefixes for a cross compiler. */
1171 #undef MD_EXEC_PREFIX
1172 #undef MD_STARTFILE_PREFIX
1173 #undef MD_STARTFILE_PREFIX_1
1174 #endif
1176 /* If no prefixes defined, use the null string, which will disable them. */
1177 #ifndef MD_EXEC_PREFIX
1178 #define MD_EXEC_PREFIX ""
1179 #endif
1180 #ifndef MD_STARTFILE_PREFIX
1181 #define MD_STARTFILE_PREFIX ""
1182 #endif
1183 #ifndef MD_STARTFILE_PREFIX_1
1184 #define MD_STARTFILE_PREFIX_1 ""
1185 #endif
1187 /* These directories are locations set at configure-time based on the
1188 --prefix option provided to configure. Their initializers are
1189 defined in Makefile.in. These paths are not *directly* used when
1190 gcc_exec_prefix is set because, in that case, we know where the
1191 compiler has been installed, and use paths relative to that
1192 location instead. */
1193 static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
1194 static const char *const standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX;
1195 static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
1196 static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1198 /* For native compilers, these are well-known paths containing
1199 components that may be provided by the system. For cross
1200 compilers, these paths are not used. */
1201 static const char *md_exec_prefix = MD_EXEC_PREFIX;
1202 static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1203 static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1204 static const char *const standard_startfile_prefix_1
1205 = STANDARD_STARTFILE_PREFIX_1;
1206 static const char *const standard_startfile_prefix_2
1207 = STANDARD_STARTFILE_PREFIX_2;
1209 /* A relative path to be used in finding the location of tools
1210 relative to the driver. */
1211 static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1213 /* Subdirectory to use for locating libraries. Set by
1214 set_multilib_dir based on the compilation options. */
1216 static const char *multilib_dir;
1218 /* Subdirectory to use for locating libraries in OS conventions. Set by
1219 set_multilib_dir based on the compilation options. */
1221 static const char *multilib_os_dir;
1223 /* Subdirectory to use for locating libraries in multiarch conventions. Set by
1224 set_multilib_dir based on the compilation options. */
1226 static const char *multiarch_dir;
1228 /* Structure to keep track of the specs that have been defined so far.
1229 These are accessed using %(specname) in a compiler or link
1230 spec. */
1232 struct spec_list
1234 /* The following 2 fields must be first */
1235 /* to allow EXTRA_SPECS to be initialized */
1236 const char *name; /* name of the spec. */
1237 const char *ptr; /* available ptr if no static pointer */
1239 /* The following fields are not initialized */
1240 /* by EXTRA_SPECS */
1241 const char **ptr_spec; /* pointer to the spec itself. */
1242 struct spec_list *next; /* Next spec in linked list. */
1243 int name_len; /* length of the name */
1244 bool user_p; /* whether string come from file spec. */
1245 bool alloc_p; /* whether string was allocated */
1248 #define INIT_STATIC_SPEC(NAME,PTR) \
1249 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, false, false }
1251 /* List of statically defined specs. */
1252 static struct spec_list static_specs[] =
1254 INIT_STATIC_SPEC ("asm", &asm_spec),
1255 INIT_STATIC_SPEC ("asm_debug", &asm_debug),
1256 INIT_STATIC_SPEC ("asm_final", &asm_final_spec),
1257 INIT_STATIC_SPEC ("asm_options", &asm_options),
1258 INIT_STATIC_SPEC ("invoke_as", &invoke_as),
1259 INIT_STATIC_SPEC ("cpp", &cpp_spec),
1260 INIT_STATIC_SPEC ("cpp_options", &cpp_options),
1261 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options),
1262 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options),
1263 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp),
1264 INIT_STATIC_SPEC ("cc1", &cc1_spec),
1265 INIT_STATIC_SPEC ("cc1_options", &cc1_options),
1266 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec),
1267 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec),
1268 INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec),
1269 INIT_STATIC_SPEC ("endfile", &endfile_spec),
1270 INIT_STATIC_SPEC ("link", &link_spec),
1271 INIT_STATIC_SPEC ("lib", &lib_spec),
1272 INIT_STATIC_SPEC ("mfwrap", &mfwrap_spec),
1273 INIT_STATIC_SPEC ("mflib", &mflib_spec),
1274 INIT_STATIC_SPEC ("link_gomp", &link_gomp_spec),
1275 INIT_STATIC_SPEC ("libgcc", &libgcc_spec),
1276 INIT_STATIC_SPEC ("startfile", &startfile_spec),
1277 INIT_STATIC_SPEC ("cross_compile", &cross_compile),
1278 INIT_STATIC_SPEC ("version", &compiler_version),
1279 INIT_STATIC_SPEC ("multilib", &multilib_select),
1280 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults),
1281 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra),
1282 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches),
1283 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions),
1284 INIT_STATIC_SPEC ("multilib_options", &multilib_options),
1285 INIT_STATIC_SPEC ("multilib_reuse", &multilib_reuse),
1286 INIT_STATIC_SPEC ("linker", &linker_name_spec),
1287 INIT_STATIC_SPEC ("linker_plugin_file", &linker_plugin_file_spec),
1288 INIT_STATIC_SPEC ("lto_wrapper", &lto_wrapper_spec),
1289 INIT_STATIC_SPEC ("lto_gcc", &lto_gcc_spec),
1290 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec),
1291 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix),
1292 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix),
1293 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1),
1294 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec),
1295 INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec),
1296 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec),
1297 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec),
1298 INIT_STATIC_SPEC ("self_spec", &self_spec),
1301 #ifdef EXTRA_SPECS /* additional specs needed */
1302 /* Structure to keep track of just the first two args of a spec_list.
1303 That is all that the EXTRA_SPECS macro gives us. */
1304 struct spec_list_1
1306 const char *const name;
1307 const char *const ptr;
1310 static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1311 static struct spec_list *extra_specs = (struct spec_list *) 0;
1312 #endif
1314 /* List of dynamically allocates specs that have been defined so far. */
1316 static struct spec_list *specs = (struct spec_list *) 0;
1318 /* List of static spec functions. */
1320 static const struct spec_function static_spec_functions[] =
1322 { "getenv", getenv_spec_function },
1323 { "if-exists", if_exists_spec_function },
1324 { "if-exists-else", if_exists_else_spec_function },
1325 { "replace-outfile", replace_outfile_spec_function },
1326 { "remove-outfile", remove_outfile_spec_function },
1327 { "version-compare", version_compare_spec_function },
1328 { "include", include_spec_function },
1329 { "find-file", find_file_spec_function },
1330 { "find-plugindir", find_plugindir_spec_function },
1331 { "print-asm-header", print_asm_header_spec_function },
1332 { "compare-debug-dump-opt", compare_debug_dump_opt_spec_function },
1333 { "compare-debug-self-opt", compare_debug_self_opt_spec_function },
1334 { "compare-debug-auxbase-opt", compare_debug_auxbase_opt_spec_function },
1335 { "pass-through-libs", pass_through_libs_spec_func },
1336 { "replace-extension", replace_extension_spec_func },
1337 #ifdef EXTRA_SPEC_FUNCTIONS
1338 EXTRA_SPEC_FUNCTIONS
1339 #endif
1340 { 0, 0 }
1343 static int processing_spec_function;
1345 /* Add appropriate libgcc specs to OBSTACK, taking into account
1346 various permutations of -shared-libgcc, -shared, and such. */
1348 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1350 #ifndef USE_LD_AS_NEEDED
1351 #define USE_LD_AS_NEEDED 0
1352 #endif
1354 static void
1355 init_gcc_specs (struct obstack *obstack, const char *shared_name,
1356 const char *static_name, const char *eh_name)
1358 char *buf;
1360 buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name, "}"
1361 "%{!static:%{!static-libgcc:"
1362 #if USE_LD_AS_NEEDED
1363 "%{!shared-libgcc:",
1364 static_name, " --as-needed ", shared_name, " --no-as-needed"
1366 "%{shared-libgcc:",
1367 shared_name, "%{!shared: ", static_name, "}"
1369 #else
1370 "%{!shared:"
1371 "%{!shared-libgcc:", static_name, " ", eh_name, "}"
1372 "%{shared-libgcc:", shared_name, " ", static_name, "}"
1374 #ifdef LINK_EH_SPEC
1375 "%{shared:"
1376 "%{shared-libgcc:", shared_name, "}"
1377 "%{!shared-libgcc:", static_name, "}"
1379 #else
1380 "%{shared:", shared_name, "}"
1381 #endif
1382 #endif
1383 "}}", NULL);
1385 obstack_grow (obstack, buf, strlen (buf));
1386 free (buf);
1388 #endif /* ENABLE_SHARED_LIBGCC */
1390 /* Initialize the specs lookup routines. */
1392 static void
1393 init_spec (void)
1395 struct spec_list *next = (struct spec_list *) 0;
1396 struct spec_list *sl = (struct spec_list *) 0;
1397 int i;
1399 if (specs)
1400 return; /* Already initialized. */
1402 if (verbose_flag)
1403 fnotice (stderr, "Using built-in specs.\n");
1405 #ifdef EXTRA_SPECS
1406 extra_specs = XCNEWVEC (struct spec_list, ARRAY_SIZE (extra_specs_1));
1408 for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--)
1410 sl = &extra_specs[i];
1411 sl->name = extra_specs_1[i].name;
1412 sl->ptr = extra_specs_1[i].ptr;
1413 sl->next = next;
1414 sl->name_len = strlen (sl->name);
1415 sl->ptr_spec = &sl->ptr;
1416 next = sl;
1418 #endif
1420 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1422 sl = &static_specs[i];
1423 sl->next = next;
1424 next = sl;
1427 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1428 /* ??? If neither -shared-libgcc nor --static-libgcc was
1429 seen, then we should be making an educated guess. Some proposed
1430 heuristics for ELF include:
1432 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1433 program will be doing dynamic loading, which will likely
1434 need the shared libgcc.
1436 (2) If "-ldl", then it's also a fair bet that we're doing
1437 dynamic loading.
1439 (3) For each ET_DYN we're linking against (either through -lfoo
1440 or /some/path/foo.so), check to see whether it or one of
1441 its dependencies depends on a shared libgcc.
1443 (4) If "-shared"
1445 If the runtime is fixed to look for program headers instead
1446 of calling __register_frame_info at all, for each object,
1447 use the shared libgcc if any EH symbol referenced.
1449 If crtstuff is fixed to not invoke __register_frame_info
1450 automatically, for each object, use the shared libgcc if
1451 any non-empty unwind section found.
1453 Doing any of this probably requires invoking an external program to
1454 do the actual object file scanning. */
1456 const char *p = libgcc_spec;
1457 int in_sep = 1;
1459 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1460 when given the proper command line arguments. */
1461 while (*p)
1463 if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
1465 init_gcc_specs (&obstack,
1466 "-lgcc_s"
1467 #ifdef USE_LIBUNWIND_EXCEPTIONS
1468 " -lunwind"
1469 #endif
1471 "-lgcc",
1472 "-lgcc_eh"
1473 #ifdef USE_LIBUNWIND_EXCEPTIONS
1474 # ifdef HAVE_LD_STATIC_DYNAMIC
1475 " %{!static:" LD_STATIC_OPTION "} -lunwind"
1476 " %{!static:" LD_DYNAMIC_OPTION "}"
1477 # else
1478 " -lunwind"
1479 # endif
1480 #endif
1483 p += 5;
1484 in_sep = 0;
1486 else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0)
1488 /* Ug. We don't know shared library extensions. Hope that
1489 systems that use this form don't do shared libraries. */
1490 init_gcc_specs (&obstack,
1491 "-lgcc_s",
1492 "libgcc.a%s",
1493 "libgcc_eh.a%s"
1494 #ifdef USE_LIBUNWIND_EXCEPTIONS
1495 " -lunwind"
1496 #endif
1498 p += 10;
1499 in_sep = 0;
1501 else
1503 obstack_1grow (&obstack, *p);
1504 in_sep = (*p == ' ');
1505 p += 1;
1509 obstack_1grow (&obstack, '\0');
1510 libgcc_spec = XOBFINISH (&obstack, const char *);
1512 #endif
1513 #ifdef USE_AS_TRADITIONAL_FORMAT
1514 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1516 static const char tf[] = "--traditional-format ";
1517 obstack_grow (&obstack, tf, sizeof(tf) - 1);
1518 obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
1519 asm_spec = XOBFINISH (&obstack, const char *);
1521 #endif
1523 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC || \
1524 defined LINKER_HASH_STYLE
1525 # ifdef LINK_BUILDID_SPEC
1526 /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. */
1527 obstack_grow (&obstack, LINK_BUILDID_SPEC, sizeof(LINK_BUILDID_SPEC) - 1);
1528 # endif
1529 # ifdef LINK_EH_SPEC
1530 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1531 obstack_grow (&obstack, LINK_EH_SPEC, sizeof(LINK_EH_SPEC) - 1);
1532 # endif
1533 # ifdef LINKER_HASH_STYLE
1534 /* Prepend --hash-style=LINKER_HASH_STYLE to whatever link_spec we had
1535 before. */
1537 static const char hash_style[] = "--hash-style=";
1538 obstack_grow (&obstack, hash_style, sizeof(hash_style) - 1);
1539 obstack_grow (&obstack, LINKER_HASH_STYLE, sizeof(LINKER_HASH_STYLE) - 1);
1540 obstack_1grow (&obstack, ' ');
1542 # endif
1543 obstack_grow0 (&obstack, link_spec, strlen (link_spec));
1544 link_spec = XOBFINISH (&obstack, const char *);
1545 #endif
1547 specs = sl;
1550 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1551 removed; If the spec starts with a + then SPEC is added to the end of the
1552 current spec. */
1554 static void
1555 set_spec (const char *name, const char *spec, bool user_p)
1557 struct spec_list *sl;
1558 const char *old_spec;
1559 int name_len = strlen (name);
1560 int i;
1562 /* If this is the first call, initialize the statically allocated specs. */
1563 if (!specs)
1565 struct spec_list *next = (struct spec_list *) 0;
1566 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1568 sl = &static_specs[i];
1569 sl->next = next;
1570 next = sl;
1572 specs = sl;
1575 /* See if the spec already exists. */
1576 for (sl = specs; sl; sl = sl->next)
1577 if (name_len == sl->name_len && !strcmp (sl->name, name))
1578 break;
1580 if (!sl)
1582 /* Not found - make it. */
1583 sl = XNEW (struct spec_list);
1584 sl->name = xstrdup (name);
1585 sl->name_len = name_len;
1586 sl->ptr_spec = &sl->ptr;
1587 sl->alloc_p = 0;
1588 *(sl->ptr_spec) = "";
1589 sl->next = specs;
1590 specs = sl;
1593 old_spec = *(sl->ptr_spec);
1594 *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
1595 ? concat (old_spec, spec + 1, NULL)
1596 : xstrdup (spec));
1598 #ifdef DEBUG_SPECS
1599 if (verbose_flag)
1600 fnotice (stderr, "Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
1601 #endif
1603 /* Free the old spec. */
1604 if (old_spec && sl->alloc_p)
1605 free (CONST_CAST(char *, old_spec));
1607 sl->user_p = user_p;
1608 sl->alloc_p = true;
1611 /* Accumulate a command (program name and args), and run it. */
1613 typedef const char *const_char_p; /* For DEF_VEC_P. */
1615 /* Vector of pointers to arguments in the current line of specifications. */
1617 static vec<const_char_p> argbuf;
1619 /* Position in the argbuf vector containing the name of the output file
1620 (the value associated with the "-o" flag). */
1622 static int have_o_argbuf_index = 0;
1624 /* Were the options -c, -S or -E passed. */
1625 static int have_c = 0;
1627 /* Was the option -o passed. */
1628 static int have_o = 0;
1630 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1631 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
1632 it here. */
1634 static struct temp_name {
1635 const char *suffix; /* suffix associated with the code. */
1636 int length; /* strlen (suffix). */
1637 int unique; /* Indicates whether %g or %u/%U was used. */
1638 const char *filename; /* associated filename. */
1639 int filename_length; /* strlen (filename). */
1640 struct temp_name *next;
1641 } *temp_names;
1643 /* Number of commands executed so far. */
1645 static int execution_count;
1647 /* Number of commands that exited with a signal. */
1649 static int signal_count;
1651 /* Allocate the argument vector. */
1653 static void
1654 alloc_args (void)
1656 argbuf.create (10);
1659 /* Clear out the vector of arguments (after a command is executed). */
1661 static void
1662 clear_args (void)
1664 argbuf.truncate (0);
1667 /* Add one argument to the vector at the end.
1668 This is done when a space is seen or at the end of the line.
1669 If DELETE_ALWAYS is nonzero, the arg is a filename
1670 and the file should be deleted eventually.
1671 If DELETE_FAILURE is nonzero, the arg is a filename
1672 and the file should be deleted if this compilation fails. */
1674 static void
1675 store_arg (const char *arg, int delete_always, int delete_failure)
1677 argbuf.safe_push (arg);
1679 if (strcmp (arg, "-o") == 0)
1680 have_o_argbuf_index = argbuf.length ();
1681 if (delete_always || delete_failure)
1683 const char *p;
1684 /* If the temporary file we should delete is specified as
1685 part of a joined argument extract the filename. */
1686 if (arg[0] == '-'
1687 && (p = strrchr (arg, '=')))
1688 arg = p + 1;
1689 record_temp_file (arg, delete_always, delete_failure);
1693 /* Load specs from a file name named FILENAME, replacing occurrences of
1694 various different types of line-endings, \r\n, \n\r and just \r, with
1695 a single \n. */
1697 static char *
1698 load_specs (const char *filename)
1700 int desc;
1701 int readlen;
1702 struct stat statbuf;
1703 char *buffer;
1704 char *buffer_p;
1705 char *specs;
1706 char *specs_p;
1708 if (verbose_flag)
1709 fnotice (stderr, "Reading specs from %s\n", filename);
1711 /* Open and stat the file. */
1712 desc = open (filename, O_RDONLY, 0);
1713 if (desc < 0)
1714 pfatal_with_name (filename);
1715 if (stat (filename, &statbuf) < 0)
1716 pfatal_with_name (filename);
1718 /* Read contents of file into BUFFER. */
1719 buffer = XNEWVEC (char, statbuf.st_size + 1);
1720 readlen = read (desc, buffer, (unsigned) statbuf.st_size);
1721 if (readlen < 0)
1722 pfatal_with_name (filename);
1723 buffer[readlen] = 0;
1724 close (desc);
1726 specs = XNEWVEC (char, readlen + 1);
1727 specs_p = specs;
1728 for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
1730 int skip = 0;
1731 char c = *buffer_p;
1732 if (c == '\r')
1734 if (buffer_p > buffer && *(buffer_p - 1) == '\n') /* \n\r */
1735 skip = 1;
1736 else if (*(buffer_p + 1) == '\n') /* \r\n */
1737 skip = 1;
1738 else /* \r */
1739 c = '\n';
1741 if (! skip)
1742 *specs_p++ = c;
1744 *specs_p = '\0';
1746 free (buffer);
1747 return (specs);
1750 /* Read compilation specs from a file named FILENAME,
1751 replacing the default ones.
1753 A suffix which starts with `*' is a definition for
1754 one of the machine-specific sub-specs. The "suffix" should be
1755 *asm, *cc1, *cpp, *link, *startfile, etc.
1756 The corresponding spec is stored in asm_spec, etc.,
1757 rather than in the `compilers' vector.
1759 Anything invalid in the file is a fatal error. */
1761 static void
1762 read_specs (const char *filename, bool main_p, bool user_p)
1764 char *buffer;
1765 char *p;
1767 buffer = load_specs (filename);
1769 /* Scan BUFFER for specs, putting them in the vector. */
1770 p = buffer;
1771 while (1)
1773 char *suffix;
1774 char *spec;
1775 char *in, *out, *p1, *p2, *p3;
1777 /* Advance P in BUFFER to the next nonblank nocomment line. */
1778 p = skip_whitespace (p);
1779 if (*p == 0)
1780 break;
1782 /* Is this a special command that starts with '%'? */
1783 /* Don't allow this for the main specs file, since it would
1784 encourage people to overwrite it. */
1785 if (*p == '%' && !main_p)
1787 p1 = p;
1788 while (*p && *p != '\n')
1789 p++;
1791 /* Skip '\n'. */
1792 p++;
1794 if (!strncmp (p1, "%include", sizeof ("%include") - 1)
1795 && (p1[sizeof "%include" - 1] == ' '
1796 || p1[sizeof "%include" - 1] == '\t'))
1798 char *new_filename;
1800 p1 += sizeof ("%include");
1801 while (*p1 == ' ' || *p1 == '\t')
1802 p1++;
1804 if (*p1++ != '<' || p[-2] != '>')
1805 fatal_error ("specs %%include syntax malformed after "
1806 "%ld characters",
1807 (long) (p1 - buffer + 1));
1809 p[-2] = '\0';
1810 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
1811 read_specs (new_filename ? new_filename : p1, false, user_p);
1812 continue;
1814 else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
1815 && (p1[sizeof "%include_noerr" - 1] == ' '
1816 || p1[sizeof "%include_noerr" - 1] == '\t'))
1818 char *new_filename;
1820 p1 += sizeof "%include_noerr";
1821 while (*p1 == ' ' || *p1 == '\t')
1822 p1++;
1824 if (*p1++ != '<' || p[-2] != '>')
1825 fatal_error ("specs %%include syntax malformed after "
1826 "%ld characters",
1827 (long) (p1 - buffer + 1));
1829 p[-2] = '\0';
1830 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
1831 if (new_filename)
1832 read_specs (new_filename, false, user_p);
1833 else if (verbose_flag)
1834 fnotice (stderr, "could not find specs file %s\n", p1);
1835 continue;
1837 else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
1838 && (p1[sizeof "%rename" - 1] == ' '
1839 || p1[sizeof "%rename" - 1] == '\t'))
1841 int name_len;
1842 struct spec_list *sl;
1843 struct spec_list *newsl;
1845 /* Get original name. */
1846 p1 += sizeof "%rename";
1847 while (*p1 == ' ' || *p1 == '\t')
1848 p1++;
1850 if (! ISALPHA ((unsigned char) *p1))
1851 fatal_error ("specs %%rename syntax malformed after "
1852 "%ld characters",
1853 (long) (p1 - buffer));
1855 p2 = p1;
1856 while (*p2 && !ISSPACE ((unsigned char) *p2))
1857 p2++;
1859 if (*p2 != ' ' && *p2 != '\t')
1860 fatal_error ("specs %%rename syntax malformed after "
1861 "%ld characters",
1862 (long) (p2 - buffer));
1864 name_len = p2 - p1;
1865 *p2++ = '\0';
1866 while (*p2 == ' ' || *p2 == '\t')
1867 p2++;
1869 if (! ISALPHA ((unsigned char) *p2))
1870 fatal_error ("specs %%rename syntax malformed after "
1871 "%ld characters",
1872 (long) (p2 - buffer));
1874 /* Get new spec name. */
1875 p3 = p2;
1876 while (*p3 && !ISSPACE ((unsigned char) *p3))
1877 p3++;
1879 if (p3 != p - 1)
1880 fatal_error ("specs %%rename syntax malformed after "
1881 "%ld characters",
1882 (long) (p3 - buffer));
1883 *p3 = '\0';
1885 for (sl = specs; sl; sl = sl->next)
1886 if (name_len == sl->name_len && !strcmp (sl->name, p1))
1887 break;
1889 if (!sl)
1890 fatal_error ("specs %s spec was not found to be renamed", p1);
1892 if (strcmp (p1, p2) == 0)
1893 continue;
1895 for (newsl = specs; newsl; newsl = newsl->next)
1896 if (strcmp (newsl->name, p2) == 0)
1897 fatal_error ("%s: attempt to rename spec %qs to "
1898 "already defined spec %qs",
1899 filename, p1, p2);
1901 if (verbose_flag)
1903 fnotice (stderr, "rename spec %s to %s\n", p1, p2);
1904 #ifdef DEBUG_SPECS
1905 fnotice (stderr, "spec is '%s'\n\n", *(sl->ptr_spec));
1906 #endif
1909 set_spec (p2, *(sl->ptr_spec), user_p);
1910 if (sl->alloc_p)
1911 free (CONST_CAST (char *, *(sl->ptr_spec)));
1913 *(sl->ptr_spec) = "";
1914 sl->alloc_p = 0;
1915 continue;
1917 else
1918 fatal_error ("specs unknown %% command after %ld characters",
1919 (long) (p1 - buffer));
1922 /* Find the colon that should end the suffix. */
1923 p1 = p;
1924 while (*p1 && *p1 != ':' && *p1 != '\n')
1925 p1++;
1927 /* The colon shouldn't be missing. */
1928 if (*p1 != ':')
1929 fatal_error ("specs file malformed after %ld characters",
1930 (long) (p1 - buffer));
1932 /* Skip back over trailing whitespace. */
1933 p2 = p1;
1934 while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
1935 p2--;
1937 /* Copy the suffix to a string. */
1938 suffix = save_string (p, p2 - p);
1939 /* Find the next line. */
1940 p = skip_whitespace (p1 + 1);
1941 if (p[1] == 0)
1942 fatal_error ("specs file malformed after %ld characters",
1943 (long) (p - buffer));
1945 p1 = p;
1946 /* Find next blank line or end of string. */
1947 while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
1948 p1++;
1950 /* Specs end at the blank line and do not include the newline. */
1951 spec = save_string (p, p1 - p);
1952 p = p1;
1954 /* Delete backslash-newline sequences from the spec. */
1955 in = spec;
1956 out = spec;
1957 while (*in != 0)
1959 if (in[0] == '\\' && in[1] == '\n')
1960 in += 2;
1961 else if (in[0] == '#')
1962 while (*in && *in != '\n')
1963 in++;
1965 else
1966 *out++ = *in++;
1968 *out = 0;
1970 if (suffix[0] == '*')
1972 if (! strcmp (suffix, "*link_command"))
1973 link_command_spec = spec;
1974 else
1975 set_spec (suffix + 1, spec, user_p);
1977 else
1979 /* Add this pair to the vector. */
1980 compilers
1981 = XRESIZEVEC (struct compiler, compilers, n_compilers + 2);
1983 compilers[n_compilers].suffix = suffix;
1984 compilers[n_compilers].spec = spec;
1985 n_compilers++;
1986 memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
1989 if (*suffix == 0)
1990 link_command_spec = spec;
1993 if (link_command_spec == 0)
1994 fatal_error ("spec file has no spec for linking");
1997 /* Record the names of temporary files we tell compilers to write,
1998 and delete them at the end of the run. */
2000 /* This is the common prefix we use to make temp file names.
2001 It is chosen once for each run of this program.
2002 It is substituted into a spec by %g or %j.
2003 Thus, all temp file names contain this prefix.
2004 In practice, all temp file names start with this prefix.
2006 This prefix comes from the envvar TMPDIR if it is defined;
2007 otherwise, from the P_tmpdir macro if that is defined;
2008 otherwise, in /usr/tmp or /tmp;
2009 or finally the current directory if all else fails. */
2011 static const char *temp_filename;
2013 /* Length of the prefix. */
2015 static int temp_filename_length;
2017 /* Define the list of temporary files to delete. */
2019 struct temp_file
2021 const char *name;
2022 struct temp_file *next;
2025 /* Queue of files to delete on success or failure of compilation. */
2026 static struct temp_file *always_delete_queue;
2027 /* Queue of files to delete on failure of compilation. */
2028 static struct temp_file *failure_delete_queue;
2030 /* Record FILENAME as a file to be deleted automatically.
2031 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2032 otherwise delete it in any case.
2033 FAIL_DELETE nonzero means delete it if a compilation step fails;
2034 otherwise delete it in any case. */
2036 void
2037 record_temp_file (const char *filename, int always_delete, int fail_delete)
2039 char *const name = xstrdup (filename);
2041 if (always_delete)
2043 struct temp_file *temp;
2044 for (temp = always_delete_queue; temp; temp = temp->next)
2045 if (! filename_cmp (name, temp->name))
2046 goto already1;
2048 temp = XNEW (struct temp_file);
2049 temp->next = always_delete_queue;
2050 temp->name = name;
2051 always_delete_queue = temp;
2053 already1:;
2056 if (fail_delete)
2058 struct temp_file *temp;
2059 for (temp = failure_delete_queue; temp; temp = temp->next)
2060 if (! filename_cmp (name, temp->name))
2062 free (name);
2063 goto already2;
2066 temp = XNEW (struct temp_file);
2067 temp->next = failure_delete_queue;
2068 temp->name = name;
2069 failure_delete_queue = temp;
2071 already2:;
2075 /* Delete all the temporary files whose names we previously recorded. */
2077 #ifndef DELETE_IF_ORDINARY
2078 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2079 do \
2081 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2082 if (unlink (NAME) < 0) \
2083 if (VERBOSE_FLAG) \
2084 perror_with_name (NAME); \
2085 } while (0)
2086 #endif
2088 static void
2089 delete_if_ordinary (const char *name)
2091 struct stat st;
2092 #ifdef DEBUG
2093 int i, c;
2095 printf ("Delete %s? (y or n) ", name);
2096 fflush (stdout);
2097 i = getchar ();
2098 if (i != '\n')
2099 while ((c = getchar ()) != '\n' && c != EOF)
2102 if (i == 'y' || i == 'Y')
2103 #endif /* DEBUG */
2104 DELETE_IF_ORDINARY (name, st, verbose_flag);
2107 static void
2108 delete_temp_files (void)
2110 struct temp_file *temp;
2112 for (temp = always_delete_queue; temp; temp = temp->next)
2113 delete_if_ordinary (temp->name);
2114 always_delete_queue = 0;
2117 /* Delete all the files to be deleted on error. */
2119 static void
2120 delete_failure_queue (void)
2122 struct temp_file *temp;
2124 for (temp = failure_delete_queue; temp; temp = temp->next)
2125 delete_if_ordinary (temp->name);
2128 static void
2129 clear_failure_queue (void)
2131 failure_delete_queue = 0;
2134 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2135 returns non-NULL.
2136 If DO_MULTI is true iterate over the paths twice, first with multilib
2137 suffix then without, otherwise iterate over the paths once without
2138 adding a multilib suffix. When DO_MULTI is true, some attempt is made
2139 to avoid visiting the same path twice, but we could do better. For
2140 instance, /usr/lib/../lib is considered different from /usr/lib.
2141 At least EXTRA_SPACE chars past the end of the path passed to
2142 CALLBACK are available for use by the callback.
2143 CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2145 Returns the value returned by CALLBACK. */
2147 static void *
2148 for_each_path (const struct path_prefix *paths,
2149 bool do_multi,
2150 size_t extra_space,
2151 void *(*callback) (char *, void *),
2152 void *callback_info)
2154 struct prefix_list *pl;
2155 const char *multi_dir = NULL;
2156 const char *multi_os_dir = NULL;
2157 const char *multiarch_suffix = NULL;
2158 const char *multi_suffix;
2159 const char *just_multi_suffix;
2160 char *path = NULL;
2161 void *ret = NULL;
2162 bool skip_multi_dir = false;
2163 bool skip_multi_os_dir = false;
2165 multi_suffix = machine_suffix;
2166 just_multi_suffix = just_machine_suffix;
2167 if (do_multi && multilib_dir && strcmp (multilib_dir, ".") != 0)
2169 multi_dir = concat (multilib_dir, dir_separator_str, NULL);
2170 multi_suffix = concat (multi_suffix, multi_dir, NULL);
2171 just_multi_suffix = concat (just_multi_suffix, multi_dir, NULL);
2173 if (do_multi && multilib_os_dir && strcmp (multilib_os_dir, ".") != 0)
2174 multi_os_dir = concat (multilib_os_dir, dir_separator_str, NULL);
2175 if (multiarch_dir)
2176 multiarch_suffix = concat (multiarch_dir, dir_separator_str, NULL);
2178 while (1)
2180 size_t multi_dir_len = 0;
2181 size_t multi_os_dir_len = 0;
2182 size_t multiarch_len = 0;
2183 size_t suffix_len;
2184 size_t just_suffix_len;
2185 size_t len;
2187 if (multi_dir)
2188 multi_dir_len = strlen (multi_dir);
2189 if (multi_os_dir)
2190 multi_os_dir_len = strlen (multi_os_dir);
2191 if (multiarch_suffix)
2192 multiarch_len = strlen (multiarch_suffix);
2193 suffix_len = strlen (multi_suffix);
2194 just_suffix_len = strlen (just_multi_suffix);
2196 if (path == NULL)
2198 len = paths->max_len + extra_space + 1;
2199 len += MAX (MAX (suffix_len, multi_os_dir_len), multiarch_len);
2200 path = XNEWVEC (char, len);
2203 for (pl = paths->plist; pl != 0; pl = pl->next)
2205 len = strlen (pl->prefix);
2206 memcpy (path, pl->prefix, len);
2208 /* Look first in MACHINE/VERSION subdirectory. */
2209 if (!skip_multi_dir)
2211 memcpy (path + len, multi_suffix, suffix_len + 1);
2212 ret = callback (path, callback_info);
2213 if (ret)
2214 break;
2217 /* Some paths are tried with just the machine (ie. target)
2218 subdir. This is used for finding as, ld, etc. */
2219 if (!skip_multi_dir
2220 && pl->require_machine_suffix == 2)
2222 memcpy (path + len, just_multi_suffix, just_suffix_len + 1);
2223 ret = callback (path, callback_info);
2224 if (ret)
2225 break;
2228 /* Now try the multiarch path. */
2229 if (!skip_multi_dir
2230 && !pl->require_machine_suffix && multiarch_dir)
2232 memcpy (path + len, multiarch_suffix, multiarch_len + 1);
2233 ret = callback (path, callback_info);
2234 if (ret)
2235 break;
2238 /* Now try the base path. */
2239 if (!pl->require_machine_suffix
2240 && !(pl->os_multilib ? skip_multi_os_dir : skip_multi_dir))
2242 const char *this_multi;
2243 size_t this_multi_len;
2245 if (pl->os_multilib)
2247 this_multi = multi_os_dir;
2248 this_multi_len = multi_os_dir_len;
2250 else
2252 this_multi = multi_dir;
2253 this_multi_len = multi_dir_len;
2256 if (this_multi_len)
2257 memcpy (path + len, this_multi, this_multi_len + 1);
2258 else
2259 path[len] = '\0';
2261 ret = callback (path, callback_info);
2262 if (ret)
2263 break;
2266 if (pl)
2267 break;
2269 if (multi_dir == NULL && multi_os_dir == NULL)
2270 break;
2272 /* Run through the paths again, this time without multilibs.
2273 Don't repeat any we have already seen. */
2274 if (multi_dir)
2276 free (CONST_CAST (char *, multi_dir));
2277 multi_dir = NULL;
2278 free (CONST_CAST (char *, multi_suffix));
2279 multi_suffix = machine_suffix;
2280 free (CONST_CAST (char *, just_multi_suffix));
2281 just_multi_suffix = just_machine_suffix;
2283 else
2284 skip_multi_dir = true;
2285 if (multi_os_dir)
2287 free (CONST_CAST (char *, multi_os_dir));
2288 multi_os_dir = NULL;
2290 else
2291 skip_multi_os_dir = true;
2294 if (multi_dir)
2296 free (CONST_CAST (char *, multi_dir));
2297 free (CONST_CAST (char *, multi_suffix));
2298 free (CONST_CAST (char *, just_multi_suffix));
2300 if (multi_os_dir)
2301 free (CONST_CAST (char *, multi_os_dir));
2302 if (ret != path)
2303 free (path);
2304 return ret;
2307 /* Callback for build_search_list. Adds path to obstack being built. */
2309 struct add_to_obstack_info {
2310 struct obstack *ob;
2311 bool check_dir;
2312 bool first_time;
2315 static void *
2316 add_to_obstack (char *path, void *data)
2318 struct add_to_obstack_info *info = (struct add_to_obstack_info *) data;
2320 if (info->check_dir && !is_directory (path, false))
2321 return NULL;
2323 if (!info->first_time)
2324 obstack_1grow (info->ob, PATH_SEPARATOR);
2326 obstack_grow (info->ob, path, strlen (path));
2328 info->first_time = false;
2329 return NULL;
2332 /* Add or change the value of an environment variable, outputting the
2333 change to standard error if in verbose mode. */
2334 static void
2335 xputenv (const char *string)
2337 if (verbose_flag)
2338 fnotice (stderr, "%s\n", string);
2339 putenv (CONST_CAST (char *, string));
2342 /* Build a list of search directories from PATHS.
2343 PREFIX is a string to prepend to the list.
2344 If CHECK_DIR_P is true we ensure the directory exists.
2345 If DO_MULTI is true, multilib paths are output first, then
2346 non-multilib paths.
2347 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2348 It is also used by the --print-search-dirs flag. */
2350 static char *
2351 build_search_list (const struct path_prefix *paths, const char *prefix,
2352 bool check_dir, bool do_multi)
2354 struct add_to_obstack_info info;
2356 info.ob = &collect_obstack;
2357 info.check_dir = check_dir;
2358 info.first_time = true;
2360 obstack_grow (&collect_obstack, prefix, strlen (prefix));
2361 obstack_1grow (&collect_obstack, '=');
2363 for_each_path (paths, do_multi, 0, add_to_obstack, &info);
2365 obstack_1grow (&collect_obstack, '\0');
2366 return XOBFINISH (&collect_obstack, char *);
2369 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2370 for collect. */
2372 static void
2373 putenv_from_prefixes (const struct path_prefix *paths, const char *env_var,
2374 bool do_multi)
2376 xputenv (build_search_list (paths, env_var, true, do_multi));
2379 /* Check whether NAME can be accessed in MODE. This is like access,
2380 except that it never considers directories to be executable. */
2382 static int
2383 access_check (const char *name, int mode)
2385 if (mode == X_OK)
2387 struct stat st;
2389 if (stat (name, &st) < 0
2390 || S_ISDIR (st.st_mode))
2391 return -1;
2394 return access (name, mode);
2397 /* Callback for find_a_file. Appends the file name to the directory
2398 path. If the resulting file exists in the right mode, return the
2399 full pathname to the file. */
2401 struct file_at_path_info {
2402 const char *name;
2403 const char *suffix;
2404 int name_len;
2405 int suffix_len;
2406 int mode;
2409 static void *
2410 file_at_path (char *path, void *data)
2412 struct file_at_path_info *info = (struct file_at_path_info *) data;
2413 size_t len = strlen (path);
2415 memcpy (path + len, info->name, info->name_len);
2416 len += info->name_len;
2418 /* Some systems have a suffix for executable files.
2419 So try appending that first. */
2420 if (info->suffix_len)
2422 memcpy (path + len, info->suffix, info->suffix_len + 1);
2423 if (access_check (path, info->mode) == 0)
2424 return path;
2427 path[len] = '\0';
2428 if (access_check (path, info->mode) == 0)
2429 return path;
2431 return NULL;
2434 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2435 access to check permissions. If DO_MULTI is true, search multilib
2436 paths then non-multilib paths, otherwise do not search multilib paths.
2437 Return 0 if not found, otherwise return its name, allocated with malloc. */
2439 static char *
2440 find_a_file (const struct path_prefix *pprefix, const char *name, int mode,
2441 bool do_multi)
2443 struct file_at_path_info info;
2445 #ifdef DEFAULT_ASSEMBLER
2446 if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
2447 return xstrdup (DEFAULT_ASSEMBLER);
2448 #endif
2450 #ifdef DEFAULT_LINKER
2451 if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0)
2452 return xstrdup (DEFAULT_LINKER);
2453 #endif
2455 /* Determine the filename to execute (special case for absolute paths). */
2457 if (IS_ABSOLUTE_PATH (name))
2459 if (access (name, mode) == 0)
2460 return xstrdup (name);
2462 return NULL;
2465 info.name = name;
2466 info.suffix = (mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "";
2467 info.name_len = strlen (info.name);
2468 info.suffix_len = strlen (info.suffix);
2469 info.mode = mode;
2471 return (char*) for_each_path (pprefix, do_multi,
2472 info.name_len + info.suffix_len,
2473 file_at_path, &info);
2476 /* Ranking of prefixes in the sort list. -B prefixes are put before
2477 all others. */
2479 enum path_prefix_priority
2481 PREFIX_PRIORITY_B_OPT,
2482 PREFIX_PRIORITY_LAST
2485 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
2486 order according to PRIORITY. Within each PRIORITY, new entries are
2487 appended.
2489 If WARN is nonzero, we will warn if no file is found
2490 through this prefix. WARN should point to an int
2491 which will be set to 1 if this entry is used.
2493 COMPONENT is the value to be passed to update_path.
2495 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2496 the complete value of machine_suffix.
2497 2 means try both machine_suffix and just_machine_suffix. */
2499 static void
2500 add_prefix (struct path_prefix *pprefix, const char *prefix,
2501 const char *component, /* enum prefix_priority */ int priority,
2502 int require_machine_suffix, int os_multilib)
2504 struct prefix_list *pl, **prev;
2505 int len;
2507 for (prev = &pprefix->plist;
2508 (*prev) != NULL && (*prev)->priority <= priority;
2509 prev = &(*prev)->next)
2512 /* Keep track of the longest prefix. */
2514 prefix = update_path (prefix, component);
2515 len = strlen (prefix);
2516 if (len > pprefix->max_len)
2517 pprefix->max_len = len;
2519 pl = XNEW (struct prefix_list);
2520 pl->prefix = prefix;
2521 pl->require_machine_suffix = require_machine_suffix;
2522 pl->priority = priority;
2523 pl->os_multilib = os_multilib;
2525 /* Insert after PREV. */
2526 pl->next = (*prev);
2527 (*prev) = pl;
2530 /* Same as add_prefix, but prepending target_system_root to prefix. */
2531 /* The target_system_root prefix has been relocated by gcc_exec_prefix. */
2532 static void
2533 add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
2534 const char *component,
2535 /* enum prefix_priority */ int priority,
2536 int require_machine_suffix, int os_multilib)
2538 if (!IS_ABSOLUTE_PATH (prefix))
2539 fatal_error ("system path %qs is not absolute", prefix);
2541 if (target_system_root)
2543 char *sysroot_no_trailing_dir_separator = xstrdup (target_system_root);
2544 size_t sysroot_len = strlen (target_system_root);
2546 if (sysroot_len > 0
2547 && target_system_root[sysroot_len - 1] == DIR_SEPARATOR)
2548 sysroot_no_trailing_dir_separator[sysroot_len - 1] = '\0';
2550 if (target_sysroot_suffix)
2551 prefix = concat (sysroot_no_trailing_dir_separator,
2552 target_sysroot_suffix, prefix, NULL);
2553 else
2554 prefix = concat (sysroot_no_trailing_dir_separator, prefix, NULL);
2556 free (sysroot_no_trailing_dir_separator);
2558 /* We have to override this because GCC's notion of sysroot
2559 moves along with GCC. */
2560 component = "GCC";
2563 add_prefix (pprefix, prefix, component, priority,
2564 require_machine_suffix, os_multilib);
2567 /* Execute the command specified by the arguments on the current line of spec.
2568 When using pipes, this includes several piped-together commands
2569 with `|' between them.
2571 Return 0 if successful, -1 if failed. */
2573 static int
2574 execute (void)
2576 int i;
2577 int n_commands; /* # of command. */
2578 char *string;
2579 struct pex_obj *pex;
2580 struct command
2582 const char *prog; /* program name. */
2583 const char **argv; /* vector of args. */
2585 const char *arg;
2587 struct command *commands; /* each command buffer with above info. */
2589 gcc_assert (!processing_spec_function);
2591 if (wrapper_string)
2593 string = find_a_file (&exec_prefixes,
2594 argbuf[0], X_OK, false);
2595 if (string)
2596 argbuf[0] = string;
2597 insert_wrapper (wrapper_string);
2600 /* Count # of piped commands. */
2601 for (n_commands = 1, i = 0; argbuf.iterate (i, &arg); i++)
2602 if (strcmp (arg, "|") == 0)
2603 n_commands++;
2605 /* Get storage for each command. */
2606 commands = (struct command *) alloca (n_commands * sizeof (struct command));
2608 /* Split argbuf into its separate piped processes,
2609 and record info about each one.
2610 Also search for the programs that are to be run. */
2612 argbuf.safe_push (0);
2614 commands[0].prog = argbuf[0]; /* first command. */
2615 commands[0].argv = argbuf.address ();
2617 if (!wrapper_string)
2619 string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, false);
2620 commands[0].argv[0] = (string) ? string : commands[0].argv[0];
2623 for (n_commands = 1, i = 0; argbuf.iterate (i, &arg); i++)
2624 if (arg && strcmp (arg, "|") == 0)
2625 { /* each command. */
2626 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2627 fatal_error ("-pipe not supported");
2628 #endif
2629 argbuf[i] = 0; /* Termination of
2630 command args. */
2631 commands[n_commands].prog = argbuf[i + 1];
2632 commands[n_commands].argv
2633 = &(argbuf.address ())[i + 1];
2634 string = find_a_file (&exec_prefixes, commands[n_commands].prog,
2635 X_OK, false);
2636 if (string)
2637 commands[n_commands].argv[0] = string;
2638 n_commands++;
2641 /* If -v, print what we are about to do, and maybe query. */
2643 if (verbose_flag)
2645 /* For help listings, put a blank line between sub-processes. */
2646 if (print_help_list)
2647 fputc ('\n', stderr);
2649 /* Print each piped command as a separate line. */
2650 for (i = 0; i < n_commands; i++)
2652 const char *const *j;
2654 if (verbose_only_flag)
2656 for (j = commands[i].argv; *j; j++)
2658 const char *p;
2659 for (p = *j; *p; ++p)
2660 if (!ISALNUM ((unsigned char) *p)
2661 && *p != '_' && *p != '/' && *p != '-' && *p != '.')
2662 break;
2663 if (*p || !*j)
2665 fprintf (stderr, " \"");
2666 for (p = *j; *p; ++p)
2668 if (*p == '"' || *p == '\\' || *p == '$')
2669 fputc ('\\', stderr);
2670 fputc (*p, stderr);
2672 fputc ('"', stderr);
2674 /* If it's empty, print "". */
2675 else if (!**j)
2676 fprintf (stderr, " \"\"");
2677 else
2678 fprintf (stderr, " %s", *j);
2681 else
2682 for (j = commands[i].argv; *j; j++)
2683 /* If it's empty, print "". */
2684 if (!**j)
2685 fprintf (stderr, " \"\"");
2686 else
2687 fprintf (stderr, " %s", *j);
2689 /* Print a pipe symbol after all but the last command. */
2690 if (i + 1 != n_commands)
2691 fprintf (stderr, " |");
2692 fprintf (stderr, "\n");
2694 fflush (stderr);
2695 if (verbose_only_flag != 0)
2697 /* verbose_only_flag should act as if the spec was
2698 executed, so increment execution_count before
2699 returning. This prevents spurious warnings about
2700 unused linker input files, etc. */
2701 execution_count++;
2702 return 0;
2704 #ifdef DEBUG
2705 fnotice (stderr, "\nGo ahead? (y or n) ");
2706 fflush (stderr);
2707 i = getchar ();
2708 if (i != '\n')
2709 while (getchar () != '\n')
2712 if (i != 'y' && i != 'Y')
2713 return 0;
2714 #endif /* DEBUG */
2717 #ifdef ENABLE_VALGRIND_CHECKING
2718 /* Run the each command through valgrind. To simplify prepending the
2719 path to valgrind and the option "-q" (for quiet operation unless
2720 something triggers), we allocate a separate argv array. */
2722 for (i = 0; i < n_commands; i++)
2724 const char **argv;
2725 int argc;
2726 int j;
2728 for (argc = 0; commands[i].argv[argc] != NULL; argc++)
2731 argv = XALLOCAVEC (const char *, argc + 3);
2733 argv[0] = VALGRIND_PATH;
2734 argv[1] = "-q";
2735 for (j = 2; j < argc + 2; j++)
2736 argv[j] = commands[i].argv[j - 2];
2737 argv[j] = NULL;
2739 commands[i].argv = argv;
2740 commands[i].prog = argv[0];
2742 #endif
2744 /* Run each piped subprocess. */
2746 pex = pex_init (PEX_USE_PIPES | ((report_times || report_times_to_file)
2747 ? PEX_RECORD_TIMES : 0),
2748 progname, temp_filename);
2749 if (pex == NULL)
2750 fatal_error ("pex_init failed: %m");
2752 for (i = 0; i < n_commands; i++)
2754 const char *errmsg;
2755 int err;
2756 const char *string = commands[i].argv[0];
2758 errmsg = pex_run (pex,
2759 ((i + 1 == n_commands ? PEX_LAST : 0)
2760 | (string == commands[i].prog ? PEX_SEARCH : 0)),
2761 string, CONST_CAST (char **, commands[i].argv),
2762 NULL, NULL, &err);
2763 if (errmsg != NULL)
2765 if (err == 0)
2766 fatal_error (errmsg);
2767 else
2769 errno = err;
2770 pfatal_with_name (errmsg);
2774 if (string != commands[i].prog)
2775 free (CONST_CAST (char *, string));
2778 execution_count++;
2780 /* Wait for all the subprocesses to finish. */
2783 int *statuses;
2784 struct pex_time *times = NULL;
2785 int ret_code = 0;
2787 statuses = (int *) alloca (n_commands * sizeof (int));
2788 if (!pex_get_status (pex, n_commands, statuses))
2789 fatal_error ("failed to get exit status: %m");
2791 if (report_times || report_times_to_file)
2793 times = (struct pex_time *) alloca (n_commands * sizeof (struct pex_time));
2794 if (!pex_get_times (pex, n_commands, times))
2795 fatal_error ("failed to get process times: %m");
2798 pex_free (pex);
2800 for (i = 0; i < n_commands; ++i)
2802 int status = statuses[i];
2804 if (WIFSIGNALED (status))
2806 #ifdef SIGPIPE
2807 /* SIGPIPE is a special case. It happens in -pipe mode
2808 when the compiler dies before the preprocessor is done,
2809 or the assembler dies before the compiler is done.
2810 There's generally been an error already, and this is
2811 just fallout. So don't generate another error unless
2812 we would otherwise have succeeded. */
2813 if (WTERMSIG (status) == SIGPIPE
2814 && (signal_count || greatest_status >= MIN_FATAL_STATUS))
2816 signal_count++;
2817 ret_code = -1;
2819 else
2820 #endif
2821 internal_error ("%s (program %s)",
2822 strsignal (WTERMSIG (status)), commands[i].prog);
2824 else if (WIFEXITED (status)
2825 && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
2827 if (WEXITSTATUS (status) > greatest_status)
2828 greatest_status = WEXITSTATUS (status);
2829 ret_code = -1;
2832 if (report_times || report_times_to_file)
2834 struct pex_time *pt = &times[i];
2835 double ut, st;
2837 ut = ((double) pt->user_seconds
2838 + (double) pt->user_microseconds / 1.0e6);
2839 st = ((double) pt->system_seconds
2840 + (double) pt->system_microseconds / 1.0e6);
2842 if (ut + st != 0)
2844 if (report_times)
2845 fnotice (stderr, "# %s %.2f %.2f\n",
2846 commands[i].prog, ut, st);
2848 if (report_times_to_file)
2850 int c = 0;
2851 const char *const *j;
2853 fprintf (report_times_to_file, "%g %g", ut, st);
2855 for (j = &commands[i].prog; *j; j = &commands[i].argv[++c])
2857 const char *p;
2858 for (p = *j; *p; ++p)
2859 if (*p == '"' || *p == '\\' || *p == '$'
2860 || ISSPACE (*p))
2861 break;
2863 if (*p)
2865 fprintf (report_times_to_file, " \"");
2866 for (p = *j; *p; ++p)
2868 if (*p == '"' || *p == '\\' || *p == '$')
2869 fputc ('\\', report_times_to_file);
2870 fputc (*p, report_times_to_file);
2872 fputc ('"', report_times_to_file);
2874 else
2875 fprintf (report_times_to_file, " %s", *j);
2878 fputc ('\n', report_times_to_file);
2884 return ret_code;
2888 /* Find all the switches given to us
2889 and make a vector describing them.
2890 The elements of the vector are strings, one per switch given.
2891 If a switch uses following arguments, then the `part1' field
2892 is the switch itself and the `args' field
2893 is a null-terminated vector containing the following arguments.
2894 Bits in the `live_cond' field are:
2895 SWITCH_LIVE to indicate this switch is true in a conditional spec.
2896 SWITCH_FALSE to indicate this switch is overridden by a later switch.
2897 SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
2898 SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored
2899 in all do_spec calls afterwards. Used for %<S from self specs.
2900 The `validated' field is nonzero if any spec has looked at this switch;
2901 if it remains zero at the end of the run, it must be meaningless. */
2903 #define SWITCH_LIVE (1 << 0)
2904 #define SWITCH_FALSE (1 << 1)
2905 #define SWITCH_IGNORE (1 << 2)
2906 #define SWITCH_IGNORE_PERMANENTLY (1 << 3)
2907 #define SWITCH_KEEP_FOR_GCC (1 << 4)
2909 struct switchstr
2911 const char *part1;
2912 const char **args;
2913 unsigned int live_cond;
2914 bool known;
2915 bool validated;
2916 bool ordering;
2919 static struct switchstr *switches;
2921 static int n_switches;
2923 static int n_switches_alloc;
2925 /* Set to zero if -fcompare-debug is disabled, positive if it's
2926 enabled and we're running the first compilation, negative if it's
2927 enabled and we're running the second compilation. For most of the
2928 time, it's in the range -1..1, but it can be temporarily set to 2
2929 or 3 to indicate that the -fcompare-debug flags didn't come from
2930 the command-line, but rather from the GCC_COMPARE_DEBUG environment
2931 variable, until a synthesized -fcompare-debug flag is added to the
2932 command line. */
2933 int compare_debug;
2935 /* Set to nonzero if we've seen the -fcompare-debug-second flag. */
2936 int compare_debug_second;
2938 /* Set to the flags that should be passed to the second compilation in
2939 a -fcompare-debug compilation. */
2940 const char *compare_debug_opt;
2942 static struct switchstr *switches_debug_check[2];
2944 static int n_switches_debug_check[2];
2946 static int n_switches_alloc_debug_check[2];
2948 static char *debug_check_temp_file[2];
2950 /* Language is one of three things:
2952 1) The name of a real programming language.
2953 2) NULL, indicating that no one has figured out
2954 what it is yet.
2955 3) '*', indicating that the file should be passed
2956 to the linker. */
2957 struct infile
2959 const char *name;
2960 const char *language;
2961 struct compiler *incompiler;
2962 bool compiled;
2963 bool preprocessed;
2966 /* Also a vector of input files specified. */
2968 static struct infile *infiles;
2970 int n_infiles;
2972 static int n_infiles_alloc;
2974 /* True if multiple input files are being compiled to a single
2975 assembly file. */
2977 static bool combine_inputs;
2979 /* This counts the number of libraries added by lang_specific_driver, so that
2980 we can tell if there were any user supplied any files or libraries. */
2982 static int added_libraries;
2984 /* And a vector of corresponding output files is made up later. */
2986 const char **outfiles;
2988 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2990 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
2991 is true if we should look for an executable suffix. DO_OBJ
2992 is true if we should look for an object suffix. */
2994 static const char *
2995 convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
2996 int do_obj ATTRIBUTE_UNUSED)
2998 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2999 int i;
3000 #endif
3001 int len;
3003 if (name == NULL)
3004 return NULL;
3006 len = strlen (name);
3008 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3009 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
3010 if (do_obj && len > 2
3011 && name[len - 2] == '.'
3012 && name[len - 1] == 'o')
3014 obstack_grow (&obstack, name, len - 2);
3015 obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
3016 name = XOBFINISH (&obstack, const char *);
3018 #endif
3020 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3021 /* If there is no filetype, make it the executable suffix (which includes
3022 the "."). But don't get confused if we have just "-o". */
3023 if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
3024 return name;
3026 for (i = len - 1; i >= 0; i--)
3027 if (IS_DIR_SEPARATOR (name[i]))
3028 break;
3030 for (i++; i < len; i++)
3031 if (name[i] == '.')
3032 return name;
3034 obstack_grow (&obstack, name, len);
3035 obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
3036 strlen (TARGET_EXECUTABLE_SUFFIX));
3037 name = XOBFINISH (&obstack, const char *);
3038 #endif
3040 return name;
3042 #endif
3044 /* Display the command line switches accepted by gcc. */
3045 static void
3046 display_help (void)
3048 printf (_("Usage: %s [options] file...\n"), progname);
3049 fputs (_("Options:\n"), stdout);
3051 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout);
3052 fputs (_(" --help Display this information\n"), stdout);
3053 fputs (_(" --target-help Display target specific command line options\n"), stdout);
3054 fputs (_(" --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...]\n"), stdout);
3055 fputs (_(" Display specific types of command line options\n"), stdout);
3056 if (! verbose_flag)
3057 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
3058 fputs (_(" --version Display compiler version information\n"), stdout);
3059 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout);
3060 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout);
3061 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout);
3062 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout);
3063 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout);
3064 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout);
3065 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout);
3066 fputs (_("\
3067 -print-multiarch Display the target's normalized GNU triplet, used as\n\
3068 a component in the library path\n"), stdout);
3069 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout);
3070 fputs (_("\
3071 -print-multi-lib Display the mapping between command line options and\n\
3072 multiple library search directories\n"), stdout);
3073 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries\n"), stdout);
3074 fputs (_(" -print-sysroot Display the target libraries directory\n"), stdout);
3075 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n"), stdout);
3076 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout);
3077 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout);
3078 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout);
3079 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler\n"), stdout);
3080 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n"), stdout);
3081 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout);
3082 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout);
3083 fputs (_(" -save-temps=<arg> Do not delete intermediate files\n"), stdout);
3084 fputs (_("\
3085 -no-canonical-prefixes Do not canonicalize paths when building relative\n\
3086 prefixes to other gcc components\n"), stdout);
3087 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout);
3088 fputs (_(" -time Time the execution of each subprocess\n"), stdout);
3089 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout);
3090 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout);
3091 fputs (_("\
3092 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3093 and libraries\n"), stdout);
3094 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout);
3095 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout);
3096 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout);
3097 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout);
3098 fputs (_(" -S Compile only; do not assemble or link\n"), stdout);
3099 fputs (_(" -c Compile and assemble, but do not link\n"), stdout);
3100 fputs (_(" -o <file> Place the output into <file>\n"), stdout);
3101 fputs (_(" -pie Create a position independent executable\n"), stdout);
3102 fputs (_(" -shared Create a shared library\n"), stdout);
3103 fputs (_("\
3104 -x <language> Specify the language of the following input files\n\
3105 Permissible languages include: c c++ assembler none\n\
3106 'none' means revert to the default behavior of\n\
3107 guessing the language based on the file's extension\n\
3108 "), stdout);
3110 printf (_("\
3111 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3112 passed on to the various sub-processes invoked by %s. In order to pass\n\
3113 other options on to these processes the -W<letter> options must be used.\n\
3114 "), progname);
3116 /* The rest of the options are displayed by invocations of the various
3117 sub-processes. */
3120 static void
3121 add_preprocessor_option (const char *option, int len)
3123 preprocessor_options.safe_push (save_string (option, len));
3126 static void
3127 add_assembler_option (const char *option, int len)
3129 assembler_options.safe_push (save_string (option, len));
3132 static void
3133 add_linker_option (const char *option, int len)
3135 linker_options.safe_push (save_string (option, len));
3138 /* Allocate space for an input file in infiles. */
3140 static void
3141 alloc_infile (void)
3143 if (n_infiles_alloc == 0)
3145 n_infiles_alloc = 16;
3146 infiles = XNEWVEC (struct infile, n_infiles_alloc);
3148 else if (n_infiles_alloc == n_infiles)
3150 n_infiles_alloc *= 2;
3151 infiles = XRESIZEVEC (struct infile, infiles, n_infiles_alloc);
3155 /* Store an input file with the given NAME and LANGUAGE in
3156 infiles. */
3158 static void
3159 add_infile (const char *name, const char *language)
3161 alloc_infile ();
3162 infiles[n_infiles].name = name;
3163 infiles[n_infiles++].language = language;
3166 /* Allocate space for a switch in switches. */
3168 static void
3169 alloc_switch (void)
3171 if (n_switches_alloc == 0)
3173 n_switches_alloc = 16;
3174 switches = XNEWVEC (struct switchstr, n_switches_alloc);
3176 else if (n_switches_alloc == n_switches)
3178 n_switches_alloc *= 2;
3179 switches = XRESIZEVEC (struct switchstr, switches, n_switches_alloc);
3183 /* Save an option OPT with N_ARGS arguments in array ARGS, marking it
3184 as validated if VALIDATED and KNOWN if it is an internal switch. */
3186 static void
3187 save_switch (const char *opt, size_t n_args, const char *const *args,
3188 bool validated, bool known)
3190 alloc_switch ();
3191 switches[n_switches].part1 = opt + 1;
3192 if (n_args == 0)
3193 switches[n_switches].args = 0;
3194 else
3196 switches[n_switches].args = XNEWVEC (const char *, n_args + 1);
3197 memcpy (switches[n_switches].args, args, n_args * sizeof (const char *));
3198 switches[n_switches].args[n_args] = NULL;
3201 switches[n_switches].live_cond = 0;
3202 switches[n_switches].validated = validated;
3203 switches[n_switches].known = known;
3204 switches[n_switches].ordering = 0;
3205 n_switches++;
3208 /* Handle an option DECODED that is unknown to the option-processing
3209 machinery. */
3211 static bool
3212 driver_unknown_option_callback (const struct cl_decoded_option *decoded)
3214 const char *opt = decoded->arg;
3215 if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-'
3216 && !(decoded->errors & CL_ERR_NEGATIVE))
3218 /* Leave unknown -Wno-* options for the compiler proper, to be
3219 diagnosed only if there are warnings. */
3220 save_switch (decoded->canonical_option[0],
3221 decoded->canonical_option_num_elements - 1,
3222 &decoded->canonical_option[1], false, true);
3223 return false;
3225 if (decoded->opt_index == OPT_SPECIAL_unknown)
3227 /* Give it a chance to define it a a spec file. */
3228 save_switch (decoded->canonical_option[0],
3229 decoded->canonical_option_num_elements - 1,
3230 &decoded->canonical_option[1], false, false);
3231 return false;
3233 else
3234 return true;
3237 /* Handle an option DECODED that is not marked as CL_DRIVER.
3238 LANG_MASK will always be CL_DRIVER. */
3240 static void
3241 driver_wrong_lang_callback (const struct cl_decoded_option *decoded,
3242 unsigned int lang_mask ATTRIBUTE_UNUSED)
3244 /* At this point, non-driver options are accepted (and expected to
3245 be passed down by specs) unless marked to be rejected by the
3246 driver. Options to be rejected by the driver but accepted by the
3247 compilers proper are treated just like completely unknown
3248 options. */
3249 const struct cl_option *option = &cl_options[decoded->opt_index];
3251 if (option->cl_reject_driver)
3252 error ("unrecognized command line option %qs",
3253 decoded->orig_option_with_args_text);
3254 else
3255 save_switch (decoded->canonical_option[0],
3256 decoded->canonical_option_num_elements - 1,
3257 &decoded->canonical_option[1], false, true);
3260 static const char *spec_lang = 0;
3261 static int last_language_n_infiles;
3263 /* Handle a driver option; arguments and return value as for
3264 handle_option. */
3266 static bool
3267 driver_handle_option (struct gcc_options *opts,
3268 struct gcc_options *opts_set,
3269 const struct cl_decoded_option *decoded,
3270 unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
3271 location_t loc,
3272 const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED,
3273 diagnostic_context *dc)
3275 size_t opt_index = decoded->opt_index;
3276 const char *arg = decoded->arg;
3277 const char *compare_debug_replacement_opt;
3278 int value = decoded->value;
3279 bool validated = false;
3280 bool do_save = true;
3282 gcc_assert (opts == &global_options);
3283 gcc_assert (opts_set == &global_options_set);
3284 gcc_assert (kind == DK_UNSPECIFIED);
3285 gcc_assert (loc == UNKNOWN_LOCATION);
3286 gcc_assert (dc == global_dc);
3288 switch (opt_index)
3290 case OPT_dumpspecs:
3292 struct spec_list *sl;
3293 init_spec ();
3294 for (sl = specs; sl; sl = sl->next)
3295 printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3296 if (link_command_spec)
3297 printf ("*link_command:\n%s\n\n", link_command_spec);
3298 exit (0);
3301 case OPT_dumpversion:
3302 printf ("%s\n", spec_version);
3303 exit (0);
3305 case OPT_dumpmachine:
3306 printf ("%s\n", spec_machine);
3307 exit (0);
3309 case OPT__version:
3310 print_version = 1;
3312 /* CPP driver cannot obtain switch from cc1_options. */
3313 if (is_cpp_driver)
3314 add_preprocessor_option ("--version", strlen ("--version"));
3315 add_assembler_option ("--version", strlen ("--version"));
3316 add_linker_option ("--version", strlen ("--version"));
3317 break;
3319 case OPT__help:
3320 print_help_list = 1;
3322 /* CPP driver cannot obtain switch from cc1_options. */
3323 if (is_cpp_driver)
3324 add_preprocessor_option ("--help", 6);
3325 add_assembler_option ("--help", 6);
3326 add_linker_option ("--help", 6);
3327 break;
3329 case OPT__help_:
3330 print_subprocess_help = 2;
3331 break;
3333 case OPT__target_help:
3334 print_subprocess_help = 1;
3336 /* CPP driver cannot obtain switch from cc1_options. */
3337 if (is_cpp_driver)
3338 add_preprocessor_option ("--target-help", 13);
3339 add_assembler_option ("--target-help", 13);
3340 add_linker_option ("--target-help", 13);
3341 break;
3343 case OPT__no_sysroot_suffix:
3344 case OPT_pass_exit_codes:
3345 case OPT_print_search_dirs:
3346 case OPT_print_file_name_:
3347 case OPT_print_prog_name_:
3348 case OPT_print_multi_lib:
3349 case OPT_print_multi_directory:
3350 case OPT_print_sysroot:
3351 case OPT_print_multi_os_directory:
3352 case OPT_print_multiarch:
3353 case OPT_print_sysroot_headers_suffix:
3354 case OPT_time:
3355 case OPT_wrapper:
3356 /* These options set the variables specified in common.opt
3357 automatically, and do not need to be saved for spec
3358 processing. */
3359 do_save = false;
3360 break;
3362 case OPT_print_libgcc_file_name:
3363 print_file_name = "libgcc.a";
3364 do_save = false;
3365 break;
3367 case OPT_fcompare_debug_second:
3368 compare_debug_second = 1;
3369 break;
3371 case OPT_fcompare_debug:
3372 switch (value)
3374 case 0:
3375 compare_debug_replacement_opt = "-fcompare-debug=";
3376 arg = "";
3377 goto compare_debug_with_arg;
3379 case 1:
3380 compare_debug_replacement_opt = "-fcompare-debug=-gtoggle";
3381 arg = "-gtoggle";
3382 goto compare_debug_with_arg;
3384 default:
3385 gcc_unreachable ();
3387 break;
3389 case OPT_fcompare_debug_:
3390 compare_debug_replacement_opt = decoded->canonical_option[0];
3391 compare_debug_with_arg:
3392 gcc_assert (decoded->canonical_option_num_elements == 1);
3393 gcc_assert (arg != NULL);
3394 if (*arg)
3395 compare_debug = 1;
3396 else
3397 compare_debug = -1;
3398 if (compare_debug < 0)
3399 compare_debug_opt = NULL;
3400 else
3401 compare_debug_opt = arg;
3402 save_switch (compare_debug_replacement_opt, 0, NULL, validated, true);
3403 return true;
3405 case OPT_Wa_:
3407 int prev, j;
3408 /* Pass the rest of this option to the assembler. */
3410 /* Split the argument at commas. */
3411 prev = 0;
3412 for (j = 0; arg[j]; j++)
3413 if (arg[j] == ',')
3415 add_assembler_option (arg + prev, j - prev);
3416 prev = j + 1;
3419 /* Record the part after the last comma. */
3420 add_assembler_option (arg + prev, j - prev);
3422 do_save = false;
3423 break;
3425 case OPT_Wp_:
3427 int prev, j;
3428 /* Pass the rest of this option to the preprocessor. */
3430 /* Split the argument at commas. */
3431 prev = 0;
3432 for (j = 0; arg[j]; j++)
3433 if (arg[j] == ',')
3435 add_preprocessor_option (arg + prev, j - prev);
3436 prev = j + 1;
3439 /* Record the part after the last comma. */
3440 add_preprocessor_option (arg + prev, j - prev);
3442 do_save = false;
3443 break;
3445 case OPT_Wl_:
3447 int prev, j;
3448 /* Split the argument at commas. */
3449 prev = 0;
3450 for (j = 0; arg[j]; j++)
3451 if (arg[j] == ',')
3453 add_infile (save_string (arg + prev, j - prev), "*");
3454 prev = j + 1;
3456 /* Record the part after the last comma. */
3457 add_infile (arg + prev, "*");
3459 do_save = false;
3460 break;
3462 case OPT_Xlinker:
3463 add_infile (arg, "*");
3464 do_save = false;
3465 break;
3467 case OPT_Xpreprocessor:
3468 add_preprocessor_option (arg, strlen (arg));
3469 do_save = false;
3470 break;
3472 case OPT_Xassembler:
3473 add_assembler_option (arg, strlen (arg));
3474 do_save = false;
3475 break;
3477 case OPT_l:
3478 /* POSIX allows separation of -l and the lib arg; canonicalize
3479 by concatenating -l with its arg */
3480 add_infile (concat ("-l", arg, NULL), "*");
3481 do_save = false;
3482 break;
3484 case OPT_L:
3485 /* Similarly, canonicalize -L for linkers that may not accept
3486 separate arguments. */
3487 save_switch (concat ("-L", arg, NULL), 0, NULL, validated, true);
3488 return true;
3490 case OPT_F:
3491 /* Likewise -F. */
3492 save_switch (concat ("-F", arg, NULL), 0, NULL, validated, true);
3493 return true;
3495 case OPT_save_temps:
3496 save_temps_flag = SAVE_TEMPS_CWD;
3497 validated = true;
3498 break;
3500 case OPT_save_temps_:
3501 if (strcmp (arg, "cwd") == 0)
3502 save_temps_flag = SAVE_TEMPS_CWD;
3503 else if (strcmp (arg, "obj") == 0
3504 || strcmp (arg, "object") == 0)
3505 save_temps_flag = SAVE_TEMPS_OBJ;
3506 else
3507 fatal_error ("%qs is an unknown -save-temps option",
3508 decoded->orig_option_with_args_text);
3509 break;
3511 case OPT_no_canonical_prefixes:
3512 /* Already handled as a special case, so ignored here. */
3513 do_save = false;
3514 break;
3516 case OPT_pipe:
3517 validated = true;
3518 /* These options set the variables specified in common.opt
3519 automatically, but do need to be saved for spec
3520 processing. */
3521 break;
3523 case OPT_specs_:
3525 struct user_specs *user = XNEW (struct user_specs);
3527 user->next = (struct user_specs *) 0;
3528 user->filename = arg;
3529 if (user_specs_tail)
3530 user_specs_tail->next = user;
3531 else
3532 user_specs_head = user;
3533 user_specs_tail = user;
3535 validated = true;
3536 break;
3538 case OPT__sysroot_:
3539 target_system_root = arg;
3540 target_system_root_changed = 1;
3541 do_save = false;
3542 break;
3544 case OPT_time_:
3545 if (report_times_to_file)
3546 fclose (report_times_to_file);
3547 report_times_to_file = fopen (arg, "a");
3548 do_save = false;
3549 break;
3551 case OPT____:
3552 /* "-###"
3553 This is similar to -v except that there is no execution
3554 of the commands and the echoed arguments are quoted. It
3555 is intended for use in shell scripts to capture the
3556 driver-generated command line. */
3557 verbose_only_flag++;
3558 verbose_flag = 1;
3559 do_save = false;
3560 break;
3562 case OPT_B:
3564 size_t len = strlen (arg);
3566 /* Catch the case where the user has forgotten to append a
3567 directory separator to the path. Note, they may be using
3568 -B to add an executable name prefix, eg "i386-elf-", in
3569 order to distinguish between multiple installations of
3570 GCC in the same directory. Hence we must check to see
3571 if appending a directory separator actually makes a
3572 valid directory name. */
3573 if (!IS_DIR_SEPARATOR (arg[len - 1])
3574 && is_directory (arg, false))
3576 char *tmp = XNEWVEC (char, len + 2);
3577 strcpy (tmp, arg);
3578 tmp[len] = DIR_SEPARATOR;
3579 tmp[++len] = 0;
3580 arg = tmp;
3583 add_prefix (&exec_prefixes, arg, NULL,
3584 PREFIX_PRIORITY_B_OPT, 0, 0);
3585 add_prefix (&startfile_prefixes, arg, NULL,
3586 PREFIX_PRIORITY_B_OPT, 0, 0);
3587 add_prefix (&include_prefixes, arg, NULL,
3588 PREFIX_PRIORITY_B_OPT, 0, 0);
3590 validated = true;
3591 break;
3593 case OPT_x:
3594 spec_lang = arg;
3595 if (!strcmp (spec_lang, "none"))
3596 /* Suppress the warning if -xnone comes after the last input
3597 file, because alternate command interfaces like g++ might
3598 find it useful to place -xnone after each input file. */
3599 spec_lang = 0;
3600 else
3601 last_language_n_infiles = n_infiles;
3602 do_save = false;
3603 break;
3605 case OPT_o:
3606 have_o = 1;
3607 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3608 arg = convert_filename (arg, ! have_c, 0);
3609 #endif
3610 /* Save the output name in case -save-temps=obj was used. */
3611 save_temps_prefix = xstrdup (arg);
3612 /* On some systems, ld cannot handle "-o" without a space. So
3613 split the option from its argument. */
3614 save_switch ("-o", 1, &arg, validated, true);
3615 return true;
3617 case OPT_static_libgcc:
3618 case OPT_shared_libgcc:
3619 case OPT_static_libgfortran:
3620 case OPT_static_libstdc__:
3621 /* These are always valid, since gcc.c itself understands the
3622 first two, gfortranspec.c understands -static-libgfortran and
3623 g++spec.c understands -static-libstdc++ */
3624 validated = true;
3625 break;
3627 default:
3628 /* Various driver options need no special processing at this
3629 point, having been handled in a prescan above or being
3630 handled by specs. */
3631 break;
3634 if (do_save)
3635 save_switch (decoded->canonical_option[0],
3636 decoded->canonical_option_num_elements - 1,
3637 &decoded->canonical_option[1], validated, true);
3638 return true;
3641 /* Put the driver's standard set of option handlers in *HANDLERS. */
3643 static void
3644 set_option_handlers (struct cl_option_handlers *handlers)
3646 handlers->unknown_option_callback = driver_unknown_option_callback;
3647 handlers->wrong_lang_callback = driver_wrong_lang_callback;
3648 handlers->num_handlers = 3;
3649 handlers->handlers[0].handler = driver_handle_option;
3650 handlers->handlers[0].mask = CL_DRIVER;
3651 handlers->handlers[1].handler = common_handle_option;
3652 handlers->handlers[1].mask = CL_COMMON;
3653 handlers->handlers[2].handler = target_handle_option;
3654 handlers->handlers[2].mask = CL_TARGET;
3657 /* Create the vector `switches' and its contents.
3658 Store its length in `n_switches'. */
3660 static void
3661 process_command (unsigned int decoded_options_count,
3662 struct cl_decoded_option *decoded_options)
3664 const char *temp;
3665 char *temp1;
3666 char *tooldir_prefix, *tooldir_prefix2;
3667 char *(*get_relative_prefix) (const char *, const char *,
3668 const char *) = NULL;
3669 struct cl_option_handlers handlers;
3670 unsigned int j;
3672 gcc_exec_prefix = getenv ("GCC_EXEC_PREFIX");
3674 n_switches = 0;
3675 n_infiles = 0;
3676 added_libraries = 0;
3678 /* Figure compiler version from version string. */
3680 compiler_version = temp1 = xstrdup (version_string);
3682 for (; *temp1; ++temp1)
3684 if (*temp1 == ' ')
3686 *temp1 = '\0';
3687 break;
3691 /* Handle any -no-canonical-prefixes flag early, to assign the function
3692 that builds relative prefixes. This function creates default search
3693 paths that are needed later in normal option handling. */
3695 for (j = 1; j < decoded_options_count; j++)
3697 if (decoded_options[j].opt_index == OPT_no_canonical_prefixes)
3699 get_relative_prefix = make_relative_prefix_ignore_links;
3700 break;
3703 if (! get_relative_prefix)
3704 get_relative_prefix = make_relative_prefix;
3706 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
3707 see if we can create it from the pathname specified in
3708 decoded_options[0].arg. */
3710 gcc_libexec_prefix = standard_libexec_prefix;
3711 #ifndef VMS
3712 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
3713 if (!gcc_exec_prefix)
3715 gcc_exec_prefix = get_relative_prefix (decoded_options[0].arg,
3716 standard_bindir_prefix,
3717 standard_exec_prefix);
3718 gcc_libexec_prefix = get_relative_prefix (decoded_options[0].arg,
3719 standard_bindir_prefix,
3720 standard_libexec_prefix);
3721 if (gcc_exec_prefix)
3722 xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
3724 else
3726 /* make_relative_prefix requires a program name, but
3727 GCC_EXEC_PREFIX is typically a directory name with a trailing
3728 / (which is ignored by make_relative_prefix), so append a
3729 program name. */
3730 char *tmp_prefix = concat (gcc_exec_prefix, "gcc", NULL);
3731 gcc_libexec_prefix = get_relative_prefix (tmp_prefix,
3732 standard_exec_prefix,
3733 standard_libexec_prefix);
3735 /* The path is unrelocated, so fallback to the original setting. */
3736 if (!gcc_libexec_prefix)
3737 gcc_libexec_prefix = standard_libexec_prefix;
3739 free (tmp_prefix);
3741 #else
3742 #endif
3743 /* From this point onward, gcc_exec_prefix is non-null if the toolchain
3744 is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
3745 or an automatically created GCC_EXEC_PREFIX from
3746 decoded_options[0].arg. */
3748 /* Do language-specific adjustment/addition of flags. */
3749 lang_specific_driver (&decoded_options, &decoded_options_count,
3750 &added_libraries);
3752 if (gcc_exec_prefix)
3754 int len = strlen (gcc_exec_prefix);
3756 if (len > (int) sizeof ("/lib/gcc/") - 1
3757 && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
3759 temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1;
3760 if (IS_DIR_SEPARATOR (*temp)
3761 && filename_ncmp (temp + 1, "lib", 3) == 0
3762 && IS_DIR_SEPARATOR (temp[4])
3763 && filename_ncmp (temp + 5, "gcc", 3) == 0)
3764 len -= sizeof ("/lib/gcc/") - 1;
3767 set_std_prefix (gcc_exec_prefix, len);
3768 add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC",
3769 PREFIX_PRIORITY_LAST, 0, 0);
3770 add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
3771 PREFIX_PRIORITY_LAST, 0, 0);
3774 /* COMPILER_PATH and LIBRARY_PATH have values
3775 that are lists of directory names with colons. */
3777 temp = getenv ("COMPILER_PATH");
3778 if (temp)
3780 const char *startp, *endp;
3781 char *nstore = (char *) alloca (strlen (temp) + 3);
3783 startp = endp = temp;
3784 while (1)
3786 if (*endp == PATH_SEPARATOR || *endp == 0)
3788 strncpy (nstore, startp, endp - startp);
3789 if (endp == startp)
3790 strcpy (nstore, concat (".", dir_separator_str, NULL));
3791 else if (!IS_DIR_SEPARATOR (endp[-1]))
3793 nstore[endp - startp] = DIR_SEPARATOR;
3794 nstore[endp - startp + 1] = 0;
3796 else
3797 nstore[endp - startp] = 0;
3798 add_prefix (&exec_prefixes, nstore, 0,
3799 PREFIX_PRIORITY_LAST, 0, 0);
3800 add_prefix (&include_prefixes, nstore, 0,
3801 PREFIX_PRIORITY_LAST, 0, 0);
3802 if (*endp == 0)
3803 break;
3804 endp = startp = endp + 1;
3806 else
3807 endp++;
3811 temp = getenv (LIBRARY_PATH_ENV);
3812 if (temp && *cross_compile == '0')
3814 const char *startp, *endp;
3815 char *nstore = (char *) alloca (strlen (temp) + 3);
3817 startp = endp = temp;
3818 while (1)
3820 if (*endp == PATH_SEPARATOR || *endp == 0)
3822 strncpy (nstore, startp, endp - startp);
3823 if (endp == startp)
3824 strcpy (nstore, concat (".", dir_separator_str, NULL));
3825 else if (!IS_DIR_SEPARATOR (endp[-1]))
3827 nstore[endp - startp] = DIR_SEPARATOR;
3828 nstore[endp - startp + 1] = 0;
3830 else
3831 nstore[endp - startp] = 0;
3832 add_prefix (&startfile_prefixes, nstore, NULL,
3833 PREFIX_PRIORITY_LAST, 0, 1);
3834 if (*endp == 0)
3835 break;
3836 endp = startp = endp + 1;
3838 else
3839 endp++;
3843 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
3844 temp = getenv ("LPATH");
3845 if (temp && *cross_compile == '0')
3847 const char *startp, *endp;
3848 char *nstore = (char *) alloca (strlen (temp) + 3);
3850 startp = endp = temp;
3851 while (1)
3853 if (*endp == PATH_SEPARATOR || *endp == 0)
3855 strncpy (nstore, startp, endp - startp);
3856 if (endp == startp)
3857 strcpy (nstore, concat (".", dir_separator_str, NULL));
3858 else if (!IS_DIR_SEPARATOR (endp[-1]))
3860 nstore[endp - startp] = DIR_SEPARATOR;
3861 nstore[endp - startp + 1] = 0;
3863 else
3864 nstore[endp - startp] = 0;
3865 add_prefix (&startfile_prefixes, nstore, NULL,
3866 PREFIX_PRIORITY_LAST, 0, 1);
3867 if (*endp == 0)
3868 break;
3869 endp = startp = endp + 1;
3871 else
3872 endp++;
3876 /* Process the options and store input files and switches in their
3877 vectors. */
3879 last_language_n_infiles = -1;
3881 set_option_handlers (&handlers);
3883 for (j = 1; j < decoded_options_count; j++)
3885 switch (decoded_options[j].opt_index)
3887 case OPT_S:
3888 case OPT_c:
3889 case OPT_E:
3890 have_c = 1;
3891 break;
3893 if (have_c)
3894 break;
3897 for (j = 1; j < decoded_options_count; j++)
3899 if (decoded_options[j].opt_index == OPT_SPECIAL_input_file)
3901 const char *arg = decoded_options[j].arg;
3902 const char *p = strrchr (arg, '@');
3903 char *fname;
3904 long offset;
3905 int consumed;
3906 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3907 arg = convert_filename (arg, 0, access (arg, F_OK));
3908 #endif
3909 /* For LTO static archive support we handle input file
3910 specifications that are composed of a filename and
3911 an offset like FNAME@OFFSET. */
3912 if (p
3913 && p != arg
3914 && sscanf (p, "@%li%n", &offset, &consumed) >= 1
3915 && strlen (p) == (unsigned int)consumed)
3917 fname = (char *)xmalloc (p - arg + 1);
3918 memcpy (fname, arg, p - arg);
3919 fname[p - arg] = '\0';
3920 /* Only accept non-stdin and existing FNAME parts, otherwise
3921 try with the full name. */
3922 if (strcmp (fname, "-") == 0 || access (fname, F_OK) < 0)
3924 free (fname);
3925 fname = xstrdup (arg);
3928 else
3929 fname = xstrdup (arg);
3931 if (strcmp (fname, "-") != 0 && access (fname, F_OK) < 0)
3932 perror_with_name (fname);
3933 else
3934 add_infile (arg, spec_lang);
3936 free (fname);
3937 continue;
3940 read_cmdline_option (&global_options, &global_options_set,
3941 decoded_options + j, UNKNOWN_LOCATION,
3942 CL_DRIVER, &handlers, global_dc);
3945 /* If -save-temps=obj and -o name, create the prefix to use for %b.
3946 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
3947 if (save_temps_flag == SAVE_TEMPS_OBJ && save_temps_prefix != NULL)
3949 save_temps_length = strlen (save_temps_prefix);
3950 temp = strrchr (lbasename (save_temps_prefix), '.');
3951 if (temp)
3953 save_temps_length -= strlen (temp);
3954 save_temps_prefix[save_temps_length] = '\0';
3958 else if (save_temps_prefix != NULL)
3960 free (save_temps_prefix);
3961 save_temps_prefix = NULL;
3964 if (save_temps_flag && use_pipes)
3966 /* -save-temps overrides -pipe, so that temp files are produced */
3967 if (save_temps_flag)
3968 warning (0, "-pipe ignored because -save-temps specified");
3969 use_pipes = 0;
3972 if (!compare_debug)
3974 const char *gcd = getenv ("GCC_COMPARE_DEBUG");
3976 if (gcd && gcd[0] == '-')
3978 compare_debug = 2;
3979 compare_debug_opt = gcd;
3981 else if (gcd && *gcd && strcmp (gcd, "0"))
3983 compare_debug = 3;
3984 compare_debug_opt = "-gtoggle";
3987 else if (compare_debug < 0)
3989 compare_debug = 0;
3990 gcc_assert (!compare_debug_opt);
3993 /* Set up the search paths. We add directories that we expect to
3994 contain GNU Toolchain components before directories specified by
3995 the machine description so that we will find GNU components (like
3996 the GNU assembler) before those of the host system. */
3998 /* If we don't know where the toolchain has been installed, use the
3999 configured-in locations. */
4000 if (!gcc_exec_prefix)
4002 #ifndef OS2
4003 add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC",
4004 PREFIX_PRIORITY_LAST, 1, 0);
4005 add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS",
4006 PREFIX_PRIORITY_LAST, 2, 0);
4007 add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
4008 PREFIX_PRIORITY_LAST, 2, 0);
4009 #endif
4010 add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
4011 PREFIX_PRIORITY_LAST, 1, 0);
4014 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix));
4015 tooldir_prefix2 = concat (tooldir_base_prefix, spec_machine,
4016 dir_separator_str, NULL);
4018 /* Look for tools relative to the location from which the driver is
4019 running, or, if that is not available, the configured prefix. */
4020 tooldir_prefix
4021 = concat (gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
4022 spec_machine, dir_separator_str,
4023 spec_version, dir_separator_str, tooldir_prefix2, NULL);
4024 free (tooldir_prefix2);
4026 add_prefix (&exec_prefixes,
4027 concat (tooldir_prefix, "bin", dir_separator_str, NULL),
4028 "BINUTILS", PREFIX_PRIORITY_LAST, 0, 0);
4029 add_prefix (&startfile_prefixes,
4030 concat (tooldir_prefix, "lib", dir_separator_str, NULL),
4031 "BINUTILS", PREFIX_PRIORITY_LAST, 0, 1);
4032 free (tooldir_prefix);
4034 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
4035 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
4036 then consider it to relocate with the rest of the GCC installation
4037 if GCC_EXEC_PREFIX is set.
4038 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
4039 if (target_system_root && !target_system_root_changed && gcc_exec_prefix)
4041 char *tmp_prefix = get_relative_prefix (decoded_options[0].arg,
4042 standard_bindir_prefix,
4043 target_system_root);
4044 if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0)
4046 target_system_root = tmp_prefix;
4047 target_system_root_changed = 1;
4050 #endif
4052 /* More prefixes are enabled in main, after we read the specs file
4053 and determine whether this is cross-compilation or not. */
4055 if (n_infiles == last_language_n_infiles && spec_lang != 0)
4056 warning (0, "%<-x %s%> after last input file has no effect", spec_lang);
4058 /* Synthesize -fcompare-debug flag from the GCC_COMPARE_DEBUG
4059 environment variable. */
4060 if (compare_debug == 2 || compare_debug == 3)
4062 const char *opt = concat ("-fcompare-debug=", compare_debug_opt, NULL);
4063 save_switch (opt, 0, NULL, false, true);
4064 compare_debug = 1;
4067 /* Ensure we only invoke each subprocess once. */
4068 if (print_subprocess_help || print_help_list || print_version)
4070 n_infiles = 0;
4072 /* Create a dummy input file, so that we can pass
4073 the help option on to the various sub-processes. */
4074 add_infile ("help-dummy", "c");
4077 alloc_switch ();
4078 switches[n_switches].part1 = 0;
4079 alloc_infile ();
4080 infiles[n_infiles].name = 0;
4083 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4084 and place that in the environment. */
4086 static void
4087 set_collect_gcc_options (void)
4089 int i;
4090 int first_time;
4092 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4093 the compiler. */
4094 obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
4095 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4097 first_time = TRUE;
4098 for (i = 0; (int) i < n_switches; i++)
4100 const char *const *args;
4101 const char *p, *q;
4102 if (!first_time)
4103 obstack_grow (&collect_obstack, " ", 1);
4105 first_time = FALSE;
4107 /* Ignore elided switches. */
4108 if ((switches[i].live_cond
4109 & (SWITCH_IGNORE | SWITCH_KEEP_FOR_GCC))
4110 == SWITCH_IGNORE)
4111 continue;
4113 obstack_grow (&collect_obstack, "'-", 2);
4114 q = switches[i].part1;
4115 while ((p = strchr (q, '\'')))
4117 obstack_grow (&collect_obstack, q, p - q);
4118 obstack_grow (&collect_obstack, "'\\''", 4);
4119 q = ++p;
4121 obstack_grow (&collect_obstack, q, strlen (q));
4122 obstack_grow (&collect_obstack, "'", 1);
4124 for (args = switches[i].args; args && *args; args++)
4126 obstack_grow (&collect_obstack, " '", 2);
4127 q = *args;
4128 while ((p = strchr (q, '\'')))
4130 obstack_grow (&collect_obstack, q, p - q);
4131 obstack_grow (&collect_obstack, "'\\''", 4);
4132 q = ++p;
4134 obstack_grow (&collect_obstack, q, strlen (q));
4135 obstack_grow (&collect_obstack, "'", 1);
4138 obstack_grow (&collect_obstack, "\0", 1);
4139 xputenv (XOBFINISH (&collect_obstack, char *));
4142 /* Process a spec string, accumulating and running commands. */
4144 /* These variables describe the input file name.
4145 input_file_number is the index on outfiles of this file,
4146 so that the output file name can be stored for later use by %o.
4147 input_basename is the start of the part of the input file
4148 sans all directory names, and basename_length is the number
4149 of characters starting there excluding the suffix .c or whatever. */
4151 static const char *gcc_input_filename;
4152 static int input_file_number;
4153 size_t input_filename_length;
4154 static int basename_length;
4155 static int suffixed_basename_length;
4156 static const char *input_basename;
4157 static const char *input_suffix;
4158 #ifndef HOST_LACKS_INODE_NUMBERS
4159 static struct stat input_stat;
4160 #endif
4161 static int input_stat_set;
4163 /* The compiler used to process the current input file. */
4164 static struct compiler *input_file_compiler;
4166 /* These are variables used within do_spec and do_spec_1. */
4168 /* Nonzero if an arg has been started and not yet terminated
4169 (with space, tab or newline). */
4170 static int arg_going;
4172 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4173 is a temporary file name. */
4174 static int delete_this_arg;
4176 /* Nonzero means %w has been seen; the next arg to be terminated
4177 is the output file name of this compilation. */
4178 static int this_is_output_file;
4180 /* Nonzero means %s has been seen; the next arg to be terminated
4181 is the name of a library file and we should try the standard
4182 search dirs for it. */
4183 static int this_is_library_file;
4185 /* Nonzero means %T has been seen; the next arg to be terminated
4186 is the name of a linker script and we should try all of the
4187 standard search dirs for it. If it is found insert a --script
4188 command line switch and then substitute the full path in place,
4189 otherwise generate an error message. */
4190 static int this_is_linker_script;
4192 /* Nonzero means that the input of this command is coming from a pipe. */
4193 static int input_from_pipe;
4195 /* Nonnull means substitute this for any suffix when outputting a switches
4196 arguments. */
4197 static const char *suffix_subst;
4199 /* If there is an argument being accumulated, terminate it and store it. */
4201 static void
4202 end_going_arg (void)
4204 if (arg_going)
4206 const char *string;
4208 obstack_1grow (&obstack, 0);
4209 string = XOBFINISH (&obstack, const char *);
4210 if (this_is_library_file)
4211 string = find_file (string);
4212 if (this_is_linker_script)
4214 char * full_script_path = find_a_file (&startfile_prefixes, string, R_OK, true);
4216 if (full_script_path == NULL)
4218 error ("unable to locate default linker script %qs in the library search paths", string);
4219 /* Script was not found on search path. */
4220 return;
4222 store_arg ("--script", false, false);
4223 string = full_script_path;
4225 store_arg (string, delete_this_arg, this_is_output_file);
4226 if (this_is_output_file)
4227 outfiles[input_file_number] = string;
4228 arg_going = 0;
4233 /* Parse the WRAPPER string which is a comma separated list of the command line
4234 and insert them into the beginning of argbuf. */
4236 static void
4237 insert_wrapper (const char *wrapper)
4239 int n = 0;
4240 int i;
4241 char *buf = xstrdup (wrapper);
4242 char *p = buf;
4243 unsigned int old_length = argbuf.length ();
4247 n++;
4248 while (*p == ',')
4249 p++;
4251 while ((p = strchr (p, ',')) != NULL);
4253 argbuf.safe_grow (old_length + n);
4254 memmove (argbuf.address () + n,
4255 argbuf.address (),
4256 old_length * sizeof (const_char_p));
4258 i = 0;
4259 p = buf;
4262 while (*p == ',')
4264 *p = 0;
4265 p++;
4267 argbuf[i] = p;
4268 i++;
4270 while ((p = strchr (p, ',')) != NULL);
4271 gcc_assert (i == n);
4274 /* Process the spec SPEC and run the commands specified therein.
4275 Returns 0 if the spec is successfully processed; -1 if failed. */
4278 do_spec (const char *spec)
4280 int value;
4282 value = do_spec_2 (spec);
4284 /* Force out any unfinished command.
4285 If -pipe, this forces out the last command if it ended in `|'. */
4286 if (value == 0)
4288 if (argbuf.length () > 0
4289 && !strcmp (argbuf.last (), "|"))
4290 argbuf.pop ();
4292 set_collect_gcc_options ();
4294 if (argbuf.length () > 0)
4295 value = execute ();
4298 return value;
4301 static int
4302 do_spec_2 (const char *spec)
4304 int result;
4306 clear_args ();
4307 arg_going = 0;
4308 delete_this_arg = 0;
4309 this_is_output_file = 0;
4310 this_is_library_file = 0;
4311 this_is_linker_script = 0;
4312 input_from_pipe = 0;
4313 suffix_subst = NULL;
4315 result = do_spec_1 (spec, 0, NULL);
4317 end_going_arg ();
4319 return result;
4323 /* Process the given spec string and add any new options to the end
4324 of the switches/n_switches array. */
4326 static void
4327 do_option_spec (const char *name, const char *spec)
4329 unsigned int i, value_count, value_len;
4330 const char *p, *q, *value;
4331 char *tmp_spec, *tmp_spec_p;
4333 if (configure_default_options[0].name == NULL)
4334 return;
4336 for (i = 0; i < ARRAY_SIZE (configure_default_options); i++)
4337 if (strcmp (configure_default_options[i].name, name) == 0)
4338 break;
4339 if (i == ARRAY_SIZE (configure_default_options))
4340 return;
4342 value = configure_default_options[i].value;
4343 value_len = strlen (value);
4345 /* Compute the size of the final spec. */
4346 value_count = 0;
4347 p = spec;
4348 while ((p = strstr (p, "%(VALUE)")) != NULL)
4350 p ++;
4351 value_count ++;
4354 /* Replace each %(VALUE) by the specified value. */
4355 tmp_spec = (char *) alloca (strlen (spec) + 1
4356 + value_count * (value_len - strlen ("%(VALUE)")));
4357 tmp_spec_p = tmp_spec;
4358 q = spec;
4359 while ((p = strstr (q, "%(VALUE)")) != NULL)
4361 memcpy (tmp_spec_p, q, p - q);
4362 tmp_spec_p = tmp_spec_p + (p - q);
4363 memcpy (tmp_spec_p, value, value_len);
4364 tmp_spec_p += value_len;
4365 q = p + strlen ("%(VALUE)");
4367 strcpy (tmp_spec_p, q);
4369 do_self_spec (tmp_spec);
4372 /* Process the given spec string and add any new options to the end
4373 of the switches/n_switches array. */
4375 static void
4376 do_self_spec (const char *spec)
4378 int i;
4380 do_spec_2 (spec);
4381 do_spec_1 (" ", 0, NULL);
4383 /* Mark %<S switches processed by do_self_spec to be ignored permanently.
4384 do_self_specs adds the replacements to switches array, so it shouldn't
4385 be processed afterwards. */
4386 for (i = 0; i < n_switches; i++)
4387 if ((switches[i].live_cond & SWITCH_IGNORE))
4388 switches[i].live_cond |= SWITCH_IGNORE_PERMANENTLY;
4390 if (argbuf.length () > 0)
4392 const char **argbuf_copy;
4393 struct cl_decoded_option *decoded_options;
4394 struct cl_option_handlers handlers;
4395 unsigned int decoded_options_count;
4396 unsigned int j;
4398 /* Create a copy of argbuf with a dummy argv[0] entry for
4399 decode_cmdline_options_to_array. */
4400 argbuf_copy = XNEWVEC (const char *,
4401 argbuf.length () + 1);
4402 argbuf_copy[0] = "";
4403 memcpy (argbuf_copy + 1, argbuf.address (),
4404 argbuf.length () * sizeof (const char *));
4406 decode_cmdline_options_to_array (argbuf.length () + 1,
4407 argbuf_copy,
4408 CL_DRIVER, &decoded_options,
4409 &decoded_options_count);
4410 free (argbuf_copy);
4412 set_option_handlers (&handlers);
4414 for (j = 1; j < decoded_options_count; j++)
4416 switch (decoded_options[j].opt_index)
4418 case OPT_SPECIAL_input_file:
4419 /* Specs should only generate options, not input
4420 files. */
4421 if (strcmp (decoded_options[j].arg, "-") != 0)
4422 fatal_error ("switch %qs does not start with %<-%>",
4423 decoded_options[j].arg);
4424 else
4425 fatal_error ("spec-generated switch is just %<-%>");
4426 break;
4428 case OPT_fcompare_debug_second:
4429 case OPT_fcompare_debug:
4430 case OPT_fcompare_debug_:
4431 case OPT_o:
4432 /* Avoid duplicate processing of some options from
4433 compare-debug specs; just save them here. */
4434 save_switch (decoded_options[j].canonical_option[0],
4435 (decoded_options[j].canonical_option_num_elements
4436 - 1),
4437 &decoded_options[j].canonical_option[1], false, true);
4438 break;
4440 default:
4441 read_cmdline_option (&global_options, &global_options_set,
4442 decoded_options + j, UNKNOWN_LOCATION,
4443 CL_DRIVER, &handlers, global_dc);
4444 break;
4448 alloc_switch ();
4449 switches[n_switches].part1 = 0;
4453 /* Callback for processing %D and %I specs. */
4455 struct spec_path_info {
4456 const char *option;
4457 const char *append;
4458 size_t append_len;
4459 bool omit_relative;
4460 bool separate_options;
4463 static void *
4464 spec_path (char *path, void *data)
4466 struct spec_path_info *info = (struct spec_path_info *) data;
4467 size_t len = 0;
4468 char save = 0;
4470 if (info->omit_relative && !IS_ABSOLUTE_PATH (path))
4471 return NULL;
4473 if (info->append_len != 0)
4475 len = strlen (path);
4476 memcpy (path + len, info->append, info->append_len + 1);
4479 if (!is_directory (path, true))
4480 return NULL;
4482 do_spec_1 (info->option, 1, NULL);
4483 if (info->separate_options)
4484 do_spec_1 (" ", 0, NULL);
4486 if (info->append_len == 0)
4488 len = strlen (path);
4489 save = path[len - 1];
4490 if (IS_DIR_SEPARATOR (path[len - 1]))
4491 path[len - 1] = '\0';
4494 do_spec_1 (path, 1, NULL);
4495 do_spec_1 (" ", 0, NULL);
4497 /* Must not damage the original path. */
4498 if (info->append_len == 0)
4499 path[len - 1] = save;
4501 return NULL;
4504 /* Create a temporary FILE with the contents of ARGV. Add @FILE to the
4505 argument list. */
4507 static void
4508 create_at_file (char **argv)
4510 char *temp_file = make_temp_file ("");
4511 char *at_argument = concat ("@", temp_file, NULL);
4512 FILE *f = fopen (temp_file, "w");
4513 int status;
4515 if (f == NULL)
4516 fatal_error ("could not open temporary response file %s",
4517 temp_file);
4519 status = writeargv (argv, f);
4521 if (status)
4522 fatal_error ("could not write to temporary response file %s",
4523 temp_file);
4525 status = fclose (f);
4527 if (EOF == status)
4528 fatal_error ("could not close temporary response file %s",
4529 temp_file);
4531 store_arg (at_argument, 0, 0);
4533 record_temp_file (temp_file, !save_temps_flag, !save_temps_flag);
4536 /* True if we should compile INFILE. */
4538 static bool
4539 compile_input_file_p (struct infile *infile)
4541 if ((!infile->language) || (infile->language[0] != '*'))
4542 if (infile->incompiler == input_file_compiler)
4543 return true;
4544 return false;
4547 /* Process each member of VEC as a spec. */
4549 static void
4550 do_specs_vec (vec<char_p> vec)
4552 unsigned ix;
4553 char *opt;
4555 FOR_EACH_VEC_ELT (vec, ix, opt)
4557 do_spec_1 (opt, 1, NULL);
4558 /* Make each accumulated option a separate argument. */
4559 do_spec_1 (" ", 0, NULL);
4563 /* Process the sub-spec SPEC as a portion of a larger spec.
4564 This is like processing a whole spec except that we do
4565 not initialize at the beginning and we do not supply a
4566 newline by default at the end.
4567 INSWITCH nonzero means don't process %-sequences in SPEC;
4568 in this case, % is treated as an ordinary character.
4569 This is used while substituting switches.
4570 INSWITCH nonzero also causes SPC not to terminate an argument.
4572 Value is zero unless a line was finished
4573 and the command on that line reported an error. */
4575 static int
4576 do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
4578 const char *p = spec;
4579 int c;
4580 int i;
4581 int value;
4583 /* If it's an empty string argument to a switch, keep it as is. */
4584 if (inswitch && !*p)
4585 arg_going = 1;
4587 while ((c = *p++))
4588 /* If substituting a switch, treat all chars like letters.
4589 Otherwise, NL, SPC, TAB and % are special. */
4590 switch (inswitch ? 'a' : c)
4592 case '\n':
4593 end_going_arg ();
4595 if (argbuf.length () > 0
4596 && !strcmp (argbuf.last (), "|"))
4598 /* A `|' before the newline means use a pipe here,
4599 but only if -pipe was specified.
4600 Otherwise, execute now and don't pass the `|' as an arg. */
4601 if (use_pipes)
4603 input_from_pipe = 1;
4604 break;
4606 else
4607 argbuf.pop ();
4610 set_collect_gcc_options ();
4612 if (argbuf.length () > 0)
4614 value = execute ();
4615 if (value)
4616 return value;
4618 /* Reinitialize for a new command, and for a new argument. */
4619 clear_args ();
4620 arg_going = 0;
4621 delete_this_arg = 0;
4622 this_is_output_file = 0;
4623 this_is_library_file = 0;
4624 this_is_linker_script = 0;
4625 input_from_pipe = 0;
4626 break;
4628 case '|':
4629 end_going_arg ();
4631 /* Use pipe */
4632 obstack_1grow (&obstack, c);
4633 arg_going = 1;
4634 break;
4636 case '\t':
4637 case ' ':
4638 end_going_arg ();
4640 /* Reinitialize for a new argument. */
4641 delete_this_arg = 0;
4642 this_is_output_file = 0;
4643 this_is_library_file = 0;
4644 this_is_linker_script = 0;
4645 break;
4647 case '%':
4648 switch (c = *p++)
4650 case 0:
4651 fatal_error ("spec %qs invalid", spec);
4653 case 'b':
4654 if (save_temps_length)
4655 obstack_grow (&obstack, save_temps_prefix, save_temps_length);
4656 else
4657 obstack_grow (&obstack, input_basename, basename_length);
4658 if (compare_debug < 0)
4659 obstack_grow (&obstack, ".gk", 3);
4660 arg_going = 1;
4661 break;
4663 case 'B':
4664 if (save_temps_length)
4665 obstack_grow (&obstack, save_temps_prefix, save_temps_length);
4666 else
4667 obstack_grow (&obstack, input_basename, suffixed_basename_length);
4668 if (compare_debug < 0)
4669 obstack_grow (&obstack, ".gk", 3);
4670 arg_going = 1;
4671 break;
4673 case 'd':
4674 delete_this_arg = 2;
4675 break;
4677 /* Dump out the directories specified with LIBRARY_PATH,
4678 followed by the absolute directories
4679 that we search for startfiles. */
4680 case 'D':
4682 struct spec_path_info info;
4684 info.option = "-L";
4685 info.append_len = 0;
4686 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
4687 /* Used on systems which record the specified -L dirs
4688 and use them to search for dynamic linking.
4689 Relative directories always come from -B,
4690 and it is better not to use them for searching
4691 at run time. In particular, stage1 loses. */
4692 info.omit_relative = true;
4693 #else
4694 info.omit_relative = false;
4695 #endif
4696 info.separate_options = false;
4698 for_each_path (&startfile_prefixes, true, 0, spec_path, &info);
4700 break;
4702 case 'e':
4703 /* %efoo means report an error with `foo' as error message
4704 and don't execute any more commands for this file. */
4706 const char *q = p;
4707 char *buf;
4708 while (*p != 0 && *p != '\n')
4709 p++;
4710 buf = (char *) alloca (p - q + 1);
4711 strncpy (buf, q, p - q);
4712 buf[p - q] = 0;
4713 error ("%s", _(buf));
4714 return -1;
4716 break;
4717 case 'n':
4718 /* %nfoo means report a notice with `foo' on stderr. */
4720 const char *q = p;
4721 char *buf;
4722 while (*p != 0 && *p != '\n')
4723 p++;
4724 buf = (char *) alloca (p - q + 1);
4725 strncpy (buf, q, p - q);
4726 buf[p - q] = 0;
4727 inform (0, "%s", _(buf));
4728 if (*p)
4729 p++;
4731 break;
4733 case 'j':
4735 struct stat st;
4737 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
4738 defined, and it is not a directory, and it is
4739 writable, use it. Otherwise, treat this like any
4740 other temporary file. */
4742 if ((!save_temps_flag)
4743 && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode))
4744 && (access (HOST_BIT_BUCKET, W_OK) == 0))
4746 obstack_grow (&obstack, HOST_BIT_BUCKET,
4747 strlen (HOST_BIT_BUCKET));
4748 delete_this_arg = 0;
4749 arg_going = 1;
4750 break;
4753 goto create_temp_file;
4754 case '|':
4755 if (use_pipes)
4757 obstack_1grow (&obstack, '-');
4758 delete_this_arg = 0;
4759 arg_going = 1;
4761 /* consume suffix */
4762 while (*p == '.' || ISALNUM ((unsigned char) *p))
4763 p++;
4764 if (p[0] == '%' && p[1] == 'O')
4765 p += 2;
4767 break;
4769 goto create_temp_file;
4770 case 'm':
4771 if (use_pipes)
4773 /* consume suffix */
4774 while (*p == '.' || ISALNUM ((unsigned char) *p))
4775 p++;
4776 if (p[0] == '%' && p[1] == 'O')
4777 p += 2;
4779 break;
4781 goto create_temp_file;
4782 case 'g':
4783 case 'u':
4784 case 'U':
4785 create_temp_file:
4787 struct temp_name *t;
4788 int suffix_length;
4789 const char *suffix = p;
4790 char *saved_suffix = NULL;
4792 while (*p == '.' || ISALNUM ((unsigned char) *p))
4793 p++;
4794 suffix_length = p - suffix;
4795 if (p[0] == '%' && p[1] == 'O')
4797 p += 2;
4798 /* We don't support extra suffix characters after %O. */
4799 if (*p == '.' || ISALNUM ((unsigned char) *p))
4800 fatal_error ("spec %qs has invalid %<%%0%c%>", spec, *p);
4801 if (suffix_length == 0)
4802 suffix = TARGET_OBJECT_SUFFIX;
4803 else
4805 saved_suffix
4806 = XNEWVEC (char, suffix_length
4807 + strlen (TARGET_OBJECT_SUFFIX));
4808 strncpy (saved_suffix, suffix, suffix_length);
4809 strcpy (saved_suffix + suffix_length,
4810 TARGET_OBJECT_SUFFIX);
4812 suffix_length += strlen (TARGET_OBJECT_SUFFIX);
4815 if (compare_debug < 0)
4817 suffix = concat (".gk", suffix, NULL);
4818 suffix_length += 3;
4821 /* If -save-temps=obj and -o were specified, use that for the
4822 temp file. */
4823 if (save_temps_length)
4825 char *tmp;
4826 temp_filename_length
4827 = save_temps_length + suffix_length + 1;
4828 tmp = (char *) alloca (temp_filename_length);
4829 memcpy (tmp, save_temps_prefix, save_temps_length);
4830 memcpy (tmp + save_temps_length, suffix, suffix_length);
4831 tmp[save_temps_length + suffix_length] = '\0';
4832 temp_filename = save_string (tmp, save_temps_length
4833 + suffix_length);
4834 obstack_grow (&obstack, temp_filename,
4835 temp_filename_length);
4836 arg_going = 1;
4837 delete_this_arg = 0;
4838 break;
4841 /* If the gcc_input_filename has the same suffix specified
4842 for the %g, %u, or %U, and -save-temps is specified,
4843 we could end up using that file as an intermediate
4844 thus clobbering the user's source file (.e.g.,
4845 gcc -save-temps foo.s would clobber foo.s with the
4846 output of cpp0). So check for this condition and
4847 generate a temp file as the intermediate. */
4849 if (save_temps_flag)
4851 char *tmp;
4852 temp_filename_length = basename_length + suffix_length + 1;
4853 tmp = (char *) alloca (temp_filename_length);
4854 memcpy (tmp, input_basename, basename_length);
4855 memcpy (tmp + basename_length, suffix, suffix_length);
4856 tmp[basename_length + suffix_length] = '\0';
4857 temp_filename = tmp;
4859 if (filename_cmp (temp_filename, gcc_input_filename) != 0)
4861 #ifndef HOST_LACKS_INODE_NUMBERS
4862 struct stat st_temp;
4864 /* Note, set_input() resets input_stat_set to 0. */
4865 if (input_stat_set == 0)
4867 input_stat_set = stat (gcc_input_filename,
4868 &input_stat);
4869 if (input_stat_set >= 0)
4870 input_stat_set = 1;
4873 /* If we have the stat for the gcc_input_filename
4874 and we can do the stat for the temp_filename
4875 then the they could still refer to the same
4876 file if st_dev/st_ino's are the same. */
4877 if (input_stat_set != 1
4878 || stat (temp_filename, &st_temp) < 0
4879 || input_stat.st_dev != st_temp.st_dev
4880 || input_stat.st_ino != st_temp.st_ino)
4881 #else
4882 /* Just compare canonical pathnames. */
4883 char* input_realname = lrealpath (gcc_input_filename);
4884 char* temp_realname = lrealpath (temp_filename);
4885 bool files_differ = filename_cmp (input_realname, temp_realname);
4886 free (input_realname);
4887 free (temp_realname);
4888 if (files_differ)
4889 #endif
4891 temp_filename = save_string (temp_filename,
4892 temp_filename_length + 1);
4893 obstack_grow (&obstack, temp_filename,
4894 temp_filename_length);
4895 arg_going = 1;
4896 delete_this_arg = 0;
4897 break;
4902 /* See if we already have an association of %g/%u/%U and
4903 suffix. */
4904 for (t = temp_names; t; t = t->next)
4905 if (t->length == suffix_length
4906 && strncmp (t->suffix, suffix, suffix_length) == 0
4907 && t->unique == (c == 'u' || c == 'U' || c == 'j'))
4908 break;
4910 /* Make a new association if needed. %u and %j
4911 require one. */
4912 if (t == 0 || c == 'u' || c == 'j')
4914 if (t == 0)
4916 t = XNEW (struct temp_name);
4917 t->next = temp_names;
4918 temp_names = t;
4920 t->length = suffix_length;
4921 if (saved_suffix)
4923 t->suffix = saved_suffix;
4924 saved_suffix = NULL;
4926 else
4927 t->suffix = save_string (suffix, suffix_length);
4928 t->unique = (c == 'u' || c == 'U' || c == 'j');
4929 temp_filename = make_temp_file (t->suffix);
4930 temp_filename_length = strlen (temp_filename);
4931 t->filename = temp_filename;
4932 t->filename_length = temp_filename_length;
4935 free (saved_suffix);
4937 obstack_grow (&obstack, t->filename, t->filename_length);
4938 delete_this_arg = 1;
4940 arg_going = 1;
4941 break;
4943 case 'i':
4944 if (combine_inputs)
4946 if (at_file_supplied)
4948 /* We are going to expand `%i' to `@FILE', where FILE
4949 is a newly-created temporary filename. The filenames
4950 that would usually be expanded in place of %o will be
4951 written to the temporary file. */
4952 char **argv;
4953 int n_files = 0;
4954 int j;
4956 for (i = 0; i < n_infiles; i++)
4957 if (compile_input_file_p (&infiles[i]))
4958 n_files++;
4960 argv = (char **) alloca (sizeof (char *) * (n_files + 1));
4962 /* Copy the strings over. */
4963 for (i = 0, j = 0; i < n_infiles; i++)
4964 if (compile_input_file_p (&infiles[i]))
4966 argv[j] = CONST_CAST (char *, infiles[i].name);
4967 infiles[i].compiled = true;
4968 j++;
4970 argv[j] = NULL;
4972 create_at_file (argv);
4974 else
4975 for (i = 0; (int) i < n_infiles; i++)
4976 if (compile_input_file_p (&infiles[i]))
4978 store_arg (infiles[i].name, 0, 0);
4979 infiles[i].compiled = true;
4982 else
4984 obstack_grow (&obstack, gcc_input_filename,
4985 input_filename_length);
4986 arg_going = 1;
4988 break;
4990 case 'I':
4992 struct spec_path_info info;
4994 if (multilib_dir)
4996 do_spec_1 ("-imultilib", 1, NULL);
4997 /* Make this a separate argument. */
4998 do_spec_1 (" ", 0, NULL);
4999 do_spec_1 (multilib_dir, 1, NULL);
5000 do_spec_1 (" ", 0, NULL);
5003 if (multiarch_dir)
5005 do_spec_1 ("-imultiarch", 1, NULL);
5006 /* Make this a separate argument. */
5007 do_spec_1 (" ", 0, NULL);
5008 do_spec_1 (multiarch_dir, 1, NULL);
5009 do_spec_1 (" ", 0, NULL);
5012 if (gcc_exec_prefix)
5014 do_spec_1 ("-iprefix", 1, NULL);
5015 /* Make this a separate argument. */
5016 do_spec_1 (" ", 0, NULL);
5017 do_spec_1 (gcc_exec_prefix, 1, NULL);
5018 do_spec_1 (" ", 0, NULL);
5021 if (target_system_root_changed ||
5022 (target_system_root && target_sysroot_hdrs_suffix))
5024 do_spec_1 ("-isysroot", 1, NULL);
5025 /* Make this a separate argument. */
5026 do_spec_1 (" ", 0, NULL);
5027 do_spec_1 (target_system_root, 1, NULL);
5028 if (target_sysroot_hdrs_suffix)
5029 do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL);
5030 do_spec_1 (" ", 0, NULL);
5033 info.option = "-isystem";
5034 info.append = "include";
5035 info.append_len = strlen (info.append);
5036 info.omit_relative = false;
5037 info.separate_options = true;
5039 for_each_path (&include_prefixes, false, info.append_len,
5040 spec_path, &info);
5042 info.append = "include-fixed";
5043 if (*sysroot_hdrs_suffix_spec)
5044 info.append = concat (info.append, dir_separator_str,
5045 multilib_dir, NULL);
5046 info.append_len = strlen (info.append);
5047 for_each_path (&include_prefixes, false, info.append_len,
5048 spec_path, &info);
5050 break;
5052 case 'o':
5054 int max = n_infiles;
5055 max += lang_specific_extra_outfiles;
5057 if (HAVE_GNU_LD && at_file_supplied)
5059 /* We are going to expand `%o' to `@FILE', where FILE
5060 is a newly-created temporary filename. The filenames
5061 that would usually be expanded in place of %o will be
5062 written to the temporary file. */
5064 char **argv;
5065 int n_files, j;
5067 /* Convert OUTFILES into a form suitable for writeargv. */
5069 /* Determine how many are non-NULL. */
5070 for (n_files = 0, i = 0; i < max; i++)
5071 n_files += outfiles[i] != NULL;
5073 argv = (char **) alloca (sizeof (char *) * (n_files + 1));
5075 /* Copy the strings over. */
5076 for (i = 0, j = 0; i < max; i++)
5077 if (outfiles[i])
5079 argv[j] = CONST_CAST (char *, outfiles[i]);
5080 j++;
5082 argv[j] = NULL;
5084 create_at_file (argv);
5086 else
5087 for (i = 0; i < max; i++)
5088 if (outfiles[i])
5089 store_arg (outfiles[i], 0, 0);
5090 break;
5093 case 'O':
5094 obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
5095 arg_going = 1;
5096 break;
5098 case 's':
5099 this_is_library_file = 1;
5100 break;
5102 case 'T':
5103 this_is_linker_script = 1;
5104 break;
5106 case 'V':
5107 outfiles[input_file_number] = NULL;
5108 break;
5110 case 'w':
5111 this_is_output_file = 1;
5112 break;
5114 case 'W':
5116 unsigned int cur_index = argbuf.length ();
5117 /* Handle the {...} following the %W. */
5118 if (*p != '{')
5119 fatal_error ("spec %qs has invalid %<%%W%c%>", spec, *p);
5120 p = handle_braces (p + 1);
5121 if (p == 0)
5122 return -1;
5123 end_going_arg ();
5124 /* If any args were output, mark the last one for deletion
5125 on failure. */
5126 if (argbuf.length () != cur_index)
5127 record_temp_file (argbuf.last (), 0, 1);
5128 break;
5131 /* %x{OPTION} records OPTION for %X to output. */
5132 case 'x':
5134 const char *p1 = p;
5135 char *string;
5136 char *opt;
5137 unsigned ix;
5139 /* Skip past the option value and make a copy. */
5140 if (*p != '{')
5141 fatal_error ("spec %qs has invalid %<%%x%c%>", spec, *p);
5142 while (*p++ != '}')
5144 string = save_string (p1 + 1, p - p1 - 2);
5146 /* See if we already recorded this option. */
5147 FOR_EACH_VEC_ELT (linker_options, ix, opt)
5148 if (! strcmp (string, opt))
5150 free (string);
5151 return 0;
5154 /* This option is new; add it. */
5155 add_linker_option (string, strlen (string));
5156 free (string);
5158 break;
5160 /* Dump out the options accumulated previously using %x. */
5161 case 'X':
5162 do_specs_vec (linker_options);
5163 break;
5165 /* Dump out the options accumulated previously using -Wa,. */
5166 case 'Y':
5167 do_specs_vec (assembler_options);
5168 break;
5170 /* Dump out the options accumulated previously using -Wp,. */
5171 case 'Z':
5172 do_specs_vec (preprocessor_options);
5173 break;
5175 /* Here are digits and numbers that just process
5176 a certain constant string as a spec. */
5178 case '1':
5179 value = do_spec_1 (cc1_spec, 0, NULL);
5180 if (value != 0)
5181 return value;
5182 break;
5184 case '2':
5185 value = do_spec_1 (cc1plus_spec, 0, NULL);
5186 if (value != 0)
5187 return value;
5188 break;
5190 case 'a':
5191 value = do_spec_1 (asm_spec, 0, NULL);
5192 if (value != 0)
5193 return value;
5194 break;
5196 case 'A':
5197 value = do_spec_1 (asm_final_spec, 0, NULL);
5198 if (value != 0)
5199 return value;
5200 break;
5202 case 'C':
5204 const char *const spec
5205 = (input_file_compiler->cpp_spec
5206 ? input_file_compiler->cpp_spec
5207 : cpp_spec);
5208 value = do_spec_1 (spec, 0, NULL);
5209 if (value != 0)
5210 return value;
5212 break;
5214 case 'E':
5215 value = do_spec_1 (endfile_spec, 0, NULL);
5216 if (value != 0)
5217 return value;
5218 break;
5220 case 'l':
5221 value = do_spec_1 (link_spec, 0, NULL);
5222 if (value != 0)
5223 return value;
5224 break;
5226 case 'L':
5227 value = do_spec_1 (lib_spec, 0, NULL);
5228 if (value != 0)
5229 return value;
5230 break;
5232 case 'M':
5233 if (multilib_os_dir == NULL)
5234 obstack_1grow (&obstack, '.');
5235 else
5236 obstack_grow (&obstack, multilib_os_dir,
5237 strlen (multilib_os_dir));
5238 break;
5240 case 'G':
5241 value = do_spec_1 (libgcc_spec, 0, NULL);
5242 if (value != 0)
5243 return value;
5244 break;
5246 case 'R':
5247 /* We assume there is a directory
5248 separator at the end of this string. */
5249 if (target_system_root)
5251 obstack_grow (&obstack, target_system_root,
5252 strlen (target_system_root));
5253 if (target_sysroot_suffix)
5254 obstack_grow (&obstack, target_sysroot_suffix,
5255 strlen (target_sysroot_suffix));
5257 break;
5259 case 'S':
5260 value = do_spec_1 (startfile_spec, 0, NULL);
5261 if (value != 0)
5262 return value;
5263 break;
5265 /* Here we define characters other than letters and digits. */
5267 case '{':
5268 p = handle_braces (p);
5269 if (p == 0)
5270 return -1;
5271 break;
5273 case ':':
5274 p = handle_spec_function (p);
5275 if (p == 0)
5276 return -1;
5277 break;
5279 case '%':
5280 obstack_1grow (&obstack, '%');
5281 break;
5283 case '.':
5285 unsigned len = 0;
5287 while (p[len] && p[len] != ' ' && p[len] != '%')
5288 len++;
5289 suffix_subst = save_string (p - 1, len + 1);
5290 p += len;
5292 break;
5294 /* Henceforth ignore the option(s) matching the pattern
5295 after the %<. */
5296 case '<':
5297 case '>':
5299 unsigned len = 0;
5300 int have_wildcard = 0;
5301 int i;
5302 int switch_option;
5304 if (c == '>')
5305 switch_option = SWITCH_IGNORE | SWITCH_KEEP_FOR_GCC;
5306 else
5307 switch_option = SWITCH_IGNORE;
5309 while (p[len] && p[len] != ' ' && p[len] != '\t')
5310 len++;
5312 if (p[len-1] == '*')
5313 have_wildcard = 1;
5315 for (i = 0; i < n_switches; i++)
5316 if (!strncmp (switches[i].part1, p, len - have_wildcard)
5317 && (have_wildcard || switches[i].part1[len] == '\0'))
5319 switches[i].live_cond |= switch_option;
5320 /* User switch be validated from validate_all_switches.
5321 when the definition is seen from the spec file.
5322 If not defined anywhere, will be rejected. */
5323 if (switches[i].known)
5324 switches[i].validated = true;
5327 p += len;
5329 break;
5331 case '*':
5332 if (soft_matched_part)
5334 if (soft_matched_part[0])
5335 do_spec_1 (soft_matched_part, 1, NULL);
5336 do_spec_1 (" ", 0, NULL);
5338 else
5339 /* Catch the case where a spec string contains something like
5340 '%{foo:%*}'. i.e. there is no * in the pattern on the left
5341 hand side of the :. */
5342 error ("spec failure: %<%%*%> has not been initialized by pattern match");
5343 break;
5345 /* Process a string found as the value of a spec given by name.
5346 This feature allows individual machine descriptions
5347 to add and use their own specs. */
5348 case '(':
5350 const char *name = p;
5351 struct spec_list *sl;
5352 int len;
5354 /* The string after the S/P is the name of a spec that is to be
5355 processed. */
5356 while (*p && *p != ')')
5357 p++;
5359 /* See if it's in the list. */
5360 for (len = p - name, sl = specs; sl; sl = sl->next)
5361 if (sl->name_len == len && !strncmp (sl->name, name, len))
5363 name = *(sl->ptr_spec);
5364 #ifdef DEBUG_SPECS
5365 fnotice (stderr, "Processing spec (%s), which is '%s'\n",
5366 sl->name, name);
5367 #endif
5368 break;
5371 if (sl)
5373 value = do_spec_1 (name, 0, NULL);
5374 if (value != 0)
5375 return value;
5378 /* Discard the closing paren. */
5379 if (*p)
5380 p++;
5382 break;
5384 default:
5385 error ("spec failure: unrecognized spec option %qc", c);
5386 break;
5388 break;
5390 case '\\':
5391 /* Backslash: treat next character as ordinary. */
5392 c = *p++;
5394 /* Fall through. */
5395 default:
5396 /* Ordinary character: put it into the current argument. */
5397 obstack_1grow (&obstack, c);
5398 arg_going = 1;
5401 /* End of string. If we are processing a spec function, we need to
5402 end any pending argument. */
5403 if (processing_spec_function)
5404 end_going_arg ();
5406 return 0;
5409 /* Look up a spec function. */
5411 static const struct spec_function *
5412 lookup_spec_function (const char *name)
5414 const struct spec_function *sf;
5416 for (sf = static_spec_functions; sf->name != NULL; sf++)
5417 if (strcmp (sf->name, name) == 0)
5418 return sf;
5420 return NULL;
5423 /* Evaluate a spec function. */
5425 static const char *
5426 eval_spec_function (const char *func, const char *args)
5428 const struct spec_function *sf;
5429 const char *funcval;
5431 /* Saved spec processing context. */
5432 vec<const_char_p> save_argbuf;
5434 int save_arg_going;
5435 int save_delete_this_arg;
5436 int save_this_is_output_file;
5437 int save_this_is_library_file;
5438 int save_input_from_pipe;
5439 int save_this_is_linker_script;
5440 const char *save_suffix_subst;
5442 int save_growing_size;
5443 void *save_growing_value;
5445 sf = lookup_spec_function (func);
5446 if (sf == NULL)
5447 fatal_error ("unknown spec function %qs", func);
5449 /* Push the spec processing context. */
5450 save_argbuf = argbuf;
5452 save_arg_going = arg_going;
5453 save_delete_this_arg = delete_this_arg;
5454 save_this_is_output_file = this_is_output_file;
5455 save_this_is_library_file = this_is_library_file;
5456 save_this_is_linker_script = this_is_linker_script;
5457 save_input_from_pipe = input_from_pipe;
5458 save_suffix_subst = suffix_subst;
5460 /* If we have some object growing now, finalize it so the args and function
5461 eval proceed from a cleared context. This is needed to prevent the first
5462 constructed arg from mistakenly including the growing value. We'll push
5463 this value back on the obstack once the function evaluation is done, to
5464 restore a consistent processing context for our caller. This is fine as
5465 the address of growing objects isn't guaranteed to remain stable until
5466 they are finalized, and we expect this situation to be rare enough for
5467 the extra copy not to be an issue. */
5468 save_growing_size = obstack_object_size (&obstack);
5469 if (save_growing_size > 0)
5470 save_growing_value = obstack_finish (&obstack);
5472 /* Create a new spec processing context, and build the function
5473 arguments. */
5475 alloc_args ();
5476 if (do_spec_2 (args) < 0)
5477 fatal_error ("error in args to spec function %qs", func);
5479 /* argbuf_index is an index for the next argument to be inserted, and
5480 so contains the count of the args already inserted. */
5482 funcval = (*sf->func) (argbuf.length (),
5483 argbuf.address ());
5485 /* Pop the spec processing context. */
5486 argbuf.release ();
5487 argbuf = save_argbuf;
5489 arg_going = save_arg_going;
5490 delete_this_arg = save_delete_this_arg;
5491 this_is_output_file = save_this_is_output_file;
5492 this_is_library_file = save_this_is_library_file;
5493 this_is_linker_script = save_this_is_linker_script;
5494 input_from_pipe = save_input_from_pipe;
5495 suffix_subst = save_suffix_subst;
5497 if (save_growing_size > 0)
5498 obstack_grow (&obstack, save_growing_value, save_growing_size);
5500 return funcval;
5503 /* Handle a spec function call of the form:
5505 %:function(args)
5507 ARGS is processed as a spec in a separate context and split into an
5508 argument vector in the normal fashion. The function returns a string
5509 containing a spec which we then process in the caller's context, or
5510 NULL if no processing is required. */
5512 static const char *
5513 handle_spec_function (const char *p)
5515 char *func, *args;
5516 const char *endp, *funcval;
5517 int count;
5519 processing_spec_function++;
5521 /* Get the function name. */
5522 for (endp = p; *endp != '\0'; endp++)
5524 if (*endp == '(') /* ) */
5525 break;
5526 /* Only allow [A-Za-z0-9], -, and _ in function names. */
5527 if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_'))
5528 fatal_error ("malformed spec function name");
5530 if (*endp != '(') /* ) */
5531 fatal_error ("no arguments for spec function");
5532 func = save_string (p, endp - p);
5533 p = ++endp;
5535 /* Get the arguments. */
5536 for (count = 0; *endp != '\0'; endp++)
5538 /* ( */
5539 if (*endp == ')')
5541 if (count == 0)
5542 break;
5543 count--;
5545 else if (*endp == '(') /* ) */
5546 count++;
5548 /* ( */
5549 if (*endp != ')')
5550 fatal_error ("malformed spec function arguments");
5551 args = save_string (p, endp - p);
5552 p = ++endp;
5554 /* p now points to just past the end of the spec function expression. */
5556 funcval = eval_spec_function (func, args);
5557 if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0)
5558 p = NULL;
5560 free (func);
5561 free (args);
5563 processing_spec_function--;
5565 return p;
5568 /* Inline subroutine of handle_braces. Returns true if the current
5569 input suffix matches the atom bracketed by ATOM and END_ATOM. */
5570 static inline bool
5571 input_suffix_matches (const char *atom, const char *end_atom)
5573 return (input_suffix
5574 && !strncmp (input_suffix, atom, end_atom - atom)
5575 && input_suffix[end_atom - atom] == '\0');
5578 /* Subroutine of handle_braces. Returns true if the current
5579 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
5580 static bool
5581 input_spec_matches (const char *atom, const char *end_atom)
5583 return (input_file_compiler
5584 && input_file_compiler->suffix
5585 && input_file_compiler->suffix[0] != '\0'
5586 && !strncmp (input_file_compiler->suffix + 1, atom,
5587 end_atom - atom)
5588 && input_file_compiler->suffix[end_atom - atom + 1] == '\0');
5591 /* Subroutine of handle_braces. Returns true if a switch
5592 matching the atom bracketed by ATOM and END_ATOM appeared on the
5593 command line. */
5594 static bool
5595 switch_matches (const char *atom, const char *end_atom, int starred)
5597 int i;
5598 int len = end_atom - atom;
5599 int plen = starred ? len : -1;
5601 for (i = 0; i < n_switches; i++)
5602 if (!strncmp (switches[i].part1, atom, len)
5603 && (starred || switches[i].part1[len] == '\0')
5604 && check_live_switch (i, plen))
5605 return true;
5607 /* Check if a switch with separated form matching the atom.
5608 We check -D and -U switches. */
5609 else if (switches[i].args != 0)
5611 if ((*switches[i].part1 == 'D' || *switches[i].part1 == 'U')
5612 && *switches[i].part1 == atom[0])
5614 if (!strncmp (switches[i].args[0], &atom[1], len - 1)
5615 && (starred || (switches[i].part1[1] == '\0'
5616 && switches[i].args[0][len - 1] == '\0'))
5617 && check_live_switch (i, (starred ? 1 : -1)))
5618 return true;
5622 return false;
5625 /* Inline subroutine of handle_braces. Mark all of the switches which
5626 match ATOM (extends to END_ATOM; STARRED indicates whether there
5627 was a star after the atom) for later processing. */
5628 static inline void
5629 mark_matching_switches (const char *atom, const char *end_atom, int starred)
5631 int i;
5632 int len = end_atom - atom;
5633 int plen = starred ? len : -1;
5635 for (i = 0; i < n_switches; i++)
5636 if (!strncmp (switches[i].part1, atom, len)
5637 && (starred || switches[i].part1[len] == '\0')
5638 && check_live_switch (i, plen))
5639 switches[i].ordering = 1;
5642 /* Inline subroutine of handle_braces. Process all the currently
5643 marked switches through give_switch, and clear the marks. */
5644 static inline void
5645 process_marked_switches (void)
5647 int i;
5649 for (i = 0; i < n_switches; i++)
5650 if (switches[i].ordering == 1)
5652 switches[i].ordering = 0;
5653 give_switch (i, 0);
5657 /* Handle a %{ ... } construct. P points just inside the leading {.
5658 Returns a pointer one past the end of the brace block, or 0
5659 if we call do_spec_1 and that returns -1. */
5661 static const char *
5662 handle_braces (const char *p)
5664 const char *atom, *end_atom;
5665 const char *d_atom = NULL, *d_end_atom = NULL;
5666 const char *orig = p;
5668 bool a_is_suffix;
5669 bool a_is_spectype;
5670 bool a_is_starred;
5671 bool a_is_negated;
5672 bool a_matched;
5674 bool a_must_be_last = false;
5675 bool ordered_set = false;
5676 bool disjunct_set = false;
5677 bool disj_matched = false;
5678 bool disj_starred = true;
5679 bool n_way_choice = false;
5680 bool n_way_matched = false;
5682 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
5686 if (a_must_be_last)
5687 goto invalid;
5689 /* Scan one "atom" (S in the description above of %{}, possibly
5690 with '!', '.', '@', ',', or '*' modifiers). */
5691 a_matched = false;
5692 a_is_suffix = false;
5693 a_is_starred = false;
5694 a_is_negated = false;
5695 a_is_spectype = false;
5697 SKIP_WHITE();
5698 if (*p == '!')
5699 p++, a_is_negated = true;
5701 SKIP_WHITE();
5702 if (*p == '.')
5703 p++, a_is_suffix = true;
5704 else if (*p == ',')
5705 p++, a_is_spectype = true;
5707 atom = p;
5708 while (ISIDNUM(*p) || *p == '-' || *p == '+' || *p == '='
5709 || *p == ',' || *p == '.' || *p == '@')
5710 p++;
5711 end_atom = p;
5713 if (*p == '*')
5714 p++, a_is_starred = 1;
5716 SKIP_WHITE();
5717 switch (*p)
5719 case '&': case '}':
5720 /* Substitute the switch(es) indicated by the current atom. */
5721 ordered_set = true;
5722 if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix
5723 || a_is_spectype || atom == end_atom)
5724 goto invalid;
5726 mark_matching_switches (atom, end_atom, a_is_starred);
5728 if (*p == '}')
5729 process_marked_switches ();
5730 break;
5732 case '|': case ':':
5733 /* Substitute some text if the current atom appears as a switch
5734 or suffix. */
5735 disjunct_set = true;
5736 if (ordered_set)
5737 goto invalid;
5739 if (atom == end_atom)
5741 if (!n_way_choice || disj_matched || *p == '|'
5742 || a_is_negated || a_is_suffix || a_is_spectype
5743 || a_is_starred)
5744 goto invalid;
5746 /* An empty term may appear as the last choice of an
5747 N-way choice set; it means "otherwise". */
5748 a_must_be_last = true;
5749 disj_matched = !n_way_matched;
5750 disj_starred = false;
5752 else
5754 if ((a_is_suffix || a_is_spectype) && a_is_starred)
5755 goto invalid;
5757 if (!a_is_starred)
5758 disj_starred = false;
5760 /* Don't bother testing this atom if we already have a
5761 match. */
5762 if (!disj_matched && !n_way_matched)
5764 if (a_is_suffix)
5765 a_matched = input_suffix_matches (atom, end_atom);
5766 else if (a_is_spectype)
5767 a_matched = input_spec_matches (atom, end_atom);
5768 else
5769 a_matched = switch_matches (atom, end_atom, a_is_starred);
5771 if (a_matched != a_is_negated)
5773 disj_matched = true;
5774 d_atom = atom;
5775 d_end_atom = end_atom;
5780 if (*p == ':')
5782 /* Found the body, that is, the text to substitute if the
5783 current disjunction matches. */
5784 p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred,
5785 disj_matched && !n_way_matched);
5786 if (p == 0)
5787 return 0;
5789 /* If we have an N-way choice, reset state for the next
5790 disjunction. */
5791 if (*p == ';')
5793 n_way_choice = true;
5794 n_way_matched |= disj_matched;
5795 disj_matched = false;
5796 disj_starred = true;
5797 d_atom = d_end_atom = NULL;
5800 break;
5802 default:
5803 goto invalid;
5806 while (*p++ != '}');
5808 return p;
5810 invalid:
5811 fatal_error ("braced spec %qs is invalid at %qc", orig, *p);
5813 #undef SKIP_WHITE
5816 /* Subroutine of handle_braces. Scan and process a brace substitution body
5817 (X in the description of %{} syntax). P points one past the colon;
5818 ATOM and END_ATOM bracket the first atom which was found to be true
5819 (present) in the current disjunction; STARRED indicates whether all
5820 the atoms in the current disjunction were starred (for syntax validation);
5821 MATCHED indicates whether the disjunction matched or not, and therefore
5822 whether or not the body is to be processed through do_spec_1 or just
5823 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
5824 returns -1. */
5826 static const char *
5827 process_brace_body (const char *p, const char *atom, const char *end_atom,
5828 int starred, int matched)
5830 const char *body, *end_body;
5831 unsigned int nesting_level;
5832 bool have_subst = false;
5834 /* Locate the closing } or ;, honoring nested braces.
5835 Trim trailing whitespace. */
5836 body = p;
5837 nesting_level = 1;
5838 for (;;)
5840 if (*p == '{')
5841 nesting_level++;
5842 else if (*p == '}')
5844 if (!--nesting_level)
5845 break;
5847 else if (*p == ';' && nesting_level == 1)
5848 break;
5849 else if (*p == '%' && p[1] == '*' && nesting_level == 1)
5850 have_subst = true;
5851 else if (*p == '\0')
5852 goto invalid;
5853 p++;
5856 end_body = p;
5857 while (end_body[-1] == ' ' || end_body[-1] == '\t')
5858 end_body--;
5860 if (have_subst && !starred)
5861 goto invalid;
5863 if (matched)
5865 /* Copy the substitution body to permanent storage and execute it.
5866 If have_subst is false, this is a simple matter of running the
5867 body through do_spec_1... */
5868 char *string = save_string (body, end_body - body);
5869 if (!have_subst)
5871 if (do_spec_1 (string, 0, NULL) < 0)
5872 return 0;
5874 else
5876 /* ... but if have_subst is true, we have to process the
5877 body once for each matching switch, with %* set to the
5878 variant part of the switch. */
5879 unsigned int hard_match_len = end_atom - atom;
5880 int i;
5882 for (i = 0; i < n_switches; i++)
5883 if (!strncmp (switches[i].part1, atom, hard_match_len)
5884 && check_live_switch (i, hard_match_len))
5886 if (do_spec_1 (string, 0,
5887 &switches[i].part1[hard_match_len]) < 0)
5888 return 0;
5889 /* Pass any arguments this switch has. */
5890 give_switch (i, 1);
5891 suffix_subst = NULL;
5896 return p;
5898 invalid:
5899 fatal_error ("braced spec body %qs is invalid", body);
5902 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
5903 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
5904 spec, or -1 if either exact match or %* is used.
5906 A -O switch is obsoleted by a later -O switch. A -f, -g, -m, or -W switch
5907 whose value does not begin with "no-" is obsoleted by the same value
5908 with the "no-", similarly for a switch with the "no-" prefix. */
5910 static int
5911 check_live_switch (int switchnum, int prefix_length)
5913 const char *name = switches[switchnum].part1;
5914 int i;
5916 /* If we already processed this switch and determined if it was
5917 live or not, return our past determination. */
5918 if (switches[switchnum].live_cond != 0)
5919 return ((switches[switchnum].live_cond & SWITCH_LIVE) != 0
5920 && (switches[switchnum].live_cond & SWITCH_FALSE) == 0
5921 && (switches[switchnum].live_cond & SWITCH_IGNORE_PERMANENTLY)
5922 == 0);
5924 /* In the common case of {<at-most-one-letter>*}, a negating
5925 switch would always match, so ignore that case. We will just
5926 send the conflicting switches to the compiler phase. */
5927 if (prefix_length >= 0 && prefix_length <= 1)
5928 return 1;
5930 /* Now search for duplicate in a manner that depends on the name. */
5931 switch (*name)
5933 case 'O':
5934 for (i = switchnum + 1; i < n_switches; i++)
5935 if (switches[i].part1[0] == 'O')
5937 switches[switchnum].validated = true;
5938 switches[switchnum].live_cond = SWITCH_FALSE;
5939 return 0;
5941 break;
5943 case 'W': case 'f': case 'm': case 'g':
5944 if (! strncmp (name + 1, "no-", 3))
5946 /* We have Xno-YYY, search for XYYY. */
5947 for (i = switchnum + 1; i < n_switches; i++)
5948 if (switches[i].part1[0] == name[0]
5949 && ! strcmp (&switches[i].part1[1], &name[4]))
5951 /* --specs are validated with the validate_switches mechanism. */
5952 if (switches[switchnum].known)
5953 switches[switchnum].validated = true;
5954 switches[switchnum].live_cond = SWITCH_FALSE;
5955 return 0;
5958 else
5960 /* We have XYYY, search for Xno-YYY. */
5961 for (i = switchnum + 1; i < n_switches; i++)
5962 if (switches[i].part1[0] == name[0]
5963 && switches[i].part1[1] == 'n'
5964 && switches[i].part1[2] == 'o'
5965 && switches[i].part1[3] == '-'
5966 && !strcmp (&switches[i].part1[4], &name[1]))
5968 /* --specs are validated with the validate_switches mechanism. */
5969 if (switches[switchnum].known)
5970 switches[switchnum].validated = true;
5971 switches[switchnum].live_cond = SWITCH_FALSE;
5972 return 0;
5975 break;
5978 /* Otherwise the switch is live. */
5979 switches[switchnum].live_cond |= SWITCH_LIVE;
5980 return 1;
5983 /* Pass a switch to the current accumulating command
5984 in the same form that we received it.
5985 SWITCHNUM identifies the switch; it is an index into
5986 the vector of switches gcc received, which is `switches'.
5987 This cannot fail since it never finishes a command line.
5989 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
5991 static void
5992 give_switch (int switchnum, int omit_first_word)
5994 if ((switches[switchnum].live_cond & SWITCH_IGNORE) != 0)
5995 return;
5997 if (!omit_first_word)
5999 do_spec_1 ("-", 0, NULL);
6000 do_spec_1 (switches[switchnum].part1, 1, NULL);
6003 if (switches[switchnum].args != 0)
6005 const char **p;
6006 for (p = switches[switchnum].args; *p; p++)
6008 const char *arg = *p;
6010 do_spec_1 (" ", 0, NULL);
6011 if (suffix_subst)
6013 unsigned length = strlen (arg);
6014 int dot = 0;
6016 while (length-- && !IS_DIR_SEPARATOR (arg[length]))
6017 if (arg[length] == '.')
6019 (CONST_CAST(char *, arg))[length] = 0;
6020 dot = 1;
6021 break;
6023 do_spec_1 (arg, 1, NULL);
6024 if (dot)
6025 (CONST_CAST(char *, arg))[length] = '.';
6026 do_spec_1 (suffix_subst, 1, NULL);
6028 else
6029 do_spec_1 (arg, 1, NULL);
6033 do_spec_1 (" ", 0, NULL);
6034 switches[switchnum].validated = true;
6037 /* Search for a file named NAME trying various prefixes including the
6038 user's -B prefix and some standard ones.
6039 Return the absolute file name found. If nothing is found, return NAME. */
6041 static const char *
6042 find_file (const char *name)
6044 char *newname = find_a_file (&startfile_prefixes, name, R_OK, true);
6045 return newname ? newname : name;
6048 /* Determine whether a directory exists. If LINKER, return 0 for
6049 certain fixed names not needed by the linker. */
6051 static int
6052 is_directory (const char *path1, bool linker)
6054 int len1;
6055 char *path;
6056 char *cp;
6057 struct stat st;
6059 /* Ensure the string ends with "/.". The resulting path will be a
6060 directory even if the given path is a symbolic link. */
6061 len1 = strlen (path1);
6062 path = (char *) alloca (3 + len1);
6063 memcpy (path, path1, len1);
6064 cp = path + len1;
6065 if (!IS_DIR_SEPARATOR (cp[-1]))
6066 *cp++ = DIR_SEPARATOR;
6067 *cp++ = '.';
6068 *cp = '\0';
6070 /* Exclude directories that the linker is known to search. */
6071 if (linker
6072 && IS_DIR_SEPARATOR (path[0])
6073 && ((cp - path == 6
6074 && filename_ncmp (path + 1, "lib", 3) == 0)
6075 || (cp - path == 10
6076 && filename_ncmp (path + 1, "usr", 3) == 0
6077 && IS_DIR_SEPARATOR (path[4])
6078 && filename_ncmp (path + 5, "lib", 3) == 0)))
6079 return 0;
6081 return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
6084 /* Set up the various global variables to indicate that we're processing
6085 the input file named FILENAME. */
6087 void
6088 set_input (const char *filename)
6090 const char *p;
6092 gcc_input_filename = filename;
6093 input_filename_length = strlen (gcc_input_filename);
6094 input_basename = lbasename (gcc_input_filename);
6096 /* Find a suffix starting with the last period,
6097 and set basename_length to exclude that suffix. */
6098 basename_length = strlen (input_basename);
6099 suffixed_basename_length = basename_length;
6100 p = input_basename + basename_length;
6101 while (p != input_basename && *p != '.')
6102 --p;
6103 if (*p == '.' && p != input_basename)
6105 basename_length = p - input_basename;
6106 input_suffix = p + 1;
6108 else
6109 input_suffix = "";
6111 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
6112 we will need to do a stat on the gcc_input_filename. The
6113 INPUT_STAT_SET signals that the stat is needed. */
6114 input_stat_set = 0;
6117 /* On fatal signals, delete all the temporary files. */
6119 static void
6120 fatal_signal (int signum)
6122 signal (signum, SIG_DFL);
6123 delete_failure_queue ();
6124 delete_temp_files ();
6125 /* Get the same signal again, this time not handled,
6126 so its normal effect occurs. */
6127 kill (getpid (), signum);
6130 /* Compare the contents of the two files named CMPFILE[0] and
6131 CMPFILE[1]. Return zero if they're identical, nonzero
6132 otherwise. */
6134 static int
6135 compare_files (char *cmpfile[])
6137 int ret = 0;
6138 FILE *temp[2] = { NULL, NULL };
6139 int i;
6141 #if HAVE_MMAP_FILE
6143 size_t length[2];
6144 void *map[2] = { NULL, NULL };
6146 for (i = 0; i < 2; i++)
6148 struct stat st;
6150 if (stat (cmpfile[i], &st) < 0 || !S_ISREG (st.st_mode))
6152 error ("%s: could not determine length of compare-debug file %s",
6153 gcc_input_filename, cmpfile[i]);
6154 ret = 1;
6155 break;
6158 length[i] = st.st_size;
6161 if (!ret && length[0] != length[1])
6163 error ("%s: -fcompare-debug failure (length)", gcc_input_filename);
6164 ret = 1;
6167 if (!ret)
6168 for (i = 0; i < 2; i++)
6170 int fd = open (cmpfile[i], O_RDONLY);
6171 if (fd < 0)
6173 error ("%s: could not open compare-debug file %s",
6174 gcc_input_filename, cmpfile[i]);
6175 ret = 1;
6176 break;
6179 map[i] = mmap (NULL, length[i], PROT_READ, MAP_PRIVATE, fd, 0);
6180 close (fd);
6182 if (map[i] == (void *) MAP_FAILED)
6184 ret = -1;
6185 break;
6189 if (!ret)
6191 if (memcmp (map[0], map[1], length[0]) != 0)
6193 error ("%s: -fcompare-debug failure", gcc_input_filename);
6194 ret = 1;
6198 for (i = 0; i < 2; i++)
6199 if (map[i])
6200 munmap ((caddr_t) map[i], length[i]);
6202 if (ret >= 0)
6203 return ret;
6205 ret = 0;
6207 #endif
6209 for (i = 0; i < 2; i++)
6211 temp[i] = fopen (cmpfile[i], "r");
6212 if (!temp[i])
6214 error ("%s: could not open compare-debug file %s",
6215 gcc_input_filename, cmpfile[i]);
6216 ret = 1;
6217 break;
6221 if (!ret && temp[0] && temp[1])
6222 for (;;)
6224 int c0, c1;
6225 c0 = fgetc (temp[0]);
6226 c1 = fgetc (temp[1]);
6228 if (c0 != c1)
6230 error ("%s: -fcompare-debug failure",
6231 gcc_input_filename);
6232 ret = 1;
6233 break;
6236 if (c0 == EOF)
6237 break;
6240 for (i = 1; i >= 0; i--)
6242 if (temp[i])
6243 fclose (temp[i]);
6246 return ret;
6249 extern int main (int, char **);
6252 main (int argc, char **argv)
6254 size_t i;
6255 int value;
6256 int linker_was_run = 0;
6257 int lang_n_infiles = 0;
6258 int num_linker_inputs = 0;
6259 char *explicit_link_files;
6260 char *specs_file;
6261 char *lto_wrapper_file;
6262 const char *p;
6263 struct user_specs *uptr;
6264 char **old_argv = argv;
6265 struct cl_decoded_option *decoded_options;
6266 unsigned int decoded_options_count;
6268 p = argv[0] + strlen (argv[0]);
6269 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
6270 --p;
6271 progname = p;
6273 xmalloc_set_program_name (progname);
6275 expandargv (&argc, &argv);
6277 /* Determine if any expansions were made. */
6278 if (argv != old_argv)
6279 at_file_supplied = true;
6281 /* Register the language-independent parameters. */
6282 global_init_params ();
6283 finish_params ();
6285 init_options_struct (&global_options, &global_options_set);
6287 decode_cmdline_options_to_array (argc, CONST_CAST2 (const char **, char **,
6288 argv),
6289 CL_DRIVER,
6290 &decoded_options, &decoded_options_count);
6292 /* Unlock the stdio streams. */
6293 unlock_std_streams ();
6295 gcc_init_libintl ();
6297 diagnostic_initialize (global_dc, 0);
6299 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6300 /* Perform host dependent initialization when needed. */
6301 GCC_DRIVER_HOST_INITIALIZATION;
6302 #endif
6304 if (atexit (delete_temp_files) != 0)
6305 fatal_error ("atexit failed");
6307 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
6308 signal (SIGINT, fatal_signal);
6309 #ifdef SIGHUP
6310 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
6311 signal (SIGHUP, fatal_signal);
6312 #endif
6313 if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
6314 signal (SIGTERM, fatal_signal);
6315 #ifdef SIGPIPE
6316 if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
6317 signal (SIGPIPE, fatal_signal);
6318 #endif
6319 #ifdef SIGCHLD
6320 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6321 receive the signal. A different setting is inheritable */
6322 signal (SIGCHLD, SIG_DFL);
6323 #endif
6325 /* Parsing and gimplification sometimes need quite large stack.
6326 Increase stack size limits if possible. */
6327 stack_limit_increase (64 * 1024 * 1024);
6329 /* Allocate the argument vector. */
6330 alloc_args ();
6332 obstack_init (&obstack);
6334 /* Build multilib_select, et. al from the separate lines that make up each
6335 multilib selection. */
6337 const char *const *q = multilib_raw;
6338 int need_space;
6340 obstack_init (&multilib_obstack);
6341 while ((p = *q++) != (char *) 0)
6342 obstack_grow (&multilib_obstack, p, strlen (p));
6344 obstack_1grow (&multilib_obstack, 0);
6345 multilib_select = XOBFINISH (&multilib_obstack, const char *);
6347 q = multilib_matches_raw;
6348 while ((p = *q++) != (char *) 0)
6349 obstack_grow (&multilib_obstack, p, strlen (p));
6351 obstack_1grow (&multilib_obstack, 0);
6352 multilib_matches = XOBFINISH (&multilib_obstack, const char *);
6354 q = multilib_exclusions_raw;
6355 while ((p = *q++) != (char *) 0)
6356 obstack_grow (&multilib_obstack, p, strlen (p));
6358 obstack_1grow (&multilib_obstack, 0);
6359 multilib_exclusions = XOBFINISH (&multilib_obstack, const char *);
6361 q = multilib_reuse_raw;
6362 while ((p = *q++) != (char *) 0)
6363 obstack_grow (&multilib_obstack, p, strlen (p));
6365 obstack_1grow (&multilib_obstack, 0);
6366 multilib_reuse = XOBFINISH (&multilib_obstack, const char *);
6368 need_space = FALSE;
6369 for (i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++)
6371 if (need_space)
6372 obstack_1grow (&multilib_obstack, ' ');
6373 obstack_grow (&multilib_obstack,
6374 multilib_defaults_raw[i],
6375 strlen (multilib_defaults_raw[i]));
6376 need_space = TRUE;
6379 obstack_1grow (&multilib_obstack, 0);
6380 multilib_defaults = XOBFINISH (&multilib_obstack, const char *);
6383 #ifdef INIT_ENVIRONMENT
6384 /* Set up any other necessary machine specific environment variables. */
6385 xputenv (INIT_ENVIRONMENT);
6386 #endif
6388 /* Make a table of what switches there are (switches, n_switches).
6389 Make a table of specified input files (infiles, n_infiles).
6390 Decode switches that are handled locally. */
6392 process_command (decoded_options_count, decoded_options);
6394 /* Initialize the vector of specs to just the default.
6395 This means one element containing 0s, as a terminator. */
6397 compilers = XNEWVAR (struct compiler, sizeof default_compilers);
6398 memcpy (compilers, default_compilers, sizeof default_compilers);
6399 n_compilers = n_default_compilers;
6401 /* Read specs from a file if there is one. */
6403 machine_suffix = concat (spec_machine, dir_separator_str,
6404 spec_version, dir_separator_str, NULL);
6405 just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
6407 specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, true);
6408 /* Read the specs file unless it is a default one. */
6409 if (specs_file != 0 && strcmp (specs_file, "specs"))
6410 read_specs (specs_file, true, false);
6411 else
6412 init_spec ();
6414 /* We need to check standard_exec_prefix/just_machine_suffix/specs
6415 for any override of as, ld and libraries. */
6416 specs_file = (char *) alloca (strlen (standard_exec_prefix)
6417 + strlen (just_machine_suffix) + sizeof ("specs"));
6419 strcpy (specs_file, standard_exec_prefix);
6420 strcat (specs_file, just_machine_suffix);
6421 strcat (specs_file, "specs");
6422 if (access (specs_file, R_OK) == 0)
6423 read_specs (specs_file, true, false);
6425 /* Process any configure-time defaults specified for the command line
6426 options, via OPTION_DEFAULT_SPECS. */
6427 for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
6428 do_option_spec (option_default_specs[i].name,
6429 option_default_specs[i].spec);
6431 /* Process DRIVER_SELF_SPECS, adding any new options to the end
6432 of the command line. */
6434 for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++)
6435 do_self_spec (driver_self_specs[i]);
6437 /* If not cross-compiling, look for executables in the standard
6438 places. */
6439 if (*cross_compile == '0')
6441 if (*md_exec_prefix)
6443 add_prefix (&exec_prefixes, md_exec_prefix, "GCC",
6444 PREFIX_PRIORITY_LAST, 0, 0);
6448 /* Process sysroot_suffix_spec. */
6449 if (*sysroot_suffix_spec != 0
6450 && !no_sysroot_suffix
6451 && do_spec_2 (sysroot_suffix_spec) == 0)
6453 if (argbuf.length () > 1)
6454 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
6455 else if (argbuf.length () == 1)
6456 target_sysroot_suffix = xstrdup (argbuf.last ());
6459 #ifdef HAVE_LD_SYSROOT
6460 /* Pass the --sysroot option to the linker, if it supports that. If
6461 there is a sysroot_suffix_spec, it has already been processed by
6462 this point, so target_system_root really is the system root we
6463 should be using. */
6464 if (target_system_root)
6466 obstack_grow (&obstack, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
6467 obstack_grow0 (&obstack, link_spec, strlen (link_spec));
6468 set_spec ("link", XOBFINISH (&obstack, const char *), false);
6470 #endif
6472 /* Process sysroot_hdrs_suffix_spec. */
6473 if (*sysroot_hdrs_suffix_spec != 0
6474 && !no_sysroot_suffix
6475 && do_spec_2 (sysroot_hdrs_suffix_spec) == 0)
6477 if (argbuf.length () > 1)
6478 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
6479 else if (argbuf.length () == 1)
6480 target_sysroot_hdrs_suffix = xstrdup (argbuf.last ());
6483 /* Look for startfiles in the standard places. */
6484 if (*startfile_prefix_spec != 0
6485 && do_spec_2 (startfile_prefix_spec) == 0
6486 && do_spec_1 (" ", 0, NULL) == 0)
6488 const char *arg;
6489 int ndx;
6490 FOR_EACH_VEC_ELT (argbuf, ndx, arg)
6491 add_sysrooted_prefix (&startfile_prefixes, arg, "BINUTILS",
6492 PREFIX_PRIORITY_LAST, 0, 1);
6494 /* We should eventually get rid of all these and stick to
6495 startfile_prefix_spec exclusively. */
6496 else if (*cross_compile == '0' || target_system_root)
6498 if (*md_startfile_prefix)
6499 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix,
6500 "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6502 if (*md_startfile_prefix_1)
6503 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix_1,
6504 "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6506 /* If standard_startfile_prefix is relative, base it on
6507 standard_exec_prefix. This lets us move the installed tree
6508 as a unit. If GCC_EXEC_PREFIX is defined, base
6509 standard_startfile_prefix on that as well.
6511 If the prefix is relative, only search it for native compilers;
6512 otherwise we will search a directory containing host libraries. */
6513 if (IS_ABSOLUTE_PATH (standard_startfile_prefix))
6514 add_sysrooted_prefix (&startfile_prefixes,
6515 standard_startfile_prefix, "BINUTILS",
6516 PREFIX_PRIORITY_LAST, 0, 1);
6517 else if (*cross_compile == '0')
6519 add_prefix (&startfile_prefixes,
6520 concat (gcc_exec_prefix
6521 ? gcc_exec_prefix : standard_exec_prefix,
6522 machine_suffix,
6523 standard_startfile_prefix, NULL),
6524 NULL, PREFIX_PRIORITY_LAST, 0, 1);
6527 /* Sysrooted prefixes are relocated because target_system_root is
6528 also relocated by gcc_exec_prefix. */
6529 if (*standard_startfile_prefix_1)
6530 add_sysrooted_prefix (&startfile_prefixes,
6531 standard_startfile_prefix_1, "BINUTILS",
6532 PREFIX_PRIORITY_LAST, 0, 1);
6533 if (*standard_startfile_prefix_2)
6534 add_sysrooted_prefix (&startfile_prefixes,
6535 standard_startfile_prefix_2, "BINUTILS",
6536 PREFIX_PRIORITY_LAST, 0, 1);
6539 /* Process any user specified specs in the order given on the command
6540 line. */
6541 for (uptr = user_specs_head; uptr; uptr = uptr->next)
6543 char *filename = find_a_file (&startfile_prefixes, uptr->filename,
6544 R_OK, true);
6545 read_specs (filename ? filename : uptr->filename, false, true);
6548 /* Process any user self specs. */
6550 struct spec_list *sl;
6551 for (sl = specs; sl; sl = sl->next)
6552 if (sl->name_len == sizeof "self_spec" - 1
6553 && !strcmp (sl->name, "self_spec"))
6554 do_self_spec (*sl->ptr_spec);
6557 if (compare_debug)
6559 enum save_temps save;
6561 if (!compare_debug_second)
6563 n_switches_debug_check[1] = n_switches;
6564 n_switches_alloc_debug_check[1] = n_switches_alloc;
6565 switches_debug_check[1] = XDUPVEC (struct switchstr, switches,
6566 n_switches_alloc);
6568 do_self_spec ("%:compare-debug-self-opt()");
6569 n_switches_debug_check[0] = n_switches;
6570 n_switches_alloc_debug_check[0] = n_switches_alloc;
6571 switches_debug_check[0] = switches;
6573 n_switches = n_switches_debug_check[1];
6574 n_switches_alloc = n_switches_alloc_debug_check[1];
6575 switches = switches_debug_check[1];
6578 /* Avoid crash when computing %j in this early. */
6579 save = save_temps_flag;
6580 save_temps_flag = SAVE_TEMPS_NONE;
6582 compare_debug = -compare_debug;
6583 do_self_spec ("%:compare-debug-self-opt()");
6585 save_temps_flag = save;
6587 if (!compare_debug_second)
6589 n_switches_debug_check[1] = n_switches;
6590 n_switches_alloc_debug_check[1] = n_switches_alloc;
6591 switches_debug_check[1] = switches;
6592 compare_debug = -compare_debug;
6593 n_switches = n_switches_debug_check[0];
6594 n_switches_alloc = n_switches_debug_check[0];
6595 switches = switches_debug_check[0];
6600 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
6601 if (gcc_exec_prefix)
6602 gcc_exec_prefix = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
6603 spec_version, dir_separator_str, NULL);
6605 /* Now we have the specs.
6606 Set the `valid' bits for switches that match anything in any spec. */
6608 validate_all_switches ();
6610 /* Now that we have the switches and the specs, set
6611 the subdirectory based on the options. */
6612 set_multilib_dir ();
6614 /* Set up to remember the pathname of gcc and any options
6615 needed for collect. We use argv[0] instead of progname because
6616 we need the complete pathname. */
6617 obstack_init (&collect_obstack);
6618 obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
6619 obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1);
6620 xputenv (XOBFINISH (&collect_obstack, char *));
6622 /* Set up to remember the pathname of the lto wrapper. */
6624 if (have_c)
6625 lto_wrapper_file = NULL;
6626 else
6627 lto_wrapper_file = find_a_file (&exec_prefixes, "lto-wrapper",
6628 X_OK, false);
6629 if (lto_wrapper_file)
6631 lto_wrapper_file = convert_white_space (lto_wrapper_file);
6632 lto_wrapper_spec = lto_wrapper_file;
6633 obstack_init (&collect_obstack);
6634 obstack_grow (&collect_obstack, "COLLECT_LTO_WRAPPER=",
6635 sizeof ("COLLECT_LTO_WRAPPER=") - 1);
6636 obstack_grow (&collect_obstack, lto_wrapper_spec,
6637 strlen (lto_wrapper_spec) + 1);
6638 xputenv (XOBFINISH (&collect_obstack, char *));
6641 /* Reject switches that no pass was interested in. */
6643 for (i = 0; (int) i < n_switches; i++)
6644 if (! switches[i].validated)
6645 error ("unrecognized command line option %<-%s%>", switches[i].part1);
6647 /* Obey some of the options. */
6649 if (print_search_dirs)
6651 printf (_("install: %s%s\n"),
6652 gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
6653 gcc_exec_prefix ? "" : machine_suffix);
6654 printf (_("programs: %s\n"),
6655 build_search_list (&exec_prefixes, "", false, false));
6656 printf (_("libraries: %s\n"),
6657 build_search_list (&startfile_prefixes, "", false, true));
6658 return (0);
6661 if (print_file_name)
6663 printf ("%s\n", find_file (print_file_name));
6664 return (0);
6667 if (print_prog_name)
6669 char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK, 0);
6670 printf ("%s\n", (newname ? newname : print_prog_name));
6671 return (0);
6674 if (print_multi_lib)
6676 print_multilib_info ();
6677 return (0);
6680 if (print_multi_directory)
6682 if (multilib_dir == NULL)
6683 printf (".\n");
6684 else
6685 printf ("%s\n", multilib_dir);
6686 return (0);
6689 if (print_multiarch)
6691 if (multiarch_dir == NULL)
6692 printf ("\n");
6693 else
6694 printf ("%s\n", multiarch_dir);
6695 return (0);
6698 if (print_sysroot)
6700 if (target_system_root)
6702 if (target_sysroot_suffix)
6703 printf ("%s%s\n", target_system_root, target_sysroot_suffix);
6704 else
6705 printf ("%s\n", target_system_root);
6707 return (0);
6710 if (print_multi_os_directory)
6712 if (multilib_os_dir == NULL)
6713 printf (".\n");
6714 else
6715 printf ("%s\n", multilib_os_dir);
6716 return (0);
6719 if (print_sysroot_headers_suffix)
6721 if (*sysroot_hdrs_suffix_spec)
6723 printf("%s\n", (target_sysroot_hdrs_suffix
6724 ? target_sysroot_hdrs_suffix
6725 : ""));
6726 return (0);
6728 else
6729 /* The error status indicates that only one set of fixed
6730 headers should be built. */
6731 fatal_error ("not configured with sysroot headers suffix");
6734 if (print_help_list)
6736 display_help ();
6738 if (! verbose_flag)
6740 printf (_("\nFor bug reporting instructions, please see:\n"));
6741 printf ("%s.\n", bug_report_url);
6743 return (0);
6746 /* We do not exit here. Instead we have created a fake input file
6747 called 'help-dummy' which needs to be compiled, and we pass this
6748 on the various sub-processes, along with the --help switch.
6749 Ensure their output appears after ours. */
6750 fputc ('\n', stdout);
6751 fflush (stdout);
6754 if (print_version)
6756 printf (_("%s %s%s\n"), progname, pkgversion_string,
6757 version_string);
6758 printf ("Copyright %s 2013 Free Software Foundation, Inc.\n",
6759 _("(C)"));
6760 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
6761 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
6762 stdout);
6763 if (! verbose_flag)
6764 return 0;
6766 /* We do not exit here. We use the same mechanism of --help to print
6767 the version of the sub-processes. */
6768 fputc ('\n', stdout);
6769 fflush (stdout);
6772 if (verbose_flag)
6774 int n;
6775 const char *thrmod;
6777 fnotice (stderr, "Target: %s\n", spec_machine);
6778 fnotice (stderr, "Configured with: %s\n", configuration_arguments);
6780 #ifdef THREAD_MODEL_SPEC
6781 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
6782 but there's no point in doing all this processing just to get
6783 thread_model back. */
6784 obstack_init (&obstack);
6785 do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model);
6786 obstack_1grow (&obstack, '\0');
6787 thrmod = XOBFINISH (&obstack, const char *);
6788 #else
6789 thrmod = thread_model;
6790 #endif
6792 fnotice (stderr, "Thread model: %s\n", thrmod);
6794 /* compiler_version is truncated at the first space when initialized
6795 from version string, so truncate version_string at the first space
6796 before comparing. */
6797 for (n = 0; version_string[n]; n++)
6798 if (version_string[n] == ' ')
6799 break;
6801 if (! strncmp (version_string, compiler_version, n)
6802 && compiler_version[n] == 0)
6803 fnotice (stderr, "gcc version %s %s\n", version_string,
6804 pkgversion_string);
6805 else
6806 fnotice (stderr, "gcc driver version %s %sexecuting gcc version %s\n",
6807 version_string, pkgversion_string, compiler_version);
6809 if (n_infiles == 0)
6810 return (0);
6813 if (n_infiles == added_libraries)
6814 fatal_error ("no input files");
6816 if (seen_error ())
6817 goto out;
6819 /* Make a place to record the compiler output file names
6820 that correspond to the input files. */
6822 i = n_infiles;
6823 i += lang_specific_extra_outfiles;
6824 outfiles = XCNEWVEC (const char *, i);
6826 /* Record which files were specified explicitly as link input. */
6828 explicit_link_files = XCNEWVEC (char, n_infiles);
6830 combine_inputs = have_o || flag_wpa;
6832 for (i = 0; (int) i < n_infiles; i++)
6834 const char *name = infiles[i].name;
6835 struct compiler *compiler = lookup_compiler (name,
6836 strlen (name),
6837 infiles[i].language);
6839 if (compiler && !(compiler->combinable))
6840 combine_inputs = false;
6842 if (lang_n_infiles > 0 && compiler != input_file_compiler
6843 && infiles[i].language && infiles[i].language[0] != '*')
6844 infiles[i].incompiler = compiler;
6845 else if (compiler)
6847 lang_n_infiles++;
6848 input_file_compiler = compiler;
6849 infiles[i].incompiler = compiler;
6851 else
6853 /* Since there is no compiler for this input file, assume it is a
6854 linker file. */
6855 explicit_link_files[i] = 1;
6856 infiles[i].incompiler = NULL;
6858 infiles[i].compiled = false;
6859 infiles[i].preprocessed = false;
6862 if (!combine_inputs && have_c && have_o && lang_n_infiles > 1)
6863 fatal_error ("cannot specify -o with -c, -S or -E with multiple files");
6865 for (i = 0; (int) i < n_infiles; i++)
6867 int this_file_error = 0;
6869 /* Tell do_spec what to substitute for %i. */
6871 input_file_number = i;
6872 set_input (infiles[i].name);
6874 if (infiles[i].compiled)
6875 continue;
6877 /* Use the same thing in %o, unless cp->spec says otherwise. */
6879 outfiles[i] = gcc_input_filename;
6881 /* Figure out which compiler from the file's suffix. */
6883 input_file_compiler
6884 = lookup_compiler (infiles[i].name, input_filename_length,
6885 infiles[i].language);
6887 if (input_file_compiler)
6889 /* Ok, we found an applicable compiler. Run its spec. */
6891 if (input_file_compiler->spec[0] == '#')
6893 error ("%s: %s compiler not installed on this system",
6894 gcc_input_filename, &input_file_compiler->spec[1]);
6895 this_file_error = 1;
6897 else
6899 if (compare_debug)
6901 free (debug_check_temp_file[0]);
6902 debug_check_temp_file[0] = NULL;
6904 free (debug_check_temp_file[1]);
6905 debug_check_temp_file[1] = NULL;
6908 value = do_spec (input_file_compiler->spec);
6909 infiles[i].compiled = true;
6910 if (value < 0)
6911 this_file_error = 1;
6912 else if (compare_debug && debug_check_temp_file[0])
6914 if (verbose_flag)
6915 inform (0, "recompiling with -fcompare-debug");
6917 compare_debug = -compare_debug;
6918 n_switches = n_switches_debug_check[1];
6919 n_switches_alloc = n_switches_alloc_debug_check[1];
6920 switches = switches_debug_check[1];
6922 value = do_spec (input_file_compiler->spec);
6924 compare_debug = -compare_debug;
6925 n_switches = n_switches_debug_check[0];
6926 n_switches_alloc = n_switches_alloc_debug_check[0];
6927 switches = switches_debug_check[0];
6929 if (value < 0)
6931 error ("during -fcompare-debug recompilation");
6932 this_file_error = 1;
6935 gcc_assert (debug_check_temp_file[1]
6936 && filename_cmp (debug_check_temp_file[0],
6937 debug_check_temp_file[1]));
6939 if (verbose_flag)
6940 inform (0, "comparing final insns dumps");
6942 if (compare_files (debug_check_temp_file))
6943 this_file_error = 1;
6946 if (compare_debug)
6948 free (debug_check_temp_file[0]);
6949 debug_check_temp_file[0] = NULL;
6951 free (debug_check_temp_file[1]);
6952 debug_check_temp_file[1] = NULL;
6957 /* If this file's name does not contain a recognized suffix,
6958 record it as explicit linker input. */
6960 else
6961 explicit_link_files[i] = 1;
6963 /* Clear the delete-on-failure queue, deleting the files in it
6964 if this compilation failed. */
6966 if (this_file_error)
6968 delete_failure_queue ();
6969 errorcount++;
6971 /* If this compilation succeeded, don't delete those files later. */
6972 clear_failure_queue ();
6975 /* Reset the input file name to the first compile/object file name, for use
6976 with %b in LINK_SPEC. We use the first input file that we can find
6977 a compiler to compile it instead of using infiles.language since for
6978 languages other than C we use aliases that we then lookup later. */
6979 if (n_infiles > 0)
6981 int i;
6983 for (i = 0; i < n_infiles ; i++)
6984 if (infiles[i].incompiler
6985 || (infiles[i].language && infiles[i].language[0] != '*'))
6987 set_input (infiles[i].name);
6988 break;
6992 if (!seen_error ())
6994 /* Make sure INPUT_FILE_NUMBER points to first available open
6995 slot. */
6996 input_file_number = n_infiles;
6997 if (lang_specific_pre_link ())
6998 errorcount++;
7001 /* Determine if there are any linker input files. */
7002 num_linker_inputs = 0;
7003 for (i = 0; (int) i < n_infiles; i++)
7004 if (explicit_link_files[i] || outfiles[i] != NULL)
7005 num_linker_inputs++;
7007 /* Run ld to link all the compiler output files. */
7009 if (num_linker_inputs > 0 && !seen_error () && print_subprocess_help < 2)
7011 int tmp = execution_count;
7013 if (! have_c)
7015 #if HAVE_LTO_PLUGIN > 0
7016 #if HAVE_LTO_PLUGIN == 2
7017 const char *fno_use_linker_plugin = "fno-use-linker-plugin";
7018 #else
7019 const char *fuse_linker_plugin = "fuse-linker-plugin";
7020 #endif
7021 #endif
7023 /* We'll use ld if we can't find collect2. */
7024 if (! strcmp (linker_name_spec, "collect2"))
7026 char *s = find_a_file (&exec_prefixes, "collect2", X_OK, false);
7027 if (s == NULL)
7028 linker_name_spec = "ld";
7031 #if HAVE_LTO_PLUGIN > 0
7032 #if HAVE_LTO_PLUGIN == 2
7033 if (!switch_matches (fno_use_linker_plugin,
7034 fno_use_linker_plugin
7035 + strlen (fno_use_linker_plugin), 0))
7036 #else
7037 if (switch_matches (fuse_linker_plugin,
7038 fuse_linker_plugin
7039 + strlen (fuse_linker_plugin), 0))
7040 #endif
7042 char *temp_spec = find_a_file (&exec_prefixes,
7043 LTOPLUGINSONAME, R_OK,
7044 false);
7045 if (!temp_spec)
7046 fatal_error ("-fuse-linker-plugin, but %s not found",
7047 LTOPLUGINSONAME);
7048 linker_plugin_file_spec = convert_white_space (temp_spec);
7050 #endif
7051 lto_gcc_spec = argv[0];
7054 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
7055 for collect. */
7056 putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH", false);
7057 putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV, true);
7059 if (print_subprocess_help == 1)
7061 printf (_("\nLinker options\n==============\n\n"));
7062 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
7063 " to the linker.\n\n"));
7064 fflush (stdout);
7066 value = do_spec (link_command_spec);
7067 if (value < 0)
7068 errorcount = 1;
7069 linker_was_run = (tmp != execution_count);
7072 /* If options said don't run linker,
7073 complain about input files to be given to the linker. */
7075 if (! linker_was_run && !seen_error ())
7076 for (i = 0; (int) i < n_infiles; i++)
7077 if (explicit_link_files[i]
7078 && !(infiles[i].language && infiles[i].language[0] == '*'))
7079 warning (0, "%s: linker input file unused because linking not done",
7080 outfiles[i]);
7082 /* Delete some or all of the temporary files we made. */
7084 if (seen_error ())
7085 delete_failure_queue ();
7086 delete_temp_files ();
7088 if (print_help_list)
7090 printf (("\nFor bug reporting instructions, please see:\n"));
7091 printf ("%s\n", bug_report_url);
7094 out:
7095 return (signal_count != 0 ? 2
7096 : seen_error () ? (pass_exit_codes ? greatest_status : 1)
7097 : 0);
7100 /* Find the proper compilation spec for the file name NAME,
7101 whose length is LENGTH. LANGUAGE is the specified language,
7102 or 0 if this file is to be passed to the linker. */
7104 static struct compiler *
7105 lookup_compiler (const char *name, size_t length, const char *language)
7107 struct compiler *cp;
7109 /* If this was specified by the user to be a linker input, indicate that. */
7110 if (language != 0 && language[0] == '*')
7111 return 0;
7113 /* Otherwise, look for the language, if one is spec'd. */
7114 if (language != 0)
7116 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7117 if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
7118 return cp;
7120 error ("language %s not recognized", language);
7121 return 0;
7124 /* Look for a suffix. */
7125 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7127 if (/* The suffix `-' matches only the file name `-'. */
7128 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
7129 || (strlen (cp->suffix) < length
7130 /* See if the suffix matches the end of NAME. */
7131 && !strcmp (cp->suffix,
7132 name + length - strlen (cp->suffix))
7134 break;
7137 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
7138 /* Look again, but case-insensitively this time. */
7139 if (cp < compilers)
7140 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7142 if (/* The suffix `-' matches only the file name `-'. */
7143 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
7144 || (strlen (cp->suffix) < length
7145 /* See if the suffix matches the end of NAME. */
7146 && ((!strcmp (cp->suffix,
7147 name + length - strlen (cp->suffix))
7148 || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
7149 && !strcasecmp (cp->suffix,
7150 name + length - strlen (cp->suffix)))
7152 break;
7154 #endif
7156 if (cp >= compilers)
7158 if (cp->spec[0] != '@')
7159 /* A non-alias entry: return it. */
7160 return cp;
7162 /* An alias entry maps a suffix to a language.
7163 Search for the language; pass 0 for NAME and LENGTH
7164 to avoid infinite recursion if language not found. */
7165 return lookup_compiler (NULL, 0, cp->spec + 1);
7167 return 0;
7170 static char *
7171 save_string (const char *s, int len)
7173 char *result = XNEWVEC (char, len + 1);
7175 memcpy (result, s, len);
7176 result[len] = 0;
7177 return result;
7180 void
7181 pfatal_with_name (const char *name)
7183 perror_with_name (name);
7184 delete_temp_files ();
7185 exit (1);
7188 static void
7189 perror_with_name (const char *name)
7191 error ("%s: %m", name);
7194 static inline void
7195 validate_switches_from_spec (const char *spec, bool user)
7197 const char *p = spec;
7198 char c;
7199 while ((c = *p++))
7200 if (c == '%' && (*p == '{' || *p == '<' || (*p == 'W' && *++p == '{')))
7201 /* We have a switch spec. */
7202 p = validate_switches (p + 1, user);
7205 static void
7206 validate_all_switches (void)
7208 struct compiler *comp;
7209 struct spec_list *spec;
7211 for (comp = compilers; comp->spec; comp++)
7212 validate_switches_from_spec (comp->spec, false);
7214 /* Look through the linked list of specs read from the specs file. */
7215 for (spec = specs; spec; spec = spec->next)
7216 validate_switches_from_spec (*spec->ptr_spec, spec->user_p);
7218 validate_switches_from_spec (link_command_spec, false);
7221 /* Look at the switch-name that comes after START
7222 and mark as valid all supplied switches that match it. */
7224 static const char *
7225 validate_switches (const char *start, bool user_spec)
7227 const char *p = start;
7228 const char *atom;
7229 size_t len;
7230 int i;
7231 bool suffix = false;
7232 bool starred = false;
7234 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7236 next_member:
7237 SKIP_WHITE ();
7239 if (*p == '!')
7240 p++;
7242 SKIP_WHITE ();
7243 if (*p == '.' || *p == ',')
7244 suffix = true, p++;
7246 atom = p;
7247 while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
7248 || *p == ',' || *p == '.' || *p == '@')
7249 p++;
7250 len = p - atom;
7252 if (*p == '*')
7253 starred = true, p++;
7255 SKIP_WHITE ();
7257 if (!suffix)
7259 /* Mark all matching switches as valid. */
7260 for (i = 0; i < n_switches; i++)
7261 if (!strncmp (switches[i].part1, atom, len)
7262 && (starred || switches[i].part1[len] == '\0')
7263 && (switches[i].known || user_spec))
7264 switches[i].validated = true;
7267 if (*p) p++;
7268 if (*p && (p[-1] == '|' || p[-1] == '&'))
7269 goto next_member;
7271 if (*p && p[-1] == ':')
7273 while (*p && *p != ';' && *p != '}')
7275 if (*p == '%')
7277 p++;
7278 if (*p == '{' || *p == '<')
7279 p = validate_switches (p+1, user_spec);
7280 else if (p[0] == 'W' && p[1] == '{')
7281 p = validate_switches (p+2, user_spec);
7283 else
7284 p++;
7287 if (*p) p++;
7288 if (*p && p[-1] == ';')
7289 goto next_member;
7292 return p;
7293 #undef SKIP_WHITE
7296 struct mdswitchstr
7298 const char *str;
7299 int len;
7302 static struct mdswitchstr *mdswitches;
7303 static int n_mdswitches;
7305 /* Check whether a particular argument was used. The first time we
7306 canonicalize the switches to keep only the ones we care about. */
7308 static int
7309 used_arg (const char *p, int len)
7311 struct mswitchstr
7313 const char *str;
7314 const char *replace;
7315 int len;
7316 int rep_len;
7319 static struct mswitchstr *mswitches;
7320 static int n_mswitches;
7321 int i, j;
7323 if (!mswitches)
7325 struct mswitchstr *matches;
7326 const char *q;
7327 int cnt = 0;
7329 /* Break multilib_matches into the component strings of string
7330 and replacement string. */
7331 for (q = multilib_matches; *q != '\0'; q++)
7332 if (*q == ';')
7333 cnt++;
7335 matches
7336 = (struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt);
7337 i = 0;
7338 q = multilib_matches;
7339 while (*q != '\0')
7341 matches[i].str = q;
7342 while (*q != ' ')
7344 if (*q == '\0')
7346 invalid_matches:
7347 fatal_error ("multilib spec %qs is invalid",
7348 multilib_matches);
7350 q++;
7352 matches[i].len = q - matches[i].str;
7354 matches[i].replace = ++q;
7355 while (*q != ';' && *q != '\0')
7357 if (*q == ' ')
7358 goto invalid_matches;
7359 q++;
7361 matches[i].rep_len = q - matches[i].replace;
7362 i++;
7363 if (*q == ';')
7364 q++;
7367 /* Now build a list of the replacement string for switches that we care
7368 about. Make sure we allocate at least one entry. This prevents
7369 xmalloc from calling fatal, and prevents us from re-executing this
7370 block of code. */
7371 mswitches
7372 = XNEWVEC (struct mswitchstr, n_mdswitches + (n_switches ? n_switches : 1));
7373 for (i = 0; i < n_switches; i++)
7374 if ((switches[i].live_cond & SWITCH_IGNORE) == 0)
7376 int xlen = strlen (switches[i].part1);
7377 for (j = 0; j < cnt; j++)
7378 if (xlen == matches[j].len
7379 && ! strncmp (switches[i].part1, matches[j].str, xlen))
7381 mswitches[n_mswitches].str = matches[j].replace;
7382 mswitches[n_mswitches].len = matches[j].rep_len;
7383 mswitches[n_mswitches].replace = (char *) 0;
7384 mswitches[n_mswitches].rep_len = 0;
7385 n_mswitches++;
7386 break;
7390 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
7391 on the command line nor any options mutually incompatible with
7392 them. */
7393 for (i = 0; i < n_mdswitches; i++)
7395 const char *r;
7397 for (q = multilib_options; *q != '\0'; q++)
7399 while (*q == ' ')
7400 q++;
7402 r = q;
7403 while (strncmp (q, mdswitches[i].str, mdswitches[i].len) != 0
7404 || strchr (" /", q[mdswitches[i].len]) == NULL)
7406 while (*q != ' ' && *q != '/' && *q != '\0')
7407 q++;
7408 if (*q != '/')
7409 break;
7410 q++;
7413 if (*q != ' ' && *q != '\0')
7415 while (*r != ' ' && *r != '\0')
7417 q = r;
7418 while (*q != ' ' && *q != '/' && *q != '\0')
7419 q++;
7421 if (used_arg (r, q - r))
7422 break;
7424 if (*q != '/')
7426 mswitches[n_mswitches].str = mdswitches[i].str;
7427 mswitches[n_mswitches].len = mdswitches[i].len;
7428 mswitches[n_mswitches].replace = (char *) 0;
7429 mswitches[n_mswitches].rep_len = 0;
7430 n_mswitches++;
7431 break;
7434 r = q + 1;
7436 break;
7442 for (i = 0; i < n_mswitches; i++)
7443 if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
7444 return 1;
7446 return 0;
7449 static int
7450 default_arg (const char *p, int len)
7452 int i;
7454 for (i = 0; i < n_mdswitches; i++)
7455 if (len == mdswitches[i].len && ! strncmp (p, mdswitches[i].str, len))
7456 return 1;
7458 return 0;
7461 /* Work out the subdirectory to use based on the options. The format of
7462 multilib_select is a list of elements. Each element is a subdirectory
7463 name followed by a list of options followed by a semicolon. The format
7464 of multilib_exclusions is the same, but without the preceding
7465 directory. First gcc will check the exclusions, if none of the options
7466 beginning with an exclamation point are present, and all of the other
7467 options are present, then we will ignore this completely. Passing
7468 that, gcc will consider each multilib_select in turn using the same
7469 rules for matching the options. If a match is found, that subdirectory
7470 will be used.
7471 A subdirectory name is optionally followed by a colon and the corresponding
7472 multiarch name. */
7474 static void
7475 set_multilib_dir (void)
7477 const char *p;
7478 unsigned int this_path_len;
7479 const char *this_path, *this_arg;
7480 const char *start, *end;
7481 int not_arg;
7482 int ok, ndfltok, first;
7484 n_mdswitches = 0;
7485 start = multilib_defaults;
7486 while (*start == ' ' || *start == '\t')
7487 start++;
7488 while (*start != '\0')
7490 n_mdswitches++;
7491 while (*start != ' ' && *start != '\t' && *start != '\0')
7492 start++;
7493 while (*start == ' ' || *start == '\t')
7494 start++;
7497 if (n_mdswitches)
7499 int i = 0;
7501 mdswitches = XNEWVEC (struct mdswitchstr, n_mdswitches);
7502 for (start = multilib_defaults; *start != '\0'; start = end + 1)
7504 while (*start == ' ' || *start == '\t')
7505 start++;
7507 if (*start == '\0')
7508 break;
7510 for (end = start + 1;
7511 *end != ' ' && *end != '\t' && *end != '\0'; end++)
7514 obstack_grow (&multilib_obstack, start, end - start);
7515 obstack_1grow (&multilib_obstack, 0);
7516 mdswitches[i].str = XOBFINISH (&multilib_obstack, const char *);
7517 mdswitches[i++].len = end - start;
7519 if (*end == '\0')
7520 break;
7524 p = multilib_exclusions;
7525 while (*p != '\0')
7527 /* Ignore newlines. */
7528 if (*p == '\n')
7530 ++p;
7531 continue;
7534 /* Check the arguments. */
7535 ok = 1;
7536 while (*p != ';')
7538 if (*p == '\0')
7540 invalid_exclusions:
7541 fatal_error ("multilib exclusions %qs is invalid",
7542 multilib_exclusions);
7545 if (! ok)
7547 ++p;
7548 continue;
7551 this_arg = p;
7552 while (*p != ' ' && *p != ';')
7554 if (*p == '\0')
7555 goto invalid_exclusions;
7556 ++p;
7559 if (*this_arg != '!')
7560 not_arg = 0;
7561 else
7563 not_arg = 1;
7564 ++this_arg;
7567 ok = used_arg (this_arg, p - this_arg);
7568 if (not_arg)
7569 ok = ! ok;
7571 if (*p == ' ')
7572 ++p;
7575 if (ok)
7576 return;
7578 ++p;
7581 first = 1;
7582 p = multilib_select;
7584 /* Append multilib reuse rules if any. With those rules, we can reuse
7585 one multilib for certain different options sets. */
7586 if (strlen (multilib_reuse) > 0)
7587 p = concat (p, multilib_reuse, NULL);
7589 while (*p != '\0')
7591 /* Ignore newlines. */
7592 if (*p == '\n')
7594 ++p;
7595 continue;
7598 /* Get the initial path. */
7599 this_path = p;
7600 while (*p != ' ')
7602 if (*p == '\0')
7604 invalid_select:
7605 fatal_error ("multilib select %qs %qs is invalid",
7606 multilib_select, multilib_reuse);
7608 ++p;
7610 this_path_len = p - this_path;
7612 /* Check the arguments. */
7613 ok = 1;
7614 ndfltok = 1;
7615 ++p;
7616 while (*p != ';')
7618 if (*p == '\0')
7619 goto invalid_select;
7621 if (! ok)
7623 ++p;
7624 continue;
7627 this_arg = p;
7628 while (*p != ' ' && *p != ';')
7630 if (*p == '\0')
7631 goto invalid_select;
7632 ++p;
7635 if (*this_arg != '!')
7636 not_arg = 0;
7637 else
7639 not_arg = 1;
7640 ++this_arg;
7643 /* If this is a default argument, we can just ignore it.
7644 This is true even if this_arg begins with '!'. Beginning
7645 with '!' does not mean that this argument is necessarily
7646 inappropriate for this library: it merely means that
7647 there is a more specific library which uses this
7648 argument. If this argument is a default, we need not
7649 consider that more specific library. */
7650 ok = used_arg (this_arg, p - this_arg);
7651 if (not_arg)
7652 ok = ! ok;
7654 if (! ok)
7655 ndfltok = 0;
7657 if (default_arg (this_arg, p - this_arg))
7658 ok = 1;
7660 if (*p == ' ')
7661 ++p;
7664 if (ok && first)
7666 if (this_path_len != 1
7667 || this_path[0] != '.')
7669 char *new_multilib_dir = XNEWVEC (char, this_path_len + 1);
7670 char *q;
7672 strncpy (new_multilib_dir, this_path, this_path_len);
7673 new_multilib_dir[this_path_len] = '\0';
7674 q = strchr (new_multilib_dir, ':');
7675 if (q != NULL)
7676 *q = '\0';
7677 multilib_dir = new_multilib_dir;
7679 first = 0;
7682 if (ndfltok)
7684 const char *q = this_path, *end = this_path + this_path_len;
7686 while (q < end && *q != ':')
7687 q++;
7688 if (q < end)
7690 const char *q2 = q + 1, *ml_end = end;
7691 char *new_multilib_os_dir;
7693 while (q2 < end && *q2 != ':')
7694 q2++;
7695 if (*q2 == ':')
7696 ml_end = q2;
7697 new_multilib_os_dir = XNEWVEC (char, ml_end - q);
7698 memcpy (new_multilib_os_dir, q + 1, ml_end - q - 1);
7699 new_multilib_os_dir[ml_end - q - 1] = '\0';
7700 multilib_os_dir = *new_multilib_os_dir ? new_multilib_os_dir : ".";
7702 if (q2 < end && *q2 == ':')
7704 char *new_multiarch_dir = XNEWVEC (char, end - q2);
7705 memcpy (new_multiarch_dir, q2 + 1, end - q2 - 1);
7706 new_multiarch_dir[end - q2 - 1] = '\0';
7707 multiarch_dir = new_multiarch_dir;
7709 break;
7713 ++p;
7716 if (multilib_dir == NULL && multilib_os_dir != NULL
7717 && strcmp (multilib_os_dir, ".") == 0)
7719 free (CONST_CAST (char *, multilib_os_dir));
7720 multilib_os_dir = NULL;
7722 else if (multilib_dir != NULL && multilib_os_dir == NULL)
7723 multilib_os_dir = multilib_dir;
7726 /* Print out the multiple library subdirectory selection
7727 information. This prints out a series of lines. Each line looks
7728 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
7729 required. Only the desired options are printed out, the negative
7730 matches. The options are print without a leading dash. There are
7731 no spaces to make it easy to use the information in the shell.
7732 Each subdirectory is printed only once. This assumes the ordering
7733 generated by the genmultilib script. Also, we leave out ones that match
7734 the exclusions. */
7736 static void
7737 print_multilib_info (void)
7739 const char *p = multilib_select;
7740 const char *last_path = 0, *this_path;
7741 int skip;
7742 unsigned int last_path_len = 0;
7744 while (*p != '\0')
7746 skip = 0;
7747 /* Ignore newlines. */
7748 if (*p == '\n')
7750 ++p;
7751 continue;
7754 /* Get the initial path. */
7755 this_path = p;
7756 while (*p != ' ')
7758 if (*p == '\0')
7760 invalid_select:
7761 fatal_error ("multilib select %qs is invalid", multilib_select);
7764 ++p;
7767 /* When --disable-multilib was used but target defines
7768 MULTILIB_OSDIRNAMES, entries starting with .: (and not starting
7769 with .:: for multiarch configurations) are there just to find
7770 multilib_os_dir, so skip them from output. */
7771 if (this_path[0] == '.' && this_path[1] == ':' && this_path[2] != ':')
7772 skip = 1;
7774 /* Check for matches with the multilib_exclusions. We don't bother
7775 with the '!' in either list. If any of the exclusion rules match
7776 all of its options with the select rule, we skip it. */
7778 const char *e = multilib_exclusions;
7779 const char *this_arg;
7781 while (*e != '\0')
7783 int m = 1;
7784 /* Ignore newlines. */
7785 if (*e == '\n')
7787 ++e;
7788 continue;
7791 /* Check the arguments. */
7792 while (*e != ';')
7794 const char *q;
7795 int mp = 0;
7797 if (*e == '\0')
7799 invalid_exclusion:
7800 fatal_error ("multilib exclusion %qs is invalid",
7801 multilib_exclusions);
7804 if (! m)
7806 ++e;
7807 continue;
7810 this_arg = e;
7812 while (*e != ' ' && *e != ';')
7814 if (*e == '\0')
7815 goto invalid_exclusion;
7816 ++e;
7819 q = p + 1;
7820 while (*q != ';')
7822 const char *arg;
7823 int len = e - this_arg;
7825 if (*q == '\0')
7826 goto invalid_select;
7828 arg = q;
7830 while (*q != ' ' && *q != ';')
7832 if (*q == '\0')
7833 goto invalid_select;
7834 ++q;
7837 if (! strncmp (arg, this_arg,
7838 (len < q - arg) ? q - arg : len)
7839 || default_arg (this_arg, e - this_arg))
7841 mp = 1;
7842 break;
7845 if (*q == ' ')
7846 ++q;
7849 if (! mp)
7850 m = 0;
7852 if (*e == ' ')
7853 ++e;
7856 if (m)
7858 skip = 1;
7859 break;
7862 if (*e != '\0')
7863 ++e;
7867 if (! skip)
7869 /* If this is a duplicate, skip it. */
7870 skip = (last_path != 0
7871 && (unsigned int) (p - this_path) == last_path_len
7872 && ! filename_ncmp (last_path, this_path, last_path_len));
7874 last_path = this_path;
7875 last_path_len = p - this_path;
7878 /* If this directory requires any default arguments, we can skip
7879 it. We will already have printed a directory identical to
7880 this one which does not require that default argument. */
7881 if (! skip)
7883 const char *q;
7885 q = p + 1;
7886 while (*q != ';')
7888 const char *arg;
7890 if (*q == '\0')
7891 goto invalid_select;
7893 if (*q == '!')
7894 arg = NULL;
7895 else
7896 arg = q;
7898 while (*q != ' ' && *q != ';')
7900 if (*q == '\0')
7901 goto invalid_select;
7902 ++q;
7905 if (arg != NULL
7906 && default_arg (arg, q - arg))
7908 skip = 1;
7909 break;
7912 if (*q == ' ')
7913 ++q;
7917 if (! skip)
7919 const char *p1;
7921 for (p1 = last_path; p1 < p && *p1 != ':'; p1++)
7922 putchar (*p1);
7923 putchar (';');
7926 ++p;
7927 while (*p != ';')
7929 int use_arg;
7931 if (*p == '\0')
7932 goto invalid_select;
7934 if (skip)
7936 ++p;
7937 continue;
7940 use_arg = *p != '!';
7942 if (use_arg)
7943 putchar ('@');
7945 while (*p != ' ' && *p != ';')
7947 if (*p == '\0')
7948 goto invalid_select;
7949 if (use_arg)
7950 putchar (*p);
7951 ++p;
7954 if (*p == ' ')
7955 ++p;
7958 if (! skip)
7960 /* If there are extra options, print them now. */
7961 if (multilib_extra && *multilib_extra)
7963 int print_at = TRUE;
7964 const char *q;
7966 for (q = multilib_extra; *q != '\0'; q++)
7968 if (*q == ' ')
7969 print_at = TRUE;
7970 else
7972 if (print_at)
7973 putchar ('@');
7974 putchar (*q);
7975 print_at = FALSE;
7980 putchar ('\n');
7983 ++p;
7987 /* getenv built-in spec function.
7989 Returns the value of the environment variable given by its first
7990 argument, concatenated with the second argument. If the
7991 environment variable is not defined, a fatal error is issued. */
7993 static const char *
7994 getenv_spec_function (int argc, const char **argv)
7996 char *value;
7997 char *result;
7998 char *ptr;
7999 size_t len;
8001 if (argc != 2)
8002 return NULL;
8004 value = getenv (argv[0]);
8005 if (!value)
8006 fatal_error ("environment variable %qs not defined", argv[0]);
8008 /* We have to escape every character of the environment variable so
8009 they are not interpreted as active spec characters. A
8010 particularly painful case is when we are reading a variable
8011 holding a windows path complete with \ separators. */
8012 len = strlen (value) * 2 + strlen (argv[1]) + 1;
8013 result = XNEWVAR (char, len);
8014 for (ptr = result; *value; ptr += 2)
8016 ptr[0] = '\\';
8017 ptr[1] = *value++;
8020 strcpy (ptr, argv[1]);
8022 return result;
8025 /* if-exists built-in spec function.
8027 Checks to see if the file specified by the absolute pathname in
8028 ARGS exists. Returns that pathname if found.
8030 The usual use for this function is to check for a library file
8031 (whose name has been expanded with %s). */
8033 static const char *
8034 if_exists_spec_function (int argc, const char **argv)
8036 /* Must have only one argument. */
8037 if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
8038 return argv[0];
8040 return NULL;
8043 /* if-exists-else built-in spec function.
8045 This is like if-exists, but takes an additional argument which
8046 is returned if the first argument does not exist. */
8048 static const char *
8049 if_exists_else_spec_function (int argc, const char **argv)
8051 /* Must have exactly two arguments. */
8052 if (argc != 2)
8053 return NULL;
8055 if (IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
8056 return argv[0];
8058 return argv[1];
8061 /* replace-outfile built-in spec function.
8063 This looks for the first argument in the outfiles array's name and
8064 replaces it with the second argument. */
8066 static const char *
8067 replace_outfile_spec_function (int argc, const char **argv)
8069 int i;
8070 /* Must have exactly two arguments. */
8071 if (argc != 2)
8072 abort ();
8074 for (i = 0; i < n_infiles; i++)
8076 if (outfiles[i] && !filename_cmp (outfiles[i], argv[0]))
8077 outfiles[i] = xstrdup (argv[1]);
8079 return NULL;
8082 /* remove-outfile built-in spec function.
8084 * This looks for the first argument in the outfiles array's name and
8085 * removes it. */
8087 static const char *
8088 remove_outfile_spec_function (int argc, const char **argv)
8090 int i;
8091 /* Must have exactly one argument. */
8092 if (argc != 1)
8093 abort ();
8095 for (i = 0; i < n_infiles; i++)
8097 if (outfiles[i] && !filename_cmp (outfiles[i], argv[0]))
8098 outfiles[i] = NULL;
8100 return NULL;
8103 /* Given two version numbers, compares the two numbers.
8104 A version number must match the regular expression
8105 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
8107 static int
8108 compare_version_strings (const char *v1, const char *v2)
8110 int rresult;
8111 regex_t r;
8113 if (regcomp (&r, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
8114 REG_EXTENDED | REG_NOSUB) != 0)
8115 abort ();
8116 rresult = regexec (&r, v1, 0, NULL, 0);
8117 if (rresult == REG_NOMATCH)
8118 fatal_error ("invalid version number %qs", v1);
8119 else if (rresult != 0)
8120 abort ();
8121 rresult = regexec (&r, v2, 0, NULL, 0);
8122 if (rresult == REG_NOMATCH)
8123 fatal_error ("invalid version number %qs", v2);
8124 else if (rresult != 0)
8125 abort ();
8127 return strverscmp (v1, v2);
8131 /* version_compare built-in spec function.
8133 This takes an argument of the following form:
8135 <comparison-op> <arg1> [<arg2>] <switch> <result>
8137 and produces "result" if the comparison evaluates to true,
8138 and nothing if it doesn't.
8140 The supported <comparison-op> values are:
8142 >= true if switch is a later (or same) version than arg1
8143 !> opposite of >=
8144 < true if switch is an earlier version than arg1
8145 !< opposite of <
8146 >< true if switch is arg1 or later, and earlier than arg2
8147 <> true if switch is earlier than arg1 or is arg2 or later
8149 If the switch is not present, the condition is false unless
8150 the first character of the <comparison-op> is '!'.
8152 For example,
8153 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
8154 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
8156 static const char *
8157 version_compare_spec_function (int argc, const char **argv)
8159 int comp1, comp2;
8160 size_t switch_len;
8161 const char *switch_value = NULL;
8162 int nargs = 1, i;
8163 bool result;
8165 if (argc < 3)
8166 fatal_error ("too few arguments to %%:version-compare");
8167 if (argv[0][0] == '\0')
8168 abort ();
8169 if ((argv[0][1] == '<' || argv[0][1] == '>') && argv[0][0] != '!')
8170 nargs = 2;
8171 if (argc != nargs + 3)
8172 fatal_error ("too many arguments to %%:version-compare");
8174 switch_len = strlen (argv[nargs + 1]);
8175 for (i = 0; i < n_switches; i++)
8176 if (!strncmp (switches[i].part1, argv[nargs + 1], switch_len)
8177 && check_live_switch (i, switch_len))
8178 switch_value = switches[i].part1 + switch_len;
8180 if (switch_value == NULL)
8181 comp1 = comp2 = -1;
8182 else
8184 comp1 = compare_version_strings (switch_value, argv[1]);
8185 if (nargs == 2)
8186 comp2 = compare_version_strings (switch_value, argv[2]);
8187 else
8188 comp2 = -1; /* This value unused. */
8191 switch (argv[0][0] << 8 | argv[0][1])
8193 case '>' << 8 | '=':
8194 result = comp1 >= 0;
8195 break;
8196 case '!' << 8 | '<':
8197 result = comp1 >= 0 || switch_value == NULL;
8198 break;
8199 case '<' << 8:
8200 result = comp1 < 0;
8201 break;
8202 case '!' << 8 | '>':
8203 result = comp1 < 0 || switch_value == NULL;
8204 break;
8205 case '>' << 8 | '<':
8206 result = comp1 >= 0 && comp2 < 0;
8207 break;
8208 case '<' << 8 | '>':
8209 result = comp1 < 0 || comp2 >= 0;
8210 break;
8212 default:
8213 fatal_error ("unknown operator %qs in %%:version-compare", argv[0]);
8215 if (! result)
8216 return NULL;
8218 return argv[nargs + 2];
8221 /* %:include builtin spec function. This differs from %include in that it
8222 can be nested inside a spec, and thus be conditionalized. It takes
8223 one argument, the filename, and looks for it in the startfile path.
8224 The result is always NULL, i.e. an empty expansion. */
8226 static const char *
8227 include_spec_function (int argc, const char **argv)
8229 char *file;
8231 if (argc != 1)
8232 abort ();
8234 file = find_a_file (&startfile_prefixes, argv[0], R_OK, true);
8235 read_specs (file ? file : argv[0], false, false);
8237 return NULL;
8240 /* %:find-file spec function. This function replaces its argument by
8241 the file found through find_file, that is the -print-file-name gcc
8242 program option. */
8243 static const char *
8244 find_file_spec_function (int argc, const char **argv)
8246 const char *file;
8248 if (argc != 1)
8249 abort ();
8251 file = find_file (argv[0]);
8252 return file;
8256 /* %:find-plugindir spec function. This function replaces its argument
8257 by the -iplugindir=<dir> option. `dir' is found through find_file, that
8258 is the -print-file-name gcc program option. */
8259 static const char *
8260 find_plugindir_spec_function (int argc, const char **argv ATTRIBUTE_UNUSED)
8262 const char *option;
8264 if (argc != 0)
8265 abort ();
8267 option = concat ("-iplugindir=", find_file ("plugin"), NULL);
8268 return option;
8272 /* %:print-asm-header spec function. Print a banner to say that the
8273 following output is from the assembler. */
8275 static const char *
8276 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED,
8277 const char **argv ATTRIBUTE_UNUSED)
8279 printf (_("Assembler options\n=================\n\n"));
8280 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
8281 fflush (stdout);
8282 return NULL;
8285 /* Get a random number for -frandom-seed */
8287 static unsigned HOST_WIDE_INT
8288 get_random_number (void)
8290 unsigned HOST_WIDE_INT ret = 0;
8291 int fd;
8293 fd = open ("/dev/urandom", O_RDONLY);
8294 if (fd >= 0)
8296 read (fd, &ret, sizeof (HOST_WIDE_INT));
8297 close (fd);
8298 if (ret)
8299 return ret;
8302 /* Get some more or less random data. */
8303 #ifdef HAVE_GETTIMEOFDAY
8305 struct timeval tv;
8307 gettimeofday (&tv, NULL);
8308 ret = tv.tv_sec * 1000 + tv.tv_usec / 1000;
8310 #else
8312 time_t now = time (NULL);
8314 if (now != (time_t)-1)
8315 ret = (unsigned) now;
8317 #endif
8319 return ret ^ getpid();
8322 /* %:compare-debug-dump-opt spec function. Save the last argument,
8323 expected to be the last -fdump-final-insns option, or generate a
8324 temporary. */
8326 static const char *
8327 compare_debug_dump_opt_spec_function (int arg,
8328 const char **argv ATTRIBUTE_UNUSED)
8330 char *ret;
8331 char *name;
8332 int which;
8333 static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];
8335 if (arg != 0)
8336 fatal_error ("too many arguments to %%:compare-debug-dump-opt");
8338 do_spec_2 ("%{fdump-final-insns=*:%*}");
8339 do_spec_1 (" ", 0, NULL);
8341 if (argbuf.length () > 0
8342 && strcmp (argv[argbuf.length () - 1], "."))
8344 if (!compare_debug)
8345 return NULL;
8347 name = xstrdup (argv[argbuf.length () - 1]);
8348 ret = NULL;
8350 else
8352 const char *ext = NULL;
8354 if (argbuf.length () > 0)
8356 do_spec_2 ("%{o*:%*}%{!o:%{!S:%b%O}%{S:%b.s}}");
8357 ext = ".gkd";
8359 else if (!compare_debug)
8360 return NULL;
8361 else
8362 do_spec_2 ("%g.gkd");
8364 do_spec_1 (" ", 0, NULL);
8366 gcc_assert (argbuf.length () > 0);
8368 name = concat (argbuf.last (), ext, NULL);
8370 ret = concat ("-fdump-final-insns=", name, NULL);
8373 which = compare_debug < 0;
8374 debug_check_temp_file[which] = name;
8376 if (!which)
8378 unsigned HOST_WIDE_INT value = get_random_number ();
8380 sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value);
8383 if (*random_seed)
8385 char *tmp = ret;
8386 ret = concat ("%{!frandom-seed=*:-frandom-seed=", random_seed, "} ",
8387 ret, NULL);
8388 free (tmp);
8391 if (which)
8392 *random_seed = 0;
8394 return ret;
8397 static const char *debug_auxbase_opt;
8399 /* %:compare-debug-self-opt spec function. Expands to the options
8400 that are to be passed in the second compilation of
8401 compare-debug. */
8403 static const char *
8404 compare_debug_self_opt_spec_function (int arg,
8405 const char **argv ATTRIBUTE_UNUSED)
8407 if (arg != 0)
8408 fatal_error ("too many arguments to %%:compare-debug-self-opt");
8410 if (compare_debug >= 0)
8411 return NULL;
8413 do_spec_2 ("%{c|S:%{o*:%*}}");
8414 do_spec_1 (" ", 0, NULL);
8416 if (argbuf.length () > 0)
8417 debug_auxbase_opt = concat ("-auxbase-strip ",
8418 argbuf.last (),
8419 NULL);
8420 else
8421 debug_auxbase_opt = NULL;
8423 return concat ("\
8424 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
8425 %<fdump-final-insns=* -w -S -o %j \
8426 %{!fcompare-debug-second:-fcompare-debug-second} \
8427 ", compare_debug_opt, NULL);
8430 /* %:compare-debug-auxbase-opt spec function. Expands to the auxbase
8431 options that are to be passed in the second compilation of
8432 compare-debug. It expects, as an argument, the basename of the
8433 current input file name, with the .gk suffix appended to it. */
8435 static const char *
8436 compare_debug_auxbase_opt_spec_function (int arg,
8437 const char **argv)
8439 char *name;
8440 int len;
8442 if (arg == 0)
8443 fatal_error ("too few arguments to %%:compare-debug-auxbase-opt");
8445 if (arg != 1)
8446 fatal_error ("too many arguments to %%:compare-debug-auxbase-opt");
8448 if (compare_debug >= 0)
8449 return NULL;
8451 len = strlen (argv[0]);
8452 if (len < 3 || strcmp (argv[0] + len - 3, ".gk") != 0)
8453 fatal_error ("argument to %%:compare-debug-auxbase-opt "
8454 "does not end in .gk");
8456 if (debug_auxbase_opt)
8457 return debug_auxbase_opt;
8459 #define OPT "-auxbase "
8461 len -= 3;
8462 name = (char*) xmalloc (sizeof (OPT) + len);
8463 memcpy (name, OPT, sizeof (OPT) - 1);
8464 memcpy (name + sizeof (OPT) - 1, argv[0], len);
8465 name[sizeof (OPT) - 1 + len] = '\0';
8467 #undef OPT
8469 return name;
8472 /* %:pass-through-libs spec function. Finds all -l options and input
8473 file names in the lib spec passed to it, and makes a list of them
8474 prepended with the plugin option to cause them to be passed through
8475 to the final link after all the new object files have been added. */
8477 const char *
8478 pass_through_libs_spec_func (int argc, const char **argv)
8480 char *prepended = xstrdup (" ");
8481 int n;
8482 /* Shlemiel the painter's algorithm. Innately horrible, but at least
8483 we know that there will never be more than a handful of strings to
8484 concat, and it's only once per run, so it's not worth optimising. */
8485 for (n = 0; n < argc; n++)
8487 char *old = prepended;
8488 /* Anything that isn't an option is a full path to an output
8489 file; pass it through if it ends in '.a'. Among options,
8490 pass only -l. */
8491 if (argv[n][0] == '-' && argv[n][1] == 'l')
8493 const char *lopt = argv[n] + 2;
8494 /* Handle both joined and non-joined -l options. If for any
8495 reason there's a trailing -l with no joined or following
8496 arg just discard it. */
8497 if (!*lopt && ++n >= argc)
8498 break;
8499 else if (!*lopt)
8500 lopt = argv[n];
8501 prepended = concat (prepended, "-plugin-opt=-pass-through=-l",
8502 lopt, " ", NULL);
8504 else if (!strcmp (".a", argv[n] + strlen (argv[n]) - 2))
8506 prepended = concat (prepended, "-plugin-opt=-pass-through=",
8507 argv[n], " ", NULL);
8509 if (prepended != old)
8510 free (old);
8512 return prepended;
8515 /* %:replace-extension spec function. Replaces the extension of the
8516 first argument with the second argument. */
8518 const char *
8519 replace_extension_spec_func (int argc, const char **argv)
8521 char *name;
8522 char *p;
8523 char *result;
8524 int i;
8526 if (argc != 2)
8527 fatal_error ("too few arguments to %%:replace-extension");
8529 name = xstrdup (argv[0]);
8531 for (i = strlen(name) - 1; i >= 0; i--)
8532 if (IS_DIR_SEPARATOR (name[i]))
8533 break;
8535 p = strrchr (name + i + 1, '.');
8536 if (p != NULL)
8537 *p = '\0';
8539 result = concat (name, argv[1], NULL);
8541 free (name);
8542 return result;
8545 /* Insert backslash before spaces in ORIG (usually a file path), to
8546 avoid being broken by spec parser.
8548 This function is needed as do_spec_1 treats white space (' ' and '\t')
8549 as the end of an argument. But in case of -plugin /usr/gcc install/xxx.so,
8550 the file name should be treated as a single argument rather than being
8551 broken into multiple. Solution is to insert '\\' before the space in a
8552 file name.
8554 This function converts and only converts all occurrence of ' '
8555 to '\\' + ' ' and '\t' to '\\' + '\t'. For example:
8556 "a b" -> "a\\ b"
8557 "a b" -> "a\\ \\ b"
8558 "a\tb" -> "a\\\tb"
8559 "a\\ b" -> "a\\\\ b"
8561 orig: input null-terminating string that was allocated by xalloc. The
8562 memory it points to might be freed in this function. Behavior undefined
8563 if ORIG wasn't xalloced or was freed already at entry.
8565 Return: ORIG if no conversion needed. Otherwise a newly allocated string
8566 that was converted from ORIG. */
8568 static char *
8569 convert_white_space (char *orig)
8571 int len, number_of_space = 0;
8573 for (len = 0; orig[len]; len++)
8574 if (orig[len] == ' ' || orig[len] == '\t') number_of_space++;
8576 if (number_of_space)
8578 char *new_spec = (char *) xmalloc (len + number_of_space + 1);
8579 int j, k;
8580 for (j = 0, k = 0; j <= len; j++, k++)
8582 if (orig[j] == ' ' || orig[j] == '\t')
8583 new_spec[k++] = '\\';
8584 new_spec[k] = orig[j];
8586 free (orig);
8587 return new_spec;
8589 else
8590 return orig;