* snames.ads-tmpl (Name_Ivdep): New pragma-related name.
[official-gcc.git] / gcc / gcc.c
blob5cb485acbd3470c7161fc6a3393643bfd07053a8
1 /* Compiler driver program that can handle many languages.
2 Copyright (C) 1987-2014 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 /* Linker suffix passed to -fuse-ld=... */
109 static const char *use_ld;
111 /* Whether we should report subprocess execution times to a file. */
113 FILE *report_times_to_file = NULL;
115 /* Nonzero means place this string before uses of /, so that include
116 and library files can be found in an alternate location. */
118 #ifdef TARGET_SYSTEM_ROOT
119 static const char *target_system_root = TARGET_SYSTEM_ROOT;
120 #else
121 static const char *target_system_root = 0;
122 #endif
124 /* Nonzero means pass the updated target_system_root to the compiler. */
126 static int target_system_root_changed;
128 /* Nonzero means append this string to target_system_root. */
130 static const char *target_sysroot_suffix = 0;
132 /* Nonzero means append this string to target_system_root for headers. */
134 static const char *target_sysroot_hdrs_suffix = 0;
136 /* Nonzero means write "temp" files in source directory
137 and use the source file's name in them, and don't delete them. */
139 static enum save_temps {
140 SAVE_TEMPS_NONE, /* no -save-temps */
141 SAVE_TEMPS_CWD, /* -save-temps in current directory */
142 SAVE_TEMPS_OBJ /* -save-temps in object directory */
143 } save_temps_flag;
145 /* Output file to use to get the object directory for -save-temps=obj */
146 static char *save_temps_prefix = 0;
147 static size_t save_temps_length = 0;
149 /* The compiler version. */
151 static const char *compiler_version;
153 /* The target version. */
155 static const char *const spec_version = DEFAULT_TARGET_VERSION;
157 /* The target machine. */
159 static const char *spec_machine = DEFAULT_TARGET_MACHINE;
161 /* Nonzero if cross-compiling.
162 When -b is used, the value comes from the `specs' file. */
164 #ifdef CROSS_DIRECTORY_STRUCTURE
165 static const char *cross_compile = "1";
166 #else
167 static const char *cross_compile = "0";
168 #endif
170 /* Greatest exit code of sub-processes that has been encountered up to
171 now. */
172 static int greatest_status = 1;
174 /* This is the obstack which we use to allocate many strings. */
176 static struct obstack obstack;
178 /* This is the obstack to build an environment variable to pass to
179 collect2 that describes all of the relevant switches of what to
180 pass the compiler in building the list of pointers to constructors
181 and destructors. */
183 static struct obstack collect_obstack;
185 /* Forward declaration for prototypes. */
186 struct path_prefix;
187 struct prefix_list;
189 static void init_spec (void);
190 static void store_arg (const char *, int, int);
191 static void insert_wrapper (const char *);
192 static char *load_specs (const char *);
193 static void read_specs (const char *, bool, bool);
194 static void set_spec (const char *, const char *, bool);
195 static struct compiler *lookup_compiler (const char *, size_t, const char *);
196 static char *build_search_list (const struct path_prefix *, const char *,
197 bool, bool);
198 static void xputenv (const char *);
199 static void putenv_from_prefixes (const struct path_prefix *, const char *,
200 bool);
201 static int access_check (const char *, int);
202 static char *find_a_file (const struct path_prefix *, const char *, int, bool);
203 static void add_prefix (struct path_prefix *, const char *, const char *,
204 int, int, int);
205 static void add_sysrooted_prefix (struct path_prefix *, const char *,
206 const char *, int, int, int);
207 static char *skip_whitespace (char *);
208 static void delete_if_ordinary (const char *);
209 static void delete_temp_files (void);
210 static void delete_failure_queue (void);
211 static void clear_failure_queue (void);
212 static int check_live_switch (int, int);
213 static const char *handle_braces (const char *);
214 static inline bool input_suffix_matches (const char *, const char *);
215 static inline bool switch_matches (const char *, const char *, int);
216 static inline void mark_matching_switches (const char *, const char *, int);
217 static inline void process_marked_switches (void);
218 static const char *process_brace_body (const char *, const char *, const char *, int, int);
219 static const struct spec_function *lookup_spec_function (const char *);
220 static const char *eval_spec_function (const char *, const char *);
221 static const char *handle_spec_function (const char *, bool *);
222 static char *save_string (const char *, int);
223 static void set_collect_gcc_options (void);
224 static int do_spec_1 (const char *, int, const char *);
225 static int do_spec_2 (const char *);
226 static void do_option_spec (const char *, const char *);
227 static void do_self_spec (const char *);
228 static const char *find_file (const char *);
229 static int is_directory (const char *, bool);
230 static const char *validate_switches (const char *, bool);
231 static void validate_all_switches (void);
232 static inline void validate_switches_from_spec (const char *, bool);
233 static void give_switch (int, int);
234 static int used_arg (const char *, int);
235 static int default_arg (const char *, int);
236 static void set_multilib_dir (void);
237 static void print_multilib_info (void);
238 static void perror_with_name (const char *);
239 static void display_help (void);
240 static void add_preprocessor_option (const char *, int);
241 static void add_assembler_option (const char *, int);
242 static void add_linker_option (const char *, int);
243 static void process_command (unsigned int, struct cl_decoded_option *);
244 static int execute (void);
245 static void alloc_args (void);
246 static void clear_args (void);
247 static void fatal_signal (int);
248 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
249 static void init_gcc_specs (struct obstack *, const char *, const char *,
250 const char *);
251 #endif
252 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
253 static const char *convert_filename (const char *, int, int);
254 #endif
256 static const char *getenv_spec_function (int, const char **);
257 static const char *if_exists_spec_function (int, const char **);
258 static const char *if_exists_else_spec_function (int, const char **);
259 static const char *sanitize_spec_function (int, const char **);
260 static const char *replace_outfile_spec_function (int, const char **);
261 static const char *remove_outfile_spec_function (int, const char **);
262 static const char *version_compare_spec_function (int, const char **);
263 static const char *include_spec_function (int, const char **);
264 static const char *find_file_spec_function (int, const char **);
265 static const char *find_plugindir_spec_function (int, const char **);
266 static const char *print_asm_header_spec_function (int, const char **);
267 static const char *compare_debug_dump_opt_spec_function (int, const char **);
268 static const char *compare_debug_self_opt_spec_function (int, const char **);
269 static const char *compare_debug_auxbase_opt_spec_function (int, const char **);
270 static const char *pass_through_libs_spec_func (int, const char **);
271 static const char *replace_extension_spec_func (int, const char **);
272 static char *convert_white_space (char *);
274 /* The Specs Language
276 Specs are strings containing lines, each of which (if not blank)
277 is made up of a program name, and arguments separated by spaces.
278 The program name must be exact and start from root, since no path
279 is searched and it is unreliable to depend on the current working directory.
280 Redirection of input or output is not supported; the subprograms must
281 accept filenames saying what files to read and write.
283 In addition, the specs can contain %-sequences to substitute variable text
284 or for conditional text. Here is a table of all defined %-sequences.
285 Note that spaces are not generated automatically around the results of
286 expanding these sequences; therefore, you can concatenate them together
287 or with constant text in a single argument.
289 %% substitute one % into the program name or argument.
290 %i substitute the name of the input file being processed.
291 %b substitute the basename of the input file being processed.
292 This is the substring up to (and not including) the last period
293 and not including the directory unless -save-temps was specified
294 to put temporaries in a different location.
295 %B same as %b, but include the file suffix (text after the last period).
296 %gSUFFIX
297 substitute a file name that has suffix SUFFIX and is chosen
298 once per compilation, and mark the argument a la %d. To reduce
299 exposure to denial-of-service attacks, the file name is now
300 chosen in a way that is hard to predict even when previously
301 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
302 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
303 the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
304 had been pre-processed. Previously, %g was simply substituted
305 with a file name chosen once per compilation, without regard
306 to any appended suffix (which was therefore treated just like
307 ordinary text), making such attacks more likely to succeed.
308 %|SUFFIX
309 like %g, but if -pipe is in effect, expands simply to "-".
310 %mSUFFIX
311 like %g, but if -pipe is in effect, expands to nothing. (We have both
312 %| and %m to accommodate differences between system assemblers; see
313 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
314 %uSUFFIX
315 like %g, but generates a new temporary file name even if %uSUFFIX
316 was already seen.
317 %USUFFIX
318 substitutes the last file name generated with %uSUFFIX, generating a
319 new one if there is no such last file name. In the absence of any
320 %uSUFFIX, this is just like %gSUFFIX, except they don't share
321 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
322 would involve the generation of two distinct file names, one
323 for each `%g.s' and another for each `%U.s'. Previously, %U was
324 simply substituted with a file name chosen for the previous %u,
325 without regard to any appended suffix.
326 %jSUFFIX
327 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
328 writable, and if save-temps is off; otherwise, substitute the name
329 of a temporary file, just like %u. This temporary file is not
330 meant for communication between processes, but rather as a junk
331 disposal mechanism.
332 %.SUFFIX
333 substitutes .SUFFIX for the suffixes of a matched switch's args when
334 it is subsequently output with %*. SUFFIX is terminated by the next
335 space or %.
336 %d marks the argument containing or following the %d as a
337 temporary file name, so that that file will be deleted if GCC exits
338 successfully. Unlike %g, this contributes no text to the argument.
339 %w marks the argument containing or following the %w as the
340 "output file" of this compilation. This puts the argument
341 into the sequence of arguments that %o will substitute later.
342 %V indicates that this compilation produces no "output file".
343 %W{...}
344 like %{...} but mark last argument supplied within
345 as a file to be deleted on failure.
346 %o substitutes the names of all the output files, with spaces
347 automatically placed around them. You should write spaces
348 around the %o as well or the results are undefined.
349 %o is for use in the specs for running the linker.
350 Input files whose names have no recognized suffix are not compiled
351 at all, but they are included among the output files, so they will
352 be linked.
353 %O substitutes the suffix for object files. Note that this is
354 handled specially when it immediately follows %g, %u, or %U
355 (with or without a suffix argument) because of the need for
356 those to form complete file names. The handling is such that
357 %O is treated exactly as if it had already been substituted,
358 except that %g, %u, and %U do not currently support additional
359 SUFFIX characters following %O as they would following, for
360 example, `.o'.
361 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
362 (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
363 and -B options) and -imultilib as necessary.
364 %s current argument is the name of a library or startup file of some sort.
365 Search for that file in a standard list of directories
366 and substitute the full name found.
367 %eSTR Print STR as an error message. STR is terminated by a newline.
368 Use this when inconsistent options are detected.
369 %nSTR Print STR as a notice. STR is terminated by a newline.
370 %x{OPTION} Accumulate an option for %X.
371 %X Output the accumulated linker options specified by compilations.
372 %Y Output the accumulated assembler options specified by compilations.
373 %Z Output the accumulated preprocessor options specified by compilations.
374 %a process ASM_SPEC as a spec.
375 This allows config.h to specify part of the spec for running as.
376 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
377 used here. This can be used to run a post-processor after the
378 assembler has done its job.
379 %D Dump out a -L option for each directory in startfile_prefixes.
380 If multilib_dir is set, extra entries are generated with it affixed.
381 %l process LINK_SPEC as a spec.
382 %L process LIB_SPEC as a spec.
383 %M Output multilib_os_dir.
384 %G process LIBGCC_SPEC as a spec.
385 %R Output the concatenation of target_system_root and
386 target_sysroot_suffix.
387 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
388 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
389 %C process CPP_SPEC as a spec.
390 %1 process CC1_SPEC as a spec.
391 %2 process CC1PLUS_SPEC as a spec.
392 %* substitute the variable part of a matched option. (See below.)
393 Note that each comma in the substituted string is replaced by
394 a single space. A space is appended after the last substition
395 unless there is more text in current sequence.
396 %<S remove all occurrences of -S from the command line.
397 Note - this command is position dependent. % commands in the
398 spec string before this one will see -S, % commands in the
399 spec string after this one will not.
400 %>S Similar to "%<S", but keep it in the GCC command line.
401 %<S* remove all occurrences of all switches beginning with -S from the
402 command line.
403 %:function(args)
404 Call the named function FUNCTION, passing it ARGS. ARGS is
405 first processed as a nested spec string, then split into an
406 argument vector in the usual fashion. The function returns
407 a string which is processed as if it had appeared literally
408 as part of the current spec.
409 %{S} substitutes the -S switch, if that switch was given to GCC.
410 If that switch was not specified, this substitutes nothing.
411 Here S is a metasyntactic variable.
412 %{S*} substitutes all the switches specified to GCC whose names start
413 with -S. This is used for -o, -I, etc; switches that take
414 arguments. GCC considers `-o foo' as being one switch whose
415 name starts with `o'. %{o*} would substitute this text,
416 including the space; thus, two arguments would be generated.
417 %{S*&T*} likewise, but preserve order of S and T options (the order
418 of S and T in the spec is not significant). Can be any number
419 of ampersand-separated variables; for each the wild card is
420 optional. Useful for CPP as %{D*&U*&A*}.
422 %{S:X} substitutes X, if the -S switch was given to GCC.
423 %{!S:X} substitutes X, if the -S switch was NOT given to GCC.
424 %{S*:X} substitutes X if one or more switches whose names start
425 with -S was given to GCC. Normally X is substituted only
426 once, no matter how many such switches appeared. However,
427 if %* appears somewhere in X, then X will be substituted
428 once for each matching switch, with the %* replaced by the
429 part of that switch that matched the '*'. A space will be
430 appended after the last substition unless there is more
431 text in current sequence.
432 %{.S:X} substitutes X, if processing a file with suffix S.
433 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
434 %{,S:X} substitutes X, if processing a file which will use spec S.
435 %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
437 %{S|T:X} substitutes X if either -S or -T was given to GCC. This may be
438 combined with '!', '.', ',', and '*' as above binding stronger
439 than the OR.
440 If %* appears in X, all of the alternatives must be starred, and
441 only the first matching alternative is substituted.
442 %{%:function(args):X}
443 Call function named FUNCTION with args ARGS. If the function
444 returns non-NULL, then X is substituted, if it returns
445 NULL, it isn't substituted.
446 %{S:X; if S was given to GCC, substitutes X;
447 T:Y; else if T was given to GCC, substitutes Y;
448 :D} else substitutes D. There can be as many clauses as you need.
449 This may be combined with '.', '!', ',', '|', and '*' as above.
451 %(Spec) processes a specification defined in a specs file as *Spec:
453 The conditional text X in a %{S:X} or similar construct may contain
454 other nested % constructs or spaces, or even newlines. They are
455 processed as usual, as described above. Trailing white space in X is
456 ignored. White space may also appear anywhere on the left side of the
457 colon in these constructs, except between . or * and the corresponding
458 word.
460 The -O, -f, -g, -m, and -W switches are handled specifically in these
461 constructs. If another value of -O or the negated form of a -f, -m, or
462 -W switch is found later in the command line, the earlier switch
463 value is ignored, except with {S*} where S is just one letter; this
464 passes all matching options.
466 The character | at the beginning of the predicate text is used to indicate
467 that a command should be piped to the following command, but only if -pipe
468 is specified.
470 Note that it is built into GCC which switches take arguments and which
471 do not. You might think it would be useful to generalize this to
472 allow each compiler's spec to say which switches take arguments. But
473 this cannot be done in a consistent fashion. GCC cannot even decide
474 which input files have been specified without knowing which switches
475 take arguments, and it must know which input files to compile in order
476 to tell which compilers to run.
478 GCC also knows implicitly that arguments starting in `-l' are to be
479 treated as compiler output files, and passed to the linker in their
480 proper position among the other output files. */
482 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
484 /* config.h can define ASM_SPEC to provide extra args to the assembler
485 or extra switch-translations. */
486 #ifndef ASM_SPEC
487 #define ASM_SPEC ""
488 #endif
490 /* config.h can define ASM_FINAL_SPEC to run a post processor after
491 the assembler has run. */
492 #ifndef ASM_FINAL_SPEC
493 #define ASM_FINAL_SPEC \
494 "%{gsplit-dwarf: \n\
495 objcopy --extract-dwo \
496 %{c:%{o*:%*}%{!o*:%b%O}}%{!c:%U%O} \
497 %{c:%{o*:%:replace-extension(%{o*:%*} .dwo)}%{!o*:%b.dwo}}%{!c:%b.dwo} \n\
498 objcopy --strip-dwo \
499 %{c:%{o*:%*}%{!o*:%b%O}}%{!c:%U%O} \
501 #endif
503 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
504 or extra switch-translations. */
505 #ifndef CPP_SPEC
506 #define CPP_SPEC ""
507 #endif
509 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
510 or extra switch-translations. */
511 #ifndef CC1_SPEC
512 #define CC1_SPEC ""
513 #endif
515 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
516 or extra switch-translations. */
517 #ifndef CC1PLUS_SPEC
518 #define CC1PLUS_SPEC ""
519 #endif
521 /* config.h can define LINK_SPEC to provide extra args to the linker
522 or extra switch-translations. */
523 #ifndef LINK_SPEC
524 #define LINK_SPEC ""
525 #endif
527 /* config.h can define LIB_SPEC to override the default libraries. */
528 #ifndef LIB_SPEC
529 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
530 #endif
532 /* When using -fsplit-stack we need to wrap pthread_create, in order
533 to initialize the stack guard. We always use wrapping, rather than
534 shared library ordering, and we keep the wrapper function in
535 libgcc. This is not yet a real spec, though it could become one;
536 it is currently just stuffed into LINK_SPEC. FIXME: This wrapping
537 only works with GNU ld and gold. */
538 #define STACK_SPLIT_SPEC " %{fsplit-stack: --wrap=pthread_create}"
540 #ifndef LIBASAN_SPEC
541 #define STATIC_LIBASAN_LIBS \
542 " %{static-libasan:%:include(libsanitizer.spec)%(link_libasan)}"
543 #ifdef LIBASAN_EARLY_SPEC
544 #define LIBASAN_SPEC STATIC_LIBASAN_LIBS
545 #elif defined(HAVE_LD_STATIC_DYNAMIC)
546 #define LIBASAN_SPEC "%{static-libasan:" LD_STATIC_OPTION \
547 "} -lasan %{static-libasan:" LD_DYNAMIC_OPTION "}" \
548 STATIC_LIBASAN_LIBS
549 #else
550 #define LIBASAN_SPEC "-lasan" STATIC_LIBASAN_LIBS
551 #endif
552 #endif
554 #ifndef LIBASAN_EARLY_SPEC
555 #define LIBASAN_EARLY_SPEC ""
556 #endif
558 #ifndef LIBTSAN_SPEC
559 #define STATIC_LIBTSAN_LIBS \
560 " %{static-libtsan:%:include(libsanitizer.spec)%(link_libtsan)}"
561 #ifdef LIBTSAN_EARLY_SPEC
562 #define LIBTSAN_SPEC STATIC_LIBTSAN_LIBS
563 #elif defined(HAVE_LD_STATIC_DYNAMIC)
564 #define LIBTSAN_SPEC "%{static-libtsan:" LD_STATIC_OPTION \
565 "} -ltsan %{static-libtsan:" LD_DYNAMIC_OPTION "}" \
566 STATIC_LIBTSAN_LIBS
567 #else
568 #define LIBTSAN_SPEC "-ltsan" STATIC_LIBTSAN_LIBS
569 #endif
570 #endif
572 #ifndef LIBTSAN_EARLY_SPEC
573 #define LIBTSAN_EARLY_SPEC ""
574 #endif
576 #ifndef LIBLSAN_SPEC
577 #define STATIC_LIBLSAN_LIBS \
578 " %{static-liblsan:%:include(libsanitizer.spec)%(link_liblsan)}"
579 #ifdef HAVE_LD_STATIC_DYNAMIC
580 #define LIBLSAN_SPEC "%{!shared:%{static-liblsan:" LD_STATIC_OPTION \
581 "} -llsan %{static-liblsan:" LD_DYNAMIC_OPTION "}" \
582 STATIC_LIBLSAN_LIBS "}"
583 #else
584 #define LIBLSAN_SPEC "%{!shared:-llsan" STATIC_LIBLSAN_LIBS "}"
585 #endif
586 #endif
588 #ifndef LIBUBSAN_SPEC
589 #define STATIC_LIBUBSAN_LIBS \
590 " %{static-libubsan:%:include(libsanitizer.spec)%(link_libubsan)}"
591 #ifdef HAVE_LD_STATIC_DYNAMIC
592 #define LIBUBSAN_SPEC "%{static-libubsan:" LD_STATIC_OPTION \
593 "} -lubsan %{static-libubsan:" LD_DYNAMIC_OPTION "}" \
594 STATIC_LIBUBSAN_LIBS
595 #else
596 #define LIBUBSAN_SPEC "-lubsan" STATIC_LIBUBSAN_LIBS
597 #endif
598 #endif
600 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
601 included. */
602 #ifndef LIBGCC_SPEC
603 #if defined(REAL_LIBGCC_SPEC)
604 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
605 #elif defined(LINK_LIBGCC_SPECIAL_1)
606 /* Have gcc do the search for libgcc.a. */
607 #define LIBGCC_SPEC "libgcc.a%s"
608 #else
609 #define LIBGCC_SPEC "-lgcc"
610 #endif
611 #endif
613 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
614 #ifndef STARTFILE_SPEC
615 #define STARTFILE_SPEC \
616 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
617 #endif
619 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
620 #ifndef ENDFILE_SPEC
621 #define ENDFILE_SPEC ""
622 #endif
624 #ifndef LINKER_NAME
625 #define LINKER_NAME "collect2"
626 #endif
628 #ifdef HAVE_AS_DEBUG_PREFIX_MAP
629 #define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
630 #else
631 #define ASM_MAP ""
632 #endif
634 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
635 to the assembler. */
636 #ifndef ASM_DEBUG_SPEC
637 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
638 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
639 # define ASM_DEBUG_SPEC \
640 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
641 ? "%{!g0:%{gdwarf*:--gdwarf2}%{!gdwarf*:%{g*:--gstabs}}}" ASM_MAP \
642 : "%{!g0:%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}}" ASM_MAP)
643 # else
644 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
645 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gstabs}}" ASM_MAP
646 # endif
647 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
648 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gdwarf2}}" ASM_MAP
649 # endif
650 # endif
651 #endif
652 #ifndef ASM_DEBUG_SPEC
653 # define ASM_DEBUG_SPEC ""
654 #endif
656 /* Here is the spec for running the linker, after compiling all files. */
658 /* This is overridable by the target in case they need to specify the
659 -lgcc and -lc order specially, yet not require them to override all
660 of LINK_COMMAND_SPEC. */
661 #ifndef LINK_GCC_C_SEQUENCE_SPEC
662 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
663 #endif
665 #ifndef LINK_SSP_SPEC
666 #ifdef TARGET_LIBC_PROVIDES_SSP
667 #define LINK_SSP_SPEC "%{fstack-protector:}"
668 #else
669 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-strong|fstack-protector-all:-lssp_nonshared -lssp}"
670 #endif
671 #endif
673 #ifndef LINK_PIE_SPEC
674 #ifdef HAVE_LD_PIE
675 #define LINK_PIE_SPEC "%{pie:-pie} "
676 #else
677 #define LINK_PIE_SPEC "%{pie:} "
678 #endif
679 #endif
681 #ifndef LINK_BUILDID_SPEC
682 # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
683 # define LINK_BUILDID_SPEC "%{!r:--build-id} "
684 # endif
685 #endif
687 /* Conditional to test whether the LTO plugin is used or not.
688 FIXME: For slim LTO we will need to enable plugin unconditionally. This
689 still cause problems with PLUGIN_LD != LD and when plugin is built but
690 not useable. For GCC 4.6 we don't support slim LTO and thus we can enable
691 plugin only when LTO is enabled. We still honor explicit
692 -fuse-linker-plugin if the linker used understands -plugin. */
694 /* The linker has some plugin support. */
695 #if HAVE_LTO_PLUGIN > 0
696 /* The linker used has full plugin support, use LTO plugin by default. */
697 #if HAVE_LTO_PLUGIN == 2
698 #define PLUGIN_COND "!fno-use-linker-plugin:%{!fno-lto"
699 #define PLUGIN_COND_CLOSE "}"
700 #else
701 /* The linker used has limited plugin support, use LTO plugin with explicit
702 -fuse-linker-plugin. */
703 #define PLUGIN_COND "fuse-linker-plugin"
704 #define PLUGIN_COND_CLOSE ""
705 #endif
706 #define LINK_PLUGIN_SPEC \
707 "%{"PLUGIN_COND": \
708 -plugin %(linker_plugin_file) \
709 -plugin-opt=%(lto_wrapper) \
710 -plugin-opt=-fresolution=%u.res \
711 %{!nostdlib:%{!nodefaultlibs:%:pass-through-libs(%(link_gcc_c_sequence))}} \
712 }"PLUGIN_COND_CLOSE
713 #else
714 /* The linker used doesn't support -plugin, reject -fuse-linker-plugin. */
715 #define LINK_PLUGIN_SPEC "%{fuse-linker-plugin:\
716 %e-fuse-linker-plugin is not supported in this configuration}"
717 #endif
719 /* Linker command line options for -fsanitize= early on the command line. */
720 #ifndef SANITIZER_EARLY_SPEC
721 #define SANITIZER_EARLY_SPEC "\
722 %{!nostdlib:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_EARLY_SPEC "} \
723 %{%:sanitize(thread):" LIBTSAN_EARLY_SPEC "}}}"
724 #endif
726 /* Linker command line options for -fsanitize= late on the command line. */
727 #ifndef SANITIZER_SPEC
728 #define SANITIZER_SPEC "\
729 %{!nostdlib:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_SPEC "\
730 %{static:%ecannot specify -static with -fsanitize=address}\
731 %{%:sanitize(thread):%e-fsanitize=address is incompatible with -fsanitize=thread}}\
732 %{%:sanitize(thread):" LIBTSAN_SPEC "\
733 %{!pie:%{!shared:%e-fsanitize=thread linking must be done with -pie or -shared}}}\
734 %{%:sanitize(undefined):" LIBUBSAN_SPEC "}\
735 %{%:sanitize(leak):" LIBLSAN_SPEC "}}}"
736 #endif
738 /* This is the spec to use, once the code for creating the vtable
739 verification runtime library, libvtv.so, has been created. Currently
740 the vtable verification runtime functions are in libstdc++, so we use
741 the spec just below this one. */
742 #ifndef VTABLE_VERIFICATION_SPEC
743 #define VTABLE_VERIFICATION_SPEC "\
744 %{!nostdlib:%{fvtable-verify=std: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}\
745 %{fvtable-verify=preinit: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}}"
746 #endif
748 /* -u* was put back because both BSD and SysV seem to support it. */
749 /* %{static:} simply prevents an error message if the target machine
750 doesn't handle -static. */
751 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
752 scripts which exist in user specified directories, or in standard
753 directories. */
754 /* We pass any -flto flags on to the linker, which is expected
755 to understand them. In practice, this means it had better be collect2. */
756 /* %{e*} includes -export-dynamic; see comment in common.opt. */
757 #ifndef LINK_COMMAND_SPEC
758 #define LINK_COMMAND_SPEC "\
759 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
760 %(linker) " \
761 LINK_PLUGIN_SPEC \
762 "%{flto|flto=*:%<fcompare-debug*} \
763 %{flto} %{flto=*} %l " LINK_PIE_SPEC \
764 "%{fuse-ld=*:-fuse-ld=%*}\
765 %X %{o*} %{e*} %{N} %{n} %{r}\
766 %{s} %{t} %{u*} %{z} %{Z} %{!nostdlib:%{!nostartfiles:%S}} " VTABLE_VERIFICATION_SPEC " \
767 %{static:} %{L*} %(mfwrap) %(link_libgcc) " SANITIZER_EARLY_SPEC " %o\
768 %{fopenmp|ftree-parallelize-loops=*:%:include(libgomp.spec)%(link_gomp)}\
769 %{fcilkplus:%:include(libcilkrts.spec)%(link_cilkrts)}\
770 %{fgnu-tm:%:include(libitm.spec)%(link_itm)}\
771 %(mflib) " STACK_SPLIT_SPEC "\
772 %{fprofile-arcs|fprofile-generate*|coverage:-lgcov} " SANITIZER_SPEC " \
773 %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\
774 %{!nostdlib:%{!nostartfiles:%E}} %{T*} }}}}}}"
775 #endif
777 #ifndef LINK_LIBGCC_SPEC
778 /* Generate -L options for startfile prefix list. */
779 # define LINK_LIBGCC_SPEC "%D"
780 #endif
782 #ifndef STARTFILE_PREFIX_SPEC
783 # define STARTFILE_PREFIX_SPEC ""
784 #endif
786 #ifndef SYSROOT_SPEC
787 # define SYSROOT_SPEC "--sysroot=%R"
788 #endif
790 #ifndef SYSROOT_SUFFIX_SPEC
791 # define SYSROOT_SUFFIX_SPEC ""
792 #endif
794 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
795 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
796 #endif
798 static const char *asm_debug = ASM_DEBUG_SPEC;
799 static const char *cpp_spec = CPP_SPEC;
800 static const char *cc1_spec = CC1_SPEC;
801 static const char *cc1plus_spec = CC1PLUS_SPEC;
802 static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC;
803 static const char *link_ssp_spec = LINK_SSP_SPEC;
804 static const char *asm_spec = ASM_SPEC;
805 static const char *asm_final_spec = ASM_FINAL_SPEC;
806 static const char *link_spec = LINK_SPEC;
807 static const char *lib_spec = LIB_SPEC;
808 static const char *link_gomp_spec = "";
809 static const char *libgcc_spec = LIBGCC_SPEC;
810 static const char *endfile_spec = ENDFILE_SPEC;
811 static const char *startfile_spec = STARTFILE_SPEC;
812 static const char *linker_name_spec = LINKER_NAME;
813 static const char *linker_plugin_file_spec = "";
814 static const char *lto_wrapper_spec = "";
815 static const char *lto_gcc_spec = "";
816 static const char *link_command_spec = LINK_COMMAND_SPEC;
817 static const char *link_libgcc_spec = LINK_LIBGCC_SPEC;
818 static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC;
819 static const char *sysroot_spec = SYSROOT_SPEC;
820 static const char *sysroot_suffix_spec = SYSROOT_SUFFIX_SPEC;
821 static const char *sysroot_hdrs_suffix_spec = SYSROOT_HEADERS_SUFFIX_SPEC;
822 static const char *self_spec = "";
824 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
825 There should be no need to override these in target dependent files,
826 but we need to copy them to the specs file so that newer versions
827 of the GCC driver can correctly drive older tool chains with the
828 appropriate -B options. */
830 /* When cpplib handles traditional preprocessing, get rid of this, and
831 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
832 that we default the front end language better. */
833 static const char *trad_capable_cpp =
834 "cc1 -E %{traditional|traditional-cpp:-traditional-cpp}";
836 /* We don't wrap .d files in %W{} since a missing .d file, and
837 therefore no dependency entry, confuses make into thinking a .o
838 file that happens to exist is up-to-date. */
839 static const char *cpp_unique_options =
840 "%{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\
841 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
842 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
843 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
844 %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
845 %{remap} %{g3|ggdb3|gstabs3|gcoff3|gxcoff3|gvms3:-dD}\
846 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
847 %{H} %C %{D*&U*&A*} %{i*} %Z %i\
848 %{E|M|MM:%W{o*}}";
850 /* This contains cpp options which are common with cc1_options and are passed
851 only when preprocessing only to avoid duplication. We pass the cc1 spec
852 options to the preprocessor so that it the cc1 spec may manipulate
853 options used to set target flags. Those special target flags settings may
854 in turn cause preprocessor symbols to be defined specially. */
855 static const char *cpp_options =
856 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
857 %{f*} %{g*:%{!g0:%{g*} %{!fno-working-directory:-fworking-directory}}} %{O*}\
858 %{undef} %{save-temps*:-fpch-preprocess}";
860 /* This contains cpp options which are not passed when the preprocessor
861 output will be used by another program. */
862 static const char *cpp_debug_options = "%{d*}";
864 /* NB: This is shared amongst all front-ends, except for Ada. */
865 static const char *cc1_options =
866 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
867 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
868 %1 %{!Q:-quiet} %{!dumpbase:-dumpbase %B} %{d*} %{m*} %{aux-info*}\
869 %{fcompare-debug-second:%:compare-debug-auxbase-opt(%b)} \
870 %{!fcompare-debug-second:%{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}}%{!c:%{!S:-auxbase %b}} \
871 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
872 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
873 %{Qn:-fno-ident} %{Qy:} %{-help:--help}\
874 %{-target-help:--target-help}\
875 %{-version:--version}\
876 %{-help=*:--help=%*}\
877 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
878 %{fsyntax-only:-o %j} %{-param*}\
879 %{coverage:-fprofile-arcs -ftest-coverage}";
881 static const char *asm_options =
882 "%{-target-help:%:print-asm-header()} "
883 #if HAVE_GNU_AS
884 /* If GNU AS is used, then convert -w (no warnings), -I, and -v
885 to the assembler equivalents. */
886 "%{v} %{w:-W} %{I*} "
887 #endif
888 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
890 static const char *invoke_as =
891 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
892 "%{!fwpa*:\
893 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
894 %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
896 #else
897 "%{!fwpa*:\
898 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
899 %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
901 #endif
903 /* Some compilers have limits on line lengths, and the multilib_select
904 and/or multilib_matches strings can be very long, so we build them at
905 run time. */
906 static struct obstack multilib_obstack;
907 static const char *multilib_select;
908 static const char *multilib_matches;
909 static const char *multilib_defaults;
910 static const char *multilib_exclusions;
911 static const char *multilib_reuse;
913 /* Check whether a particular argument is a default argument. */
915 #ifndef MULTILIB_DEFAULTS
916 #define MULTILIB_DEFAULTS { "" }
917 #endif
919 static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
921 #ifndef DRIVER_SELF_SPECS
922 #define DRIVER_SELF_SPECS ""
923 #endif
925 /* Linking to libgomp implies pthreads. This is particularly important
926 for targets that use different start files and suchlike. */
927 #ifndef GOMP_SELF_SPECS
928 #define GOMP_SELF_SPECS "%{fopenmp|ftree-parallelize-loops=*: -pthread}"
929 #endif
931 /* Likewise for -fgnu-tm. */
932 #ifndef GTM_SELF_SPECS
933 #define GTM_SELF_SPECS "%{fgnu-tm: -pthread}"
934 #endif
936 /* Likewise for -fcilkplus. */
937 #ifndef CILK_SELF_SPECS
938 #define CILK_SELF_SPECS "%{fcilkplus: -pthread}"
939 #endif
941 static const char *const driver_self_specs[] = {
942 "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
943 DRIVER_SELF_SPECS, CONFIGURE_SPECS, GOMP_SELF_SPECS, GTM_SELF_SPECS,
944 CILK_SELF_SPECS
947 #ifndef OPTION_DEFAULT_SPECS
948 #define OPTION_DEFAULT_SPECS { "", "" }
949 #endif
951 struct default_spec
953 const char *name;
954 const char *spec;
957 static const struct default_spec
958 option_default_specs[] = { OPTION_DEFAULT_SPECS };
960 struct user_specs
962 struct user_specs *next;
963 const char *filename;
966 static struct user_specs *user_specs_head, *user_specs_tail;
969 /* Record the mapping from file suffixes for compilation specs. */
971 struct compiler
973 const char *suffix; /* Use this compiler for input files
974 whose names end in this suffix. */
976 const char *spec; /* To use this compiler, run this spec. */
978 const char *cpp_spec; /* If non-NULL, substitute this spec
979 for `%C', rather than the usual
980 cpp_spec. */
981 const int combinable; /* If nonzero, compiler can deal with
982 multiple source files at once (IMA). */
983 const int needs_preprocessing; /* If nonzero, source files need to
984 be run through a preprocessor. */
987 /* Pointer to a vector of `struct compiler' that gives the spec for
988 compiling a file, based on its suffix.
989 A file that does not end in any of these suffixes will be passed
990 unchanged to the loader and nothing else will be done to it.
992 An entry containing two 0s is used to terminate the vector.
994 If multiple entries match a file, the last matching one is used. */
996 static struct compiler *compilers;
998 /* Number of entries in `compilers', not counting the null terminator. */
1000 static int n_compilers;
1002 /* The default list of file name suffixes and their compilation specs. */
1004 static const struct compiler default_compilers[] =
1006 /* Add lists of suffixes of known languages here. If those languages
1007 were not present when we built the driver, we will hit these copies
1008 and be given a more meaningful error than "file not used since
1009 linking is not done". */
1010 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0},
1011 {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
1012 {".mii", "#Objective-C++", 0, 0, 0},
1013 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
1014 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
1015 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
1016 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
1017 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
1018 {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
1019 {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
1020 {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
1021 {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
1022 {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
1023 {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
1024 {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
1025 {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
1026 {".r", "#Ratfor", 0, 0, 0},
1027 {".p", "#Pascal", 0, 0, 0}, {".pas", "#Pascal", 0, 0, 0},
1028 {".java", "#Java", 0, 0, 0}, {".class", "#Java", 0, 0, 0},
1029 {".zip", "#Java", 0, 0, 0}, {".jar", "#Java", 0, 0, 0},
1030 {".go", "#Go", 0, 1, 0},
1031 /* Next come the entries for C. */
1032 {".c", "@c", 0, 0, 1},
1033 {"@c",
1034 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1035 external preprocessor if -save-temps is given. */
1036 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1037 %{!E:%{!M:%{!MM:\
1038 %{traditional:\
1039 %eGNU C no longer supports -traditional without -E}\
1040 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1041 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1042 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1043 %(cc1_options)}\
1044 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1045 cc1 %(cpp_unique_options) %(cc1_options)}}}\
1046 %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 1},
1047 {"-",
1048 "%{!E:%e-E or -x required when input is from standard input}\
1049 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
1050 {".h", "@c-header", 0, 0, 0},
1051 {"@c-header",
1052 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1053 external preprocessor if -save-temps is given. */
1054 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1055 %{!E:%{!M:%{!MM:\
1056 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1057 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1058 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1059 %(cc1_options)\
1060 %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
1061 %W{o*:--output-pch=%*}}%V}\
1062 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1063 cc1 %(cpp_unique_options) %(cc1_options)\
1064 %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
1065 %W{o*:--output-pch=%*}}%V}}}}}}", 0, 0, 0},
1066 {".i", "@cpp-output", 0, 0, 0},
1067 {"@cpp-output",
1068 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 0},
1069 {".s", "@assembler", 0, 0, 0},
1070 {"@assembler",
1071 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 0, 0},
1072 {".sx", "@assembler-with-cpp", 0, 0, 0},
1073 {".S", "@assembler-with-cpp", 0, 0, 0},
1074 {"@assembler-with-cpp",
1075 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1076 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1077 %{E|M|MM:%(cpp_debug_options)}\
1078 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1079 as %(asm_debug) %(asm_options) %|.s %A }}}}"
1080 #else
1081 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1082 %{E|M|MM:%(cpp_debug_options)}\
1083 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1084 as %(asm_debug) %(asm_options) %m.s %A }}}}"
1085 #endif
1086 , 0, 0, 0},
1088 #include "specs.h"
1089 /* Mark end of table. */
1090 {0, 0, 0, 0, 0}
1093 /* Number of elements in default_compilers, not counting the terminator. */
1095 static const int n_default_compilers = ARRAY_SIZE (default_compilers) - 1;
1097 typedef char *char_p; /* For DEF_VEC_P. */
1099 /* A vector of options to give to the linker.
1100 These options are accumulated by %x,
1101 and substituted into the linker command with %X. */
1102 static vec<char_p> linker_options;
1104 /* A vector of options to give to the assembler.
1105 These options are accumulated by -Wa,
1106 and substituted into the assembler command with %Y. */
1107 static vec<char_p> assembler_options;
1109 /* A vector of options to give to the preprocessor.
1110 These options are accumulated by -Wp,
1111 and substituted into the preprocessor command with %Z. */
1112 static vec<char_p> preprocessor_options;
1114 static char *
1115 skip_whitespace (char *p)
1117 while (1)
1119 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1120 be considered whitespace. */
1121 if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
1122 return p + 1;
1123 else if (*p == '\n' || *p == ' ' || *p == '\t')
1124 p++;
1125 else if (*p == '#')
1127 while (*p != '\n')
1128 p++;
1129 p++;
1131 else
1132 break;
1135 return p;
1137 /* Structures to keep track of prefixes to try when looking for files. */
1139 struct prefix_list
1141 const char *prefix; /* String to prepend to the path. */
1142 struct prefix_list *next; /* Next in linked list. */
1143 int require_machine_suffix; /* Don't use without machine_suffix. */
1144 /* 2 means try both machine_suffix and just_machine_suffix. */
1145 int priority; /* Sort key - priority within list. */
1146 int os_multilib; /* 1 if OS multilib scheme should be used,
1147 0 for GCC multilib scheme. */
1150 struct path_prefix
1152 struct prefix_list *plist; /* List of prefixes to try */
1153 int max_len; /* Max length of a prefix in PLIST */
1154 const char *name; /* Name of this list (used in config stuff) */
1157 /* List of prefixes to try when looking for executables. */
1159 static struct path_prefix exec_prefixes = { 0, 0, "exec" };
1161 /* List of prefixes to try when looking for startup (crt0) files. */
1163 static struct path_prefix startfile_prefixes = { 0, 0, "startfile" };
1165 /* List of prefixes to try when looking for include files. */
1167 static struct path_prefix include_prefixes = { 0, 0, "include" };
1169 /* Suffix to attach to directories searched for commands.
1170 This looks like `MACHINE/VERSION/'. */
1172 static const char *machine_suffix = 0;
1174 /* Suffix to attach to directories searched for commands.
1175 This is just `MACHINE/'. */
1177 static const char *just_machine_suffix = 0;
1179 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1181 static const char *gcc_exec_prefix;
1183 /* Adjusted value of standard_libexec_prefix. */
1185 static const char *gcc_libexec_prefix;
1187 /* Default prefixes to attach to command names. */
1189 #ifndef STANDARD_STARTFILE_PREFIX_1
1190 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1191 #endif
1192 #ifndef STANDARD_STARTFILE_PREFIX_2
1193 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1194 #endif
1196 #ifdef CROSS_DIRECTORY_STRUCTURE /* Don't use these prefixes for a cross compiler. */
1197 #undef MD_EXEC_PREFIX
1198 #undef MD_STARTFILE_PREFIX
1199 #undef MD_STARTFILE_PREFIX_1
1200 #endif
1202 /* If no prefixes defined, use the null string, which will disable them. */
1203 #ifndef MD_EXEC_PREFIX
1204 #define MD_EXEC_PREFIX ""
1205 #endif
1206 #ifndef MD_STARTFILE_PREFIX
1207 #define MD_STARTFILE_PREFIX ""
1208 #endif
1209 #ifndef MD_STARTFILE_PREFIX_1
1210 #define MD_STARTFILE_PREFIX_1 ""
1211 #endif
1213 /* These directories are locations set at configure-time based on the
1214 --prefix option provided to configure. Their initializers are
1215 defined in Makefile.in. These paths are not *directly* used when
1216 gcc_exec_prefix is set because, in that case, we know where the
1217 compiler has been installed, and use paths relative to that
1218 location instead. */
1219 static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
1220 static const char *const standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX;
1221 static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
1222 static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1224 /* For native compilers, these are well-known paths containing
1225 components that may be provided by the system. For cross
1226 compilers, these paths are not used. */
1227 static const char *md_exec_prefix = MD_EXEC_PREFIX;
1228 static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1229 static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1230 static const char *const standard_startfile_prefix_1
1231 = STANDARD_STARTFILE_PREFIX_1;
1232 static const char *const standard_startfile_prefix_2
1233 = STANDARD_STARTFILE_PREFIX_2;
1235 /* A relative path to be used in finding the location of tools
1236 relative to the driver. */
1237 static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1239 /* Subdirectory to use for locating libraries. Set by
1240 set_multilib_dir based on the compilation options. */
1242 static const char *multilib_dir;
1244 /* Subdirectory to use for locating libraries in OS conventions. Set by
1245 set_multilib_dir based on the compilation options. */
1247 static const char *multilib_os_dir;
1249 /* Subdirectory to use for locating libraries in multiarch conventions. Set by
1250 set_multilib_dir based on the compilation options. */
1252 static const char *multiarch_dir;
1254 /* Structure to keep track of the specs that have been defined so far.
1255 These are accessed using %(specname) in a compiler or link
1256 spec. */
1258 struct spec_list
1260 /* The following 2 fields must be first */
1261 /* to allow EXTRA_SPECS to be initialized */
1262 const char *name; /* name of the spec. */
1263 const char *ptr; /* available ptr if no static pointer */
1265 /* The following fields are not initialized */
1266 /* by EXTRA_SPECS */
1267 const char **ptr_spec; /* pointer to the spec itself. */
1268 struct spec_list *next; /* Next spec in linked list. */
1269 int name_len; /* length of the name */
1270 bool user_p; /* whether string come from file spec. */
1271 bool alloc_p; /* whether string was allocated */
1274 #define INIT_STATIC_SPEC(NAME,PTR) \
1275 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, false, false }
1277 /* List of statically defined specs. */
1278 static struct spec_list static_specs[] =
1280 INIT_STATIC_SPEC ("asm", &asm_spec),
1281 INIT_STATIC_SPEC ("asm_debug", &asm_debug),
1282 INIT_STATIC_SPEC ("asm_final", &asm_final_spec),
1283 INIT_STATIC_SPEC ("asm_options", &asm_options),
1284 INIT_STATIC_SPEC ("invoke_as", &invoke_as),
1285 INIT_STATIC_SPEC ("cpp", &cpp_spec),
1286 INIT_STATIC_SPEC ("cpp_options", &cpp_options),
1287 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options),
1288 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options),
1289 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp),
1290 INIT_STATIC_SPEC ("cc1", &cc1_spec),
1291 INIT_STATIC_SPEC ("cc1_options", &cc1_options),
1292 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec),
1293 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec),
1294 INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec),
1295 INIT_STATIC_SPEC ("endfile", &endfile_spec),
1296 INIT_STATIC_SPEC ("link", &link_spec),
1297 INIT_STATIC_SPEC ("lib", &lib_spec),
1298 INIT_STATIC_SPEC ("link_gomp", &link_gomp_spec),
1299 INIT_STATIC_SPEC ("libgcc", &libgcc_spec),
1300 INIT_STATIC_SPEC ("startfile", &startfile_spec),
1301 INIT_STATIC_SPEC ("cross_compile", &cross_compile),
1302 INIT_STATIC_SPEC ("version", &compiler_version),
1303 INIT_STATIC_SPEC ("multilib", &multilib_select),
1304 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults),
1305 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra),
1306 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches),
1307 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions),
1308 INIT_STATIC_SPEC ("multilib_options", &multilib_options),
1309 INIT_STATIC_SPEC ("multilib_reuse", &multilib_reuse),
1310 INIT_STATIC_SPEC ("linker", &linker_name_spec),
1311 INIT_STATIC_SPEC ("linker_plugin_file", &linker_plugin_file_spec),
1312 INIT_STATIC_SPEC ("lto_wrapper", &lto_wrapper_spec),
1313 INIT_STATIC_SPEC ("lto_gcc", &lto_gcc_spec),
1314 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec),
1315 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix),
1316 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix),
1317 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1),
1318 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec),
1319 INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec),
1320 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec),
1321 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec),
1322 INIT_STATIC_SPEC ("self_spec", &self_spec),
1325 #ifdef EXTRA_SPECS /* additional specs needed */
1326 /* Structure to keep track of just the first two args of a spec_list.
1327 That is all that the EXTRA_SPECS macro gives us. */
1328 struct spec_list_1
1330 const char *const name;
1331 const char *const ptr;
1334 static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1335 static struct spec_list *extra_specs = (struct spec_list *) 0;
1336 #endif
1338 /* List of dynamically allocates specs that have been defined so far. */
1340 static struct spec_list *specs = (struct spec_list *) 0;
1342 /* List of static spec functions. */
1344 static const struct spec_function static_spec_functions[] =
1346 { "getenv", getenv_spec_function },
1347 { "if-exists", if_exists_spec_function },
1348 { "if-exists-else", if_exists_else_spec_function },
1349 { "sanitize", sanitize_spec_function },
1350 { "replace-outfile", replace_outfile_spec_function },
1351 { "remove-outfile", remove_outfile_spec_function },
1352 { "version-compare", version_compare_spec_function },
1353 { "include", include_spec_function },
1354 { "find-file", find_file_spec_function },
1355 { "find-plugindir", find_plugindir_spec_function },
1356 { "print-asm-header", print_asm_header_spec_function },
1357 { "compare-debug-dump-opt", compare_debug_dump_opt_spec_function },
1358 { "compare-debug-self-opt", compare_debug_self_opt_spec_function },
1359 { "compare-debug-auxbase-opt", compare_debug_auxbase_opt_spec_function },
1360 { "pass-through-libs", pass_through_libs_spec_func },
1361 { "replace-extension", replace_extension_spec_func },
1362 #ifdef EXTRA_SPEC_FUNCTIONS
1363 EXTRA_SPEC_FUNCTIONS
1364 #endif
1365 { 0, 0 }
1368 static int processing_spec_function;
1370 /* Add appropriate libgcc specs to OBSTACK, taking into account
1371 various permutations of -shared-libgcc, -shared, and such. */
1373 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1375 #ifndef USE_LD_AS_NEEDED
1376 #define USE_LD_AS_NEEDED 0
1377 #endif
1379 static void
1380 init_gcc_specs (struct obstack *obstack, const char *shared_name,
1381 const char *static_name, const char *eh_name)
1383 char *buf;
1385 buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name, "}"
1386 "%{!static:%{!static-libgcc:"
1387 #if USE_LD_AS_NEEDED
1388 "%{!shared-libgcc:",
1389 static_name, " " LD_AS_NEEDED_OPTION " ",
1390 shared_name, " " LD_NO_AS_NEEDED_OPTION
1392 "%{shared-libgcc:",
1393 shared_name, "%{!shared: ", static_name, "}"
1395 #else
1396 "%{!shared:"
1397 "%{!shared-libgcc:", static_name, " ", eh_name, "}"
1398 "%{shared-libgcc:", shared_name, " ", static_name, "}"
1400 #ifdef LINK_EH_SPEC
1401 "%{shared:"
1402 "%{shared-libgcc:", shared_name, "}"
1403 "%{!shared-libgcc:", static_name, "}"
1405 #else
1406 "%{shared:", shared_name, "}"
1407 #endif
1408 #endif
1409 "}}", NULL);
1411 obstack_grow (obstack, buf, strlen (buf));
1412 free (buf);
1414 #endif /* ENABLE_SHARED_LIBGCC */
1416 /* Initialize the specs lookup routines. */
1418 static void
1419 init_spec (void)
1421 struct spec_list *next = (struct spec_list *) 0;
1422 struct spec_list *sl = (struct spec_list *) 0;
1423 int i;
1425 if (specs)
1426 return; /* Already initialized. */
1428 if (verbose_flag)
1429 fnotice (stderr, "Using built-in specs.\n");
1431 #ifdef EXTRA_SPECS
1432 extra_specs = XCNEWVEC (struct spec_list, ARRAY_SIZE (extra_specs_1));
1434 for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--)
1436 sl = &extra_specs[i];
1437 sl->name = extra_specs_1[i].name;
1438 sl->ptr = extra_specs_1[i].ptr;
1439 sl->next = next;
1440 sl->name_len = strlen (sl->name);
1441 sl->ptr_spec = &sl->ptr;
1442 next = sl;
1444 #endif
1446 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1448 sl = &static_specs[i];
1449 sl->next = next;
1450 next = sl;
1453 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1454 /* ??? If neither -shared-libgcc nor --static-libgcc was
1455 seen, then we should be making an educated guess. Some proposed
1456 heuristics for ELF include:
1458 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1459 program will be doing dynamic loading, which will likely
1460 need the shared libgcc.
1462 (2) If "-ldl", then it's also a fair bet that we're doing
1463 dynamic loading.
1465 (3) For each ET_DYN we're linking against (either through -lfoo
1466 or /some/path/foo.so), check to see whether it or one of
1467 its dependencies depends on a shared libgcc.
1469 (4) If "-shared"
1471 If the runtime is fixed to look for program headers instead
1472 of calling __register_frame_info at all, for each object,
1473 use the shared libgcc if any EH symbol referenced.
1475 If crtstuff is fixed to not invoke __register_frame_info
1476 automatically, for each object, use the shared libgcc if
1477 any non-empty unwind section found.
1479 Doing any of this probably requires invoking an external program to
1480 do the actual object file scanning. */
1482 const char *p = libgcc_spec;
1483 int in_sep = 1;
1485 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1486 when given the proper command line arguments. */
1487 while (*p)
1489 if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
1491 init_gcc_specs (&obstack,
1492 "-lgcc_s"
1493 #ifdef USE_LIBUNWIND_EXCEPTIONS
1494 " -lunwind"
1495 #endif
1497 "-lgcc",
1498 "-lgcc_eh"
1499 #ifdef USE_LIBUNWIND_EXCEPTIONS
1500 # ifdef HAVE_LD_STATIC_DYNAMIC
1501 " %{!static:" LD_STATIC_OPTION "} -lunwind"
1502 " %{!static:" LD_DYNAMIC_OPTION "}"
1503 # else
1504 " -lunwind"
1505 # endif
1506 #endif
1509 p += 5;
1510 in_sep = 0;
1512 else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0)
1514 /* Ug. We don't know shared library extensions. Hope that
1515 systems that use this form don't do shared libraries. */
1516 init_gcc_specs (&obstack,
1517 "-lgcc_s",
1518 "libgcc.a%s",
1519 "libgcc_eh.a%s"
1520 #ifdef USE_LIBUNWIND_EXCEPTIONS
1521 " -lunwind"
1522 #endif
1524 p += 10;
1525 in_sep = 0;
1527 else
1529 obstack_1grow (&obstack, *p);
1530 in_sep = (*p == ' ');
1531 p += 1;
1535 obstack_1grow (&obstack, '\0');
1536 libgcc_spec = XOBFINISH (&obstack, const char *);
1538 #endif
1539 #ifdef USE_AS_TRADITIONAL_FORMAT
1540 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1542 static const char tf[] = "--traditional-format ";
1543 obstack_grow (&obstack, tf, sizeof (tf) - 1);
1544 obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
1545 asm_spec = XOBFINISH (&obstack, const char *);
1547 #endif
1549 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC || \
1550 defined LINKER_HASH_STYLE
1551 # ifdef LINK_BUILDID_SPEC
1552 /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. */
1553 obstack_grow (&obstack, LINK_BUILDID_SPEC, sizeof (LINK_BUILDID_SPEC) - 1);
1554 # endif
1555 # ifdef LINK_EH_SPEC
1556 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1557 obstack_grow (&obstack, LINK_EH_SPEC, sizeof (LINK_EH_SPEC) - 1);
1558 # endif
1559 # ifdef LINKER_HASH_STYLE
1560 /* Prepend --hash-style=LINKER_HASH_STYLE to whatever link_spec we had
1561 before. */
1563 static const char hash_style[] = "--hash-style=";
1564 obstack_grow (&obstack, hash_style, sizeof (hash_style) - 1);
1565 obstack_grow (&obstack, LINKER_HASH_STYLE, sizeof (LINKER_HASH_STYLE) - 1);
1566 obstack_1grow (&obstack, ' ');
1568 # endif
1569 obstack_grow0 (&obstack, link_spec, strlen (link_spec));
1570 link_spec = XOBFINISH (&obstack, const char *);
1571 #endif
1573 specs = sl;
1576 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1577 removed; If the spec starts with a + then SPEC is added to the end of the
1578 current spec. */
1580 static void
1581 set_spec (const char *name, const char *spec, bool user_p)
1583 struct spec_list *sl;
1584 const char *old_spec;
1585 int name_len = strlen (name);
1586 int i;
1588 /* If this is the first call, initialize the statically allocated specs. */
1589 if (!specs)
1591 struct spec_list *next = (struct spec_list *) 0;
1592 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1594 sl = &static_specs[i];
1595 sl->next = next;
1596 next = sl;
1598 specs = sl;
1601 /* See if the spec already exists. */
1602 for (sl = specs; sl; sl = sl->next)
1603 if (name_len == sl->name_len && !strcmp (sl->name, name))
1604 break;
1606 if (!sl)
1608 /* Not found - make it. */
1609 sl = XNEW (struct spec_list);
1610 sl->name = xstrdup (name);
1611 sl->name_len = name_len;
1612 sl->ptr_spec = &sl->ptr;
1613 sl->alloc_p = 0;
1614 *(sl->ptr_spec) = "";
1615 sl->next = specs;
1616 specs = sl;
1619 old_spec = *(sl->ptr_spec);
1620 *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
1621 ? concat (old_spec, spec + 1, NULL)
1622 : xstrdup (spec));
1624 #ifdef DEBUG_SPECS
1625 if (verbose_flag)
1626 fnotice (stderr, "Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
1627 #endif
1629 /* Free the old spec. */
1630 if (old_spec && sl->alloc_p)
1631 free (CONST_CAST (char *, old_spec));
1633 sl->user_p = user_p;
1634 sl->alloc_p = true;
1637 /* Accumulate a command (program name and args), and run it. */
1639 typedef const char *const_char_p; /* For DEF_VEC_P. */
1641 /* Vector of pointers to arguments in the current line of specifications. */
1643 static vec<const_char_p> argbuf;
1645 /* Position in the argbuf vector containing the name of the output file
1646 (the value associated with the "-o" flag). */
1648 static int have_o_argbuf_index = 0;
1650 /* Were the options -c, -S or -E passed. */
1651 static int have_c = 0;
1653 /* Was the option -o passed. */
1654 static int have_o = 0;
1656 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1657 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
1658 it here. */
1660 static struct temp_name {
1661 const char *suffix; /* suffix associated with the code. */
1662 int length; /* strlen (suffix). */
1663 int unique; /* Indicates whether %g or %u/%U was used. */
1664 const char *filename; /* associated filename. */
1665 int filename_length; /* strlen (filename). */
1666 struct temp_name *next;
1667 } *temp_names;
1669 /* Number of commands executed so far. */
1671 static int execution_count;
1673 /* Number of commands that exited with a signal. */
1675 static int signal_count;
1677 /* Allocate the argument vector. */
1679 static void
1680 alloc_args (void)
1682 argbuf.create (10);
1685 /* Clear out the vector of arguments (after a command is executed). */
1687 static void
1688 clear_args (void)
1690 argbuf.truncate (0);
1693 /* Add one argument to the vector at the end.
1694 This is done when a space is seen or at the end of the line.
1695 If DELETE_ALWAYS is nonzero, the arg is a filename
1696 and the file should be deleted eventually.
1697 If DELETE_FAILURE is nonzero, the arg is a filename
1698 and the file should be deleted if this compilation fails. */
1700 static void
1701 store_arg (const char *arg, int delete_always, int delete_failure)
1703 argbuf.safe_push (arg);
1705 if (strcmp (arg, "-o") == 0)
1706 have_o_argbuf_index = argbuf.length ();
1707 if (delete_always || delete_failure)
1709 const char *p;
1710 /* If the temporary file we should delete is specified as
1711 part of a joined argument extract the filename. */
1712 if (arg[0] == '-'
1713 && (p = strrchr (arg, '=')))
1714 arg = p + 1;
1715 record_temp_file (arg, delete_always, delete_failure);
1719 /* Load specs from a file name named FILENAME, replacing occurrences of
1720 various different types of line-endings, \r\n, \n\r and just \r, with
1721 a single \n. */
1723 static char *
1724 load_specs (const char *filename)
1726 int desc;
1727 int readlen;
1728 struct stat statbuf;
1729 char *buffer;
1730 char *buffer_p;
1731 char *specs;
1732 char *specs_p;
1734 if (verbose_flag)
1735 fnotice (stderr, "Reading specs from %s\n", filename);
1737 /* Open and stat the file. */
1738 desc = open (filename, O_RDONLY, 0);
1739 if (desc < 0)
1740 pfatal_with_name (filename);
1741 if (stat (filename, &statbuf) < 0)
1742 pfatal_with_name (filename);
1744 /* Read contents of file into BUFFER. */
1745 buffer = XNEWVEC (char, statbuf.st_size + 1);
1746 readlen = read (desc, buffer, (unsigned) statbuf.st_size);
1747 if (readlen < 0)
1748 pfatal_with_name (filename);
1749 buffer[readlen] = 0;
1750 close (desc);
1752 specs = XNEWVEC (char, readlen + 1);
1753 specs_p = specs;
1754 for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
1756 int skip = 0;
1757 char c = *buffer_p;
1758 if (c == '\r')
1760 if (buffer_p > buffer && *(buffer_p - 1) == '\n') /* \n\r */
1761 skip = 1;
1762 else if (*(buffer_p + 1) == '\n') /* \r\n */
1763 skip = 1;
1764 else /* \r */
1765 c = '\n';
1767 if (! skip)
1768 *specs_p++ = c;
1770 *specs_p = '\0';
1772 free (buffer);
1773 return (specs);
1776 /* Read compilation specs from a file named FILENAME,
1777 replacing the default ones.
1779 A suffix which starts with `*' is a definition for
1780 one of the machine-specific sub-specs. The "suffix" should be
1781 *asm, *cc1, *cpp, *link, *startfile, etc.
1782 The corresponding spec is stored in asm_spec, etc.,
1783 rather than in the `compilers' vector.
1785 Anything invalid in the file is a fatal error. */
1787 static void
1788 read_specs (const char *filename, bool main_p, bool user_p)
1790 char *buffer;
1791 char *p;
1793 buffer = load_specs (filename);
1795 /* Scan BUFFER for specs, putting them in the vector. */
1796 p = buffer;
1797 while (1)
1799 char *suffix;
1800 char *spec;
1801 char *in, *out, *p1, *p2, *p3;
1803 /* Advance P in BUFFER to the next nonblank nocomment line. */
1804 p = skip_whitespace (p);
1805 if (*p == 0)
1806 break;
1808 /* Is this a special command that starts with '%'? */
1809 /* Don't allow this for the main specs file, since it would
1810 encourage people to overwrite it. */
1811 if (*p == '%' && !main_p)
1813 p1 = p;
1814 while (*p && *p != '\n')
1815 p++;
1817 /* Skip '\n'. */
1818 p++;
1820 if (!strncmp (p1, "%include", sizeof ("%include") - 1)
1821 && (p1[sizeof "%include" - 1] == ' '
1822 || p1[sizeof "%include" - 1] == '\t'))
1824 char *new_filename;
1826 p1 += sizeof ("%include");
1827 while (*p1 == ' ' || *p1 == '\t')
1828 p1++;
1830 if (*p1++ != '<' || p[-2] != '>')
1831 fatal_error ("specs %%include syntax malformed after "
1832 "%ld characters",
1833 (long) (p1 - buffer + 1));
1835 p[-2] = '\0';
1836 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
1837 read_specs (new_filename ? new_filename : p1, false, user_p);
1838 continue;
1840 else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
1841 && (p1[sizeof "%include_noerr" - 1] == ' '
1842 || p1[sizeof "%include_noerr" - 1] == '\t'))
1844 char *new_filename;
1846 p1 += sizeof "%include_noerr";
1847 while (*p1 == ' ' || *p1 == '\t')
1848 p1++;
1850 if (*p1++ != '<' || p[-2] != '>')
1851 fatal_error ("specs %%include syntax malformed after "
1852 "%ld characters",
1853 (long) (p1 - buffer + 1));
1855 p[-2] = '\0';
1856 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
1857 if (new_filename)
1858 read_specs (new_filename, false, user_p);
1859 else if (verbose_flag)
1860 fnotice (stderr, "could not find specs file %s\n", p1);
1861 continue;
1863 else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
1864 && (p1[sizeof "%rename" - 1] == ' '
1865 || p1[sizeof "%rename" - 1] == '\t'))
1867 int name_len;
1868 struct spec_list *sl;
1869 struct spec_list *newsl;
1871 /* Get original name. */
1872 p1 += sizeof "%rename";
1873 while (*p1 == ' ' || *p1 == '\t')
1874 p1++;
1876 if (! ISALPHA ((unsigned char) *p1))
1877 fatal_error ("specs %%rename syntax malformed after "
1878 "%ld characters",
1879 (long) (p1 - buffer));
1881 p2 = p1;
1882 while (*p2 && !ISSPACE ((unsigned char) *p2))
1883 p2++;
1885 if (*p2 != ' ' && *p2 != '\t')
1886 fatal_error ("specs %%rename syntax malformed after "
1887 "%ld characters",
1888 (long) (p2 - buffer));
1890 name_len = p2 - p1;
1891 *p2++ = '\0';
1892 while (*p2 == ' ' || *p2 == '\t')
1893 p2++;
1895 if (! ISALPHA ((unsigned char) *p2))
1896 fatal_error ("specs %%rename syntax malformed after "
1897 "%ld characters",
1898 (long) (p2 - buffer));
1900 /* Get new spec name. */
1901 p3 = p2;
1902 while (*p3 && !ISSPACE ((unsigned char) *p3))
1903 p3++;
1905 if (p3 != p - 1)
1906 fatal_error ("specs %%rename syntax malformed after "
1907 "%ld characters",
1908 (long) (p3 - buffer));
1909 *p3 = '\0';
1911 for (sl = specs; sl; sl = sl->next)
1912 if (name_len == sl->name_len && !strcmp (sl->name, p1))
1913 break;
1915 if (!sl)
1916 fatal_error ("specs %s spec was not found to be renamed", p1);
1918 if (strcmp (p1, p2) == 0)
1919 continue;
1921 for (newsl = specs; newsl; newsl = newsl->next)
1922 if (strcmp (newsl->name, p2) == 0)
1923 fatal_error ("%s: attempt to rename spec %qs to "
1924 "already defined spec %qs",
1925 filename, p1, p2);
1927 if (verbose_flag)
1929 fnotice (stderr, "rename spec %s to %s\n", p1, p2);
1930 #ifdef DEBUG_SPECS
1931 fnotice (stderr, "spec is '%s'\n\n", *(sl->ptr_spec));
1932 #endif
1935 set_spec (p2, *(sl->ptr_spec), user_p);
1936 if (sl->alloc_p)
1937 free (CONST_CAST (char *, *(sl->ptr_spec)));
1939 *(sl->ptr_spec) = "";
1940 sl->alloc_p = 0;
1941 continue;
1943 else
1944 fatal_error ("specs unknown %% command after %ld characters",
1945 (long) (p1 - buffer));
1948 /* Find the colon that should end the suffix. */
1949 p1 = p;
1950 while (*p1 && *p1 != ':' && *p1 != '\n')
1951 p1++;
1953 /* The colon shouldn't be missing. */
1954 if (*p1 != ':')
1955 fatal_error ("specs file malformed after %ld characters",
1956 (long) (p1 - buffer));
1958 /* Skip back over trailing whitespace. */
1959 p2 = p1;
1960 while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
1961 p2--;
1963 /* Copy the suffix to a string. */
1964 suffix = save_string (p, p2 - p);
1965 /* Find the next line. */
1966 p = skip_whitespace (p1 + 1);
1967 if (p[1] == 0)
1968 fatal_error ("specs file malformed after %ld characters",
1969 (long) (p - buffer));
1971 p1 = p;
1972 /* Find next blank line or end of string. */
1973 while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
1974 p1++;
1976 /* Specs end at the blank line and do not include the newline. */
1977 spec = save_string (p, p1 - p);
1978 p = p1;
1980 /* Delete backslash-newline sequences from the spec. */
1981 in = spec;
1982 out = spec;
1983 while (*in != 0)
1985 if (in[0] == '\\' && in[1] == '\n')
1986 in += 2;
1987 else if (in[0] == '#')
1988 while (*in && *in != '\n')
1989 in++;
1991 else
1992 *out++ = *in++;
1994 *out = 0;
1996 if (suffix[0] == '*')
1998 if (! strcmp (suffix, "*link_command"))
1999 link_command_spec = spec;
2000 else
2001 set_spec (suffix + 1, spec, user_p);
2003 else
2005 /* Add this pair to the vector. */
2006 compilers
2007 = XRESIZEVEC (struct compiler, compilers, n_compilers + 2);
2009 compilers[n_compilers].suffix = suffix;
2010 compilers[n_compilers].spec = spec;
2011 n_compilers++;
2012 memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
2015 if (*suffix == 0)
2016 link_command_spec = spec;
2019 if (link_command_spec == 0)
2020 fatal_error ("spec file has no spec for linking");
2023 /* Record the names of temporary files we tell compilers to write,
2024 and delete them at the end of the run. */
2026 /* This is the common prefix we use to make temp file names.
2027 It is chosen once for each run of this program.
2028 It is substituted into a spec by %g or %j.
2029 Thus, all temp file names contain this prefix.
2030 In practice, all temp file names start with this prefix.
2032 This prefix comes from the envvar TMPDIR if it is defined;
2033 otherwise, from the P_tmpdir macro if that is defined;
2034 otherwise, in /usr/tmp or /tmp;
2035 or finally the current directory if all else fails. */
2037 static const char *temp_filename;
2039 /* Length of the prefix. */
2041 static int temp_filename_length;
2043 /* Define the list of temporary files to delete. */
2045 struct temp_file
2047 const char *name;
2048 struct temp_file *next;
2051 /* Queue of files to delete on success or failure of compilation. */
2052 static struct temp_file *always_delete_queue;
2053 /* Queue of files to delete on failure of compilation. */
2054 static struct temp_file *failure_delete_queue;
2056 /* Record FILENAME as a file to be deleted automatically.
2057 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2058 otherwise delete it in any case.
2059 FAIL_DELETE nonzero means delete it if a compilation step fails;
2060 otherwise delete it in any case. */
2062 void
2063 record_temp_file (const char *filename, int always_delete, int fail_delete)
2065 char *const name = xstrdup (filename);
2067 if (always_delete)
2069 struct temp_file *temp;
2070 for (temp = always_delete_queue; temp; temp = temp->next)
2071 if (! filename_cmp (name, temp->name))
2072 goto already1;
2074 temp = XNEW (struct temp_file);
2075 temp->next = always_delete_queue;
2076 temp->name = name;
2077 always_delete_queue = temp;
2079 already1:;
2082 if (fail_delete)
2084 struct temp_file *temp;
2085 for (temp = failure_delete_queue; temp; temp = temp->next)
2086 if (! filename_cmp (name, temp->name))
2088 free (name);
2089 goto already2;
2092 temp = XNEW (struct temp_file);
2093 temp->next = failure_delete_queue;
2094 temp->name = name;
2095 failure_delete_queue = temp;
2097 already2:;
2101 /* Delete all the temporary files whose names we previously recorded. */
2103 #ifndef DELETE_IF_ORDINARY
2104 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2105 do \
2107 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2108 if (unlink (NAME) < 0) \
2109 if (VERBOSE_FLAG) \
2110 perror_with_name (NAME); \
2111 } while (0)
2112 #endif
2114 static void
2115 delete_if_ordinary (const char *name)
2117 struct stat st;
2118 #ifdef DEBUG
2119 int i, c;
2121 printf ("Delete %s? (y or n) ", name);
2122 fflush (stdout);
2123 i = getchar ();
2124 if (i != '\n')
2125 while ((c = getchar ()) != '\n' && c != EOF)
2128 if (i == 'y' || i == 'Y')
2129 #endif /* DEBUG */
2130 DELETE_IF_ORDINARY (name, st, verbose_flag);
2133 static void
2134 delete_temp_files (void)
2136 struct temp_file *temp;
2138 for (temp = always_delete_queue; temp; temp = temp->next)
2139 delete_if_ordinary (temp->name);
2140 always_delete_queue = 0;
2143 /* Delete all the files to be deleted on error. */
2145 static void
2146 delete_failure_queue (void)
2148 struct temp_file *temp;
2150 for (temp = failure_delete_queue; temp; temp = temp->next)
2151 delete_if_ordinary (temp->name);
2154 static void
2155 clear_failure_queue (void)
2157 failure_delete_queue = 0;
2160 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2161 returns non-NULL.
2162 If DO_MULTI is true iterate over the paths twice, first with multilib
2163 suffix then without, otherwise iterate over the paths once without
2164 adding a multilib suffix. When DO_MULTI is true, some attempt is made
2165 to avoid visiting the same path twice, but we could do better. For
2166 instance, /usr/lib/../lib is considered different from /usr/lib.
2167 At least EXTRA_SPACE chars past the end of the path passed to
2168 CALLBACK are available for use by the callback.
2169 CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2171 Returns the value returned by CALLBACK. */
2173 static void *
2174 for_each_path (const struct path_prefix *paths,
2175 bool do_multi,
2176 size_t extra_space,
2177 void *(*callback) (char *, void *),
2178 void *callback_info)
2180 struct prefix_list *pl;
2181 const char *multi_dir = NULL;
2182 const char *multi_os_dir = NULL;
2183 const char *multiarch_suffix = NULL;
2184 const char *multi_suffix;
2185 const char *just_multi_suffix;
2186 char *path = NULL;
2187 void *ret = NULL;
2188 bool skip_multi_dir = false;
2189 bool skip_multi_os_dir = false;
2191 multi_suffix = machine_suffix;
2192 just_multi_suffix = just_machine_suffix;
2193 if (do_multi && multilib_dir && strcmp (multilib_dir, ".") != 0)
2195 multi_dir = concat (multilib_dir, dir_separator_str, NULL);
2196 multi_suffix = concat (multi_suffix, multi_dir, NULL);
2197 just_multi_suffix = concat (just_multi_suffix, multi_dir, NULL);
2199 if (do_multi && multilib_os_dir && strcmp (multilib_os_dir, ".") != 0)
2200 multi_os_dir = concat (multilib_os_dir, dir_separator_str, NULL);
2201 if (multiarch_dir)
2202 multiarch_suffix = concat (multiarch_dir, dir_separator_str, NULL);
2204 while (1)
2206 size_t multi_dir_len = 0;
2207 size_t multi_os_dir_len = 0;
2208 size_t multiarch_len = 0;
2209 size_t suffix_len;
2210 size_t just_suffix_len;
2211 size_t len;
2213 if (multi_dir)
2214 multi_dir_len = strlen (multi_dir);
2215 if (multi_os_dir)
2216 multi_os_dir_len = strlen (multi_os_dir);
2217 if (multiarch_suffix)
2218 multiarch_len = strlen (multiarch_suffix);
2219 suffix_len = strlen (multi_suffix);
2220 just_suffix_len = strlen (just_multi_suffix);
2222 if (path == NULL)
2224 len = paths->max_len + extra_space + 1;
2225 len += MAX (MAX (suffix_len, multi_os_dir_len), multiarch_len);
2226 path = XNEWVEC (char, len);
2229 for (pl = paths->plist; pl != 0; pl = pl->next)
2231 len = strlen (pl->prefix);
2232 memcpy (path, pl->prefix, len);
2234 /* Look first in MACHINE/VERSION subdirectory. */
2235 if (!skip_multi_dir)
2237 memcpy (path + len, multi_suffix, suffix_len + 1);
2238 ret = callback (path, callback_info);
2239 if (ret)
2240 break;
2243 /* Some paths are tried with just the machine (ie. target)
2244 subdir. This is used for finding as, ld, etc. */
2245 if (!skip_multi_dir
2246 && pl->require_machine_suffix == 2)
2248 memcpy (path + len, just_multi_suffix, just_suffix_len + 1);
2249 ret = callback (path, callback_info);
2250 if (ret)
2251 break;
2254 /* Now try the multiarch path. */
2255 if (!skip_multi_dir
2256 && !pl->require_machine_suffix && multiarch_dir)
2258 memcpy (path + len, multiarch_suffix, multiarch_len + 1);
2259 ret = callback (path, callback_info);
2260 if (ret)
2261 break;
2264 /* Now try the base path. */
2265 if (!pl->require_machine_suffix
2266 && !(pl->os_multilib ? skip_multi_os_dir : skip_multi_dir))
2268 const char *this_multi;
2269 size_t this_multi_len;
2271 if (pl->os_multilib)
2273 this_multi = multi_os_dir;
2274 this_multi_len = multi_os_dir_len;
2276 else
2278 this_multi = multi_dir;
2279 this_multi_len = multi_dir_len;
2282 if (this_multi_len)
2283 memcpy (path + len, this_multi, this_multi_len + 1);
2284 else
2285 path[len] = '\0';
2287 ret = callback (path, callback_info);
2288 if (ret)
2289 break;
2292 if (pl)
2293 break;
2295 if (multi_dir == NULL && multi_os_dir == NULL)
2296 break;
2298 /* Run through the paths again, this time without multilibs.
2299 Don't repeat any we have already seen. */
2300 if (multi_dir)
2302 free (CONST_CAST (char *, multi_dir));
2303 multi_dir = NULL;
2304 free (CONST_CAST (char *, multi_suffix));
2305 multi_suffix = machine_suffix;
2306 free (CONST_CAST (char *, just_multi_suffix));
2307 just_multi_suffix = just_machine_suffix;
2309 else
2310 skip_multi_dir = true;
2311 if (multi_os_dir)
2313 free (CONST_CAST (char *, multi_os_dir));
2314 multi_os_dir = NULL;
2316 else
2317 skip_multi_os_dir = true;
2320 if (multi_dir)
2322 free (CONST_CAST (char *, multi_dir));
2323 free (CONST_CAST (char *, multi_suffix));
2324 free (CONST_CAST (char *, just_multi_suffix));
2326 if (multi_os_dir)
2327 free (CONST_CAST (char *, multi_os_dir));
2328 if (ret != path)
2329 free (path);
2330 return ret;
2333 /* Callback for build_search_list. Adds path to obstack being built. */
2335 struct add_to_obstack_info {
2336 struct obstack *ob;
2337 bool check_dir;
2338 bool first_time;
2341 static void *
2342 add_to_obstack (char *path, void *data)
2344 struct add_to_obstack_info *info = (struct add_to_obstack_info *) data;
2346 if (info->check_dir && !is_directory (path, false))
2347 return NULL;
2349 if (!info->first_time)
2350 obstack_1grow (info->ob, PATH_SEPARATOR);
2352 obstack_grow (info->ob, path, strlen (path));
2354 info->first_time = false;
2355 return NULL;
2358 /* Add or change the value of an environment variable, outputting the
2359 change to standard error if in verbose mode. */
2360 static void
2361 xputenv (const char *string)
2363 if (verbose_flag)
2364 fnotice (stderr, "%s\n", string);
2365 putenv (CONST_CAST (char *, string));
2368 /* Build a list of search directories from PATHS.
2369 PREFIX is a string to prepend to the list.
2370 If CHECK_DIR_P is true we ensure the directory exists.
2371 If DO_MULTI is true, multilib paths are output first, then
2372 non-multilib paths.
2373 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2374 It is also used by the --print-search-dirs flag. */
2376 static char *
2377 build_search_list (const struct path_prefix *paths, const char *prefix,
2378 bool check_dir, bool do_multi)
2380 struct add_to_obstack_info info;
2382 info.ob = &collect_obstack;
2383 info.check_dir = check_dir;
2384 info.first_time = true;
2386 obstack_grow (&collect_obstack, prefix, strlen (prefix));
2387 obstack_1grow (&collect_obstack, '=');
2389 for_each_path (paths, do_multi, 0, add_to_obstack, &info);
2391 obstack_1grow (&collect_obstack, '\0');
2392 return XOBFINISH (&collect_obstack, char *);
2395 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2396 for collect. */
2398 static void
2399 putenv_from_prefixes (const struct path_prefix *paths, const char *env_var,
2400 bool do_multi)
2402 xputenv (build_search_list (paths, env_var, true, do_multi));
2405 /* Check whether NAME can be accessed in MODE. This is like access,
2406 except that it never considers directories to be executable. */
2408 static int
2409 access_check (const char *name, int mode)
2411 if (mode == X_OK)
2413 struct stat st;
2415 if (stat (name, &st) < 0
2416 || S_ISDIR (st.st_mode))
2417 return -1;
2420 return access (name, mode);
2423 /* Callback for find_a_file. Appends the file name to the directory
2424 path. If the resulting file exists in the right mode, return the
2425 full pathname to the file. */
2427 struct file_at_path_info {
2428 const char *name;
2429 const char *suffix;
2430 int name_len;
2431 int suffix_len;
2432 int mode;
2435 static void *
2436 file_at_path (char *path, void *data)
2438 struct file_at_path_info *info = (struct file_at_path_info *) data;
2439 size_t len = strlen (path);
2441 memcpy (path + len, info->name, info->name_len);
2442 len += info->name_len;
2444 /* Some systems have a suffix for executable files.
2445 So try appending that first. */
2446 if (info->suffix_len)
2448 memcpy (path + len, info->suffix, info->suffix_len + 1);
2449 if (access_check (path, info->mode) == 0)
2450 return path;
2453 path[len] = '\0';
2454 if (access_check (path, info->mode) == 0)
2455 return path;
2457 return NULL;
2460 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2461 access to check permissions. If DO_MULTI is true, search multilib
2462 paths then non-multilib paths, otherwise do not search multilib paths.
2463 Return 0 if not found, otherwise return its name, allocated with malloc. */
2465 static char *
2466 find_a_file (const struct path_prefix *pprefix, const char *name, int mode,
2467 bool do_multi)
2469 struct file_at_path_info info;
2471 #ifdef DEFAULT_ASSEMBLER
2472 if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
2473 return xstrdup (DEFAULT_ASSEMBLER);
2474 #endif
2476 #ifdef DEFAULT_LINKER
2477 if (! strcmp (name, "ld") && access (DEFAULT_LINKER, mode) == 0)
2478 return xstrdup (DEFAULT_LINKER);
2479 #endif
2481 /* Determine the filename to execute (special case for absolute paths). */
2483 if (IS_ABSOLUTE_PATH (name))
2485 if (access (name, mode) == 0)
2486 return xstrdup (name);
2488 return NULL;
2491 info.name = name;
2492 info.suffix = (mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "";
2493 info.name_len = strlen (info.name);
2494 info.suffix_len = strlen (info.suffix);
2495 info.mode = mode;
2497 return (char*) for_each_path (pprefix, do_multi,
2498 info.name_len + info.suffix_len,
2499 file_at_path, &info);
2502 /* Ranking of prefixes in the sort list. -B prefixes are put before
2503 all others. */
2505 enum path_prefix_priority
2507 PREFIX_PRIORITY_B_OPT,
2508 PREFIX_PRIORITY_LAST
2511 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
2512 order according to PRIORITY. Within each PRIORITY, new entries are
2513 appended.
2515 If WARN is nonzero, we will warn if no file is found
2516 through this prefix. WARN should point to an int
2517 which will be set to 1 if this entry is used.
2519 COMPONENT is the value to be passed to update_path.
2521 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2522 the complete value of machine_suffix.
2523 2 means try both machine_suffix and just_machine_suffix. */
2525 static void
2526 add_prefix (struct path_prefix *pprefix, const char *prefix,
2527 const char *component, /* enum prefix_priority */ int priority,
2528 int require_machine_suffix, int os_multilib)
2530 struct prefix_list *pl, **prev;
2531 int len;
2533 for (prev = &pprefix->plist;
2534 (*prev) != NULL && (*prev)->priority <= priority;
2535 prev = &(*prev)->next)
2538 /* Keep track of the longest prefix. */
2540 prefix = update_path (prefix, component);
2541 len = strlen (prefix);
2542 if (len > pprefix->max_len)
2543 pprefix->max_len = len;
2545 pl = XNEW (struct prefix_list);
2546 pl->prefix = prefix;
2547 pl->require_machine_suffix = require_machine_suffix;
2548 pl->priority = priority;
2549 pl->os_multilib = os_multilib;
2551 /* Insert after PREV. */
2552 pl->next = (*prev);
2553 (*prev) = pl;
2556 /* Same as add_prefix, but prepending target_system_root to prefix. */
2557 /* The target_system_root prefix has been relocated by gcc_exec_prefix. */
2558 static void
2559 add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
2560 const char *component,
2561 /* enum prefix_priority */ int priority,
2562 int require_machine_suffix, int os_multilib)
2564 if (!IS_ABSOLUTE_PATH (prefix))
2565 fatal_error ("system path %qs is not absolute", prefix);
2567 if (target_system_root)
2569 char *sysroot_no_trailing_dir_separator = xstrdup (target_system_root);
2570 size_t sysroot_len = strlen (target_system_root);
2572 if (sysroot_len > 0
2573 && target_system_root[sysroot_len - 1] == DIR_SEPARATOR)
2574 sysroot_no_trailing_dir_separator[sysroot_len - 1] = '\0';
2576 if (target_sysroot_suffix)
2577 prefix = concat (sysroot_no_trailing_dir_separator,
2578 target_sysroot_suffix, prefix, NULL);
2579 else
2580 prefix = concat (sysroot_no_trailing_dir_separator, prefix, NULL);
2582 free (sysroot_no_trailing_dir_separator);
2584 /* We have to override this because GCC's notion of sysroot
2585 moves along with GCC. */
2586 component = "GCC";
2589 add_prefix (pprefix, prefix, component, priority,
2590 require_machine_suffix, os_multilib);
2593 /* Execute the command specified by the arguments on the current line of spec.
2594 When using pipes, this includes several piped-together commands
2595 with `|' between them.
2597 Return 0 if successful, -1 if failed. */
2599 static int
2600 execute (void)
2602 int i;
2603 int n_commands; /* # of command. */
2604 char *string;
2605 struct pex_obj *pex;
2606 struct command
2608 const char *prog; /* program name. */
2609 const char **argv; /* vector of args. */
2611 const char *arg;
2613 struct command *commands; /* each command buffer with above info. */
2615 gcc_assert (!processing_spec_function);
2617 if (wrapper_string)
2619 string = find_a_file (&exec_prefixes,
2620 argbuf[0], X_OK, false);
2621 if (string)
2622 argbuf[0] = string;
2623 insert_wrapper (wrapper_string);
2626 /* Count # of piped commands. */
2627 for (n_commands = 1, i = 0; argbuf.iterate (i, &arg); i++)
2628 if (strcmp (arg, "|") == 0)
2629 n_commands++;
2631 /* Get storage for each command. */
2632 commands = (struct command *) alloca (n_commands * sizeof (struct command));
2634 /* Split argbuf into its separate piped processes,
2635 and record info about each one.
2636 Also search for the programs that are to be run. */
2638 argbuf.safe_push (0);
2640 commands[0].prog = argbuf[0]; /* first command. */
2641 commands[0].argv = argbuf.address ();
2643 if (!wrapper_string)
2645 string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, false);
2646 commands[0].argv[0] = (string) ? string : commands[0].argv[0];
2649 for (n_commands = 1, i = 0; argbuf.iterate (i, &arg); i++)
2650 if (arg && strcmp (arg, "|") == 0)
2651 { /* each command. */
2652 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2653 fatal_error ("-pipe not supported");
2654 #endif
2655 argbuf[i] = 0; /* Termination of
2656 command args. */
2657 commands[n_commands].prog = argbuf[i + 1];
2658 commands[n_commands].argv
2659 = &(argbuf.address ())[i + 1];
2660 string = find_a_file (&exec_prefixes, commands[n_commands].prog,
2661 X_OK, false);
2662 if (string)
2663 commands[n_commands].argv[0] = string;
2664 n_commands++;
2667 /* If -v, print what we are about to do, and maybe query. */
2669 if (verbose_flag)
2671 /* For help listings, put a blank line between sub-processes. */
2672 if (print_help_list)
2673 fputc ('\n', stderr);
2675 /* Print each piped command as a separate line. */
2676 for (i = 0; i < n_commands; i++)
2678 const char *const *j;
2680 if (verbose_only_flag)
2682 for (j = commands[i].argv; *j; j++)
2684 const char *p;
2685 for (p = *j; *p; ++p)
2686 if (!ISALNUM ((unsigned char) *p)
2687 && *p != '_' && *p != '/' && *p != '-' && *p != '.')
2688 break;
2689 if (*p || !*j)
2691 fprintf (stderr, " \"");
2692 for (p = *j; *p; ++p)
2694 if (*p == '"' || *p == '\\' || *p == '$')
2695 fputc ('\\', stderr);
2696 fputc (*p, stderr);
2698 fputc ('"', stderr);
2700 /* If it's empty, print "". */
2701 else if (!**j)
2702 fprintf (stderr, " \"\"");
2703 else
2704 fprintf (stderr, " %s", *j);
2707 else
2708 for (j = commands[i].argv; *j; j++)
2709 /* If it's empty, print "". */
2710 if (!**j)
2711 fprintf (stderr, " \"\"");
2712 else
2713 fprintf (stderr, " %s", *j);
2715 /* Print a pipe symbol after all but the last command. */
2716 if (i + 1 != n_commands)
2717 fprintf (stderr, " |");
2718 fprintf (stderr, "\n");
2720 fflush (stderr);
2721 if (verbose_only_flag != 0)
2723 /* verbose_only_flag should act as if the spec was
2724 executed, so increment execution_count before
2725 returning. This prevents spurious warnings about
2726 unused linker input files, etc. */
2727 execution_count++;
2728 return 0;
2730 #ifdef DEBUG
2731 fnotice (stderr, "\nGo ahead? (y or n) ");
2732 fflush (stderr);
2733 i = getchar ();
2734 if (i != '\n')
2735 while (getchar () != '\n')
2738 if (i != 'y' && i != 'Y')
2739 return 0;
2740 #endif /* DEBUG */
2743 #ifdef ENABLE_VALGRIND_CHECKING
2744 /* Run the each command through valgrind. To simplify prepending the
2745 path to valgrind and the option "-q" (for quiet operation unless
2746 something triggers), we allocate a separate argv array. */
2748 for (i = 0; i < n_commands; i++)
2750 const char **argv;
2751 int argc;
2752 int j;
2754 for (argc = 0; commands[i].argv[argc] != NULL; argc++)
2757 argv = XALLOCAVEC (const char *, argc + 3);
2759 argv[0] = VALGRIND_PATH;
2760 argv[1] = "-q";
2761 for (j = 2; j < argc + 2; j++)
2762 argv[j] = commands[i].argv[j - 2];
2763 argv[j] = NULL;
2765 commands[i].argv = argv;
2766 commands[i].prog = argv[0];
2768 #endif
2770 /* Run each piped subprocess. */
2772 pex = pex_init (PEX_USE_PIPES | ((report_times || report_times_to_file)
2773 ? PEX_RECORD_TIMES : 0),
2774 progname, temp_filename);
2775 if (pex == NULL)
2776 fatal_error ("pex_init failed: %m");
2778 for (i = 0; i < n_commands; i++)
2780 const char *errmsg;
2781 int err;
2782 const char *string = commands[i].argv[0];
2784 errmsg = pex_run (pex,
2785 ((i + 1 == n_commands ? PEX_LAST : 0)
2786 | (string == commands[i].prog ? PEX_SEARCH : 0)),
2787 string, CONST_CAST (char **, commands[i].argv),
2788 NULL, NULL, &err);
2789 if (errmsg != NULL)
2791 if (err == 0)
2792 fatal_error (errmsg);
2793 else
2795 errno = err;
2796 pfatal_with_name (errmsg);
2800 if (string != commands[i].prog)
2801 free (CONST_CAST (char *, string));
2804 execution_count++;
2806 /* Wait for all the subprocesses to finish. */
2809 int *statuses;
2810 struct pex_time *times = NULL;
2811 int ret_code = 0;
2813 statuses = (int *) alloca (n_commands * sizeof (int));
2814 if (!pex_get_status (pex, n_commands, statuses))
2815 fatal_error ("failed to get exit status: %m");
2817 if (report_times || report_times_to_file)
2819 times = (struct pex_time *) alloca (n_commands * sizeof (struct pex_time));
2820 if (!pex_get_times (pex, n_commands, times))
2821 fatal_error ("failed to get process times: %m");
2824 pex_free (pex);
2826 for (i = 0; i < n_commands; ++i)
2828 int status = statuses[i];
2830 if (WIFSIGNALED (status))
2832 #ifdef SIGPIPE
2833 /* SIGPIPE is a special case. It happens in -pipe mode
2834 when the compiler dies before the preprocessor is done,
2835 or the assembler dies before the compiler is done.
2836 There's generally been an error already, and this is
2837 just fallout. So don't generate another error unless
2838 we would otherwise have succeeded. */
2839 if (WTERMSIG (status) == SIGPIPE
2840 && (signal_count || greatest_status >= MIN_FATAL_STATUS))
2842 signal_count++;
2843 ret_code = -1;
2845 else
2846 #endif
2847 internal_error ("%s (program %s)",
2848 strsignal (WTERMSIG (status)), commands[i].prog);
2850 else if (WIFEXITED (status)
2851 && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
2853 if (WEXITSTATUS (status) > greatest_status)
2854 greatest_status = WEXITSTATUS (status);
2855 ret_code = -1;
2858 if (report_times || report_times_to_file)
2860 struct pex_time *pt = &times[i];
2861 double ut, st;
2863 ut = ((double) pt->user_seconds
2864 + (double) pt->user_microseconds / 1.0e6);
2865 st = ((double) pt->system_seconds
2866 + (double) pt->system_microseconds / 1.0e6);
2868 if (ut + st != 0)
2870 if (report_times)
2871 fnotice (stderr, "# %s %.2f %.2f\n",
2872 commands[i].prog, ut, st);
2874 if (report_times_to_file)
2876 int c = 0;
2877 const char *const *j;
2879 fprintf (report_times_to_file, "%g %g", ut, st);
2881 for (j = &commands[i].prog; *j; j = &commands[i].argv[++c])
2883 const char *p;
2884 for (p = *j; *p; ++p)
2885 if (*p == '"' || *p == '\\' || *p == '$'
2886 || ISSPACE (*p))
2887 break;
2889 if (*p)
2891 fprintf (report_times_to_file, " \"");
2892 for (p = *j; *p; ++p)
2894 if (*p == '"' || *p == '\\' || *p == '$')
2895 fputc ('\\', report_times_to_file);
2896 fputc (*p, report_times_to_file);
2898 fputc ('"', report_times_to_file);
2900 else
2901 fprintf (report_times_to_file, " %s", *j);
2904 fputc ('\n', report_times_to_file);
2910 return ret_code;
2914 /* Find all the switches given to us
2915 and make a vector describing them.
2916 The elements of the vector are strings, one per switch given.
2917 If a switch uses following arguments, then the `part1' field
2918 is the switch itself and the `args' field
2919 is a null-terminated vector containing the following arguments.
2920 Bits in the `live_cond' field are:
2921 SWITCH_LIVE to indicate this switch is true in a conditional spec.
2922 SWITCH_FALSE to indicate this switch is overridden by a later switch.
2923 SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
2924 SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored
2925 in all do_spec calls afterwards. Used for %<S from self specs.
2926 The `validated' field is nonzero if any spec has looked at this switch;
2927 if it remains zero at the end of the run, it must be meaningless. */
2929 #define SWITCH_LIVE (1 << 0)
2930 #define SWITCH_FALSE (1 << 1)
2931 #define SWITCH_IGNORE (1 << 2)
2932 #define SWITCH_IGNORE_PERMANENTLY (1 << 3)
2933 #define SWITCH_KEEP_FOR_GCC (1 << 4)
2935 struct switchstr
2937 const char *part1;
2938 const char **args;
2939 unsigned int live_cond;
2940 bool known;
2941 bool validated;
2942 bool ordering;
2945 static struct switchstr *switches;
2947 static int n_switches;
2949 static int n_switches_alloc;
2951 /* Set to zero if -fcompare-debug is disabled, positive if it's
2952 enabled and we're running the first compilation, negative if it's
2953 enabled and we're running the second compilation. For most of the
2954 time, it's in the range -1..1, but it can be temporarily set to 2
2955 or 3 to indicate that the -fcompare-debug flags didn't come from
2956 the command-line, but rather from the GCC_COMPARE_DEBUG environment
2957 variable, until a synthesized -fcompare-debug flag is added to the
2958 command line. */
2959 int compare_debug;
2961 /* Set to nonzero if we've seen the -fcompare-debug-second flag. */
2962 int compare_debug_second;
2964 /* Set to the flags that should be passed to the second compilation in
2965 a -fcompare-debug compilation. */
2966 const char *compare_debug_opt;
2968 static struct switchstr *switches_debug_check[2];
2970 static int n_switches_debug_check[2];
2972 static int n_switches_alloc_debug_check[2];
2974 static char *debug_check_temp_file[2];
2976 /* Language is one of three things:
2978 1) The name of a real programming language.
2979 2) NULL, indicating that no one has figured out
2980 what it is yet.
2981 3) '*', indicating that the file should be passed
2982 to the linker. */
2983 struct infile
2985 const char *name;
2986 const char *language;
2987 struct compiler *incompiler;
2988 bool compiled;
2989 bool preprocessed;
2992 /* Also a vector of input files specified. */
2994 static struct infile *infiles;
2996 int n_infiles;
2998 static int n_infiles_alloc;
3000 /* True if multiple input files are being compiled to a single
3001 assembly file. */
3003 static bool combine_inputs;
3005 /* This counts the number of libraries added by lang_specific_driver, so that
3006 we can tell if there were any user supplied any files or libraries. */
3008 static int added_libraries;
3010 /* And a vector of corresponding output files is made up later. */
3012 const char **outfiles;
3014 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3016 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
3017 is true if we should look for an executable suffix. DO_OBJ
3018 is true if we should look for an object suffix. */
3020 static const char *
3021 convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
3022 int do_obj ATTRIBUTE_UNUSED)
3024 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3025 int i;
3026 #endif
3027 int len;
3029 if (name == NULL)
3030 return NULL;
3032 len = strlen (name);
3034 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3035 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
3036 if (do_obj && len > 2
3037 && name[len - 2] == '.'
3038 && name[len - 1] == 'o')
3040 obstack_grow (&obstack, name, len - 2);
3041 obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
3042 name = XOBFINISH (&obstack, const char *);
3044 #endif
3046 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3047 /* If there is no filetype, make it the executable suffix (which includes
3048 the "."). But don't get confused if we have just "-o". */
3049 if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
3050 return name;
3052 for (i = len - 1; i >= 0; i--)
3053 if (IS_DIR_SEPARATOR (name[i]))
3054 break;
3056 for (i++; i < len; i++)
3057 if (name[i] == '.')
3058 return name;
3060 obstack_grow (&obstack, name, len);
3061 obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
3062 strlen (TARGET_EXECUTABLE_SUFFIX));
3063 name = XOBFINISH (&obstack, const char *);
3064 #endif
3066 return name;
3068 #endif
3070 /* Display the command line switches accepted by gcc. */
3071 static void
3072 display_help (void)
3074 printf (_("Usage: %s [options] file...\n"), progname);
3075 fputs (_("Options:\n"), stdout);
3077 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout);
3078 fputs (_(" --help Display this information\n"), stdout);
3079 fputs (_(" --target-help Display target specific command line options\n"), stdout);
3080 fputs (_(" --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...]\n"), stdout);
3081 fputs (_(" Display specific types of command line options\n"), stdout);
3082 if (! verbose_flag)
3083 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
3084 fputs (_(" --version Display compiler version information\n"), stdout);
3085 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout);
3086 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout);
3087 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout);
3088 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout);
3089 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout);
3090 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout);
3091 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout);
3092 fputs (_("\
3093 -print-multiarch Display the target's normalized GNU triplet, used as\n\
3094 a component in the library path\n"), stdout);
3095 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout);
3096 fputs (_("\
3097 -print-multi-lib Display the mapping between command line options and\n\
3098 multiple library search directories\n"), stdout);
3099 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries\n"), stdout);
3100 fputs (_(" -print-sysroot Display the target libraries directory\n"), stdout);
3101 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n"), stdout);
3102 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout);
3103 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout);
3104 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout);
3105 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler\n"), stdout);
3106 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n"), stdout);
3107 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout);
3108 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout);
3109 fputs (_(" -save-temps=<arg> Do not delete intermediate files\n"), stdout);
3110 fputs (_("\
3111 -no-canonical-prefixes Do not canonicalize paths when building relative\n\
3112 prefixes to other gcc components\n"), stdout);
3113 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout);
3114 fputs (_(" -time Time the execution of each subprocess\n"), stdout);
3115 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout);
3116 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout);
3117 fputs (_("\
3118 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3119 and libraries\n"), stdout);
3120 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout);
3121 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout);
3122 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout);
3123 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout);
3124 fputs (_(" -S Compile only; do not assemble or link\n"), stdout);
3125 fputs (_(" -c Compile and assemble, but do not link\n"), stdout);
3126 fputs (_(" -o <file> Place the output into <file>\n"), stdout);
3127 fputs (_(" -pie Create a position independent executable\n"), stdout);
3128 fputs (_(" -shared Create a shared library\n"), stdout);
3129 fputs (_("\
3130 -x <language> Specify the language of the following input files\n\
3131 Permissible languages include: c c++ assembler none\n\
3132 'none' means revert to the default behavior of\n\
3133 guessing the language based on the file's extension\n\
3134 "), stdout);
3136 printf (_("\
3137 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3138 passed on to the various sub-processes invoked by %s. In order to pass\n\
3139 other options on to these processes the -W<letter> options must be used.\n\
3140 "), progname);
3142 /* The rest of the options are displayed by invocations of the various
3143 sub-processes. */
3146 static void
3147 add_preprocessor_option (const char *option, int len)
3149 preprocessor_options.safe_push (save_string (option, len));
3152 static void
3153 add_assembler_option (const char *option, int len)
3155 assembler_options.safe_push (save_string (option, len));
3158 static void
3159 add_linker_option (const char *option, int len)
3161 linker_options.safe_push (save_string (option, len));
3164 /* Allocate space for an input file in infiles. */
3166 static void
3167 alloc_infile (void)
3169 if (n_infiles_alloc == 0)
3171 n_infiles_alloc = 16;
3172 infiles = XNEWVEC (struct infile, n_infiles_alloc);
3174 else if (n_infiles_alloc == n_infiles)
3176 n_infiles_alloc *= 2;
3177 infiles = XRESIZEVEC (struct infile, infiles, n_infiles_alloc);
3181 /* Store an input file with the given NAME and LANGUAGE in
3182 infiles. */
3184 static void
3185 add_infile (const char *name, const char *language)
3187 alloc_infile ();
3188 infiles[n_infiles].name = name;
3189 infiles[n_infiles++].language = language;
3192 /* Allocate space for a switch in switches. */
3194 static void
3195 alloc_switch (void)
3197 if (n_switches_alloc == 0)
3199 n_switches_alloc = 16;
3200 switches = XNEWVEC (struct switchstr, n_switches_alloc);
3202 else if (n_switches_alloc == n_switches)
3204 n_switches_alloc *= 2;
3205 switches = XRESIZEVEC (struct switchstr, switches, n_switches_alloc);
3209 /* Save an option OPT with N_ARGS arguments in array ARGS, marking it
3210 as validated if VALIDATED and KNOWN if it is an internal switch. */
3212 static void
3213 save_switch (const char *opt, size_t n_args, const char *const *args,
3214 bool validated, bool known)
3216 alloc_switch ();
3217 switches[n_switches].part1 = opt + 1;
3218 if (n_args == 0)
3219 switches[n_switches].args = 0;
3220 else
3222 switches[n_switches].args = XNEWVEC (const char *, n_args + 1);
3223 memcpy (switches[n_switches].args, args, n_args * sizeof (const char *));
3224 switches[n_switches].args[n_args] = NULL;
3227 switches[n_switches].live_cond = 0;
3228 switches[n_switches].validated = validated;
3229 switches[n_switches].known = known;
3230 switches[n_switches].ordering = 0;
3231 n_switches++;
3234 /* Handle an option DECODED that is unknown to the option-processing
3235 machinery. */
3237 static bool
3238 driver_unknown_option_callback (const struct cl_decoded_option *decoded)
3240 const char *opt = decoded->arg;
3241 if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-'
3242 && !(decoded->errors & CL_ERR_NEGATIVE))
3244 /* Leave unknown -Wno-* options for the compiler proper, to be
3245 diagnosed only if there are warnings. */
3246 save_switch (decoded->canonical_option[0],
3247 decoded->canonical_option_num_elements - 1,
3248 &decoded->canonical_option[1], false, true);
3249 return false;
3251 if (decoded->opt_index == OPT_SPECIAL_unknown)
3253 /* Give it a chance to define it a a spec file. */
3254 save_switch (decoded->canonical_option[0],
3255 decoded->canonical_option_num_elements - 1,
3256 &decoded->canonical_option[1], false, false);
3257 return false;
3259 else
3260 return true;
3263 /* Handle an option DECODED that is not marked as CL_DRIVER.
3264 LANG_MASK will always be CL_DRIVER. */
3266 static void
3267 driver_wrong_lang_callback (const struct cl_decoded_option *decoded,
3268 unsigned int lang_mask ATTRIBUTE_UNUSED)
3270 /* At this point, non-driver options are accepted (and expected to
3271 be passed down by specs) unless marked to be rejected by the
3272 driver. Options to be rejected by the driver but accepted by the
3273 compilers proper are treated just like completely unknown
3274 options. */
3275 const struct cl_option *option = &cl_options[decoded->opt_index];
3277 if (option->cl_reject_driver)
3278 error ("unrecognized command line option %qs",
3279 decoded->orig_option_with_args_text);
3280 else
3281 save_switch (decoded->canonical_option[0],
3282 decoded->canonical_option_num_elements - 1,
3283 &decoded->canonical_option[1], false, true);
3286 static const char *spec_lang = 0;
3287 static int last_language_n_infiles;
3289 /* Handle a driver option; arguments and return value as for
3290 handle_option. */
3292 static bool
3293 driver_handle_option (struct gcc_options *opts,
3294 struct gcc_options *opts_set,
3295 const struct cl_decoded_option *decoded,
3296 unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
3297 location_t loc,
3298 const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED,
3299 diagnostic_context *dc)
3301 size_t opt_index = decoded->opt_index;
3302 const char *arg = decoded->arg;
3303 const char *compare_debug_replacement_opt;
3304 int value = decoded->value;
3305 bool validated = false;
3306 bool do_save = true;
3308 gcc_assert (opts == &global_options);
3309 gcc_assert (opts_set == &global_options_set);
3310 gcc_assert (kind == DK_UNSPECIFIED);
3311 gcc_assert (loc == UNKNOWN_LOCATION);
3312 gcc_assert (dc == global_dc);
3314 switch (opt_index)
3316 case OPT_dumpspecs:
3318 struct spec_list *sl;
3319 init_spec ();
3320 for (sl = specs; sl; sl = sl->next)
3321 printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3322 if (link_command_spec)
3323 printf ("*link_command:\n%s\n\n", link_command_spec);
3324 exit (0);
3327 case OPT_dumpversion:
3328 printf ("%s\n", spec_version);
3329 exit (0);
3331 case OPT_dumpmachine:
3332 printf ("%s\n", spec_machine);
3333 exit (0);
3335 case OPT__version:
3336 print_version = 1;
3338 /* CPP driver cannot obtain switch from cc1_options. */
3339 if (is_cpp_driver)
3340 add_preprocessor_option ("--version", strlen ("--version"));
3341 add_assembler_option ("--version", strlen ("--version"));
3342 add_linker_option ("--version", strlen ("--version"));
3343 break;
3345 case OPT__help:
3346 print_help_list = 1;
3348 /* CPP driver cannot obtain switch from cc1_options. */
3349 if (is_cpp_driver)
3350 add_preprocessor_option ("--help", 6);
3351 add_assembler_option ("--help", 6);
3352 add_linker_option ("--help", 6);
3353 break;
3355 case OPT__help_:
3356 print_subprocess_help = 2;
3357 break;
3359 case OPT__target_help:
3360 print_subprocess_help = 1;
3362 /* CPP driver cannot obtain switch from cc1_options. */
3363 if (is_cpp_driver)
3364 add_preprocessor_option ("--target-help", 13);
3365 add_assembler_option ("--target-help", 13);
3366 add_linker_option ("--target-help", 13);
3367 break;
3369 case OPT__no_sysroot_suffix:
3370 case OPT_pass_exit_codes:
3371 case OPT_print_search_dirs:
3372 case OPT_print_file_name_:
3373 case OPT_print_prog_name_:
3374 case OPT_print_multi_lib:
3375 case OPT_print_multi_directory:
3376 case OPT_print_sysroot:
3377 case OPT_print_multi_os_directory:
3378 case OPT_print_multiarch:
3379 case OPT_print_sysroot_headers_suffix:
3380 case OPT_time:
3381 case OPT_wrapper:
3382 /* These options set the variables specified in common.opt
3383 automatically, and do not need to be saved for spec
3384 processing. */
3385 do_save = false;
3386 break;
3388 case OPT_print_libgcc_file_name:
3389 print_file_name = "libgcc.a";
3390 do_save = false;
3391 break;
3393 case OPT_fuse_ld_bfd:
3394 use_ld = ".bfd";
3395 break;
3397 case OPT_fuse_ld_gold:
3398 use_ld = ".gold";
3399 break;
3401 case OPT_fcompare_debug_second:
3402 compare_debug_second = 1;
3403 break;
3405 case OPT_fcompare_debug:
3406 switch (value)
3408 case 0:
3409 compare_debug_replacement_opt = "-fcompare-debug=";
3410 arg = "";
3411 goto compare_debug_with_arg;
3413 case 1:
3414 compare_debug_replacement_opt = "-fcompare-debug=-gtoggle";
3415 arg = "-gtoggle";
3416 goto compare_debug_with_arg;
3418 default:
3419 gcc_unreachable ();
3421 break;
3423 case OPT_fcompare_debug_:
3424 compare_debug_replacement_opt = decoded->canonical_option[0];
3425 compare_debug_with_arg:
3426 gcc_assert (decoded->canonical_option_num_elements == 1);
3427 gcc_assert (arg != NULL);
3428 if (*arg)
3429 compare_debug = 1;
3430 else
3431 compare_debug = -1;
3432 if (compare_debug < 0)
3433 compare_debug_opt = NULL;
3434 else
3435 compare_debug_opt = arg;
3436 save_switch (compare_debug_replacement_opt, 0, NULL, validated, true);
3437 return true;
3439 case OPT_Wa_:
3441 int prev, j;
3442 /* Pass the rest of this option to the assembler. */
3444 /* Split the argument at commas. */
3445 prev = 0;
3446 for (j = 0; arg[j]; j++)
3447 if (arg[j] == ',')
3449 add_assembler_option (arg + prev, j - prev);
3450 prev = j + 1;
3453 /* Record the part after the last comma. */
3454 add_assembler_option (arg + prev, j - prev);
3456 do_save = false;
3457 break;
3459 case OPT_Wp_:
3461 int prev, j;
3462 /* Pass the rest of this option to the preprocessor. */
3464 /* Split the argument at commas. */
3465 prev = 0;
3466 for (j = 0; arg[j]; j++)
3467 if (arg[j] == ',')
3469 add_preprocessor_option (arg + prev, j - prev);
3470 prev = j + 1;
3473 /* Record the part after the last comma. */
3474 add_preprocessor_option (arg + prev, j - prev);
3476 do_save = false;
3477 break;
3479 case OPT_Wl_:
3481 int prev, j;
3482 /* Split the argument at commas. */
3483 prev = 0;
3484 for (j = 0; arg[j]; j++)
3485 if (arg[j] == ',')
3487 add_infile (save_string (arg + prev, j - prev), "*");
3488 prev = j + 1;
3490 /* Record the part after the last comma. */
3491 add_infile (arg + prev, "*");
3493 do_save = false;
3494 break;
3496 case OPT_Xlinker:
3497 add_infile (arg, "*");
3498 do_save = false;
3499 break;
3501 case OPT_Xpreprocessor:
3502 add_preprocessor_option (arg, strlen (arg));
3503 do_save = false;
3504 break;
3506 case OPT_Xassembler:
3507 add_assembler_option (arg, strlen (arg));
3508 do_save = false;
3509 break;
3511 case OPT_l:
3512 /* POSIX allows separation of -l and the lib arg; canonicalize
3513 by concatenating -l with its arg */
3514 add_infile (concat ("-l", arg, NULL), "*");
3515 do_save = false;
3516 break;
3518 case OPT_L:
3519 /* Similarly, canonicalize -L for linkers that may not accept
3520 separate arguments. */
3521 save_switch (concat ("-L", arg, NULL), 0, NULL, validated, true);
3522 return true;
3524 case OPT_F:
3525 /* Likewise -F. */
3526 save_switch (concat ("-F", arg, NULL), 0, NULL, validated, true);
3527 return true;
3529 case OPT_save_temps:
3530 save_temps_flag = SAVE_TEMPS_CWD;
3531 validated = true;
3532 break;
3534 case OPT_save_temps_:
3535 if (strcmp (arg, "cwd") == 0)
3536 save_temps_flag = SAVE_TEMPS_CWD;
3537 else if (strcmp (arg, "obj") == 0
3538 || strcmp (arg, "object") == 0)
3539 save_temps_flag = SAVE_TEMPS_OBJ;
3540 else
3541 fatal_error ("%qs is an unknown -save-temps option",
3542 decoded->orig_option_with_args_text);
3543 break;
3545 case OPT_no_canonical_prefixes:
3546 /* Already handled as a special case, so ignored here. */
3547 do_save = false;
3548 break;
3550 case OPT_pipe:
3551 validated = true;
3552 /* These options set the variables specified in common.opt
3553 automatically, but do need to be saved for spec
3554 processing. */
3555 break;
3557 case OPT_specs_:
3559 struct user_specs *user = XNEW (struct user_specs);
3561 user->next = (struct user_specs *) 0;
3562 user->filename = arg;
3563 if (user_specs_tail)
3564 user_specs_tail->next = user;
3565 else
3566 user_specs_head = user;
3567 user_specs_tail = user;
3569 validated = true;
3570 break;
3572 case OPT__sysroot_:
3573 target_system_root = arg;
3574 target_system_root_changed = 1;
3575 do_save = false;
3576 break;
3578 case OPT_time_:
3579 if (report_times_to_file)
3580 fclose (report_times_to_file);
3581 report_times_to_file = fopen (arg, "a");
3582 do_save = false;
3583 break;
3585 case OPT____:
3586 /* "-###"
3587 This is similar to -v except that there is no execution
3588 of the commands and the echoed arguments are quoted. It
3589 is intended for use in shell scripts to capture the
3590 driver-generated command line. */
3591 verbose_only_flag++;
3592 verbose_flag = 1;
3593 do_save = false;
3594 break;
3596 case OPT_B:
3598 size_t len = strlen (arg);
3600 /* Catch the case where the user has forgotten to append a
3601 directory separator to the path. Note, they may be using
3602 -B to add an executable name prefix, eg "i386-elf-", in
3603 order to distinguish between multiple installations of
3604 GCC in the same directory. Hence we must check to see
3605 if appending a directory separator actually makes a
3606 valid directory name. */
3607 if (!IS_DIR_SEPARATOR (arg[len - 1])
3608 && is_directory (arg, false))
3610 char *tmp = XNEWVEC (char, len + 2);
3611 strcpy (tmp, arg);
3612 tmp[len] = DIR_SEPARATOR;
3613 tmp[++len] = 0;
3614 arg = tmp;
3617 add_prefix (&exec_prefixes, arg, NULL,
3618 PREFIX_PRIORITY_B_OPT, 0, 0);
3619 add_prefix (&startfile_prefixes, arg, NULL,
3620 PREFIX_PRIORITY_B_OPT, 0, 0);
3621 add_prefix (&include_prefixes, arg, NULL,
3622 PREFIX_PRIORITY_B_OPT, 0, 0);
3624 validated = true;
3625 break;
3627 case OPT_x:
3628 spec_lang = arg;
3629 if (!strcmp (spec_lang, "none"))
3630 /* Suppress the warning if -xnone comes after the last input
3631 file, because alternate command interfaces like g++ might
3632 find it useful to place -xnone after each input file. */
3633 spec_lang = 0;
3634 else
3635 last_language_n_infiles = n_infiles;
3636 do_save = false;
3637 break;
3639 case OPT_o:
3640 have_o = 1;
3641 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3642 arg = convert_filename (arg, ! have_c, 0);
3643 #endif
3644 /* Save the output name in case -save-temps=obj was used. */
3645 save_temps_prefix = xstrdup (arg);
3646 /* On some systems, ld cannot handle "-o" without a space. So
3647 split the option from its argument. */
3648 save_switch ("-o", 1, &arg, validated, true);
3649 return true;
3651 case OPT_static_libgcc:
3652 case OPT_shared_libgcc:
3653 case OPT_static_libgfortran:
3654 case OPT_static_libstdc__:
3655 /* These are always valid, since gcc.c itself understands the
3656 first two, gfortranspec.c understands -static-libgfortran and
3657 g++spec.c understands -static-libstdc++ */
3658 validated = true;
3659 break;
3661 case OPT_fwpa:
3662 flag_wpa = "";
3663 break;
3665 default:
3666 /* Various driver options need no special processing at this
3667 point, having been handled in a prescan above or being
3668 handled by specs. */
3669 break;
3672 if (do_save)
3673 save_switch (decoded->canonical_option[0],
3674 decoded->canonical_option_num_elements - 1,
3675 &decoded->canonical_option[1], validated, true);
3676 return true;
3679 /* Put the driver's standard set of option handlers in *HANDLERS. */
3681 static void
3682 set_option_handlers (struct cl_option_handlers *handlers)
3684 handlers->unknown_option_callback = driver_unknown_option_callback;
3685 handlers->wrong_lang_callback = driver_wrong_lang_callback;
3686 handlers->num_handlers = 3;
3687 handlers->handlers[0].handler = driver_handle_option;
3688 handlers->handlers[0].mask = CL_DRIVER;
3689 handlers->handlers[1].handler = common_handle_option;
3690 handlers->handlers[1].mask = CL_COMMON;
3691 handlers->handlers[2].handler = target_handle_option;
3692 handlers->handlers[2].mask = CL_TARGET;
3695 /* Create the vector `switches' and its contents.
3696 Store its length in `n_switches'. */
3698 static void
3699 process_command (unsigned int decoded_options_count,
3700 struct cl_decoded_option *decoded_options)
3702 const char *temp;
3703 char *temp1;
3704 char *tooldir_prefix, *tooldir_prefix2;
3705 char *(*get_relative_prefix) (const char *, const char *,
3706 const char *) = NULL;
3707 struct cl_option_handlers handlers;
3708 unsigned int j;
3710 gcc_exec_prefix = getenv ("GCC_EXEC_PREFIX");
3712 n_switches = 0;
3713 n_infiles = 0;
3714 added_libraries = 0;
3716 /* Figure compiler version from version string. */
3718 compiler_version = temp1 = xstrdup (version_string);
3720 for (; *temp1; ++temp1)
3722 if (*temp1 == ' ')
3724 *temp1 = '\0';
3725 break;
3729 /* Handle any -no-canonical-prefixes flag early, to assign the function
3730 that builds relative prefixes. This function creates default search
3731 paths that are needed later in normal option handling. */
3733 for (j = 1; j < decoded_options_count; j++)
3735 if (decoded_options[j].opt_index == OPT_no_canonical_prefixes)
3737 get_relative_prefix = make_relative_prefix_ignore_links;
3738 break;
3741 if (! get_relative_prefix)
3742 get_relative_prefix = make_relative_prefix;
3744 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
3745 see if we can create it from the pathname specified in
3746 decoded_options[0].arg. */
3748 gcc_libexec_prefix = standard_libexec_prefix;
3749 #ifndef VMS
3750 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
3751 if (!gcc_exec_prefix)
3753 gcc_exec_prefix = get_relative_prefix (decoded_options[0].arg,
3754 standard_bindir_prefix,
3755 standard_exec_prefix);
3756 gcc_libexec_prefix = get_relative_prefix (decoded_options[0].arg,
3757 standard_bindir_prefix,
3758 standard_libexec_prefix);
3759 if (gcc_exec_prefix)
3760 xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
3762 else
3764 /* make_relative_prefix requires a program name, but
3765 GCC_EXEC_PREFIX is typically a directory name with a trailing
3766 / (which is ignored by make_relative_prefix), so append a
3767 program name. */
3768 char *tmp_prefix = concat (gcc_exec_prefix, "gcc", NULL);
3769 gcc_libexec_prefix = get_relative_prefix (tmp_prefix,
3770 standard_exec_prefix,
3771 standard_libexec_prefix);
3773 /* The path is unrelocated, so fallback to the original setting. */
3774 if (!gcc_libexec_prefix)
3775 gcc_libexec_prefix = standard_libexec_prefix;
3777 free (tmp_prefix);
3779 #else
3780 #endif
3781 /* From this point onward, gcc_exec_prefix is non-null if the toolchain
3782 is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
3783 or an automatically created GCC_EXEC_PREFIX from
3784 decoded_options[0].arg. */
3786 /* Do language-specific adjustment/addition of flags. */
3787 lang_specific_driver (&decoded_options, &decoded_options_count,
3788 &added_libraries);
3790 if (gcc_exec_prefix)
3792 int len = strlen (gcc_exec_prefix);
3794 if (len > (int) sizeof ("/lib/gcc/") - 1
3795 && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
3797 temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1;
3798 if (IS_DIR_SEPARATOR (*temp)
3799 && filename_ncmp (temp + 1, "lib", 3) == 0
3800 && IS_DIR_SEPARATOR (temp[4])
3801 && filename_ncmp (temp + 5, "gcc", 3) == 0)
3802 len -= sizeof ("/lib/gcc/") - 1;
3805 set_std_prefix (gcc_exec_prefix, len);
3806 add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC",
3807 PREFIX_PRIORITY_LAST, 0, 0);
3808 add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
3809 PREFIX_PRIORITY_LAST, 0, 0);
3812 /* COMPILER_PATH and LIBRARY_PATH have values
3813 that are lists of directory names with colons. */
3815 temp = getenv ("COMPILER_PATH");
3816 if (temp)
3818 const char *startp, *endp;
3819 char *nstore = (char *) alloca (strlen (temp) + 3);
3821 startp = endp = temp;
3822 while (1)
3824 if (*endp == PATH_SEPARATOR || *endp == 0)
3826 strncpy (nstore, startp, endp - startp);
3827 if (endp == startp)
3828 strcpy (nstore, concat (".", dir_separator_str, NULL));
3829 else if (!IS_DIR_SEPARATOR (endp[-1]))
3831 nstore[endp - startp] = DIR_SEPARATOR;
3832 nstore[endp - startp + 1] = 0;
3834 else
3835 nstore[endp - startp] = 0;
3836 add_prefix (&exec_prefixes, nstore, 0,
3837 PREFIX_PRIORITY_LAST, 0, 0);
3838 add_prefix (&include_prefixes, nstore, 0,
3839 PREFIX_PRIORITY_LAST, 0, 0);
3840 if (*endp == 0)
3841 break;
3842 endp = startp = endp + 1;
3844 else
3845 endp++;
3849 temp = getenv (LIBRARY_PATH_ENV);
3850 if (temp && *cross_compile == '0')
3852 const char *startp, *endp;
3853 char *nstore = (char *) alloca (strlen (temp) + 3);
3855 startp = endp = temp;
3856 while (1)
3858 if (*endp == PATH_SEPARATOR || *endp == 0)
3860 strncpy (nstore, startp, endp - startp);
3861 if (endp == startp)
3862 strcpy (nstore, concat (".", dir_separator_str, NULL));
3863 else if (!IS_DIR_SEPARATOR (endp[-1]))
3865 nstore[endp - startp] = DIR_SEPARATOR;
3866 nstore[endp - startp + 1] = 0;
3868 else
3869 nstore[endp - startp] = 0;
3870 add_prefix (&startfile_prefixes, nstore, NULL,
3871 PREFIX_PRIORITY_LAST, 0, 1);
3872 if (*endp == 0)
3873 break;
3874 endp = startp = endp + 1;
3876 else
3877 endp++;
3881 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
3882 temp = getenv ("LPATH");
3883 if (temp && *cross_compile == '0')
3885 const char *startp, *endp;
3886 char *nstore = (char *) alloca (strlen (temp) + 3);
3888 startp = endp = temp;
3889 while (1)
3891 if (*endp == PATH_SEPARATOR || *endp == 0)
3893 strncpy (nstore, startp, endp - startp);
3894 if (endp == startp)
3895 strcpy (nstore, concat (".", dir_separator_str, NULL));
3896 else if (!IS_DIR_SEPARATOR (endp[-1]))
3898 nstore[endp - startp] = DIR_SEPARATOR;
3899 nstore[endp - startp + 1] = 0;
3901 else
3902 nstore[endp - startp] = 0;
3903 add_prefix (&startfile_prefixes, nstore, NULL,
3904 PREFIX_PRIORITY_LAST, 0, 1);
3905 if (*endp == 0)
3906 break;
3907 endp = startp = endp + 1;
3909 else
3910 endp++;
3914 /* Process the options and store input files and switches in their
3915 vectors. */
3917 last_language_n_infiles = -1;
3919 set_option_handlers (&handlers);
3921 for (j = 1; j < decoded_options_count; j++)
3923 switch (decoded_options[j].opt_index)
3925 case OPT_S:
3926 case OPT_c:
3927 case OPT_E:
3928 have_c = 1;
3929 break;
3931 if (have_c)
3932 break;
3935 for (j = 1; j < decoded_options_count; j++)
3937 if (decoded_options[j].opt_index == OPT_SPECIAL_input_file)
3939 const char *arg = decoded_options[j].arg;
3940 const char *p = strrchr (arg, '@');
3941 char *fname;
3942 long offset;
3943 int consumed;
3944 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3945 arg = convert_filename (arg, 0, access (arg, F_OK));
3946 #endif
3947 /* For LTO static archive support we handle input file
3948 specifications that are composed of a filename and
3949 an offset like FNAME@OFFSET. */
3950 if (p
3951 && p != arg
3952 && sscanf (p, "@%li%n", &offset, &consumed) >= 1
3953 && strlen (p) == (unsigned int)consumed)
3955 fname = (char *)xmalloc (p - arg + 1);
3956 memcpy (fname, arg, p - arg);
3957 fname[p - arg] = '\0';
3958 /* Only accept non-stdin and existing FNAME parts, otherwise
3959 try with the full name. */
3960 if (strcmp (fname, "-") == 0 || access (fname, F_OK) < 0)
3962 free (fname);
3963 fname = xstrdup (arg);
3966 else
3967 fname = xstrdup (arg);
3969 if (strcmp (fname, "-") != 0 && access (fname, F_OK) < 0)
3970 perror_with_name (fname);
3971 else
3972 add_infile (arg, spec_lang);
3974 free (fname);
3975 continue;
3978 read_cmdline_option (&global_options, &global_options_set,
3979 decoded_options + j, UNKNOWN_LOCATION,
3980 CL_DRIVER, &handlers, global_dc);
3983 /* If -save-temps=obj and -o name, create the prefix to use for %b.
3984 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
3985 if (save_temps_flag == SAVE_TEMPS_OBJ && save_temps_prefix != NULL)
3987 save_temps_length = strlen (save_temps_prefix);
3988 temp = strrchr (lbasename (save_temps_prefix), '.');
3989 if (temp)
3991 save_temps_length -= strlen (temp);
3992 save_temps_prefix[save_temps_length] = '\0';
3996 else if (save_temps_prefix != NULL)
3998 free (save_temps_prefix);
3999 save_temps_prefix = NULL;
4002 if (save_temps_flag && use_pipes)
4004 /* -save-temps overrides -pipe, so that temp files are produced */
4005 if (save_temps_flag)
4006 warning (0, "-pipe ignored because -save-temps specified");
4007 use_pipes = 0;
4010 if (!compare_debug)
4012 const char *gcd = getenv ("GCC_COMPARE_DEBUG");
4014 if (gcd && gcd[0] == '-')
4016 compare_debug = 2;
4017 compare_debug_opt = gcd;
4019 else if (gcd && *gcd && strcmp (gcd, "0"))
4021 compare_debug = 3;
4022 compare_debug_opt = "-gtoggle";
4025 else if (compare_debug < 0)
4027 compare_debug = 0;
4028 gcc_assert (!compare_debug_opt);
4031 /* Set up the search paths. We add directories that we expect to
4032 contain GNU Toolchain components before directories specified by
4033 the machine description so that we will find GNU components (like
4034 the GNU assembler) before those of the host system. */
4036 /* If we don't know where the toolchain has been installed, use the
4037 configured-in locations. */
4038 if (!gcc_exec_prefix)
4040 #ifndef OS2
4041 add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC",
4042 PREFIX_PRIORITY_LAST, 1, 0);
4043 add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS",
4044 PREFIX_PRIORITY_LAST, 2, 0);
4045 add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
4046 PREFIX_PRIORITY_LAST, 2, 0);
4047 #endif
4048 add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
4049 PREFIX_PRIORITY_LAST, 1, 0);
4052 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix));
4053 tooldir_prefix2 = concat (tooldir_base_prefix, spec_machine,
4054 dir_separator_str, NULL);
4056 /* Look for tools relative to the location from which the driver is
4057 running, or, if that is not available, the configured prefix. */
4058 tooldir_prefix
4059 = concat (gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
4060 spec_machine, dir_separator_str,
4061 spec_version, dir_separator_str, tooldir_prefix2, NULL);
4062 free (tooldir_prefix2);
4064 add_prefix (&exec_prefixes,
4065 concat (tooldir_prefix, "bin", dir_separator_str, NULL),
4066 "BINUTILS", PREFIX_PRIORITY_LAST, 0, 0);
4067 add_prefix (&startfile_prefixes,
4068 concat (tooldir_prefix, "lib", dir_separator_str, NULL),
4069 "BINUTILS", PREFIX_PRIORITY_LAST, 0, 1);
4070 free (tooldir_prefix);
4072 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
4073 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
4074 then consider it to relocate with the rest of the GCC installation
4075 if GCC_EXEC_PREFIX is set.
4076 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
4077 if (target_system_root && !target_system_root_changed && gcc_exec_prefix)
4079 char *tmp_prefix = get_relative_prefix (decoded_options[0].arg,
4080 standard_bindir_prefix,
4081 target_system_root);
4082 if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0)
4084 target_system_root = tmp_prefix;
4085 target_system_root_changed = 1;
4088 #endif
4090 /* More prefixes are enabled in main, after we read the specs file
4091 and determine whether this is cross-compilation or not. */
4093 if (n_infiles == last_language_n_infiles && spec_lang != 0)
4094 warning (0, "%<-x %s%> after last input file has no effect", spec_lang);
4096 /* Synthesize -fcompare-debug flag from the GCC_COMPARE_DEBUG
4097 environment variable. */
4098 if (compare_debug == 2 || compare_debug == 3)
4100 const char *opt = concat ("-fcompare-debug=", compare_debug_opt, NULL);
4101 save_switch (opt, 0, NULL, false, true);
4102 compare_debug = 1;
4105 /* Ensure we only invoke each subprocess once. */
4106 if (print_subprocess_help || print_help_list || print_version)
4108 n_infiles = 0;
4110 /* Create a dummy input file, so that we can pass
4111 the help option on to the various sub-processes. */
4112 add_infile ("help-dummy", "c");
4115 alloc_switch ();
4116 switches[n_switches].part1 = 0;
4117 alloc_infile ();
4118 infiles[n_infiles].name = 0;
4121 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4122 and place that in the environment. */
4124 static void
4125 set_collect_gcc_options (void)
4127 int i;
4128 int first_time;
4130 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4131 the compiler. */
4132 obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
4133 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4135 first_time = TRUE;
4136 for (i = 0; (int) i < n_switches; i++)
4138 const char *const *args;
4139 const char *p, *q;
4140 if (!first_time)
4141 obstack_grow (&collect_obstack, " ", 1);
4143 first_time = FALSE;
4145 /* Ignore elided switches. */
4146 if ((switches[i].live_cond
4147 & (SWITCH_IGNORE | SWITCH_KEEP_FOR_GCC))
4148 == SWITCH_IGNORE)
4149 continue;
4151 obstack_grow (&collect_obstack, "'-", 2);
4152 q = switches[i].part1;
4153 while ((p = strchr (q, '\'')))
4155 obstack_grow (&collect_obstack, q, p - q);
4156 obstack_grow (&collect_obstack, "'\\''", 4);
4157 q = ++p;
4159 obstack_grow (&collect_obstack, q, strlen (q));
4160 obstack_grow (&collect_obstack, "'", 1);
4162 for (args = switches[i].args; args && *args; args++)
4164 obstack_grow (&collect_obstack, " '", 2);
4165 q = *args;
4166 while ((p = strchr (q, '\'')))
4168 obstack_grow (&collect_obstack, q, p - q);
4169 obstack_grow (&collect_obstack, "'\\''", 4);
4170 q = ++p;
4172 obstack_grow (&collect_obstack, q, strlen (q));
4173 obstack_grow (&collect_obstack, "'", 1);
4176 obstack_grow (&collect_obstack, "\0", 1);
4177 xputenv (XOBFINISH (&collect_obstack, char *));
4180 /* Process a spec string, accumulating and running commands. */
4182 /* These variables describe the input file name.
4183 input_file_number is the index on outfiles of this file,
4184 so that the output file name can be stored for later use by %o.
4185 input_basename is the start of the part of the input file
4186 sans all directory names, and basename_length is the number
4187 of characters starting there excluding the suffix .c or whatever. */
4189 static const char *gcc_input_filename;
4190 static int input_file_number;
4191 size_t input_filename_length;
4192 static int basename_length;
4193 static int suffixed_basename_length;
4194 static const char *input_basename;
4195 static const char *input_suffix;
4196 #ifndef HOST_LACKS_INODE_NUMBERS
4197 static struct stat input_stat;
4198 #endif
4199 static int input_stat_set;
4201 /* The compiler used to process the current input file. */
4202 static struct compiler *input_file_compiler;
4204 /* These are variables used within do_spec and do_spec_1. */
4206 /* Nonzero if an arg has been started and not yet terminated
4207 (with space, tab or newline). */
4208 static int arg_going;
4210 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4211 is a temporary file name. */
4212 static int delete_this_arg;
4214 /* Nonzero means %w has been seen; the next arg to be terminated
4215 is the output file name of this compilation. */
4216 static int this_is_output_file;
4218 /* Nonzero means %s has been seen; the next arg to be terminated
4219 is the name of a library file and we should try the standard
4220 search dirs for it. */
4221 static int this_is_library_file;
4223 /* Nonzero means %T has been seen; the next arg to be terminated
4224 is the name of a linker script and we should try all of the
4225 standard search dirs for it. If it is found insert a --script
4226 command line switch and then substitute the full path in place,
4227 otherwise generate an error message. */
4228 static int this_is_linker_script;
4230 /* Nonzero means that the input of this command is coming from a pipe. */
4231 static int input_from_pipe;
4233 /* Nonnull means substitute this for any suffix when outputting a switches
4234 arguments. */
4235 static const char *suffix_subst;
4237 /* If there is an argument being accumulated, terminate it and store it. */
4239 static void
4240 end_going_arg (void)
4242 if (arg_going)
4244 const char *string;
4246 obstack_1grow (&obstack, 0);
4247 string = XOBFINISH (&obstack, const char *);
4248 if (this_is_library_file)
4249 string = find_file (string);
4250 if (this_is_linker_script)
4252 char * full_script_path = find_a_file (&startfile_prefixes, string, R_OK, true);
4254 if (full_script_path == NULL)
4256 error ("unable to locate default linker script %qs in the library search paths", string);
4257 /* Script was not found on search path. */
4258 return;
4260 store_arg ("--script", false, false);
4261 string = full_script_path;
4263 store_arg (string, delete_this_arg, this_is_output_file);
4264 if (this_is_output_file)
4265 outfiles[input_file_number] = string;
4266 arg_going = 0;
4271 /* Parse the WRAPPER string which is a comma separated list of the command line
4272 and insert them into the beginning of argbuf. */
4274 static void
4275 insert_wrapper (const char *wrapper)
4277 int n = 0;
4278 int i;
4279 char *buf = xstrdup (wrapper);
4280 char *p = buf;
4281 unsigned int old_length = argbuf.length ();
4285 n++;
4286 while (*p == ',')
4287 p++;
4289 while ((p = strchr (p, ',')) != NULL);
4291 argbuf.safe_grow (old_length + n);
4292 memmove (argbuf.address () + n,
4293 argbuf.address (),
4294 old_length * sizeof (const_char_p));
4296 i = 0;
4297 p = buf;
4300 while (*p == ',')
4302 *p = 0;
4303 p++;
4305 argbuf[i] = p;
4306 i++;
4308 while ((p = strchr (p, ',')) != NULL);
4309 gcc_assert (i == n);
4312 /* Process the spec SPEC and run the commands specified therein.
4313 Returns 0 if the spec is successfully processed; -1 if failed. */
4316 do_spec (const char *spec)
4318 int value;
4320 value = do_spec_2 (spec);
4322 /* Force out any unfinished command.
4323 If -pipe, this forces out the last command if it ended in `|'. */
4324 if (value == 0)
4326 if (argbuf.length () > 0
4327 && !strcmp (argbuf.last (), "|"))
4328 argbuf.pop ();
4330 set_collect_gcc_options ();
4332 if (argbuf.length () > 0)
4333 value = execute ();
4336 return value;
4339 static int
4340 do_spec_2 (const char *spec)
4342 int result;
4344 clear_args ();
4345 arg_going = 0;
4346 delete_this_arg = 0;
4347 this_is_output_file = 0;
4348 this_is_library_file = 0;
4349 this_is_linker_script = 0;
4350 input_from_pipe = 0;
4351 suffix_subst = NULL;
4353 result = do_spec_1 (spec, 0, NULL);
4355 end_going_arg ();
4357 return result;
4361 /* Process the given spec string and add any new options to the end
4362 of the switches/n_switches array. */
4364 static void
4365 do_option_spec (const char *name, const char *spec)
4367 unsigned int i, value_count, value_len;
4368 const char *p, *q, *value;
4369 char *tmp_spec, *tmp_spec_p;
4371 if (configure_default_options[0].name == NULL)
4372 return;
4374 for (i = 0; i < ARRAY_SIZE (configure_default_options); i++)
4375 if (strcmp (configure_default_options[i].name, name) == 0)
4376 break;
4377 if (i == ARRAY_SIZE (configure_default_options))
4378 return;
4380 value = configure_default_options[i].value;
4381 value_len = strlen (value);
4383 /* Compute the size of the final spec. */
4384 value_count = 0;
4385 p = spec;
4386 while ((p = strstr (p, "%(VALUE)")) != NULL)
4388 p ++;
4389 value_count ++;
4392 /* Replace each %(VALUE) by the specified value. */
4393 tmp_spec = (char *) alloca (strlen (spec) + 1
4394 + value_count * (value_len - strlen ("%(VALUE)")));
4395 tmp_spec_p = tmp_spec;
4396 q = spec;
4397 while ((p = strstr (q, "%(VALUE)")) != NULL)
4399 memcpy (tmp_spec_p, q, p - q);
4400 tmp_spec_p = tmp_spec_p + (p - q);
4401 memcpy (tmp_spec_p, value, value_len);
4402 tmp_spec_p += value_len;
4403 q = p + strlen ("%(VALUE)");
4405 strcpy (tmp_spec_p, q);
4407 do_self_spec (tmp_spec);
4410 /* Process the given spec string and add any new options to the end
4411 of the switches/n_switches array. */
4413 static void
4414 do_self_spec (const char *spec)
4416 int i;
4418 do_spec_2 (spec);
4419 do_spec_1 (" ", 0, NULL);
4421 /* Mark %<S switches processed by do_self_spec to be ignored permanently.
4422 do_self_specs adds the replacements to switches array, so it shouldn't
4423 be processed afterwards. */
4424 for (i = 0; i < n_switches; i++)
4425 if ((switches[i].live_cond & SWITCH_IGNORE))
4426 switches[i].live_cond |= SWITCH_IGNORE_PERMANENTLY;
4428 if (argbuf.length () > 0)
4430 const char **argbuf_copy;
4431 struct cl_decoded_option *decoded_options;
4432 struct cl_option_handlers handlers;
4433 unsigned int decoded_options_count;
4434 unsigned int j;
4436 /* Create a copy of argbuf with a dummy argv[0] entry for
4437 decode_cmdline_options_to_array. */
4438 argbuf_copy = XNEWVEC (const char *,
4439 argbuf.length () + 1);
4440 argbuf_copy[0] = "";
4441 memcpy (argbuf_copy + 1, argbuf.address (),
4442 argbuf.length () * sizeof (const char *));
4444 decode_cmdline_options_to_array (argbuf.length () + 1,
4445 argbuf_copy,
4446 CL_DRIVER, &decoded_options,
4447 &decoded_options_count);
4448 free (argbuf_copy);
4450 set_option_handlers (&handlers);
4452 for (j = 1; j < decoded_options_count; j++)
4454 switch (decoded_options[j].opt_index)
4456 case OPT_SPECIAL_input_file:
4457 /* Specs should only generate options, not input
4458 files. */
4459 if (strcmp (decoded_options[j].arg, "-") != 0)
4460 fatal_error ("switch %qs does not start with %<-%>",
4461 decoded_options[j].arg);
4462 else
4463 fatal_error ("spec-generated switch is just %<-%>");
4464 break;
4466 case OPT_fcompare_debug_second:
4467 case OPT_fcompare_debug:
4468 case OPT_fcompare_debug_:
4469 case OPT_o:
4470 /* Avoid duplicate processing of some options from
4471 compare-debug specs; just save them here. */
4472 save_switch (decoded_options[j].canonical_option[0],
4473 (decoded_options[j].canonical_option_num_elements
4474 - 1),
4475 &decoded_options[j].canonical_option[1], false, true);
4476 break;
4478 default:
4479 read_cmdline_option (&global_options, &global_options_set,
4480 decoded_options + j, UNKNOWN_LOCATION,
4481 CL_DRIVER, &handlers, global_dc);
4482 break;
4486 alloc_switch ();
4487 switches[n_switches].part1 = 0;
4491 /* Callback for processing %D and %I specs. */
4493 struct spec_path_info {
4494 const char *option;
4495 const char *append;
4496 size_t append_len;
4497 bool omit_relative;
4498 bool separate_options;
4501 static void *
4502 spec_path (char *path, void *data)
4504 struct spec_path_info *info = (struct spec_path_info *) data;
4505 size_t len = 0;
4506 char save = 0;
4508 if (info->omit_relative && !IS_ABSOLUTE_PATH (path))
4509 return NULL;
4511 if (info->append_len != 0)
4513 len = strlen (path);
4514 memcpy (path + len, info->append, info->append_len + 1);
4517 if (!is_directory (path, true))
4518 return NULL;
4520 do_spec_1 (info->option, 1, NULL);
4521 if (info->separate_options)
4522 do_spec_1 (" ", 0, NULL);
4524 if (info->append_len == 0)
4526 len = strlen (path);
4527 save = path[len - 1];
4528 if (IS_DIR_SEPARATOR (path[len - 1]))
4529 path[len - 1] = '\0';
4532 do_spec_1 (path, 1, NULL);
4533 do_spec_1 (" ", 0, NULL);
4535 /* Must not damage the original path. */
4536 if (info->append_len == 0)
4537 path[len - 1] = save;
4539 return NULL;
4542 /* Create a temporary FILE with the contents of ARGV. Add @FILE to the
4543 argument list. */
4545 static void
4546 create_at_file (char **argv)
4548 char *temp_file = make_temp_file ("");
4549 char *at_argument = concat ("@", temp_file, NULL);
4550 FILE *f = fopen (temp_file, "w");
4551 int status;
4553 if (f == NULL)
4554 fatal_error ("could not open temporary response file %s",
4555 temp_file);
4557 status = writeargv (argv, f);
4559 if (status)
4560 fatal_error ("could not write to temporary response file %s",
4561 temp_file);
4563 status = fclose (f);
4565 if (EOF == status)
4566 fatal_error ("could not close temporary response file %s",
4567 temp_file);
4569 store_arg (at_argument, 0, 0);
4571 record_temp_file (temp_file, !save_temps_flag, !save_temps_flag);
4574 /* True if we should compile INFILE. */
4576 static bool
4577 compile_input_file_p (struct infile *infile)
4579 if ((!infile->language) || (infile->language[0] != '*'))
4580 if (infile->incompiler == input_file_compiler)
4581 return true;
4582 return false;
4585 /* Process each member of VEC as a spec. */
4587 static void
4588 do_specs_vec (vec<char_p> vec)
4590 unsigned ix;
4591 char *opt;
4593 FOR_EACH_VEC_ELT (vec, ix, opt)
4595 do_spec_1 (opt, 1, NULL);
4596 /* Make each accumulated option a separate argument. */
4597 do_spec_1 (" ", 0, NULL);
4601 /* Process the sub-spec SPEC as a portion of a larger spec.
4602 This is like processing a whole spec except that we do
4603 not initialize at the beginning and we do not supply a
4604 newline by default at the end.
4605 INSWITCH nonzero means don't process %-sequences in SPEC;
4606 in this case, % is treated as an ordinary character.
4607 This is used while substituting switches.
4608 INSWITCH nonzero also causes SPC not to terminate an argument.
4610 Value is zero unless a line was finished
4611 and the command on that line reported an error. */
4613 static int
4614 do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
4616 const char *p = spec;
4617 int c;
4618 int i;
4619 int value;
4621 /* If it's an empty string argument to a switch, keep it as is. */
4622 if (inswitch && !*p)
4623 arg_going = 1;
4625 while ((c = *p++))
4626 /* If substituting a switch, treat all chars like letters.
4627 Otherwise, NL, SPC, TAB and % are special. */
4628 switch (inswitch ? 'a' : c)
4630 case '\n':
4631 end_going_arg ();
4633 if (argbuf.length () > 0
4634 && !strcmp (argbuf.last (), "|"))
4636 /* A `|' before the newline means use a pipe here,
4637 but only if -pipe was specified.
4638 Otherwise, execute now and don't pass the `|' as an arg. */
4639 if (use_pipes)
4641 input_from_pipe = 1;
4642 break;
4644 else
4645 argbuf.pop ();
4648 set_collect_gcc_options ();
4650 if (argbuf.length () > 0)
4652 value = execute ();
4653 if (value)
4654 return value;
4656 /* Reinitialize for a new command, and for a new argument. */
4657 clear_args ();
4658 arg_going = 0;
4659 delete_this_arg = 0;
4660 this_is_output_file = 0;
4661 this_is_library_file = 0;
4662 this_is_linker_script = 0;
4663 input_from_pipe = 0;
4664 break;
4666 case '|':
4667 end_going_arg ();
4669 /* Use pipe */
4670 obstack_1grow (&obstack, c);
4671 arg_going = 1;
4672 break;
4674 case '\t':
4675 case ' ':
4676 end_going_arg ();
4678 /* Reinitialize for a new argument. */
4679 delete_this_arg = 0;
4680 this_is_output_file = 0;
4681 this_is_library_file = 0;
4682 this_is_linker_script = 0;
4683 break;
4685 case '%':
4686 switch (c = *p++)
4688 case 0:
4689 fatal_error ("spec %qs invalid", spec);
4691 case 'b':
4692 if (save_temps_length)
4693 obstack_grow (&obstack, save_temps_prefix, save_temps_length);
4694 else
4695 obstack_grow (&obstack, input_basename, basename_length);
4696 if (compare_debug < 0)
4697 obstack_grow (&obstack, ".gk", 3);
4698 arg_going = 1;
4699 break;
4701 case 'B':
4702 if (save_temps_length)
4703 obstack_grow (&obstack, save_temps_prefix, save_temps_length);
4704 else
4705 obstack_grow (&obstack, input_basename, suffixed_basename_length);
4706 if (compare_debug < 0)
4707 obstack_grow (&obstack, ".gk", 3);
4708 arg_going = 1;
4709 break;
4711 case 'd':
4712 delete_this_arg = 2;
4713 break;
4715 /* Dump out the directories specified with LIBRARY_PATH,
4716 followed by the absolute directories
4717 that we search for startfiles. */
4718 case 'D':
4720 struct spec_path_info info;
4722 info.option = "-L";
4723 info.append_len = 0;
4724 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
4725 /* Used on systems which record the specified -L dirs
4726 and use them to search for dynamic linking.
4727 Relative directories always come from -B,
4728 and it is better not to use them for searching
4729 at run time. In particular, stage1 loses. */
4730 info.omit_relative = true;
4731 #else
4732 info.omit_relative = false;
4733 #endif
4734 info.separate_options = false;
4736 for_each_path (&startfile_prefixes, true, 0, spec_path, &info);
4738 break;
4740 case 'e':
4741 /* %efoo means report an error with `foo' as error message
4742 and don't execute any more commands for this file. */
4744 const char *q = p;
4745 char *buf;
4746 while (*p != 0 && *p != '\n')
4747 p++;
4748 buf = (char *) alloca (p - q + 1);
4749 strncpy (buf, q, p - q);
4750 buf[p - q] = 0;
4751 error ("%s", _(buf));
4752 return -1;
4754 break;
4755 case 'n':
4756 /* %nfoo means report a notice with `foo' on stderr. */
4758 const char *q = p;
4759 char *buf;
4760 while (*p != 0 && *p != '\n')
4761 p++;
4762 buf = (char *) alloca (p - q + 1);
4763 strncpy (buf, q, p - q);
4764 buf[p - q] = 0;
4765 inform (0, "%s", _(buf));
4766 if (*p)
4767 p++;
4769 break;
4771 case 'j':
4773 struct stat st;
4775 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
4776 defined, and it is not a directory, and it is
4777 writable, use it. Otherwise, treat this like any
4778 other temporary file. */
4780 if ((!save_temps_flag)
4781 && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode))
4782 && (access (HOST_BIT_BUCKET, W_OK) == 0))
4784 obstack_grow (&obstack, HOST_BIT_BUCKET,
4785 strlen (HOST_BIT_BUCKET));
4786 delete_this_arg = 0;
4787 arg_going = 1;
4788 break;
4791 goto create_temp_file;
4792 case '|':
4793 if (use_pipes)
4795 obstack_1grow (&obstack, '-');
4796 delete_this_arg = 0;
4797 arg_going = 1;
4799 /* consume suffix */
4800 while (*p == '.' || ISALNUM ((unsigned char) *p))
4801 p++;
4802 if (p[0] == '%' && p[1] == 'O')
4803 p += 2;
4805 break;
4807 goto create_temp_file;
4808 case 'm':
4809 if (use_pipes)
4811 /* consume suffix */
4812 while (*p == '.' || ISALNUM ((unsigned char) *p))
4813 p++;
4814 if (p[0] == '%' && p[1] == 'O')
4815 p += 2;
4817 break;
4819 goto create_temp_file;
4820 case 'g':
4821 case 'u':
4822 case 'U':
4823 create_temp_file:
4825 struct temp_name *t;
4826 int suffix_length;
4827 const char *suffix = p;
4828 char *saved_suffix = NULL;
4830 while (*p == '.' || ISALNUM ((unsigned char) *p))
4831 p++;
4832 suffix_length = p - suffix;
4833 if (p[0] == '%' && p[1] == 'O')
4835 p += 2;
4836 /* We don't support extra suffix characters after %O. */
4837 if (*p == '.' || ISALNUM ((unsigned char) *p))
4838 fatal_error ("spec %qs has invalid %<%%0%c%>", spec, *p);
4839 if (suffix_length == 0)
4840 suffix = TARGET_OBJECT_SUFFIX;
4841 else
4843 saved_suffix
4844 = XNEWVEC (char, suffix_length
4845 + strlen (TARGET_OBJECT_SUFFIX));
4846 strncpy (saved_suffix, suffix, suffix_length);
4847 strcpy (saved_suffix + suffix_length,
4848 TARGET_OBJECT_SUFFIX);
4850 suffix_length += strlen (TARGET_OBJECT_SUFFIX);
4853 if (compare_debug < 0)
4855 suffix = concat (".gk", suffix, NULL);
4856 suffix_length += 3;
4859 /* If -save-temps=obj and -o were specified, use that for the
4860 temp file. */
4861 if (save_temps_length)
4863 char *tmp;
4864 temp_filename_length
4865 = save_temps_length + suffix_length + 1;
4866 tmp = (char *) alloca (temp_filename_length);
4867 memcpy (tmp, save_temps_prefix, save_temps_length);
4868 memcpy (tmp + save_temps_length, suffix, suffix_length);
4869 tmp[save_temps_length + suffix_length] = '\0';
4870 temp_filename = save_string (tmp, save_temps_length
4871 + suffix_length);
4872 obstack_grow (&obstack, temp_filename,
4873 temp_filename_length);
4874 arg_going = 1;
4875 delete_this_arg = 0;
4876 break;
4879 /* If the gcc_input_filename has the same suffix specified
4880 for the %g, %u, or %U, and -save-temps is specified,
4881 we could end up using that file as an intermediate
4882 thus clobbering the user's source file (.e.g.,
4883 gcc -save-temps foo.s would clobber foo.s with the
4884 output of cpp0). So check for this condition and
4885 generate a temp file as the intermediate. */
4887 if (save_temps_flag)
4889 char *tmp;
4890 temp_filename_length = basename_length + suffix_length + 1;
4891 tmp = (char *) alloca (temp_filename_length);
4892 memcpy (tmp, input_basename, basename_length);
4893 memcpy (tmp + basename_length, suffix, suffix_length);
4894 tmp[basename_length + suffix_length] = '\0';
4895 temp_filename = tmp;
4897 if (filename_cmp (temp_filename, gcc_input_filename) != 0)
4899 #ifndef HOST_LACKS_INODE_NUMBERS
4900 struct stat st_temp;
4902 /* Note, set_input() resets input_stat_set to 0. */
4903 if (input_stat_set == 0)
4905 input_stat_set = stat (gcc_input_filename,
4906 &input_stat);
4907 if (input_stat_set >= 0)
4908 input_stat_set = 1;
4911 /* If we have the stat for the gcc_input_filename
4912 and we can do the stat for the temp_filename
4913 then the they could still refer to the same
4914 file if st_dev/st_ino's are the same. */
4915 if (input_stat_set != 1
4916 || stat (temp_filename, &st_temp) < 0
4917 || input_stat.st_dev != st_temp.st_dev
4918 || input_stat.st_ino != st_temp.st_ino)
4919 #else
4920 /* Just compare canonical pathnames. */
4921 char* input_realname = lrealpath (gcc_input_filename);
4922 char* temp_realname = lrealpath (temp_filename);
4923 bool files_differ = filename_cmp (input_realname, temp_realname);
4924 free (input_realname);
4925 free (temp_realname);
4926 if (files_differ)
4927 #endif
4929 temp_filename = save_string (temp_filename,
4930 temp_filename_length + 1);
4931 obstack_grow (&obstack, temp_filename,
4932 temp_filename_length);
4933 arg_going = 1;
4934 delete_this_arg = 0;
4935 break;
4940 /* See if we already have an association of %g/%u/%U and
4941 suffix. */
4942 for (t = temp_names; t; t = t->next)
4943 if (t->length == suffix_length
4944 && strncmp (t->suffix, suffix, suffix_length) == 0
4945 && t->unique == (c == 'u' || c == 'U' || c == 'j'))
4946 break;
4948 /* Make a new association if needed. %u and %j
4949 require one. */
4950 if (t == 0 || c == 'u' || c == 'j')
4952 if (t == 0)
4954 t = XNEW (struct temp_name);
4955 t->next = temp_names;
4956 temp_names = t;
4958 t->length = suffix_length;
4959 if (saved_suffix)
4961 t->suffix = saved_suffix;
4962 saved_suffix = NULL;
4964 else
4965 t->suffix = save_string (suffix, suffix_length);
4966 t->unique = (c == 'u' || c == 'U' || c == 'j');
4967 temp_filename = make_temp_file (t->suffix);
4968 temp_filename_length = strlen (temp_filename);
4969 t->filename = temp_filename;
4970 t->filename_length = temp_filename_length;
4973 free (saved_suffix);
4975 obstack_grow (&obstack, t->filename, t->filename_length);
4976 delete_this_arg = 1;
4978 arg_going = 1;
4979 break;
4981 case 'i':
4982 if (combine_inputs)
4984 if (at_file_supplied)
4986 /* We are going to expand `%i' to `@FILE', where FILE
4987 is a newly-created temporary filename. The filenames
4988 that would usually be expanded in place of %o will be
4989 written to the temporary file. */
4990 char **argv;
4991 int n_files = 0;
4992 int j;
4994 for (i = 0; i < n_infiles; i++)
4995 if (compile_input_file_p (&infiles[i]))
4996 n_files++;
4998 argv = (char **) alloca (sizeof (char *) * (n_files + 1));
5000 /* Copy the strings over. */
5001 for (i = 0, j = 0; i < n_infiles; i++)
5002 if (compile_input_file_p (&infiles[i]))
5004 argv[j] = CONST_CAST (char *, infiles[i].name);
5005 infiles[i].compiled = true;
5006 j++;
5008 argv[j] = NULL;
5010 create_at_file (argv);
5012 else
5013 for (i = 0; (int) i < n_infiles; i++)
5014 if (compile_input_file_p (&infiles[i]))
5016 store_arg (infiles[i].name, 0, 0);
5017 infiles[i].compiled = true;
5020 else
5022 obstack_grow (&obstack, gcc_input_filename,
5023 input_filename_length);
5024 arg_going = 1;
5026 break;
5028 case 'I':
5030 struct spec_path_info info;
5032 if (multilib_dir)
5034 do_spec_1 ("-imultilib", 1, NULL);
5035 /* Make this a separate argument. */
5036 do_spec_1 (" ", 0, NULL);
5037 do_spec_1 (multilib_dir, 1, NULL);
5038 do_spec_1 (" ", 0, NULL);
5041 if (multiarch_dir)
5043 do_spec_1 ("-imultiarch", 1, NULL);
5044 /* Make this a separate argument. */
5045 do_spec_1 (" ", 0, NULL);
5046 do_spec_1 (multiarch_dir, 1, NULL);
5047 do_spec_1 (" ", 0, NULL);
5050 if (gcc_exec_prefix)
5052 do_spec_1 ("-iprefix", 1, NULL);
5053 /* Make this a separate argument. */
5054 do_spec_1 (" ", 0, NULL);
5055 do_spec_1 (gcc_exec_prefix, 1, NULL);
5056 do_spec_1 (" ", 0, NULL);
5059 if (target_system_root_changed ||
5060 (target_system_root && target_sysroot_hdrs_suffix))
5062 do_spec_1 ("-isysroot", 1, NULL);
5063 /* Make this a separate argument. */
5064 do_spec_1 (" ", 0, NULL);
5065 do_spec_1 (target_system_root, 1, NULL);
5066 if (target_sysroot_hdrs_suffix)
5067 do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL);
5068 do_spec_1 (" ", 0, NULL);
5071 info.option = "-isystem";
5072 info.append = "include";
5073 info.append_len = strlen (info.append);
5074 info.omit_relative = false;
5075 info.separate_options = true;
5077 for_each_path (&include_prefixes, false, info.append_len,
5078 spec_path, &info);
5080 info.append = "include-fixed";
5081 if (*sysroot_hdrs_suffix_spec)
5082 info.append = concat (info.append, dir_separator_str,
5083 multilib_dir, NULL);
5084 info.append_len = strlen (info.append);
5085 for_each_path (&include_prefixes, false, info.append_len,
5086 spec_path, &info);
5088 break;
5090 case 'o':
5092 int max = n_infiles;
5093 max += lang_specific_extra_outfiles;
5095 if (HAVE_GNU_LD && at_file_supplied)
5097 /* We are going to expand `%o' to `@FILE', where FILE
5098 is a newly-created temporary filename. The filenames
5099 that would usually be expanded in place of %o will be
5100 written to the temporary file. */
5102 char **argv;
5103 int n_files, j;
5105 /* Convert OUTFILES into a form suitable for writeargv. */
5107 /* Determine how many are non-NULL. */
5108 for (n_files = 0, i = 0; i < max; i++)
5109 n_files += outfiles[i] != NULL;
5111 argv = (char **) alloca (sizeof (char *) * (n_files + 1));
5113 /* Copy the strings over. */
5114 for (i = 0, j = 0; i < max; i++)
5115 if (outfiles[i])
5117 argv[j] = CONST_CAST (char *, outfiles[i]);
5118 j++;
5120 argv[j] = NULL;
5122 create_at_file (argv);
5124 else
5125 for (i = 0; i < max; i++)
5126 if (outfiles[i])
5127 store_arg (outfiles[i], 0, 0);
5128 break;
5131 case 'O':
5132 obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
5133 arg_going = 1;
5134 break;
5136 case 's':
5137 this_is_library_file = 1;
5138 break;
5140 case 'T':
5141 this_is_linker_script = 1;
5142 break;
5144 case 'V':
5145 outfiles[input_file_number] = NULL;
5146 break;
5148 case 'w':
5149 this_is_output_file = 1;
5150 break;
5152 case 'W':
5154 unsigned int cur_index = argbuf.length ();
5155 /* Handle the {...} following the %W. */
5156 if (*p != '{')
5157 fatal_error ("spec %qs has invalid %<%%W%c%>", spec, *p);
5158 p = handle_braces (p + 1);
5159 if (p == 0)
5160 return -1;
5161 end_going_arg ();
5162 /* If any args were output, mark the last one for deletion
5163 on failure. */
5164 if (argbuf.length () != cur_index)
5165 record_temp_file (argbuf.last (), 0, 1);
5166 break;
5169 /* %x{OPTION} records OPTION for %X to output. */
5170 case 'x':
5172 const char *p1 = p;
5173 char *string;
5174 char *opt;
5175 unsigned ix;
5177 /* Skip past the option value and make a copy. */
5178 if (*p != '{')
5179 fatal_error ("spec %qs has invalid %<%%x%c%>", spec, *p);
5180 while (*p++ != '}')
5182 string = save_string (p1 + 1, p - p1 - 2);
5184 /* See if we already recorded this option. */
5185 FOR_EACH_VEC_ELT (linker_options, ix, opt)
5186 if (! strcmp (string, opt))
5188 free (string);
5189 return 0;
5192 /* This option is new; add it. */
5193 add_linker_option (string, strlen (string));
5194 free (string);
5196 break;
5198 /* Dump out the options accumulated previously using %x. */
5199 case 'X':
5200 do_specs_vec (linker_options);
5201 break;
5203 /* Dump out the options accumulated previously using -Wa,. */
5204 case 'Y':
5205 do_specs_vec (assembler_options);
5206 break;
5208 /* Dump out the options accumulated previously using -Wp,. */
5209 case 'Z':
5210 do_specs_vec (preprocessor_options);
5211 break;
5213 /* Here are digits and numbers that just process
5214 a certain constant string as a spec. */
5216 case '1':
5217 value = do_spec_1 (cc1_spec, 0, NULL);
5218 if (value != 0)
5219 return value;
5220 break;
5222 case '2':
5223 value = do_spec_1 (cc1plus_spec, 0, NULL);
5224 if (value != 0)
5225 return value;
5226 break;
5228 case 'a':
5229 value = do_spec_1 (asm_spec, 0, NULL);
5230 if (value != 0)
5231 return value;
5232 break;
5234 case 'A':
5235 value = do_spec_1 (asm_final_spec, 0, NULL);
5236 if (value != 0)
5237 return value;
5238 break;
5240 case 'C':
5242 const char *const spec
5243 = (input_file_compiler->cpp_spec
5244 ? input_file_compiler->cpp_spec
5245 : cpp_spec);
5246 value = do_spec_1 (spec, 0, NULL);
5247 if (value != 0)
5248 return value;
5250 break;
5252 case 'E':
5253 value = do_spec_1 (endfile_spec, 0, NULL);
5254 if (value != 0)
5255 return value;
5256 break;
5258 case 'l':
5259 value = do_spec_1 (link_spec, 0, NULL);
5260 if (value != 0)
5261 return value;
5262 break;
5264 case 'L':
5265 value = do_spec_1 (lib_spec, 0, NULL);
5266 if (value != 0)
5267 return value;
5268 break;
5270 case 'M':
5271 if (multilib_os_dir == NULL)
5272 obstack_1grow (&obstack, '.');
5273 else
5274 obstack_grow (&obstack, multilib_os_dir,
5275 strlen (multilib_os_dir));
5276 break;
5278 case 'G':
5279 value = do_spec_1 (libgcc_spec, 0, NULL);
5280 if (value != 0)
5281 return value;
5282 break;
5284 case 'R':
5285 /* We assume there is a directory
5286 separator at the end of this string. */
5287 if (target_system_root)
5289 obstack_grow (&obstack, target_system_root,
5290 strlen (target_system_root));
5291 if (target_sysroot_suffix)
5292 obstack_grow (&obstack, target_sysroot_suffix,
5293 strlen (target_sysroot_suffix));
5295 break;
5297 case 'S':
5298 value = do_spec_1 (startfile_spec, 0, NULL);
5299 if (value != 0)
5300 return value;
5301 break;
5303 /* Here we define characters other than letters and digits. */
5305 case '{':
5306 p = handle_braces (p);
5307 if (p == 0)
5308 return -1;
5309 break;
5311 case ':':
5312 p = handle_spec_function (p, NULL);
5313 if (p == 0)
5314 return -1;
5315 break;
5317 case '%':
5318 obstack_1grow (&obstack, '%');
5319 break;
5321 case '.':
5323 unsigned len = 0;
5325 while (p[len] && p[len] != ' ' && p[len] != '%')
5326 len++;
5327 suffix_subst = save_string (p - 1, len + 1);
5328 p += len;
5330 break;
5332 /* Henceforth ignore the option(s) matching the pattern
5333 after the %<. */
5334 case '<':
5335 case '>':
5337 unsigned len = 0;
5338 int have_wildcard = 0;
5339 int i;
5340 int switch_option;
5342 if (c == '>')
5343 switch_option = SWITCH_IGNORE | SWITCH_KEEP_FOR_GCC;
5344 else
5345 switch_option = SWITCH_IGNORE;
5347 while (p[len] && p[len] != ' ' && p[len] != '\t')
5348 len++;
5350 if (p[len-1] == '*')
5351 have_wildcard = 1;
5353 for (i = 0; i < n_switches; i++)
5354 if (!strncmp (switches[i].part1, p, len - have_wildcard)
5355 && (have_wildcard || switches[i].part1[len] == '\0'))
5357 switches[i].live_cond |= switch_option;
5358 /* User switch be validated from validate_all_switches.
5359 when the definition is seen from the spec file.
5360 If not defined anywhere, will be rejected. */
5361 if (switches[i].known)
5362 switches[i].validated = true;
5365 p += len;
5367 break;
5369 case '*':
5370 if (soft_matched_part)
5372 if (soft_matched_part[0])
5373 do_spec_1 (soft_matched_part, 1, NULL);
5374 /* Only insert a space after the substitution if it is at the
5375 end of the current sequence. So if:
5377 "%{foo=*:bar%*}%{foo=*:one%*two}"
5379 matches -foo=hello then it will produce:
5381 barhello onehellotwo
5383 if (*p == 0 || *p == '}')
5384 do_spec_1 (" ", 0, NULL);
5386 else
5387 /* Catch the case where a spec string contains something like
5388 '%{foo:%*}'. i.e. there is no * in the pattern on the left
5389 hand side of the :. */
5390 error ("spec failure: %<%%*%> has not been initialized by pattern match");
5391 break;
5393 /* Process a string found as the value of a spec given by name.
5394 This feature allows individual machine descriptions
5395 to add and use their own specs. */
5396 case '(':
5398 const char *name = p;
5399 struct spec_list *sl;
5400 int len;
5402 /* The string after the S/P is the name of a spec that is to be
5403 processed. */
5404 while (*p && *p != ')')
5405 p++;
5407 /* See if it's in the list. */
5408 for (len = p - name, sl = specs; sl; sl = sl->next)
5409 if (sl->name_len == len && !strncmp (sl->name, name, len))
5411 name = *(sl->ptr_spec);
5412 #ifdef DEBUG_SPECS
5413 fnotice (stderr, "Processing spec (%s), which is '%s'\n",
5414 sl->name, name);
5415 #endif
5416 break;
5419 if (sl)
5421 value = do_spec_1 (name, 0, NULL);
5422 if (value != 0)
5423 return value;
5426 /* Discard the closing paren. */
5427 if (*p)
5428 p++;
5430 break;
5432 default:
5433 error ("spec failure: unrecognized spec option %qc", c);
5434 break;
5436 break;
5438 case '\\':
5439 /* Backslash: treat next character as ordinary. */
5440 c = *p++;
5442 /* Fall through. */
5443 default:
5444 /* Ordinary character: put it into the current argument. */
5445 obstack_1grow (&obstack, c);
5446 arg_going = 1;
5449 /* End of string. If we are processing a spec function, we need to
5450 end any pending argument. */
5451 if (processing_spec_function)
5452 end_going_arg ();
5454 return 0;
5457 /* Look up a spec function. */
5459 static const struct spec_function *
5460 lookup_spec_function (const char *name)
5462 const struct spec_function *sf;
5464 for (sf = static_spec_functions; sf->name != NULL; sf++)
5465 if (strcmp (sf->name, name) == 0)
5466 return sf;
5468 return NULL;
5471 /* Evaluate a spec function. */
5473 static const char *
5474 eval_spec_function (const char *func, const char *args)
5476 const struct spec_function *sf;
5477 const char *funcval;
5479 /* Saved spec processing context. */
5480 vec<const_char_p> save_argbuf;
5482 int save_arg_going;
5483 int save_delete_this_arg;
5484 int save_this_is_output_file;
5485 int save_this_is_library_file;
5486 int save_input_from_pipe;
5487 int save_this_is_linker_script;
5488 const char *save_suffix_subst;
5490 int save_growing_size;
5491 void *save_growing_value = NULL;
5493 sf = lookup_spec_function (func);
5494 if (sf == NULL)
5495 fatal_error ("unknown spec function %qs", func);
5497 /* Push the spec processing context. */
5498 save_argbuf = argbuf;
5500 save_arg_going = arg_going;
5501 save_delete_this_arg = delete_this_arg;
5502 save_this_is_output_file = this_is_output_file;
5503 save_this_is_library_file = this_is_library_file;
5504 save_this_is_linker_script = this_is_linker_script;
5505 save_input_from_pipe = input_from_pipe;
5506 save_suffix_subst = suffix_subst;
5508 /* If we have some object growing now, finalize it so the args and function
5509 eval proceed from a cleared context. This is needed to prevent the first
5510 constructed arg from mistakenly including the growing value. We'll push
5511 this value back on the obstack once the function evaluation is done, to
5512 restore a consistent processing context for our caller. This is fine as
5513 the address of growing objects isn't guaranteed to remain stable until
5514 they are finalized, and we expect this situation to be rare enough for
5515 the extra copy not to be an issue. */
5516 save_growing_size = obstack_object_size (&obstack);
5517 if (save_growing_size > 0)
5518 save_growing_value = obstack_finish (&obstack);
5520 /* Create a new spec processing context, and build the function
5521 arguments. */
5523 alloc_args ();
5524 if (do_spec_2 (args) < 0)
5525 fatal_error ("error in args to spec function %qs", func);
5527 /* argbuf_index is an index for the next argument to be inserted, and
5528 so contains the count of the args already inserted. */
5530 funcval = (*sf->func) (argbuf.length (),
5531 argbuf.address ());
5533 /* Pop the spec processing context. */
5534 argbuf.release ();
5535 argbuf = save_argbuf;
5537 arg_going = save_arg_going;
5538 delete_this_arg = save_delete_this_arg;
5539 this_is_output_file = save_this_is_output_file;
5540 this_is_library_file = save_this_is_library_file;
5541 this_is_linker_script = save_this_is_linker_script;
5542 input_from_pipe = save_input_from_pipe;
5543 suffix_subst = save_suffix_subst;
5545 if (save_growing_size > 0)
5546 obstack_grow (&obstack, save_growing_value, save_growing_size);
5548 return funcval;
5551 /* Handle a spec function call of the form:
5553 %:function(args)
5555 ARGS is processed as a spec in a separate context and split into an
5556 argument vector in the normal fashion. The function returns a string
5557 containing a spec which we then process in the caller's context, or
5558 NULL if no processing is required.
5560 If RETVAL_NONNULL is not NULL, then store a bool whether function
5561 returned non-NULL. */
5563 static const char *
5564 handle_spec_function (const char *p, bool *retval_nonnull)
5566 char *func, *args;
5567 const char *endp, *funcval;
5568 int count;
5570 processing_spec_function++;
5572 /* Get the function name. */
5573 for (endp = p; *endp != '\0'; endp++)
5575 if (*endp == '(') /* ) */
5576 break;
5577 /* Only allow [A-Za-z0-9], -, and _ in function names. */
5578 if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_'))
5579 fatal_error ("malformed spec function name");
5581 if (*endp != '(') /* ) */
5582 fatal_error ("no arguments for spec function");
5583 func = save_string (p, endp - p);
5584 p = ++endp;
5586 /* Get the arguments. */
5587 for (count = 0; *endp != '\0'; endp++)
5589 /* ( */
5590 if (*endp == ')')
5592 if (count == 0)
5593 break;
5594 count--;
5596 else if (*endp == '(') /* ) */
5597 count++;
5599 /* ( */
5600 if (*endp != ')')
5601 fatal_error ("malformed spec function arguments");
5602 args = save_string (p, endp - p);
5603 p = ++endp;
5605 /* p now points to just past the end of the spec function expression. */
5607 funcval = eval_spec_function (func, args);
5608 if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0)
5609 p = NULL;
5610 if (retval_nonnull)
5611 *retval_nonnull = funcval != NULL;
5613 free (func);
5614 free (args);
5616 processing_spec_function--;
5618 return p;
5621 /* Inline subroutine of handle_braces. Returns true if the current
5622 input suffix matches the atom bracketed by ATOM and END_ATOM. */
5623 static inline bool
5624 input_suffix_matches (const char *atom, const char *end_atom)
5626 return (input_suffix
5627 && !strncmp (input_suffix, atom, end_atom - atom)
5628 && input_suffix[end_atom - atom] == '\0');
5631 /* Subroutine of handle_braces. Returns true if the current
5632 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
5633 static bool
5634 input_spec_matches (const char *atom, const char *end_atom)
5636 return (input_file_compiler
5637 && input_file_compiler->suffix
5638 && input_file_compiler->suffix[0] != '\0'
5639 && !strncmp (input_file_compiler->suffix + 1, atom,
5640 end_atom - atom)
5641 && input_file_compiler->suffix[end_atom - atom + 1] == '\0');
5644 /* Subroutine of handle_braces. Returns true if a switch
5645 matching the atom bracketed by ATOM and END_ATOM appeared on the
5646 command line. */
5647 static bool
5648 switch_matches (const char *atom, const char *end_atom, int starred)
5650 int i;
5651 int len = end_atom - atom;
5652 int plen = starred ? len : -1;
5654 for (i = 0; i < n_switches; i++)
5655 if (!strncmp (switches[i].part1, atom, len)
5656 && (starred || switches[i].part1[len] == '\0')
5657 && check_live_switch (i, plen))
5658 return true;
5660 /* Check if a switch with separated form matching the atom.
5661 We check -D and -U switches. */
5662 else if (switches[i].args != 0)
5664 if ((*switches[i].part1 == 'D' || *switches[i].part1 == 'U')
5665 && *switches[i].part1 == atom[0])
5667 if (!strncmp (switches[i].args[0], &atom[1], len - 1)
5668 && (starred || (switches[i].part1[1] == '\0'
5669 && switches[i].args[0][len - 1] == '\0'))
5670 && check_live_switch (i, (starred ? 1 : -1)))
5671 return true;
5675 return false;
5678 /* Inline subroutine of handle_braces. Mark all of the switches which
5679 match ATOM (extends to END_ATOM; STARRED indicates whether there
5680 was a star after the atom) for later processing. */
5681 static inline void
5682 mark_matching_switches (const char *atom, const char *end_atom, int starred)
5684 int i;
5685 int len = end_atom - atom;
5686 int plen = starred ? len : -1;
5688 for (i = 0; i < n_switches; i++)
5689 if (!strncmp (switches[i].part1, atom, len)
5690 && (starred || switches[i].part1[len] == '\0')
5691 && check_live_switch (i, plen))
5692 switches[i].ordering = 1;
5695 /* Inline subroutine of handle_braces. Process all the currently
5696 marked switches through give_switch, and clear the marks. */
5697 static inline void
5698 process_marked_switches (void)
5700 int i;
5702 for (i = 0; i < n_switches; i++)
5703 if (switches[i].ordering == 1)
5705 switches[i].ordering = 0;
5706 give_switch (i, 0);
5710 /* Handle a %{ ... } construct. P points just inside the leading {.
5711 Returns a pointer one past the end of the brace block, or 0
5712 if we call do_spec_1 and that returns -1. */
5714 static const char *
5715 handle_braces (const char *p)
5717 const char *atom, *end_atom;
5718 const char *d_atom = NULL, *d_end_atom = NULL;
5719 const char *orig = p;
5721 bool a_is_suffix;
5722 bool a_is_spectype;
5723 bool a_is_starred;
5724 bool a_is_negated;
5725 bool a_matched;
5727 bool a_must_be_last = false;
5728 bool ordered_set = false;
5729 bool disjunct_set = false;
5730 bool disj_matched = false;
5731 bool disj_starred = true;
5732 bool n_way_choice = false;
5733 bool n_way_matched = false;
5735 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
5739 if (a_must_be_last)
5740 goto invalid;
5742 /* Scan one "atom" (S in the description above of %{}, possibly
5743 with '!', '.', '@', ',', or '*' modifiers). */
5744 a_matched = false;
5745 a_is_suffix = false;
5746 a_is_starred = false;
5747 a_is_negated = false;
5748 a_is_spectype = false;
5750 SKIP_WHITE ();
5751 if (*p == '!')
5752 p++, a_is_negated = true;
5754 SKIP_WHITE ();
5755 if (*p == '%' && p[1] == ':')
5757 atom = NULL;
5758 end_atom = NULL;
5759 p = handle_spec_function (p + 2, &a_matched);
5761 else
5763 if (*p == '.')
5764 p++, a_is_suffix = true;
5765 else if (*p == ',')
5766 p++, a_is_spectype = true;
5768 atom = p;
5769 while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
5770 || *p == ',' || *p == '.' || *p == '@')
5771 p++;
5772 end_atom = p;
5774 if (*p == '*')
5775 p++, a_is_starred = 1;
5778 SKIP_WHITE ();
5779 switch (*p)
5781 case '&': case '}':
5782 /* Substitute the switch(es) indicated by the current atom. */
5783 ordered_set = true;
5784 if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix
5785 || a_is_spectype || atom == end_atom)
5786 goto invalid;
5788 mark_matching_switches (atom, end_atom, a_is_starred);
5790 if (*p == '}')
5791 process_marked_switches ();
5792 break;
5794 case '|': case ':':
5795 /* Substitute some text if the current atom appears as a switch
5796 or suffix. */
5797 disjunct_set = true;
5798 if (ordered_set)
5799 goto invalid;
5801 if (atom && atom == end_atom)
5803 if (!n_way_choice || disj_matched || *p == '|'
5804 || a_is_negated || a_is_suffix || a_is_spectype
5805 || a_is_starred)
5806 goto invalid;
5808 /* An empty term may appear as the last choice of an
5809 N-way choice set; it means "otherwise". */
5810 a_must_be_last = true;
5811 disj_matched = !n_way_matched;
5812 disj_starred = false;
5814 else
5816 if ((a_is_suffix || a_is_spectype) && a_is_starred)
5817 goto invalid;
5819 if (!a_is_starred)
5820 disj_starred = false;
5822 /* Don't bother testing this atom if we already have a
5823 match. */
5824 if (!disj_matched && !n_way_matched)
5826 if (atom == NULL)
5827 /* a_matched is already set by handle_spec_function. */;
5828 else if (a_is_suffix)
5829 a_matched = input_suffix_matches (atom, end_atom);
5830 else if (a_is_spectype)
5831 a_matched = input_spec_matches (atom, end_atom);
5832 else
5833 a_matched = switch_matches (atom, end_atom, a_is_starred);
5835 if (a_matched != a_is_negated)
5837 disj_matched = true;
5838 d_atom = atom;
5839 d_end_atom = end_atom;
5844 if (*p == ':')
5846 /* Found the body, that is, the text to substitute if the
5847 current disjunction matches. */
5848 p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred,
5849 disj_matched && !n_way_matched);
5850 if (p == 0)
5851 return 0;
5853 /* If we have an N-way choice, reset state for the next
5854 disjunction. */
5855 if (*p == ';')
5857 n_way_choice = true;
5858 n_way_matched |= disj_matched;
5859 disj_matched = false;
5860 disj_starred = true;
5861 d_atom = d_end_atom = NULL;
5864 break;
5866 default:
5867 goto invalid;
5870 while (*p++ != '}');
5872 return p;
5874 invalid:
5875 fatal_error ("braced spec %qs is invalid at %qc", orig, *p);
5877 #undef SKIP_WHITE
5880 /* Subroutine of handle_braces. Scan and process a brace substitution body
5881 (X in the description of %{} syntax). P points one past the colon;
5882 ATOM and END_ATOM bracket the first atom which was found to be true
5883 (present) in the current disjunction; STARRED indicates whether all
5884 the atoms in the current disjunction were starred (for syntax validation);
5885 MATCHED indicates whether the disjunction matched or not, and therefore
5886 whether or not the body is to be processed through do_spec_1 or just
5887 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
5888 returns -1. */
5890 static const char *
5891 process_brace_body (const char *p, const char *atom, const char *end_atom,
5892 int starred, int matched)
5894 const char *body, *end_body;
5895 unsigned int nesting_level;
5896 bool have_subst = false;
5898 /* Locate the closing } or ;, honoring nested braces.
5899 Trim trailing whitespace. */
5900 body = p;
5901 nesting_level = 1;
5902 for (;;)
5904 if (*p == '{')
5905 nesting_level++;
5906 else if (*p == '}')
5908 if (!--nesting_level)
5909 break;
5911 else if (*p == ';' && nesting_level == 1)
5912 break;
5913 else if (*p == '%' && p[1] == '*' && nesting_level == 1)
5914 have_subst = true;
5915 else if (*p == '\0')
5916 goto invalid;
5917 p++;
5920 end_body = p;
5921 while (end_body[-1] == ' ' || end_body[-1] == '\t')
5922 end_body--;
5924 if (have_subst && !starred)
5925 goto invalid;
5927 if (matched)
5929 /* Copy the substitution body to permanent storage and execute it.
5930 If have_subst is false, this is a simple matter of running the
5931 body through do_spec_1... */
5932 char *string = save_string (body, end_body - body);
5933 if (!have_subst)
5935 if (do_spec_1 (string, 0, NULL) < 0)
5936 return 0;
5938 else
5940 /* ... but if have_subst is true, we have to process the
5941 body once for each matching switch, with %* set to the
5942 variant part of the switch. */
5943 unsigned int hard_match_len = end_atom - atom;
5944 int i;
5946 for (i = 0; i < n_switches; i++)
5947 if (!strncmp (switches[i].part1, atom, hard_match_len)
5948 && check_live_switch (i, hard_match_len))
5950 if (do_spec_1 (string, 0,
5951 &switches[i].part1[hard_match_len]) < 0)
5952 return 0;
5953 /* Pass any arguments this switch has. */
5954 give_switch (i, 1);
5955 suffix_subst = NULL;
5960 return p;
5962 invalid:
5963 fatal_error ("braced spec body %qs is invalid", body);
5966 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
5967 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
5968 spec, or -1 if either exact match or %* is used.
5970 A -O switch is obsoleted by a later -O switch. A -f, -g, -m, or -W switch
5971 whose value does not begin with "no-" is obsoleted by the same value
5972 with the "no-", similarly for a switch with the "no-" prefix. */
5974 static int
5975 check_live_switch (int switchnum, int prefix_length)
5977 const char *name = switches[switchnum].part1;
5978 int i;
5980 /* If we already processed this switch and determined if it was
5981 live or not, return our past determination. */
5982 if (switches[switchnum].live_cond != 0)
5983 return ((switches[switchnum].live_cond & SWITCH_LIVE) != 0
5984 && (switches[switchnum].live_cond & SWITCH_FALSE) == 0
5985 && (switches[switchnum].live_cond & SWITCH_IGNORE_PERMANENTLY)
5986 == 0);
5988 /* In the common case of {<at-most-one-letter>*}, a negating
5989 switch would always match, so ignore that case. We will just
5990 send the conflicting switches to the compiler phase. */
5991 if (prefix_length >= 0 && prefix_length <= 1)
5992 return 1;
5994 /* Now search for duplicate in a manner that depends on the name. */
5995 switch (*name)
5997 case 'O':
5998 for (i = switchnum + 1; i < n_switches; i++)
5999 if (switches[i].part1[0] == 'O')
6001 switches[switchnum].validated = true;
6002 switches[switchnum].live_cond = SWITCH_FALSE;
6003 return 0;
6005 break;
6007 case 'W': case 'f': case 'm': case 'g':
6008 if (! strncmp (name + 1, "no-", 3))
6010 /* We have Xno-YYY, search for XYYY. */
6011 for (i = switchnum + 1; i < n_switches; i++)
6012 if (switches[i].part1[0] == name[0]
6013 && ! strcmp (&switches[i].part1[1], &name[4]))
6015 /* --specs are validated with the validate_switches mechanism. */
6016 if (switches[switchnum].known)
6017 switches[switchnum].validated = true;
6018 switches[switchnum].live_cond = SWITCH_FALSE;
6019 return 0;
6022 else
6024 /* We have XYYY, search for Xno-YYY. */
6025 for (i = switchnum + 1; i < n_switches; i++)
6026 if (switches[i].part1[0] == name[0]
6027 && switches[i].part1[1] == 'n'
6028 && switches[i].part1[2] == 'o'
6029 && switches[i].part1[3] == '-'
6030 && !strcmp (&switches[i].part1[4], &name[1]))
6032 /* --specs are validated with the validate_switches mechanism. */
6033 if (switches[switchnum].known)
6034 switches[switchnum].validated = true;
6035 switches[switchnum].live_cond = SWITCH_FALSE;
6036 return 0;
6039 break;
6042 /* Otherwise the switch is live. */
6043 switches[switchnum].live_cond |= SWITCH_LIVE;
6044 return 1;
6047 /* Pass a switch to the current accumulating command
6048 in the same form that we received it.
6049 SWITCHNUM identifies the switch; it is an index into
6050 the vector of switches gcc received, which is `switches'.
6051 This cannot fail since it never finishes a command line.
6053 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
6055 static void
6056 give_switch (int switchnum, int omit_first_word)
6058 if ((switches[switchnum].live_cond & SWITCH_IGNORE) != 0)
6059 return;
6061 if (!omit_first_word)
6063 do_spec_1 ("-", 0, NULL);
6064 do_spec_1 (switches[switchnum].part1, 1, NULL);
6067 if (switches[switchnum].args != 0)
6069 const char **p;
6070 for (p = switches[switchnum].args; *p; p++)
6072 const char *arg = *p;
6074 do_spec_1 (" ", 0, NULL);
6075 if (suffix_subst)
6077 unsigned length = strlen (arg);
6078 int dot = 0;
6080 while (length-- && !IS_DIR_SEPARATOR (arg[length]))
6081 if (arg[length] == '.')
6083 (CONST_CAST (char *, arg))[length] = 0;
6084 dot = 1;
6085 break;
6087 do_spec_1 (arg, 1, NULL);
6088 if (dot)
6089 (CONST_CAST (char *, arg))[length] = '.';
6090 do_spec_1 (suffix_subst, 1, NULL);
6092 else
6093 do_spec_1 (arg, 1, NULL);
6097 do_spec_1 (" ", 0, NULL);
6098 switches[switchnum].validated = true;
6101 /* Search for a file named NAME trying various prefixes including the
6102 user's -B prefix and some standard ones.
6103 Return the absolute file name found. If nothing is found, return NAME. */
6105 static const char *
6106 find_file (const char *name)
6108 char *newname = find_a_file (&startfile_prefixes, name, R_OK, true);
6109 return newname ? newname : name;
6112 /* Determine whether a directory exists. If LINKER, return 0 for
6113 certain fixed names not needed by the linker. */
6115 static int
6116 is_directory (const char *path1, bool linker)
6118 int len1;
6119 char *path;
6120 char *cp;
6121 struct stat st;
6123 /* Ensure the string ends with "/.". The resulting path will be a
6124 directory even if the given path is a symbolic link. */
6125 len1 = strlen (path1);
6126 path = (char *) alloca (3 + len1);
6127 memcpy (path, path1, len1);
6128 cp = path + len1;
6129 if (!IS_DIR_SEPARATOR (cp[-1]))
6130 *cp++ = DIR_SEPARATOR;
6131 *cp++ = '.';
6132 *cp = '\0';
6134 /* Exclude directories that the linker is known to search. */
6135 if (linker
6136 && IS_DIR_SEPARATOR (path[0])
6137 && ((cp - path == 6
6138 && filename_ncmp (path + 1, "lib", 3) == 0)
6139 || (cp - path == 10
6140 && filename_ncmp (path + 1, "usr", 3) == 0
6141 && IS_DIR_SEPARATOR (path[4])
6142 && filename_ncmp (path + 5, "lib", 3) == 0)))
6143 return 0;
6145 return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
6148 /* Set up the various global variables to indicate that we're processing
6149 the input file named FILENAME. */
6151 void
6152 set_input (const char *filename)
6154 const char *p;
6156 gcc_input_filename = filename;
6157 input_filename_length = strlen (gcc_input_filename);
6158 input_basename = lbasename (gcc_input_filename);
6160 /* Find a suffix starting with the last period,
6161 and set basename_length to exclude that suffix. */
6162 basename_length = strlen (input_basename);
6163 suffixed_basename_length = basename_length;
6164 p = input_basename + basename_length;
6165 while (p != input_basename && *p != '.')
6166 --p;
6167 if (*p == '.' && p != input_basename)
6169 basename_length = p - input_basename;
6170 input_suffix = p + 1;
6172 else
6173 input_suffix = "";
6175 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
6176 we will need to do a stat on the gcc_input_filename. The
6177 INPUT_STAT_SET signals that the stat is needed. */
6178 input_stat_set = 0;
6181 /* On fatal signals, delete all the temporary files. */
6183 static void
6184 fatal_signal (int signum)
6186 signal (signum, SIG_DFL);
6187 delete_failure_queue ();
6188 delete_temp_files ();
6189 /* Get the same signal again, this time not handled,
6190 so its normal effect occurs. */
6191 kill (getpid (), signum);
6194 /* Compare the contents of the two files named CMPFILE[0] and
6195 CMPFILE[1]. Return zero if they're identical, nonzero
6196 otherwise. */
6198 static int
6199 compare_files (char *cmpfile[])
6201 int ret = 0;
6202 FILE *temp[2] = { NULL, NULL };
6203 int i;
6205 #if HAVE_MMAP_FILE
6207 size_t length[2];
6208 void *map[2] = { NULL, NULL };
6210 for (i = 0; i < 2; i++)
6212 struct stat st;
6214 if (stat (cmpfile[i], &st) < 0 || !S_ISREG (st.st_mode))
6216 error ("%s: could not determine length of compare-debug file %s",
6217 gcc_input_filename, cmpfile[i]);
6218 ret = 1;
6219 break;
6222 length[i] = st.st_size;
6225 if (!ret && length[0] != length[1])
6227 error ("%s: -fcompare-debug failure (length)", gcc_input_filename);
6228 ret = 1;
6231 if (!ret)
6232 for (i = 0; i < 2; i++)
6234 int fd = open (cmpfile[i], O_RDONLY);
6235 if (fd < 0)
6237 error ("%s: could not open compare-debug file %s",
6238 gcc_input_filename, cmpfile[i]);
6239 ret = 1;
6240 break;
6243 map[i] = mmap (NULL, length[i], PROT_READ, MAP_PRIVATE, fd, 0);
6244 close (fd);
6246 if (map[i] == (void *) MAP_FAILED)
6248 ret = -1;
6249 break;
6253 if (!ret)
6255 if (memcmp (map[0], map[1], length[0]) != 0)
6257 error ("%s: -fcompare-debug failure", gcc_input_filename);
6258 ret = 1;
6262 for (i = 0; i < 2; i++)
6263 if (map[i])
6264 munmap ((caddr_t) map[i], length[i]);
6266 if (ret >= 0)
6267 return ret;
6269 ret = 0;
6271 #endif
6273 for (i = 0; i < 2; i++)
6275 temp[i] = fopen (cmpfile[i], "r");
6276 if (!temp[i])
6278 error ("%s: could not open compare-debug file %s",
6279 gcc_input_filename, cmpfile[i]);
6280 ret = 1;
6281 break;
6285 if (!ret && temp[0] && temp[1])
6286 for (;;)
6288 int c0, c1;
6289 c0 = fgetc (temp[0]);
6290 c1 = fgetc (temp[1]);
6292 if (c0 != c1)
6294 error ("%s: -fcompare-debug failure",
6295 gcc_input_filename);
6296 ret = 1;
6297 break;
6300 if (c0 == EOF)
6301 break;
6304 for (i = 1; i >= 0; i--)
6306 if (temp[i])
6307 fclose (temp[i]);
6310 return ret;
6313 extern int main (int, char **);
6316 main (int argc, char **argv)
6318 size_t i;
6319 int value;
6320 int linker_was_run = 0;
6321 int lang_n_infiles = 0;
6322 int num_linker_inputs = 0;
6323 char *explicit_link_files;
6324 char *specs_file;
6325 char *lto_wrapper_file;
6326 const char *p;
6327 struct user_specs *uptr;
6328 char **old_argv = argv;
6329 struct cl_decoded_option *decoded_options;
6330 unsigned int decoded_options_count;
6332 p = argv[0] + strlen (argv[0]);
6333 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
6334 --p;
6335 progname = p;
6337 xmalloc_set_program_name (progname);
6339 expandargv (&argc, &argv);
6341 /* Determine if any expansions were made. */
6342 if (argv != old_argv)
6343 at_file_supplied = true;
6345 /* Register the language-independent parameters. */
6346 global_init_params ();
6347 finish_params ();
6349 init_options_struct (&global_options, &global_options_set);
6351 decode_cmdline_options_to_array (argc, CONST_CAST2 (const char **, char **,
6352 argv),
6353 CL_DRIVER,
6354 &decoded_options, &decoded_options_count);
6356 /* Unlock the stdio streams. */
6357 unlock_std_streams ();
6359 gcc_init_libintl ();
6361 diagnostic_initialize (global_dc, 0);
6363 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6364 /* Perform host dependent initialization when needed. */
6365 GCC_DRIVER_HOST_INITIALIZATION;
6366 #endif
6368 if (atexit (delete_temp_files) != 0)
6369 fatal_error ("atexit failed");
6371 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
6372 signal (SIGINT, fatal_signal);
6373 #ifdef SIGHUP
6374 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
6375 signal (SIGHUP, fatal_signal);
6376 #endif
6377 if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
6378 signal (SIGTERM, fatal_signal);
6379 #ifdef SIGPIPE
6380 if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
6381 signal (SIGPIPE, fatal_signal);
6382 #endif
6383 #ifdef SIGCHLD
6384 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6385 receive the signal. A different setting is inheritable */
6386 signal (SIGCHLD, SIG_DFL);
6387 #endif
6389 /* Parsing and gimplification sometimes need quite large stack.
6390 Increase stack size limits if possible. */
6391 stack_limit_increase (64 * 1024 * 1024);
6393 /* Allocate the argument vector. */
6394 alloc_args ();
6396 obstack_init (&obstack);
6398 /* Build multilib_select, et. al from the separate lines that make up each
6399 multilib selection. */
6401 const char *const *q = multilib_raw;
6402 int need_space;
6404 obstack_init (&multilib_obstack);
6405 while ((p = *q++) != (char *) 0)
6406 obstack_grow (&multilib_obstack, p, strlen (p));
6408 obstack_1grow (&multilib_obstack, 0);
6409 multilib_select = XOBFINISH (&multilib_obstack, const char *);
6411 q = multilib_matches_raw;
6412 while ((p = *q++) != (char *) 0)
6413 obstack_grow (&multilib_obstack, p, strlen (p));
6415 obstack_1grow (&multilib_obstack, 0);
6416 multilib_matches = XOBFINISH (&multilib_obstack, const char *);
6418 q = multilib_exclusions_raw;
6419 while ((p = *q++) != (char *) 0)
6420 obstack_grow (&multilib_obstack, p, strlen (p));
6422 obstack_1grow (&multilib_obstack, 0);
6423 multilib_exclusions = XOBFINISH (&multilib_obstack, const char *);
6425 q = multilib_reuse_raw;
6426 while ((p = *q++) != (char *) 0)
6427 obstack_grow (&multilib_obstack, p, strlen (p));
6429 obstack_1grow (&multilib_obstack, 0);
6430 multilib_reuse = XOBFINISH (&multilib_obstack, const char *);
6432 need_space = FALSE;
6433 for (i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++)
6435 if (need_space)
6436 obstack_1grow (&multilib_obstack, ' ');
6437 obstack_grow (&multilib_obstack,
6438 multilib_defaults_raw[i],
6439 strlen (multilib_defaults_raw[i]));
6440 need_space = TRUE;
6443 obstack_1grow (&multilib_obstack, 0);
6444 multilib_defaults = XOBFINISH (&multilib_obstack, const char *);
6447 #ifdef INIT_ENVIRONMENT
6448 /* Set up any other necessary machine specific environment variables. */
6449 xputenv (INIT_ENVIRONMENT);
6450 #endif
6452 /* Make a table of what switches there are (switches, n_switches).
6453 Make a table of specified input files (infiles, n_infiles).
6454 Decode switches that are handled locally. */
6456 process_command (decoded_options_count, decoded_options);
6458 /* Initialize the vector of specs to just the default.
6459 This means one element containing 0s, as a terminator. */
6461 compilers = XNEWVAR (struct compiler, sizeof default_compilers);
6462 memcpy (compilers, default_compilers, sizeof default_compilers);
6463 n_compilers = n_default_compilers;
6465 /* Read specs from a file if there is one. */
6467 machine_suffix = concat (spec_machine, dir_separator_str,
6468 spec_version, dir_separator_str, NULL);
6469 just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
6471 specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, true);
6472 /* Read the specs file unless it is a default one. */
6473 if (specs_file != 0 && strcmp (specs_file, "specs"))
6474 read_specs (specs_file, true, false);
6475 else
6476 init_spec ();
6478 /* We need to check standard_exec_prefix/just_machine_suffix/specs
6479 for any override of as, ld and libraries. */
6480 specs_file = (char *) alloca (strlen (standard_exec_prefix)
6481 + strlen (just_machine_suffix) + sizeof ("specs"));
6483 strcpy (specs_file, standard_exec_prefix);
6484 strcat (specs_file, just_machine_suffix);
6485 strcat (specs_file, "specs");
6486 if (access (specs_file, R_OK) == 0)
6487 read_specs (specs_file, true, false);
6489 /* Process any configure-time defaults specified for the command line
6490 options, via OPTION_DEFAULT_SPECS. */
6491 for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
6492 do_option_spec (option_default_specs[i].name,
6493 option_default_specs[i].spec);
6495 /* Process DRIVER_SELF_SPECS, adding any new options to the end
6496 of the command line. */
6498 for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++)
6499 do_self_spec (driver_self_specs[i]);
6501 /* If not cross-compiling, look for executables in the standard
6502 places. */
6503 if (*cross_compile == '0')
6505 if (*md_exec_prefix)
6507 add_prefix (&exec_prefixes, md_exec_prefix, "GCC",
6508 PREFIX_PRIORITY_LAST, 0, 0);
6512 /* Process sysroot_suffix_spec. */
6513 if (*sysroot_suffix_spec != 0
6514 && !no_sysroot_suffix
6515 && do_spec_2 (sysroot_suffix_spec) == 0)
6517 if (argbuf.length () > 1)
6518 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
6519 else if (argbuf.length () == 1)
6520 target_sysroot_suffix = xstrdup (argbuf.last ());
6523 #ifdef HAVE_LD_SYSROOT
6524 /* Pass the --sysroot option to the linker, if it supports that. If
6525 there is a sysroot_suffix_spec, it has already been processed by
6526 this point, so target_system_root really is the system root we
6527 should be using. */
6528 if (target_system_root)
6530 obstack_grow (&obstack, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
6531 obstack_grow0 (&obstack, link_spec, strlen (link_spec));
6532 set_spec ("link", XOBFINISH (&obstack, const char *), false);
6534 #endif
6536 /* Process sysroot_hdrs_suffix_spec. */
6537 if (*sysroot_hdrs_suffix_spec != 0
6538 && !no_sysroot_suffix
6539 && do_spec_2 (sysroot_hdrs_suffix_spec) == 0)
6541 if (argbuf.length () > 1)
6542 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
6543 else if (argbuf.length () == 1)
6544 target_sysroot_hdrs_suffix = xstrdup (argbuf.last ());
6547 /* Look for startfiles in the standard places. */
6548 if (*startfile_prefix_spec != 0
6549 && do_spec_2 (startfile_prefix_spec) == 0
6550 && do_spec_1 (" ", 0, NULL) == 0)
6552 const char *arg;
6553 int ndx;
6554 FOR_EACH_VEC_ELT (argbuf, ndx, arg)
6555 add_sysrooted_prefix (&startfile_prefixes, arg, "BINUTILS",
6556 PREFIX_PRIORITY_LAST, 0, 1);
6558 /* We should eventually get rid of all these and stick to
6559 startfile_prefix_spec exclusively. */
6560 else if (*cross_compile == '0' || target_system_root)
6562 if (*md_startfile_prefix)
6563 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix,
6564 "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6566 if (*md_startfile_prefix_1)
6567 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix_1,
6568 "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6570 /* If standard_startfile_prefix is relative, base it on
6571 standard_exec_prefix. This lets us move the installed tree
6572 as a unit. If GCC_EXEC_PREFIX is defined, base
6573 standard_startfile_prefix on that as well.
6575 If the prefix is relative, only search it for native compilers;
6576 otherwise we will search a directory containing host libraries. */
6577 if (IS_ABSOLUTE_PATH (standard_startfile_prefix))
6578 add_sysrooted_prefix (&startfile_prefixes,
6579 standard_startfile_prefix, "BINUTILS",
6580 PREFIX_PRIORITY_LAST, 0, 1);
6581 else if (*cross_compile == '0')
6583 add_prefix (&startfile_prefixes,
6584 concat (gcc_exec_prefix
6585 ? gcc_exec_prefix : standard_exec_prefix,
6586 machine_suffix,
6587 standard_startfile_prefix, NULL),
6588 NULL, PREFIX_PRIORITY_LAST, 0, 1);
6591 /* Sysrooted prefixes are relocated because target_system_root is
6592 also relocated by gcc_exec_prefix. */
6593 if (*standard_startfile_prefix_1)
6594 add_sysrooted_prefix (&startfile_prefixes,
6595 standard_startfile_prefix_1, "BINUTILS",
6596 PREFIX_PRIORITY_LAST, 0, 1);
6597 if (*standard_startfile_prefix_2)
6598 add_sysrooted_prefix (&startfile_prefixes,
6599 standard_startfile_prefix_2, "BINUTILS",
6600 PREFIX_PRIORITY_LAST, 0, 1);
6603 /* Process any user specified specs in the order given on the command
6604 line. */
6605 for (uptr = user_specs_head; uptr; uptr = uptr->next)
6607 char *filename = find_a_file (&startfile_prefixes, uptr->filename,
6608 R_OK, true);
6609 read_specs (filename ? filename : uptr->filename, false, true);
6612 /* Process any user self specs. */
6614 struct spec_list *sl;
6615 for (sl = specs; sl; sl = sl->next)
6616 if (sl->name_len == sizeof "self_spec" - 1
6617 && !strcmp (sl->name, "self_spec"))
6618 do_self_spec (*sl->ptr_spec);
6621 if (compare_debug)
6623 enum save_temps save;
6625 if (!compare_debug_second)
6627 n_switches_debug_check[1] = n_switches;
6628 n_switches_alloc_debug_check[1] = n_switches_alloc;
6629 switches_debug_check[1] = XDUPVEC (struct switchstr, switches,
6630 n_switches_alloc);
6632 do_self_spec ("%:compare-debug-self-opt()");
6633 n_switches_debug_check[0] = n_switches;
6634 n_switches_alloc_debug_check[0] = n_switches_alloc;
6635 switches_debug_check[0] = switches;
6637 n_switches = n_switches_debug_check[1];
6638 n_switches_alloc = n_switches_alloc_debug_check[1];
6639 switches = switches_debug_check[1];
6642 /* Avoid crash when computing %j in this early. */
6643 save = save_temps_flag;
6644 save_temps_flag = SAVE_TEMPS_NONE;
6646 compare_debug = -compare_debug;
6647 do_self_spec ("%:compare-debug-self-opt()");
6649 save_temps_flag = save;
6651 if (!compare_debug_second)
6653 n_switches_debug_check[1] = n_switches;
6654 n_switches_alloc_debug_check[1] = n_switches_alloc;
6655 switches_debug_check[1] = switches;
6656 compare_debug = -compare_debug;
6657 n_switches = n_switches_debug_check[0];
6658 n_switches_alloc = n_switches_debug_check[0];
6659 switches = switches_debug_check[0];
6664 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
6665 if (gcc_exec_prefix)
6666 gcc_exec_prefix = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
6667 spec_version, dir_separator_str, NULL);
6669 /* Now we have the specs.
6670 Set the `valid' bits for switches that match anything in any spec. */
6672 validate_all_switches ();
6674 /* Now that we have the switches and the specs, set
6675 the subdirectory based on the options. */
6676 set_multilib_dir ();
6678 /* Set up to remember the pathname of gcc and any options
6679 needed for collect. We use argv[0] instead of progname because
6680 we need the complete pathname. */
6681 obstack_init (&collect_obstack);
6682 obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
6683 obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1);
6684 xputenv (XOBFINISH (&collect_obstack, char *));
6686 /* Set up to remember the pathname of the lto wrapper. */
6688 if (have_c)
6689 lto_wrapper_file = NULL;
6690 else
6691 lto_wrapper_file = find_a_file (&exec_prefixes, "lto-wrapper",
6692 X_OK, false);
6693 if (lto_wrapper_file)
6695 lto_wrapper_file = convert_white_space (lto_wrapper_file);
6696 lto_wrapper_spec = lto_wrapper_file;
6697 obstack_init (&collect_obstack);
6698 obstack_grow (&collect_obstack, "COLLECT_LTO_WRAPPER=",
6699 sizeof ("COLLECT_LTO_WRAPPER=") - 1);
6700 obstack_grow (&collect_obstack, lto_wrapper_spec,
6701 strlen (lto_wrapper_spec) + 1);
6702 xputenv (XOBFINISH (&collect_obstack, char *));
6705 /* Reject switches that no pass was interested in. */
6707 for (i = 0; (int) i < n_switches; i++)
6708 if (! switches[i].validated)
6709 error ("unrecognized command line option %<-%s%>", switches[i].part1);
6711 /* Obey some of the options. */
6713 if (print_search_dirs)
6715 printf (_("install: %s%s\n"),
6716 gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
6717 gcc_exec_prefix ? "" : machine_suffix);
6718 printf (_("programs: %s\n"),
6719 build_search_list (&exec_prefixes, "", false, false));
6720 printf (_("libraries: %s\n"),
6721 build_search_list (&startfile_prefixes, "", false, true));
6722 return (0);
6725 if (print_file_name)
6727 printf ("%s\n", find_file (print_file_name));
6728 return (0);
6731 if (print_prog_name)
6733 if (use_ld != NULL && ! strcmp (print_prog_name, "ld"))
6735 /* Append USE_LD to to the default linker. */
6736 #ifdef DEFAULT_LINKER
6737 char *ld;
6738 # ifdef HAVE_HOST_EXECUTABLE_SUFFIX
6739 int len = (sizeof (DEFAULT_LINKER)
6740 - sizeof (HOST_EXECUTABLE_SUFFIX));
6741 ld = NULL;
6742 if (len > 0)
6744 char *default_linker = xstrdup (DEFAULT_LINKER);
6745 /* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains
6746 HOST_EXECUTABLE_SUFFIX. */
6747 if (! strcmp (&default_linker[len], HOST_EXECUTABLE_SUFFIX))
6749 default_linker[len] = '\0';
6750 ld = concat (default_linker, use_ld,
6751 HOST_EXECUTABLE_SUFFIX, NULL);
6754 if (ld == NULL)
6755 # endif
6756 ld = concat (DEFAULT_LINKER, use_ld, NULL);
6757 if (access (ld, X_OK) == 0)
6759 printf ("%s\n", ld);
6760 return (0);
6762 #endif
6763 print_prog_name = concat (print_prog_name, use_ld, NULL);
6765 char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK, 0);
6766 printf ("%s\n", (newname ? newname : print_prog_name));
6767 return (0);
6770 if (print_multi_lib)
6772 print_multilib_info ();
6773 return (0);
6776 if (print_multi_directory)
6778 if (multilib_dir == NULL)
6779 printf (".\n");
6780 else
6781 printf ("%s\n", multilib_dir);
6782 return (0);
6785 if (print_multiarch)
6787 if (multiarch_dir == NULL)
6788 printf ("\n");
6789 else
6790 printf ("%s\n", multiarch_dir);
6791 return (0);
6794 if (print_sysroot)
6796 if (target_system_root)
6798 if (target_sysroot_suffix)
6799 printf ("%s%s\n", target_system_root, target_sysroot_suffix);
6800 else
6801 printf ("%s\n", target_system_root);
6803 return (0);
6806 if (print_multi_os_directory)
6808 if (multilib_os_dir == NULL)
6809 printf (".\n");
6810 else
6811 printf ("%s\n", multilib_os_dir);
6812 return (0);
6815 if (print_sysroot_headers_suffix)
6817 if (*sysroot_hdrs_suffix_spec)
6819 printf("%s\n", (target_sysroot_hdrs_suffix
6820 ? target_sysroot_hdrs_suffix
6821 : ""));
6822 return (0);
6824 else
6825 /* The error status indicates that only one set of fixed
6826 headers should be built. */
6827 fatal_error ("not configured with sysroot headers suffix");
6830 if (print_help_list)
6832 display_help ();
6834 if (! verbose_flag)
6836 printf (_("\nFor bug reporting instructions, please see:\n"));
6837 printf ("%s.\n", bug_report_url);
6839 return (0);
6842 /* We do not exit here. Instead we have created a fake input file
6843 called 'help-dummy' which needs to be compiled, and we pass this
6844 on the various sub-processes, along with the --help switch.
6845 Ensure their output appears after ours. */
6846 fputc ('\n', stdout);
6847 fflush (stdout);
6850 if (print_version)
6852 printf (_("%s %s%s\n"), progname, pkgversion_string,
6853 version_string);
6854 printf ("Copyright %s 2014 Free Software Foundation, Inc.\n",
6855 _("(C)"));
6856 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
6857 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
6858 stdout);
6859 if (! verbose_flag)
6860 return 0;
6862 /* We do not exit here. We use the same mechanism of --help to print
6863 the version of the sub-processes. */
6864 fputc ('\n', stdout);
6865 fflush (stdout);
6868 if (verbose_flag)
6870 int n;
6871 const char *thrmod;
6873 fnotice (stderr, "Target: %s\n", spec_machine);
6874 fnotice (stderr, "Configured with: %s\n", configuration_arguments);
6876 #ifdef THREAD_MODEL_SPEC
6877 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
6878 but there's no point in doing all this processing just to get
6879 thread_model back. */
6880 obstack_init (&obstack);
6881 do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model);
6882 obstack_1grow (&obstack, '\0');
6883 thrmod = XOBFINISH (&obstack, const char *);
6884 #else
6885 thrmod = thread_model;
6886 #endif
6888 fnotice (stderr, "Thread model: %s\n", thrmod);
6890 /* compiler_version is truncated at the first space when initialized
6891 from version string, so truncate version_string at the first space
6892 before comparing. */
6893 for (n = 0; version_string[n]; n++)
6894 if (version_string[n] == ' ')
6895 break;
6897 if (! strncmp (version_string, compiler_version, n)
6898 && compiler_version[n] == 0)
6899 fnotice (stderr, "gcc version %s %s\n", version_string,
6900 pkgversion_string);
6901 else
6902 fnotice (stderr, "gcc driver version %s %sexecuting gcc version %s\n",
6903 version_string, pkgversion_string, compiler_version);
6905 if (n_infiles == 0)
6906 return (0);
6909 if (n_infiles == added_libraries)
6910 fatal_error ("no input files");
6912 if (seen_error ())
6913 goto out;
6915 /* Make a place to record the compiler output file names
6916 that correspond to the input files. */
6918 i = n_infiles;
6919 i += lang_specific_extra_outfiles;
6920 outfiles = XCNEWVEC (const char *, i);
6922 /* Record which files were specified explicitly as link input. */
6924 explicit_link_files = XCNEWVEC (char, n_infiles);
6926 combine_inputs = have_o || flag_wpa;
6928 for (i = 0; (int) i < n_infiles; i++)
6930 const char *name = infiles[i].name;
6931 struct compiler *compiler = lookup_compiler (name,
6932 strlen (name),
6933 infiles[i].language);
6935 if (compiler && !(compiler->combinable))
6936 combine_inputs = false;
6938 if (lang_n_infiles > 0 && compiler != input_file_compiler
6939 && infiles[i].language && infiles[i].language[0] != '*')
6940 infiles[i].incompiler = compiler;
6941 else if (compiler)
6943 lang_n_infiles++;
6944 input_file_compiler = compiler;
6945 infiles[i].incompiler = compiler;
6947 else
6949 /* Since there is no compiler for this input file, assume it is a
6950 linker file. */
6951 explicit_link_files[i] = 1;
6952 infiles[i].incompiler = NULL;
6954 infiles[i].compiled = false;
6955 infiles[i].preprocessed = false;
6958 if (!combine_inputs && have_c && have_o && lang_n_infiles > 1)
6959 fatal_error ("cannot specify -o with -c, -S or -E with multiple files");
6961 for (i = 0; (int) i < n_infiles; i++)
6963 int this_file_error = 0;
6965 /* Tell do_spec what to substitute for %i. */
6967 input_file_number = i;
6968 set_input (infiles[i].name);
6970 if (infiles[i].compiled)
6971 continue;
6973 /* Use the same thing in %o, unless cp->spec says otherwise. */
6975 outfiles[i] = gcc_input_filename;
6977 /* Figure out which compiler from the file's suffix. */
6979 input_file_compiler
6980 = lookup_compiler (infiles[i].name, input_filename_length,
6981 infiles[i].language);
6983 if (input_file_compiler)
6985 /* Ok, we found an applicable compiler. Run its spec. */
6987 if (input_file_compiler->spec[0] == '#')
6989 error ("%s: %s compiler not installed on this system",
6990 gcc_input_filename, &input_file_compiler->spec[1]);
6991 this_file_error = 1;
6993 else
6995 if (compare_debug)
6997 free (debug_check_temp_file[0]);
6998 debug_check_temp_file[0] = NULL;
7000 free (debug_check_temp_file[1]);
7001 debug_check_temp_file[1] = NULL;
7004 value = do_spec (input_file_compiler->spec);
7005 infiles[i].compiled = true;
7006 if (value < 0)
7007 this_file_error = 1;
7008 else if (compare_debug && debug_check_temp_file[0])
7010 if (verbose_flag)
7011 inform (0, "recompiling with -fcompare-debug");
7013 compare_debug = -compare_debug;
7014 n_switches = n_switches_debug_check[1];
7015 n_switches_alloc = n_switches_alloc_debug_check[1];
7016 switches = switches_debug_check[1];
7018 value = do_spec (input_file_compiler->spec);
7020 compare_debug = -compare_debug;
7021 n_switches = n_switches_debug_check[0];
7022 n_switches_alloc = n_switches_alloc_debug_check[0];
7023 switches = switches_debug_check[0];
7025 if (value < 0)
7027 error ("during -fcompare-debug recompilation");
7028 this_file_error = 1;
7031 gcc_assert (debug_check_temp_file[1]
7032 && filename_cmp (debug_check_temp_file[0],
7033 debug_check_temp_file[1]));
7035 if (verbose_flag)
7036 inform (0, "comparing final insns dumps");
7038 if (compare_files (debug_check_temp_file))
7039 this_file_error = 1;
7042 if (compare_debug)
7044 free (debug_check_temp_file[0]);
7045 debug_check_temp_file[0] = NULL;
7047 free (debug_check_temp_file[1]);
7048 debug_check_temp_file[1] = NULL;
7053 /* If this file's name does not contain a recognized suffix,
7054 record it as explicit linker input. */
7056 else
7057 explicit_link_files[i] = 1;
7059 /* Clear the delete-on-failure queue, deleting the files in it
7060 if this compilation failed. */
7062 if (this_file_error)
7064 delete_failure_queue ();
7065 errorcount++;
7067 /* If this compilation succeeded, don't delete those files later. */
7068 clear_failure_queue ();
7071 /* Reset the input file name to the first compile/object file name, for use
7072 with %b in LINK_SPEC. We use the first input file that we can find
7073 a compiler to compile it instead of using infiles.language since for
7074 languages other than C we use aliases that we then lookup later. */
7075 if (n_infiles > 0)
7077 int i;
7079 for (i = 0; i < n_infiles ; i++)
7080 if (infiles[i].incompiler
7081 || (infiles[i].language && infiles[i].language[0] != '*'))
7083 set_input (infiles[i].name);
7084 break;
7088 if (!seen_error ())
7090 /* Make sure INPUT_FILE_NUMBER points to first available open
7091 slot. */
7092 input_file_number = n_infiles;
7093 if (lang_specific_pre_link ())
7094 errorcount++;
7097 /* Determine if there are any linker input files. */
7098 num_linker_inputs = 0;
7099 for (i = 0; (int) i < n_infiles; i++)
7100 if (explicit_link_files[i] || outfiles[i] != NULL)
7101 num_linker_inputs++;
7103 /* Run ld to link all the compiler output files. */
7105 if (num_linker_inputs > 0 && !seen_error () && print_subprocess_help < 2)
7107 int tmp = execution_count;
7109 if (! have_c)
7111 #if HAVE_LTO_PLUGIN > 0
7112 #if HAVE_LTO_PLUGIN == 2
7113 const char *fno_use_linker_plugin = "fno-use-linker-plugin";
7114 #else
7115 const char *fuse_linker_plugin = "fuse-linker-plugin";
7116 #endif
7117 #endif
7119 /* We'll use ld if we can't find collect2. */
7120 if (! strcmp (linker_name_spec, "collect2"))
7122 char *s = find_a_file (&exec_prefixes, "collect2", X_OK, false);
7123 if (s == NULL)
7124 linker_name_spec = "ld";
7127 #if HAVE_LTO_PLUGIN > 0
7128 #if HAVE_LTO_PLUGIN == 2
7129 if (!switch_matches (fno_use_linker_plugin,
7130 fno_use_linker_plugin
7131 + strlen (fno_use_linker_plugin), 0))
7132 #else
7133 if (switch_matches (fuse_linker_plugin,
7134 fuse_linker_plugin
7135 + strlen (fuse_linker_plugin), 0))
7136 #endif
7138 char *temp_spec = find_a_file (&exec_prefixes,
7139 LTOPLUGINSONAME, R_OK,
7140 false);
7141 if (!temp_spec)
7142 fatal_error ("-fuse-linker-plugin, but %s not found",
7143 LTOPLUGINSONAME);
7144 linker_plugin_file_spec = convert_white_space (temp_spec);
7146 #endif
7147 lto_gcc_spec = argv[0];
7150 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
7151 for collect. */
7152 putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH", false);
7153 putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV, true);
7155 if (print_subprocess_help == 1)
7157 printf (_("\nLinker options\n==============\n\n"));
7158 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
7159 " to the linker.\n\n"));
7160 fflush (stdout);
7162 value = do_spec (link_command_spec);
7163 if (value < 0)
7164 errorcount = 1;
7165 linker_was_run = (tmp != execution_count);
7168 /* If options said don't run linker,
7169 complain about input files to be given to the linker. */
7171 if (! linker_was_run && !seen_error ())
7172 for (i = 0; (int) i < n_infiles; i++)
7173 if (explicit_link_files[i]
7174 && !(infiles[i].language && infiles[i].language[0] == '*'))
7175 warning (0, "%s: linker input file unused because linking not done",
7176 outfiles[i]);
7178 /* Delete some or all of the temporary files we made. */
7180 if (seen_error ())
7181 delete_failure_queue ();
7182 delete_temp_files ();
7184 if (print_help_list)
7186 printf (("\nFor bug reporting instructions, please see:\n"));
7187 printf ("%s\n", bug_report_url);
7190 out:
7191 return (signal_count != 0 ? 2
7192 : seen_error () ? (pass_exit_codes ? greatest_status : 1)
7193 : 0);
7196 /* Find the proper compilation spec for the file name NAME,
7197 whose length is LENGTH. LANGUAGE is the specified language,
7198 or 0 if this file is to be passed to the linker. */
7200 static struct compiler *
7201 lookup_compiler (const char *name, size_t length, const char *language)
7203 struct compiler *cp;
7205 /* If this was specified by the user to be a linker input, indicate that. */
7206 if (language != 0 && language[0] == '*')
7207 return 0;
7209 /* Otherwise, look for the language, if one is spec'd. */
7210 if (language != 0)
7212 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7213 if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
7214 return cp;
7216 error ("language %s not recognized", language);
7217 return 0;
7220 /* Look for a suffix. */
7221 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7223 if (/* The suffix `-' matches only the file name `-'. */
7224 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
7225 || (strlen (cp->suffix) < length
7226 /* See if the suffix matches the end of NAME. */
7227 && !strcmp (cp->suffix,
7228 name + length - strlen (cp->suffix))
7230 break;
7233 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
7234 /* Look again, but case-insensitively this time. */
7235 if (cp < compilers)
7236 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7238 if (/* The suffix `-' matches only the file name `-'. */
7239 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
7240 || (strlen (cp->suffix) < length
7241 /* See if the suffix matches the end of NAME. */
7242 && ((!strcmp (cp->suffix,
7243 name + length - strlen (cp->suffix))
7244 || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
7245 && !strcasecmp (cp->suffix,
7246 name + length - strlen (cp->suffix)))
7248 break;
7250 #endif
7252 if (cp >= compilers)
7254 if (cp->spec[0] != '@')
7255 /* A non-alias entry: return it. */
7256 return cp;
7258 /* An alias entry maps a suffix to a language.
7259 Search for the language; pass 0 for NAME and LENGTH
7260 to avoid infinite recursion if language not found. */
7261 return lookup_compiler (NULL, 0, cp->spec + 1);
7263 return 0;
7266 static char *
7267 save_string (const char *s, int len)
7269 char *result = XNEWVEC (char, len + 1);
7271 memcpy (result, s, len);
7272 result[len] = 0;
7273 return result;
7276 void
7277 pfatal_with_name (const char *name)
7279 perror_with_name (name);
7280 delete_temp_files ();
7281 exit (1);
7284 static void
7285 perror_with_name (const char *name)
7287 error ("%s: %m", name);
7290 static inline void
7291 validate_switches_from_spec (const char *spec, bool user)
7293 const char *p = spec;
7294 char c;
7295 while ((c = *p++))
7296 if (c == '%' && (*p == '{' || *p == '<' || (*p == 'W' && *++p == '{')))
7297 /* We have a switch spec. */
7298 p = validate_switches (p + 1, user);
7301 static void
7302 validate_all_switches (void)
7304 struct compiler *comp;
7305 struct spec_list *spec;
7307 for (comp = compilers; comp->spec; comp++)
7308 validate_switches_from_spec (comp->spec, false);
7310 /* Look through the linked list of specs read from the specs file. */
7311 for (spec = specs; spec; spec = spec->next)
7312 validate_switches_from_spec (*spec->ptr_spec, spec->user_p);
7314 validate_switches_from_spec (link_command_spec, false);
7317 /* Look at the switch-name that comes after START
7318 and mark as valid all supplied switches that match it. */
7320 static const char *
7321 validate_switches (const char *start, bool user_spec)
7323 const char *p = start;
7324 const char *atom;
7325 size_t len;
7326 int i;
7327 bool suffix = false;
7328 bool starred = false;
7330 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7332 next_member:
7333 SKIP_WHITE ();
7335 if (*p == '!')
7336 p++;
7338 SKIP_WHITE ();
7339 if (*p == '.' || *p == ',')
7340 suffix = true, p++;
7342 atom = p;
7343 while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
7344 || *p == ',' || *p == '.' || *p == '@')
7345 p++;
7346 len = p - atom;
7348 if (*p == '*')
7349 starred = true, p++;
7351 SKIP_WHITE ();
7353 if (!suffix)
7355 /* Mark all matching switches as valid. */
7356 for (i = 0; i < n_switches; i++)
7357 if (!strncmp (switches[i].part1, atom, len)
7358 && (starred || switches[i].part1[len] == '\0')
7359 && (switches[i].known || user_spec))
7360 switches[i].validated = true;
7363 if (*p) p++;
7364 if (*p && (p[-1] == '|' || p[-1] == '&'))
7365 goto next_member;
7367 if (*p && p[-1] == ':')
7369 while (*p && *p != ';' && *p != '}')
7371 if (*p == '%')
7373 p++;
7374 if (*p == '{' || *p == '<')
7375 p = validate_switches (p+1, user_spec);
7376 else if (p[0] == 'W' && p[1] == '{')
7377 p = validate_switches (p+2, user_spec);
7379 else
7380 p++;
7383 if (*p) p++;
7384 if (*p && p[-1] == ';')
7385 goto next_member;
7388 return p;
7389 #undef SKIP_WHITE
7392 struct mdswitchstr
7394 const char *str;
7395 int len;
7398 static struct mdswitchstr *mdswitches;
7399 static int n_mdswitches;
7401 /* Check whether a particular argument was used. The first time we
7402 canonicalize the switches to keep only the ones we care about. */
7404 static int
7405 used_arg (const char *p, int len)
7407 struct mswitchstr
7409 const char *str;
7410 const char *replace;
7411 int len;
7412 int rep_len;
7415 static struct mswitchstr *mswitches;
7416 static int n_mswitches;
7417 int i, j;
7419 if (!mswitches)
7421 struct mswitchstr *matches;
7422 const char *q;
7423 int cnt = 0;
7425 /* Break multilib_matches into the component strings of string
7426 and replacement string. */
7427 for (q = multilib_matches; *q != '\0'; q++)
7428 if (*q == ';')
7429 cnt++;
7431 matches
7432 = (struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt);
7433 i = 0;
7434 q = multilib_matches;
7435 while (*q != '\0')
7437 matches[i].str = q;
7438 while (*q != ' ')
7440 if (*q == '\0')
7442 invalid_matches:
7443 fatal_error ("multilib spec %qs is invalid",
7444 multilib_matches);
7446 q++;
7448 matches[i].len = q - matches[i].str;
7450 matches[i].replace = ++q;
7451 while (*q != ';' && *q != '\0')
7453 if (*q == ' ')
7454 goto invalid_matches;
7455 q++;
7457 matches[i].rep_len = q - matches[i].replace;
7458 i++;
7459 if (*q == ';')
7460 q++;
7463 /* Now build a list of the replacement string for switches that we care
7464 about. Make sure we allocate at least one entry. This prevents
7465 xmalloc from calling fatal, and prevents us from re-executing this
7466 block of code. */
7467 mswitches
7468 = XNEWVEC (struct mswitchstr, n_mdswitches + (n_switches ? n_switches : 1));
7469 for (i = 0; i < n_switches; i++)
7470 if ((switches[i].live_cond & SWITCH_IGNORE) == 0)
7472 int xlen = strlen (switches[i].part1);
7473 for (j = 0; j < cnt; j++)
7474 if (xlen == matches[j].len
7475 && ! strncmp (switches[i].part1, matches[j].str, xlen))
7477 mswitches[n_mswitches].str = matches[j].replace;
7478 mswitches[n_mswitches].len = matches[j].rep_len;
7479 mswitches[n_mswitches].replace = (char *) 0;
7480 mswitches[n_mswitches].rep_len = 0;
7481 n_mswitches++;
7482 break;
7486 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
7487 on the command line nor any options mutually incompatible with
7488 them. */
7489 for (i = 0; i < n_mdswitches; i++)
7491 const char *r;
7493 for (q = multilib_options; *q != '\0'; q++)
7495 while (*q == ' ')
7496 q++;
7498 r = q;
7499 while (strncmp (q, mdswitches[i].str, mdswitches[i].len) != 0
7500 || strchr (" /", q[mdswitches[i].len]) == NULL)
7502 while (*q != ' ' && *q != '/' && *q != '\0')
7503 q++;
7504 if (*q != '/')
7505 break;
7506 q++;
7509 if (*q != ' ' && *q != '\0')
7511 while (*r != ' ' && *r != '\0')
7513 q = r;
7514 while (*q != ' ' && *q != '/' && *q != '\0')
7515 q++;
7517 if (used_arg (r, q - r))
7518 break;
7520 if (*q != '/')
7522 mswitches[n_mswitches].str = mdswitches[i].str;
7523 mswitches[n_mswitches].len = mdswitches[i].len;
7524 mswitches[n_mswitches].replace = (char *) 0;
7525 mswitches[n_mswitches].rep_len = 0;
7526 n_mswitches++;
7527 break;
7530 r = q + 1;
7532 break;
7538 for (i = 0; i < n_mswitches; i++)
7539 if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
7540 return 1;
7542 return 0;
7545 static int
7546 default_arg (const char *p, int len)
7548 int i;
7550 for (i = 0; i < n_mdswitches; i++)
7551 if (len == mdswitches[i].len && ! strncmp (p, mdswitches[i].str, len))
7552 return 1;
7554 return 0;
7557 /* Work out the subdirectory to use based on the options. The format of
7558 multilib_select is a list of elements. Each element is a subdirectory
7559 name followed by a list of options followed by a semicolon. The format
7560 of multilib_exclusions is the same, but without the preceding
7561 directory. First gcc will check the exclusions, if none of the options
7562 beginning with an exclamation point are present, and all of the other
7563 options are present, then we will ignore this completely. Passing
7564 that, gcc will consider each multilib_select in turn using the same
7565 rules for matching the options. If a match is found, that subdirectory
7566 will be used.
7567 A subdirectory name is optionally followed by a colon and the corresponding
7568 multiarch name. */
7570 static void
7571 set_multilib_dir (void)
7573 const char *p;
7574 unsigned int this_path_len;
7575 const char *this_path, *this_arg;
7576 const char *start, *end;
7577 int not_arg;
7578 int ok, ndfltok, first;
7580 n_mdswitches = 0;
7581 start = multilib_defaults;
7582 while (*start == ' ' || *start == '\t')
7583 start++;
7584 while (*start != '\0')
7586 n_mdswitches++;
7587 while (*start != ' ' && *start != '\t' && *start != '\0')
7588 start++;
7589 while (*start == ' ' || *start == '\t')
7590 start++;
7593 if (n_mdswitches)
7595 int i = 0;
7597 mdswitches = XNEWVEC (struct mdswitchstr, n_mdswitches);
7598 for (start = multilib_defaults; *start != '\0'; start = end + 1)
7600 while (*start == ' ' || *start == '\t')
7601 start++;
7603 if (*start == '\0')
7604 break;
7606 for (end = start + 1;
7607 *end != ' ' && *end != '\t' && *end != '\0'; end++)
7610 obstack_grow (&multilib_obstack, start, end - start);
7611 obstack_1grow (&multilib_obstack, 0);
7612 mdswitches[i].str = XOBFINISH (&multilib_obstack, const char *);
7613 mdswitches[i++].len = end - start;
7615 if (*end == '\0')
7616 break;
7620 p = multilib_exclusions;
7621 while (*p != '\0')
7623 /* Ignore newlines. */
7624 if (*p == '\n')
7626 ++p;
7627 continue;
7630 /* Check the arguments. */
7631 ok = 1;
7632 while (*p != ';')
7634 if (*p == '\0')
7636 invalid_exclusions:
7637 fatal_error ("multilib exclusions %qs is invalid",
7638 multilib_exclusions);
7641 if (! ok)
7643 ++p;
7644 continue;
7647 this_arg = p;
7648 while (*p != ' ' && *p != ';')
7650 if (*p == '\0')
7651 goto invalid_exclusions;
7652 ++p;
7655 if (*this_arg != '!')
7656 not_arg = 0;
7657 else
7659 not_arg = 1;
7660 ++this_arg;
7663 ok = used_arg (this_arg, p - this_arg);
7664 if (not_arg)
7665 ok = ! ok;
7667 if (*p == ' ')
7668 ++p;
7671 if (ok)
7672 return;
7674 ++p;
7677 first = 1;
7678 p = multilib_select;
7680 /* Append multilib reuse rules if any. With those rules, we can reuse
7681 one multilib for certain different options sets. */
7682 if (strlen (multilib_reuse) > 0)
7683 p = concat (p, multilib_reuse, NULL);
7685 while (*p != '\0')
7687 /* Ignore newlines. */
7688 if (*p == '\n')
7690 ++p;
7691 continue;
7694 /* Get the initial path. */
7695 this_path = p;
7696 while (*p != ' ')
7698 if (*p == '\0')
7700 invalid_select:
7701 fatal_error ("multilib select %qs %qs is invalid",
7702 multilib_select, multilib_reuse);
7704 ++p;
7706 this_path_len = p - this_path;
7708 /* Check the arguments. */
7709 ok = 1;
7710 ndfltok = 1;
7711 ++p;
7712 while (*p != ';')
7714 if (*p == '\0')
7715 goto invalid_select;
7717 if (! ok)
7719 ++p;
7720 continue;
7723 this_arg = p;
7724 while (*p != ' ' && *p != ';')
7726 if (*p == '\0')
7727 goto invalid_select;
7728 ++p;
7731 if (*this_arg != '!')
7732 not_arg = 0;
7733 else
7735 not_arg = 1;
7736 ++this_arg;
7739 /* If this is a default argument, we can just ignore it.
7740 This is true even if this_arg begins with '!'. Beginning
7741 with '!' does not mean that this argument is necessarily
7742 inappropriate for this library: it merely means that
7743 there is a more specific library which uses this
7744 argument. If this argument is a default, we need not
7745 consider that more specific library. */
7746 ok = used_arg (this_arg, p - this_arg);
7747 if (not_arg)
7748 ok = ! ok;
7750 if (! ok)
7751 ndfltok = 0;
7753 if (default_arg (this_arg, p - this_arg))
7754 ok = 1;
7756 if (*p == ' ')
7757 ++p;
7760 if (ok && first)
7762 if (this_path_len != 1
7763 || this_path[0] != '.')
7765 char *new_multilib_dir = XNEWVEC (char, this_path_len + 1);
7766 char *q;
7768 strncpy (new_multilib_dir, this_path, this_path_len);
7769 new_multilib_dir[this_path_len] = '\0';
7770 q = strchr (new_multilib_dir, ':');
7771 if (q != NULL)
7772 *q = '\0';
7773 multilib_dir = new_multilib_dir;
7775 first = 0;
7778 if (ndfltok)
7780 const char *q = this_path, *end = this_path + this_path_len;
7782 while (q < end && *q != ':')
7783 q++;
7784 if (q < end)
7786 const char *q2 = q + 1, *ml_end = end;
7787 char *new_multilib_os_dir;
7789 while (q2 < end && *q2 != ':')
7790 q2++;
7791 if (*q2 == ':')
7792 ml_end = q2;
7793 new_multilib_os_dir = XNEWVEC (char, ml_end - q);
7794 memcpy (new_multilib_os_dir, q + 1, ml_end - q - 1);
7795 new_multilib_os_dir[ml_end - q - 1] = '\0';
7796 multilib_os_dir = *new_multilib_os_dir ? new_multilib_os_dir : ".";
7798 if (q2 < end && *q2 == ':')
7800 char *new_multiarch_dir = XNEWVEC (char, end - q2);
7801 memcpy (new_multiarch_dir, q2 + 1, end - q2 - 1);
7802 new_multiarch_dir[end - q2 - 1] = '\0';
7803 multiarch_dir = new_multiarch_dir;
7805 break;
7809 ++p;
7812 if (multilib_dir == NULL && multilib_os_dir != NULL
7813 && strcmp (multilib_os_dir, ".") == 0)
7815 free (CONST_CAST (char *, multilib_os_dir));
7816 multilib_os_dir = NULL;
7818 else if (multilib_dir != NULL && multilib_os_dir == NULL)
7819 multilib_os_dir = multilib_dir;
7822 /* Print out the multiple library subdirectory selection
7823 information. This prints out a series of lines. Each line looks
7824 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
7825 required. Only the desired options are printed out, the negative
7826 matches. The options are print without a leading dash. There are
7827 no spaces to make it easy to use the information in the shell.
7828 Each subdirectory is printed only once. This assumes the ordering
7829 generated by the genmultilib script. Also, we leave out ones that match
7830 the exclusions. */
7832 static void
7833 print_multilib_info (void)
7835 const char *p = multilib_select;
7836 const char *last_path = 0, *this_path;
7837 int skip;
7838 unsigned int last_path_len = 0;
7840 while (*p != '\0')
7842 skip = 0;
7843 /* Ignore newlines. */
7844 if (*p == '\n')
7846 ++p;
7847 continue;
7850 /* Get the initial path. */
7851 this_path = p;
7852 while (*p != ' ')
7854 if (*p == '\0')
7856 invalid_select:
7857 fatal_error ("multilib select %qs is invalid", multilib_select);
7860 ++p;
7863 /* When --disable-multilib was used but target defines
7864 MULTILIB_OSDIRNAMES, entries starting with .: (and not starting
7865 with .:: for multiarch configurations) are there just to find
7866 multilib_os_dir, so skip them from output. */
7867 if (this_path[0] == '.' && this_path[1] == ':' && this_path[2] != ':')
7868 skip = 1;
7870 /* Check for matches with the multilib_exclusions. We don't bother
7871 with the '!' in either list. If any of the exclusion rules match
7872 all of its options with the select rule, we skip it. */
7874 const char *e = multilib_exclusions;
7875 const char *this_arg;
7877 while (*e != '\0')
7879 int m = 1;
7880 /* Ignore newlines. */
7881 if (*e == '\n')
7883 ++e;
7884 continue;
7887 /* Check the arguments. */
7888 while (*e != ';')
7890 const char *q;
7891 int mp = 0;
7893 if (*e == '\0')
7895 invalid_exclusion:
7896 fatal_error ("multilib exclusion %qs is invalid",
7897 multilib_exclusions);
7900 if (! m)
7902 ++e;
7903 continue;
7906 this_arg = e;
7908 while (*e != ' ' && *e != ';')
7910 if (*e == '\0')
7911 goto invalid_exclusion;
7912 ++e;
7915 q = p + 1;
7916 while (*q != ';')
7918 const char *arg;
7919 int len = e - this_arg;
7921 if (*q == '\0')
7922 goto invalid_select;
7924 arg = q;
7926 while (*q != ' ' && *q != ';')
7928 if (*q == '\0')
7929 goto invalid_select;
7930 ++q;
7933 if (! strncmp (arg, this_arg,
7934 (len < q - arg) ? q - arg : len)
7935 || default_arg (this_arg, e - this_arg))
7937 mp = 1;
7938 break;
7941 if (*q == ' ')
7942 ++q;
7945 if (! mp)
7946 m = 0;
7948 if (*e == ' ')
7949 ++e;
7952 if (m)
7954 skip = 1;
7955 break;
7958 if (*e != '\0')
7959 ++e;
7963 if (! skip)
7965 /* If this is a duplicate, skip it. */
7966 skip = (last_path != 0
7967 && (unsigned int) (p - this_path) == last_path_len
7968 && ! filename_ncmp (last_path, this_path, last_path_len));
7970 last_path = this_path;
7971 last_path_len = p - this_path;
7974 /* If this directory requires any default arguments, we can skip
7975 it. We will already have printed a directory identical to
7976 this one which does not require that default argument. */
7977 if (! skip)
7979 const char *q;
7981 q = p + 1;
7982 while (*q != ';')
7984 const char *arg;
7986 if (*q == '\0')
7987 goto invalid_select;
7989 if (*q == '!')
7990 arg = NULL;
7991 else
7992 arg = q;
7994 while (*q != ' ' && *q != ';')
7996 if (*q == '\0')
7997 goto invalid_select;
7998 ++q;
8001 if (arg != NULL
8002 && default_arg (arg, q - arg))
8004 skip = 1;
8005 break;
8008 if (*q == ' ')
8009 ++q;
8013 if (! skip)
8015 const char *p1;
8017 for (p1 = last_path; p1 < p && *p1 != ':'; p1++)
8018 putchar (*p1);
8019 putchar (';');
8022 ++p;
8023 while (*p != ';')
8025 int use_arg;
8027 if (*p == '\0')
8028 goto invalid_select;
8030 if (skip)
8032 ++p;
8033 continue;
8036 use_arg = *p != '!';
8038 if (use_arg)
8039 putchar ('@');
8041 while (*p != ' ' && *p != ';')
8043 if (*p == '\0')
8044 goto invalid_select;
8045 if (use_arg)
8046 putchar (*p);
8047 ++p;
8050 if (*p == ' ')
8051 ++p;
8054 if (! skip)
8056 /* If there are extra options, print them now. */
8057 if (multilib_extra && *multilib_extra)
8059 int print_at = TRUE;
8060 const char *q;
8062 for (q = multilib_extra; *q != '\0'; q++)
8064 if (*q == ' ')
8065 print_at = TRUE;
8066 else
8068 if (print_at)
8069 putchar ('@');
8070 putchar (*q);
8071 print_at = FALSE;
8076 putchar ('\n');
8079 ++p;
8083 /* getenv built-in spec function.
8085 Returns the value of the environment variable given by its first
8086 argument, concatenated with the second argument. If the
8087 environment variable is not defined, a fatal error is issued. */
8089 static const char *
8090 getenv_spec_function (int argc, const char **argv)
8092 char *value;
8093 char *result;
8094 char *ptr;
8095 size_t len;
8097 if (argc != 2)
8098 return NULL;
8100 value = getenv (argv[0]);
8101 if (!value)
8102 fatal_error ("environment variable %qs not defined", argv[0]);
8104 /* We have to escape every character of the environment variable so
8105 they are not interpreted as active spec characters. A
8106 particularly painful case is when we are reading a variable
8107 holding a windows path complete with \ separators. */
8108 len = strlen (value) * 2 + strlen (argv[1]) + 1;
8109 result = XNEWVAR (char, len);
8110 for (ptr = result; *value; ptr += 2)
8112 ptr[0] = '\\';
8113 ptr[1] = *value++;
8116 strcpy (ptr, argv[1]);
8118 return result;
8121 /* if-exists built-in spec function.
8123 Checks to see if the file specified by the absolute pathname in
8124 ARGS exists. Returns that pathname if found.
8126 The usual use for this function is to check for a library file
8127 (whose name has been expanded with %s). */
8129 static const char *
8130 if_exists_spec_function (int argc, const char **argv)
8132 /* Must have only one argument. */
8133 if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
8134 return argv[0];
8136 return NULL;
8139 /* if-exists-else built-in spec function.
8141 This is like if-exists, but takes an additional argument which
8142 is returned if the first argument does not exist. */
8144 static const char *
8145 if_exists_else_spec_function (int argc, const char **argv)
8147 /* Must have exactly two arguments. */
8148 if (argc != 2)
8149 return NULL;
8151 if (IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
8152 return argv[0];
8154 return argv[1];
8157 /* sanitize built-in spec function.
8159 This returns non-NULL, if sanitizing address, thread or
8160 any of the undefined behavior sanitizers. */
8162 static const char *
8163 sanitize_spec_function (int argc, const char **argv)
8165 if (argc != 1)
8166 return NULL;
8168 if (strcmp (argv[0], "address") == 0)
8169 return (flag_sanitize & SANITIZE_ADDRESS) ? "" : NULL;
8170 if (strcmp (argv[0], "thread") == 0)
8171 return (flag_sanitize & SANITIZE_THREAD) ? "" : NULL;
8172 if (strcmp (argv[0], "undefined") == 0)
8173 return (flag_sanitize & SANITIZE_UNDEFINED) ? "" : NULL;
8174 if (strcmp (argv[0], "leak") == 0)
8175 return ((flag_sanitize
8176 & (SANITIZE_ADDRESS | SANITIZE_LEAK | SANITIZE_THREAD))
8177 == SANITIZE_LEAK) ? "" : NULL;
8178 return NULL;
8181 /* replace-outfile built-in spec function.
8183 This looks for the first argument in the outfiles array's name and
8184 replaces it with the second argument. */
8186 static const char *
8187 replace_outfile_spec_function (int argc, const char **argv)
8189 int i;
8190 /* Must have exactly two arguments. */
8191 if (argc != 2)
8192 abort ();
8194 for (i = 0; i < n_infiles; i++)
8196 if (outfiles[i] && !filename_cmp (outfiles[i], argv[0]))
8197 outfiles[i] = xstrdup (argv[1]);
8199 return NULL;
8202 /* remove-outfile built-in spec function.
8204 * This looks for the first argument in the outfiles array's name and
8205 * removes it. */
8207 static const char *
8208 remove_outfile_spec_function (int argc, const char **argv)
8210 int i;
8211 /* Must have exactly one argument. */
8212 if (argc != 1)
8213 abort ();
8215 for (i = 0; i < n_infiles; i++)
8217 if (outfiles[i] && !filename_cmp (outfiles[i], argv[0]))
8218 outfiles[i] = NULL;
8220 return NULL;
8223 /* Given two version numbers, compares the two numbers.
8224 A version number must match the regular expression
8225 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
8227 static int
8228 compare_version_strings (const char *v1, const char *v2)
8230 int rresult;
8231 regex_t r;
8233 if (regcomp (&r, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
8234 REG_EXTENDED | REG_NOSUB) != 0)
8235 abort ();
8236 rresult = regexec (&r, v1, 0, NULL, 0);
8237 if (rresult == REG_NOMATCH)
8238 fatal_error ("invalid version number %qs", v1);
8239 else if (rresult != 0)
8240 abort ();
8241 rresult = regexec (&r, v2, 0, NULL, 0);
8242 if (rresult == REG_NOMATCH)
8243 fatal_error ("invalid version number %qs", v2);
8244 else if (rresult != 0)
8245 abort ();
8247 return strverscmp (v1, v2);
8251 /* version_compare built-in spec function.
8253 This takes an argument of the following form:
8255 <comparison-op> <arg1> [<arg2>] <switch> <result>
8257 and produces "result" if the comparison evaluates to true,
8258 and nothing if it doesn't.
8260 The supported <comparison-op> values are:
8262 >= true if switch is a later (or same) version than arg1
8263 !> opposite of >=
8264 < true if switch is an earlier version than arg1
8265 !< opposite of <
8266 >< true if switch is arg1 or later, and earlier than arg2
8267 <> true if switch is earlier than arg1 or is arg2 or later
8269 If the switch is not present, the condition is false unless
8270 the first character of the <comparison-op> is '!'.
8272 For example,
8273 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
8274 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
8276 static const char *
8277 version_compare_spec_function (int argc, const char **argv)
8279 int comp1, comp2;
8280 size_t switch_len;
8281 const char *switch_value = NULL;
8282 int nargs = 1, i;
8283 bool result;
8285 if (argc < 3)
8286 fatal_error ("too few arguments to %%:version-compare");
8287 if (argv[0][0] == '\0')
8288 abort ();
8289 if ((argv[0][1] == '<' || argv[0][1] == '>') && argv[0][0] != '!')
8290 nargs = 2;
8291 if (argc != nargs + 3)
8292 fatal_error ("too many arguments to %%:version-compare");
8294 switch_len = strlen (argv[nargs + 1]);
8295 for (i = 0; i < n_switches; i++)
8296 if (!strncmp (switches[i].part1, argv[nargs + 1], switch_len)
8297 && check_live_switch (i, switch_len))
8298 switch_value = switches[i].part1 + switch_len;
8300 if (switch_value == NULL)
8301 comp1 = comp2 = -1;
8302 else
8304 comp1 = compare_version_strings (switch_value, argv[1]);
8305 if (nargs == 2)
8306 comp2 = compare_version_strings (switch_value, argv[2]);
8307 else
8308 comp2 = -1; /* This value unused. */
8311 switch (argv[0][0] << 8 | argv[0][1])
8313 case '>' << 8 | '=':
8314 result = comp1 >= 0;
8315 break;
8316 case '!' << 8 | '<':
8317 result = comp1 >= 0 || switch_value == NULL;
8318 break;
8319 case '<' << 8:
8320 result = comp1 < 0;
8321 break;
8322 case '!' << 8 | '>':
8323 result = comp1 < 0 || switch_value == NULL;
8324 break;
8325 case '>' << 8 | '<':
8326 result = comp1 >= 0 && comp2 < 0;
8327 break;
8328 case '<' << 8 | '>':
8329 result = comp1 < 0 || comp2 >= 0;
8330 break;
8332 default:
8333 fatal_error ("unknown operator %qs in %%:version-compare", argv[0]);
8335 if (! result)
8336 return NULL;
8338 return argv[nargs + 2];
8341 /* %:include builtin spec function. This differs from %include in that it
8342 can be nested inside a spec, and thus be conditionalized. It takes
8343 one argument, the filename, and looks for it in the startfile path.
8344 The result is always NULL, i.e. an empty expansion. */
8346 static const char *
8347 include_spec_function (int argc, const char **argv)
8349 char *file;
8351 if (argc != 1)
8352 abort ();
8354 file = find_a_file (&startfile_prefixes, argv[0], R_OK, true);
8355 read_specs (file ? file : argv[0], false, false);
8357 return NULL;
8360 /* %:find-file spec function. This function replaces its argument by
8361 the file found through find_file, that is the -print-file-name gcc
8362 program option. */
8363 static const char *
8364 find_file_spec_function (int argc, const char **argv)
8366 const char *file;
8368 if (argc != 1)
8369 abort ();
8371 file = find_file (argv[0]);
8372 return file;
8376 /* %:find-plugindir spec function. This function replaces its argument
8377 by the -iplugindir=<dir> option. `dir' is found through find_file, that
8378 is the -print-file-name gcc program option. */
8379 static const char *
8380 find_plugindir_spec_function (int argc, const char **argv ATTRIBUTE_UNUSED)
8382 const char *option;
8384 if (argc != 0)
8385 abort ();
8387 option = concat ("-iplugindir=", find_file ("plugin"), NULL);
8388 return option;
8392 /* %:print-asm-header spec function. Print a banner to say that the
8393 following output is from the assembler. */
8395 static const char *
8396 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED,
8397 const char **argv ATTRIBUTE_UNUSED)
8399 printf (_("Assembler options\n=================\n\n"));
8400 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
8401 fflush (stdout);
8402 return NULL;
8405 /* Get a random number for -frandom-seed */
8407 static unsigned HOST_WIDE_INT
8408 get_random_number (void)
8410 unsigned HOST_WIDE_INT ret = 0;
8411 int fd;
8413 fd = open ("/dev/urandom", O_RDONLY);
8414 if (fd >= 0)
8416 read (fd, &ret, sizeof (HOST_WIDE_INT));
8417 close (fd);
8418 if (ret)
8419 return ret;
8422 /* Get some more or less random data. */
8423 #ifdef HAVE_GETTIMEOFDAY
8425 struct timeval tv;
8427 gettimeofday (&tv, NULL);
8428 ret = tv.tv_sec * 1000 + tv.tv_usec / 1000;
8430 #else
8432 time_t now = time (NULL);
8434 if (now != (time_t)-1)
8435 ret = (unsigned) now;
8437 #endif
8439 return ret ^ getpid ();
8442 /* %:compare-debug-dump-opt spec function. Save the last argument,
8443 expected to be the last -fdump-final-insns option, or generate a
8444 temporary. */
8446 static const char *
8447 compare_debug_dump_opt_spec_function (int arg,
8448 const char **argv ATTRIBUTE_UNUSED)
8450 char *ret;
8451 char *name;
8452 int which;
8453 static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];
8455 if (arg != 0)
8456 fatal_error ("too many arguments to %%:compare-debug-dump-opt");
8458 do_spec_2 ("%{fdump-final-insns=*:%*}");
8459 do_spec_1 (" ", 0, NULL);
8461 if (argbuf.length () > 0
8462 && strcmp (argv[argbuf.length () - 1], "."))
8464 if (!compare_debug)
8465 return NULL;
8467 name = xstrdup (argv[argbuf.length () - 1]);
8468 ret = NULL;
8470 else
8472 const char *ext = NULL;
8474 if (argbuf.length () > 0)
8476 do_spec_2 ("%{o*:%*}%{!o:%{!S:%b%O}%{S:%b.s}}");
8477 ext = ".gkd";
8479 else if (!compare_debug)
8480 return NULL;
8481 else
8482 do_spec_2 ("%g.gkd");
8484 do_spec_1 (" ", 0, NULL);
8486 gcc_assert (argbuf.length () > 0);
8488 name = concat (argbuf.last (), ext, NULL);
8490 ret = concat ("-fdump-final-insns=", name, NULL);
8493 which = compare_debug < 0;
8494 debug_check_temp_file[which] = name;
8496 if (!which)
8498 unsigned HOST_WIDE_INT value = get_random_number ();
8500 sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value);
8503 if (*random_seed)
8505 char *tmp = ret;
8506 ret = concat ("%{!frandom-seed=*:-frandom-seed=", random_seed, "} ",
8507 ret, NULL);
8508 free (tmp);
8511 if (which)
8512 *random_seed = 0;
8514 return ret;
8517 static const char *debug_auxbase_opt;
8519 /* %:compare-debug-self-opt spec function. Expands to the options
8520 that are to be passed in the second compilation of
8521 compare-debug. */
8523 static const char *
8524 compare_debug_self_opt_spec_function (int arg,
8525 const char **argv ATTRIBUTE_UNUSED)
8527 if (arg != 0)
8528 fatal_error ("too many arguments to %%:compare-debug-self-opt");
8530 if (compare_debug >= 0)
8531 return NULL;
8533 do_spec_2 ("%{c|S:%{o*:%*}}");
8534 do_spec_1 (" ", 0, NULL);
8536 if (argbuf.length () > 0)
8537 debug_auxbase_opt = concat ("-auxbase-strip ",
8538 argbuf.last (),
8539 NULL);
8540 else
8541 debug_auxbase_opt = NULL;
8543 return concat ("\
8544 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
8545 %<fdump-final-insns=* -w -S -o %j \
8546 %{!fcompare-debug-second:-fcompare-debug-second} \
8547 ", compare_debug_opt, NULL);
8550 /* %:compare-debug-auxbase-opt spec function. Expands to the auxbase
8551 options that are to be passed in the second compilation of
8552 compare-debug. It expects, as an argument, the basename of the
8553 current input file name, with the .gk suffix appended to it. */
8555 static const char *
8556 compare_debug_auxbase_opt_spec_function (int arg,
8557 const char **argv)
8559 char *name;
8560 int len;
8562 if (arg == 0)
8563 fatal_error ("too few arguments to %%:compare-debug-auxbase-opt");
8565 if (arg != 1)
8566 fatal_error ("too many arguments to %%:compare-debug-auxbase-opt");
8568 if (compare_debug >= 0)
8569 return NULL;
8571 len = strlen (argv[0]);
8572 if (len < 3 || strcmp (argv[0] + len - 3, ".gk") != 0)
8573 fatal_error ("argument to %%:compare-debug-auxbase-opt "
8574 "does not end in .gk");
8576 if (debug_auxbase_opt)
8577 return debug_auxbase_opt;
8579 #define OPT "-auxbase "
8581 len -= 3;
8582 name = (char*) xmalloc (sizeof (OPT) + len);
8583 memcpy (name, OPT, sizeof (OPT) - 1);
8584 memcpy (name + sizeof (OPT) - 1, argv[0], len);
8585 name[sizeof (OPT) - 1 + len] = '\0';
8587 #undef OPT
8589 return name;
8592 /* %:pass-through-libs spec function. Finds all -l options and input
8593 file names in the lib spec passed to it, and makes a list of them
8594 prepended with the plugin option to cause them to be passed through
8595 to the final link after all the new object files have been added. */
8597 const char *
8598 pass_through_libs_spec_func (int argc, const char **argv)
8600 char *prepended = xstrdup (" ");
8601 int n;
8602 /* Shlemiel the painter's algorithm. Innately horrible, but at least
8603 we know that there will never be more than a handful of strings to
8604 concat, and it's only once per run, so it's not worth optimising. */
8605 for (n = 0; n < argc; n++)
8607 char *old = prepended;
8608 /* Anything that isn't an option is a full path to an output
8609 file; pass it through if it ends in '.a'. Among options,
8610 pass only -l. */
8611 if (argv[n][0] == '-' && argv[n][1] == 'l')
8613 const char *lopt = argv[n] + 2;
8614 /* Handle both joined and non-joined -l options. If for any
8615 reason there's a trailing -l with no joined or following
8616 arg just discard it. */
8617 if (!*lopt && ++n >= argc)
8618 break;
8619 else if (!*lopt)
8620 lopt = argv[n];
8621 prepended = concat (prepended, "-plugin-opt=-pass-through=-l",
8622 lopt, " ", NULL);
8624 else if (!strcmp (".a", argv[n] + strlen (argv[n]) - 2))
8626 prepended = concat (prepended, "-plugin-opt=-pass-through=",
8627 argv[n], " ", NULL);
8629 if (prepended != old)
8630 free (old);
8632 return prepended;
8635 /* %:replace-extension spec function. Replaces the extension of the
8636 first argument with the second argument. */
8638 const char *
8639 replace_extension_spec_func (int argc, const char **argv)
8641 char *name;
8642 char *p;
8643 char *result;
8644 int i;
8646 if (argc != 2)
8647 fatal_error ("too few arguments to %%:replace-extension");
8649 name = xstrdup (argv[0]);
8651 for (i = strlen (name) - 1; i >= 0; i--)
8652 if (IS_DIR_SEPARATOR (name[i]))
8653 break;
8655 p = strrchr (name + i + 1, '.');
8656 if (p != NULL)
8657 *p = '\0';
8659 result = concat (name, argv[1], NULL);
8661 free (name);
8662 return result;
8665 /* Insert backslash before spaces in ORIG (usually a file path), to
8666 avoid being broken by spec parser.
8668 This function is needed as do_spec_1 treats white space (' ' and '\t')
8669 as the end of an argument. But in case of -plugin /usr/gcc install/xxx.so,
8670 the file name should be treated as a single argument rather than being
8671 broken into multiple. Solution is to insert '\\' before the space in a
8672 file name.
8674 This function converts and only converts all occurrence of ' '
8675 to '\\' + ' ' and '\t' to '\\' + '\t'. For example:
8676 "a b" -> "a\\ b"
8677 "a b" -> "a\\ \\ b"
8678 "a\tb" -> "a\\\tb"
8679 "a\\ b" -> "a\\\\ b"
8681 orig: input null-terminating string that was allocated by xalloc. The
8682 memory it points to might be freed in this function. Behavior undefined
8683 if ORIG wasn't xalloced or was freed already at entry.
8685 Return: ORIG if no conversion needed. Otherwise a newly allocated string
8686 that was converted from ORIG. */
8688 static char *
8689 convert_white_space (char *orig)
8691 int len, number_of_space = 0;
8693 for (len = 0; orig[len]; len++)
8694 if (orig[len] == ' ' || orig[len] == '\t') number_of_space++;
8696 if (number_of_space)
8698 char *new_spec = (char *) xmalloc (len + number_of_space + 1);
8699 int j, k;
8700 for (j = 0, k = 0; j <= len; j++, k++)
8702 if (orig[j] == ' ' || orig[j] == '\t')
8703 new_spec[k++] = '\\';
8704 new_spec[k] = orig[j];
8706 free (orig);
8707 return new_spec;
8709 else
8710 return orig;