Daily bump.
[official-gcc.git] / gcc / gcc.c
blobc7ce64d8fc864c2f8cf46269e020b86b637437ff
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 LIBLSAN_EARLY_SPEC
580 #define LIBLSAN_SPEC STATIC_LIBLSAN_LIBS
581 #elif defined(HAVE_LD_STATIC_DYNAMIC)
582 #define LIBLSAN_SPEC "%{static-liblsan:" LD_STATIC_OPTION \
583 "} -llsan %{static-liblsan:" LD_DYNAMIC_OPTION "}" \
584 STATIC_LIBLSAN_LIBS
585 #else
586 #define LIBLSAN_SPEC "-llsan" STATIC_LIBLSAN_LIBS
587 #endif
588 #endif
590 #ifndef LIBLSAN_EARLY_SPEC
591 #define LIBLSAN_EARLY_SPEC ""
592 #endif
594 #ifndef LIBUBSAN_SPEC
595 #define STATIC_LIBUBSAN_LIBS \
596 " %{static-libubsan:%:include(libsanitizer.spec)%(link_libubsan)}"
597 #ifdef HAVE_LD_STATIC_DYNAMIC
598 #define LIBUBSAN_SPEC "%{static-libubsan:" LD_STATIC_OPTION \
599 "} -lubsan %{static-libubsan:" LD_DYNAMIC_OPTION "}" \
600 STATIC_LIBUBSAN_LIBS
601 #else
602 #define LIBUBSAN_SPEC "-lubsan" STATIC_LIBUBSAN_LIBS
603 #endif
604 #endif
606 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
607 included. */
608 #ifndef LIBGCC_SPEC
609 #if defined(REAL_LIBGCC_SPEC)
610 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
611 #elif defined(LINK_LIBGCC_SPECIAL_1)
612 /* Have gcc do the search for libgcc.a. */
613 #define LIBGCC_SPEC "libgcc.a%s"
614 #else
615 #define LIBGCC_SPEC "-lgcc"
616 #endif
617 #endif
619 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
620 #ifndef STARTFILE_SPEC
621 #define STARTFILE_SPEC \
622 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
623 #endif
625 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
626 #ifndef ENDFILE_SPEC
627 #define ENDFILE_SPEC ""
628 #endif
630 #ifndef LINKER_NAME
631 #define LINKER_NAME "collect2"
632 #endif
634 #ifdef HAVE_AS_DEBUG_PREFIX_MAP
635 #define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
636 #else
637 #define ASM_MAP ""
638 #endif
640 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
641 to the assembler. */
642 #ifndef ASM_DEBUG_SPEC
643 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
644 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
645 # define ASM_DEBUG_SPEC \
646 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
647 ? "%{!g0:%{gdwarf*:--gdwarf2}%{!gdwarf*:%{g*:--gstabs}}}" ASM_MAP \
648 : "%{!g0:%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}}" ASM_MAP)
649 # else
650 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
651 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gstabs}}" ASM_MAP
652 # endif
653 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
654 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gdwarf2}}" ASM_MAP
655 # endif
656 # endif
657 #endif
658 #ifndef ASM_DEBUG_SPEC
659 # define ASM_DEBUG_SPEC ""
660 #endif
662 /* Here is the spec for running the linker, after compiling all files. */
664 /* This is overridable by the target in case they need to specify the
665 -lgcc and -lc order specially, yet not require them to override all
666 of LINK_COMMAND_SPEC. */
667 #ifndef LINK_GCC_C_SEQUENCE_SPEC
668 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
669 #endif
671 #ifndef LINK_SSP_SPEC
672 #ifdef TARGET_LIBC_PROVIDES_SSP
673 #define LINK_SSP_SPEC "%{fstack-protector:}"
674 #else
675 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-strong|fstack-protector-all:-lssp_nonshared -lssp}"
676 #endif
677 #endif
679 #ifndef LINK_PIE_SPEC
680 #ifdef HAVE_LD_PIE
681 #define LINK_PIE_SPEC "%{pie:-pie} "
682 #else
683 #define LINK_PIE_SPEC "%{pie:} "
684 #endif
685 #endif
687 #ifndef LINK_BUILDID_SPEC
688 # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
689 # define LINK_BUILDID_SPEC "%{!r:--build-id} "
690 # endif
691 #endif
693 /* Conditional to test whether the LTO plugin is used or not.
694 FIXME: For slim LTO we will need to enable plugin unconditionally. This
695 still cause problems with PLUGIN_LD != LD and when plugin is built but
696 not useable. For GCC 4.6 we don't support slim LTO and thus we can enable
697 plugin only when LTO is enabled. We still honor explicit
698 -fuse-linker-plugin if the linker used understands -plugin. */
700 /* The linker has some plugin support. */
701 #if HAVE_LTO_PLUGIN > 0
702 /* The linker used has full plugin support, use LTO plugin by default. */
703 #if HAVE_LTO_PLUGIN == 2
704 #define PLUGIN_COND "!fno-use-linker-plugin:%{!fno-lto"
705 #define PLUGIN_COND_CLOSE "}"
706 #else
707 /* The linker used has limited plugin support, use LTO plugin with explicit
708 -fuse-linker-plugin. */
709 #define PLUGIN_COND "fuse-linker-plugin"
710 #define PLUGIN_COND_CLOSE ""
711 #endif
712 #define LINK_PLUGIN_SPEC \
713 "%{"PLUGIN_COND": \
714 -plugin %(linker_plugin_file) \
715 -plugin-opt=%(lto_wrapper) \
716 -plugin-opt=-fresolution=%u.res \
717 %{!nostdlib:%{!nodefaultlibs:%:pass-through-libs(%(link_gcc_c_sequence))}} \
718 }"PLUGIN_COND_CLOSE
719 #else
720 /* The linker used doesn't support -plugin, reject -fuse-linker-plugin. */
721 #define LINK_PLUGIN_SPEC "%{fuse-linker-plugin:\
722 %e-fuse-linker-plugin is not supported in this configuration}"
723 #endif
725 /* Linker command line options for -fsanitize= early on the command line. */
726 #ifndef SANITIZER_EARLY_SPEC
727 #define SANITIZER_EARLY_SPEC "\
728 %{!nostdlib:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_EARLY_SPEC "} \
729 %{%:sanitize(thread):" LIBTSAN_EARLY_SPEC "} \
730 %{%:sanitize(leak):" LIBLSAN_EARLY_SPEC "}}}"
731 #endif
733 /* Linker command line options for -fsanitize= late on the command line. */
734 #ifndef SANITIZER_SPEC
735 #define SANITIZER_SPEC "\
736 %{!nostdlib:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_SPEC "\
737 %{static:%ecannot specify -static with -fsanitize=address}}\
738 %{%:sanitize(thread):" LIBTSAN_SPEC "\
739 %{!pie:%{!shared:%e-fsanitize=thread linking must be done with -pie or -shared}}}\
740 %{%:sanitize(undefined):" LIBUBSAN_SPEC "}\
741 %{%:sanitize(leak):" LIBLSAN_SPEC "}}}"
742 #endif
744 /* This is the spec to use, once the code for creating the vtable
745 verification runtime library, libvtv.so, has been created. Currently
746 the vtable verification runtime functions are in libstdc++, so we use
747 the spec just below this one. */
748 #ifndef VTABLE_VERIFICATION_SPEC
749 #define VTABLE_VERIFICATION_SPEC "\
750 %{!nostdlib:%{fvtable-verify=std: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}\
751 %{fvtable-verify=preinit: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}}"
752 #endif
754 /* -u* was put back because both BSD and SysV seem to support it. */
755 /* %{static:} simply prevents an error message if the target machine
756 doesn't handle -static. */
757 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
758 scripts which exist in user specified directories, or in standard
759 directories. */
760 /* We pass any -flto flags on to the linker, which is expected
761 to understand them. In practice, this means it had better be collect2. */
762 /* %{e*} includes -export-dynamic; see comment in common.opt. */
763 #ifndef LINK_COMMAND_SPEC
764 #define LINK_COMMAND_SPEC "\
765 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
766 %(linker) " \
767 LINK_PLUGIN_SPEC \
768 "%{flto|flto=*:%<fcompare-debug*} \
769 %{flto} %{fno-lto} %{flto=*} %l " LINK_PIE_SPEC \
770 "%{fuse-ld=*:-fuse-ld=%*}\
771 %X %{o*} %{e*} %{N} %{n} %{r}\
772 %{s} %{t} %{u*} %{z} %{Z} %{!nostdlib:%{!nostartfiles:%S}} " VTABLE_VERIFICATION_SPEC " \
773 %{static:} %{L*} %(mfwrap) %(link_libgcc) " SANITIZER_EARLY_SPEC " %o\
774 %{fopenmp|ftree-parallelize-loops=*:%:include(libgomp.spec)%(link_gomp)}\
775 %{fcilkplus:%:include(libcilkrts.spec)%(link_cilkrts)}\
776 %{fgnu-tm:%:include(libitm.spec)%(link_itm)}\
777 %(mflib) " STACK_SPLIT_SPEC "\
778 %{fprofile-arcs|fprofile-generate*|coverage:-lgcov} " SANITIZER_SPEC " \
779 %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\
780 %{!nostdlib:%{!nostartfiles:%E}} %{T*} }}}}}}"
781 #endif
783 #ifndef LINK_LIBGCC_SPEC
784 /* Generate -L options for startfile prefix list. */
785 # define LINK_LIBGCC_SPEC "%D"
786 #endif
788 #ifndef STARTFILE_PREFIX_SPEC
789 # define STARTFILE_PREFIX_SPEC ""
790 #endif
792 #ifndef SYSROOT_SPEC
793 # define SYSROOT_SPEC "--sysroot=%R"
794 #endif
796 #ifndef SYSROOT_SUFFIX_SPEC
797 # define SYSROOT_SUFFIX_SPEC ""
798 #endif
800 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
801 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
802 #endif
804 static const char *asm_debug = ASM_DEBUG_SPEC;
805 static const char *cpp_spec = CPP_SPEC;
806 static const char *cc1_spec = CC1_SPEC;
807 static const char *cc1plus_spec = CC1PLUS_SPEC;
808 static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC;
809 static const char *link_ssp_spec = LINK_SSP_SPEC;
810 static const char *asm_spec = ASM_SPEC;
811 static const char *asm_final_spec = ASM_FINAL_SPEC;
812 static const char *link_spec = LINK_SPEC;
813 static const char *lib_spec = LIB_SPEC;
814 static const char *link_gomp_spec = "";
815 static const char *libgcc_spec = LIBGCC_SPEC;
816 static const char *endfile_spec = ENDFILE_SPEC;
817 static const char *startfile_spec = STARTFILE_SPEC;
818 static const char *linker_name_spec = LINKER_NAME;
819 static const char *linker_plugin_file_spec = "";
820 static const char *lto_wrapper_spec = "";
821 static const char *lto_gcc_spec = "";
822 static const char *link_command_spec = LINK_COMMAND_SPEC;
823 static const char *link_libgcc_spec = LINK_LIBGCC_SPEC;
824 static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC;
825 static const char *sysroot_spec = SYSROOT_SPEC;
826 static const char *sysroot_suffix_spec = SYSROOT_SUFFIX_SPEC;
827 static const char *sysroot_hdrs_suffix_spec = SYSROOT_HEADERS_SUFFIX_SPEC;
828 static const char *self_spec = "";
830 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
831 There should be no need to override these in target dependent files,
832 but we need to copy them to the specs file so that newer versions
833 of the GCC driver can correctly drive older tool chains with the
834 appropriate -B options. */
836 /* When cpplib handles traditional preprocessing, get rid of this, and
837 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
838 that we default the front end language better. */
839 static const char *trad_capable_cpp =
840 "cc1 -E %{traditional|traditional-cpp:-traditional-cpp}";
842 /* We don't wrap .d files in %W{} since a missing .d file, and
843 therefore no dependency entry, confuses make into thinking a .o
844 file that happens to exist is up-to-date. */
845 static const char *cpp_unique_options =
846 "%{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\
847 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
848 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
849 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
850 %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
851 %{remap} %{g3|ggdb3|gstabs3|gcoff3|gxcoff3|gvms3:-dD}\
852 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
853 %{H} %C %{D*&U*&A*} %{i*} %Z %i\
854 %{E|M|MM:%W{o*}}";
856 /* This contains cpp options which are common with cc1_options and are passed
857 only when preprocessing only to avoid duplication. We pass the cc1 spec
858 options to the preprocessor so that it the cc1 spec may manipulate
859 options used to set target flags. Those special target flags settings may
860 in turn cause preprocessor symbols to be defined specially. */
861 static const char *cpp_options =
862 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
863 %{f*} %{g*:%{!g0:%{g*} %{!fno-working-directory:-fworking-directory}}} %{O*}\
864 %{undef} %{save-temps*:-fpch-preprocess}";
866 /* This contains cpp options which are not passed when the preprocessor
867 output will be used by another program. */
868 static const char *cpp_debug_options = "%{d*}";
870 /* NB: This is shared amongst all front-ends, except for Ada. */
871 static const char *cc1_options =
872 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
873 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
874 %1 %{!Q:-quiet} %{!dumpbase:-dumpbase %B} %{d*} %{m*} %{aux-info*}\
875 %{fcompare-debug-second:%:compare-debug-auxbase-opt(%b)} \
876 %{!fcompare-debug-second:%{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}}%{!c:%{!S:-auxbase %b}} \
877 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
878 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
879 %{Qn:-fno-ident} %{Qy:} %{-help:--help}\
880 %{-target-help:--target-help}\
881 %{-version:--version}\
882 %{-help=*:--help=%*}\
883 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
884 %{fsyntax-only:-o %j} %{-param*}\
885 %{coverage:-fprofile-arcs -ftest-coverage}";
887 static const char *asm_options =
888 "%{-target-help:%:print-asm-header()} "
889 #if HAVE_GNU_AS
890 /* If GNU AS is used, then convert -w (no warnings), -I, and -v
891 to the assembler equivalents. */
892 "%{v} %{w:-W} %{I*} "
893 #endif
894 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
896 static const char *invoke_as =
897 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
898 "%{!fwpa*:\
899 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
900 %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
902 #else
903 "%{!fwpa*:\
904 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
905 %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
907 #endif
909 /* Some compilers have limits on line lengths, and the multilib_select
910 and/or multilib_matches strings can be very long, so we build them at
911 run time. */
912 static struct obstack multilib_obstack;
913 static const char *multilib_select;
914 static const char *multilib_matches;
915 static const char *multilib_defaults;
916 static const char *multilib_exclusions;
917 static const char *multilib_reuse;
919 /* Check whether a particular argument is a default argument. */
921 #ifndef MULTILIB_DEFAULTS
922 #define MULTILIB_DEFAULTS { "" }
923 #endif
925 static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
927 #ifndef DRIVER_SELF_SPECS
928 #define DRIVER_SELF_SPECS ""
929 #endif
931 /* Linking to libgomp implies pthreads. This is particularly important
932 for targets that use different start files and suchlike. */
933 #ifndef GOMP_SELF_SPECS
934 #define GOMP_SELF_SPECS "%{fopenmp|ftree-parallelize-loops=*: -pthread}"
935 #endif
937 /* Likewise for -fgnu-tm. */
938 #ifndef GTM_SELF_SPECS
939 #define GTM_SELF_SPECS "%{fgnu-tm: -pthread}"
940 #endif
942 /* Likewise for -fcilkplus. */
943 #ifndef CILK_SELF_SPECS
944 #define CILK_SELF_SPECS "%{fcilkplus: -pthread}"
945 #endif
947 static const char *const driver_self_specs[] = {
948 "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
949 DRIVER_SELF_SPECS, CONFIGURE_SPECS, GOMP_SELF_SPECS, GTM_SELF_SPECS,
950 CILK_SELF_SPECS
953 #ifndef OPTION_DEFAULT_SPECS
954 #define OPTION_DEFAULT_SPECS { "", "" }
955 #endif
957 struct default_spec
959 const char *name;
960 const char *spec;
963 static const struct default_spec
964 option_default_specs[] = { OPTION_DEFAULT_SPECS };
966 struct user_specs
968 struct user_specs *next;
969 const char *filename;
972 static struct user_specs *user_specs_head, *user_specs_tail;
975 /* Record the mapping from file suffixes for compilation specs. */
977 struct compiler
979 const char *suffix; /* Use this compiler for input files
980 whose names end in this suffix. */
982 const char *spec; /* To use this compiler, run this spec. */
984 const char *cpp_spec; /* If non-NULL, substitute this spec
985 for `%C', rather than the usual
986 cpp_spec. */
987 const int combinable; /* If nonzero, compiler can deal with
988 multiple source files at once (IMA). */
989 const int needs_preprocessing; /* If nonzero, source files need to
990 be run through a preprocessor. */
993 /* Pointer to a vector of `struct compiler' that gives the spec for
994 compiling a file, based on its suffix.
995 A file that does not end in any of these suffixes will be passed
996 unchanged to the loader and nothing else will be done to it.
998 An entry containing two 0s is used to terminate the vector.
1000 If multiple entries match a file, the last matching one is used. */
1002 static struct compiler *compilers;
1004 /* Number of entries in `compilers', not counting the null terminator. */
1006 static int n_compilers;
1008 /* The default list of file name suffixes and their compilation specs. */
1010 static const struct compiler default_compilers[] =
1012 /* Add lists of suffixes of known languages here. If those languages
1013 were not present when we built the driver, we will hit these copies
1014 and be given a more meaningful error than "file not used since
1015 linking is not done". */
1016 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0},
1017 {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
1018 {".mii", "#Objective-C++", 0, 0, 0},
1019 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
1020 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
1021 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
1022 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
1023 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
1024 {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
1025 {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
1026 {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
1027 {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
1028 {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
1029 {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
1030 {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
1031 {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
1032 {".r", "#Ratfor", 0, 0, 0},
1033 {".p", "#Pascal", 0, 0, 0}, {".pas", "#Pascal", 0, 0, 0},
1034 {".java", "#Java", 0, 0, 0}, {".class", "#Java", 0, 0, 0},
1035 {".zip", "#Java", 0, 0, 0}, {".jar", "#Java", 0, 0, 0},
1036 {".go", "#Go", 0, 1, 0},
1037 /* Next come the entries for C. */
1038 {".c", "@c", 0, 0, 1},
1039 {"@c",
1040 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1041 external preprocessor if -save-temps is given. */
1042 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1043 %{!E:%{!M:%{!MM:\
1044 %{traditional:\
1045 %eGNU C no longer supports -traditional without -E}\
1046 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1047 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1048 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1049 %(cc1_options)}\
1050 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1051 cc1 %(cpp_unique_options) %(cc1_options)}}}\
1052 %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 1},
1053 {"-",
1054 "%{!E:%e-E or -x required when input is from standard input}\
1055 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
1056 {".h", "@c-header", 0, 0, 0},
1057 {"@c-header",
1058 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1059 external preprocessor if -save-temps is given. */
1060 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1061 %{!E:%{!M:%{!MM:\
1062 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1063 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1064 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1065 %(cc1_options)\
1066 %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
1067 %W{o*:--output-pch=%*}}%V}\
1068 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1069 cc1 %(cpp_unique_options) %(cc1_options)\
1070 %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
1071 %W{o*:--output-pch=%*}}%V}}}}}}", 0, 0, 0},
1072 {".i", "@cpp-output", 0, 0, 0},
1073 {"@cpp-output",
1074 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 0},
1075 {".s", "@assembler", 0, 0, 0},
1076 {"@assembler",
1077 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 0, 0},
1078 {".sx", "@assembler-with-cpp", 0, 0, 0},
1079 {".S", "@assembler-with-cpp", 0, 0, 0},
1080 {"@assembler-with-cpp",
1081 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1082 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1083 %{E|M|MM:%(cpp_debug_options)}\
1084 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1085 as %(asm_debug) %(asm_options) %|.s %A }}}}"
1086 #else
1087 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1088 %{E|M|MM:%(cpp_debug_options)}\
1089 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1090 as %(asm_debug) %(asm_options) %m.s %A }}}}"
1091 #endif
1092 , 0, 0, 0},
1094 #include "specs.h"
1095 /* Mark end of table. */
1096 {0, 0, 0, 0, 0}
1099 /* Number of elements in default_compilers, not counting the terminator. */
1101 static const int n_default_compilers = ARRAY_SIZE (default_compilers) - 1;
1103 typedef char *char_p; /* For DEF_VEC_P. */
1105 /* A vector of options to give to the linker.
1106 These options are accumulated by %x,
1107 and substituted into the linker command with %X. */
1108 static vec<char_p> linker_options;
1110 /* A vector of options to give to the assembler.
1111 These options are accumulated by -Wa,
1112 and substituted into the assembler command with %Y. */
1113 static vec<char_p> assembler_options;
1115 /* A vector of options to give to the preprocessor.
1116 These options are accumulated by -Wp,
1117 and substituted into the preprocessor command with %Z. */
1118 static vec<char_p> preprocessor_options;
1120 static char *
1121 skip_whitespace (char *p)
1123 while (1)
1125 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1126 be considered whitespace. */
1127 if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
1128 return p + 1;
1129 else if (*p == '\n' || *p == ' ' || *p == '\t')
1130 p++;
1131 else if (*p == '#')
1133 while (*p != '\n')
1134 p++;
1135 p++;
1137 else
1138 break;
1141 return p;
1143 /* Structures to keep track of prefixes to try when looking for files. */
1145 struct prefix_list
1147 const char *prefix; /* String to prepend to the path. */
1148 struct prefix_list *next; /* Next in linked list. */
1149 int require_machine_suffix; /* Don't use without machine_suffix. */
1150 /* 2 means try both machine_suffix and just_machine_suffix. */
1151 int priority; /* Sort key - priority within list. */
1152 int os_multilib; /* 1 if OS multilib scheme should be used,
1153 0 for GCC multilib scheme. */
1156 struct path_prefix
1158 struct prefix_list *plist; /* List of prefixes to try */
1159 int max_len; /* Max length of a prefix in PLIST */
1160 const char *name; /* Name of this list (used in config stuff) */
1163 /* List of prefixes to try when looking for executables. */
1165 static struct path_prefix exec_prefixes = { 0, 0, "exec" };
1167 /* List of prefixes to try when looking for startup (crt0) files. */
1169 static struct path_prefix startfile_prefixes = { 0, 0, "startfile" };
1171 /* List of prefixes to try when looking for include files. */
1173 static struct path_prefix include_prefixes = { 0, 0, "include" };
1175 /* Suffix to attach to directories searched for commands.
1176 This looks like `MACHINE/VERSION/'. */
1178 static const char *machine_suffix = 0;
1180 /* Suffix to attach to directories searched for commands.
1181 This is just `MACHINE/'. */
1183 static const char *just_machine_suffix = 0;
1185 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1187 static const char *gcc_exec_prefix;
1189 /* Adjusted value of standard_libexec_prefix. */
1191 static const char *gcc_libexec_prefix;
1193 /* Default prefixes to attach to command names. */
1195 #ifndef STANDARD_STARTFILE_PREFIX_1
1196 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1197 #endif
1198 #ifndef STANDARD_STARTFILE_PREFIX_2
1199 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1200 #endif
1202 #ifdef CROSS_DIRECTORY_STRUCTURE /* Don't use these prefixes for a cross compiler. */
1203 #undef MD_EXEC_PREFIX
1204 #undef MD_STARTFILE_PREFIX
1205 #undef MD_STARTFILE_PREFIX_1
1206 #endif
1208 /* If no prefixes defined, use the null string, which will disable them. */
1209 #ifndef MD_EXEC_PREFIX
1210 #define MD_EXEC_PREFIX ""
1211 #endif
1212 #ifndef MD_STARTFILE_PREFIX
1213 #define MD_STARTFILE_PREFIX ""
1214 #endif
1215 #ifndef MD_STARTFILE_PREFIX_1
1216 #define MD_STARTFILE_PREFIX_1 ""
1217 #endif
1219 /* These directories are locations set at configure-time based on the
1220 --prefix option provided to configure. Their initializers are
1221 defined in Makefile.in. These paths are not *directly* used when
1222 gcc_exec_prefix is set because, in that case, we know where the
1223 compiler has been installed, and use paths relative to that
1224 location instead. */
1225 static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
1226 static const char *const standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX;
1227 static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
1228 static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1230 /* For native compilers, these are well-known paths containing
1231 components that may be provided by the system. For cross
1232 compilers, these paths are not used. */
1233 static const char *md_exec_prefix = MD_EXEC_PREFIX;
1234 static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1235 static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1236 static const char *const standard_startfile_prefix_1
1237 = STANDARD_STARTFILE_PREFIX_1;
1238 static const char *const standard_startfile_prefix_2
1239 = STANDARD_STARTFILE_PREFIX_2;
1241 /* A relative path to be used in finding the location of tools
1242 relative to the driver. */
1243 static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1245 /* Subdirectory to use for locating libraries. Set by
1246 set_multilib_dir based on the compilation options. */
1248 static const char *multilib_dir;
1250 /* Subdirectory to use for locating libraries in OS conventions. Set by
1251 set_multilib_dir based on the compilation options. */
1253 static const char *multilib_os_dir;
1255 /* Subdirectory to use for locating libraries in multiarch conventions. Set by
1256 set_multilib_dir based on the compilation options. */
1258 static const char *multiarch_dir;
1260 /* Structure to keep track of the specs that have been defined so far.
1261 These are accessed using %(specname) in a compiler or link
1262 spec. */
1264 struct spec_list
1266 /* The following 2 fields must be first */
1267 /* to allow EXTRA_SPECS to be initialized */
1268 const char *name; /* name of the spec. */
1269 const char *ptr; /* available ptr if no static pointer */
1271 /* The following fields are not initialized */
1272 /* by EXTRA_SPECS */
1273 const char **ptr_spec; /* pointer to the spec itself. */
1274 struct spec_list *next; /* Next spec in linked list. */
1275 int name_len; /* length of the name */
1276 bool user_p; /* whether string come from file spec. */
1277 bool alloc_p; /* whether string was allocated */
1280 #define INIT_STATIC_SPEC(NAME,PTR) \
1281 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, false, false }
1283 /* List of statically defined specs. */
1284 static struct spec_list static_specs[] =
1286 INIT_STATIC_SPEC ("asm", &asm_spec),
1287 INIT_STATIC_SPEC ("asm_debug", &asm_debug),
1288 INIT_STATIC_SPEC ("asm_final", &asm_final_spec),
1289 INIT_STATIC_SPEC ("asm_options", &asm_options),
1290 INIT_STATIC_SPEC ("invoke_as", &invoke_as),
1291 INIT_STATIC_SPEC ("cpp", &cpp_spec),
1292 INIT_STATIC_SPEC ("cpp_options", &cpp_options),
1293 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options),
1294 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options),
1295 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp),
1296 INIT_STATIC_SPEC ("cc1", &cc1_spec),
1297 INIT_STATIC_SPEC ("cc1_options", &cc1_options),
1298 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec),
1299 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec),
1300 INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec),
1301 INIT_STATIC_SPEC ("endfile", &endfile_spec),
1302 INIT_STATIC_SPEC ("link", &link_spec),
1303 INIT_STATIC_SPEC ("lib", &lib_spec),
1304 INIT_STATIC_SPEC ("link_gomp", &link_gomp_spec),
1305 INIT_STATIC_SPEC ("libgcc", &libgcc_spec),
1306 INIT_STATIC_SPEC ("startfile", &startfile_spec),
1307 INIT_STATIC_SPEC ("cross_compile", &cross_compile),
1308 INIT_STATIC_SPEC ("version", &compiler_version),
1309 INIT_STATIC_SPEC ("multilib", &multilib_select),
1310 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults),
1311 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra),
1312 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches),
1313 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions),
1314 INIT_STATIC_SPEC ("multilib_options", &multilib_options),
1315 INIT_STATIC_SPEC ("multilib_reuse", &multilib_reuse),
1316 INIT_STATIC_SPEC ("linker", &linker_name_spec),
1317 INIT_STATIC_SPEC ("linker_plugin_file", &linker_plugin_file_spec),
1318 INIT_STATIC_SPEC ("lto_wrapper", &lto_wrapper_spec),
1319 INIT_STATIC_SPEC ("lto_gcc", &lto_gcc_spec),
1320 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec),
1321 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix),
1322 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix),
1323 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1),
1324 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec),
1325 INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec),
1326 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec),
1327 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec),
1328 INIT_STATIC_SPEC ("self_spec", &self_spec),
1331 #ifdef EXTRA_SPECS /* additional specs needed */
1332 /* Structure to keep track of just the first two args of a spec_list.
1333 That is all that the EXTRA_SPECS macro gives us. */
1334 struct spec_list_1
1336 const char *const name;
1337 const char *const ptr;
1340 static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1341 static struct spec_list *extra_specs = (struct spec_list *) 0;
1342 #endif
1344 /* List of dynamically allocates specs that have been defined so far. */
1346 static struct spec_list *specs = (struct spec_list *) 0;
1348 /* List of static spec functions. */
1350 static const struct spec_function static_spec_functions[] =
1352 { "getenv", getenv_spec_function },
1353 { "if-exists", if_exists_spec_function },
1354 { "if-exists-else", if_exists_else_spec_function },
1355 { "sanitize", sanitize_spec_function },
1356 { "replace-outfile", replace_outfile_spec_function },
1357 { "remove-outfile", remove_outfile_spec_function },
1358 { "version-compare", version_compare_spec_function },
1359 { "include", include_spec_function },
1360 { "find-file", find_file_spec_function },
1361 { "find-plugindir", find_plugindir_spec_function },
1362 { "print-asm-header", print_asm_header_spec_function },
1363 { "compare-debug-dump-opt", compare_debug_dump_opt_spec_function },
1364 { "compare-debug-self-opt", compare_debug_self_opt_spec_function },
1365 { "compare-debug-auxbase-opt", compare_debug_auxbase_opt_spec_function },
1366 { "pass-through-libs", pass_through_libs_spec_func },
1367 { "replace-extension", replace_extension_spec_func },
1368 #ifdef EXTRA_SPEC_FUNCTIONS
1369 EXTRA_SPEC_FUNCTIONS
1370 #endif
1371 { 0, 0 }
1374 static int processing_spec_function;
1376 /* Add appropriate libgcc specs to OBSTACK, taking into account
1377 various permutations of -shared-libgcc, -shared, and such. */
1379 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1381 #ifndef USE_LD_AS_NEEDED
1382 #define USE_LD_AS_NEEDED 0
1383 #endif
1385 static void
1386 init_gcc_specs (struct obstack *obstack, const char *shared_name,
1387 const char *static_name, const char *eh_name)
1389 char *buf;
1391 buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name, "}"
1392 "%{!static:%{!static-libgcc:"
1393 #if USE_LD_AS_NEEDED
1394 "%{!shared-libgcc:",
1395 static_name, " " LD_AS_NEEDED_OPTION " ",
1396 shared_name, " " LD_NO_AS_NEEDED_OPTION
1398 "%{shared-libgcc:",
1399 shared_name, "%{!shared: ", static_name, "}"
1401 #else
1402 "%{!shared:"
1403 "%{!shared-libgcc:", static_name, " ", eh_name, "}"
1404 "%{shared-libgcc:", shared_name, " ", static_name, "}"
1406 #ifdef LINK_EH_SPEC
1407 "%{shared:"
1408 "%{shared-libgcc:", shared_name, "}"
1409 "%{!shared-libgcc:", static_name, "}"
1411 #else
1412 "%{shared:", shared_name, "}"
1413 #endif
1414 #endif
1415 "}}", NULL);
1417 obstack_grow (obstack, buf, strlen (buf));
1418 free (buf);
1420 #endif /* ENABLE_SHARED_LIBGCC */
1422 /* Initialize the specs lookup routines. */
1424 static void
1425 init_spec (void)
1427 struct spec_list *next = (struct spec_list *) 0;
1428 struct spec_list *sl = (struct spec_list *) 0;
1429 int i;
1431 if (specs)
1432 return; /* Already initialized. */
1434 if (verbose_flag)
1435 fnotice (stderr, "Using built-in specs.\n");
1437 #ifdef EXTRA_SPECS
1438 extra_specs = XCNEWVEC (struct spec_list, ARRAY_SIZE (extra_specs_1));
1440 for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--)
1442 sl = &extra_specs[i];
1443 sl->name = extra_specs_1[i].name;
1444 sl->ptr = extra_specs_1[i].ptr;
1445 sl->next = next;
1446 sl->name_len = strlen (sl->name);
1447 sl->ptr_spec = &sl->ptr;
1448 next = sl;
1450 #endif
1452 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1454 sl = &static_specs[i];
1455 sl->next = next;
1456 next = sl;
1459 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1460 /* ??? If neither -shared-libgcc nor --static-libgcc was
1461 seen, then we should be making an educated guess. Some proposed
1462 heuristics for ELF include:
1464 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1465 program will be doing dynamic loading, which will likely
1466 need the shared libgcc.
1468 (2) If "-ldl", then it's also a fair bet that we're doing
1469 dynamic loading.
1471 (3) For each ET_DYN we're linking against (either through -lfoo
1472 or /some/path/foo.so), check to see whether it or one of
1473 its dependencies depends on a shared libgcc.
1475 (4) If "-shared"
1477 If the runtime is fixed to look for program headers instead
1478 of calling __register_frame_info at all, for each object,
1479 use the shared libgcc if any EH symbol referenced.
1481 If crtstuff is fixed to not invoke __register_frame_info
1482 automatically, for each object, use the shared libgcc if
1483 any non-empty unwind section found.
1485 Doing any of this probably requires invoking an external program to
1486 do the actual object file scanning. */
1488 const char *p = libgcc_spec;
1489 int in_sep = 1;
1491 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1492 when given the proper command line arguments. */
1493 while (*p)
1495 if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
1497 init_gcc_specs (&obstack,
1498 "-lgcc_s"
1499 #ifdef USE_LIBUNWIND_EXCEPTIONS
1500 " -lunwind"
1501 #endif
1503 "-lgcc",
1504 "-lgcc_eh"
1505 #ifdef USE_LIBUNWIND_EXCEPTIONS
1506 # ifdef HAVE_LD_STATIC_DYNAMIC
1507 " %{!static:" LD_STATIC_OPTION "} -lunwind"
1508 " %{!static:" LD_DYNAMIC_OPTION "}"
1509 # else
1510 " -lunwind"
1511 # endif
1512 #endif
1515 p += 5;
1516 in_sep = 0;
1518 else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0)
1520 /* Ug. We don't know shared library extensions. Hope that
1521 systems that use this form don't do shared libraries. */
1522 init_gcc_specs (&obstack,
1523 "-lgcc_s",
1524 "libgcc.a%s",
1525 "libgcc_eh.a%s"
1526 #ifdef USE_LIBUNWIND_EXCEPTIONS
1527 " -lunwind"
1528 #endif
1530 p += 10;
1531 in_sep = 0;
1533 else
1535 obstack_1grow (&obstack, *p);
1536 in_sep = (*p == ' ');
1537 p += 1;
1541 obstack_1grow (&obstack, '\0');
1542 libgcc_spec = XOBFINISH (&obstack, const char *);
1544 #endif
1545 #ifdef USE_AS_TRADITIONAL_FORMAT
1546 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1548 static const char tf[] = "--traditional-format ";
1549 obstack_grow (&obstack, tf, sizeof (tf) - 1);
1550 obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
1551 asm_spec = XOBFINISH (&obstack, const char *);
1553 #endif
1555 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC || \
1556 defined LINKER_HASH_STYLE
1557 # ifdef LINK_BUILDID_SPEC
1558 /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. */
1559 obstack_grow (&obstack, LINK_BUILDID_SPEC, sizeof (LINK_BUILDID_SPEC) - 1);
1560 # endif
1561 # ifdef LINK_EH_SPEC
1562 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1563 obstack_grow (&obstack, LINK_EH_SPEC, sizeof (LINK_EH_SPEC) - 1);
1564 # endif
1565 # ifdef LINKER_HASH_STYLE
1566 /* Prepend --hash-style=LINKER_HASH_STYLE to whatever link_spec we had
1567 before. */
1569 static const char hash_style[] = "--hash-style=";
1570 obstack_grow (&obstack, hash_style, sizeof (hash_style) - 1);
1571 obstack_grow (&obstack, LINKER_HASH_STYLE, sizeof (LINKER_HASH_STYLE) - 1);
1572 obstack_1grow (&obstack, ' ');
1574 # endif
1575 obstack_grow0 (&obstack, link_spec, strlen (link_spec));
1576 link_spec = XOBFINISH (&obstack, const char *);
1577 #endif
1579 specs = sl;
1582 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1583 removed; If the spec starts with a + then SPEC is added to the end of the
1584 current spec. */
1586 static void
1587 set_spec (const char *name, const char *spec, bool user_p)
1589 struct spec_list *sl;
1590 const char *old_spec;
1591 int name_len = strlen (name);
1592 int i;
1594 /* If this is the first call, initialize the statically allocated specs. */
1595 if (!specs)
1597 struct spec_list *next = (struct spec_list *) 0;
1598 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1600 sl = &static_specs[i];
1601 sl->next = next;
1602 next = sl;
1604 specs = sl;
1607 /* See if the spec already exists. */
1608 for (sl = specs; sl; sl = sl->next)
1609 if (name_len == sl->name_len && !strcmp (sl->name, name))
1610 break;
1612 if (!sl)
1614 /* Not found - make it. */
1615 sl = XNEW (struct spec_list);
1616 sl->name = xstrdup (name);
1617 sl->name_len = name_len;
1618 sl->ptr_spec = &sl->ptr;
1619 sl->alloc_p = 0;
1620 *(sl->ptr_spec) = "";
1621 sl->next = specs;
1622 specs = sl;
1625 old_spec = *(sl->ptr_spec);
1626 *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
1627 ? concat (old_spec, spec + 1, NULL)
1628 : xstrdup (spec));
1630 #ifdef DEBUG_SPECS
1631 if (verbose_flag)
1632 fnotice (stderr, "Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
1633 #endif
1635 /* Free the old spec. */
1636 if (old_spec && sl->alloc_p)
1637 free (CONST_CAST (char *, old_spec));
1639 sl->user_p = user_p;
1640 sl->alloc_p = true;
1643 /* Accumulate a command (program name and args), and run it. */
1645 typedef const char *const_char_p; /* For DEF_VEC_P. */
1647 /* Vector of pointers to arguments in the current line of specifications. */
1649 static vec<const_char_p> argbuf;
1651 /* Position in the argbuf vector containing the name of the output file
1652 (the value associated with the "-o" flag). */
1654 static int have_o_argbuf_index = 0;
1656 /* Were the options -c, -S or -E passed. */
1657 static int have_c = 0;
1659 /* Was the option -o passed. */
1660 static int have_o = 0;
1662 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1663 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
1664 it here. */
1666 static struct temp_name {
1667 const char *suffix; /* suffix associated with the code. */
1668 int length; /* strlen (suffix). */
1669 int unique; /* Indicates whether %g or %u/%U was used. */
1670 const char *filename; /* associated filename. */
1671 int filename_length; /* strlen (filename). */
1672 struct temp_name *next;
1673 } *temp_names;
1675 /* Number of commands executed so far. */
1677 static int execution_count;
1679 /* Number of commands that exited with a signal. */
1681 static int signal_count;
1683 /* Allocate the argument vector. */
1685 static void
1686 alloc_args (void)
1688 argbuf.create (10);
1691 /* Clear out the vector of arguments (after a command is executed). */
1693 static void
1694 clear_args (void)
1696 argbuf.truncate (0);
1699 /* Add one argument to the vector at the end.
1700 This is done when a space is seen or at the end of the line.
1701 If DELETE_ALWAYS is nonzero, the arg is a filename
1702 and the file should be deleted eventually.
1703 If DELETE_FAILURE is nonzero, the arg is a filename
1704 and the file should be deleted if this compilation fails. */
1706 static void
1707 store_arg (const char *arg, int delete_always, int delete_failure)
1709 argbuf.safe_push (arg);
1711 if (strcmp (arg, "-o") == 0)
1712 have_o_argbuf_index = argbuf.length ();
1713 if (delete_always || delete_failure)
1715 const char *p;
1716 /* If the temporary file we should delete is specified as
1717 part of a joined argument extract the filename. */
1718 if (arg[0] == '-'
1719 && (p = strrchr (arg, '=')))
1720 arg = p + 1;
1721 record_temp_file (arg, delete_always, delete_failure);
1725 /* Load specs from a file name named FILENAME, replacing occurrences of
1726 various different types of line-endings, \r\n, \n\r and just \r, with
1727 a single \n. */
1729 static char *
1730 load_specs (const char *filename)
1732 int desc;
1733 int readlen;
1734 struct stat statbuf;
1735 char *buffer;
1736 char *buffer_p;
1737 char *specs;
1738 char *specs_p;
1740 if (verbose_flag)
1741 fnotice (stderr, "Reading specs from %s\n", filename);
1743 /* Open and stat the file. */
1744 desc = open (filename, O_RDONLY, 0);
1745 if (desc < 0)
1746 pfatal_with_name (filename);
1747 if (stat (filename, &statbuf) < 0)
1748 pfatal_with_name (filename);
1750 /* Read contents of file into BUFFER. */
1751 buffer = XNEWVEC (char, statbuf.st_size + 1);
1752 readlen = read (desc, buffer, (unsigned) statbuf.st_size);
1753 if (readlen < 0)
1754 pfatal_with_name (filename);
1755 buffer[readlen] = 0;
1756 close (desc);
1758 specs = XNEWVEC (char, readlen + 1);
1759 specs_p = specs;
1760 for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
1762 int skip = 0;
1763 char c = *buffer_p;
1764 if (c == '\r')
1766 if (buffer_p > buffer && *(buffer_p - 1) == '\n') /* \n\r */
1767 skip = 1;
1768 else if (*(buffer_p + 1) == '\n') /* \r\n */
1769 skip = 1;
1770 else /* \r */
1771 c = '\n';
1773 if (! skip)
1774 *specs_p++ = c;
1776 *specs_p = '\0';
1778 free (buffer);
1779 return (specs);
1782 /* Read compilation specs from a file named FILENAME,
1783 replacing the default ones.
1785 A suffix which starts with `*' is a definition for
1786 one of the machine-specific sub-specs. The "suffix" should be
1787 *asm, *cc1, *cpp, *link, *startfile, etc.
1788 The corresponding spec is stored in asm_spec, etc.,
1789 rather than in the `compilers' vector.
1791 Anything invalid in the file is a fatal error. */
1793 static void
1794 read_specs (const char *filename, bool main_p, bool user_p)
1796 char *buffer;
1797 char *p;
1799 buffer = load_specs (filename);
1801 /* Scan BUFFER for specs, putting them in the vector. */
1802 p = buffer;
1803 while (1)
1805 char *suffix;
1806 char *spec;
1807 char *in, *out, *p1, *p2, *p3;
1809 /* Advance P in BUFFER to the next nonblank nocomment line. */
1810 p = skip_whitespace (p);
1811 if (*p == 0)
1812 break;
1814 /* Is this a special command that starts with '%'? */
1815 /* Don't allow this for the main specs file, since it would
1816 encourage people to overwrite it. */
1817 if (*p == '%' && !main_p)
1819 p1 = p;
1820 while (*p && *p != '\n')
1821 p++;
1823 /* Skip '\n'. */
1824 p++;
1826 if (!strncmp (p1, "%include", sizeof ("%include") - 1)
1827 && (p1[sizeof "%include" - 1] == ' '
1828 || p1[sizeof "%include" - 1] == '\t'))
1830 char *new_filename;
1832 p1 += sizeof ("%include");
1833 while (*p1 == ' ' || *p1 == '\t')
1834 p1++;
1836 if (*p1++ != '<' || p[-2] != '>')
1837 fatal_error ("specs %%include syntax malformed after "
1838 "%ld characters",
1839 (long) (p1 - buffer + 1));
1841 p[-2] = '\0';
1842 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
1843 read_specs (new_filename ? new_filename : p1, false, user_p);
1844 continue;
1846 else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
1847 && (p1[sizeof "%include_noerr" - 1] == ' '
1848 || p1[sizeof "%include_noerr" - 1] == '\t'))
1850 char *new_filename;
1852 p1 += sizeof "%include_noerr";
1853 while (*p1 == ' ' || *p1 == '\t')
1854 p1++;
1856 if (*p1++ != '<' || p[-2] != '>')
1857 fatal_error ("specs %%include syntax malformed after "
1858 "%ld characters",
1859 (long) (p1 - buffer + 1));
1861 p[-2] = '\0';
1862 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
1863 if (new_filename)
1864 read_specs (new_filename, false, user_p);
1865 else if (verbose_flag)
1866 fnotice (stderr, "could not find specs file %s\n", p1);
1867 continue;
1869 else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
1870 && (p1[sizeof "%rename" - 1] == ' '
1871 || p1[sizeof "%rename" - 1] == '\t'))
1873 int name_len;
1874 struct spec_list *sl;
1875 struct spec_list *newsl;
1877 /* Get original name. */
1878 p1 += sizeof "%rename";
1879 while (*p1 == ' ' || *p1 == '\t')
1880 p1++;
1882 if (! ISALPHA ((unsigned char) *p1))
1883 fatal_error ("specs %%rename syntax malformed after "
1884 "%ld characters",
1885 (long) (p1 - buffer));
1887 p2 = p1;
1888 while (*p2 && !ISSPACE ((unsigned char) *p2))
1889 p2++;
1891 if (*p2 != ' ' && *p2 != '\t')
1892 fatal_error ("specs %%rename syntax malformed after "
1893 "%ld characters",
1894 (long) (p2 - buffer));
1896 name_len = p2 - p1;
1897 *p2++ = '\0';
1898 while (*p2 == ' ' || *p2 == '\t')
1899 p2++;
1901 if (! ISALPHA ((unsigned char) *p2))
1902 fatal_error ("specs %%rename syntax malformed after "
1903 "%ld characters",
1904 (long) (p2 - buffer));
1906 /* Get new spec name. */
1907 p3 = p2;
1908 while (*p3 && !ISSPACE ((unsigned char) *p3))
1909 p3++;
1911 if (p3 != p - 1)
1912 fatal_error ("specs %%rename syntax malformed after "
1913 "%ld characters",
1914 (long) (p3 - buffer));
1915 *p3 = '\0';
1917 for (sl = specs; sl; sl = sl->next)
1918 if (name_len == sl->name_len && !strcmp (sl->name, p1))
1919 break;
1921 if (!sl)
1922 fatal_error ("specs %s spec was not found to be renamed", p1);
1924 if (strcmp (p1, p2) == 0)
1925 continue;
1927 for (newsl = specs; newsl; newsl = newsl->next)
1928 if (strcmp (newsl->name, p2) == 0)
1929 fatal_error ("%s: attempt to rename spec %qs to "
1930 "already defined spec %qs",
1931 filename, p1, p2);
1933 if (verbose_flag)
1935 fnotice (stderr, "rename spec %s to %s\n", p1, p2);
1936 #ifdef DEBUG_SPECS
1937 fnotice (stderr, "spec is '%s'\n\n", *(sl->ptr_spec));
1938 #endif
1941 set_spec (p2, *(sl->ptr_spec), user_p);
1942 if (sl->alloc_p)
1943 free (CONST_CAST (char *, *(sl->ptr_spec)));
1945 *(sl->ptr_spec) = "";
1946 sl->alloc_p = 0;
1947 continue;
1949 else
1950 fatal_error ("specs unknown %% command after %ld characters",
1951 (long) (p1 - buffer));
1954 /* Find the colon that should end the suffix. */
1955 p1 = p;
1956 while (*p1 && *p1 != ':' && *p1 != '\n')
1957 p1++;
1959 /* The colon shouldn't be missing. */
1960 if (*p1 != ':')
1961 fatal_error ("specs file malformed after %ld characters",
1962 (long) (p1 - buffer));
1964 /* Skip back over trailing whitespace. */
1965 p2 = p1;
1966 while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
1967 p2--;
1969 /* Copy the suffix to a string. */
1970 suffix = save_string (p, p2 - p);
1971 /* Find the next line. */
1972 p = skip_whitespace (p1 + 1);
1973 if (p[1] == 0)
1974 fatal_error ("specs file malformed after %ld characters",
1975 (long) (p - buffer));
1977 p1 = p;
1978 /* Find next blank line or end of string. */
1979 while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
1980 p1++;
1982 /* Specs end at the blank line and do not include the newline. */
1983 spec = save_string (p, p1 - p);
1984 p = p1;
1986 /* Delete backslash-newline sequences from the spec. */
1987 in = spec;
1988 out = spec;
1989 while (*in != 0)
1991 if (in[0] == '\\' && in[1] == '\n')
1992 in += 2;
1993 else if (in[0] == '#')
1994 while (*in && *in != '\n')
1995 in++;
1997 else
1998 *out++ = *in++;
2000 *out = 0;
2002 if (suffix[0] == '*')
2004 if (! strcmp (suffix, "*link_command"))
2005 link_command_spec = spec;
2006 else
2007 set_spec (suffix + 1, spec, user_p);
2009 else
2011 /* Add this pair to the vector. */
2012 compilers
2013 = XRESIZEVEC (struct compiler, compilers, n_compilers + 2);
2015 compilers[n_compilers].suffix = suffix;
2016 compilers[n_compilers].spec = spec;
2017 n_compilers++;
2018 memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
2021 if (*suffix == 0)
2022 link_command_spec = spec;
2025 if (link_command_spec == 0)
2026 fatal_error ("spec file has no spec for linking");
2029 /* Record the names of temporary files we tell compilers to write,
2030 and delete them at the end of the run. */
2032 /* This is the common prefix we use to make temp file names.
2033 It is chosen once for each run of this program.
2034 It is substituted into a spec by %g or %j.
2035 Thus, all temp file names contain this prefix.
2036 In practice, all temp file names start with this prefix.
2038 This prefix comes from the envvar TMPDIR if it is defined;
2039 otherwise, from the P_tmpdir macro if that is defined;
2040 otherwise, in /usr/tmp or /tmp;
2041 or finally the current directory if all else fails. */
2043 static const char *temp_filename;
2045 /* Length of the prefix. */
2047 static int temp_filename_length;
2049 /* Define the list of temporary files to delete. */
2051 struct temp_file
2053 const char *name;
2054 struct temp_file *next;
2057 /* Queue of files to delete on success or failure of compilation. */
2058 static struct temp_file *always_delete_queue;
2059 /* Queue of files to delete on failure of compilation. */
2060 static struct temp_file *failure_delete_queue;
2062 /* Record FILENAME as a file to be deleted automatically.
2063 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2064 otherwise delete it in any case.
2065 FAIL_DELETE nonzero means delete it if a compilation step fails;
2066 otherwise delete it in any case. */
2068 void
2069 record_temp_file (const char *filename, int always_delete, int fail_delete)
2071 char *const name = xstrdup (filename);
2073 if (always_delete)
2075 struct temp_file *temp;
2076 for (temp = always_delete_queue; temp; temp = temp->next)
2077 if (! filename_cmp (name, temp->name))
2078 goto already1;
2080 temp = XNEW (struct temp_file);
2081 temp->next = always_delete_queue;
2082 temp->name = name;
2083 always_delete_queue = temp;
2085 already1:;
2088 if (fail_delete)
2090 struct temp_file *temp;
2091 for (temp = failure_delete_queue; temp; temp = temp->next)
2092 if (! filename_cmp (name, temp->name))
2094 free (name);
2095 goto already2;
2098 temp = XNEW (struct temp_file);
2099 temp->next = failure_delete_queue;
2100 temp->name = name;
2101 failure_delete_queue = temp;
2103 already2:;
2107 /* Delete all the temporary files whose names we previously recorded. */
2109 #ifndef DELETE_IF_ORDINARY
2110 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2111 do \
2113 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2114 if (unlink (NAME) < 0) \
2115 if (VERBOSE_FLAG) \
2116 perror_with_name (NAME); \
2117 } while (0)
2118 #endif
2120 static void
2121 delete_if_ordinary (const char *name)
2123 struct stat st;
2124 #ifdef DEBUG
2125 int i, c;
2127 printf ("Delete %s? (y or n) ", name);
2128 fflush (stdout);
2129 i = getchar ();
2130 if (i != '\n')
2131 while ((c = getchar ()) != '\n' && c != EOF)
2134 if (i == 'y' || i == 'Y')
2135 #endif /* DEBUG */
2136 DELETE_IF_ORDINARY (name, st, verbose_flag);
2139 static void
2140 delete_temp_files (void)
2142 struct temp_file *temp;
2144 for (temp = always_delete_queue; temp; temp = temp->next)
2145 delete_if_ordinary (temp->name);
2146 always_delete_queue = 0;
2149 /* Delete all the files to be deleted on error. */
2151 static void
2152 delete_failure_queue (void)
2154 struct temp_file *temp;
2156 for (temp = failure_delete_queue; temp; temp = temp->next)
2157 delete_if_ordinary (temp->name);
2160 static void
2161 clear_failure_queue (void)
2163 failure_delete_queue = 0;
2166 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2167 returns non-NULL.
2168 If DO_MULTI is true iterate over the paths twice, first with multilib
2169 suffix then without, otherwise iterate over the paths once without
2170 adding a multilib suffix. When DO_MULTI is true, some attempt is made
2171 to avoid visiting the same path twice, but we could do better. For
2172 instance, /usr/lib/../lib is considered different from /usr/lib.
2173 At least EXTRA_SPACE chars past the end of the path passed to
2174 CALLBACK are available for use by the callback.
2175 CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2177 Returns the value returned by CALLBACK. */
2179 static void *
2180 for_each_path (const struct path_prefix *paths,
2181 bool do_multi,
2182 size_t extra_space,
2183 void *(*callback) (char *, void *),
2184 void *callback_info)
2186 struct prefix_list *pl;
2187 const char *multi_dir = NULL;
2188 const char *multi_os_dir = NULL;
2189 const char *multiarch_suffix = NULL;
2190 const char *multi_suffix;
2191 const char *just_multi_suffix;
2192 char *path = NULL;
2193 void *ret = NULL;
2194 bool skip_multi_dir = false;
2195 bool skip_multi_os_dir = false;
2197 multi_suffix = machine_suffix;
2198 just_multi_suffix = just_machine_suffix;
2199 if (do_multi && multilib_dir && strcmp (multilib_dir, ".") != 0)
2201 multi_dir = concat (multilib_dir, dir_separator_str, NULL);
2202 multi_suffix = concat (multi_suffix, multi_dir, NULL);
2203 just_multi_suffix = concat (just_multi_suffix, multi_dir, NULL);
2205 if (do_multi && multilib_os_dir && strcmp (multilib_os_dir, ".") != 0)
2206 multi_os_dir = concat (multilib_os_dir, dir_separator_str, NULL);
2207 if (multiarch_dir)
2208 multiarch_suffix = concat (multiarch_dir, dir_separator_str, NULL);
2210 while (1)
2212 size_t multi_dir_len = 0;
2213 size_t multi_os_dir_len = 0;
2214 size_t multiarch_len = 0;
2215 size_t suffix_len;
2216 size_t just_suffix_len;
2217 size_t len;
2219 if (multi_dir)
2220 multi_dir_len = strlen (multi_dir);
2221 if (multi_os_dir)
2222 multi_os_dir_len = strlen (multi_os_dir);
2223 if (multiarch_suffix)
2224 multiarch_len = strlen (multiarch_suffix);
2225 suffix_len = strlen (multi_suffix);
2226 just_suffix_len = strlen (just_multi_suffix);
2228 if (path == NULL)
2230 len = paths->max_len + extra_space + 1;
2231 len += MAX (MAX (suffix_len, multi_os_dir_len), multiarch_len);
2232 path = XNEWVEC (char, len);
2235 for (pl = paths->plist; pl != 0; pl = pl->next)
2237 len = strlen (pl->prefix);
2238 memcpy (path, pl->prefix, len);
2240 /* Look first in MACHINE/VERSION subdirectory. */
2241 if (!skip_multi_dir)
2243 memcpy (path + len, multi_suffix, suffix_len + 1);
2244 ret = callback (path, callback_info);
2245 if (ret)
2246 break;
2249 /* Some paths are tried with just the machine (ie. target)
2250 subdir. This is used for finding as, ld, etc. */
2251 if (!skip_multi_dir
2252 && pl->require_machine_suffix == 2)
2254 memcpy (path + len, just_multi_suffix, just_suffix_len + 1);
2255 ret = callback (path, callback_info);
2256 if (ret)
2257 break;
2260 /* Now try the multiarch path. */
2261 if (!skip_multi_dir
2262 && !pl->require_machine_suffix && multiarch_dir)
2264 memcpy (path + len, multiarch_suffix, multiarch_len + 1);
2265 ret = callback (path, callback_info);
2266 if (ret)
2267 break;
2270 /* Now try the base path. */
2271 if (!pl->require_machine_suffix
2272 && !(pl->os_multilib ? skip_multi_os_dir : skip_multi_dir))
2274 const char *this_multi;
2275 size_t this_multi_len;
2277 if (pl->os_multilib)
2279 this_multi = multi_os_dir;
2280 this_multi_len = multi_os_dir_len;
2282 else
2284 this_multi = multi_dir;
2285 this_multi_len = multi_dir_len;
2288 if (this_multi_len)
2289 memcpy (path + len, this_multi, this_multi_len + 1);
2290 else
2291 path[len] = '\0';
2293 ret = callback (path, callback_info);
2294 if (ret)
2295 break;
2298 if (pl)
2299 break;
2301 if (multi_dir == NULL && multi_os_dir == NULL)
2302 break;
2304 /* Run through the paths again, this time without multilibs.
2305 Don't repeat any we have already seen. */
2306 if (multi_dir)
2308 free (CONST_CAST (char *, multi_dir));
2309 multi_dir = NULL;
2310 free (CONST_CAST (char *, multi_suffix));
2311 multi_suffix = machine_suffix;
2312 free (CONST_CAST (char *, just_multi_suffix));
2313 just_multi_suffix = just_machine_suffix;
2315 else
2316 skip_multi_dir = true;
2317 if (multi_os_dir)
2319 free (CONST_CAST (char *, multi_os_dir));
2320 multi_os_dir = NULL;
2322 else
2323 skip_multi_os_dir = true;
2326 if (multi_dir)
2328 free (CONST_CAST (char *, multi_dir));
2329 free (CONST_CAST (char *, multi_suffix));
2330 free (CONST_CAST (char *, just_multi_suffix));
2332 if (multi_os_dir)
2333 free (CONST_CAST (char *, multi_os_dir));
2334 if (ret != path)
2335 free (path);
2336 return ret;
2339 /* Callback for build_search_list. Adds path to obstack being built. */
2341 struct add_to_obstack_info {
2342 struct obstack *ob;
2343 bool check_dir;
2344 bool first_time;
2347 static void *
2348 add_to_obstack (char *path, void *data)
2350 struct add_to_obstack_info *info = (struct add_to_obstack_info *) data;
2352 if (info->check_dir && !is_directory (path, false))
2353 return NULL;
2355 if (!info->first_time)
2356 obstack_1grow (info->ob, PATH_SEPARATOR);
2358 obstack_grow (info->ob, path, strlen (path));
2360 info->first_time = false;
2361 return NULL;
2364 /* Add or change the value of an environment variable, outputting the
2365 change to standard error if in verbose mode. */
2366 static void
2367 xputenv (const char *string)
2369 if (verbose_flag)
2370 fnotice (stderr, "%s\n", string);
2371 putenv (CONST_CAST (char *, string));
2374 /* Build a list of search directories from PATHS.
2375 PREFIX is a string to prepend to the list.
2376 If CHECK_DIR_P is true we ensure the directory exists.
2377 If DO_MULTI is true, multilib paths are output first, then
2378 non-multilib paths.
2379 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2380 It is also used by the --print-search-dirs flag. */
2382 static char *
2383 build_search_list (const struct path_prefix *paths, const char *prefix,
2384 bool check_dir, bool do_multi)
2386 struct add_to_obstack_info info;
2388 info.ob = &collect_obstack;
2389 info.check_dir = check_dir;
2390 info.first_time = true;
2392 obstack_grow (&collect_obstack, prefix, strlen (prefix));
2393 obstack_1grow (&collect_obstack, '=');
2395 for_each_path (paths, do_multi, 0, add_to_obstack, &info);
2397 obstack_1grow (&collect_obstack, '\0');
2398 return XOBFINISH (&collect_obstack, char *);
2401 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2402 for collect. */
2404 static void
2405 putenv_from_prefixes (const struct path_prefix *paths, const char *env_var,
2406 bool do_multi)
2408 xputenv (build_search_list (paths, env_var, true, do_multi));
2411 /* Check whether NAME can be accessed in MODE. This is like access,
2412 except that it never considers directories to be executable. */
2414 static int
2415 access_check (const char *name, int mode)
2417 if (mode == X_OK)
2419 struct stat st;
2421 if (stat (name, &st) < 0
2422 || S_ISDIR (st.st_mode))
2423 return -1;
2426 return access (name, mode);
2429 /* Callback for find_a_file. Appends the file name to the directory
2430 path. If the resulting file exists in the right mode, return the
2431 full pathname to the file. */
2433 struct file_at_path_info {
2434 const char *name;
2435 const char *suffix;
2436 int name_len;
2437 int suffix_len;
2438 int mode;
2441 static void *
2442 file_at_path (char *path, void *data)
2444 struct file_at_path_info *info = (struct file_at_path_info *) data;
2445 size_t len = strlen (path);
2447 memcpy (path + len, info->name, info->name_len);
2448 len += info->name_len;
2450 /* Some systems have a suffix for executable files.
2451 So try appending that first. */
2452 if (info->suffix_len)
2454 memcpy (path + len, info->suffix, info->suffix_len + 1);
2455 if (access_check (path, info->mode) == 0)
2456 return path;
2459 path[len] = '\0';
2460 if (access_check (path, info->mode) == 0)
2461 return path;
2463 return NULL;
2466 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2467 access to check permissions. If DO_MULTI is true, search multilib
2468 paths then non-multilib paths, otherwise do not search multilib paths.
2469 Return 0 if not found, otherwise return its name, allocated with malloc. */
2471 static char *
2472 find_a_file (const struct path_prefix *pprefix, const char *name, int mode,
2473 bool do_multi)
2475 struct file_at_path_info info;
2477 #ifdef DEFAULT_ASSEMBLER
2478 if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
2479 return xstrdup (DEFAULT_ASSEMBLER);
2480 #endif
2482 #ifdef DEFAULT_LINKER
2483 if (! strcmp (name, "ld") && access (DEFAULT_LINKER, mode) == 0)
2484 return xstrdup (DEFAULT_LINKER);
2485 #endif
2487 /* Determine the filename to execute (special case for absolute paths). */
2489 if (IS_ABSOLUTE_PATH (name))
2491 if (access (name, mode) == 0)
2492 return xstrdup (name);
2494 return NULL;
2497 info.name = name;
2498 info.suffix = (mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "";
2499 info.name_len = strlen (info.name);
2500 info.suffix_len = strlen (info.suffix);
2501 info.mode = mode;
2503 return (char*) for_each_path (pprefix, do_multi,
2504 info.name_len + info.suffix_len,
2505 file_at_path, &info);
2508 /* Ranking of prefixes in the sort list. -B prefixes are put before
2509 all others. */
2511 enum path_prefix_priority
2513 PREFIX_PRIORITY_B_OPT,
2514 PREFIX_PRIORITY_LAST
2517 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
2518 order according to PRIORITY. Within each PRIORITY, new entries are
2519 appended.
2521 If WARN is nonzero, we will warn if no file is found
2522 through this prefix. WARN should point to an int
2523 which will be set to 1 if this entry is used.
2525 COMPONENT is the value to be passed to update_path.
2527 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2528 the complete value of machine_suffix.
2529 2 means try both machine_suffix and just_machine_suffix. */
2531 static void
2532 add_prefix (struct path_prefix *pprefix, const char *prefix,
2533 const char *component, /* enum prefix_priority */ int priority,
2534 int require_machine_suffix, int os_multilib)
2536 struct prefix_list *pl, **prev;
2537 int len;
2539 for (prev = &pprefix->plist;
2540 (*prev) != NULL && (*prev)->priority <= priority;
2541 prev = &(*prev)->next)
2544 /* Keep track of the longest prefix. */
2546 prefix = update_path (prefix, component);
2547 len = strlen (prefix);
2548 if (len > pprefix->max_len)
2549 pprefix->max_len = len;
2551 pl = XNEW (struct prefix_list);
2552 pl->prefix = prefix;
2553 pl->require_machine_suffix = require_machine_suffix;
2554 pl->priority = priority;
2555 pl->os_multilib = os_multilib;
2557 /* Insert after PREV. */
2558 pl->next = (*prev);
2559 (*prev) = pl;
2562 /* Same as add_prefix, but prepending target_system_root to prefix. */
2563 /* The target_system_root prefix has been relocated by gcc_exec_prefix. */
2564 static void
2565 add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
2566 const char *component,
2567 /* enum prefix_priority */ int priority,
2568 int require_machine_suffix, int os_multilib)
2570 if (!IS_ABSOLUTE_PATH (prefix))
2571 fatal_error ("system path %qs is not absolute", prefix);
2573 if (target_system_root)
2575 char *sysroot_no_trailing_dir_separator = xstrdup (target_system_root);
2576 size_t sysroot_len = strlen (target_system_root);
2578 if (sysroot_len > 0
2579 && target_system_root[sysroot_len - 1] == DIR_SEPARATOR)
2580 sysroot_no_trailing_dir_separator[sysroot_len - 1] = '\0';
2582 if (target_sysroot_suffix)
2583 prefix = concat (sysroot_no_trailing_dir_separator,
2584 target_sysroot_suffix, prefix, NULL);
2585 else
2586 prefix = concat (sysroot_no_trailing_dir_separator, prefix, NULL);
2588 free (sysroot_no_trailing_dir_separator);
2590 /* We have to override this because GCC's notion of sysroot
2591 moves along with GCC. */
2592 component = "GCC";
2595 add_prefix (pprefix, prefix, component, priority,
2596 require_machine_suffix, os_multilib);
2599 /* Execute the command specified by the arguments on the current line of spec.
2600 When using pipes, this includes several piped-together commands
2601 with `|' between them.
2603 Return 0 if successful, -1 if failed. */
2605 static int
2606 execute (void)
2608 int i;
2609 int n_commands; /* # of command. */
2610 char *string;
2611 struct pex_obj *pex;
2612 struct command
2614 const char *prog; /* program name. */
2615 const char **argv; /* vector of args. */
2617 const char *arg;
2619 struct command *commands; /* each command buffer with above info. */
2621 gcc_assert (!processing_spec_function);
2623 if (wrapper_string)
2625 string = find_a_file (&exec_prefixes,
2626 argbuf[0], X_OK, false);
2627 if (string)
2628 argbuf[0] = string;
2629 insert_wrapper (wrapper_string);
2632 /* Count # of piped commands. */
2633 for (n_commands = 1, i = 0; argbuf.iterate (i, &arg); i++)
2634 if (strcmp (arg, "|") == 0)
2635 n_commands++;
2637 /* Get storage for each command. */
2638 commands = (struct command *) alloca (n_commands * sizeof (struct command));
2640 /* Split argbuf into its separate piped processes,
2641 and record info about each one.
2642 Also search for the programs that are to be run. */
2644 argbuf.safe_push (0);
2646 commands[0].prog = argbuf[0]; /* first command. */
2647 commands[0].argv = argbuf.address ();
2649 if (!wrapper_string)
2651 string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, false);
2652 commands[0].argv[0] = (string) ? string : commands[0].argv[0];
2655 for (n_commands = 1, i = 0; argbuf.iterate (i, &arg); i++)
2656 if (arg && strcmp (arg, "|") == 0)
2657 { /* each command. */
2658 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2659 fatal_error ("-pipe not supported");
2660 #endif
2661 argbuf[i] = 0; /* Termination of
2662 command args. */
2663 commands[n_commands].prog = argbuf[i + 1];
2664 commands[n_commands].argv
2665 = &(argbuf.address ())[i + 1];
2666 string = find_a_file (&exec_prefixes, commands[n_commands].prog,
2667 X_OK, false);
2668 if (string)
2669 commands[n_commands].argv[0] = string;
2670 n_commands++;
2673 /* If -v, print what we are about to do, and maybe query. */
2675 if (verbose_flag)
2677 /* For help listings, put a blank line between sub-processes. */
2678 if (print_help_list)
2679 fputc ('\n', stderr);
2681 /* Print each piped command as a separate line. */
2682 for (i = 0; i < n_commands; i++)
2684 const char *const *j;
2686 if (verbose_only_flag)
2688 for (j = commands[i].argv; *j; j++)
2690 const char *p;
2691 for (p = *j; *p; ++p)
2692 if (!ISALNUM ((unsigned char) *p)
2693 && *p != '_' && *p != '/' && *p != '-' && *p != '.')
2694 break;
2695 if (*p || !*j)
2697 fprintf (stderr, " \"");
2698 for (p = *j; *p; ++p)
2700 if (*p == '"' || *p == '\\' || *p == '$')
2701 fputc ('\\', stderr);
2702 fputc (*p, stderr);
2704 fputc ('"', stderr);
2706 /* If it's empty, print "". */
2707 else if (!**j)
2708 fprintf (stderr, " \"\"");
2709 else
2710 fprintf (stderr, " %s", *j);
2713 else
2714 for (j = commands[i].argv; *j; j++)
2715 /* If it's empty, print "". */
2716 if (!**j)
2717 fprintf (stderr, " \"\"");
2718 else
2719 fprintf (stderr, " %s", *j);
2721 /* Print a pipe symbol after all but the last command. */
2722 if (i + 1 != n_commands)
2723 fprintf (stderr, " |");
2724 fprintf (stderr, "\n");
2726 fflush (stderr);
2727 if (verbose_only_flag != 0)
2729 /* verbose_only_flag should act as if the spec was
2730 executed, so increment execution_count before
2731 returning. This prevents spurious warnings about
2732 unused linker input files, etc. */
2733 execution_count++;
2734 return 0;
2736 #ifdef DEBUG
2737 fnotice (stderr, "\nGo ahead? (y or n) ");
2738 fflush (stderr);
2739 i = getchar ();
2740 if (i != '\n')
2741 while (getchar () != '\n')
2744 if (i != 'y' && i != 'Y')
2745 return 0;
2746 #endif /* DEBUG */
2749 #ifdef ENABLE_VALGRIND_CHECKING
2750 /* Run the each command through valgrind. To simplify prepending the
2751 path to valgrind and the option "-q" (for quiet operation unless
2752 something triggers), we allocate a separate argv array. */
2754 for (i = 0; i < n_commands; i++)
2756 const char **argv;
2757 int argc;
2758 int j;
2760 for (argc = 0; commands[i].argv[argc] != NULL; argc++)
2763 argv = XALLOCAVEC (const char *, argc + 3);
2765 argv[0] = VALGRIND_PATH;
2766 argv[1] = "-q";
2767 for (j = 2; j < argc + 2; j++)
2768 argv[j] = commands[i].argv[j - 2];
2769 argv[j] = NULL;
2771 commands[i].argv = argv;
2772 commands[i].prog = argv[0];
2774 #endif
2776 /* Run each piped subprocess. */
2778 pex = pex_init (PEX_USE_PIPES | ((report_times || report_times_to_file)
2779 ? PEX_RECORD_TIMES : 0),
2780 progname, temp_filename);
2781 if (pex == NULL)
2782 fatal_error ("pex_init failed: %m");
2784 for (i = 0; i < n_commands; i++)
2786 const char *errmsg;
2787 int err;
2788 const char *string = commands[i].argv[0];
2790 errmsg = pex_run (pex,
2791 ((i + 1 == n_commands ? PEX_LAST : 0)
2792 | (string == commands[i].prog ? PEX_SEARCH : 0)),
2793 string, CONST_CAST (char **, commands[i].argv),
2794 NULL, NULL, &err);
2795 if (errmsg != NULL)
2797 if (err == 0)
2798 fatal_error (errmsg);
2799 else
2801 errno = err;
2802 pfatal_with_name (errmsg);
2806 if (string != commands[i].prog)
2807 free (CONST_CAST (char *, string));
2810 execution_count++;
2812 /* Wait for all the subprocesses to finish. */
2815 int *statuses;
2816 struct pex_time *times = NULL;
2817 int ret_code = 0;
2819 statuses = (int *) alloca (n_commands * sizeof (int));
2820 if (!pex_get_status (pex, n_commands, statuses))
2821 fatal_error ("failed to get exit status: %m");
2823 if (report_times || report_times_to_file)
2825 times = (struct pex_time *) alloca (n_commands * sizeof (struct pex_time));
2826 if (!pex_get_times (pex, n_commands, times))
2827 fatal_error ("failed to get process times: %m");
2830 pex_free (pex);
2832 for (i = 0; i < n_commands; ++i)
2834 int status = statuses[i];
2836 if (WIFSIGNALED (status))
2838 #ifdef SIGPIPE
2839 /* SIGPIPE is a special case. It happens in -pipe mode
2840 when the compiler dies before the preprocessor is done,
2841 or the assembler dies before the compiler is done.
2842 There's generally been an error already, and this is
2843 just fallout. So don't generate another error unless
2844 we would otherwise have succeeded. */
2845 if (WTERMSIG (status) == SIGPIPE
2846 && (signal_count || greatest_status >= MIN_FATAL_STATUS))
2848 signal_count++;
2849 ret_code = -1;
2851 else
2852 #endif
2853 internal_error ("%s (program %s)",
2854 strsignal (WTERMSIG (status)), commands[i].prog);
2856 else if (WIFEXITED (status)
2857 && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
2859 if (WEXITSTATUS (status) > greatest_status)
2860 greatest_status = WEXITSTATUS (status);
2861 ret_code = -1;
2864 if (report_times || report_times_to_file)
2866 struct pex_time *pt = &times[i];
2867 double ut, st;
2869 ut = ((double) pt->user_seconds
2870 + (double) pt->user_microseconds / 1.0e6);
2871 st = ((double) pt->system_seconds
2872 + (double) pt->system_microseconds / 1.0e6);
2874 if (ut + st != 0)
2876 if (report_times)
2877 fnotice (stderr, "# %s %.2f %.2f\n",
2878 commands[i].prog, ut, st);
2880 if (report_times_to_file)
2882 int c = 0;
2883 const char *const *j;
2885 fprintf (report_times_to_file, "%g %g", ut, st);
2887 for (j = &commands[i].prog; *j; j = &commands[i].argv[++c])
2889 const char *p;
2890 for (p = *j; *p; ++p)
2891 if (*p == '"' || *p == '\\' || *p == '$'
2892 || ISSPACE (*p))
2893 break;
2895 if (*p)
2897 fprintf (report_times_to_file, " \"");
2898 for (p = *j; *p; ++p)
2900 if (*p == '"' || *p == '\\' || *p == '$')
2901 fputc ('\\', report_times_to_file);
2902 fputc (*p, report_times_to_file);
2904 fputc ('"', report_times_to_file);
2906 else
2907 fprintf (report_times_to_file, " %s", *j);
2910 fputc ('\n', report_times_to_file);
2916 return ret_code;
2920 /* Find all the switches given to us
2921 and make a vector describing them.
2922 The elements of the vector are strings, one per switch given.
2923 If a switch uses following arguments, then the `part1' field
2924 is the switch itself and the `args' field
2925 is a null-terminated vector containing the following arguments.
2926 Bits in the `live_cond' field are:
2927 SWITCH_LIVE to indicate this switch is true in a conditional spec.
2928 SWITCH_FALSE to indicate this switch is overridden by a later switch.
2929 SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
2930 SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored
2931 in all do_spec calls afterwards. Used for %<S from self specs.
2932 The `validated' field is nonzero if any spec has looked at this switch;
2933 if it remains zero at the end of the run, it must be meaningless. */
2935 #define SWITCH_LIVE (1 << 0)
2936 #define SWITCH_FALSE (1 << 1)
2937 #define SWITCH_IGNORE (1 << 2)
2938 #define SWITCH_IGNORE_PERMANENTLY (1 << 3)
2939 #define SWITCH_KEEP_FOR_GCC (1 << 4)
2941 struct switchstr
2943 const char *part1;
2944 const char **args;
2945 unsigned int live_cond;
2946 bool known;
2947 bool validated;
2948 bool ordering;
2951 static struct switchstr *switches;
2953 static int n_switches;
2955 static int n_switches_alloc;
2957 /* Set to zero if -fcompare-debug is disabled, positive if it's
2958 enabled and we're running the first compilation, negative if it's
2959 enabled and we're running the second compilation. For most of the
2960 time, it's in the range -1..1, but it can be temporarily set to 2
2961 or 3 to indicate that the -fcompare-debug flags didn't come from
2962 the command-line, but rather from the GCC_COMPARE_DEBUG environment
2963 variable, until a synthesized -fcompare-debug flag is added to the
2964 command line. */
2965 int compare_debug;
2967 /* Set to nonzero if we've seen the -fcompare-debug-second flag. */
2968 int compare_debug_second;
2970 /* Set to the flags that should be passed to the second compilation in
2971 a -fcompare-debug compilation. */
2972 const char *compare_debug_opt;
2974 static struct switchstr *switches_debug_check[2];
2976 static int n_switches_debug_check[2];
2978 static int n_switches_alloc_debug_check[2];
2980 static char *debug_check_temp_file[2];
2982 /* Language is one of three things:
2984 1) The name of a real programming language.
2985 2) NULL, indicating that no one has figured out
2986 what it is yet.
2987 3) '*', indicating that the file should be passed
2988 to the linker. */
2989 struct infile
2991 const char *name;
2992 const char *language;
2993 struct compiler *incompiler;
2994 bool compiled;
2995 bool preprocessed;
2998 /* Also a vector of input files specified. */
3000 static struct infile *infiles;
3002 int n_infiles;
3004 static int n_infiles_alloc;
3006 /* True if multiple input files are being compiled to a single
3007 assembly file. */
3009 static bool combine_inputs;
3011 /* This counts the number of libraries added by lang_specific_driver, so that
3012 we can tell if there were any user supplied any files or libraries. */
3014 static int added_libraries;
3016 /* And a vector of corresponding output files is made up later. */
3018 const char **outfiles;
3020 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3022 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
3023 is true if we should look for an executable suffix. DO_OBJ
3024 is true if we should look for an object suffix. */
3026 static const char *
3027 convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
3028 int do_obj ATTRIBUTE_UNUSED)
3030 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3031 int i;
3032 #endif
3033 int len;
3035 if (name == NULL)
3036 return NULL;
3038 len = strlen (name);
3040 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3041 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
3042 if (do_obj && len > 2
3043 && name[len - 2] == '.'
3044 && name[len - 1] == 'o')
3046 obstack_grow (&obstack, name, len - 2);
3047 obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
3048 name = XOBFINISH (&obstack, const char *);
3050 #endif
3052 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3053 /* If there is no filetype, make it the executable suffix (which includes
3054 the "."). But don't get confused if we have just "-o". */
3055 if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
3056 return name;
3058 for (i = len - 1; i >= 0; i--)
3059 if (IS_DIR_SEPARATOR (name[i]))
3060 break;
3062 for (i++; i < len; i++)
3063 if (name[i] == '.')
3064 return name;
3066 obstack_grow (&obstack, name, len);
3067 obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
3068 strlen (TARGET_EXECUTABLE_SUFFIX));
3069 name = XOBFINISH (&obstack, const char *);
3070 #endif
3072 return name;
3074 #endif
3076 /* Display the command line switches accepted by gcc. */
3077 static void
3078 display_help (void)
3080 printf (_("Usage: %s [options] file...\n"), progname);
3081 fputs (_("Options:\n"), stdout);
3083 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout);
3084 fputs (_(" --help Display this information\n"), stdout);
3085 fputs (_(" --target-help Display target specific command line options\n"), stdout);
3086 fputs (_(" --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...]\n"), stdout);
3087 fputs (_(" Display specific types of command line options\n"), stdout);
3088 if (! verbose_flag)
3089 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
3090 fputs (_(" --version Display compiler version information\n"), stdout);
3091 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout);
3092 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout);
3093 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout);
3094 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout);
3095 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout);
3096 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout);
3097 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout);
3098 fputs (_("\
3099 -print-multiarch Display the target's normalized GNU triplet, used as\n\
3100 a component in the library path\n"), stdout);
3101 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout);
3102 fputs (_("\
3103 -print-multi-lib Display the mapping between command line options and\n\
3104 multiple library search directories\n"), stdout);
3105 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries\n"), stdout);
3106 fputs (_(" -print-sysroot Display the target libraries directory\n"), stdout);
3107 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n"), stdout);
3108 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout);
3109 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout);
3110 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout);
3111 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler\n"), stdout);
3112 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n"), stdout);
3113 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout);
3114 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout);
3115 fputs (_(" -save-temps=<arg> Do not delete intermediate files\n"), stdout);
3116 fputs (_("\
3117 -no-canonical-prefixes Do not canonicalize paths when building relative\n\
3118 prefixes to other gcc components\n"), stdout);
3119 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout);
3120 fputs (_(" -time Time the execution of each subprocess\n"), stdout);
3121 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout);
3122 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout);
3123 fputs (_("\
3124 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3125 and libraries\n"), stdout);
3126 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout);
3127 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout);
3128 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout);
3129 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout);
3130 fputs (_(" -S Compile only; do not assemble or link\n"), stdout);
3131 fputs (_(" -c Compile and assemble, but do not link\n"), stdout);
3132 fputs (_(" -o <file> Place the output into <file>\n"), stdout);
3133 fputs (_(" -pie Create a position independent executable\n"), stdout);
3134 fputs (_(" -shared Create a shared library\n"), stdout);
3135 fputs (_("\
3136 -x <language> Specify the language of the following input files\n\
3137 Permissible languages include: c c++ assembler none\n\
3138 'none' means revert to the default behavior of\n\
3139 guessing the language based on the file's extension\n\
3140 "), stdout);
3142 printf (_("\
3143 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3144 passed on to the various sub-processes invoked by %s. In order to pass\n\
3145 other options on to these processes the -W<letter> options must be used.\n\
3146 "), progname);
3148 /* The rest of the options are displayed by invocations of the various
3149 sub-processes. */
3152 static void
3153 add_preprocessor_option (const char *option, int len)
3155 preprocessor_options.safe_push (save_string (option, len));
3158 static void
3159 add_assembler_option (const char *option, int len)
3161 assembler_options.safe_push (save_string (option, len));
3164 static void
3165 add_linker_option (const char *option, int len)
3167 linker_options.safe_push (save_string (option, len));
3170 /* Allocate space for an input file in infiles. */
3172 static void
3173 alloc_infile (void)
3175 if (n_infiles_alloc == 0)
3177 n_infiles_alloc = 16;
3178 infiles = XNEWVEC (struct infile, n_infiles_alloc);
3180 else if (n_infiles_alloc == n_infiles)
3182 n_infiles_alloc *= 2;
3183 infiles = XRESIZEVEC (struct infile, infiles, n_infiles_alloc);
3187 /* Store an input file with the given NAME and LANGUAGE in
3188 infiles. */
3190 static void
3191 add_infile (const char *name, const char *language)
3193 alloc_infile ();
3194 infiles[n_infiles].name = name;
3195 infiles[n_infiles++].language = language;
3198 /* Allocate space for a switch in switches. */
3200 static void
3201 alloc_switch (void)
3203 if (n_switches_alloc == 0)
3205 n_switches_alloc = 16;
3206 switches = XNEWVEC (struct switchstr, n_switches_alloc);
3208 else if (n_switches_alloc == n_switches)
3210 n_switches_alloc *= 2;
3211 switches = XRESIZEVEC (struct switchstr, switches, n_switches_alloc);
3215 /* Save an option OPT with N_ARGS arguments in array ARGS, marking it
3216 as validated if VALIDATED and KNOWN if it is an internal switch. */
3218 static void
3219 save_switch (const char *opt, size_t n_args, const char *const *args,
3220 bool validated, bool known)
3222 alloc_switch ();
3223 switches[n_switches].part1 = opt + 1;
3224 if (n_args == 0)
3225 switches[n_switches].args = 0;
3226 else
3228 switches[n_switches].args = XNEWVEC (const char *, n_args + 1);
3229 memcpy (switches[n_switches].args, args, n_args * sizeof (const char *));
3230 switches[n_switches].args[n_args] = NULL;
3233 switches[n_switches].live_cond = 0;
3234 switches[n_switches].validated = validated;
3235 switches[n_switches].known = known;
3236 switches[n_switches].ordering = 0;
3237 n_switches++;
3240 /* Handle an option DECODED that is unknown to the option-processing
3241 machinery. */
3243 static bool
3244 driver_unknown_option_callback (const struct cl_decoded_option *decoded)
3246 const char *opt = decoded->arg;
3247 if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-'
3248 && !(decoded->errors & CL_ERR_NEGATIVE))
3250 /* Leave unknown -Wno-* options for the compiler proper, to be
3251 diagnosed only if there are warnings. */
3252 save_switch (decoded->canonical_option[0],
3253 decoded->canonical_option_num_elements - 1,
3254 &decoded->canonical_option[1], false, true);
3255 return false;
3257 if (decoded->opt_index == OPT_SPECIAL_unknown)
3259 /* Give it a chance to define it a a spec file. */
3260 save_switch (decoded->canonical_option[0],
3261 decoded->canonical_option_num_elements - 1,
3262 &decoded->canonical_option[1], false, false);
3263 return false;
3265 else
3266 return true;
3269 /* Handle an option DECODED that is not marked as CL_DRIVER.
3270 LANG_MASK will always be CL_DRIVER. */
3272 static void
3273 driver_wrong_lang_callback (const struct cl_decoded_option *decoded,
3274 unsigned int lang_mask ATTRIBUTE_UNUSED)
3276 /* At this point, non-driver options are accepted (and expected to
3277 be passed down by specs) unless marked to be rejected by the
3278 driver. Options to be rejected by the driver but accepted by the
3279 compilers proper are treated just like completely unknown
3280 options. */
3281 const struct cl_option *option = &cl_options[decoded->opt_index];
3283 if (option->cl_reject_driver)
3284 error ("unrecognized command line option %qs",
3285 decoded->orig_option_with_args_text);
3286 else
3287 save_switch (decoded->canonical_option[0],
3288 decoded->canonical_option_num_elements - 1,
3289 &decoded->canonical_option[1], false, true);
3292 static const char *spec_lang = 0;
3293 static int last_language_n_infiles;
3295 /* Handle a driver option; arguments and return value as for
3296 handle_option. */
3298 static bool
3299 driver_handle_option (struct gcc_options *opts,
3300 struct gcc_options *opts_set,
3301 const struct cl_decoded_option *decoded,
3302 unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
3303 location_t loc,
3304 const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED,
3305 diagnostic_context *dc)
3307 size_t opt_index = decoded->opt_index;
3308 const char *arg = decoded->arg;
3309 const char *compare_debug_replacement_opt;
3310 int value = decoded->value;
3311 bool validated = false;
3312 bool do_save = true;
3314 gcc_assert (opts == &global_options);
3315 gcc_assert (opts_set == &global_options_set);
3316 gcc_assert (kind == DK_UNSPECIFIED);
3317 gcc_assert (loc == UNKNOWN_LOCATION);
3318 gcc_assert (dc == global_dc);
3320 switch (opt_index)
3322 case OPT_dumpspecs:
3324 struct spec_list *sl;
3325 init_spec ();
3326 for (sl = specs; sl; sl = sl->next)
3327 printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3328 if (link_command_spec)
3329 printf ("*link_command:\n%s\n\n", link_command_spec);
3330 exit (0);
3333 case OPT_dumpversion:
3334 printf ("%s\n", spec_version);
3335 exit (0);
3337 case OPT_dumpmachine:
3338 printf ("%s\n", spec_machine);
3339 exit (0);
3341 case OPT__version:
3342 print_version = 1;
3344 /* CPP driver cannot obtain switch from cc1_options. */
3345 if (is_cpp_driver)
3346 add_preprocessor_option ("--version", strlen ("--version"));
3347 add_assembler_option ("--version", strlen ("--version"));
3348 add_linker_option ("--version", strlen ("--version"));
3349 break;
3351 case OPT__help:
3352 print_help_list = 1;
3354 /* CPP driver cannot obtain switch from cc1_options. */
3355 if (is_cpp_driver)
3356 add_preprocessor_option ("--help", 6);
3357 add_assembler_option ("--help", 6);
3358 add_linker_option ("--help", 6);
3359 break;
3361 case OPT__help_:
3362 print_subprocess_help = 2;
3363 break;
3365 case OPT__target_help:
3366 print_subprocess_help = 1;
3368 /* CPP driver cannot obtain switch from cc1_options. */
3369 if (is_cpp_driver)
3370 add_preprocessor_option ("--target-help", 13);
3371 add_assembler_option ("--target-help", 13);
3372 add_linker_option ("--target-help", 13);
3373 break;
3375 case OPT__no_sysroot_suffix:
3376 case OPT_pass_exit_codes:
3377 case OPT_print_search_dirs:
3378 case OPT_print_file_name_:
3379 case OPT_print_prog_name_:
3380 case OPT_print_multi_lib:
3381 case OPT_print_multi_directory:
3382 case OPT_print_sysroot:
3383 case OPT_print_multi_os_directory:
3384 case OPT_print_multiarch:
3385 case OPT_print_sysroot_headers_suffix:
3386 case OPT_time:
3387 case OPT_wrapper:
3388 /* These options set the variables specified in common.opt
3389 automatically, and do not need to be saved for spec
3390 processing. */
3391 do_save = false;
3392 break;
3394 case OPT_print_libgcc_file_name:
3395 print_file_name = "libgcc.a";
3396 do_save = false;
3397 break;
3399 case OPT_fuse_ld_bfd:
3400 use_ld = ".bfd";
3401 break;
3403 case OPT_fuse_ld_gold:
3404 use_ld = ".gold";
3405 break;
3407 case OPT_fcompare_debug_second:
3408 compare_debug_second = 1;
3409 break;
3411 case OPT_fcompare_debug:
3412 switch (value)
3414 case 0:
3415 compare_debug_replacement_opt = "-fcompare-debug=";
3416 arg = "";
3417 goto compare_debug_with_arg;
3419 case 1:
3420 compare_debug_replacement_opt = "-fcompare-debug=-gtoggle";
3421 arg = "-gtoggle";
3422 goto compare_debug_with_arg;
3424 default:
3425 gcc_unreachable ();
3427 break;
3429 case OPT_fcompare_debug_:
3430 compare_debug_replacement_opt = decoded->canonical_option[0];
3431 compare_debug_with_arg:
3432 gcc_assert (decoded->canonical_option_num_elements == 1);
3433 gcc_assert (arg != NULL);
3434 if (*arg)
3435 compare_debug = 1;
3436 else
3437 compare_debug = -1;
3438 if (compare_debug < 0)
3439 compare_debug_opt = NULL;
3440 else
3441 compare_debug_opt = arg;
3442 save_switch (compare_debug_replacement_opt, 0, NULL, validated, true);
3443 return true;
3445 case OPT_Wa_:
3447 int prev, j;
3448 /* Pass the rest of this option to the assembler. */
3450 /* Split the argument at commas. */
3451 prev = 0;
3452 for (j = 0; arg[j]; j++)
3453 if (arg[j] == ',')
3455 add_assembler_option (arg + prev, j - prev);
3456 prev = j + 1;
3459 /* Record the part after the last comma. */
3460 add_assembler_option (arg + prev, j - prev);
3462 do_save = false;
3463 break;
3465 case OPT_Wp_:
3467 int prev, j;
3468 /* Pass the rest of this option to the preprocessor. */
3470 /* Split the argument at commas. */
3471 prev = 0;
3472 for (j = 0; arg[j]; j++)
3473 if (arg[j] == ',')
3475 add_preprocessor_option (arg + prev, j - prev);
3476 prev = j + 1;
3479 /* Record the part after the last comma. */
3480 add_preprocessor_option (arg + prev, j - prev);
3482 do_save = false;
3483 break;
3485 case OPT_Wl_:
3487 int prev, j;
3488 /* Split the argument at commas. */
3489 prev = 0;
3490 for (j = 0; arg[j]; j++)
3491 if (arg[j] == ',')
3493 add_infile (save_string (arg + prev, j - prev), "*");
3494 prev = j + 1;
3496 /* Record the part after the last comma. */
3497 add_infile (arg + prev, "*");
3499 do_save = false;
3500 break;
3502 case OPT_Xlinker:
3503 add_infile (arg, "*");
3504 do_save = false;
3505 break;
3507 case OPT_Xpreprocessor:
3508 add_preprocessor_option (arg, strlen (arg));
3509 do_save = false;
3510 break;
3512 case OPT_Xassembler:
3513 add_assembler_option (arg, strlen (arg));
3514 do_save = false;
3515 break;
3517 case OPT_l:
3518 /* POSIX allows separation of -l and the lib arg; canonicalize
3519 by concatenating -l with its arg */
3520 add_infile (concat ("-l", arg, NULL), "*");
3521 do_save = false;
3522 break;
3524 case OPT_L:
3525 /* Similarly, canonicalize -L for linkers that may not accept
3526 separate arguments. */
3527 save_switch (concat ("-L", arg, NULL), 0, NULL, validated, true);
3528 return true;
3530 case OPT_F:
3531 /* Likewise -F. */
3532 save_switch (concat ("-F", arg, NULL), 0, NULL, validated, true);
3533 return true;
3535 case OPT_save_temps:
3536 save_temps_flag = SAVE_TEMPS_CWD;
3537 validated = true;
3538 break;
3540 case OPT_save_temps_:
3541 if (strcmp (arg, "cwd") == 0)
3542 save_temps_flag = SAVE_TEMPS_CWD;
3543 else if (strcmp (arg, "obj") == 0
3544 || strcmp (arg, "object") == 0)
3545 save_temps_flag = SAVE_TEMPS_OBJ;
3546 else
3547 fatal_error ("%qs is an unknown -save-temps option",
3548 decoded->orig_option_with_args_text);
3549 break;
3551 case OPT_no_canonical_prefixes:
3552 /* Already handled as a special case, so ignored here. */
3553 do_save = false;
3554 break;
3556 case OPT_pipe:
3557 validated = true;
3558 /* These options set the variables specified in common.opt
3559 automatically, but do need to be saved for spec
3560 processing. */
3561 break;
3563 case OPT_specs_:
3565 struct user_specs *user = XNEW (struct user_specs);
3567 user->next = (struct user_specs *) 0;
3568 user->filename = arg;
3569 if (user_specs_tail)
3570 user_specs_tail->next = user;
3571 else
3572 user_specs_head = user;
3573 user_specs_tail = user;
3575 validated = true;
3576 break;
3578 case OPT__sysroot_:
3579 target_system_root = arg;
3580 target_system_root_changed = 1;
3581 do_save = false;
3582 break;
3584 case OPT_time_:
3585 if (report_times_to_file)
3586 fclose (report_times_to_file);
3587 report_times_to_file = fopen (arg, "a");
3588 do_save = false;
3589 break;
3591 case OPT____:
3592 /* "-###"
3593 This is similar to -v except that there is no execution
3594 of the commands and the echoed arguments are quoted. It
3595 is intended for use in shell scripts to capture the
3596 driver-generated command line. */
3597 verbose_only_flag++;
3598 verbose_flag = 1;
3599 do_save = false;
3600 break;
3602 case OPT_B:
3604 size_t len = strlen (arg);
3606 /* Catch the case where the user has forgotten to append a
3607 directory separator to the path. Note, they may be using
3608 -B to add an executable name prefix, eg "i386-elf-", in
3609 order to distinguish between multiple installations of
3610 GCC in the same directory. Hence we must check to see
3611 if appending a directory separator actually makes a
3612 valid directory name. */
3613 if (!IS_DIR_SEPARATOR (arg[len - 1])
3614 && is_directory (arg, false))
3616 char *tmp = XNEWVEC (char, len + 2);
3617 strcpy (tmp, arg);
3618 tmp[len] = DIR_SEPARATOR;
3619 tmp[++len] = 0;
3620 arg = tmp;
3623 add_prefix (&exec_prefixes, arg, NULL,
3624 PREFIX_PRIORITY_B_OPT, 0, 0);
3625 add_prefix (&startfile_prefixes, arg, NULL,
3626 PREFIX_PRIORITY_B_OPT, 0, 0);
3627 add_prefix (&include_prefixes, arg, NULL,
3628 PREFIX_PRIORITY_B_OPT, 0, 0);
3630 validated = true;
3631 break;
3633 case OPT_x:
3634 spec_lang = arg;
3635 if (!strcmp (spec_lang, "none"))
3636 /* Suppress the warning if -xnone comes after the last input
3637 file, because alternate command interfaces like g++ might
3638 find it useful to place -xnone after each input file. */
3639 spec_lang = 0;
3640 else
3641 last_language_n_infiles = n_infiles;
3642 do_save = false;
3643 break;
3645 case OPT_o:
3646 have_o = 1;
3647 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3648 arg = convert_filename (arg, ! have_c, 0);
3649 #endif
3650 /* Save the output name in case -save-temps=obj was used. */
3651 save_temps_prefix = xstrdup (arg);
3652 /* On some systems, ld cannot handle "-o" without a space. So
3653 split the option from its argument. */
3654 save_switch ("-o", 1, &arg, validated, true);
3655 return true;
3657 case OPT_static_libgcc:
3658 case OPT_shared_libgcc:
3659 case OPT_static_libgfortran:
3660 case OPT_static_libstdc__:
3661 /* These are always valid, since gcc.c itself understands the
3662 first two, gfortranspec.c understands -static-libgfortran and
3663 g++spec.c understands -static-libstdc++ */
3664 validated = true;
3665 break;
3667 case OPT_fwpa:
3668 flag_wpa = "";
3669 break;
3671 default:
3672 /* Various driver options need no special processing at this
3673 point, having been handled in a prescan above or being
3674 handled by specs. */
3675 break;
3678 if (do_save)
3679 save_switch (decoded->canonical_option[0],
3680 decoded->canonical_option_num_elements - 1,
3681 &decoded->canonical_option[1], validated, true);
3682 return true;
3685 /* Put the driver's standard set of option handlers in *HANDLERS. */
3687 static void
3688 set_option_handlers (struct cl_option_handlers *handlers)
3690 handlers->unknown_option_callback = driver_unknown_option_callback;
3691 handlers->wrong_lang_callback = driver_wrong_lang_callback;
3692 handlers->num_handlers = 3;
3693 handlers->handlers[0].handler = driver_handle_option;
3694 handlers->handlers[0].mask = CL_DRIVER;
3695 handlers->handlers[1].handler = common_handle_option;
3696 handlers->handlers[1].mask = CL_COMMON;
3697 handlers->handlers[2].handler = target_handle_option;
3698 handlers->handlers[2].mask = CL_TARGET;
3701 /* Create the vector `switches' and its contents.
3702 Store its length in `n_switches'. */
3704 static void
3705 process_command (unsigned int decoded_options_count,
3706 struct cl_decoded_option *decoded_options)
3708 const char *temp;
3709 char *temp1;
3710 char *tooldir_prefix, *tooldir_prefix2;
3711 char *(*get_relative_prefix) (const char *, const char *,
3712 const char *) = NULL;
3713 struct cl_option_handlers handlers;
3714 unsigned int j;
3716 gcc_exec_prefix = getenv ("GCC_EXEC_PREFIX");
3718 n_switches = 0;
3719 n_infiles = 0;
3720 added_libraries = 0;
3722 /* Figure compiler version from version string. */
3724 compiler_version = temp1 = xstrdup (version_string);
3726 for (; *temp1; ++temp1)
3728 if (*temp1 == ' ')
3730 *temp1 = '\0';
3731 break;
3735 /* Handle any -no-canonical-prefixes flag early, to assign the function
3736 that builds relative prefixes. This function creates default search
3737 paths that are needed later in normal option handling. */
3739 for (j = 1; j < decoded_options_count; j++)
3741 if (decoded_options[j].opt_index == OPT_no_canonical_prefixes)
3743 get_relative_prefix = make_relative_prefix_ignore_links;
3744 break;
3747 if (! get_relative_prefix)
3748 get_relative_prefix = make_relative_prefix;
3750 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
3751 see if we can create it from the pathname specified in
3752 decoded_options[0].arg. */
3754 gcc_libexec_prefix = standard_libexec_prefix;
3755 #ifndef VMS
3756 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
3757 if (!gcc_exec_prefix)
3759 gcc_exec_prefix = get_relative_prefix (decoded_options[0].arg,
3760 standard_bindir_prefix,
3761 standard_exec_prefix);
3762 gcc_libexec_prefix = get_relative_prefix (decoded_options[0].arg,
3763 standard_bindir_prefix,
3764 standard_libexec_prefix);
3765 if (gcc_exec_prefix)
3766 xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
3768 else
3770 /* make_relative_prefix requires a program name, but
3771 GCC_EXEC_PREFIX is typically a directory name with a trailing
3772 / (which is ignored by make_relative_prefix), so append a
3773 program name. */
3774 char *tmp_prefix = concat (gcc_exec_prefix, "gcc", NULL);
3775 gcc_libexec_prefix = get_relative_prefix (tmp_prefix,
3776 standard_exec_prefix,
3777 standard_libexec_prefix);
3779 /* The path is unrelocated, so fallback to the original setting. */
3780 if (!gcc_libexec_prefix)
3781 gcc_libexec_prefix = standard_libexec_prefix;
3783 free (tmp_prefix);
3785 #else
3786 #endif
3787 /* From this point onward, gcc_exec_prefix is non-null if the toolchain
3788 is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
3789 or an automatically created GCC_EXEC_PREFIX from
3790 decoded_options[0].arg. */
3792 /* Do language-specific adjustment/addition of flags. */
3793 lang_specific_driver (&decoded_options, &decoded_options_count,
3794 &added_libraries);
3796 if (gcc_exec_prefix)
3798 int len = strlen (gcc_exec_prefix);
3800 if (len > (int) sizeof ("/lib/gcc/") - 1
3801 && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
3803 temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1;
3804 if (IS_DIR_SEPARATOR (*temp)
3805 && filename_ncmp (temp + 1, "lib", 3) == 0
3806 && IS_DIR_SEPARATOR (temp[4])
3807 && filename_ncmp (temp + 5, "gcc", 3) == 0)
3808 len -= sizeof ("/lib/gcc/") - 1;
3811 set_std_prefix (gcc_exec_prefix, len);
3812 add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC",
3813 PREFIX_PRIORITY_LAST, 0, 0);
3814 add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
3815 PREFIX_PRIORITY_LAST, 0, 0);
3818 /* COMPILER_PATH and LIBRARY_PATH have values
3819 that are lists of directory names with colons. */
3821 temp = getenv ("COMPILER_PATH");
3822 if (temp)
3824 const char *startp, *endp;
3825 char *nstore = (char *) alloca (strlen (temp) + 3);
3827 startp = endp = temp;
3828 while (1)
3830 if (*endp == PATH_SEPARATOR || *endp == 0)
3832 strncpy (nstore, startp, endp - startp);
3833 if (endp == startp)
3834 strcpy (nstore, concat (".", dir_separator_str, NULL));
3835 else if (!IS_DIR_SEPARATOR (endp[-1]))
3837 nstore[endp - startp] = DIR_SEPARATOR;
3838 nstore[endp - startp + 1] = 0;
3840 else
3841 nstore[endp - startp] = 0;
3842 add_prefix (&exec_prefixes, nstore, 0,
3843 PREFIX_PRIORITY_LAST, 0, 0);
3844 add_prefix (&include_prefixes, nstore, 0,
3845 PREFIX_PRIORITY_LAST, 0, 0);
3846 if (*endp == 0)
3847 break;
3848 endp = startp = endp + 1;
3850 else
3851 endp++;
3855 temp = getenv (LIBRARY_PATH_ENV);
3856 if (temp && *cross_compile == '0')
3858 const char *startp, *endp;
3859 char *nstore = (char *) alloca (strlen (temp) + 3);
3861 startp = endp = temp;
3862 while (1)
3864 if (*endp == PATH_SEPARATOR || *endp == 0)
3866 strncpy (nstore, startp, endp - startp);
3867 if (endp == startp)
3868 strcpy (nstore, concat (".", dir_separator_str, NULL));
3869 else if (!IS_DIR_SEPARATOR (endp[-1]))
3871 nstore[endp - startp] = DIR_SEPARATOR;
3872 nstore[endp - startp + 1] = 0;
3874 else
3875 nstore[endp - startp] = 0;
3876 add_prefix (&startfile_prefixes, nstore, NULL,
3877 PREFIX_PRIORITY_LAST, 0, 1);
3878 if (*endp == 0)
3879 break;
3880 endp = startp = endp + 1;
3882 else
3883 endp++;
3887 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
3888 temp = getenv ("LPATH");
3889 if (temp && *cross_compile == '0')
3891 const char *startp, *endp;
3892 char *nstore = (char *) alloca (strlen (temp) + 3);
3894 startp = endp = temp;
3895 while (1)
3897 if (*endp == PATH_SEPARATOR || *endp == 0)
3899 strncpy (nstore, startp, endp - startp);
3900 if (endp == startp)
3901 strcpy (nstore, concat (".", dir_separator_str, NULL));
3902 else if (!IS_DIR_SEPARATOR (endp[-1]))
3904 nstore[endp - startp] = DIR_SEPARATOR;
3905 nstore[endp - startp + 1] = 0;
3907 else
3908 nstore[endp - startp] = 0;
3909 add_prefix (&startfile_prefixes, nstore, NULL,
3910 PREFIX_PRIORITY_LAST, 0, 1);
3911 if (*endp == 0)
3912 break;
3913 endp = startp = endp + 1;
3915 else
3916 endp++;
3920 /* Process the options and store input files and switches in their
3921 vectors. */
3923 last_language_n_infiles = -1;
3925 set_option_handlers (&handlers);
3927 for (j = 1; j < decoded_options_count; j++)
3929 switch (decoded_options[j].opt_index)
3931 case OPT_S:
3932 case OPT_c:
3933 case OPT_E:
3934 have_c = 1;
3935 break;
3937 if (have_c)
3938 break;
3941 for (j = 1; j < decoded_options_count; j++)
3943 if (decoded_options[j].opt_index == OPT_SPECIAL_input_file)
3945 const char *arg = decoded_options[j].arg;
3946 const char *p = strrchr (arg, '@');
3947 char *fname;
3948 long offset;
3949 int consumed;
3950 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3951 arg = convert_filename (arg, 0, access (arg, F_OK));
3952 #endif
3953 /* For LTO static archive support we handle input file
3954 specifications that are composed of a filename and
3955 an offset like FNAME@OFFSET. */
3956 if (p
3957 && p != arg
3958 && sscanf (p, "@%li%n", &offset, &consumed) >= 1
3959 && strlen (p) == (unsigned int)consumed)
3961 fname = (char *)xmalloc (p - arg + 1);
3962 memcpy (fname, arg, p - arg);
3963 fname[p - arg] = '\0';
3964 /* Only accept non-stdin and existing FNAME parts, otherwise
3965 try with the full name. */
3966 if (strcmp (fname, "-") == 0 || access (fname, F_OK) < 0)
3968 free (fname);
3969 fname = xstrdup (arg);
3972 else
3973 fname = xstrdup (arg);
3975 if (strcmp (fname, "-") != 0 && access (fname, F_OK) < 0)
3976 perror_with_name (fname);
3977 else
3978 add_infile (arg, spec_lang);
3980 free (fname);
3981 continue;
3984 read_cmdline_option (&global_options, &global_options_set,
3985 decoded_options + j, UNKNOWN_LOCATION,
3986 CL_DRIVER, &handlers, global_dc);
3989 /* If -save-temps=obj and -o name, create the prefix to use for %b.
3990 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
3991 if (save_temps_flag == SAVE_TEMPS_OBJ && save_temps_prefix != NULL)
3993 save_temps_length = strlen (save_temps_prefix);
3994 temp = strrchr (lbasename (save_temps_prefix), '.');
3995 if (temp)
3997 save_temps_length -= strlen (temp);
3998 save_temps_prefix[save_temps_length] = '\0';
4002 else if (save_temps_prefix != NULL)
4004 free (save_temps_prefix);
4005 save_temps_prefix = NULL;
4008 if (save_temps_flag && use_pipes)
4010 /* -save-temps overrides -pipe, so that temp files are produced */
4011 if (save_temps_flag)
4012 warning (0, "-pipe ignored because -save-temps specified");
4013 use_pipes = 0;
4016 if (!compare_debug)
4018 const char *gcd = getenv ("GCC_COMPARE_DEBUG");
4020 if (gcd && gcd[0] == '-')
4022 compare_debug = 2;
4023 compare_debug_opt = gcd;
4025 else if (gcd && *gcd && strcmp (gcd, "0"))
4027 compare_debug = 3;
4028 compare_debug_opt = "-gtoggle";
4031 else if (compare_debug < 0)
4033 compare_debug = 0;
4034 gcc_assert (!compare_debug_opt);
4037 /* Set up the search paths. We add directories that we expect to
4038 contain GNU Toolchain components before directories specified by
4039 the machine description so that we will find GNU components (like
4040 the GNU assembler) before those of the host system. */
4042 /* If we don't know where the toolchain has been installed, use the
4043 configured-in locations. */
4044 if (!gcc_exec_prefix)
4046 #ifndef OS2
4047 add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC",
4048 PREFIX_PRIORITY_LAST, 1, 0);
4049 add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS",
4050 PREFIX_PRIORITY_LAST, 2, 0);
4051 add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
4052 PREFIX_PRIORITY_LAST, 2, 0);
4053 #endif
4054 add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
4055 PREFIX_PRIORITY_LAST, 1, 0);
4058 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix));
4059 tooldir_prefix2 = concat (tooldir_base_prefix, spec_machine,
4060 dir_separator_str, NULL);
4062 /* Look for tools relative to the location from which the driver is
4063 running, or, if that is not available, the configured prefix. */
4064 tooldir_prefix
4065 = concat (gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
4066 spec_machine, dir_separator_str,
4067 spec_version, dir_separator_str, tooldir_prefix2, NULL);
4068 free (tooldir_prefix2);
4070 add_prefix (&exec_prefixes,
4071 concat (tooldir_prefix, "bin", dir_separator_str, NULL),
4072 "BINUTILS", PREFIX_PRIORITY_LAST, 0, 0);
4073 add_prefix (&startfile_prefixes,
4074 concat (tooldir_prefix, "lib", dir_separator_str, NULL),
4075 "BINUTILS", PREFIX_PRIORITY_LAST, 0, 1);
4076 free (tooldir_prefix);
4078 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
4079 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
4080 then consider it to relocate with the rest of the GCC installation
4081 if GCC_EXEC_PREFIX is set.
4082 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
4083 if (target_system_root && !target_system_root_changed && gcc_exec_prefix)
4085 char *tmp_prefix = get_relative_prefix (decoded_options[0].arg,
4086 standard_bindir_prefix,
4087 target_system_root);
4088 if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0)
4090 target_system_root = tmp_prefix;
4091 target_system_root_changed = 1;
4094 #endif
4096 /* More prefixes are enabled in main, after we read the specs file
4097 and determine whether this is cross-compilation or not. */
4099 if (n_infiles == last_language_n_infiles && spec_lang != 0)
4100 warning (0, "%<-x %s%> after last input file has no effect", spec_lang);
4102 /* Synthesize -fcompare-debug flag from the GCC_COMPARE_DEBUG
4103 environment variable. */
4104 if (compare_debug == 2 || compare_debug == 3)
4106 const char *opt = concat ("-fcompare-debug=", compare_debug_opt, NULL);
4107 save_switch (opt, 0, NULL, false, true);
4108 compare_debug = 1;
4111 /* Ensure we only invoke each subprocess once. */
4112 if (print_subprocess_help || print_help_list || print_version)
4114 n_infiles = 0;
4116 /* Create a dummy input file, so that we can pass
4117 the help option on to the various sub-processes. */
4118 add_infile ("help-dummy", "c");
4121 alloc_switch ();
4122 switches[n_switches].part1 = 0;
4123 alloc_infile ();
4124 infiles[n_infiles].name = 0;
4127 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4128 and place that in the environment. */
4130 static void
4131 set_collect_gcc_options (void)
4133 int i;
4134 int first_time;
4136 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4137 the compiler. */
4138 obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
4139 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4141 first_time = TRUE;
4142 for (i = 0; (int) i < n_switches; i++)
4144 const char *const *args;
4145 const char *p, *q;
4146 if (!first_time)
4147 obstack_grow (&collect_obstack, " ", 1);
4149 first_time = FALSE;
4151 /* Ignore elided switches. */
4152 if ((switches[i].live_cond
4153 & (SWITCH_IGNORE | SWITCH_KEEP_FOR_GCC))
4154 == SWITCH_IGNORE)
4155 continue;
4157 obstack_grow (&collect_obstack, "'-", 2);
4158 q = switches[i].part1;
4159 while ((p = strchr (q, '\'')))
4161 obstack_grow (&collect_obstack, q, p - q);
4162 obstack_grow (&collect_obstack, "'\\''", 4);
4163 q = ++p;
4165 obstack_grow (&collect_obstack, q, strlen (q));
4166 obstack_grow (&collect_obstack, "'", 1);
4168 for (args = switches[i].args; args && *args; args++)
4170 obstack_grow (&collect_obstack, " '", 2);
4171 q = *args;
4172 while ((p = strchr (q, '\'')))
4174 obstack_grow (&collect_obstack, q, p - q);
4175 obstack_grow (&collect_obstack, "'\\''", 4);
4176 q = ++p;
4178 obstack_grow (&collect_obstack, q, strlen (q));
4179 obstack_grow (&collect_obstack, "'", 1);
4182 obstack_grow (&collect_obstack, "\0", 1);
4183 xputenv (XOBFINISH (&collect_obstack, char *));
4186 /* Process a spec string, accumulating and running commands. */
4188 /* These variables describe the input file name.
4189 input_file_number is the index on outfiles of this file,
4190 so that the output file name can be stored for later use by %o.
4191 input_basename is the start of the part of the input file
4192 sans all directory names, and basename_length is the number
4193 of characters starting there excluding the suffix .c or whatever. */
4195 static const char *gcc_input_filename;
4196 static int input_file_number;
4197 size_t input_filename_length;
4198 static int basename_length;
4199 static int suffixed_basename_length;
4200 static const char *input_basename;
4201 static const char *input_suffix;
4202 #ifndef HOST_LACKS_INODE_NUMBERS
4203 static struct stat input_stat;
4204 #endif
4205 static int input_stat_set;
4207 /* The compiler used to process the current input file. */
4208 static struct compiler *input_file_compiler;
4210 /* These are variables used within do_spec and do_spec_1. */
4212 /* Nonzero if an arg has been started and not yet terminated
4213 (with space, tab or newline). */
4214 static int arg_going;
4216 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4217 is a temporary file name. */
4218 static int delete_this_arg;
4220 /* Nonzero means %w has been seen; the next arg to be terminated
4221 is the output file name of this compilation. */
4222 static int this_is_output_file;
4224 /* Nonzero means %s has been seen; the next arg to be terminated
4225 is the name of a library file and we should try the standard
4226 search dirs for it. */
4227 static int this_is_library_file;
4229 /* Nonzero means %T has been seen; the next arg to be terminated
4230 is the name of a linker script and we should try all of the
4231 standard search dirs for it. If it is found insert a --script
4232 command line switch and then substitute the full path in place,
4233 otherwise generate an error message. */
4234 static int this_is_linker_script;
4236 /* Nonzero means that the input of this command is coming from a pipe. */
4237 static int input_from_pipe;
4239 /* Nonnull means substitute this for any suffix when outputting a switches
4240 arguments. */
4241 static const char *suffix_subst;
4243 /* If there is an argument being accumulated, terminate it and store it. */
4245 static void
4246 end_going_arg (void)
4248 if (arg_going)
4250 const char *string;
4252 obstack_1grow (&obstack, 0);
4253 string = XOBFINISH (&obstack, const char *);
4254 if (this_is_library_file)
4255 string = find_file (string);
4256 if (this_is_linker_script)
4258 char * full_script_path = find_a_file (&startfile_prefixes, string, R_OK, true);
4260 if (full_script_path == NULL)
4262 error ("unable to locate default linker script %qs in the library search paths", string);
4263 /* Script was not found on search path. */
4264 return;
4266 store_arg ("--script", false, false);
4267 string = full_script_path;
4269 store_arg (string, delete_this_arg, this_is_output_file);
4270 if (this_is_output_file)
4271 outfiles[input_file_number] = string;
4272 arg_going = 0;
4277 /* Parse the WRAPPER string which is a comma separated list of the command line
4278 and insert them into the beginning of argbuf. */
4280 static void
4281 insert_wrapper (const char *wrapper)
4283 int n = 0;
4284 int i;
4285 char *buf = xstrdup (wrapper);
4286 char *p = buf;
4287 unsigned int old_length = argbuf.length ();
4291 n++;
4292 while (*p == ',')
4293 p++;
4295 while ((p = strchr (p, ',')) != NULL);
4297 argbuf.safe_grow (old_length + n);
4298 memmove (argbuf.address () + n,
4299 argbuf.address (),
4300 old_length * sizeof (const_char_p));
4302 i = 0;
4303 p = buf;
4306 while (*p == ',')
4308 *p = 0;
4309 p++;
4311 argbuf[i] = p;
4312 i++;
4314 while ((p = strchr (p, ',')) != NULL);
4315 gcc_assert (i == n);
4318 /* Process the spec SPEC and run the commands specified therein.
4319 Returns 0 if the spec is successfully processed; -1 if failed. */
4322 do_spec (const char *spec)
4324 int value;
4326 value = do_spec_2 (spec);
4328 /* Force out any unfinished command.
4329 If -pipe, this forces out the last command if it ended in `|'. */
4330 if (value == 0)
4332 if (argbuf.length () > 0
4333 && !strcmp (argbuf.last (), "|"))
4334 argbuf.pop ();
4336 set_collect_gcc_options ();
4338 if (argbuf.length () > 0)
4339 value = execute ();
4342 return value;
4345 static int
4346 do_spec_2 (const char *spec)
4348 int result;
4350 clear_args ();
4351 arg_going = 0;
4352 delete_this_arg = 0;
4353 this_is_output_file = 0;
4354 this_is_library_file = 0;
4355 this_is_linker_script = 0;
4356 input_from_pipe = 0;
4357 suffix_subst = NULL;
4359 result = do_spec_1 (spec, 0, NULL);
4361 end_going_arg ();
4363 return result;
4367 /* Process the given spec string and add any new options to the end
4368 of the switches/n_switches array. */
4370 static void
4371 do_option_spec (const char *name, const char *spec)
4373 unsigned int i, value_count, value_len;
4374 const char *p, *q, *value;
4375 char *tmp_spec, *tmp_spec_p;
4377 if (configure_default_options[0].name == NULL)
4378 return;
4380 for (i = 0; i < ARRAY_SIZE (configure_default_options); i++)
4381 if (strcmp (configure_default_options[i].name, name) == 0)
4382 break;
4383 if (i == ARRAY_SIZE (configure_default_options))
4384 return;
4386 value = configure_default_options[i].value;
4387 value_len = strlen (value);
4389 /* Compute the size of the final spec. */
4390 value_count = 0;
4391 p = spec;
4392 while ((p = strstr (p, "%(VALUE)")) != NULL)
4394 p ++;
4395 value_count ++;
4398 /* Replace each %(VALUE) by the specified value. */
4399 tmp_spec = (char *) alloca (strlen (spec) + 1
4400 + value_count * (value_len - strlen ("%(VALUE)")));
4401 tmp_spec_p = tmp_spec;
4402 q = spec;
4403 while ((p = strstr (q, "%(VALUE)")) != NULL)
4405 memcpy (tmp_spec_p, q, p - q);
4406 tmp_spec_p = tmp_spec_p + (p - q);
4407 memcpy (tmp_spec_p, value, value_len);
4408 tmp_spec_p += value_len;
4409 q = p + strlen ("%(VALUE)");
4411 strcpy (tmp_spec_p, q);
4413 do_self_spec (tmp_spec);
4416 /* Process the given spec string and add any new options to the end
4417 of the switches/n_switches array. */
4419 static void
4420 do_self_spec (const char *spec)
4422 int i;
4424 do_spec_2 (spec);
4425 do_spec_1 (" ", 0, NULL);
4427 /* Mark %<S switches processed by do_self_spec to be ignored permanently.
4428 do_self_specs adds the replacements to switches array, so it shouldn't
4429 be processed afterwards. */
4430 for (i = 0; i < n_switches; i++)
4431 if ((switches[i].live_cond & SWITCH_IGNORE))
4432 switches[i].live_cond |= SWITCH_IGNORE_PERMANENTLY;
4434 if (argbuf.length () > 0)
4436 const char **argbuf_copy;
4437 struct cl_decoded_option *decoded_options;
4438 struct cl_option_handlers handlers;
4439 unsigned int decoded_options_count;
4440 unsigned int j;
4442 /* Create a copy of argbuf with a dummy argv[0] entry for
4443 decode_cmdline_options_to_array. */
4444 argbuf_copy = XNEWVEC (const char *,
4445 argbuf.length () + 1);
4446 argbuf_copy[0] = "";
4447 memcpy (argbuf_copy + 1, argbuf.address (),
4448 argbuf.length () * sizeof (const char *));
4450 decode_cmdline_options_to_array (argbuf.length () + 1,
4451 argbuf_copy,
4452 CL_DRIVER, &decoded_options,
4453 &decoded_options_count);
4454 free (argbuf_copy);
4456 set_option_handlers (&handlers);
4458 for (j = 1; j < decoded_options_count; j++)
4460 switch (decoded_options[j].opt_index)
4462 case OPT_SPECIAL_input_file:
4463 /* Specs should only generate options, not input
4464 files. */
4465 if (strcmp (decoded_options[j].arg, "-") != 0)
4466 fatal_error ("switch %qs does not start with %<-%>",
4467 decoded_options[j].arg);
4468 else
4469 fatal_error ("spec-generated switch is just %<-%>");
4470 break;
4472 case OPT_fcompare_debug_second:
4473 case OPT_fcompare_debug:
4474 case OPT_fcompare_debug_:
4475 case OPT_o:
4476 /* Avoid duplicate processing of some options from
4477 compare-debug specs; just save them here. */
4478 save_switch (decoded_options[j].canonical_option[0],
4479 (decoded_options[j].canonical_option_num_elements
4480 - 1),
4481 &decoded_options[j].canonical_option[1], false, true);
4482 break;
4484 default:
4485 read_cmdline_option (&global_options, &global_options_set,
4486 decoded_options + j, UNKNOWN_LOCATION,
4487 CL_DRIVER, &handlers, global_dc);
4488 break;
4492 alloc_switch ();
4493 switches[n_switches].part1 = 0;
4497 /* Callback for processing %D and %I specs. */
4499 struct spec_path_info {
4500 const char *option;
4501 const char *append;
4502 size_t append_len;
4503 bool omit_relative;
4504 bool separate_options;
4507 static void *
4508 spec_path (char *path, void *data)
4510 struct spec_path_info *info = (struct spec_path_info *) data;
4511 size_t len = 0;
4512 char save = 0;
4514 if (info->omit_relative && !IS_ABSOLUTE_PATH (path))
4515 return NULL;
4517 if (info->append_len != 0)
4519 len = strlen (path);
4520 memcpy (path + len, info->append, info->append_len + 1);
4523 if (!is_directory (path, true))
4524 return NULL;
4526 do_spec_1 (info->option, 1, NULL);
4527 if (info->separate_options)
4528 do_spec_1 (" ", 0, NULL);
4530 if (info->append_len == 0)
4532 len = strlen (path);
4533 save = path[len - 1];
4534 if (IS_DIR_SEPARATOR (path[len - 1]))
4535 path[len - 1] = '\0';
4538 do_spec_1 (path, 1, NULL);
4539 do_spec_1 (" ", 0, NULL);
4541 /* Must not damage the original path. */
4542 if (info->append_len == 0)
4543 path[len - 1] = save;
4545 return NULL;
4548 /* Create a temporary FILE with the contents of ARGV. Add @FILE to the
4549 argument list. */
4551 static void
4552 create_at_file (char **argv)
4554 char *temp_file = make_temp_file ("");
4555 char *at_argument = concat ("@", temp_file, NULL);
4556 FILE *f = fopen (temp_file, "w");
4557 int status;
4559 if (f == NULL)
4560 fatal_error ("could not open temporary response file %s",
4561 temp_file);
4563 status = writeargv (argv, f);
4565 if (status)
4566 fatal_error ("could not write to temporary response file %s",
4567 temp_file);
4569 status = fclose (f);
4571 if (EOF == status)
4572 fatal_error ("could not close temporary response file %s",
4573 temp_file);
4575 store_arg (at_argument, 0, 0);
4577 record_temp_file (temp_file, !save_temps_flag, !save_temps_flag);
4580 /* True if we should compile INFILE. */
4582 static bool
4583 compile_input_file_p (struct infile *infile)
4585 if ((!infile->language) || (infile->language[0] != '*'))
4586 if (infile->incompiler == input_file_compiler)
4587 return true;
4588 return false;
4591 /* Process each member of VEC as a spec. */
4593 static void
4594 do_specs_vec (vec<char_p> vec)
4596 unsigned ix;
4597 char *opt;
4599 FOR_EACH_VEC_ELT (vec, ix, opt)
4601 do_spec_1 (opt, 1, NULL);
4602 /* Make each accumulated option a separate argument. */
4603 do_spec_1 (" ", 0, NULL);
4607 /* Process the sub-spec SPEC as a portion of a larger spec.
4608 This is like processing a whole spec except that we do
4609 not initialize at the beginning and we do not supply a
4610 newline by default at the end.
4611 INSWITCH nonzero means don't process %-sequences in SPEC;
4612 in this case, % is treated as an ordinary character.
4613 This is used while substituting switches.
4614 INSWITCH nonzero also causes SPC not to terminate an argument.
4616 Value is zero unless a line was finished
4617 and the command on that line reported an error. */
4619 static int
4620 do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
4622 const char *p = spec;
4623 int c;
4624 int i;
4625 int value;
4627 /* If it's an empty string argument to a switch, keep it as is. */
4628 if (inswitch && !*p)
4629 arg_going = 1;
4631 while ((c = *p++))
4632 /* If substituting a switch, treat all chars like letters.
4633 Otherwise, NL, SPC, TAB and % are special. */
4634 switch (inswitch ? 'a' : c)
4636 case '\n':
4637 end_going_arg ();
4639 if (argbuf.length () > 0
4640 && !strcmp (argbuf.last (), "|"))
4642 /* A `|' before the newline means use a pipe here,
4643 but only if -pipe was specified.
4644 Otherwise, execute now and don't pass the `|' as an arg. */
4645 if (use_pipes)
4647 input_from_pipe = 1;
4648 break;
4650 else
4651 argbuf.pop ();
4654 set_collect_gcc_options ();
4656 if (argbuf.length () > 0)
4658 value = execute ();
4659 if (value)
4660 return value;
4662 /* Reinitialize for a new command, and for a new argument. */
4663 clear_args ();
4664 arg_going = 0;
4665 delete_this_arg = 0;
4666 this_is_output_file = 0;
4667 this_is_library_file = 0;
4668 this_is_linker_script = 0;
4669 input_from_pipe = 0;
4670 break;
4672 case '|':
4673 end_going_arg ();
4675 /* Use pipe */
4676 obstack_1grow (&obstack, c);
4677 arg_going = 1;
4678 break;
4680 case '\t':
4681 case ' ':
4682 end_going_arg ();
4684 /* Reinitialize for a new argument. */
4685 delete_this_arg = 0;
4686 this_is_output_file = 0;
4687 this_is_library_file = 0;
4688 this_is_linker_script = 0;
4689 break;
4691 case '%':
4692 switch (c = *p++)
4694 case 0:
4695 fatal_error ("spec %qs invalid", spec);
4697 case 'b':
4698 if (save_temps_length)
4699 obstack_grow (&obstack, save_temps_prefix, save_temps_length);
4700 else
4701 obstack_grow (&obstack, input_basename, basename_length);
4702 if (compare_debug < 0)
4703 obstack_grow (&obstack, ".gk", 3);
4704 arg_going = 1;
4705 break;
4707 case 'B':
4708 if (save_temps_length)
4709 obstack_grow (&obstack, save_temps_prefix, save_temps_length);
4710 else
4711 obstack_grow (&obstack, input_basename, suffixed_basename_length);
4712 if (compare_debug < 0)
4713 obstack_grow (&obstack, ".gk", 3);
4714 arg_going = 1;
4715 break;
4717 case 'd':
4718 delete_this_arg = 2;
4719 break;
4721 /* Dump out the directories specified with LIBRARY_PATH,
4722 followed by the absolute directories
4723 that we search for startfiles. */
4724 case 'D':
4726 struct spec_path_info info;
4728 info.option = "-L";
4729 info.append_len = 0;
4730 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
4731 /* Used on systems which record the specified -L dirs
4732 and use them to search for dynamic linking.
4733 Relative directories always come from -B,
4734 and it is better not to use them for searching
4735 at run time. In particular, stage1 loses. */
4736 info.omit_relative = true;
4737 #else
4738 info.omit_relative = false;
4739 #endif
4740 info.separate_options = false;
4742 for_each_path (&startfile_prefixes, true, 0, spec_path, &info);
4744 break;
4746 case 'e':
4747 /* %efoo means report an error with `foo' as error message
4748 and don't execute any more commands for this file. */
4750 const char *q = p;
4751 char *buf;
4752 while (*p != 0 && *p != '\n')
4753 p++;
4754 buf = (char *) alloca (p - q + 1);
4755 strncpy (buf, q, p - q);
4756 buf[p - q] = 0;
4757 error ("%s", _(buf));
4758 return -1;
4760 break;
4761 case 'n':
4762 /* %nfoo means report a notice with `foo' on stderr. */
4764 const char *q = p;
4765 char *buf;
4766 while (*p != 0 && *p != '\n')
4767 p++;
4768 buf = (char *) alloca (p - q + 1);
4769 strncpy (buf, q, p - q);
4770 buf[p - q] = 0;
4771 inform (0, "%s", _(buf));
4772 if (*p)
4773 p++;
4775 break;
4777 case 'j':
4779 struct stat st;
4781 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
4782 defined, and it is not a directory, and it is
4783 writable, use it. Otherwise, treat this like any
4784 other temporary file. */
4786 if ((!save_temps_flag)
4787 && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode))
4788 && (access (HOST_BIT_BUCKET, W_OK) == 0))
4790 obstack_grow (&obstack, HOST_BIT_BUCKET,
4791 strlen (HOST_BIT_BUCKET));
4792 delete_this_arg = 0;
4793 arg_going = 1;
4794 break;
4797 goto create_temp_file;
4798 case '|':
4799 if (use_pipes)
4801 obstack_1grow (&obstack, '-');
4802 delete_this_arg = 0;
4803 arg_going = 1;
4805 /* consume suffix */
4806 while (*p == '.' || ISALNUM ((unsigned char) *p))
4807 p++;
4808 if (p[0] == '%' && p[1] == 'O')
4809 p += 2;
4811 break;
4813 goto create_temp_file;
4814 case 'm':
4815 if (use_pipes)
4817 /* consume suffix */
4818 while (*p == '.' || ISALNUM ((unsigned char) *p))
4819 p++;
4820 if (p[0] == '%' && p[1] == 'O')
4821 p += 2;
4823 break;
4825 goto create_temp_file;
4826 case 'g':
4827 case 'u':
4828 case 'U':
4829 create_temp_file:
4831 struct temp_name *t;
4832 int suffix_length;
4833 const char *suffix = p;
4834 char *saved_suffix = NULL;
4836 while (*p == '.' || ISALNUM ((unsigned char) *p))
4837 p++;
4838 suffix_length = p - suffix;
4839 if (p[0] == '%' && p[1] == 'O')
4841 p += 2;
4842 /* We don't support extra suffix characters after %O. */
4843 if (*p == '.' || ISALNUM ((unsigned char) *p))
4844 fatal_error ("spec %qs has invalid %<%%0%c%>", spec, *p);
4845 if (suffix_length == 0)
4846 suffix = TARGET_OBJECT_SUFFIX;
4847 else
4849 saved_suffix
4850 = XNEWVEC (char, suffix_length
4851 + strlen (TARGET_OBJECT_SUFFIX));
4852 strncpy (saved_suffix, suffix, suffix_length);
4853 strcpy (saved_suffix + suffix_length,
4854 TARGET_OBJECT_SUFFIX);
4856 suffix_length += strlen (TARGET_OBJECT_SUFFIX);
4859 if (compare_debug < 0)
4861 suffix = concat (".gk", suffix, NULL);
4862 suffix_length += 3;
4865 /* If -save-temps=obj and -o were specified, use that for the
4866 temp file. */
4867 if (save_temps_length)
4869 char *tmp;
4870 temp_filename_length
4871 = save_temps_length + suffix_length + 1;
4872 tmp = (char *) alloca (temp_filename_length);
4873 memcpy (tmp, save_temps_prefix, save_temps_length);
4874 memcpy (tmp + save_temps_length, suffix, suffix_length);
4875 tmp[save_temps_length + suffix_length] = '\0';
4876 temp_filename = save_string (tmp, save_temps_length
4877 + suffix_length);
4878 obstack_grow (&obstack, temp_filename,
4879 temp_filename_length);
4880 arg_going = 1;
4881 delete_this_arg = 0;
4882 break;
4885 /* If the gcc_input_filename has the same suffix specified
4886 for the %g, %u, or %U, and -save-temps is specified,
4887 we could end up using that file as an intermediate
4888 thus clobbering the user's source file (.e.g.,
4889 gcc -save-temps foo.s would clobber foo.s with the
4890 output of cpp0). So check for this condition and
4891 generate a temp file as the intermediate. */
4893 if (save_temps_flag)
4895 char *tmp;
4896 temp_filename_length = basename_length + suffix_length + 1;
4897 tmp = (char *) alloca (temp_filename_length);
4898 memcpy (tmp, input_basename, basename_length);
4899 memcpy (tmp + basename_length, suffix, suffix_length);
4900 tmp[basename_length + suffix_length] = '\0';
4901 temp_filename = tmp;
4903 if (filename_cmp (temp_filename, gcc_input_filename) != 0)
4905 #ifndef HOST_LACKS_INODE_NUMBERS
4906 struct stat st_temp;
4908 /* Note, set_input() resets input_stat_set to 0. */
4909 if (input_stat_set == 0)
4911 input_stat_set = stat (gcc_input_filename,
4912 &input_stat);
4913 if (input_stat_set >= 0)
4914 input_stat_set = 1;
4917 /* If we have the stat for the gcc_input_filename
4918 and we can do the stat for the temp_filename
4919 then the they could still refer to the same
4920 file if st_dev/st_ino's are the same. */
4921 if (input_stat_set != 1
4922 || stat (temp_filename, &st_temp) < 0
4923 || input_stat.st_dev != st_temp.st_dev
4924 || input_stat.st_ino != st_temp.st_ino)
4925 #else
4926 /* Just compare canonical pathnames. */
4927 char* input_realname = lrealpath (gcc_input_filename);
4928 char* temp_realname = lrealpath (temp_filename);
4929 bool files_differ = filename_cmp (input_realname, temp_realname);
4930 free (input_realname);
4931 free (temp_realname);
4932 if (files_differ)
4933 #endif
4935 temp_filename = save_string (temp_filename,
4936 temp_filename_length + 1);
4937 obstack_grow (&obstack, temp_filename,
4938 temp_filename_length);
4939 arg_going = 1;
4940 delete_this_arg = 0;
4941 break;
4946 /* See if we already have an association of %g/%u/%U and
4947 suffix. */
4948 for (t = temp_names; t; t = t->next)
4949 if (t->length == suffix_length
4950 && strncmp (t->suffix, suffix, suffix_length) == 0
4951 && t->unique == (c == 'u' || c == 'U' || c == 'j'))
4952 break;
4954 /* Make a new association if needed. %u and %j
4955 require one. */
4956 if (t == 0 || c == 'u' || c == 'j')
4958 if (t == 0)
4960 t = XNEW (struct temp_name);
4961 t->next = temp_names;
4962 temp_names = t;
4964 t->length = suffix_length;
4965 if (saved_suffix)
4967 t->suffix = saved_suffix;
4968 saved_suffix = NULL;
4970 else
4971 t->suffix = save_string (suffix, suffix_length);
4972 t->unique = (c == 'u' || c == 'U' || c == 'j');
4973 temp_filename = make_temp_file (t->suffix);
4974 temp_filename_length = strlen (temp_filename);
4975 t->filename = temp_filename;
4976 t->filename_length = temp_filename_length;
4979 free (saved_suffix);
4981 obstack_grow (&obstack, t->filename, t->filename_length);
4982 delete_this_arg = 1;
4984 arg_going = 1;
4985 break;
4987 case 'i':
4988 if (combine_inputs)
4990 if (at_file_supplied)
4992 /* We are going to expand `%i' to `@FILE', where FILE
4993 is a newly-created temporary filename. The filenames
4994 that would usually be expanded in place of %o will be
4995 written to the temporary file. */
4996 char **argv;
4997 int n_files = 0;
4998 int j;
5000 for (i = 0; i < n_infiles; i++)
5001 if (compile_input_file_p (&infiles[i]))
5002 n_files++;
5004 argv = (char **) alloca (sizeof (char *) * (n_files + 1));
5006 /* Copy the strings over. */
5007 for (i = 0, j = 0; i < n_infiles; i++)
5008 if (compile_input_file_p (&infiles[i]))
5010 argv[j] = CONST_CAST (char *, infiles[i].name);
5011 infiles[i].compiled = true;
5012 j++;
5014 argv[j] = NULL;
5016 create_at_file (argv);
5018 else
5019 for (i = 0; (int) i < n_infiles; i++)
5020 if (compile_input_file_p (&infiles[i]))
5022 store_arg (infiles[i].name, 0, 0);
5023 infiles[i].compiled = true;
5026 else
5028 obstack_grow (&obstack, gcc_input_filename,
5029 input_filename_length);
5030 arg_going = 1;
5032 break;
5034 case 'I':
5036 struct spec_path_info info;
5038 if (multilib_dir)
5040 do_spec_1 ("-imultilib", 1, NULL);
5041 /* Make this a separate argument. */
5042 do_spec_1 (" ", 0, NULL);
5043 do_spec_1 (multilib_dir, 1, NULL);
5044 do_spec_1 (" ", 0, NULL);
5047 if (multiarch_dir)
5049 do_spec_1 ("-imultiarch", 1, NULL);
5050 /* Make this a separate argument. */
5051 do_spec_1 (" ", 0, NULL);
5052 do_spec_1 (multiarch_dir, 1, NULL);
5053 do_spec_1 (" ", 0, NULL);
5056 if (gcc_exec_prefix)
5058 do_spec_1 ("-iprefix", 1, NULL);
5059 /* Make this a separate argument. */
5060 do_spec_1 (" ", 0, NULL);
5061 do_spec_1 (gcc_exec_prefix, 1, NULL);
5062 do_spec_1 (" ", 0, NULL);
5065 if (target_system_root_changed ||
5066 (target_system_root && target_sysroot_hdrs_suffix))
5068 do_spec_1 ("-isysroot", 1, NULL);
5069 /* Make this a separate argument. */
5070 do_spec_1 (" ", 0, NULL);
5071 do_spec_1 (target_system_root, 1, NULL);
5072 if (target_sysroot_hdrs_suffix)
5073 do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL);
5074 do_spec_1 (" ", 0, NULL);
5077 info.option = "-isystem";
5078 info.append = "include";
5079 info.append_len = strlen (info.append);
5080 info.omit_relative = false;
5081 info.separate_options = true;
5083 for_each_path (&include_prefixes, false, info.append_len,
5084 spec_path, &info);
5086 info.append = "include-fixed";
5087 if (*sysroot_hdrs_suffix_spec)
5088 info.append = concat (info.append, dir_separator_str,
5089 multilib_dir, NULL);
5090 info.append_len = strlen (info.append);
5091 for_each_path (&include_prefixes, false, info.append_len,
5092 spec_path, &info);
5094 break;
5096 case 'o':
5098 int max = n_infiles;
5099 max += lang_specific_extra_outfiles;
5101 if (HAVE_GNU_LD && at_file_supplied)
5103 /* We are going to expand `%o' to `@FILE', where FILE
5104 is a newly-created temporary filename. The filenames
5105 that would usually be expanded in place of %o will be
5106 written to the temporary file. */
5108 char **argv;
5109 int n_files, j;
5111 /* Convert OUTFILES into a form suitable for writeargv. */
5113 /* Determine how many are non-NULL. */
5114 for (n_files = 0, i = 0; i < max; i++)
5115 n_files += outfiles[i] != NULL;
5117 argv = (char **) alloca (sizeof (char *) * (n_files + 1));
5119 /* Copy the strings over. */
5120 for (i = 0, j = 0; i < max; i++)
5121 if (outfiles[i])
5123 argv[j] = CONST_CAST (char *, outfiles[i]);
5124 j++;
5126 argv[j] = NULL;
5128 create_at_file (argv);
5130 else
5131 for (i = 0; i < max; i++)
5132 if (outfiles[i])
5133 store_arg (outfiles[i], 0, 0);
5134 break;
5137 case 'O':
5138 obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
5139 arg_going = 1;
5140 break;
5142 case 's':
5143 this_is_library_file = 1;
5144 break;
5146 case 'T':
5147 this_is_linker_script = 1;
5148 break;
5150 case 'V':
5151 outfiles[input_file_number] = NULL;
5152 break;
5154 case 'w':
5155 this_is_output_file = 1;
5156 break;
5158 case 'W':
5160 unsigned int cur_index = argbuf.length ();
5161 /* Handle the {...} following the %W. */
5162 if (*p != '{')
5163 fatal_error ("spec %qs has invalid %<%%W%c%>", spec, *p);
5164 p = handle_braces (p + 1);
5165 if (p == 0)
5166 return -1;
5167 end_going_arg ();
5168 /* If any args were output, mark the last one for deletion
5169 on failure. */
5170 if (argbuf.length () != cur_index)
5171 record_temp_file (argbuf.last (), 0, 1);
5172 break;
5175 /* %x{OPTION} records OPTION for %X to output. */
5176 case 'x':
5178 const char *p1 = p;
5179 char *string;
5180 char *opt;
5181 unsigned ix;
5183 /* Skip past the option value and make a copy. */
5184 if (*p != '{')
5185 fatal_error ("spec %qs has invalid %<%%x%c%>", spec, *p);
5186 while (*p++ != '}')
5188 string = save_string (p1 + 1, p - p1 - 2);
5190 /* See if we already recorded this option. */
5191 FOR_EACH_VEC_ELT (linker_options, ix, opt)
5192 if (! strcmp (string, opt))
5194 free (string);
5195 return 0;
5198 /* This option is new; add it. */
5199 add_linker_option (string, strlen (string));
5200 free (string);
5202 break;
5204 /* Dump out the options accumulated previously using %x. */
5205 case 'X':
5206 do_specs_vec (linker_options);
5207 break;
5209 /* Dump out the options accumulated previously using -Wa,. */
5210 case 'Y':
5211 do_specs_vec (assembler_options);
5212 break;
5214 /* Dump out the options accumulated previously using -Wp,. */
5215 case 'Z':
5216 do_specs_vec (preprocessor_options);
5217 break;
5219 /* Here are digits and numbers that just process
5220 a certain constant string as a spec. */
5222 case '1':
5223 value = do_spec_1 (cc1_spec, 0, NULL);
5224 if (value != 0)
5225 return value;
5226 break;
5228 case '2':
5229 value = do_spec_1 (cc1plus_spec, 0, NULL);
5230 if (value != 0)
5231 return value;
5232 break;
5234 case 'a':
5235 value = do_spec_1 (asm_spec, 0, NULL);
5236 if (value != 0)
5237 return value;
5238 break;
5240 case 'A':
5241 value = do_spec_1 (asm_final_spec, 0, NULL);
5242 if (value != 0)
5243 return value;
5244 break;
5246 case 'C':
5248 const char *const spec
5249 = (input_file_compiler->cpp_spec
5250 ? input_file_compiler->cpp_spec
5251 : cpp_spec);
5252 value = do_spec_1 (spec, 0, NULL);
5253 if (value != 0)
5254 return value;
5256 break;
5258 case 'E':
5259 value = do_spec_1 (endfile_spec, 0, NULL);
5260 if (value != 0)
5261 return value;
5262 break;
5264 case 'l':
5265 value = do_spec_1 (link_spec, 0, NULL);
5266 if (value != 0)
5267 return value;
5268 break;
5270 case 'L':
5271 value = do_spec_1 (lib_spec, 0, NULL);
5272 if (value != 0)
5273 return value;
5274 break;
5276 case 'M':
5277 if (multilib_os_dir == NULL)
5278 obstack_1grow (&obstack, '.');
5279 else
5280 obstack_grow (&obstack, multilib_os_dir,
5281 strlen (multilib_os_dir));
5282 break;
5284 case 'G':
5285 value = do_spec_1 (libgcc_spec, 0, NULL);
5286 if (value != 0)
5287 return value;
5288 break;
5290 case 'R':
5291 /* We assume there is a directory
5292 separator at the end of this string. */
5293 if (target_system_root)
5295 obstack_grow (&obstack, target_system_root,
5296 strlen (target_system_root));
5297 if (target_sysroot_suffix)
5298 obstack_grow (&obstack, target_sysroot_suffix,
5299 strlen (target_sysroot_suffix));
5301 break;
5303 case 'S':
5304 value = do_spec_1 (startfile_spec, 0, NULL);
5305 if (value != 0)
5306 return value;
5307 break;
5309 /* Here we define characters other than letters and digits. */
5311 case '{':
5312 p = handle_braces (p);
5313 if (p == 0)
5314 return -1;
5315 break;
5317 case ':':
5318 p = handle_spec_function (p, NULL);
5319 if (p == 0)
5320 return -1;
5321 break;
5323 case '%':
5324 obstack_1grow (&obstack, '%');
5325 break;
5327 case '.':
5329 unsigned len = 0;
5331 while (p[len] && p[len] != ' ' && p[len] != '%')
5332 len++;
5333 suffix_subst = save_string (p - 1, len + 1);
5334 p += len;
5336 break;
5338 /* Henceforth ignore the option(s) matching the pattern
5339 after the %<. */
5340 case '<':
5341 case '>':
5343 unsigned len = 0;
5344 int have_wildcard = 0;
5345 int i;
5346 int switch_option;
5348 if (c == '>')
5349 switch_option = SWITCH_IGNORE | SWITCH_KEEP_FOR_GCC;
5350 else
5351 switch_option = SWITCH_IGNORE;
5353 while (p[len] && p[len] != ' ' && p[len] != '\t')
5354 len++;
5356 if (p[len-1] == '*')
5357 have_wildcard = 1;
5359 for (i = 0; i < n_switches; i++)
5360 if (!strncmp (switches[i].part1, p, len - have_wildcard)
5361 && (have_wildcard || switches[i].part1[len] == '\0'))
5363 switches[i].live_cond |= switch_option;
5364 /* User switch be validated from validate_all_switches.
5365 when the definition is seen from the spec file.
5366 If not defined anywhere, will be rejected. */
5367 if (switches[i].known)
5368 switches[i].validated = true;
5371 p += len;
5373 break;
5375 case '*':
5376 if (soft_matched_part)
5378 if (soft_matched_part[0])
5379 do_spec_1 (soft_matched_part, 1, NULL);
5380 /* Only insert a space after the substitution if it is at the
5381 end of the current sequence. So if:
5383 "%{foo=*:bar%*}%{foo=*:one%*two}"
5385 matches -foo=hello then it will produce:
5387 barhello onehellotwo
5389 if (*p == 0 || *p == '}')
5390 do_spec_1 (" ", 0, NULL);
5392 else
5393 /* Catch the case where a spec string contains something like
5394 '%{foo:%*}'. i.e. there is no * in the pattern on the left
5395 hand side of the :. */
5396 error ("spec failure: %<%%*%> has not been initialized by pattern match");
5397 break;
5399 /* Process a string found as the value of a spec given by name.
5400 This feature allows individual machine descriptions
5401 to add and use their own specs. */
5402 case '(':
5404 const char *name = p;
5405 struct spec_list *sl;
5406 int len;
5408 /* The string after the S/P is the name of a spec that is to be
5409 processed. */
5410 while (*p && *p != ')')
5411 p++;
5413 /* See if it's in the list. */
5414 for (len = p - name, sl = specs; sl; sl = sl->next)
5415 if (sl->name_len == len && !strncmp (sl->name, name, len))
5417 name = *(sl->ptr_spec);
5418 #ifdef DEBUG_SPECS
5419 fnotice (stderr, "Processing spec (%s), which is '%s'\n",
5420 sl->name, name);
5421 #endif
5422 break;
5425 if (sl)
5427 value = do_spec_1 (name, 0, NULL);
5428 if (value != 0)
5429 return value;
5432 /* Discard the closing paren. */
5433 if (*p)
5434 p++;
5436 break;
5438 default:
5439 error ("spec failure: unrecognized spec option %qc", c);
5440 break;
5442 break;
5444 case '\\':
5445 /* Backslash: treat next character as ordinary. */
5446 c = *p++;
5448 /* Fall through. */
5449 default:
5450 /* Ordinary character: put it into the current argument. */
5451 obstack_1grow (&obstack, c);
5452 arg_going = 1;
5455 /* End of string. If we are processing a spec function, we need to
5456 end any pending argument. */
5457 if (processing_spec_function)
5458 end_going_arg ();
5460 return 0;
5463 /* Look up a spec function. */
5465 static const struct spec_function *
5466 lookup_spec_function (const char *name)
5468 const struct spec_function *sf;
5470 for (sf = static_spec_functions; sf->name != NULL; sf++)
5471 if (strcmp (sf->name, name) == 0)
5472 return sf;
5474 return NULL;
5477 /* Evaluate a spec function. */
5479 static const char *
5480 eval_spec_function (const char *func, const char *args)
5482 const struct spec_function *sf;
5483 const char *funcval;
5485 /* Saved spec processing context. */
5486 vec<const_char_p> save_argbuf;
5488 int save_arg_going;
5489 int save_delete_this_arg;
5490 int save_this_is_output_file;
5491 int save_this_is_library_file;
5492 int save_input_from_pipe;
5493 int save_this_is_linker_script;
5494 const char *save_suffix_subst;
5496 int save_growing_size;
5497 void *save_growing_value = NULL;
5499 sf = lookup_spec_function (func);
5500 if (sf == NULL)
5501 fatal_error ("unknown spec function %qs", func);
5503 /* Push the spec processing context. */
5504 save_argbuf = argbuf;
5506 save_arg_going = arg_going;
5507 save_delete_this_arg = delete_this_arg;
5508 save_this_is_output_file = this_is_output_file;
5509 save_this_is_library_file = this_is_library_file;
5510 save_this_is_linker_script = this_is_linker_script;
5511 save_input_from_pipe = input_from_pipe;
5512 save_suffix_subst = suffix_subst;
5514 /* If we have some object growing now, finalize it so the args and function
5515 eval proceed from a cleared context. This is needed to prevent the first
5516 constructed arg from mistakenly including the growing value. We'll push
5517 this value back on the obstack once the function evaluation is done, to
5518 restore a consistent processing context for our caller. This is fine as
5519 the address of growing objects isn't guaranteed to remain stable until
5520 they are finalized, and we expect this situation to be rare enough for
5521 the extra copy not to be an issue. */
5522 save_growing_size = obstack_object_size (&obstack);
5523 if (save_growing_size > 0)
5524 save_growing_value = obstack_finish (&obstack);
5526 /* Create a new spec processing context, and build the function
5527 arguments. */
5529 alloc_args ();
5530 if (do_spec_2 (args) < 0)
5531 fatal_error ("error in args to spec function %qs", func);
5533 /* argbuf_index is an index for the next argument to be inserted, and
5534 so contains the count of the args already inserted. */
5536 funcval = (*sf->func) (argbuf.length (),
5537 argbuf.address ());
5539 /* Pop the spec processing context. */
5540 argbuf.release ();
5541 argbuf = save_argbuf;
5543 arg_going = save_arg_going;
5544 delete_this_arg = save_delete_this_arg;
5545 this_is_output_file = save_this_is_output_file;
5546 this_is_library_file = save_this_is_library_file;
5547 this_is_linker_script = save_this_is_linker_script;
5548 input_from_pipe = save_input_from_pipe;
5549 suffix_subst = save_suffix_subst;
5551 if (save_growing_size > 0)
5552 obstack_grow (&obstack, save_growing_value, save_growing_size);
5554 return funcval;
5557 /* Handle a spec function call of the form:
5559 %:function(args)
5561 ARGS is processed as a spec in a separate context and split into an
5562 argument vector in the normal fashion. The function returns a string
5563 containing a spec which we then process in the caller's context, or
5564 NULL if no processing is required.
5566 If RETVAL_NONNULL is not NULL, then store a bool whether function
5567 returned non-NULL. */
5569 static const char *
5570 handle_spec_function (const char *p, bool *retval_nonnull)
5572 char *func, *args;
5573 const char *endp, *funcval;
5574 int count;
5576 processing_spec_function++;
5578 /* Get the function name. */
5579 for (endp = p; *endp != '\0'; endp++)
5581 if (*endp == '(') /* ) */
5582 break;
5583 /* Only allow [A-Za-z0-9], -, and _ in function names. */
5584 if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_'))
5585 fatal_error ("malformed spec function name");
5587 if (*endp != '(') /* ) */
5588 fatal_error ("no arguments for spec function");
5589 func = save_string (p, endp - p);
5590 p = ++endp;
5592 /* Get the arguments. */
5593 for (count = 0; *endp != '\0'; endp++)
5595 /* ( */
5596 if (*endp == ')')
5598 if (count == 0)
5599 break;
5600 count--;
5602 else if (*endp == '(') /* ) */
5603 count++;
5605 /* ( */
5606 if (*endp != ')')
5607 fatal_error ("malformed spec function arguments");
5608 args = save_string (p, endp - p);
5609 p = ++endp;
5611 /* p now points to just past the end of the spec function expression. */
5613 funcval = eval_spec_function (func, args);
5614 if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0)
5615 p = NULL;
5616 if (retval_nonnull)
5617 *retval_nonnull = funcval != NULL;
5619 free (func);
5620 free (args);
5622 processing_spec_function--;
5624 return p;
5627 /* Inline subroutine of handle_braces. Returns true if the current
5628 input suffix matches the atom bracketed by ATOM and END_ATOM. */
5629 static inline bool
5630 input_suffix_matches (const char *atom, const char *end_atom)
5632 return (input_suffix
5633 && !strncmp (input_suffix, atom, end_atom - atom)
5634 && input_suffix[end_atom - atom] == '\0');
5637 /* Subroutine of handle_braces. Returns true if the current
5638 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
5639 static bool
5640 input_spec_matches (const char *atom, const char *end_atom)
5642 return (input_file_compiler
5643 && input_file_compiler->suffix
5644 && input_file_compiler->suffix[0] != '\0'
5645 && !strncmp (input_file_compiler->suffix + 1, atom,
5646 end_atom - atom)
5647 && input_file_compiler->suffix[end_atom - atom + 1] == '\0');
5650 /* Subroutine of handle_braces. Returns true if a switch
5651 matching the atom bracketed by ATOM and END_ATOM appeared on the
5652 command line. */
5653 static bool
5654 switch_matches (const char *atom, const char *end_atom, int starred)
5656 int i;
5657 int len = end_atom - atom;
5658 int plen = starred ? len : -1;
5660 for (i = 0; i < n_switches; i++)
5661 if (!strncmp (switches[i].part1, atom, len)
5662 && (starred || switches[i].part1[len] == '\0')
5663 && check_live_switch (i, plen))
5664 return true;
5666 /* Check if a switch with separated form matching the atom.
5667 We check -D and -U switches. */
5668 else if (switches[i].args != 0)
5670 if ((*switches[i].part1 == 'D' || *switches[i].part1 == 'U')
5671 && *switches[i].part1 == atom[0])
5673 if (!strncmp (switches[i].args[0], &atom[1], len - 1)
5674 && (starred || (switches[i].part1[1] == '\0'
5675 && switches[i].args[0][len - 1] == '\0'))
5676 && check_live_switch (i, (starred ? 1 : -1)))
5677 return true;
5681 return false;
5684 /* Inline subroutine of handle_braces. Mark all of the switches which
5685 match ATOM (extends to END_ATOM; STARRED indicates whether there
5686 was a star after the atom) for later processing. */
5687 static inline void
5688 mark_matching_switches (const char *atom, const char *end_atom, int starred)
5690 int i;
5691 int len = end_atom - atom;
5692 int plen = starred ? len : -1;
5694 for (i = 0; i < n_switches; i++)
5695 if (!strncmp (switches[i].part1, atom, len)
5696 && (starred || switches[i].part1[len] == '\0')
5697 && check_live_switch (i, plen))
5698 switches[i].ordering = 1;
5701 /* Inline subroutine of handle_braces. Process all the currently
5702 marked switches through give_switch, and clear the marks. */
5703 static inline void
5704 process_marked_switches (void)
5706 int i;
5708 for (i = 0; i < n_switches; i++)
5709 if (switches[i].ordering == 1)
5711 switches[i].ordering = 0;
5712 give_switch (i, 0);
5716 /* Handle a %{ ... } construct. P points just inside the leading {.
5717 Returns a pointer one past the end of the brace block, or 0
5718 if we call do_spec_1 and that returns -1. */
5720 static const char *
5721 handle_braces (const char *p)
5723 const char *atom, *end_atom;
5724 const char *d_atom = NULL, *d_end_atom = NULL;
5725 const char *orig = p;
5727 bool a_is_suffix;
5728 bool a_is_spectype;
5729 bool a_is_starred;
5730 bool a_is_negated;
5731 bool a_matched;
5733 bool a_must_be_last = false;
5734 bool ordered_set = false;
5735 bool disjunct_set = false;
5736 bool disj_matched = false;
5737 bool disj_starred = true;
5738 bool n_way_choice = false;
5739 bool n_way_matched = false;
5741 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
5745 if (a_must_be_last)
5746 goto invalid;
5748 /* Scan one "atom" (S in the description above of %{}, possibly
5749 with '!', '.', '@', ',', or '*' modifiers). */
5750 a_matched = false;
5751 a_is_suffix = false;
5752 a_is_starred = false;
5753 a_is_negated = false;
5754 a_is_spectype = false;
5756 SKIP_WHITE ();
5757 if (*p == '!')
5758 p++, a_is_negated = true;
5760 SKIP_WHITE ();
5761 if (*p == '%' && p[1] == ':')
5763 atom = NULL;
5764 end_atom = NULL;
5765 p = handle_spec_function (p + 2, &a_matched);
5767 else
5769 if (*p == '.')
5770 p++, a_is_suffix = true;
5771 else if (*p == ',')
5772 p++, a_is_spectype = true;
5774 atom = p;
5775 while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
5776 || *p == ',' || *p == '.' || *p == '@')
5777 p++;
5778 end_atom = p;
5780 if (*p == '*')
5781 p++, a_is_starred = 1;
5784 SKIP_WHITE ();
5785 switch (*p)
5787 case '&': case '}':
5788 /* Substitute the switch(es) indicated by the current atom. */
5789 ordered_set = true;
5790 if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix
5791 || a_is_spectype || atom == end_atom)
5792 goto invalid;
5794 mark_matching_switches (atom, end_atom, a_is_starred);
5796 if (*p == '}')
5797 process_marked_switches ();
5798 break;
5800 case '|': case ':':
5801 /* Substitute some text if the current atom appears as a switch
5802 or suffix. */
5803 disjunct_set = true;
5804 if (ordered_set)
5805 goto invalid;
5807 if (atom && atom == end_atom)
5809 if (!n_way_choice || disj_matched || *p == '|'
5810 || a_is_negated || a_is_suffix || a_is_spectype
5811 || a_is_starred)
5812 goto invalid;
5814 /* An empty term may appear as the last choice of an
5815 N-way choice set; it means "otherwise". */
5816 a_must_be_last = true;
5817 disj_matched = !n_way_matched;
5818 disj_starred = false;
5820 else
5822 if ((a_is_suffix || a_is_spectype) && a_is_starred)
5823 goto invalid;
5825 if (!a_is_starred)
5826 disj_starred = false;
5828 /* Don't bother testing this atom if we already have a
5829 match. */
5830 if (!disj_matched && !n_way_matched)
5832 if (atom == NULL)
5833 /* a_matched is already set by handle_spec_function. */;
5834 else if (a_is_suffix)
5835 a_matched = input_suffix_matches (atom, end_atom);
5836 else if (a_is_spectype)
5837 a_matched = input_spec_matches (atom, end_atom);
5838 else
5839 a_matched = switch_matches (atom, end_atom, a_is_starred);
5841 if (a_matched != a_is_negated)
5843 disj_matched = true;
5844 d_atom = atom;
5845 d_end_atom = end_atom;
5850 if (*p == ':')
5852 /* Found the body, that is, the text to substitute if the
5853 current disjunction matches. */
5854 p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred,
5855 disj_matched && !n_way_matched);
5856 if (p == 0)
5857 return 0;
5859 /* If we have an N-way choice, reset state for the next
5860 disjunction. */
5861 if (*p == ';')
5863 n_way_choice = true;
5864 n_way_matched |= disj_matched;
5865 disj_matched = false;
5866 disj_starred = true;
5867 d_atom = d_end_atom = NULL;
5870 break;
5872 default:
5873 goto invalid;
5876 while (*p++ != '}');
5878 return p;
5880 invalid:
5881 fatal_error ("braced spec %qs is invalid at %qc", orig, *p);
5883 #undef SKIP_WHITE
5886 /* Subroutine of handle_braces. Scan and process a brace substitution body
5887 (X in the description of %{} syntax). P points one past the colon;
5888 ATOM and END_ATOM bracket the first atom which was found to be true
5889 (present) in the current disjunction; STARRED indicates whether all
5890 the atoms in the current disjunction were starred (for syntax validation);
5891 MATCHED indicates whether the disjunction matched or not, and therefore
5892 whether or not the body is to be processed through do_spec_1 or just
5893 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
5894 returns -1. */
5896 static const char *
5897 process_brace_body (const char *p, const char *atom, const char *end_atom,
5898 int starred, int matched)
5900 const char *body, *end_body;
5901 unsigned int nesting_level;
5902 bool have_subst = false;
5904 /* Locate the closing } or ;, honoring nested braces.
5905 Trim trailing whitespace. */
5906 body = p;
5907 nesting_level = 1;
5908 for (;;)
5910 if (*p == '{')
5911 nesting_level++;
5912 else if (*p == '}')
5914 if (!--nesting_level)
5915 break;
5917 else if (*p == ';' && nesting_level == 1)
5918 break;
5919 else if (*p == '%' && p[1] == '*' && nesting_level == 1)
5920 have_subst = true;
5921 else if (*p == '\0')
5922 goto invalid;
5923 p++;
5926 end_body = p;
5927 while (end_body[-1] == ' ' || end_body[-1] == '\t')
5928 end_body--;
5930 if (have_subst && !starred)
5931 goto invalid;
5933 if (matched)
5935 /* Copy the substitution body to permanent storage and execute it.
5936 If have_subst is false, this is a simple matter of running the
5937 body through do_spec_1... */
5938 char *string = save_string (body, end_body - body);
5939 if (!have_subst)
5941 if (do_spec_1 (string, 0, NULL) < 0)
5942 return 0;
5944 else
5946 /* ... but if have_subst is true, we have to process the
5947 body once for each matching switch, with %* set to the
5948 variant part of the switch. */
5949 unsigned int hard_match_len = end_atom - atom;
5950 int i;
5952 for (i = 0; i < n_switches; i++)
5953 if (!strncmp (switches[i].part1, atom, hard_match_len)
5954 && check_live_switch (i, hard_match_len))
5956 if (do_spec_1 (string, 0,
5957 &switches[i].part1[hard_match_len]) < 0)
5958 return 0;
5959 /* Pass any arguments this switch has. */
5960 give_switch (i, 1);
5961 suffix_subst = NULL;
5966 return p;
5968 invalid:
5969 fatal_error ("braced spec body %qs is invalid", body);
5972 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
5973 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
5974 spec, or -1 if either exact match or %* is used.
5976 A -O switch is obsoleted by a later -O switch. A -f, -g, -m, or -W switch
5977 whose value does not begin with "no-" is obsoleted by the same value
5978 with the "no-", similarly for a switch with the "no-" prefix. */
5980 static int
5981 check_live_switch (int switchnum, int prefix_length)
5983 const char *name = switches[switchnum].part1;
5984 int i;
5986 /* If we already processed this switch and determined if it was
5987 live or not, return our past determination. */
5988 if (switches[switchnum].live_cond != 0)
5989 return ((switches[switchnum].live_cond & SWITCH_LIVE) != 0
5990 && (switches[switchnum].live_cond & SWITCH_FALSE) == 0
5991 && (switches[switchnum].live_cond & SWITCH_IGNORE_PERMANENTLY)
5992 == 0);
5994 /* In the common case of {<at-most-one-letter>*}, a negating
5995 switch would always match, so ignore that case. We will just
5996 send the conflicting switches to the compiler phase. */
5997 if (prefix_length >= 0 && prefix_length <= 1)
5998 return 1;
6000 /* Now search for duplicate in a manner that depends on the name. */
6001 switch (*name)
6003 case 'O':
6004 for (i = switchnum + 1; i < n_switches; i++)
6005 if (switches[i].part1[0] == 'O')
6007 switches[switchnum].validated = true;
6008 switches[switchnum].live_cond = SWITCH_FALSE;
6009 return 0;
6011 break;
6013 case 'W': case 'f': case 'm': case 'g':
6014 if (! strncmp (name + 1, "no-", 3))
6016 /* We have Xno-YYY, search for XYYY. */
6017 for (i = switchnum + 1; i < n_switches; i++)
6018 if (switches[i].part1[0] == name[0]
6019 && ! strcmp (&switches[i].part1[1], &name[4]))
6021 /* --specs are validated with the validate_switches mechanism. */
6022 if (switches[switchnum].known)
6023 switches[switchnum].validated = true;
6024 switches[switchnum].live_cond = SWITCH_FALSE;
6025 return 0;
6028 else
6030 /* We have XYYY, search for Xno-YYY. */
6031 for (i = switchnum + 1; i < n_switches; i++)
6032 if (switches[i].part1[0] == name[0]
6033 && switches[i].part1[1] == 'n'
6034 && switches[i].part1[2] == 'o'
6035 && switches[i].part1[3] == '-'
6036 && !strcmp (&switches[i].part1[4], &name[1]))
6038 /* --specs are validated with the validate_switches mechanism. */
6039 if (switches[switchnum].known)
6040 switches[switchnum].validated = true;
6041 switches[switchnum].live_cond = SWITCH_FALSE;
6042 return 0;
6045 break;
6048 /* Otherwise the switch is live. */
6049 switches[switchnum].live_cond |= SWITCH_LIVE;
6050 return 1;
6053 /* Pass a switch to the current accumulating command
6054 in the same form that we received it.
6055 SWITCHNUM identifies the switch; it is an index into
6056 the vector of switches gcc received, which is `switches'.
6057 This cannot fail since it never finishes a command line.
6059 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
6061 static void
6062 give_switch (int switchnum, int omit_first_word)
6064 if ((switches[switchnum].live_cond & SWITCH_IGNORE) != 0)
6065 return;
6067 if (!omit_first_word)
6069 do_spec_1 ("-", 0, NULL);
6070 do_spec_1 (switches[switchnum].part1, 1, NULL);
6073 if (switches[switchnum].args != 0)
6075 const char **p;
6076 for (p = switches[switchnum].args; *p; p++)
6078 const char *arg = *p;
6080 do_spec_1 (" ", 0, NULL);
6081 if (suffix_subst)
6083 unsigned length = strlen (arg);
6084 int dot = 0;
6086 while (length-- && !IS_DIR_SEPARATOR (arg[length]))
6087 if (arg[length] == '.')
6089 (CONST_CAST (char *, arg))[length] = 0;
6090 dot = 1;
6091 break;
6093 do_spec_1 (arg, 1, NULL);
6094 if (dot)
6095 (CONST_CAST (char *, arg))[length] = '.';
6096 do_spec_1 (suffix_subst, 1, NULL);
6098 else
6099 do_spec_1 (arg, 1, NULL);
6103 do_spec_1 (" ", 0, NULL);
6104 switches[switchnum].validated = true;
6107 /* Search for a file named NAME trying various prefixes including the
6108 user's -B prefix and some standard ones.
6109 Return the absolute file name found. If nothing is found, return NAME. */
6111 static const char *
6112 find_file (const char *name)
6114 char *newname = find_a_file (&startfile_prefixes, name, R_OK, true);
6115 return newname ? newname : name;
6118 /* Determine whether a directory exists. If LINKER, return 0 for
6119 certain fixed names not needed by the linker. */
6121 static int
6122 is_directory (const char *path1, bool linker)
6124 int len1;
6125 char *path;
6126 char *cp;
6127 struct stat st;
6129 /* Ensure the string ends with "/.". The resulting path will be a
6130 directory even if the given path is a symbolic link. */
6131 len1 = strlen (path1);
6132 path = (char *) alloca (3 + len1);
6133 memcpy (path, path1, len1);
6134 cp = path + len1;
6135 if (!IS_DIR_SEPARATOR (cp[-1]))
6136 *cp++ = DIR_SEPARATOR;
6137 *cp++ = '.';
6138 *cp = '\0';
6140 /* Exclude directories that the linker is known to search. */
6141 if (linker
6142 && IS_DIR_SEPARATOR (path[0])
6143 && ((cp - path == 6
6144 && filename_ncmp (path + 1, "lib", 3) == 0)
6145 || (cp - path == 10
6146 && filename_ncmp (path + 1, "usr", 3) == 0
6147 && IS_DIR_SEPARATOR (path[4])
6148 && filename_ncmp (path + 5, "lib", 3) == 0)))
6149 return 0;
6151 return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
6154 /* Set up the various global variables to indicate that we're processing
6155 the input file named FILENAME. */
6157 void
6158 set_input (const char *filename)
6160 const char *p;
6162 gcc_input_filename = filename;
6163 input_filename_length = strlen (gcc_input_filename);
6164 input_basename = lbasename (gcc_input_filename);
6166 /* Find a suffix starting with the last period,
6167 and set basename_length to exclude that suffix. */
6168 basename_length = strlen (input_basename);
6169 suffixed_basename_length = basename_length;
6170 p = input_basename + basename_length;
6171 while (p != input_basename && *p != '.')
6172 --p;
6173 if (*p == '.' && p != input_basename)
6175 basename_length = p - input_basename;
6176 input_suffix = p + 1;
6178 else
6179 input_suffix = "";
6181 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
6182 we will need to do a stat on the gcc_input_filename. The
6183 INPUT_STAT_SET signals that the stat is needed. */
6184 input_stat_set = 0;
6187 /* On fatal signals, delete all the temporary files. */
6189 static void
6190 fatal_signal (int signum)
6192 signal (signum, SIG_DFL);
6193 delete_failure_queue ();
6194 delete_temp_files ();
6195 /* Get the same signal again, this time not handled,
6196 so its normal effect occurs. */
6197 kill (getpid (), signum);
6200 /* Compare the contents of the two files named CMPFILE[0] and
6201 CMPFILE[1]. Return zero if they're identical, nonzero
6202 otherwise. */
6204 static int
6205 compare_files (char *cmpfile[])
6207 int ret = 0;
6208 FILE *temp[2] = { NULL, NULL };
6209 int i;
6211 #if HAVE_MMAP_FILE
6213 size_t length[2];
6214 void *map[2] = { NULL, NULL };
6216 for (i = 0; i < 2; i++)
6218 struct stat st;
6220 if (stat (cmpfile[i], &st) < 0 || !S_ISREG (st.st_mode))
6222 error ("%s: could not determine length of compare-debug file %s",
6223 gcc_input_filename, cmpfile[i]);
6224 ret = 1;
6225 break;
6228 length[i] = st.st_size;
6231 if (!ret && length[0] != length[1])
6233 error ("%s: -fcompare-debug failure (length)", gcc_input_filename);
6234 ret = 1;
6237 if (!ret)
6238 for (i = 0; i < 2; i++)
6240 int fd = open (cmpfile[i], O_RDONLY);
6241 if (fd < 0)
6243 error ("%s: could not open compare-debug file %s",
6244 gcc_input_filename, cmpfile[i]);
6245 ret = 1;
6246 break;
6249 map[i] = mmap (NULL, length[i], PROT_READ, MAP_PRIVATE, fd, 0);
6250 close (fd);
6252 if (map[i] == (void *) MAP_FAILED)
6254 ret = -1;
6255 break;
6259 if (!ret)
6261 if (memcmp (map[0], map[1], length[0]) != 0)
6263 error ("%s: -fcompare-debug failure", gcc_input_filename);
6264 ret = 1;
6268 for (i = 0; i < 2; i++)
6269 if (map[i])
6270 munmap ((caddr_t) map[i], length[i]);
6272 if (ret >= 0)
6273 return ret;
6275 ret = 0;
6277 #endif
6279 for (i = 0; i < 2; i++)
6281 temp[i] = fopen (cmpfile[i], "r");
6282 if (!temp[i])
6284 error ("%s: could not open compare-debug file %s",
6285 gcc_input_filename, cmpfile[i]);
6286 ret = 1;
6287 break;
6291 if (!ret && temp[0] && temp[1])
6292 for (;;)
6294 int c0, c1;
6295 c0 = fgetc (temp[0]);
6296 c1 = fgetc (temp[1]);
6298 if (c0 != c1)
6300 error ("%s: -fcompare-debug failure",
6301 gcc_input_filename);
6302 ret = 1;
6303 break;
6306 if (c0 == EOF)
6307 break;
6310 for (i = 1; i >= 0; i--)
6312 if (temp[i])
6313 fclose (temp[i]);
6316 return ret;
6319 extern int main (int, char **);
6322 main (int argc, char **argv)
6324 size_t i;
6325 int value;
6326 int linker_was_run = 0;
6327 int lang_n_infiles = 0;
6328 int num_linker_inputs = 0;
6329 char *explicit_link_files;
6330 char *specs_file;
6331 char *lto_wrapper_file;
6332 const char *p;
6333 struct user_specs *uptr;
6334 char **old_argv = argv;
6335 struct cl_decoded_option *decoded_options;
6336 unsigned int decoded_options_count;
6338 p = argv[0] + strlen (argv[0]);
6339 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
6340 --p;
6341 progname = p;
6343 xmalloc_set_program_name (progname);
6345 expandargv (&argc, &argv);
6347 /* Determine if any expansions were made. */
6348 if (argv != old_argv)
6349 at_file_supplied = true;
6351 /* Register the language-independent parameters. */
6352 global_init_params ();
6353 finish_params ();
6355 init_options_struct (&global_options, &global_options_set);
6357 decode_cmdline_options_to_array (argc, CONST_CAST2 (const char **, char **,
6358 argv),
6359 CL_DRIVER,
6360 &decoded_options, &decoded_options_count);
6362 /* Unlock the stdio streams. */
6363 unlock_std_streams ();
6365 gcc_init_libintl ();
6367 diagnostic_initialize (global_dc, 0);
6369 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6370 /* Perform host dependent initialization when needed. */
6371 GCC_DRIVER_HOST_INITIALIZATION;
6372 #endif
6374 if (atexit (delete_temp_files) != 0)
6375 fatal_error ("atexit failed");
6377 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
6378 signal (SIGINT, fatal_signal);
6379 #ifdef SIGHUP
6380 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
6381 signal (SIGHUP, fatal_signal);
6382 #endif
6383 if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
6384 signal (SIGTERM, fatal_signal);
6385 #ifdef SIGPIPE
6386 if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
6387 signal (SIGPIPE, fatal_signal);
6388 #endif
6389 #ifdef SIGCHLD
6390 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6391 receive the signal. A different setting is inheritable */
6392 signal (SIGCHLD, SIG_DFL);
6393 #endif
6395 /* Parsing and gimplification sometimes need quite large stack.
6396 Increase stack size limits if possible. */
6397 stack_limit_increase (64 * 1024 * 1024);
6399 /* Allocate the argument vector. */
6400 alloc_args ();
6402 obstack_init (&obstack);
6404 /* Build multilib_select, et. al from the separate lines that make up each
6405 multilib selection. */
6407 const char *const *q = multilib_raw;
6408 int need_space;
6410 obstack_init (&multilib_obstack);
6411 while ((p = *q++) != (char *) 0)
6412 obstack_grow (&multilib_obstack, p, strlen (p));
6414 obstack_1grow (&multilib_obstack, 0);
6415 multilib_select = XOBFINISH (&multilib_obstack, const char *);
6417 q = multilib_matches_raw;
6418 while ((p = *q++) != (char *) 0)
6419 obstack_grow (&multilib_obstack, p, strlen (p));
6421 obstack_1grow (&multilib_obstack, 0);
6422 multilib_matches = XOBFINISH (&multilib_obstack, const char *);
6424 q = multilib_exclusions_raw;
6425 while ((p = *q++) != (char *) 0)
6426 obstack_grow (&multilib_obstack, p, strlen (p));
6428 obstack_1grow (&multilib_obstack, 0);
6429 multilib_exclusions = XOBFINISH (&multilib_obstack, const char *);
6431 q = multilib_reuse_raw;
6432 while ((p = *q++) != (char *) 0)
6433 obstack_grow (&multilib_obstack, p, strlen (p));
6435 obstack_1grow (&multilib_obstack, 0);
6436 multilib_reuse = XOBFINISH (&multilib_obstack, const char *);
6438 need_space = FALSE;
6439 for (i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++)
6441 if (need_space)
6442 obstack_1grow (&multilib_obstack, ' ');
6443 obstack_grow (&multilib_obstack,
6444 multilib_defaults_raw[i],
6445 strlen (multilib_defaults_raw[i]));
6446 need_space = TRUE;
6449 obstack_1grow (&multilib_obstack, 0);
6450 multilib_defaults = XOBFINISH (&multilib_obstack, const char *);
6453 #ifdef INIT_ENVIRONMENT
6454 /* Set up any other necessary machine specific environment variables. */
6455 xputenv (INIT_ENVIRONMENT);
6456 #endif
6458 /* Make a table of what switches there are (switches, n_switches).
6459 Make a table of specified input files (infiles, n_infiles).
6460 Decode switches that are handled locally. */
6462 process_command (decoded_options_count, decoded_options);
6464 /* Initialize the vector of specs to just the default.
6465 This means one element containing 0s, as a terminator. */
6467 compilers = XNEWVAR (struct compiler, sizeof default_compilers);
6468 memcpy (compilers, default_compilers, sizeof default_compilers);
6469 n_compilers = n_default_compilers;
6471 /* Read specs from a file if there is one. */
6473 machine_suffix = concat (spec_machine, dir_separator_str,
6474 spec_version, dir_separator_str, NULL);
6475 just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
6477 specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, true);
6478 /* Read the specs file unless it is a default one. */
6479 if (specs_file != 0 && strcmp (specs_file, "specs"))
6480 read_specs (specs_file, true, false);
6481 else
6482 init_spec ();
6484 /* We need to check standard_exec_prefix/just_machine_suffix/specs
6485 for any override of as, ld and libraries. */
6486 specs_file = (char *) alloca (strlen (standard_exec_prefix)
6487 + strlen (just_machine_suffix) + sizeof ("specs"));
6489 strcpy (specs_file, standard_exec_prefix);
6490 strcat (specs_file, just_machine_suffix);
6491 strcat (specs_file, "specs");
6492 if (access (specs_file, R_OK) == 0)
6493 read_specs (specs_file, true, false);
6495 /* Process any configure-time defaults specified for the command line
6496 options, via OPTION_DEFAULT_SPECS. */
6497 for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
6498 do_option_spec (option_default_specs[i].name,
6499 option_default_specs[i].spec);
6501 /* Process DRIVER_SELF_SPECS, adding any new options to the end
6502 of the command line. */
6504 for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++)
6505 do_self_spec (driver_self_specs[i]);
6507 /* If not cross-compiling, look for executables in the standard
6508 places. */
6509 if (*cross_compile == '0')
6511 if (*md_exec_prefix)
6513 add_prefix (&exec_prefixes, md_exec_prefix, "GCC",
6514 PREFIX_PRIORITY_LAST, 0, 0);
6518 /* Process sysroot_suffix_spec. */
6519 if (*sysroot_suffix_spec != 0
6520 && !no_sysroot_suffix
6521 && do_spec_2 (sysroot_suffix_spec) == 0)
6523 if (argbuf.length () > 1)
6524 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
6525 else if (argbuf.length () == 1)
6526 target_sysroot_suffix = xstrdup (argbuf.last ());
6529 #ifdef HAVE_LD_SYSROOT
6530 /* Pass the --sysroot option to the linker, if it supports that. If
6531 there is a sysroot_suffix_spec, it has already been processed by
6532 this point, so target_system_root really is the system root we
6533 should be using. */
6534 if (target_system_root)
6536 obstack_grow (&obstack, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
6537 obstack_grow0 (&obstack, link_spec, strlen (link_spec));
6538 set_spec ("link", XOBFINISH (&obstack, const char *), false);
6540 #endif
6542 /* Process sysroot_hdrs_suffix_spec. */
6543 if (*sysroot_hdrs_suffix_spec != 0
6544 && !no_sysroot_suffix
6545 && do_spec_2 (sysroot_hdrs_suffix_spec) == 0)
6547 if (argbuf.length () > 1)
6548 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
6549 else if (argbuf.length () == 1)
6550 target_sysroot_hdrs_suffix = xstrdup (argbuf.last ());
6553 /* Look for startfiles in the standard places. */
6554 if (*startfile_prefix_spec != 0
6555 && do_spec_2 (startfile_prefix_spec) == 0
6556 && do_spec_1 (" ", 0, NULL) == 0)
6558 const char *arg;
6559 int ndx;
6560 FOR_EACH_VEC_ELT (argbuf, ndx, arg)
6561 add_sysrooted_prefix (&startfile_prefixes, arg, "BINUTILS",
6562 PREFIX_PRIORITY_LAST, 0, 1);
6564 /* We should eventually get rid of all these and stick to
6565 startfile_prefix_spec exclusively. */
6566 else if (*cross_compile == '0' || target_system_root)
6568 if (*md_startfile_prefix)
6569 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix,
6570 "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6572 if (*md_startfile_prefix_1)
6573 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix_1,
6574 "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6576 /* If standard_startfile_prefix is relative, base it on
6577 standard_exec_prefix. This lets us move the installed tree
6578 as a unit. If GCC_EXEC_PREFIX is defined, base
6579 standard_startfile_prefix on that as well.
6581 If the prefix is relative, only search it for native compilers;
6582 otherwise we will search a directory containing host libraries. */
6583 if (IS_ABSOLUTE_PATH (standard_startfile_prefix))
6584 add_sysrooted_prefix (&startfile_prefixes,
6585 standard_startfile_prefix, "BINUTILS",
6586 PREFIX_PRIORITY_LAST, 0, 1);
6587 else if (*cross_compile == '0')
6589 add_prefix (&startfile_prefixes,
6590 concat (gcc_exec_prefix
6591 ? gcc_exec_prefix : standard_exec_prefix,
6592 machine_suffix,
6593 standard_startfile_prefix, NULL),
6594 NULL, PREFIX_PRIORITY_LAST, 0, 1);
6597 /* Sysrooted prefixes are relocated because target_system_root is
6598 also relocated by gcc_exec_prefix. */
6599 if (*standard_startfile_prefix_1)
6600 add_sysrooted_prefix (&startfile_prefixes,
6601 standard_startfile_prefix_1, "BINUTILS",
6602 PREFIX_PRIORITY_LAST, 0, 1);
6603 if (*standard_startfile_prefix_2)
6604 add_sysrooted_prefix (&startfile_prefixes,
6605 standard_startfile_prefix_2, "BINUTILS",
6606 PREFIX_PRIORITY_LAST, 0, 1);
6609 /* Process any user specified specs in the order given on the command
6610 line. */
6611 for (uptr = user_specs_head; uptr; uptr = uptr->next)
6613 char *filename = find_a_file (&startfile_prefixes, uptr->filename,
6614 R_OK, true);
6615 read_specs (filename ? filename : uptr->filename, false, true);
6618 /* Process any user self specs. */
6620 struct spec_list *sl;
6621 for (sl = specs; sl; sl = sl->next)
6622 if (sl->name_len == sizeof "self_spec" - 1
6623 && !strcmp (sl->name, "self_spec"))
6624 do_self_spec (*sl->ptr_spec);
6627 if (compare_debug)
6629 enum save_temps save;
6631 if (!compare_debug_second)
6633 n_switches_debug_check[1] = n_switches;
6634 n_switches_alloc_debug_check[1] = n_switches_alloc;
6635 switches_debug_check[1] = XDUPVEC (struct switchstr, switches,
6636 n_switches_alloc);
6638 do_self_spec ("%:compare-debug-self-opt()");
6639 n_switches_debug_check[0] = n_switches;
6640 n_switches_alloc_debug_check[0] = n_switches_alloc;
6641 switches_debug_check[0] = switches;
6643 n_switches = n_switches_debug_check[1];
6644 n_switches_alloc = n_switches_alloc_debug_check[1];
6645 switches = switches_debug_check[1];
6648 /* Avoid crash when computing %j in this early. */
6649 save = save_temps_flag;
6650 save_temps_flag = SAVE_TEMPS_NONE;
6652 compare_debug = -compare_debug;
6653 do_self_spec ("%:compare-debug-self-opt()");
6655 save_temps_flag = save;
6657 if (!compare_debug_second)
6659 n_switches_debug_check[1] = n_switches;
6660 n_switches_alloc_debug_check[1] = n_switches_alloc;
6661 switches_debug_check[1] = switches;
6662 compare_debug = -compare_debug;
6663 n_switches = n_switches_debug_check[0];
6664 n_switches_alloc = n_switches_debug_check[0];
6665 switches = switches_debug_check[0];
6670 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
6671 if (gcc_exec_prefix)
6672 gcc_exec_prefix = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
6673 spec_version, dir_separator_str, NULL);
6675 /* Now we have the specs.
6676 Set the `valid' bits for switches that match anything in any spec. */
6678 validate_all_switches ();
6680 /* Now that we have the switches and the specs, set
6681 the subdirectory based on the options. */
6682 set_multilib_dir ();
6684 /* Set up to remember the pathname of gcc and any options
6685 needed for collect. We use argv[0] instead of progname because
6686 we need the complete pathname. */
6687 obstack_init (&collect_obstack);
6688 obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
6689 obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1);
6690 xputenv (XOBFINISH (&collect_obstack, char *));
6692 /* Set up to remember the pathname of the lto wrapper. */
6694 if (have_c)
6695 lto_wrapper_file = NULL;
6696 else
6697 lto_wrapper_file = find_a_file (&exec_prefixes, "lto-wrapper",
6698 X_OK, false);
6699 if (lto_wrapper_file)
6701 lto_wrapper_file = convert_white_space (lto_wrapper_file);
6702 lto_wrapper_spec = lto_wrapper_file;
6703 obstack_init (&collect_obstack);
6704 obstack_grow (&collect_obstack, "COLLECT_LTO_WRAPPER=",
6705 sizeof ("COLLECT_LTO_WRAPPER=") - 1);
6706 obstack_grow (&collect_obstack, lto_wrapper_spec,
6707 strlen (lto_wrapper_spec) + 1);
6708 xputenv (XOBFINISH (&collect_obstack, char *));
6711 /* Reject switches that no pass was interested in. */
6713 for (i = 0; (int) i < n_switches; i++)
6714 if (! switches[i].validated)
6715 error ("unrecognized command line option %<-%s%>", switches[i].part1);
6717 /* Obey some of the options. */
6719 if (print_search_dirs)
6721 printf (_("install: %s%s\n"),
6722 gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
6723 gcc_exec_prefix ? "" : machine_suffix);
6724 printf (_("programs: %s\n"),
6725 build_search_list (&exec_prefixes, "", false, false));
6726 printf (_("libraries: %s\n"),
6727 build_search_list (&startfile_prefixes, "", false, true));
6728 return (0);
6731 if (print_file_name)
6733 printf ("%s\n", find_file (print_file_name));
6734 return (0);
6737 if (print_prog_name)
6739 if (use_ld != NULL && ! strcmp (print_prog_name, "ld"))
6741 /* Append USE_LD to to the default linker. */
6742 #ifdef DEFAULT_LINKER
6743 char *ld;
6744 # ifdef HAVE_HOST_EXECUTABLE_SUFFIX
6745 int len = (sizeof (DEFAULT_LINKER)
6746 - sizeof (HOST_EXECUTABLE_SUFFIX));
6747 ld = NULL;
6748 if (len > 0)
6750 char *default_linker = xstrdup (DEFAULT_LINKER);
6751 /* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains
6752 HOST_EXECUTABLE_SUFFIX. */
6753 if (! strcmp (&default_linker[len], HOST_EXECUTABLE_SUFFIX))
6755 default_linker[len] = '\0';
6756 ld = concat (default_linker, use_ld,
6757 HOST_EXECUTABLE_SUFFIX, NULL);
6760 if (ld == NULL)
6761 # endif
6762 ld = concat (DEFAULT_LINKER, use_ld, NULL);
6763 if (access (ld, X_OK) == 0)
6765 printf ("%s\n", ld);
6766 return (0);
6768 #endif
6769 print_prog_name = concat (print_prog_name, use_ld, NULL);
6771 char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK, 0);
6772 printf ("%s\n", (newname ? newname : print_prog_name));
6773 return (0);
6776 if (print_multi_lib)
6778 print_multilib_info ();
6779 return (0);
6782 if (print_multi_directory)
6784 if (multilib_dir == NULL)
6785 printf (".\n");
6786 else
6787 printf ("%s\n", multilib_dir);
6788 return (0);
6791 if (print_multiarch)
6793 if (multiarch_dir == NULL)
6794 printf ("\n");
6795 else
6796 printf ("%s\n", multiarch_dir);
6797 return (0);
6800 if (print_sysroot)
6802 if (target_system_root)
6804 if (target_sysroot_suffix)
6805 printf ("%s%s\n", target_system_root, target_sysroot_suffix);
6806 else
6807 printf ("%s\n", target_system_root);
6809 return (0);
6812 if (print_multi_os_directory)
6814 if (multilib_os_dir == NULL)
6815 printf (".\n");
6816 else
6817 printf ("%s\n", multilib_os_dir);
6818 return (0);
6821 if (print_sysroot_headers_suffix)
6823 if (*sysroot_hdrs_suffix_spec)
6825 printf("%s\n", (target_sysroot_hdrs_suffix
6826 ? target_sysroot_hdrs_suffix
6827 : ""));
6828 return (0);
6830 else
6831 /* The error status indicates that only one set of fixed
6832 headers should be built. */
6833 fatal_error ("not configured with sysroot headers suffix");
6836 if (print_help_list)
6838 display_help ();
6840 if (! verbose_flag)
6842 printf (_("\nFor bug reporting instructions, please see:\n"));
6843 printf ("%s.\n", bug_report_url);
6845 return (0);
6848 /* We do not exit here. Instead we have created a fake input file
6849 called 'help-dummy' which needs to be compiled, and we pass this
6850 on the various sub-processes, along with the --help switch.
6851 Ensure their output appears after ours. */
6852 fputc ('\n', stdout);
6853 fflush (stdout);
6856 if (print_version)
6858 printf (_("%s %s%s\n"), progname, pkgversion_string,
6859 version_string);
6860 printf ("Copyright %s 2014 Free Software Foundation, Inc.\n",
6861 _("(C)"));
6862 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
6863 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
6864 stdout);
6865 if (! verbose_flag)
6866 return 0;
6868 /* We do not exit here. We use the same mechanism of --help to print
6869 the version of the sub-processes. */
6870 fputc ('\n', stdout);
6871 fflush (stdout);
6874 if (verbose_flag)
6876 int n;
6877 const char *thrmod;
6879 fnotice (stderr, "Target: %s\n", spec_machine);
6880 fnotice (stderr, "Configured with: %s\n", configuration_arguments);
6882 #ifdef THREAD_MODEL_SPEC
6883 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
6884 but there's no point in doing all this processing just to get
6885 thread_model back. */
6886 obstack_init (&obstack);
6887 do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model);
6888 obstack_1grow (&obstack, '\0');
6889 thrmod = XOBFINISH (&obstack, const char *);
6890 #else
6891 thrmod = thread_model;
6892 #endif
6894 fnotice (stderr, "Thread model: %s\n", thrmod);
6896 /* compiler_version is truncated at the first space when initialized
6897 from version string, so truncate version_string at the first space
6898 before comparing. */
6899 for (n = 0; version_string[n]; n++)
6900 if (version_string[n] == ' ')
6901 break;
6903 if (! strncmp (version_string, compiler_version, n)
6904 && compiler_version[n] == 0)
6905 fnotice (stderr, "gcc version %s %s\n", version_string,
6906 pkgversion_string);
6907 else
6908 fnotice (stderr, "gcc driver version %s %sexecuting gcc version %s\n",
6909 version_string, pkgversion_string, compiler_version);
6911 if (n_infiles == 0)
6912 return (0);
6915 if (n_infiles == added_libraries)
6916 fatal_error ("no input files");
6918 if (seen_error ())
6919 goto out;
6921 /* Make a place to record the compiler output file names
6922 that correspond to the input files. */
6924 i = n_infiles;
6925 i += lang_specific_extra_outfiles;
6926 outfiles = XCNEWVEC (const char *, i);
6928 /* Record which files were specified explicitly as link input. */
6930 explicit_link_files = XCNEWVEC (char, n_infiles);
6932 combine_inputs = have_o || flag_wpa;
6934 for (i = 0; (int) i < n_infiles; i++)
6936 const char *name = infiles[i].name;
6937 struct compiler *compiler = lookup_compiler (name,
6938 strlen (name),
6939 infiles[i].language);
6941 if (compiler && !(compiler->combinable))
6942 combine_inputs = false;
6944 if (lang_n_infiles > 0 && compiler != input_file_compiler
6945 && infiles[i].language && infiles[i].language[0] != '*')
6946 infiles[i].incompiler = compiler;
6947 else if (compiler)
6949 lang_n_infiles++;
6950 input_file_compiler = compiler;
6951 infiles[i].incompiler = compiler;
6953 else
6955 /* Since there is no compiler for this input file, assume it is a
6956 linker file. */
6957 explicit_link_files[i] = 1;
6958 infiles[i].incompiler = NULL;
6960 infiles[i].compiled = false;
6961 infiles[i].preprocessed = false;
6964 if (!combine_inputs && have_c && have_o && lang_n_infiles > 1)
6965 fatal_error ("cannot specify -o with -c, -S or -E with multiple files");
6967 for (i = 0; (int) i < n_infiles; i++)
6969 int this_file_error = 0;
6971 /* Tell do_spec what to substitute for %i. */
6973 input_file_number = i;
6974 set_input (infiles[i].name);
6976 if (infiles[i].compiled)
6977 continue;
6979 /* Use the same thing in %o, unless cp->spec says otherwise. */
6981 outfiles[i] = gcc_input_filename;
6983 /* Figure out which compiler from the file's suffix. */
6985 input_file_compiler
6986 = lookup_compiler (infiles[i].name, input_filename_length,
6987 infiles[i].language);
6989 if (input_file_compiler)
6991 /* Ok, we found an applicable compiler. Run its spec. */
6993 if (input_file_compiler->spec[0] == '#')
6995 error ("%s: %s compiler not installed on this system",
6996 gcc_input_filename, &input_file_compiler->spec[1]);
6997 this_file_error = 1;
6999 else
7001 if (compare_debug)
7003 free (debug_check_temp_file[0]);
7004 debug_check_temp_file[0] = NULL;
7006 free (debug_check_temp_file[1]);
7007 debug_check_temp_file[1] = NULL;
7010 value = do_spec (input_file_compiler->spec);
7011 infiles[i].compiled = true;
7012 if (value < 0)
7013 this_file_error = 1;
7014 else if (compare_debug && debug_check_temp_file[0])
7016 if (verbose_flag)
7017 inform (0, "recompiling with -fcompare-debug");
7019 compare_debug = -compare_debug;
7020 n_switches = n_switches_debug_check[1];
7021 n_switches_alloc = n_switches_alloc_debug_check[1];
7022 switches = switches_debug_check[1];
7024 value = do_spec (input_file_compiler->spec);
7026 compare_debug = -compare_debug;
7027 n_switches = n_switches_debug_check[0];
7028 n_switches_alloc = n_switches_alloc_debug_check[0];
7029 switches = switches_debug_check[0];
7031 if (value < 0)
7033 error ("during -fcompare-debug recompilation");
7034 this_file_error = 1;
7037 gcc_assert (debug_check_temp_file[1]
7038 && filename_cmp (debug_check_temp_file[0],
7039 debug_check_temp_file[1]));
7041 if (verbose_flag)
7042 inform (0, "comparing final insns dumps");
7044 if (compare_files (debug_check_temp_file))
7045 this_file_error = 1;
7048 if (compare_debug)
7050 free (debug_check_temp_file[0]);
7051 debug_check_temp_file[0] = NULL;
7053 free (debug_check_temp_file[1]);
7054 debug_check_temp_file[1] = NULL;
7059 /* If this file's name does not contain a recognized suffix,
7060 record it as explicit linker input. */
7062 else
7063 explicit_link_files[i] = 1;
7065 /* Clear the delete-on-failure queue, deleting the files in it
7066 if this compilation failed. */
7068 if (this_file_error)
7070 delete_failure_queue ();
7071 errorcount++;
7073 /* If this compilation succeeded, don't delete those files later. */
7074 clear_failure_queue ();
7077 /* Reset the input file name to the first compile/object file name, for use
7078 with %b in LINK_SPEC. We use the first input file that we can find
7079 a compiler to compile it instead of using infiles.language since for
7080 languages other than C we use aliases that we then lookup later. */
7081 if (n_infiles > 0)
7083 int i;
7085 for (i = 0; i < n_infiles ; i++)
7086 if (infiles[i].incompiler
7087 || (infiles[i].language && infiles[i].language[0] != '*'))
7089 set_input (infiles[i].name);
7090 break;
7094 if (!seen_error ())
7096 /* Make sure INPUT_FILE_NUMBER points to first available open
7097 slot. */
7098 input_file_number = n_infiles;
7099 if (lang_specific_pre_link ())
7100 errorcount++;
7103 /* Determine if there are any linker input files. */
7104 num_linker_inputs = 0;
7105 for (i = 0; (int) i < n_infiles; i++)
7106 if (explicit_link_files[i] || outfiles[i] != NULL)
7107 num_linker_inputs++;
7109 /* Run ld to link all the compiler output files. */
7111 if (num_linker_inputs > 0 && !seen_error () && print_subprocess_help < 2)
7113 int tmp = execution_count;
7115 if (! have_c)
7117 #if HAVE_LTO_PLUGIN > 0
7118 #if HAVE_LTO_PLUGIN == 2
7119 const char *fno_use_linker_plugin = "fno-use-linker-plugin";
7120 #else
7121 const char *fuse_linker_plugin = "fuse-linker-plugin";
7122 #endif
7123 #endif
7125 /* We'll use ld if we can't find collect2. */
7126 if (! strcmp (linker_name_spec, "collect2"))
7128 char *s = find_a_file (&exec_prefixes, "collect2", X_OK, false);
7129 if (s == NULL)
7130 linker_name_spec = "ld";
7133 #if HAVE_LTO_PLUGIN > 0
7134 #if HAVE_LTO_PLUGIN == 2
7135 if (!switch_matches (fno_use_linker_plugin,
7136 fno_use_linker_plugin
7137 + strlen (fno_use_linker_plugin), 0))
7138 #else
7139 if (switch_matches (fuse_linker_plugin,
7140 fuse_linker_plugin
7141 + strlen (fuse_linker_plugin), 0))
7142 #endif
7144 char *temp_spec = find_a_file (&exec_prefixes,
7145 LTOPLUGINSONAME, R_OK,
7146 false);
7147 if (!temp_spec)
7148 fatal_error ("-fuse-linker-plugin, but %s not found",
7149 LTOPLUGINSONAME);
7150 linker_plugin_file_spec = convert_white_space (temp_spec);
7152 #endif
7153 lto_gcc_spec = argv[0];
7156 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
7157 for collect. */
7158 putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH", false);
7159 putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV, true);
7161 if (print_subprocess_help == 1)
7163 printf (_("\nLinker options\n==============\n\n"));
7164 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
7165 " to the linker.\n\n"));
7166 fflush (stdout);
7168 value = do_spec (link_command_spec);
7169 if (value < 0)
7170 errorcount = 1;
7171 linker_was_run = (tmp != execution_count);
7174 /* If options said don't run linker,
7175 complain about input files to be given to the linker. */
7177 if (! linker_was_run && !seen_error ())
7178 for (i = 0; (int) i < n_infiles; i++)
7179 if (explicit_link_files[i]
7180 && !(infiles[i].language && infiles[i].language[0] == '*'))
7181 warning (0, "%s: linker input file unused because linking not done",
7182 outfiles[i]);
7184 /* Delete some or all of the temporary files we made. */
7186 if (seen_error ())
7187 delete_failure_queue ();
7188 delete_temp_files ();
7190 if (print_help_list)
7192 printf (("\nFor bug reporting instructions, please see:\n"));
7193 printf ("%s\n", bug_report_url);
7196 out:
7197 return (signal_count != 0 ? 2
7198 : seen_error () ? (pass_exit_codes ? greatest_status : 1)
7199 : 0);
7202 /* Find the proper compilation spec for the file name NAME,
7203 whose length is LENGTH. LANGUAGE is the specified language,
7204 or 0 if this file is to be passed to the linker. */
7206 static struct compiler *
7207 lookup_compiler (const char *name, size_t length, const char *language)
7209 struct compiler *cp;
7211 /* If this was specified by the user to be a linker input, indicate that. */
7212 if (language != 0 && language[0] == '*')
7213 return 0;
7215 /* Otherwise, look for the language, if one is spec'd. */
7216 if (language != 0)
7218 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7219 if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
7220 return cp;
7222 error ("language %s not recognized", language);
7223 return 0;
7226 /* Look for a suffix. */
7227 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7229 if (/* The suffix `-' matches only the file name `-'. */
7230 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
7231 || (strlen (cp->suffix) < length
7232 /* See if the suffix matches the end of NAME. */
7233 && !strcmp (cp->suffix,
7234 name + length - strlen (cp->suffix))
7236 break;
7239 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
7240 /* Look again, but case-insensitively this time. */
7241 if (cp < compilers)
7242 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7244 if (/* The suffix `-' matches only the file name `-'. */
7245 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
7246 || (strlen (cp->suffix) < length
7247 /* See if the suffix matches the end of NAME. */
7248 && ((!strcmp (cp->suffix,
7249 name + length - strlen (cp->suffix))
7250 || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
7251 && !strcasecmp (cp->suffix,
7252 name + length - strlen (cp->suffix)))
7254 break;
7256 #endif
7258 if (cp >= compilers)
7260 if (cp->spec[0] != '@')
7261 /* A non-alias entry: return it. */
7262 return cp;
7264 /* An alias entry maps a suffix to a language.
7265 Search for the language; pass 0 for NAME and LENGTH
7266 to avoid infinite recursion if language not found. */
7267 return lookup_compiler (NULL, 0, cp->spec + 1);
7269 return 0;
7272 static char *
7273 save_string (const char *s, int len)
7275 char *result = XNEWVEC (char, len + 1);
7277 memcpy (result, s, len);
7278 result[len] = 0;
7279 return result;
7282 void
7283 pfatal_with_name (const char *name)
7285 perror_with_name (name);
7286 delete_temp_files ();
7287 exit (1);
7290 static void
7291 perror_with_name (const char *name)
7293 error ("%s: %m", name);
7296 static inline void
7297 validate_switches_from_spec (const char *spec, bool user)
7299 const char *p = spec;
7300 char c;
7301 while ((c = *p++))
7302 if (c == '%' && (*p == '{' || *p == '<' || (*p == 'W' && *++p == '{')))
7303 /* We have a switch spec. */
7304 p = validate_switches (p + 1, user);
7307 static void
7308 validate_all_switches (void)
7310 struct compiler *comp;
7311 struct spec_list *spec;
7313 for (comp = compilers; comp->spec; comp++)
7314 validate_switches_from_spec (comp->spec, false);
7316 /* Look through the linked list of specs read from the specs file. */
7317 for (spec = specs; spec; spec = spec->next)
7318 validate_switches_from_spec (*spec->ptr_spec, spec->user_p);
7320 validate_switches_from_spec (link_command_spec, false);
7323 /* Look at the switch-name that comes after START
7324 and mark as valid all supplied switches that match it. */
7326 static const char *
7327 validate_switches (const char *start, bool user_spec)
7329 const char *p = start;
7330 const char *atom;
7331 size_t len;
7332 int i;
7333 bool suffix = false;
7334 bool starred = false;
7336 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7338 next_member:
7339 SKIP_WHITE ();
7341 if (*p == '!')
7342 p++;
7344 SKIP_WHITE ();
7345 if (*p == '.' || *p == ',')
7346 suffix = true, p++;
7348 atom = p;
7349 while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
7350 || *p == ',' || *p == '.' || *p == '@')
7351 p++;
7352 len = p - atom;
7354 if (*p == '*')
7355 starred = true, p++;
7357 SKIP_WHITE ();
7359 if (!suffix)
7361 /* Mark all matching switches as valid. */
7362 for (i = 0; i < n_switches; i++)
7363 if (!strncmp (switches[i].part1, atom, len)
7364 && (starred || switches[i].part1[len] == '\0')
7365 && (switches[i].known || user_spec))
7366 switches[i].validated = true;
7369 if (*p) p++;
7370 if (*p && (p[-1] == '|' || p[-1] == '&'))
7371 goto next_member;
7373 if (*p && p[-1] == ':')
7375 while (*p && *p != ';' && *p != '}')
7377 if (*p == '%')
7379 p++;
7380 if (*p == '{' || *p == '<')
7381 p = validate_switches (p+1, user_spec);
7382 else if (p[0] == 'W' && p[1] == '{')
7383 p = validate_switches (p+2, user_spec);
7385 else
7386 p++;
7389 if (*p) p++;
7390 if (*p && p[-1] == ';')
7391 goto next_member;
7394 return p;
7395 #undef SKIP_WHITE
7398 struct mdswitchstr
7400 const char *str;
7401 int len;
7404 static struct mdswitchstr *mdswitches;
7405 static int n_mdswitches;
7407 /* Check whether a particular argument was used. The first time we
7408 canonicalize the switches to keep only the ones we care about. */
7410 static int
7411 used_arg (const char *p, int len)
7413 struct mswitchstr
7415 const char *str;
7416 const char *replace;
7417 int len;
7418 int rep_len;
7421 static struct mswitchstr *mswitches;
7422 static int n_mswitches;
7423 int i, j;
7425 if (!mswitches)
7427 struct mswitchstr *matches;
7428 const char *q;
7429 int cnt = 0;
7431 /* Break multilib_matches into the component strings of string
7432 and replacement string. */
7433 for (q = multilib_matches; *q != '\0'; q++)
7434 if (*q == ';')
7435 cnt++;
7437 matches
7438 = (struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt);
7439 i = 0;
7440 q = multilib_matches;
7441 while (*q != '\0')
7443 matches[i].str = q;
7444 while (*q != ' ')
7446 if (*q == '\0')
7448 invalid_matches:
7449 fatal_error ("multilib spec %qs is invalid",
7450 multilib_matches);
7452 q++;
7454 matches[i].len = q - matches[i].str;
7456 matches[i].replace = ++q;
7457 while (*q != ';' && *q != '\0')
7459 if (*q == ' ')
7460 goto invalid_matches;
7461 q++;
7463 matches[i].rep_len = q - matches[i].replace;
7464 i++;
7465 if (*q == ';')
7466 q++;
7469 /* Now build a list of the replacement string for switches that we care
7470 about. Make sure we allocate at least one entry. This prevents
7471 xmalloc from calling fatal, and prevents us from re-executing this
7472 block of code. */
7473 mswitches
7474 = XNEWVEC (struct mswitchstr, n_mdswitches + (n_switches ? n_switches : 1));
7475 for (i = 0; i < n_switches; i++)
7476 if ((switches[i].live_cond & SWITCH_IGNORE) == 0)
7478 int xlen = strlen (switches[i].part1);
7479 for (j = 0; j < cnt; j++)
7480 if (xlen == matches[j].len
7481 && ! strncmp (switches[i].part1, matches[j].str, xlen))
7483 mswitches[n_mswitches].str = matches[j].replace;
7484 mswitches[n_mswitches].len = matches[j].rep_len;
7485 mswitches[n_mswitches].replace = (char *) 0;
7486 mswitches[n_mswitches].rep_len = 0;
7487 n_mswitches++;
7488 break;
7492 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
7493 on the command line nor any options mutually incompatible with
7494 them. */
7495 for (i = 0; i < n_mdswitches; i++)
7497 const char *r;
7499 for (q = multilib_options; *q != '\0'; q++)
7501 while (*q == ' ')
7502 q++;
7504 r = q;
7505 while (strncmp (q, mdswitches[i].str, mdswitches[i].len) != 0
7506 || strchr (" /", q[mdswitches[i].len]) == NULL)
7508 while (*q != ' ' && *q != '/' && *q != '\0')
7509 q++;
7510 if (*q != '/')
7511 break;
7512 q++;
7515 if (*q != ' ' && *q != '\0')
7517 while (*r != ' ' && *r != '\0')
7519 q = r;
7520 while (*q != ' ' && *q != '/' && *q != '\0')
7521 q++;
7523 if (used_arg (r, q - r))
7524 break;
7526 if (*q != '/')
7528 mswitches[n_mswitches].str = mdswitches[i].str;
7529 mswitches[n_mswitches].len = mdswitches[i].len;
7530 mswitches[n_mswitches].replace = (char *) 0;
7531 mswitches[n_mswitches].rep_len = 0;
7532 n_mswitches++;
7533 break;
7536 r = q + 1;
7538 break;
7544 for (i = 0; i < n_mswitches; i++)
7545 if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
7546 return 1;
7548 return 0;
7551 static int
7552 default_arg (const char *p, int len)
7554 int i;
7556 for (i = 0; i < n_mdswitches; i++)
7557 if (len == mdswitches[i].len && ! strncmp (p, mdswitches[i].str, len))
7558 return 1;
7560 return 0;
7563 /* Work out the subdirectory to use based on the options. The format of
7564 multilib_select is a list of elements. Each element is a subdirectory
7565 name followed by a list of options followed by a semicolon. The format
7566 of multilib_exclusions is the same, but without the preceding
7567 directory. First gcc will check the exclusions, if none of the options
7568 beginning with an exclamation point are present, and all of the other
7569 options are present, then we will ignore this completely. Passing
7570 that, gcc will consider each multilib_select in turn using the same
7571 rules for matching the options. If a match is found, that subdirectory
7572 will be used.
7573 A subdirectory name is optionally followed by a colon and the corresponding
7574 multiarch name. */
7576 static void
7577 set_multilib_dir (void)
7579 const char *p;
7580 unsigned int this_path_len;
7581 const char *this_path, *this_arg;
7582 const char *start, *end;
7583 int not_arg;
7584 int ok, ndfltok, first;
7586 n_mdswitches = 0;
7587 start = multilib_defaults;
7588 while (*start == ' ' || *start == '\t')
7589 start++;
7590 while (*start != '\0')
7592 n_mdswitches++;
7593 while (*start != ' ' && *start != '\t' && *start != '\0')
7594 start++;
7595 while (*start == ' ' || *start == '\t')
7596 start++;
7599 if (n_mdswitches)
7601 int i = 0;
7603 mdswitches = XNEWVEC (struct mdswitchstr, n_mdswitches);
7604 for (start = multilib_defaults; *start != '\0'; start = end + 1)
7606 while (*start == ' ' || *start == '\t')
7607 start++;
7609 if (*start == '\0')
7610 break;
7612 for (end = start + 1;
7613 *end != ' ' && *end != '\t' && *end != '\0'; end++)
7616 obstack_grow (&multilib_obstack, start, end - start);
7617 obstack_1grow (&multilib_obstack, 0);
7618 mdswitches[i].str = XOBFINISH (&multilib_obstack, const char *);
7619 mdswitches[i++].len = end - start;
7621 if (*end == '\0')
7622 break;
7626 p = multilib_exclusions;
7627 while (*p != '\0')
7629 /* Ignore newlines. */
7630 if (*p == '\n')
7632 ++p;
7633 continue;
7636 /* Check the arguments. */
7637 ok = 1;
7638 while (*p != ';')
7640 if (*p == '\0')
7642 invalid_exclusions:
7643 fatal_error ("multilib exclusions %qs is invalid",
7644 multilib_exclusions);
7647 if (! ok)
7649 ++p;
7650 continue;
7653 this_arg = p;
7654 while (*p != ' ' && *p != ';')
7656 if (*p == '\0')
7657 goto invalid_exclusions;
7658 ++p;
7661 if (*this_arg != '!')
7662 not_arg = 0;
7663 else
7665 not_arg = 1;
7666 ++this_arg;
7669 ok = used_arg (this_arg, p - this_arg);
7670 if (not_arg)
7671 ok = ! ok;
7673 if (*p == ' ')
7674 ++p;
7677 if (ok)
7678 return;
7680 ++p;
7683 first = 1;
7684 p = multilib_select;
7686 /* Append multilib reuse rules if any. With those rules, we can reuse
7687 one multilib for certain different options sets. */
7688 if (strlen (multilib_reuse) > 0)
7689 p = concat (p, multilib_reuse, NULL);
7691 while (*p != '\0')
7693 /* Ignore newlines. */
7694 if (*p == '\n')
7696 ++p;
7697 continue;
7700 /* Get the initial path. */
7701 this_path = p;
7702 while (*p != ' ')
7704 if (*p == '\0')
7706 invalid_select:
7707 fatal_error ("multilib select %qs %qs is invalid",
7708 multilib_select, multilib_reuse);
7710 ++p;
7712 this_path_len = p - this_path;
7714 /* Check the arguments. */
7715 ok = 1;
7716 ndfltok = 1;
7717 ++p;
7718 while (*p != ';')
7720 if (*p == '\0')
7721 goto invalid_select;
7723 if (! ok)
7725 ++p;
7726 continue;
7729 this_arg = p;
7730 while (*p != ' ' && *p != ';')
7732 if (*p == '\0')
7733 goto invalid_select;
7734 ++p;
7737 if (*this_arg != '!')
7738 not_arg = 0;
7739 else
7741 not_arg = 1;
7742 ++this_arg;
7745 /* If this is a default argument, we can just ignore it.
7746 This is true even if this_arg begins with '!'. Beginning
7747 with '!' does not mean that this argument is necessarily
7748 inappropriate for this library: it merely means that
7749 there is a more specific library which uses this
7750 argument. If this argument is a default, we need not
7751 consider that more specific library. */
7752 ok = used_arg (this_arg, p - this_arg);
7753 if (not_arg)
7754 ok = ! ok;
7756 if (! ok)
7757 ndfltok = 0;
7759 if (default_arg (this_arg, p - this_arg))
7760 ok = 1;
7762 if (*p == ' ')
7763 ++p;
7766 if (ok && first)
7768 if (this_path_len != 1
7769 || this_path[0] != '.')
7771 char *new_multilib_dir = XNEWVEC (char, this_path_len + 1);
7772 char *q;
7774 strncpy (new_multilib_dir, this_path, this_path_len);
7775 new_multilib_dir[this_path_len] = '\0';
7776 q = strchr (new_multilib_dir, ':');
7777 if (q != NULL)
7778 *q = '\0';
7779 multilib_dir = new_multilib_dir;
7781 first = 0;
7784 if (ndfltok)
7786 const char *q = this_path, *end = this_path + this_path_len;
7788 while (q < end && *q != ':')
7789 q++;
7790 if (q < end)
7792 const char *q2 = q + 1, *ml_end = end;
7793 char *new_multilib_os_dir;
7795 while (q2 < end && *q2 != ':')
7796 q2++;
7797 if (*q2 == ':')
7798 ml_end = q2;
7799 new_multilib_os_dir = XNEWVEC (char, ml_end - q);
7800 memcpy (new_multilib_os_dir, q + 1, ml_end - q - 1);
7801 new_multilib_os_dir[ml_end - q - 1] = '\0';
7802 multilib_os_dir = *new_multilib_os_dir ? new_multilib_os_dir : ".";
7804 if (q2 < end && *q2 == ':')
7806 char *new_multiarch_dir = XNEWVEC (char, end - q2);
7807 memcpy (new_multiarch_dir, q2 + 1, end - q2 - 1);
7808 new_multiarch_dir[end - q2 - 1] = '\0';
7809 multiarch_dir = new_multiarch_dir;
7811 break;
7815 ++p;
7818 if (multilib_dir == NULL && multilib_os_dir != NULL
7819 && strcmp (multilib_os_dir, ".") == 0)
7821 free (CONST_CAST (char *, multilib_os_dir));
7822 multilib_os_dir = NULL;
7824 else if (multilib_dir != NULL && multilib_os_dir == NULL)
7825 multilib_os_dir = multilib_dir;
7828 /* Print out the multiple library subdirectory selection
7829 information. This prints out a series of lines. Each line looks
7830 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
7831 required. Only the desired options are printed out, the negative
7832 matches. The options are print without a leading dash. There are
7833 no spaces to make it easy to use the information in the shell.
7834 Each subdirectory is printed only once. This assumes the ordering
7835 generated by the genmultilib script. Also, we leave out ones that match
7836 the exclusions. */
7838 static void
7839 print_multilib_info (void)
7841 const char *p = multilib_select;
7842 const char *last_path = 0, *this_path;
7843 int skip;
7844 unsigned int last_path_len = 0;
7846 while (*p != '\0')
7848 skip = 0;
7849 /* Ignore newlines. */
7850 if (*p == '\n')
7852 ++p;
7853 continue;
7856 /* Get the initial path. */
7857 this_path = p;
7858 while (*p != ' ')
7860 if (*p == '\0')
7862 invalid_select:
7863 fatal_error ("multilib select %qs is invalid", multilib_select);
7866 ++p;
7869 /* When --disable-multilib was used but target defines
7870 MULTILIB_OSDIRNAMES, entries starting with .: (and not starting
7871 with .:: for multiarch configurations) are there just to find
7872 multilib_os_dir, so skip them from output. */
7873 if (this_path[0] == '.' && this_path[1] == ':' && this_path[2] != ':')
7874 skip = 1;
7876 /* Check for matches with the multilib_exclusions. We don't bother
7877 with the '!' in either list. If any of the exclusion rules match
7878 all of its options with the select rule, we skip it. */
7880 const char *e = multilib_exclusions;
7881 const char *this_arg;
7883 while (*e != '\0')
7885 int m = 1;
7886 /* Ignore newlines. */
7887 if (*e == '\n')
7889 ++e;
7890 continue;
7893 /* Check the arguments. */
7894 while (*e != ';')
7896 const char *q;
7897 int mp = 0;
7899 if (*e == '\0')
7901 invalid_exclusion:
7902 fatal_error ("multilib exclusion %qs is invalid",
7903 multilib_exclusions);
7906 if (! m)
7908 ++e;
7909 continue;
7912 this_arg = e;
7914 while (*e != ' ' && *e != ';')
7916 if (*e == '\0')
7917 goto invalid_exclusion;
7918 ++e;
7921 q = p + 1;
7922 while (*q != ';')
7924 const char *arg;
7925 int len = e - this_arg;
7927 if (*q == '\0')
7928 goto invalid_select;
7930 arg = q;
7932 while (*q != ' ' && *q != ';')
7934 if (*q == '\0')
7935 goto invalid_select;
7936 ++q;
7939 if (! strncmp (arg, this_arg,
7940 (len < q - arg) ? q - arg : len)
7941 || default_arg (this_arg, e - this_arg))
7943 mp = 1;
7944 break;
7947 if (*q == ' ')
7948 ++q;
7951 if (! mp)
7952 m = 0;
7954 if (*e == ' ')
7955 ++e;
7958 if (m)
7960 skip = 1;
7961 break;
7964 if (*e != '\0')
7965 ++e;
7969 if (! skip)
7971 /* If this is a duplicate, skip it. */
7972 skip = (last_path != 0
7973 && (unsigned int) (p - this_path) == last_path_len
7974 && ! filename_ncmp (last_path, this_path, last_path_len));
7976 last_path = this_path;
7977 last_path_len = p - this_path;
7980 /* If this directory requires any default arguments, we can skip
7981 it. We will already have printed a directory identical to
7982 this one which does not require that default argument. */
7983 if (! skip)
7985 const char *q;
7987 q = p + 1;
7988 while (*q != ';')
7990 const char *arg;
7992 if (*q == '\0')
7993 goto invalid_select;
7995 if (*q == '!')
7996 arg = NULL;
7997 else
7998 arg = q;
8000 while (*q != ' ' && *q != ';')
8002 if (*q == '\0')
8003 goto invalid_select;
8004 ++q;
8007 if (arg != NULL
8008 && default_arg (arg, q - arg))
8010 skip = 1;
8011 break;
8014 if (*q == ' ')
8015 ++q;
8019 if (! skip)
8021 const char *p1;
8023 for (p1 = last_path; p1 < p && *p1 != ':'; p1++)
8024 putchar (*p1);
8025 putchar (';');
8028 ++p;
8029 while (*p != ';')
8031 int use_arg;
8033 if (*p == '\0')
8034 goto invalid_select;
8036 if (skip)
8038 ++p;
8039 continue;
8042 use_arg = *p != '!';
8044 if (use_arg)
8045 putchar ('@');
8047 while (*p != ' ' && *p != ';')
8049 if (*p == '\0')
8050 goto invalid_select;
8051 if (use_arg)
8052 putchar (*p);
8053 ++p;
8056 if (*p == ' ')
8057 ++p;
8060 if (! skip)
8062 /* If there are extra options, print them now. */
8063 if (multilib_extra && *multilib_extra)
8065 int print_at = TRUE;
8066 const char *q;
8068 for (q = multilib_extra; *q != '\0'; q++)
8070 if (*q == ' ')
8071 print_at = TRUE;
8072 else
8074 if (print_at)
8075 putchar ('@');
8076 putchar (*q);
8077 print_at = FALSE;
8082 putchar ('\n');
8085 ++p;
8089 /* getenv built-in spec function.
8091 Returns the value of the environment variable given by its first
8092 argument, concatenated with the second argument. If the
8093 environment variable is not defined, a fatal error is issued. */
8095 static const char *
8096 getenv_spec_function (int argc, const char **argv)
8098 char *value;
8099 char *result;
8100 char *ptr;
8101 size_t len;
8103 if (argc != 2)
8104 return NULL;
8106 value = getenv (argv[0]);
8107 if (!value)
8108 fatal_error ("environment variable %qs not defined", argv[0]);
8110 /* We have to escape every character of the environment variable so
8111 they are not interpreted as active spec characters. A
8112 particularly painful case is when we are reading a variable
8113 holding a windows path complete with \ separators. */
8114 len = strlen (value) * 2 + strlen (argv[1]) + 1;
8115 result = XNEWVAR (char, len);
8116 for (ptr = result; *value; ptr += 2)
8118 ptr[0] = '\\';
8119 ptr[1] = *value++;
8122 strcpy (ptr, argv[1]);
8124 return result;
8127 /* if-exists built-in spec function.
8129 Checks to see if the file specified by the absolute pathname in
8130 ARGS exists. Returns that pathname if found.
8132 The usual use for this function is to check for a library file
8133 (whose name has been expanded with %s). */
8135 static const char *
8136 if_exists_spec_function (int argc, const char **argv)
8138 /* Must have only one argument. */
8139 if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
8140 return argv[0];
8142 return NULL;
8145 /* if-exists-else built-in spec function.
8147 This is like if-exists, but takes an additional argument which
8148 is returned if the first argument does not exist. */
8150 static const char *
8151 if_exists_else_spec_function (int argc, const char **argv)
8153 /* Must have exactly two arguments. */
8154 if (argc != 2)
8155 return NULL;
8157 if (IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
8158 return argv[0];
8160 return argv[1];
8163 /* sanitize built-in spec function.
8165 This returns non-NULL, if sanitizing address, thread or
8166 any of the undefined behavior sanitizers. */
8168 static const char *
8169 sanitize_spec_function (int argc, const char **argv)
8171 if (argc != 1)
8172 return NULL;
8174 if (strcmp (argv[0], "address") == 0)
8175 return (flag_sanitize & SANITIZE_USER_ADDRESS) ? "" : NULL;
8176 if (strcmp (argv[0], "kernel-address") == 0)
8177 return (flag_sanitize & SANITIZE_KERNEL_ADDRESS) ? "" : NULL;
8178 if (strcmp (argv[0], "thread") == 0)
8179 return (flag_sanitize & SANITIZE_THREAD) ? "" : NULL;
8180 if (strcmp (argv[0], "undefined") == 0)
8181 return (flag_sanitize & SANITIZE_UNDEFINED) ? "" : NULL;
8182 if (strcmp (argv[0], "leak") == 0)
8183 return ((flag_sanitize
8184 & (SANITIZE_ADDRESS | SANITIZE_LEAK | SANITIZE_THREAD))
8185 == SANITIZE_LEAK) ? "" : NULL;
8186 return NULL;
8189 /* replace-outfile built-in spec function.
8191 This looks for the first argument in the outfiles array's name and
8192 replaces it with the second argument. */
8194 static const char *
8195 replace_outfile_spec_function (int argc, const char **argv)
8197 int i;
8198 /* Must have exactly two arguments. */
8199 if (argc != 2)
8200 abort ();
8202 for (i = 0; i < n_infiles; i++)
8204 if (outfiles[i] && !filename_cmp (outfiles[i], argv[0]))
8205 outfiles[i] = xstrdup (argv[1]);
8207 return NULL;
8210 /* remove-outfile built-in spec function.
8212 * This looks for the first argument in the outfiles array's name and
8213 * removes it. */
8215 static const char *
8216 remove_outfile_spec_function (int argc, const char **argv)
8218 int i;
8219 /* Must have exactly one argument. */
8220 if (argc != 1)
8221 abort ();
8223 for (i = 0; i < n_infiles; i++)
8225 if (outfiles[i] && !filename_cmp (outfiles[i], argv[0]))
8226 outfiles[i] = NULL;
8228 return NULL;
8231 /* Given two version numbers, compares the two numbers.
8232 A version number must match the regular expression
8233 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
8235 static int
8236 compare_version_strings (const char *v1, const char *v2)
8238 int rresult;
8239 regex_t r;
8241 if (regcomp (&r, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
8242 REG_EXTENDED | REG_NOSUB) != 0)
8243 abort ();
8244 rresult = regexec (&r, v1, 0, NULL, 0);
8245 if (rresult == REG_NOMATCH)
8246 fatal_error ("invalid version number %qs", v1);
8247 else if (rresult != 0)
8248 abort ();
8249 rresult = regexec (&r, v2, 0, NULL, 0);
8250 if (rresult == REG_NOMATCH)
8251 fatal_error ("invalid version number %qs", v2);
8252 else if (rresult != 0)
8253 abort ();
8255 return strverscmp (v1, v2);
8259 /* version_compare built-in spec function.
8261 This takes an argument of the following form:
8263 <comparison-op> <arg1> [<arg2>] <switch> <result>
8265 and produces "result" if the comparison evaluates to true,
8266 and nothing if it doesn't.
8268 The supported <comparison-op> values are:
8270 >= true if switch is a later (or same) version than arg1
8271 !> opposite of >=
8272 < true if switch is an earlier version than arg1
8273 !< opposite of <
8274 >< true if switch is arg1 or later, and earlier than arg2
8275 <> true if switch is earlier than arg1 or is arg2 or later
8277 If the switch is not present, the condition is false unless
8278 the first character of the <comparison-op> is '!'.
8280 For example,
8281 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
8282 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
8284 static const char *
8285 version_compare_spec_function (int argc, const char **argv)
8287 int comp1, comp2;
8288 size_t switch_len;
8289 const char *switch_value = NULL;
8290 int nargs = 1, i;
8291 bool result;
8293 if (argc < 3)
8294 fatal_error ("too few arguments to %%:version-compare");
8295 if (argv[0][0] == '\0')
8296 abort ();
8297 if ((argv[0][1] == '<' || argv[0][1] == '>') && argv[0][0] != '!')
8298 nargs = 2;
8299 if (argc != nargs + 3)
8300 fatal_error ("too many arguments to %%:version-compare");
8302 switch_len = strlen (argv[nargs + 1]);
8303 for (i = 0; i < n_switches; i++)
8304 if (!strncmp (switches[i].part1, argv[nargs + 1], switch_len)
8305 && check_live_switch (i, switch_len))
8306 switch_value = switches[i].part1 + switch_len;
8308 if (switch_value == NULL)
8309 comp1 = comp2 = -1;
8310 else
8312 comp1 = compare_version_strings (switch_value, argv[1]);
8313 if (nargs == 2)
8314 comp2 = compare_version_strings (switch_value, argv[2]);
8315 else
8316 comp2 = -1; /* This value unused. */
8319 switch (argv[0][0] << 8 | argv[0][1])
8321 case '>' << 8 | '=':
8322 result = comp1 >= 0;
8323 break;
8324 case '!' << 8 | '<':
8325 result = comp1 >= 0 || switch_value == NULL;
8326 break;
8327 case '<' << 8:
8328 result = comp1 < 0;
8329 break;
8330 case '!' << 8 | '>':
8331 result = comp1 < 0 || switch_value == NULL;
8332 break;
8333 case '>' << 8 | '<':
8334 result = comp1 >= 0 && comp2 < 0;
8335 break;
8336 case '<' << 8 | '>':
8337 result = comp1 < 0 || comp2 >= 0;
8338 break;
8340 default:
8341 fatal_error ("unknown operator %qs in %%:version-compare", argv[0]);
8343 if (! result)
8344 return NULL;
8346 return argv[nargs + 2];
8349 /* %:include builtin spec function. This differs from %include in that it
8350 can be nested inside a spec, and thus be conditionalized. It takes
8351 one argument, the filename, and looks for it in the startfile path.
8352 The result is always NULL, i.e. an empty expansion. */
8354 static const char *
8355 include_spec_function (int argc, const char **argv)
8357 char *file;
8359 if (argc != 1)
8360 abort ();
8362 file = find_a_file (&startfile_prefixes, argv[0], R_OK, true);
8363 read_specs (file ? file : argv[0], false, false);
8365 return NULL;
8368 /* %:find-file spec function. This function replaces its argument by
8369 the file found through find_file, that is the -print-file-name gcc
8370 program option. */
8371 static const char *
8372 find_file_spec_function (int argc, const char **argv)
8374 const char *file;
8376 if (argc != 1)
8377 abort ();
8379 file = find_file (argv[0]);
8380 return file;
8384 /* %:find-plugindir spec function. This function replaces its argument
8385 by the -iplugindir=<dir> option. `dir' is found through find_file, that
8386 is the -print-file-name gcc program option. */
8387 static const char *
8388 find_plugindir_spec_function (int argc, const char **argv ATTRIBUTE_UNUSED)
8390 const char *option;
8392 if (argc != 0)
8393 abort ();
8395 option = concat ("-iplugindir=", find_file ("plugin"), NULL);
8396 return option;
8400 /* %:print-asm-header spec function. Print a banner to say that the
8401 following output is from the assembler. */
8403 static const char *
8404 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED,
8405 const char **argv ATTRIBUTE_UNUSED)
8407 printf (_("Assembler options\n=================\n\n"));
8408 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
8409 fflush (stdout);
8410 return NULL;
8413 /* Get a random number for -frandom-seed */
8415 static unsigned HOST_WIDE_INT
8416 get_random_number (void)
8418 unsigned HOST_WIDE_INT ret = 0;
8419 int fd;
8421 fd = open ("/dev/urandom", O_RDONLY);
8422 if (fd >= 0)
8424 read (fd, &ret, sizeof (HOST_WIDE_INT));
8425 close (fd);
8426 if (ret)
8427 return ret;
8430 /* Get some more or less random data. */
8431 #ifdef HAVE_GETTIMEOFDAY
8433 struct timeval tv;
8435 gettimeofday (&tv, NULL);
8436 ret = tv.tv_sec * 1000 + tv.tv_usec / 1000;
8438 #else
8440 time_t now = time (NULL);
8442 if (now != (time_t)-1)
8443 ret = (unsigned) now;
8445 #endif
8447 return ret ^ getpid ();
8450 /* %:compare-debug-dump-opt spec function. Save the last argument,
8451 expected to be the last -fdump-final-insns option, or generate a
8452 temporary. */
8454 static const char *
8455 compare_debug_dump_opt_spec_function (int arg,
8456 const char **argv ATTRIBUTE_UNUSED)
8458 char *ret;
8459 char *name;
8460 int which;
8461 static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];
8463 if (arg != 0)
8464 fatal_error ("too many arguments to %%:compare-debug-dump-opt");
8466 do_spec_2 ("%{fdump-final-insns=*:%*}");
8467 do_spec_1 (" ", 0, NULL);
8469 if (argbuf.length () > 0
8470 && strcmp (argv[argbuf.length () - 1], "."))
8472 if (!compare_debug)
8473 return NULL;
8475 name = xstrdup (argv[argbuf.length () - 1]);
8476 ret = NULL;
8478 else
8480 const char *ext = NULL;
8482 if (argbuf.length () > 0)
8484 do_spec_2 ("%{o*:%*}%{!o:%{!S:%b%O}%{S:%b.s}}");
8485 ext = ".gkd";
8487 else if (!compare_debug)
8488 return NULL;
8489 else
8490 do_spec_2 ("%g.gkd");
8492 do_spec_1 (" ", 0, NULL);
8494 gcc_assert (argbuf.length () > 0);
8496 name = concat (argbuf.last (), ext, NULL);
8498 ret = concat ("-fdump-final-insns=", name, NULL);
8501 which = compare_debug < 0;
8502 debug_check_temp_file[which] = name;
8504 if (!which)
8506 unsigned HOST_WIDE_INT value = get_random_number ();
8508 sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value);
8511 if (*random_seed)
8513 char *tmp = ret;
8514 ret = concat ("%{!frandom-seed=*:-frandom-seed=", random_seed, "} ",
8515 ret, NULL);
8516 free (tmp);
8519 if (which)
8520 *random_seed = 0;
8522 return ret;
8525 static const char *debug_auxbase_opt;
8527 /* %:compare-debug-self-opt spec function. Expands to the options
8528 that are to be passed in the second compilation of
8529 compare-debug. */
8531 static const char *
8532 compare_debug_self_opt_spec_function (int arg,
8533 const char **argv ATTRIBUTE_UNUSED)
8535 if (arg != 0)
8536 fatal_error ("too many arguments to %%:compare-debug-self-opt");
8538 if (compare_debug >= 0)
8539 return NULL;
8541 do_spec_2 ("%{c|S:%{o*:%*}}");
8542 do_spec_1 (" ", 0, NULL);
8544 if (argbuf.length () > 0)
8545 debug_auxbase_opt = concat ("-auxbase-strip ",
8546 argbuf.last (),
8547 NULL);
8548 else
8549 debug_auxbase_opt = NULL;
8551 return concat ("\
8552 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
8553 %<fdump-final-insns=* -w -S -o %j \
8554 %{!fcompare-debug-second:-fcompare-debug-second} \
8555 ", compare_debug_opt, NULL);
8558 /* %:compare-debug-auxbase-opt spec function. Expands to the auxbase
8559 options that are to be passed in the second compilation of
8560 compare-debug. It expects, as an argument, the basename of the
8561 current input file name, with the .gk suffix appended to it. */
8563 static const char *
8564 compare_debug_auxbase_opt_spec_function (int arg,
8565 const char **argv)
8567 char *name;
8568 int len;
8570 if (arg == 0)
8571 fatal_error ("too few arguments to %%:compare-debug-auxbase-opt");
8573 if (arg != 1)
8574 fatal_error ("too many arguments to %%:compare-debug-auxbase-opt");
8576 if (compare_debug >= 0)
8577 return NULL;
8579 len = strlen (argv[0]);
8580 if (len < 3 || strcmp (argv[0] + len - 3, ".gk") != 0)
8581 fatal_error ("argument to %%:compare-debug-auxbase-opt "
8582 "does not end in .gk");
8584 if (debug_auxbase_opt)
8585 return debug_auxbase_opt;
8587 #define OPT "-auxbase "
8589 len -= 3;
8590 name = (char*) xmalloc (sizeof (OPT) + len);
8591 memcpy (name, OPT, sizeof (OPT) - 1);
8592 memcpy (name + sizeof (OPT) - 1, argv[0], len);
8593 name[sizeof (OPT) - 1 + len] = '\0';
8595 #undef OPT
8597 return name;
8600 /* %:pass-through-libs spec function. Finds all -l options and input
8601 file names in the lib spec passed to it, and makes a list of them
8602 prepended with the plugin option to cause them to be passed through
8603 to the final link after all the new object files have been added. */
8605 const char *
8606 pass_through_libs_spec_func (int argc, const char **argv)
8608 char *prepended = xstrdup (" ");
8609 int n;
8610 /* Shlemiel the painter's algorithm. Innately horrible, but at least
8611 we know that there will never be more than a handful of strings to
8612 concat, and it's only once per run, so it's not worth optimising. */
8613 for (n = 0; n < argc; n++)
8615 char *old = prepended;
8616 /* Anything that isn't an option is a full path to an output
8617 file; pass it through if it ends in '.a'. Among options,
8618 pass only -l. */
8619 if (argv[n][0] == '-' && argv[n][1] == 'l')
8621 const char *lopt = argv[n] + 2;
8622 /* Handle both joined and non-joined -l options. If for any
8623 reason there's a trailing -l with no joined or following
8624 arg just discard it. */
8625 if (!*lopt && ++n >= argc)
8626 break;
8627 else if (!*lopt)
8628 lopt = argv[n];
8629 prepended = concat (prepended, "-plugin-opt=-pass-through=-l",
8630 lopt, " ", NULL);
8632 else if (!strcmp (".a", argv[n] + strlen (argv[n]) - 2))
8634 prepended = concat (prepended, "-plugin-opt=-pass-through=",
8635 argv[n], " ", NULL);
8637 if (prepended != old)
8638 free (old);
8640 return prepended;
8643 /* %:replace-extension spec function. Replaces the extension of the
8644 first argument with the second argument. */
8646 const char *
8647 replace_extension_spec_func (int argc, const char **argv)
8649 char *name;
8650 char *p;
8651 char *result;
8652 int i;
8654 if (argc != 2)
8655 fatal_error ("too few arguments to %%:replace-extension");
8657 name = xstrdup (argv[0]);
8659 for (i = strlen (name) - 1; i >= 0; i--)
8660 if (IS_DIR_SEPARATOR (name[i]))
8661 break;
8663 p = strrchr (name + i + 1, '.');
8664 if (p != NULL)
8665 *p = '\0';
8667 result = concat (name, argv[1], NULL);
8669 free (name);
8670 return result;
8673 /* Insert backslash before spaces in ORIG (usually a file path), to
8674 avoid being broken by spec parser.
8676 This function is needed as do_spec_1 treats white space (' ' and '\t')
8677 as the end of an argument. But in case of -plugin /usr/gcc install/xxx.so,
8678 the file name should be treated as a single argument rather than being
8679 broken into multiple. Solution is to insert '\\' before the space in a
8680 file name.
8682 This function converts and only converts all occurrence of ' '
8683 to '\\' + ' ' and '\t' to '\\' + '\t'. For example:
8684 "a b" -> "a\\ b"
8685 "a b" -> "a\\ \\ b"
8686 "a\tb" -> "a\\\tb"
8687 "a\\ b" -> "a\\\\ b"
8689 orig: input null-terminating string that was allocated by xalloc. The
8690 memory it points to might be freed in this function. Behavior undefined
8691 if ORIG wasn't xalloced or was freed already at entry.
8693 Return: ORIG if no conversion needed. Otherwise a newly allocated string
8694 that was converted from ORIG. */
8696 static char *
8697 convert_white_space (char *orig)
8699 int len, number_of_space = 0;
8701 for (len = 0; orig[len]; len++)
8702 if (orig[len] == ' ' || orig[len] == '\t') number_of_space++;
8704 if (number_of_space)
8706 char *new_spec = (char *) xmalloc (len + number_of_space + 1);
8707 int j, k;
8708 for (j = 0, k = 0; j <= len; j++, k++)
8710 if (orig[j] == ' ' || orig[j] == '\t')
8711 new_spec[k++] = '\\';
8712 new_spec[k] = orig[j];
8714 free (orig);
8715 return new_spec;
8717 else
8718 return orig;