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
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
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". */
32 #include "coretypes.h"
33 #include "multilib.h" /* before tm.h */
40 #include "diagnostic.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
53 /* By default there is no special suffix for host executables. */
54 #ifdef HOST_EXECUTABLE_SUFFIX
55 #define HAVE_HOST_EXECUTABLE_SUFFIX
57 #define HOST_EXECUTABLE_SUFFIX ""
60 /* By default, the suffix for target object files is ".o". */
61 #ifdef TARGET_OBJECT_SUFFIX
62 #define HAVE_TARGET_OBJECT_SUFFIX
64 #define TARGET_OBJECT_SUFFIX ".o"
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"
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. */
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
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
;
121 static const char *target_system_root
= 0;
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 */
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
;
160 static const char *spec_host_machine
= DEFAULT_REAL_TARGET_MACHINE
;
162 /* List of offload targets. */
164 static char *offload_targets
= NULL
;
166 /* Nonzero if cross-compiling.
167 When -b is used, the value comes from the `specs' file. */
169 #ifdef CROSS_DIRECTORY_STRUCTURE
170 static const char *cross_compile
= "1";
172 static const char *cross_compile
= "0";
175 /* Greatest exit code of sub-processes that has been encountered up to
177 static int greatest_status
= 1;
179 /* This is the obstack which we use to allocate many strings. */
181 static struct obstack obstack
;
183 /* This is the obstack to build an environment variable to pass to
184 collect2 that describes all of the relevant switches of what to
185 pass the compiler in building the list of pointers to constructors
188 static struct obstack collect_obstack
;
190 /* Forward declaration for prototypes. */
194 static void init_spec (void);
195 static void store_arg (const char *, int, int);
196 static void insert_wrapper (const char *);
197 static char *load_specs (const char *);
198 static void read_specs (const char *, bool, bool);
199 static void set_spec (const char *, const char *, bool);
200 static struct compiler
*lookup_compiler (const char *, size_t, const char *);
201 static char *build_search_list (const struct path_prefix
*, const char *,
203 static void xputenv (const char *);
204 static void putenv_from_prefixes (const struct path_prefix
*, const char *,
206 static int access_check (const char *, int);
207 static char *find_a_file (const struct path_prefix
*, const char *, int, bool);
208 static void add_prefix (struct path_prefix
*, const char *, const char *,
210 static void add_sysrooted_prefix (struct path_prefix
*, const char *,
211 const char *, int, int, int);
212 static char *skip_whitespace (char *);
213 static void delete_if_ordinary (const char *);
214 static void delete_temp_files (void);
215 static void delete_failure_queue (void);
216 static void clear_failure_queue (void);
217 static int check_live_switch (int, int);
218 static const char *handle_braces (const char *);
219 static inline bool input_suffix_matches (const char *, const char *);
220 static inline bool switch_matches (const char *, const char *, int);
221 static inline void mark_matching_switches (const char *, const char *, int);
222 static inline void process_marked_switches (void);
223 static const char *process_brace_body (const char *, const char *, const char *, int, int);
224 static const struct spec_function
*lookup_spec_function (const char *);
225 static const char *eval_spec_function (const char *, const char *);
226 static const char *handle_spec_function (const char *, bool *);
227 static char *save_string (const char *, int);
228 static void set_collect_gcc_options (void);
229 static int do_spec_1 (const char *, int, const char *);
230 static int do_spec_2 (const char *);
231 static void do_option_spec (const char *, const char *);
232 static void do_self_spec (const char *);
233 static const char *find_file (const char *);
234 static int is_directory (const char *, bool);
235 static const char *validate_switches (const char *, bool);
236 static void validate_all_switches (void);
237 static inline void validate_switches_from_spec (const char *, bool);
238 static void give_switch (int, int);
239 static int used_arg (const char *, int);
240 static int default_arg (const char *, int);
241 static void set_multilib_dir (void);
242 static void print_multilib_info (void);
243 static void perror_with_name (const char *);
244 static void display_help (void);
245 static void add_preprocessor_option (const char *, int);
246 static void add_assembler_option (const char *, int);
247 static void add_linker_option (const char *, int);
248 static void process_command (unsigned int, struct cl_decoded_option
*);
249 static int execute (void);
250 static void alloc_args (void);
251 static void clear_args (void);
252 static void fatal_signal (int);
253 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
254 static void init_gcc_specs (struct obstack
*, const char *, const char *,
257 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
258 static const char *convert_filename (const char *, int, int);
261 static void try_generate_repro (const char **argv
);
262 static const char *getenv_spec_function (int, const char **);
263 static const char *if_exists_spec_function (int, const char **);
264 static const char *if_exists_else_spec_function (int, const char **);
265 static const char *sanitize_spec_function (int, const char **);
266 static const char *replace_outfile_spec_function (int, const char **);
267 static const char *remove_outfile_spec_function (int, const char **);
268 static const char *version_compare_spec_function (int, const char **);
269 static const char *include_spec_function (int, const char **);
270 static const char *find_file_spec_function (int, const char **);
271 static const char *find_plugindir_spec_function (int, const char **);
272 static const char *print_asm_header_spec_function (int, const char **);
273 static const char *compare_debug_dump_opt_spec_function (int, const char **);
274 static const char *compare_debug_self_opt_spec_function (int, const char **);
275 static const char *compare_debug_auxbase_opt_spec_function (int, const char **);
276 static const char *pass_through_libs_spec_func (int, const char **);
277 static const char *replace_extension_spec_func (int, const char **);
278 static char *convert_white_space (char *);
280 /* The Specs Language
282 Specs are strings containing lines, each of which (if not blank)
283 is made up of a program name, and arguments separated by spaces.
284 The program name must be exact and start from root, since no path
285 is searched and it is unreliable to depend on the current working directory.
286 Redirection of input or output is not supported; the subprograms must
287 accept filenames saying what files to read and write.
289 In addition, the specs can contain %-sequences to substitute variable text
290 or for conditional text. Here is a table of all defined %-sequences.
291 Note that spaces are not generated automatically around the results of
292 expanding these sequences; therefore, you can concatenate them together
293 or with constant text in a single argument.
295 %% substitute one % into the program name or argument.
296 %i substitute the name of the input file being processed.
297 %b substitute the basename of the input file being processed.
298 This is the substring up to (and not including) the last period
299 and not including the directory unless -save-temps was specified
300 to put temporaries in a different location.
301 %B same as %b, but include the file suffix (text after the last period).
303 substitute a file name that has suffix SUFFIX and is chosen
304 once per compilation, and mark the argument a la %d. To reduce
305 exposure to denial-of-service attacks, the file name is now
306 chosen in a way that is hard to predict even when previously
307 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
308 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
309 the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
310 had been pre-processed. Previously, %g was simply substituted
311 with a file name chosen once per compilation, without regard
312 to any appended suffix (which was therefore treated just like
313 ordinary text), making such attacks more likely to succeed.
315 like %g, but if -pipe is in effect, expands simply to "-".
317 like %g, but if -pipe is in effect, expands to nothing. (We have both
318 %| and %m to accommodate differences between system assemblers; see
319 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
321 like %g, but generates a new temporary file name even if %uSUFFIX
324 substitutes the last file name generated with %uSUFFIX, generating a
325 new one if there is no such last file name. In the absence of any
326 %uSUFFIX, this is just like %gSUFFIX, except they don't share
327 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
328 would involve the generation of two distinct file names, one
329 for each `%g.s' and another for each `%U.s'. Previously, %U was
330 simply substituted with a file name chosen for the previous %u,
331 without regard to any appended suffix.
333 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
334 writable, and if save-temps is off; otherwise, substitute the name
335 of a temporary file, just like %u. This temporary file is not
336 meant for communication between processes, but rather as a junk
339 substitutes .SUFFIX for the suffixes of a matched switch's args when
340 it is subsequently output with %*. SUFFIX is terminated by the next
342 %d marks the argument containing or following the %d as a
343 temporary file name, so that that file will be deleted if GCC exits
344 successfully. Unlike %g, this contributes no text to the argument.
345 %w marks the argument containing or following the %w as the
346 "output file" of this compilation. This puts the argument
347 into the sequence of arguments that %o will substitute later.
348 %V indicates that this compilation produces no "output file".
350 like %{...} but mark last argument supplied within
351 as a file to be deleted on failure.
352 %o substitutes the names of all the output files, with spaces
353 automatically placed around them. You should write spaces
354 around the %o as well or the results are undefined.
355 %o is for use in the specs for running the linker.
356 Input files whose names have no recognized suffix are not compiled
357 at all, but they are included among the output files, so they will
359 %O substitutes the suffix for object files. Note that this is
360 handled specially when it immediately follows %g, %u, or %U
361 (with or without a suffix argument) because of the need for
362 those to form complete file names. The handling is such that
363 %O is treated exactly as if it had already been substituted,
364 except that %g, %u, and %U do not currently support additional
365 SUFFIX characters following %O as they would following, for
367 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
368 (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
369 and -B options) and -imultilib as necessary.
370 %s current argument is the name of a library or startup file of some sort.
371 Search for that file in a standard list of directories
372 and substitute the full name found.
373 %eSTR Print STR as an error message. STR is terminated by a newline.
374 Use this when inconsistent options are detected.
375 %nSTR Print STR as a notice. STR is terminated by a newline.
376 %x{OPTION} Accumulate an option for %X.
377 %X Output the accumulated linker options specified by compilations.
378 %Y Output the accumulated assembler options specified by compilations.
379 %Z Output the accumulated preprocessor options specified by compilations.
380 %a process ASM_SPEC as a spec.
381 This allows config.h to specify part of the spec for running as.
382 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
383 used here. This can be used to run a post-processor after the
384 assembler has done its job.
385 %D Dump out a -L option for each directory in startfile_prefixes.
386 If multilib_dir is set, extra entries are generated with it affixed.
387 %l process LINK_SPEC as a spec.
388 %L process LIB_SPEC as a spec.
389 %M Output multilib_os_dir.
390 %G process LIBGCC_SPEC as a spec.
391 %R Output the concatenation of target_system_root and
392 target_sysroot_suffix.
393 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
394 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
395 %C process CPP_SPEC as a spec.
396 %1 process CC1_SPEC as a spec.
397 %2 process CC1PLUS_SPEC as a spec.
398 %* substitute the variable part of a matched option. (See below.)
399 Note that each comma in the substituted string is replaced by
400 a single space. A space is appended after the last substition
401 unless there is more text in current sequence.
402 %<S remove all occurrences of -S from the command line.
403 Note - this command is position dependent. % commands in the
404 spec string before this one will see -S, % commands in the
405 spec string after this one will not.
406 %>S Similar to "%<S", but keep it in the GCC command line.
407 %<S* remove all occurrences of all switches beginning with -S from the
410 Call the named function FUNCTION, passing it ARGS. ARGS is
411 first processed as a nested spec string, then split into an
412 argument vector in the usual fashion. The function returns
413 a string which is processed as if it had appeared literally
414 as part of the current spec.
415 %{S} substitutes the -S switch, if that switch was given to GCC.
416 If that switch was not specified, this substitutes nothing.
417 Here S is a metasyntactic variable.
418 %{S*} substitutes all the switches specified to GCC whose names start
419 with -S. This is used for -o, -I, etc; switches that take
420 arguments. GCC considers `-o foo' as being one switch whose
421 name starts with `o'. %{o*} would substitute this text,
422 including the space; thus, two arguments would be generated.
423 %{S*&T*} likewise, but preserve order of S and T options (the order
424 of S and T in the spec is not significant). Can be any number
425 of ampersand-separated variables; for each the wild card is
426 optional. Useful for CPP as %{D*&U*&A*}.
428 %{S:X} substitutes X, if the -S switch was given to GCC.
429 %{!S:X} substitutes X, if the -S switch was NOT given to GCC.
430 %{S*:X} substitutes X if one or more switches whose names start
431 with -S was given to GCC. Normally X is substituted only
432 once, no matter how many such switches appeared. However,
433 if %* appears somewhere in X, then X will be substituted
434 once for each matching switch, with the %* replaced by the
435 part of that switch that matched the '*'. A space will be
436 appended after the last substition unless there is more
437 text in current sequence.
438 %{.S:X} substitutes X, if processing a file with suffix S.
439 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
440 %{,S:X} substitutes X, if processing a file which will use spec S.
441 %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
443 %{S|T:X} substitutes X if either -S or -T was given to GCC. This may be
444 combined with '!', '.', ',', and '*' as above binding stronger
446 If %* appears in X, all of the alternatives must be starred, and
447 only the first matching alternative is substituted.
448 %{%:function(args):X}
449 Call function named FUNCTION with args ARGS. If the function
450 returns non-NULL, then X is substituted, if it returns
451 NULL, it isn't substituted.
452 %{S:X; if S was given to GCC, substitutes X;
453 T:Y; else if T was given to GCC, substitutes Y;
454 :D} else substitutes D. There can be as many clauses as you need.
455 This may be combined with '.', '!', ',', '|', and '*' as above.
457 %(Spec) processes a specification defined in a specs file as *Spec:
459 The conditional text X in a %{S:X} or similar construct may contain
460 other nested % constructs or spaces, or even newlines. They are
461 processed as usual, as described above. Trailing white space in X is
462 ignored. White space may also appear anywhere on the left side of the
463 colon in these constructs, except between . or * and the corresponding
466 The -O, -f, -g, -m, and -W switches are handled specifically in these
467 constructs. If another value of -O or the negated form of a -f, -m, or
468 -W switch is found later in the command line, the earlier switch
469 value is ignored, except with {S*} where S is just one letter; this
470 passes all matching options.
472 The character | at the beginning of the predicate text is used to indicate
473 that a command should be piped to the following command, but only if -pipe
476 Note that it is built into GCC which switches take arguments and which
477 do not. You might think it would be useful to generalize this to
478 allow each compiler's spec to say which switches take arguments. But
479 this cannot be done in a consistent fashion. GCC cannot even decide
480 which input files have been specified without knowing which switches
481 take arguments, and it must know which input files to compile in order
482 to tell which compilers to run.
484 GCC also knows implicitly that arguments starting in `-l' are to be
485 treated as compiler output files, and passed to the linker in their
486 proper position among the other output files. */
488 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
490 /* config.h can define ASM_SPEC to provide extra args to the assembler
491 or extra switch-translations. */
496 /* config.h can define ASM_FINAL_SPEC to run a post processor after
497 the assembler has run. */
498 #ifndef ASM_FINAL_SPEC
499 #define ASM_FINAL_SPEC \
501 objcopy --extract-dwo \
502 %{c:%{o*:%*}%{!o*:%b%O}}%{!c:%U%O} \
503 %{c:%{o*:%:replace-extension(%{o*:%*} .dwo)}%{!o*:%b.dwo}}%{!c:%b.dwo} \n\
504 objcopy --strip-dwo \
505 %{c:%{o*:%*}%{!o*:%b%O}}%{!c:%U%O} \
509 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
510 or extra switch-translations. */
515 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
516 or extra switch-translations. */
521 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
522 or extra switch-translations. */
524 #define CC1PLUS_SPEC ""
527 /* config.h can define LINK_SPEC to provide extra args to the linker
528 or extra switch-translations. */
533 /* config.h can define LIB_SPEC to override the default libraries. */
535 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
538 /* When using -fsplit-stack we need to wrap pthread_create, in order
539 to initialize the stack guard. We always use wrapping, rather than
540 shared library ordering, and we keep the wrapper function in
541 libgcc. This is not yet a real spec, though it could become one;
542 it is currently just stuffed into LINK_SPEC. FIXME: This wrapping
543 only works with GNU ld and gold. */
544 #define STACK_SPLIT_SPEC " %{fsplit-stack: --wrap=pthread_create}"
547 #define STATIC_LIBASAN_LIBS \
548 " %{static-libasan:%:include(libsanitizer.spec)%(link_libasan)}"
549 #ifdef LIBASAN_EARLY_SPEC
550 #define LIBASAN_SPEC STATIC_LIBASAN_LIBS
551 #elif defined(HAVE_LD_STATIC_DYNAMIC)
552 #define LIBASAN_SPEC "%{static-libasan:" LD_STATIC_OPTION \
553 "} -lasan %{static-libasan:" LD_DYNAMIC_OPTION "}" \
556 #define LIBASAN_SPEC "-lasan" STATIC_LIBASAN_LIBS
560 #ifndef LIBASAN_EARLY_SPEC
561 #define LIBASAN_EARLY_SPEC ""
565 #define STATIC_LIBTSAN_LIBS \
566 " %{static-libtsan:%:include(libsanitizer.spec)%(link_libtsan)}"
567 #ifdef LIBTSAN_EARLY_SPEC
568 #define LIBTSAN_SPEC STATIC_LIBTSAN_LIBS
569 #elif defined(HAVE_LD_STATIC_DYNAMIC)
570 #define LIBTSAN_SPEC "%{static-libtsan:" LD_STATIC_OPTION \
571 "} -ltsan %{static-libtsan:" LD_DYNAMIC_OPTION "}" \
574 #define LIBTSAN_SPEC "-ltsan" STATIC_LIBTSAN_LIBS
578 #ifndef LIBTSAN_EARLY_SPEC
579 #define LIBTSAN_EARLY_SPEC ""
583 #define STATIC_LIBLSAN_LIBS \
584 " %{static-liblsan:%:include(libsanitizer.spec)%(link_liblsan)}"
585 #ifdef LIBLSAN_EARLY_SPEC
586 #define LIBLSAN_SPEC STATIC_LIBLSAN_LIBS
587 #elif defined(HAVE_LD_STATIC_DYNAMIC)
588 #define LIBLSAN_SPEC "%{static-liblsan:" LD_STATIC_OPTION \
589 "} -llsan %{static-liblsan:" LD_DYNAMIC_OPTION "}" \
592 #define LIBLSAN_SPEC "-llsan" STATIC_LIBLSAN_LIBS
596 #ifndef LIBLSAN_EARLY_SPEC
597 #define LIBLSAN_EARLY_SPEC ""
600 #ifndef LIBUBSAN_SPEC
601 #define STATIC_LIBUBSAN_LIBS \
602 " %{static-libubsan:%:include(libsanitizer.spec)%(link_libubsan)}"
603 #ifdef HAVE_LD_STATIC_DYNAMIC
604 #define LIBUBSAN_SPEC "%{static-libubsan:" LD_STATIC_OPTION \
605 "} -lubsan %{static-libubsan:" LD_DYNAMIC_OPTION "}" \
608 #define LIBUBSAN_SPEC "-lubsan" STATIC_LIBUBSAN_LIBS
612 /* Linker options for compressed debug sections. */
613 #if HAVE_LD_COMPRESS_DEBUG == 0
614 /* No linker support. */
615 #define LINK_COMPRESS_DEBUG_SPEC \
616 " %{gz*:%e-gz is not supported in this configuration} "
617 #elif HAVE_LD_COMPRESS_DEBUG == 1
618 /* GNU style on input, GNU ld options. Reject, not useful. */
619 #define LINK_COMPRESS_DEBUG_SPEC \
620 " %{gz*:%e-gz is not supported in this configuration} "
621 #elif HAVE_LD_COMPRESS_DEBUG == 2
622 /* GNU style, GNU gold options. */
623 #define LINK_COMPRESS_DEBUG_SPEC \
624 " %{gz|gz=zlib-gnu:" LD_COMPRESS_DEBUG_OPTION "=zlib}" \
625 " %{gz=none:" LD_COMPRESS_DEBUG_OPTION "=none}" \
626 " %{gz=zlib:%e-gz=zlib is not supported in this configuration} "
627 #elif HAVE_LD_COMPRESS_DEBUG == 3
628 /* ELF gABI style. */
629 #define LINK_COMPRESS_DEBUG_SPEC \
630 " %{gz|gz=zlib:" LD_COMPRESS_DEBUG_OPTION "=zlib}" \
631 " %{gz=none:" LD_COMPRESS_DEBUG_OPTION "=none}" \
632 " %{gz=zlib-gnu:" LD_COMPRESS_DEBUG_OPTION "=zlib-gnu} "
634 #error Unknown value for HAVE_LD_COMPRESS_DEBUG.
637 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
640 #if defined(REAL_LIBGCC_SPEC)
641 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
642 #elif defined(LINK_LIBGCC_SPECIAL_1)
643 /* Have gcc do the search for libgcc.a. */
644 #define LIBGCC_SPEC "libgcc.a%s"
646 #define LIBGCC_SPEC "-lgcc"
650 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
651 #ifndef STARTFILE_SPEC
652 #define STARTFILE_SPEC \
653 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
656 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
658 #define ENDFILE_SPEC ""
662 #define LINKER_NAME "collect2"
665 #ifdef HAVE_AS_DEBUG_PREFIX_MAP
666 #define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
671 /* Assembler options for compressed debug sections. */
672 #if HAVE_LD_COMPRESS_DEBUG < 2
673 /* Reject if the linker cannot write compressed debug sections. */
674 #define ASM_COMPRESS_DEBUG_SPEC \
675 " %{gz*:%e-gz is not supported in this configuration} "
676 #else /* HAVE_LD_COMPRESS_DEBUG >= 2 */
677 #if HAVE_AS_COMPRESS_DEBUG == 0
678 /* No assembler support. Ignore silently. */
679 #define ASM_COMPRESS_DEBUG_SPEC \
681 #elif HAVE_AS_COMPRESS_DEBUG == 1
682 /* GNU style, GNU as options. */
683 #define ASM_COMPRESS_DEBUG_SPEC \
684 " %{gz|gz=zlib-gnu:" AS_COMPRESS_DEBUG_OPTION "}" \
685 " %{gz=none:" AS_NO_COMPRESS_DEBUG_OPTION "}" \
686 " %{gz=zlib:%e-gz=zlib is not supported in this configuration} "
687 #elif HAVE_AS_COMPRESS_DEBUG == 2
688 /* ELF gABI style. */
689 #define ASM_COMPRESS_DEBUG_SPEC \
690 " %{gz|gz=zlib:" AS_COMPRESS_DEBUG_OPTION "=zlib}" \
691 " %{gz=none:" AS_COMPRESS_DEBUG_OPTION "=none}" \
692 " %{gz=zlib-gnu:" AS_COMPRESS_DEBUG_OPTION "=zlib-gnu} "
694 #error Unknown value for HAVE_AS_COMPRESS_DEBUG.
696 #endif /* HAVE_LD_COMPRESS_DEBUG >= 2 */
698 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
700 #ifndef ASM_DEBUG_SPEC
701 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
702 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
703 # define ASM_DEBUG_SPEC \
704 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
705 ? "%{!g0:%{gdwarf*:--gdwarf2}%{!gdwarf*:%{g*:--gstabs}}}" ASM_MAP \
706 : "%{!g0:%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}}" ASM_MAP)
708 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
709 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gstabs}}" ASM_MAP
711 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
712 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gdwarf2}}" ASM_MAP
716 #ifndef ASM_DEBUG_SPEC
717 # define ASM_DEBUG_SPEC ""
720 /* Here is the spec for running the linker, after compiling all files. */
722 /* This is overridable by the target in case they need to specify the
723 -lgcc and -lc order specially, yet not require them to override all
724 of LINK_COMMAND_SPEC. */
725 #ifndef LINK_GCC_C_SEQUENCE_SPEC
726 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
729 #ifndef LINK_SSP_SPEC
730 #ifdef TARGET_LIBC_PROVIDES_SSP
731 #define LINK_SSP_SPEC "%{fstack-protector:}"
733 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-strong|fstack-protector-all:-lssp_nonshared -lssp}"
737 #ifndef LINK_PIE_SPEC
739 #define LINK_PIE_SPEC "%{pie:-pie} "
741 #define LINK_PIE_SPEC "%{pie:} "
745 #ifndef LINK_BUILDID_SPEC
746 # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
747 # define LINK_BUILDID_SPEC "%{!r:--build-id} "
751 /* Conditional to test whether the LTO plugin is used or not.
752 FIXME: For slim LTO we will need to enable plugin unconditionally. This
753 still cause problems with PLUGIN_LD != LD and when plugin is built but
754 not useable. For GCC 4.6 we don't support slim LTO and thus we can enable
755 plugin only when LTO is enabled. We still honor explicit
756 -fuse-linker-plugin if the linker used understands -plugin. */
758 /* The linker has some plugin support. */
759 #if HAVE_LTO_PLUGIN > 0
760 /* The linker used has full plugin support, use LTO plugin by default. */
761 #if HAVE_LTO_PLUGIN == 2
762 #define PLUGIN_COND "!fno-use-linker-plugin:%{!fno-lto"
763 #define PLUGIN_COND_CLOSE "}"
765 /* The linker used has limited plugin support, use LTO plugin with explicit
766 -fuse-linker-plugin. */
767 #define PLUGIN_COND "fuse-linker-plugin"
768 #define PLUGIN_COND_CLOSE ""
770 #define LINK_PLUGIN_SPEC \
772 -plugin %(linker_plugin_file) \
773 -plugin-opt=%(lto_wrapper) \
774 -plugin-opt=-fresolution=%u.res \
775 %{!nostdlib:%{!nodefaultlibs:%:pass-through-libs(%(link_gcc_c_sequence))}} \
778 /* The linker used doesn't support -plugin, reject -fuse-linker-plugin. */
779 #define LINK_PLUGIN_SPEC "%{fuse-linker-plugin:\
780 %e-fuse-linker-plugin is not supported in this configuration}"
783 /* Linker command line options for -fsanitize= early on the command line. */
784 #ifndef SANITIZER_EARLY_SPEC
785 #define SANITIZER_EARLY_SPEC "\
786 %{!nostdlib:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_EARLY_SPEC "} \
787 %{%:sanitize(thread):" LIBTSAN_EARLY_SPEC "} \
788 %{%:sanitize(leak):" LIBLSAN_EARLY_SPEC "}}}"
791 /* Linker command line options for -fsanitize= late on the command line. */
792 #ifndef SANITIZER_SPEC
793 #define SANITIZER_SPEC "\
794 %{!nostdlib:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_SPEC "\
795 %{static:%ecannot specify -static with -fsanitize=address}}\
796 %{%:sanitize(thread):" LIBTSAN_SPEC "\
797 %{static:%ecannot specify -static with -fsanitize=thread}}\
798 %{%:sanitize(undefined):" LIBUBSAN_SPEC "}\
799 %{%:sanitize(leak):" LIBLSAN_SPEC "}}}"
802 /* This is the spec to use, once the code for creating the vtable
803 verification runtime library, libvtv.so, has been created. Currently
804 the vtable verification runtime functions are in libstdc++, so we use
805 the spec just below this one. */
806 #ifndef VTABLE_VERIFICATION_SPEC
807 #define VTABLE_VERIFICATION_SPEC "\
808 %{!nostdlib:%{fvtable-verify=std: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}\
809 %{fvtable-verify=preinit: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}}"
812 /* -u* was put back because both BSD and SysV seem to support it. */
813 /* %{static:} simply prevents an error message if the target machine
814 doesn't handle -static. */
815 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
816 scripts which exist in user specified directories, or in standard
818 /* We pass any -flto flags on to the linker, which is expected
819 to understand them. In practice, this means it had better be collect2. */
820 /* %{e*} includes -export-dynamic; see comment in common.opt. */
821 #ifndef LINK_COMMAND_SPEC
822 #define LINK_COMMAND_SPEC "\
823 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
826 "%{flto|flto=*:%<fcompare-debug*} \
827 %{flto} %{fno-lto} %{flto=*} %l " LINK_PIE_SPEC \
828 "%{fuse-ld=*:-fuse-ld=%*} " LINK_COMPRESS_DEBUG_SPEC \
829 "%X %{o*} %{e*} %{N} %{n} %{r}\
830 %{s} %{t} %{u*} %{z} %{Z} %{!nostdlib:%{!nostartfiles:%S}} " VTABLE_VERIFICATION_SPEC " \
831 %{static:} %{L*} %(mfwrap) %(link_libgcc) " SANITIZER_EARLY_SPEC " %o\
832 %{fopenacc|fopenmp|ftree-parallelize-loops=*:%:include(libgomp.spec)%(link_gomp)}\
833 %{fcilkplus:%:include(libcilkrts.spec)%(link_cilkrts)}\
834 %{fgnu-tm:%:include(libitm.spec)%(link_itm)}\
835 %(mflib) " STACK_SPLIT_SPEC "\
836 %{fprofile-arcs|fprofile-generate*|coverage:-lgcov} " SANITIZER_SPEC " \
837 %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\
838 %{!nostdlib:%{!nostartfiles:%E}} %{T*} }}}}}}"
841 #ifndef LINK_LIBGCC_SPEC
842 /* Generate -L options for startfile prefix list. */
843 # define LINK_LIBGCC_SPEC "%D"
846 #ifndef STARTFILE_PREFIX_SPEC
847 # define STARTFILE_PREFIX_SPEC ""
851 # define SYSROOT_SPEC "--sysroot=%R"
854 #ifndef SYSROOT_SUFFIX_SPEC
855 # define SYSROOT_SUFFIX_SPEC ""
858 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
859 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
862 static const char *asm_debug
= ASM_DEBUG_SPEC
;
863 static const char *cpp_spec
= CPP_SPEC
;
864 static const char *cc1_spec
= CC1_SPEC
;
865 static const char *cc1plus_spec
= CC1PLUS_SPEC
;
866 static const char *link_gcc_c_sequence_spec
= LINK_GCC_C_SEQUENCE_SPEC
;
867 static const char *link_ssp_spec
= LINK_SSP_SPEC
;
868 static const char *asm_spec
= ASM_SPEC
;
869 static const char *asm_final_spec
= ASM_FINAL_SPEC
;
870 static const char *link_spec
= LINK_SPEC
;
871 static const char *lib_spec
= LIB_SPEC
;
872 static const char *link_gomp_spec
= "";
873 static const char *libgcc_spec
= LIBGCC_SPEC
;
874 static const char *endfile_spec
= ENDFILE_SPEC
;
875 static const char *startfile_spec
= STARTFILE_SPEC
;
876 static const char *linker_name_spec
= LINKER_NAME
;
877 static const char *linker_plugin_file_spec
= "";
878 static const char *lto_wrapper_spec
= "";
879 static const char *lto_gcc_spec
= "";
880 static const char *link_command_spec
= LINK_COMMAND_SPEC
;
881 static const char *link_libgcc_spec
= LINK_LIBGCC_SPEC
;
882 static const char *startfile_prefix_spec
= STARTFILE_PREFIX_SPEC
;
883 static const char *sysroot_spec
= SYSROOT_SPEC
;
884 static const char *sysroot_suffix_spec
= SYSROOT_SUFFIX_SPEC
;
885 static const char *sysroot_hdrs_suffix_spec
= SYSROOT_HEADERS_SUFFIX_SPEC
;
886 static const char *self_spec
= "";
888 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
889 There should be no need to override these in target dependent files,
890 but we need to copy them to the specs file so that newer versions
891 of the GCC driver can correctly drive older tool chains with the
892 appropriate -B options. */
894 /* When cpplib handles traditional preprocessing, get rid of this, and
895 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
896 that we default the front end language better. */
897 static const char *trad_capable_cpp
=
898 "cc1 -E %{traditional|traditional-cpp:-traditional-cpp}";
900 /* We don't wrap .d files in %W{} since a missing .d file, and
901 therefore no dependency entry, confuses make into thinking a .o
902 file that happens to exist is up-to-date. */
903 static const char *cpp_unique_options
=
904 "%{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\
905 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
906 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
907 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
908 %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
909 %{remap} %{g3|ggdb3|gstabs3|gcoff3|gxcoff3|gvms3:-dD}\
910 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
911 %{H} %C %{D*&U*&A*} %{i*} %Z %i\
914 /* This contains cpp options which are common with cc1_options and are passed
915 only when preprocessing only to avoid duplication. We pass the cc1 spec
916 options to the preprocessor so that it the cc1 spec may manipulate
917 options used to set target flags. Those special target flags settings may
918 in turn cause preprocessor symbols to be defined specially. */
919 static const char *cpp_options
=
920 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
921 %{f*} %{g*:%{!g0:%{g*} %{!fno-working-directory:-fworking-directory}}} %{O*}\
922 %{undef} %{save-temps*:-fpch-preprocess}";
924 /* This contains cpp options which are not passed when the preprocessor
925 output will be used by another program. */
926 static const char *cpp_debug_options
= "%{d*}";
928 /* NB: This is shared amongst all front-ends, except for Ada. */
929 static const char *cc1_options
=
930 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
931 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
932 %1 %{!Q:-quiet} %{!dumpbase:-dumpbase %B} %{d*} %{m*} %{aux-info*}\
933 %{fcompare-debug-second:%:compare-debug-auxbase-opt(%b)} \
934 %{!fcompare-debug-second:%{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}}%{!c:%{!S:-auxbase %b}} \
935 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
936 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
937 %{Qn:-fno-ident} %{Qy:} %{-help:--help}\
938 %{-target-help:--target-help}\
939 %{-version:--version}\
940 %{-help=*:--help=%*}\
941 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
942 %{fsyntax-only:-o %j} %{-param*}\
943 %{coverage:-fprofile-arcs -ftest-coverage}";
945 static const char *asm_options
=
946 "%{-target-help:%:print-asm-header()} "
948 /* If GNU AS is used, then convert -w (no warnings), -I, and -v
949 to the assembler equivalents. */
950 "%{v} %{w:-W} %{I*} "
952 ASM_COMPRESS_DEBUG_SPEC
953 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
955 static const char *invoke_as
=
956 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
958 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
959 %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
963 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
964 %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
968 /* Some compilers have limits on line lengths, and the multilib_select
969 and/or multilib_matches strings can be very long, so we build them at
971 static struct obstack multilib_obstack
;
972 static const char *multilib_select
;
973 static const char *multilib_matches
;
974 static const char *multilib_defaults
;
975 static const char *multilib_exclusions
;
976 static const char *multilib_reuse
;
978 /* Check whether a particular argument is a default argument. */
980 #ifndef MULTILIB_DEFAULTS
981 #define MULTILIB_DEFAULTS { "" }
984 static const char *const multilib_defaults_raw
[] = MULTILIB_DEFAULTS
;
986 #ifndef DRIVER_SELF_SPECS
987 #define DRIVER_SELF_SPECS ""
990 /* Linking to libgomp implies pthreads. This is particularly important
991 for targets that use different start files and suchlike. */
992 #ifndef GOMP_SELF_SPECS
993 #define GOMP_SELF_SPECS "%{fopenacc|fopenmp|ftree-parallelize-loops=*: " \
997 /* Likewise for -fgnu-tm. */
998 #ifndef GTM_SELF_SPECS
999 #define GTM_SELF_SPECS "%{fgnu-tm: -pthread}"
1002 /* Likewise for -fcilkplus. */
1003 #ifndef CILK_SELF_SPECS
1004 #define CILK_SELF_SPECS "%{fcilkplus: -pthread}"
1007 static const char *const driver_self_specs
[] = {
1008 "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
1009 DRIVER_SELF_SPECS
, CONFIGURE_SPECS
, GOMP_SELF_SPECS
, GTM_SELF_SPECS
,
1013 #ifndef OPTION_DEFAULT_SPECS
1014 #define OPTION_DEFAULT_SPECS { "", "" }
1023 static const struct default_spec
1024 option_default_specs
[] = { OPTION_DEFAULT_SPECS
};
1028 struct user_specs
*next
;
1029 const char *filename
;
1032 static struct user_specs
*user_specs_head
, *user_specs_tail
;
1035 /* Record the mapping from file suffixes for compilation specs. */
1039 const char *suffix
; /* Use this compiler for input files
1040 whose names end in this suffix. */
1042 const char *spec
; /* To use this compiler, run this spec. */
1044 const char *cpp_spec
; /* If non-NULL, substitute this spec
1045 for `%C', rather than the usual
1047 const int combinable
; /* If nonzero, compiler can deal with
1048 multiple source files at once (IMA). */
1049 const int needs_preprocessing
; /* If nonzero, source files need to
1050 be run through a preprocessor. */
1053 /* Pointer to a vector of `struct compiler' that gives the spec for
1054 compiling a file, based on its suffix.
1055 A file that does not end in any of these suffixes will be passed
1056 unchanged to the loader and nothing else will be done to it.
1058 An entry containing two 0s is used to terminate the vector.
1060 If multiple entries match a file, the last matching one is used. */
1062 static struct compiler
*compilers
;
1064 /* Number of entries in `compilers', not counting the null terminator. */
1066 static int n_compilers
;
1068 /* The default list of file name suffixes and their compilation specs. */
1070 static const struct compiler default_compilers
[] =
1072 /* Add lists of suffixes of known languages here. If those languages
1073 were not present when we built the driver, we will hit these copies
1074 and be given a more meaningful error than "file not used since
1075 linking is not done". */
1076 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0},
1077 {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
1078 {".mii", "#Objective-C++", 0, 0, 0},
1079 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
1080 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
1081 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
1082 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
1083 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
1084 {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
1085 {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
1086 {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
1087 {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
1088 {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
1089 {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
1090 {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
1091 {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
1092 {".r", "#Ratfor", 0, 0, 0},
1093 {".p", "#Pascal", 0, 0, 0}, {".pas", "#Pascal", 0, 0, 0},
1094 {".java", "#Java", 0, 0, 0}, {".class", "#Java", 0, 0, 0},
1095 {".zip", "#Java", 0, 0, 0}, {".jar", "#Java", 0, 0, 0},
1096 {".go", "#Go", 0, 1, 0},
1097 /* Next come the entries for C. */
1098 {".c", "@c", 0, 0, 1},
1100 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1101 external preprocessor if -save-temps is given. */
1102 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1105 %eGNU C no longer supports -traditional without -E}\
1106 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1107 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1108 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1110 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1111 cc1 %(cpp_unique_options) %(cc1_options)}}}\
1112 %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 1},
1114 "%{!E:%e-E or -x required when input is from standard input}\
1115 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
1116 {".h", "@c-header", 0, 0, 0},
1118 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1119 external preprocessor if -save-temps is given. */
1120 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1122 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1123 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1124 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1126 %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
1127 %W{o*:--output-pch=%*}}%V}\
1128 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1129 cc1 %(cpp_unique_options) %(cc1_options)\
1130 %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
1131 %W{o*:--output-pch=%*}}%V}}}}}}", 0, 0, 0},
1132 {".i", "@cpp-output", 0, 0, 0},
1134 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 0},
1135 {".s", "@assembler", 0, 0, 0},
1137 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 0, 0},
1138 {".sx", "@assembler-with-cpp", 0, 0, 0},
1139 {".S", "@assembler-with-cpp", 0, 0, 0},
1140 {"@assembler-with-cpp",
1141 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1142 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1143 %{E|M|MM:%(cpp_debug_options)}\
1144 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1145 as %(asm_debug) %(asm_options) %|.s %A }}}}"
1147 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1148 %{E|M|MM:%(cpp_debug_options)}\
1149 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1150 as %(asm_debug) %(asm_options) %m.s %A }}}}"
1155 /* Mark end of table. */
1159 /* Number of elements in default_compilers, not counting the terminator. */
1161 static const int n_default_compilers
= ARRAY_SIZE (default_compilers
) - 1;
1163 typedef char *char_p
; /* For DEF_VEC_P. */
1165 /* A vector of options to give to the linker.
1166 These options are accumulated by %x,
1167 and substituted into the linker command with %X. */
1168 static vec
<char_p
> linker_options
;
1170 /* A vector of options to give to the assembler.
1171 These options are accumulated by -Wa,
1172 and substituted into the assembler command with %Y. */
1173 static vec
<char_p
> assembler_options
;
1175 /* A vector of options to give to the preprocessor.
1176 These options are accumulated by -Wp,
1177 and substituted into the preprocessor command with %Z. */
1178 static vec
<char_p
> preprocessor_options
;
1181 skip_whitespace (char *p
)
1185 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1186 be considered whitespace. */
1187 if (p
[0] == '\n' && p
[1] == '\n' && p
[2] == '\n')
1189 else if (*p
== '\n' || *p
== ' ' || *p
== '\t')
1203 /* Structures to keep track of prefixes to try when looking for files. */
1207 const char *prefix
; /* String to prepend to the path. */
1208 struct prefix_list
*next
; /* Next in linked list. */
1209 int require_machine_suffix
; /* Don't use without machine_suffix. */
1210 /* 2 means try both machine_suffix and just_machine_suffix. */
1211 int priority
; /* Sort key - priority within list. */
1212 int os_multilib
; /* 1 if OS multilib scheme should be used,
1213 0 for GCC multilib scheme. */
1218 struct prefix_list
*plist
; /* List of prefixes to try */
1219 int max_len
; /* Max length of a prefix in PLIST */
1220 const char *name
; /* Name of this list (used in config stuff) */
1223 /* List of prefixes to try when looking for executables. */
1225 static struct path_prefix exec_prefixes
= { 0, 0, "exec" };
1227 /* List of prefixes to try when looking for startup (crt0) files. */
1229 static struct path_prefix startfile_prefixes
= { 0, 0, "startfile" };
1231 /* List of prefixes to try when looking for include files. */
1233 static struct path_prefix include_prefixes
= { 0, 0, "include" };
1235 /* Suffix to attach to directories searched for commands.
1236 This looks like `MACHINE/VERSION/'. */
1238 static const char *machine_suffix
= 0;
1240 /* Suffix to attach to directories searched for commands.
1241 This is just `MACHINE/'. */
1243 static const char *just_machine_suffix
= 0;
1245 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1247 static const char *gcc_exec_prefix
;
1249 /* Adjusted value of standard_libexec_prefix. */
1251 static const char *gcc_libexec_prefix
;
1253 /* Default prefixes to attach to command names. */
1255 #ifndef STANDARD_STARTFILE_PREFIX_1
1256 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1258 #ifndef STANDARD_STARTFILE_PREFIX_2
1259 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1262 #ifdef CROSS_DIRECTORY_STRUCTURE /* Don't use these prefixes for a cross compiler. */
1263 #undef MD_EXEC_PREFIX
1264 #undef MD_STARTFILE_PREFIX
1265 #undef MD_STARTFILE_PREFIX_1
1268 /* If no prefixes defined, use the null string, which will disable them. */
1269 #ifndef MD_EXEC_PREFIX
1270 #define MD_EXEC_PREFIX ""
1272 #ifndef MD_STARTFILE_PREFIX
1273 #define MD_STARTFILE_PREFIX ""
1275 #ifndef MD_STARTFILE_PREFIX_1
1276 #define MD_STARTFILE_PREFIX_1 ""
1279 /* These directories are locations set at configure-time based on the
1280 --prefix option provided to configure. Their initializers are
1281 defined in Makefile.in. These paths are not *directly* used when
1282 gcc_exec_prefix is set because, in that case, we know where the
1283 compiler has been installed, and use paths relative to that
1284 location instead. */
1285 static const char *const standard_exec_prefix
= STANDARD_EXEC_PREFIX
;
1286 static const char *const standard_libexec_prefix
= STANDARD_LIBEXEC_PREFIX
;
1287 static const char *const standard_bindir_prefix
= STANDARD_BINDIR_PREFIX
;
1288 static const char *const standard_startfile_prefix
= STANDARD_STARTFILE_PREFIX
;
1290 /* For native compilers, these are well-known paths containing
1291 components that may be provided by the system. For cross
1292 compilers, these paths are not used. */
1293 static const char *md_exec_prefix
= MD_EXEC_PREFIX
;
1294 static const char *md_startfile_prefix
= MD_STARTFILE_PREFIX
;
1295 static const char *md_startfile_prefix_1
= MD_STARTFILE_PREFIX_1
;
1296 static const char *const standard_startfile_prefix_1
1297 = STANDARD_STARTFILE_PREFIX_1
;
1298 static const char *const standard_startfile_prefix_2
1299 = STANDARD_STARTFILE_PREFIX_2
;
1301 /* A relative path to be used in finding the location of tools
1302 relative to the driver. */
1303 static const char *const tooldir_base_prefix
= TOOLDIR_BASE_PREFIX
;
1305 /* A prefix to be used when this is an accelerator compiler. */
1306 static const char *const accel_dir_suffix
= ACCEL_DIR_SUFFIX
;
1308 /* Subdirectory to use for locating libraries. Set by
1309 set_multilib_dir based on the compilation options. */
1311 static const char *multilib_dir
;
1313 /* Subdirectory to use for locating libraries in OS conventions. Set by
1314 set_multilib_dir based on the compilation options. */
1316 static const char *multilib_os_dir
;
1318 /* Subdirectory to use for locating libraries in multiarch conventions. Set by
1319 set_multilib_dir based on the compilation options. */
1321 static const char *multiarch_dir
;
1323 /* Structure to keep track of the specs that have been defined so far.
1324 These are accessed using %(specname) in a compiler or link
1329 /* The following 2 fields must be first */
1330 /* to allow EXTRA_SPECS to be initialized */
1331 const char *name
; /* name of the spec. */
1332 const char *ptr
; /* available ptr if no static pointer */
1334 /* The following fields are not initialized */
1335 /* by EXTRA_SPECS */
1336 const char **ptr_spec
; /* pointer to the spec itself. */
1337 struct spec_list
*next
; /* Next spec in linked list. */
1338 int name_len
; /* length of the name */
1339 bool user_p
; /* whether string come from file spec. */
1340 bool alloc_p
; /* whether string was allocated */
1343 #define INIT_STATIC_SPEC(NAME,PTR) \
1344 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, false, false }
1346 /* List of statically defined specs. */
1347 static struct spec_list static_specs
[] =
1349 INIT_STATIC_SPEC ("asm", &asm_spec
),
1350 INIT_STATIC_SPEC ("asm_debug", &asm_debug
),
1351 INIT_STATIC_SPEC ("asm_final", &asm_final_spec
),
1352 INIT_STATIC_SPEC ("asm_options", &asm_options
),
1353 INIT_STATIC_SPEC ("invoke_as", &invoke_as
),
1354 INIT_STATIC_SPEC ("cpp", &cpp_spec
),
1355 INIT_STATIC_SPEC ("cpp_options", &cpp_options
),
1356 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options
),
1357 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options
),
1358 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp
),
1359 INIT_STATIC_SPEC ("cc1", &cc1_spec
),
1360 INIT_STATIC_SPEC ("cc1_options", &cc1_options
),
1361 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec
),
1362 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec
),
1363 INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec
),
1364 INIT_STATIC_SPEC ("endfile", &endfile_spec
),
1365 INIT_STATIC_SPEC ("link", &link_spec
),
1366 INIT_STATIC_SPEC ("lib", &lib_spec
),
1367 INIT_STATIC_SPEC ("link_gomp", &link_gomp_spec
),
1368 INIT_STATIC_SPEC ("libgcc", &libgcc_spec
),
1369 INIT_STATIC_SPEC ("startfile", &startfile_spec
),
1370 INIT_STATIC_SPEC ("cross_compile", &cross_compile
),
1371 INIT_STATIC_SPEC ("version", &compiler_version
),
1372 INIT_STATIC_SPEC ("multilib", &multilib_select
),
1373 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults
),
1374 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra
),
1375 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches
),
1376 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions
),
1377 INIT_STATIC_SPEC ("multilib_options", &multilib_options
),
1378 INIT_STATIC_SPEC ("multilib_reuse", &multilib_reuse
),
1379 INIT_STATIC_SPEC ("linker", &linker_name_spec
),
1380 INIT_STATIC_SPEC ("linker_plugin_file", &linker_plugin_file_spec
),
1381 INIT_STATIC_SPEC ("lto_wrapper", <o_wrapper_spec
),
1382 INIT_STATIC_SPEC ("lto_gcc", <o_gcc_spec
),
1383 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec
),
1384 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix
),
1385 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix
),
1386 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1
),
1387 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec
),
1388 INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec
),
1389 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec
),
1390 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec
),
1391 INIT_STATIC_SPEC ("self_spec", &self_spec
),
1394 #ifdef EXTRA_SPECS /* additional specs needed */
1395 /* Structure to keep track of just the first two args of a spec_list.
1396 That is all that the EXTRA_SPECS macro gives us. */
1399 const char *const name
;
1400 const char *const ptr
;
1403 static const struct spec_list_1 extra_specs_1
[] = { EXTRA_SPECS
};
1404 static struct spec_list
*extra_specs
= (struct spec_list
*) 0;
1407 /* List of dynamically allocates specs that have been defined so far. */
1409 static struct spec_list
*specs
= (struct spec_list
*) 0;
1411 /* List of static spec functions. */
1413 static const struct spec_function static_spec_functions
[] =
1415 { "getenv", getenv_spec_function
},
1416 { "if-exists", if_exists_spec_function
},
1417 { "if-exists-else", if_exists_else_spec_function
},
1418 { "sanitize", sanitize_spec_function
},
1419 { "replace-outfile", replace_outfile_spec_function
},
1420 { "remove-outfile", remove_outfile_spec_function
},
1421 { "version-compare", version_compare_spec_function
},
1422 { "include", include_spec_function
},
1423 { "find-file", find_file_spec_function
},
1424 { "find-plugindir", find_plugindir_spec_function
},
1425 { "print-asm-header", print_asm_header_spec_function
},
1426 { "compare-debug-dump-opt", compare_debug_dump_opt_spec_function
},
1427 { "compare-debug-self-opt", compare_debug_self_opt_spec_function
},
1428 { "compare-debug-auxbase-opt", compare_debug_auxbase_opt_spec_function
},
1429 { "pass-through-libs", pass_through_libs_spec_func
},
1430 { "replace-extension", replace_extension_spec_func
},
1431 #ifdef EXTRA_SPEC_FUNCTIONS
1432 EXTRA_SPEC_FUNCTIONS
1437 static int processing_spec_function
;
1439 /* Add appropriate libgcc specs to OBSTACK, taking into account
1440 various permutations of -shared-libgcc, -shared, and such. */
1442 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1444 #ifndef USE_LD_AS_NEEDED
1445 #define USE_LD_AS_NEEDED 0
1449 init_gcc_specs (struct obstack
*obstack
, const char *shared_name
,
1450 const char *static_name
, const char *eh_name
)
1454 buf
= concat ("%{static|static-libgcc:", static_name
, " ", eh_name
, "}"
1455 "%{!static:%{!static-libgcc:"
1456 #if USE_LD_AS_NEEDED
1457 "%{!shared-libgcc:",
1458 static_name
, " " LD_AS_NEEDED_OPTION
" ",
1459 shared_name
, " " LD_NO_AS_NEEDED_OPTION
1462 shared_name
, "%{!shared: ", static_name
, "}"
1466 "%{!shared-libgcc:", static_name
, " ", eh_name
, "}"
1467 "%{shared-libgcc:", shared_name
, " ", static_name
, "}"
1471 "%{shared-libgcc:", shared_name
, "}"
1472 "%{!shared-libgcc:", static_name
, "}"
1475 "%{shared:", shared_name
, "}"
1480 obstack_grow (obstack
, buf
, strlen (buf
));
1483 #endif /* ENABLE_SHARED_LIBGCC */
1485 /* Initialize the specs lookup routines. */
1490 struct spec_list
*next
= (struct spec_list
*) 0;
1491 struct spec_list
*sl
= (struct spec_list
*) 0;
1495 return; /* Already initialized. */
1498 fnotice (stderr
, "Using built-in specs.\n");
1501 extra_specs
= XCNEWVEC (struct spec_list
, ARRAY_SIZE (extra_specs_1
));
1503 for (i
= ARRAY_SIZE (extra_specs_1
) - 1; i
>= 0; i
--)
1505 sl
= &extra_specs
[i
];
1506 sl
->name
= extra_specs_1
[i
].name
;
1507 sl
->ptr
= extra_specs_1
[i
].ptr
;
1509 sl
->name_len
= strlen (sl
->name
);
1510 sl
->ptr_spec
= &sl
->ptr
;
1515 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1517 sl
= &static_specs
[i
];
1522 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1523 /* ??? If neither -shared-libgcc nor --static-libgcc was
1524 seen, then we should be making an educated guess. Some proposed
1525 heuristics for ELF include:
1527 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1528 program will be doing dynamic loading, which will likely
1529 need the shared libgcc.
1531 (2) If "-ldl", then it's also a fair bet that we're doing
1534 (3) For each ET_DYN we're linking against (either through -lfoo
1535 or /some/path/foo.so), check to see whether it or one of
1536 its dependencies depends on a shared libgcc.
1540 If the runtime is fixed to look for program headers instead
1541 of calling __register_frame_info at all, for each object,
1542 use the shared libgcc if any EH symbol referenced.
1544 If crtstuff is fixed to not invoke __register_frame_info
1545 automatically, for each object, use the shared libgcc if
1546 any non-empty unwind section found.
1548 Doing any of this probably requires invoking an external program to
1549 do the actual object file scanning. */
1551 const char *p
= libgcc_spec
;
1554 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1555 when given the proper command line arguments. */
1558 if (in_sep
&& *p
== '-' && strncmp (p
, "-lgcc", 5) == 0)
1560 init_gcc_specs (&obstack
,
1562 #ifdef USE_LIBUNWIND_EXCEPTIONS
1568 #ifdef USE_LIBUNWIND_EXCEPTIONS
1569 # ifdef HAVE_LD_STATIC_DYNAMIC
1570 " %{!static:" LD_STATIC_OPTION
"} -lunwind"
1571 " %{!static:" LD_DYNAMIC_OPTION
"}"
1581 else if (in_sep
&& *p
== 'l' && strncmp (p
, "libgcc.a%s", 10) == 0)
1583 /* Ug. We don't know shared library extensions. Hope that
1584 systems that use this form don't do shared libraries. */
1585 init_gcc_specs (&obstack
,
1589 #ifdef USE_LIBUNWIND_EXCEPTIONS
1598 obstack_1grow (&obstack
, *p
);
1599 in_sep
= (*p
== ' ');
1604 obstack_1grow (&obstack
, '\0');
1605 libgcc_spec
= XOBFINISH (&obstack
, const char *);
1608 #ifdef USE_AS_TRADITIONAL_FORMAT
1609 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1611 static const char tf
[] = "--traditional-format ";
1612 obstack_grow (&obstack
, tf
, sizeof (tf
) - 1);
1613 obstack_grow0 (&obstack
, asm_spec
, strlen (asm_spec
));
1614 asm_spec
= XOBFINISH (&obstack
, const char *);
1618 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC || \
1619 defined LINKER_HASH_STYLE
1620 # ifdef LINK_BUILDID_SPEC
1621 /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. */
1622 obstack_grow (&obstack
, LINK_BUILDID_SPEC
, sizeof (LINK_BUILDID_SPEC
) - 1);
1624 # ifdef LINK_EH_SPEC
1625 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1626 obstack_grow (&obstack
, LINK_EH_SPEC
, sizeof (LINK_EH_SPEC
) - 1);
1628 # ifdef LINKER_HASH_STYLE
1629 /* Prepend --hash-style=LINKER_HASH_STYLE to whatever link_spec we had
1632 static const char hash_style
[] = "--hash-style=";
1633 obstack_grow (&obstack
, hash_style
, sizeof (hash_style
) - 1);
1634 obstack_grow (&obstack
, LINKER_HASH_STYLE
, sizeof (LINKER_HASH_STYLE
) - 1);
1635 obstack_1grow (&obstack
, ' ');
1638 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
1639 link_spec
= XOBFINISH (&obstack
, const char *);
1645 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1646 removed; If the spec starts with a + then SPEC is added to the end of the
1650 set_spec (const char *name
, const char *spec
, bool user_p
)
1652 struct spec_list
*sl
;
1653 const char *old_spec
;
1654 int name_len
= strlen (name
);
1657 /* If this is the first call, initialize the statically allocated specs. */
1660 struct spec_list
*next
= (struct spec_list
*) 0;
1661 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1663 sl
= &static_specs
[i
];
1670 /* See if the spec already exists. */
1671 for (sl
= specs
; sl
; sl
= sl
->next
)
1672 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, name
))
1677 /* Not found - make it. */
1678 sl
= XNEW (struct spec_list
);
1679 sl
->name
= xstrdup (name
);
1680 sl
->name_len
= name_len
;
1681 sl
->ptr_spec
= &sl
->ptr
;
1683 *(sl
->ptr_spec
) = "";
1688 old_spec
= *(sl
->ptr_spec
);
1689 *(sl
->ptr_spec
) = ((spec
[0] == '+' && ISSPACE ((unsigned char)spec
[1]))
1690 ? concat (old_spec
, spec
+ 1, NULL
)
1695 fnotice (stderr
, "Setting spec %s to '%s'\n\n", name
, *(sl
->ptr_spec
));
1698 /* Free the old spec. */
1699 if (old_spec
&& sl
->alloc_p
)
1700 free (CONST_CAST (char *, old_spec
));
1702 sl
->user_p
= user_p
;
1706 /* Accumulate a command (program name and args), and run it. */
1708 typedef const char *const_char_p
; /* For DEF_VEC_P. */
1710 /* Vector of pointers to arguments in the current line of specifications. */
1712 static vec
<const_char_p
> argbuf
;
1714 /* Were the options -c, -S or -E passed. */
1715 static int have_c
= 0;
1717 /* Was the option -o passed. */
1718 static int have_o
= 0;
1720 /* Pointer to output file name passed in with -o. */
1721 static const char *output_file
= 0;
1723 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1724 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
1727 static struct temp_name
{
1728 const char *suffix
; /* suffix associated with the code. */
1729 int length
; /* strlen (suffix). */
1730 int unique
; /* Indicates whether %g or %u/%U was used. */
1731 const char *filename
; /* associated filename. */
1732 int filename_length
; /* strlen (filename). */
1733 struct temp_name
*next
;
1736 /* Number of commands executed so far. */
1738 static int execution_count
;
1740 /* Number of commands that exited with a signal. */
1742 static int signal_count
;
1744 /* Allocate the argument vector. */
1752 /* Clear out the vector of arguments (after a command is executed). */
1757 argbuf
.truncate (0);
1760 /* Add one argument to the vector at the end.
1761 This is done when a space is seen or at the end of the line.
1762 If DELETE_ALWAYS is nonzero, the arg is a filename
1763 and the file should be deleted eventually.
1764 If DELETE_FAILURE is nonzero, the arg is a filename
1765 and the file should be deleted if this compilation fails. */
1768 store_arg (const char *arg
, int delete_always
, int delete_failure
)
1770 argbuf
.safe_push (arg
);
1772 if (delete_always
|| delete_failure
)
1775 /* If the temporary file we should delete is specified as
1776 part of a joined argument extract the filename. */
1778 && (p
= strrchr (arg
, '=')))
1780 record_temp_file (arg
, delete_always
, delete_failure
);
1784 /* Load specs from a file name named FILENAME, replacing occurrences of
1785 various different types of line-endings, \r\n, \n\r and just \r, with
1789 load_specs (const char *filename
)
1793 struct stat statbuf
;
1800 fnotice (stderr
, "Reading specs from %s\n", filename
);
1802 /* Open and stat the file. */
1803 desc
= open (filename
, O_RDONLY
, 0);
1805 pfatal_with_name (filename
);
1806 if (stat (filename
, &statbuf
) < 0)
1807 pfatal_with_name (filename
);
1809 /* Read contents of file into BUFFER. */
1810 buffer
= XNEWVEC (char, statbuf
.st_size
+ 1);
1811 readlen
= read (desc
, buffer
, (unsigned) statbuf
.st_size
);
1813 pfatal_with_name (filename
);
1814 buffer
[readlen
] = 0;
1817 specs
= XNEWVEC (char, readlen
+ 1);
1819 for (buffer_p
= buffer
; buffer_p
&& *buffer_p
; buffer_p
++)
1825 if (buffer_p
> buffer
&& *(buffer_p
- 1) == '\n') /* \n\r */
1827 else if (*(buffer_p
+ 1) == '\n') /* \r\n */
1841 /* Read compilation specs from a file named FILENAME,
1842 replacing the default ones.
1844 A suffix which starts with `*' is a definition for
1845 one of the machine-specific sub-specs. The "suffix" should be
1846 *asm, *cc1, *cpp, *link, *startfile, etc.
1847 The corresponding spec is stored in asm_spec, etc.,
1848 rather than in the `compilers' vector.
1850 Anything invalid in the file is a fatal error. */
1853 read_specs (const char *filename
, bool main_p
, bool user_p
)
1858 buffer
= load_specs (filename
);
1860 /* Scan BUFFER for specs, putting them in the vector. */
1866 char *in
, *out
, *p1
, *p2
, *p3
;
1868 /* Advance P in BUFFER to the next nonblank nocomment line. */
1869 p
= skip_whitespace (p
);
1873 /* Is this a special command that starts with '%'? */
1874 /* Don't allow this for the main specs file, since it would
1875 encourage people to overwrite it. */
1876 if (*p
== '%' && !main_p
)
1879 while (*p
&& *p
!= '\n')
1885 if (!strncmp (p1
, "%include", sizeof ("%include") - 1)
1886 && (p1
[sizeof "%include" - 1] == ' '
1887 || p1
[sizeof "%include" - 1] == '\t'))
1891 p1
+= sizeof ("%include");
1892 while (*p1
== ' ' || *p1
== '\t')
1895 if (*p1
++ != '<' || p
[-2] != '>')
1896 fatal_error ("specs %%include syntax malformed after "
1898 (long) (p1
- buffer
+ 1));
1901 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
1902 read_specs (new_filename
? new_filename
: p1
, false, user_p
);
1905 else if (!strncmp (p1
, "%include_noerr", sizeof "%include_noerr" - 1)
1906 && (p1
[sizeof "%include_noerr" - 1] == ' '
1907 || p1
[sizeof "%include_noerr" - 1] == '\t'))
1911 p1
+= sizeof "%include_noerr";
1912 while (*p1
== ' ' || *p1
== '\t')
1915 if (*p1
++ != '<' || p
[-2] != '>')
1916 fatal_error ("specs %%include syntax malformed after "
1918 (long) (p1
- buffer
+ 1));
1921 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
1923 read_specs (new_filename
, false, user_p
);
1924 else if (verbose_flag
)
1925 fnotice (stderr
, "could not find specs file %s\n", p1
);
1928 else if (!strncmp (p1
, "%rename", sizeof "%rename" - 1)
1929 && (p1
[sizeof "%rename" - 1] == ' '
1930 || p1
[sizeof "%rename" - 1] == '\t'))
1933 struct spec_list
*sl
;
1934 struct spec_list
*newsl
;
1936 /* Get original name. */
1937 p1
+= sizeof "%rename";
1938 while (*p1
== ' ' || *p1
== '\t')
1941 if (! ISALPHA ((unsigned char) *p1
))
1942 fatal_error ("specs %%rename syntax malformed after "
1944 (long) (p1
- buffer
));
1947 while (*p2
&& !ISSPACE ((unsigned char) *p2
))
1950 if (*p2
!= ' ' && *p2
!= '\t')
1951 fatal_error ("specs %%rename syntax malformed after "
1953 (long) (p2
- buffer
));
1957 while (*p2
== ' ' || *p2
== '\t')
1960 if (! ISALPHA ((unsigned char) *p2
))
1961 fatal_error ("specs %%rename syntax malformed after "
1963 (long) (p2
- buffer
));
1965 /* Get new spec name. */
1967 while (*p3
&& !ISSPACE ((unsigned char) *p3
))
1971 fatal_error ("specs %%rename syntax malformed after "
1973 (long) (p3
- buffer
));
1976 for (sl
= specs
; sl
; sl
= sl
->next
)
1977 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, p1
))
1981 fatal_error ("specs %s spec was not found to be renamed", p1
);
1983 if (strcmp (p1
, p2
) == 0)
1986 for (newsl
= specs
; newsl
; newsl
= newsl
->next
)
1987 if (strcmp (newsl
->name
, p2
) == 0)
1988 fatal_error ("%s: attempt to rename spec %qs to "
1989 "already defined spec %qs",
1994 fnotice (stderr
, "rename spec %s to %s\n", p1
, p2
);
1996 fnotice (stderr
, "spec is '%s'\n\n", *(sl
->ptr_spec
));
2000 set_spec (p2
, *(sl
->ptr_spec
), user_p
);
2002 free (CONST_CAST (char *, *(sl
->ptr_spec
)));
2004 *(sl
->ptr_spec
) = "";
2009 fatal_error ("specs unknown %% command after %ld characters",
2010 (long) (p1
- buffer
));
2013 /* Find the colon that should end the suffix. */
2015 while (*p1
&& *p1
!= ':' && *p1
!= '\n')
2018 /* The colon shouldn't be missing. */
2020 fatal_error ("specs file malformed after %ld characters",
2021 (long) (p1
- buffer
));
2023 /* Skip back over trailing whitespace. */
2025 while (p2
> buffer
&& (p2
[-1] == ' ' || p2
[-1] == '\t'))
2028 /* Copy the suffix to a string. */
2029 suffix
= save_string (p
, p2
- p
);
2030 /* Find the next line. */
2031 p
= skip_whitespace (p1
+ 1);
2033 fatal_error ("specs file malformed after %ld characters",
2034 (long) (p
- buffer
));
2037 /* Find next blank line or end of string. */
2038 while (*p1
&& !(*p1
== '\n' && (p1
[1] == '\n' || p1
[1] == '\0')))
2041 /* Specs end at the blank line and do not include the newline. */
2042 spec
= save_string (p
, p1
- p
);
2045 /* Delete backslash-newline sequences from the spec. */
2050 if (in
[0] == '\\' && in
[1] == '\n')
2052 else if (in
[0] == '#')
2053 while (*in
&& *in
!= '\n')
2061 if (suffix
[0] == '*')
2063 if (! strcmp (suffix
, "*link_command"))
2064 link_command_spec
= spec
;
2066 set_spec (suffix
+ 1, spec
, user_p
);
2070 /* Add this pair to the vector. */
2072 = XRESIZEVEC (struct compiler
, compilers
, n_compilers
+ 2);
2074 compilers
[n_compilers
].suffix
= suffix
;
2075 compilers
[n_compilers
].spec
= spec
;
2077 memset (&compilers
[n_compilers
], 0, sizeof compilers
[n_compilers
]);
2081 link_command_spec
= spec
;
2084 if (link_command_spec
== 0)
2085 fatal_error ("spec file has no spec for linking");
2088 /* Record the names of temporary files we tell compilers to write,
2089 and delete them at the end of the run. */
2091 /* This is the common prefix we use to make temp file names.
2092 It is chosen once for each run of this program.
2093 It is substituted into a spec by %g or %j.
2094 Thus, all temp file names contain this prefix.
2095 In practice, all temp file names start with this prefix.
2097 This prefix comes from the envvar TMPDIR if it is defined;
2098 otherwise, from the P_tmpdir macro if that is defined;
2099 otherwise, in /usr/tmp or /tmp;
2100 or finally the current directory if all else fails. */
2102 static const char *temp_filename
;
2104 /* Length of the prefix. */
2106 static int temp_filename_length
;
2108 /* Define the list of temporary files to delete. */
2113 struct temp_file
*next
;
2116 /* Queue of files to delete on success or failure of compilation. */
2117 static struct temp_file
*always_delete_queue
;
2118 /* Queue of files to delete on failure of compilation. */
2119 static struct temp_file
*failure_delete_queue
;
2121 /* Record FILENAME as a file to be deleted automatically.
2122 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2123 otherwise delete it in any case.
2124 FAIL_DELETE nonzero means delete it if a compilation step fails;
2125 otherwise delete it in any case. */
2128 record_temp_file (const char *filename
, int always_delete
, int fail_delete
)
2130 char *const name
= xstrdup (filename
);
2134 struct temp_file
*temp
;
2135 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2136 if (! filename_cmp (name
, temp
->name
))
2139 temp
= XNEW (struct temp_file
);
2140 temp
->next
= always_delete_queue
;
2142 always_delete_queue
= temp
;
2149 struct temp_file
*temp
;
2150 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2151 if (! filename_cmp (name
, temp
->name
))
2157 temp
= XNEW (struct temp_file
);
2158 temp
->next
= failure_delete_queue
;
2160 failure_delete_queue
= temp
;
2166 /* Delete all the temporary files whose names we previously recorded. */
2168 #ifndef DELETE_IF_ORDINARY
2169 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2172 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2173 if (unlink (NAME) < 0) \
2175 perror_with_name (NAME); \
2180 delete_if_ordinary (const char *name
)
2186 printf ("Delete %s? (y or n) ", name
);
2190 while ((c
= getchar ()) != '\n' && c
!= EOF
)
2193 if (i
== 'y' || i
== 'Y')
2195 DELETE_IF_ORDINARY (name
, st
, verbose_flag
);
2199 delete_temp_files (void)
2201 struct temp_file
*temp
;
2203 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2204 delete_if_ordinary (temp
->name
);
2205 always_delete_queue
= 0;
2208 /* Delete all the files to be deleted on error. */
2211 delete_failure_queue (void)
2213 struct temp_file
*temp
;
2215 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2216 delete_if_ordinary (temp
->name
);
2220 clear_failure_queue (void)
2222 failure_delete_queue
= 0;
2225 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2227 If DO_MULTI is true iterate over the paths twice, first with multilib
2228 suffix then without, otherwise iterate over the paths once without
2229 adding a multilib suffix. When DO_MULTI is true, some attempt is made
2230 to avoid visiting the same path twice, but we could do better. For
2231 instance, /usr/lib/../lib is considered different from /usr/lib.
2232 At least EXTRA_SPACE chars past the end of the path passed to
2233 CALLBACK are available for use by the callback.
2234 CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2236 Returns the value returned by CALLBACK. */
2239 for_each_path (const struct path_prefix
*paths
,
2242 void *(*callback
) (char *, void *),
2243 void *callback_info
)
2245 struct prefix_list
*pl
;
2246 const char *multi_dir
= NULL
;
2247 const char *multi_os_dir
= NULL
;
2248 const char *multiarch_suffix
= NULL
;
2249 const char *multi_suffix
;
2250 const char *just_multi_suffix
;
2253 bool skip_multi_dir
= false;
2254 bool skip_multi_os_dir
= false;
2256 multi_suffix
= machine_suffix
;
2257 just_multi_suffix
= just_machine_suffix
;
2258 if (do_multi
&& multilib_dir
&& strcmp (multilib_dir
, ".") != 0)
2260 multi_dir
= concat (multilib_dir
, dir_separator_str
, NULL
);
2261 multi_suffix
= concat (multi_suffix
, multi_dir
, NULL
);
2262 just_multi_suffix
= concat (just_multi_suffix
, multi_dir
, NULL
);
2264 if (do_multi
&& multilib_os_dir
&& strcmp (multilib_os_dir
, ".") != 0)
2265 multi_os_dir
= concat (multilib_os_dir
, dir_separator_str
, NULL
);
2267 multiarch_suffix
= concat (multiarch_dir
, dir_separator_str
, NULL
);
2271 size_t multi_dir_len
= 0;
2272 size_t multi_os_dir_len
= 0;
2273 size_t multiarch_len
= 0;
2275 size_t just_suffix_len
;
2279 multi_dir_len
= strlen (multi_dir
);
2281 multi_os_dir_len
= strlen (multi_os_dir
);
2282 if (multiarch_suffix
)
2283 multiarch_len
= strlen (multiarch_suffix
);
2284 suffix_len
= strlen (multi_suffix
);
2285 just_suffix_len
= strlen (just_multi_suffix
);
2289 len
= paths
->max_len
+ extra_space
+ 1;
2290 len
+= MAX (MAX (suffix_len
, multi_os_dir_len
), multiarch_len
);
2291 path
= XNEWVEC (char, len
);
2294 for (pl
= paths
->plist
; pl
!= 0; pl
= pl
->next
)
2296 len
= strlen (pl
->prefix
);
2297 memcpy (path
, pl
->prefix
, len
);
2299 /* Look first in MACHINE/VERSION subdirectory. */
2300 if (!skip_multi_dir
)
2302 memcpy (path
+ len
, multi_suffix
, suffix_len
+ 1);
2303 ret
= callback (path
, callback_info
);
2308 /* Some paths are tried with just the machine (ie. target)
2309 subdir. This is used for finding as, ld, etc. */
2311 && pl
->require_machine_suffix
== 2)
2313 memcpy (path
+ len
, just_multi_suffix
, just_suffix_len
+ 1);
2314 ret
= callback (path
, callback_info
);
2319 /* Now try the multiarch path. */
2321 && !pl
->require_machine_suffix
&& multiarch_dir
)
2323 memcpy (path
+ len
, multiarch_suffix
, multiarch_len
+ 1);
2324 ret
= callback (path
, callback_info
);
2329 /* Now try the base path. */
2330 if (!pl
->require_machine_suffix
2331 && !(pl
->os_multilib
? skip_multi_os_dir
: skip_multi_dir
))
2333 const char *this_multi
;
2334 size_t this_multi_len
;
2336 if (pl
->os_multilib
)
2338 this_multi
= multi_os_dir
;
2339 this_multi_len
= multi_os_dir_len
;
2343 this_multi
= multi_dir
;
2344 this_multi_len
= multi_dir_len
;
2348 memcpy (path
+ len
, this_multi
, this_multi_len
+ 1);
2352 ret
= callback (path
, callback_info
);
2360 if (multi_dir
== NULL
&& multi_os_dir
== NULL
)
2363 /* Run through the paths again, this time without multilibs.
2364 Don't repeat any we have already seen. */
2367 free (CONST_CAST (char *, multi_dir
));
2369 free (CONST_CAST (char *, multi_suffix
));
2370 multi_suffix
= machine_suffix
;
2371 free (CONST_CAST (char *, just_multi_suffix
));
2372 just_multi_suffix
= just_machine_suffix
;
2375 skip_multi_dir
= true;
2378 free (CONST_CAST (char *, multi_os_dir
));
2379 multi_os_dir
= NULL
;
2382 skip_multi_os_dir
= true;
2387 free (CONST_CAST (char *, multi_dir
));
2388 free (CONST_CAST (char *, multi_suffix
));
2389 free (CONST_CAST (char *, just_multi_suffix
));
2392 free (CONST_CAST (char *, multi_os_dir
));
2398 /* Callback for build_search_list. Adds path to obstack being built. */
2400 struct add_to_obstack_info
{
2407 add_to_obstack (char *path
, void *data
)
2409 struct add_to_obstack_info
*info
= (struct add_to_obstack_info
*) data
;
2411 if (info
->check_dir
&& !is_directory (path
, false))
2414 if (!info
->first_time
)
2415 obstack_1grow (info
->ob
, PATH_SEPARATOR
);
2417 obstack_grow (info
->ob
, path
, strlen (path
));
2419 info
->first_time
= false;
2423 /* Add or change the value of an environment variable, outputting the
2424 change to standard error if in verbose mode. */
2426 xputenv (const char *string
)
2429 fnotice (stderr
, "%s\n", string
);
2430 putenv (CONST_CAST (char *, string
));
2433 /* Build a list of search directories from PATHS.
2434 PREFIX is a string to prepend to the list.
2435 If CHECK_DIR_P is true we ensure the directory exists.
2436 If DO_MULTI is true, multilib paths are output first, then
2438 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2439 It is also used by the --print-search-dirs flag. */
2442 build_search_list (const struct path_prefix
*paths
, const char *prefix
,
2443 bool check_dir
, bool do_multi
)
2445 struct add_to_obstack_info info
;
2447 info
.ob
= &collect_obstack
;
2448 info
.check_dir
= check_dir
;
2449 info
.first_time
= true;
2451 obstack_grow (&collect_obstack
, prefix
, strlen (prefix
));
2452 obstack_1grow (&collect_obstack
, '=');
2454 for_each_path (paths
, do_multi
, 0, add_to_obstack
, &info
);
2456 obstack_1grow (&collect_obstack
, '\0');
2457 return XOBFINISH (&collect_obstack
, char *);
2460 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2464 putenv_from_prefixes (const struct path_prefix
*paths
, const char *env_var
,
2467 xputenv (build_search_list (paths
, env_var
, true, do_multi
));
2470 /* Check whether NAME can be accessed in MODE. This is like access,
2471 except that it never considers directories to be executable. */
2474 access_check (const char *name
, int mode
)
2480 if (stat (name
, &st
) < 0
2481 || S_ISDIR (st
.st_mode
))
2485 return access (name
, mode
);
2488 /* Callback for find_a_file. Appends the file name to the directory
2489 path. If the resulting file exists in the right mode, return the
2490 full pathname to the file. */
2492 struct file_at_path_info
{
2501 file_at_path (char *path
, void *data
)
2503 struct file_at_path_info
*info
= (struct file_at_path_info
*) data
;
2504 size_t len
= strlen (path
);
2506 memcpy (path
+ len
, info
->name
, info
->name_len
);
2507 len
+= info
->name_len
;
2509 /* Some systems have a suffix for executable files.
2510 So try appending that first. */
2511 if (info
->suffix_len
)
2513 memcpy (path
+ len
, info
->suffix
, info
->suffix_len
+ 1);
2514 if (access_check (path
, info
->mode
) == 0)
2519 if (access_check (path
, info
->mode
) == 0)
2525 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2526 access to check permissions. If DO_MULTI is true, search multilib
2527 paths then non-multilib paths, otherwise do not search multilib paths.
2528 Return 0 if not found, otherwise return its name, allocated with malloc. */
2531 find_a_file (const struct path_prefix
*pprefix
, const char *name
, int mode
,
2534 struct file_at_path_info info
;
2536 #ifdef DEFAULT_ASSEMBLER
2537 if (! strcmp (name
, "as") && access (DEFAULT_ASSEMBLER
, mode
) == 0)
2538 return xstrdup (DEFAULT_ASSEMBLER
);
2541 #ifdef DEFAULT_LINKER
2542 if (! strcmp (name
, "ld") && access (DEFAULT_LINKER
, mode
) == 0)
2543 return xstrdup (DEFAULT_LINKER
);
2546 /* Determine the filename to execute (special case for absolute paths). */
2548 if (IS_ABSOLUTE_PATH (name
))
2550 if (access (name
, mode
) == 0)
2551 return xstrdup (name
);
2557 info
.suffix
= (mode
& X_OK
) != 0 ? HOST_EXECUTABLE_SUFFIX
: "";
2558 info
.name_len
= strlen (info
.name
);
2559 info
.suffix_len
= strlen (info
.suffix
);
2562 return (char*) for_each_path (pprefix
, do_multi
,
2563 info
.name_len
+ info
.suffix_len
,
2564 file_at_path
, &info
);
2567 /* Ranking of prefixes in the sort list. -B prefixes are put before
2570 enum path_prefix_priority
2572 PREFIX_PRIORITY_B_OPT
,
2573 PREFIX_PRIORITY_LAST
2576 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
2577 order according to PRIORITY. Within each PRIORITY, new entries are
2580 If WARN is nonzero, we will warn if no file is found
2581 through this prefix. WARN should point to an int
2582 which will be set to 1 if this entry is used.
2584 COMPONENT is the value to be passed to update_path.
2586 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2587 the complete value of machine_suffix.
2588 2 means try both machine_suffix and just_machine_suffix. */
2591 add_prefix (struct path_prefix
*pprefix
, const char *prefix
,
2592 const char *component
, /* enum prefix_priority */ int priority
,
2593 int require_machine_suffix
, int os_multilib
)
2595 struct prefix_list
*pl
, **prev
;
2598 for (prev
= &pprefix
->plist
;
2599 (*prev
) != NULL
&& (*prev
)->priority
<= priority
;
2600 prev
= &(*prev
)->next
)
2603 /* Keep track of the longest prefix. */
2605 prefix
= update_path (prefix
, component
);
2606 len
= strlen (prefix
);
2607 if (len
> pprefix
->max_len
)
2608 pprefix
->max_len
= len
;
2610 pl
= XNEW (struct prefix_list
);
2611 pl
->prefix
= prefix
;
2612 pl
->require_machine_suffix
= require_machine_suffix
;
2613 pl
->priority
= priority
;
2614 pl
->os_multilib
= os_multilib
;
2616 /* Insert after PREV. */
2621 /* Same as add_prefix, but prepending target_system_root to prefix. */
2622 /* The target_system_root prefix has been relocated by gcc_exec_prefix. */
2624 add_sysrooted_prefix (struct path_prefix
*pprefix
, const char *prefix
,
2625 const char *component
,
2626 /* enum prefix_priority */ int priority
,
2627 int require_machine_suffix
, int os_multilib
)
2629 if (!IS_ABSOLUTE_PATH (prefix
))
2630 fatal_error ("system path %qs is not absolute", prefix
);
2632 if (target_system_root
)
2634 char *sysroot_no_trailing_dir_separator
= xstrdup (target_system_root
);
2635 size_t sysroot_len
= strlen (target_system_root
);
2638 && target_system_root
[sysroot_len
- 1] == DIR_SEPARATOR
)
2639 sysroot_no_trailing_dir_separator
[sysroot_len
- 1] = '\0';
2641 if (target_sysroot_suffix
)
2642 prefix
= concat (sysroot_no_trailing_dir_separator
,
2643 target_sysroot_suffix
, prefix
, NULL
);
2645 prefix
= concat (sysroot_no_trailing_dir_separator
, prefix
, NULL
);
2647 free (sysroot_no_trailing_dir_separator
);
2649 /* We have to override this because GCC's notion of sysroot
2650 moves along with GCC. */
2654 add_prefix (pprefix
, prefix
, component
, priority
,
2655 require_machine_suffix
, os_multilib
);
2658 /* Execute the command specified by the arguments on the current line of spec.
2659 When using pipes, this includes several piped-together commands
2660 with `|' between them.
2662 Return 0 if successful, -1 if failed. */
2668 int n_commands
; /* # of command. */
2670 struct pex_obj
*pex
;
2673 const char *prog
; /* program name. */
2674 const char **argv
; /* vector of args. */
2678 struct command
*commands
; /* each command buffer with above info. */
2680 gcc_assert (!processing_spec_function
);
2684 string
= find_a_file (&exec_prefixes
,
2685 argbuf
[0], X_OK
, false);
2688 insert_wrapper (wrapper_string
);
2691 /* Count # of piped commands. */
2692 for (n_commands
= 1, i
= 0; argbuf
.iterate (i
, &arg
); i
++)
2693 if (strcmp (arg
, "|") == 0)
2696 /* Get storage for each command. */
2697 commands
= (struct command
*) alloca (n_commands
* sizeof (struct command
));
2699 /* Split argbuf into its separate piped processes,
2700 and record info about each one.
2701 Also search for the programs that are to be run. */
2703 argbuf
.safe_push (0);
2705 commands
[0].prog
= argbuf
[0]; /* first command. */
2706 commands
[0].argv
= argbuf
.address ();
2708 if (!wrapper_string
)
2710 string
= find_a_file (&exec_prefixes
, commands
[0].prog
, X_OK
, false);
2711 commands
[0].argv
[0] = (string
) ? string
: commands
[0].argv
[0];
2714 for (n_commands
= 1, i
= 0; argbuf
.iterate (i
, &arg
); i
++)
2715 if (arg
&& strcmp (arg
, "|") == 0)
2716 { /* each command. */
2717 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2718 fatal_error ("-pipe not supported");
2720 argbuf
[i
] = 0; /* Termination of
2722 commands
[n_commands
].prog
= argbuf
[i
+ 1];
2723 commands
[n_commands
].argv
2724 = &(argbuf
.address ())[i
+ 1];
2725 string
= find_a_file (&exec_prefixes
, commands
[n_commands
].prog
,
2728 commands
[n_commands
].argv
[0] = string
;
2732 /* If -v, print what we are about to do, and maybe query. */
2736 /* For help listings, put a blank line between sub-processes. */
2737 if (print_help_list
)
2738 fputc ('\n', stderr
);
2740 /* Print each piped command as a separate line. */
2741 for (i
= 0; i
< n_commands
; i
++)
2743 const char *const *j
;
2745 if (verbose_only_flag
)
2747 for (j
= commands
[i
].argv
; *j
; j
++)
2750 for (p
= *j
; *p
; ++p
)
2751 if (!ISALNUM ((unsigned char) *p
)
2752 && *p
!= '_' && *p
!= '/' && *p
!= '-' && *p
!= '.')
2756 fprintf (stderr
, " \"");
2757 for (p
= *j
; *p
; ++p
)
2759 if (*p
== '"' || *p
== '\\' || *p
== '$')
2760 fputc ('\\', stderr
);
2763 fputc ('"', stderr
);
2765 /* If it's empty, print "". */
2767 fprintf (stderr
, " \"\"");
2769 fprintf (stderr
, " %s", *j
);
2773 for (j
= commands
[i
].argv
; *j
; j
++)
2774 /* If it's empty, print "". */
2776 fprintf (stderr
, " \"\"");
2778 fprintf (stderr
, " %s", *j
);
2780 /* Print a pipe symbol after all but the last command. */
2781 if (i
+ 1 != n_commands
)
2782 fprintf (stderr
, " |");
2783 fprintf (stderr
, "\n");
2786 if (verbose_only_flag
!= 0)
2788 /* verbose_only_flag should act as if the spec was
2789 executed, so increment execution_count before
2790 returning. This prevents spurious warnings about
2791 unused linker input files, etc. */
2796 fnotice (stderr
, "\nGo ahead? (y or n) ");
2800 while (getchar () != '\n')
2803 if (i
!= 'y' && i
!= 'Y')
2808 #ifdef ENABLE_VALGRIND_CHECKING
2809 /* Run the each command through valgrind. To simplify prepending the
2810 path to valgrind and the option "-q" (for quiet operation unless
2811 something triggers), we allocate a separate argv array. */
2813 for (i
= 0; i
< n_commands
; i
++)
2819 for (argc
= 0; commands
[i
].argv
[argc
] != NULL
; argc
++)
2822 argv
= XALLOCAVEC (const char *, argc
+ 3);
2824 argv
[0] = VALGRIND_PATH
;
2826 for (j
= 2; j
< argc
+ 2; j
++)
2827 argv
[j
] = commands
[i
].argv
[j
- 2];
2830 commands
[i
].argv
= argv
;
2831 commands
[i
].prog
= argv
[0];
2835 /* Run each piped subprocess. */
2837 pex
= pex_init (PEX_USE_PIPES
| ((report_times
|| report_times_to_file
)
2838 ? PEX_RECORD_TIMES
: 0),
2839 progname
, temp_filename
);
2841 fatal_error ("pex_init failed: %m");
2843 for (i
= 0; i
< n_commands
; i
++)
2847 const char *string
= commands
[i
].argv
[0];
2849 errmsg
= pex_run (pex
,
2850 ((i
+ 1 == n_commands
? PEX_LAST
: 0)
2851 | (string
== commands
[i
].prog
? PEX_SEARCH
: 0)),
2852 string
, CONST_CAST (char **, commands
[i
].argv
),
2857 fatal_error (errmsg
);
2861 pfatal_with_name (errmsg
);
2865 if (i
&& string
!= commands
[i
].prog
)
2866 free (CONST_CAST (char *, string
));
2871 /* Wait for all the subprocesses to finish. */
2875 struct pex_time
*times
= NULL
;
2878 statuses
= (int *) alloca (n_commands
* sizeof (int));
2879 if (!pex_get_status (pex
, n_commands
, statuses
))
2880 fatal_error ("failed to get exit status: %m");
2882 if (report_times
|| report_times_to_file
)
2884 times
= (struct pex_time
*) alloca (n_commands
* sizeof (struct pex_time
));
2885 if (!pex_get_times (pex
, n_commands
, times
))
2886 fatal_error ("failed to get process times: %m");
2891 for (i
= 0; i
< n_commands
; ++i
)
2893 int status
= statuses
[i
];
2895 if (WIFSIGNALED (status
))
2898 /* SIGPIPE is a special case. It happens in -pipe mode
2899 when the compiler dies before the preprocessor is done,
2900 or the assembler dies before the compiler is done.
2901 There's generally been an error already, and this is
2902 just fallout. So don't generate another error unless
2903 we would otherwise have succeeded. */
2904 if (WTERMSIG (status
) == SIGPIPE
2905 && (signal_count
|| greatest_status
>= MIN_FATAL_STATUS
))
2912 internal_error ("%s (program %s)",
2913 strsignal (WTERMSIG (status
)), commands
[i
].prog
);
2915 else if (WIFEXITED (status
)
2916 && WEXITSTATUS (status
) >= MIN_FATAL_STATUS
)
2918 /* For ICEs in cc1, cc1obj, cc1plus see if it is
2919 reproducible or not. */
2922 && WEXITSTATUS (status
) == ICE_EXIT_CODE
2924 && (p
= strrchr (commands
[0].argv
[0], DIR_SEPARATOR
))
2925 && ! strncmp (p
+ 1, "cc1", 3))
2926 try_generate_repro (commands
[0].argv
);
2927 if (WEXITSTATUS (status
) > greatest_status
)
2928 greatest_status
= WEXITSTATUS (status
);
2932 if (report_times
|| report_times_to_file
)
2934 struct pex_time
*pt
= ×
[i
];
2937 ut
= ((double) pt
->user_seconds
2938 + (double) pt
->user_microseconds
/ 1.0e6
);
2939 st
= ((double) pt
->system_seconds
2940 + (double) pt
->system_microseconds
/ 1.0e6
);
2945 fnotice (stderr
, "# %s %.2f %.2f\n",
2946 commands
[i
].prog
, ut
, st
);
2948 if (report_times_to_file
)
2951 const char *const *j
;
2953 fprintf (report_times_to_file
, "%g %g", ut
, st
);
2955 for (j
= &commands
[i
].prog
; *j
; j
= &commands
[i
].argv
[++c
])
2958 for (p
= *j
; *p
; ++p
)
2959 if (*p
== '"' || *p
== '\\' || *p
== '$'
2965 fprintf (report_times_to_file
, " \"");
2966 for (p
= *j
; *p
; ++p
)
2968 if (*p
== '"' || *p
== '\\' || *p
== '$')
2969 fputc ('\\', report_times_to_file
);
2970 fputc (*p
, report_times_to_file
);
2972 fputc ('"', report_times_to_file
);
2975 fprintf (report_times_to_file
, " %s", *j
);
2978 fputc ('\n', report_times_to_file
);
2984 if (commands
[0].argv
[0] != commands
[0].prog
)
2985 free (CONST_CAST (char *, commands
[0].argv
[0]));
2991 /* Find all the switches given to us
2992 and make a vector describing them.
2993 The elements of the vector are strings, one per switch given.
2994 If a switch uses following arguments, then the `part1' field
2995 is the switch itself and the `args' field
2996 is a null-terminated vector containing the following arguments.
2997 Bits in the `live_cond' field are:
2998 SWITCH_LIVE to indicate this switch is true in a conditional spec.
2999 SWITCH_FALSE to indicate this switch is overridden by a later switch.
3000 SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
3001 SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored
3002 in all do_spec calls afterwards. Used for %<S from self specs.
3003 The `validated' field is nonzero if any spec has looked at this switch;
3004 if it remains zero at the end of the run, it must be meaningless. */
3006 #define SWITCH_LIVE (1 << 0)
3007 #define SWITCH_FALSE (1 << 1)
3008 #define SWITCH_IGNORE (1 << 2)
3009 #define SWITCH_IGNORE_PERMANENTLY (1 << 3)
3010 #define SWITCH_KEEP_FOR_GCC (1 << 4)
3016 unsigned int live_cond
;
3022 static struct switchstr
*switches
;
3024 static int n_switches
;
3026 static int n_switches_alloc
;
3028 /* Set to zero if -fcompare-debug is disabled, positive if it's
3029 enabled and we're running the first compilation, negative if it's
3030 enabled and we're running the second compilation. For most of the
3031 time, it's in the range -1..1, but it can be temporarily set to 2
3032 or 3 to indicate that the -fcompare-debug flags didn't come from
3033 the command-line, but rather from the GCC_COMPARE_DEBUG environment
3034 variable, until a synthesized -fcompare-debug flag is added to the
3038 /* Set to nonzero if we've seen the -fcompare-debug-second flag. */
3039 int compare_debug_second
;
3041 /* Set to the flags that should be passed to the second compilation in
3042 a -fcompare-debug compilation. */
3043 const char *compare_debug_opt
;
3045 static struct switchstr
*switches_debug_check
[2];
3047 static int n_switches_debug_check
[2];
3049 static int n_switches_alloc_debug_check
[2];
3051 static char *debug_check_temp_file
[2];
3053 /* Language is one of three things:
3055 1) The name of a real programming language.
3056 2) NULL, indicating that no one has figured out
3058 3) '*', indicating that the file should be passed
3063 const char *language
;
3064 struct compiler
*incompiler
;
3069 /* Also a vector of input files specified. */
3071 static struct infile
*infiles
;
3075 static int n_infiles_alloc
;
3077 /* True if multiple input files are being compiled to a single
3080 static bool combine_inputs
;
3082 /* This counts the number of libraries added by lang_specific_driver, so that
3083 we can tell if there were any user supplied any files or libraries. */
3085 static int added_libraries
;
3087 /* And a vector of corresponding output files is made up later. */
3089 const char **outfiles
;
3091 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3093 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
3094 is true if we should look for an executable suffix. DO_OBJ
3095 is true if we should look for an object suffix. */
3098 convert_filename (const char *name
, int do_exe ATTRIBUTE_UNUSED
,
3099 int do_obj ATTRIBUTE_UNUSED
)
3101 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3109 len
= strlen (name
);
3111 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3112 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
3113 if (do_obj
&& len
> 2
3114 && name
[len
- 2] == '.'
3115 && name
[len
- 1] == 'o')
3117 obstack_grow (&obstack
, name
, len
- 2);
3118 obstack_grow0 (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
3119 name
= XOBFINISH (&obstack
, const char *);
3123 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3124 /* If there is no filetype, make it the executable suffix (which includes
3125 the "."). But don't get confused if we have just "-o". */
3126 if (! do_exe
|| TARGET_EXECUTABLE_SUFFIX
[0] == 0 || (len
== 2 && name
[0] == '-'))
3129 for (i
= len
- 1; i
>= 0; i
--)
3130 if (IS_DIR_SEPARATOR (name
[i
]))
3133 for (i
++; i
< len
; i
++)
3137 obstack_grow (&obstack
, name
, len
);
3138 obstack_grow0 (&obstack
, TARGET_EXECUTABLE_SUFFIX
,
3139 strlen (TARGET_EXECUTABLE_SUFFIX
));
3140 name
= XOBFINISH (&obstack
, const char *);
3147 /* Display the command line switches accepted by gcc. */
3151 printf (_("Usage: %s [options] file...\n"), progname
);
3152 fputs (_("Options:\n"), stdout
);
3154 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout
);
3155 fputs (_(" --help Display this information\n"), stdout
);
3156 fputs (_(" --target-help Display target specific command line options\n"), stdout
);
3157 fputs (_(" --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...]\n"), stdout
);
3158 fputs (_(" Display specific types of command line options\n"), stdout
);
3160 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout
);
3161 fputs (_(" --version Display compiler version information\n"), stdout
);
3162 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout
);
3163 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout
);
3164 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout
);
3165 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout
);
3166 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout
);
3167 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout
);
3168 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout
);
3170 -print-multiarch Display the target's normalized GNU triplet, used as\n\
3171 a component in the library path\n"), stdout
);
3172 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout
);
3174 -print-multi-lib Display the mapping between command line options and\n\
3175 multiple library search directories\n"), stdout
);
3176 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries\n"), stdout
);
3177 fputs (_(" -print-sysroot Display the target libraries directory\n"), stdout
);
3178 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n"), stdout
);
3179 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout
);
3180 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout
);
3181 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout
);
3182 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler\n"), stdout
);
3183 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n"), stdout
);
3184 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout
);
3185 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout
);
3186 fputs (_(" -save-temps=<arg> Do not delete intermediate files\n"), stdout
);
3188 -no-canonical-prefixes Do not canonicalize paths when building relative\n\
3189 prefixes to other gcc components\n"), stdout
);
3190 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout
);
3191 fputs (_(" -time Time the execution of each subprocess\n"), stdout
);
3192 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout
);
3193 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout
);
3195 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3196 and libraries\n"), stdout
);
3197 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout
);
3198 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout
);
3199 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout
);
3200 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout
);
3201 fputs (_(" -S Compile only; do not assemble or link\n"), stdout
);
3202 fputs (_(" -c Compile and assemble, but do not link\n"), stdout
);
3203 fputs (_(" -o <file> Place the output into <file>\n"), stdout
);
3204 fputs (_(" -pie Create a position independent executable\n"), stdout
);
3205 fputs (_(" -shared Create a shared library\n"), stdout
);
3207 -x <language> Specify the language of the following input files\n\
3208 Permissible languages include: c c++ assembler none\n\
3209 'none' means revert to the default behavior of\n\
3210 guessing the language based on the file's extension\n\
3214 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3215 passed on to the various sub-processes invoked by %s. In order to pass\n\
3216 other options on to these processes the -W<letter> options must be used.\n\
3219 /* The rest of the options are displayed by invocations of the various
3224 add_preprocessor_option (const char *option
, int len
)
3226 preprocessor_options
.safe_push (save_string (option
, len
));
3230 add_assembler_option (const char *option
, int len
)
3232 assembler_options
.safe_push (save_string (option
, len
));
3236 add_linker_option (const char *option
, int len
)
3238 linker_options
.safe_push (save_string (option
, len
));
3241 /* Allocate space for an input file in infiles. */
3246 if (n_infiles_alloc
== 0)
3248 n_infiles_alloc
= 16;
3249 infiles
= XNEWVEC (struct infile
, n_infiles_alloc
);
3251 else if (n_infiles_alloc
== n_infiles
)
3253 n_infiles_alloc
*= 2;
3254 infiles
= XRESIZEVEC (struct infile
, infiles
, n_infiles_alloc
);
3258 /* Store an input file with the given NAME and LANGUAGE in
3262 add_infile (const char *name
, const char *language
)
3265 infiles
[n_infiles
].name
= name
;
3266 infiles
[n_infiles
++].language
= language
;
3269 /* Allocate space for a switch in switches. */
3274 if (n_switches_alloc
== 0)
3276 n_switches_alloc
= 16;
3277 switches
= XNEWVEC (struct switchstr
, n_switches_alloc
);
3279 else if (n_switches_alloc
== n_switches
)
3281 n_switches_alloc
*= 2;
3282 switches
= XRESIZEVEC (struct switchstr
, switches
, n_switches_alloc
);
3286 /* Save an option OPT with N_ARGS arguments in array ARGS, marking it
3287 as validated if VALIDATED and KNOWN if it is an internal switch. */
3290 save_switch (const char *opt
, size_t n_args
, const char *const *args
,
3291 bool validated
, bool known
)
3294 switches
[n_switches
].part1
= opt
+ 1;
3296 switches
[n_switches
].args
= 0;
3299 switches
[n_switches
].args
= XNEWVEC (const char *, n_args
+ 1);
3300 memcpy (switches
[n_switches
].args
, args
, n_args
* sizeof (const char *));
3301 switches
[n_switches
].args
[n_args
] = NULL
;
3304 switches
[n_switches
].live_cond
= 0;
3305 switches
[n_switches
].validated
= validated
;
3306 switches
[n_switches
].known
= known
;
3307 switches
[n_switches
].ordering
= 0;
3311 /* Handle an option DECODED that is unknown to the option-processing
3315 driver_unknown_option_callback (const struct cl_decoded_option
*decoded
)
3317 const char *opt
= decoded
->arg
;
3318 if (opt
[1] == 'W' && opt
[2] == 'n' && opt
[3] == 'o' && opt
[4] == '-'
3319 && !(decoded
->errors
& CL_ERR_NEGATIVE
))
3321 /* Leave unknown -Wno-* options for the compiler proper, to be
3322 diagnosed only if there are warnings. */
3323 save_switch (decoded
->canonical_option
[0],
3324 decoded
->canonical_option_num_elements
- 1,
3325 &decoded
->canonical_option
[1], false, true);
3328 if (decoded
->opt_index
== OPT_SPECIAL_unknown
)
3330 /* Give it a chance to define it a a spec file. */
3331 save_switch (decoded
->canonical_option
[0],
3332 decoded
->canonical_option_num_elements
- 1,
3333 &decoded
->canonical_option
[1], false, false);
3340 /* Handle an option DECODED that is not marked as CL_DRIVER.
3341 LANG_MASK will always be CL_DRIVER. */
3344 driver_wrong_lang_callback (const struct cl_decoded_option
*decoded
,
3345 unsigned int lang_mask ATTRIBUTE_UNUSED
)
3347 /* At this point, non-driver options are accepted (and expected to
3348 be passed down by specs) unless marked to be rejected by the
3349 driver. Options to be rejected by the driver but accepted by the
3350 compilers proper are treated just like completely unknown
3352 const struct cl_option
*option
= &cl_options
[decoded
->opt_index
];
3354 if (option
->cl_reject_driver
)
3355 error ("unrecognized command line option %qs",
3356 decoded
->orig_option_with_args_text
);
3358 save_switch (decoded
->canonical_option
[0],
3359 decoded
->canonical_option_num_elements
- 1,
3360 &decoded
->canonical_option
[1], false, true);
3363 static const char *spec_lang
= 0;
3364 static int last_language_n_infiles
;
3366 /* Parse -foffload option argument. */
3369 handle_foffload_option (const char *arg
)
3371 const char *c
, *cur
, *n
, *next
, *end
;
3374 /* If option argument starts with '-' then no target is specified and we
3375 do not need to parse it. */
3379 end
= strchr (arg
, '=');
3381 end
= strchr (arg
, '\0');
3386 next
= strchr (cur
, ',');
3389 next
= (next
> end
) ? end
: next
;
3391 target
= XNEWVEC (char, next
- cur
+ 1);
3392 memcpy (target
, cur
, next
- cur
);
3393 target
[next
- cur
] = '\0';
3395 /* If 'disable' is passed to the option, stop parsing the option and clean
3396 the list of offload targets. */
3397 if (strcmp (target
, "disable") == 0)
3399 free (offload_targets
);
3400 offload_targets
= xstrdup ("");
3404 /* Check that GCC is configured to support the offload target. */
3405 c
= OFFLOAD_TARGETS
;
3408 n
= strchr (c
, ',');
3410 n
= strchr (c
, '\0');
3412 if (next
- cur
== n
- c
&& strncmp (target
, c
, n
- c
) == 0)
3415 c
= *n
? n
+ 1 : NULL
;
3419 fatal_error ("GCC is not configured to support %s as offload target",
3422 if (!offload_targets
)
3424 offload_targets
= target
;
3429 /* Check that the target hasn't already presented in the list. */
3430 c
= offload_targets
;
3433 n
= strchr (c
, ':');
3435 n
= strchr (c
, '\0');
3437 if (next
- cur
== n
- c
&& strncmp (c
, target
, n
- c
) == 0)
3444 /* If duplicate is not found, append the target to the list. */
3447 size_t offload_targets_len
= strlen (offload_targets
);
3449 = XRESIZEVEC (char, offload_targets
,
3450 offload_targets_len
+ next
- cur
+ 2);
3451 if (offload_targets_len
)
3452 offload_targets
[offload_targets_len
++] = ':';
3453 memcpy (offload_targets
+ offload_targets_len
, target
, next
- cur
);
3458 XDELETEVEC (target
);
3462 /* Handle a driver option; arguments and return value as for
3466 driver_handle_option (struct gcc_options
*opts
,
3467 struct gcc_options
*opts_set
,
3468 const struct cl_decoded_option
*decoded
,
3469 unsigned int lang_mask ATTRIBUTE_UNUSED
, int kind
,
3471 const struct cl_option_handlers
*handlers ATTRIBUTE_UNUSED
,
3472 diagnostic_context
*dc
)
3474 size_t opt_index
= decoded
->opt_index
;
3475 const char *arg
= decoded
->arg
;
3476 const char *compare_debug_replacement_opt
;
3477 int value
= decoded
->value
;
3478 bool validated
= false;
3479 bool do_save
= true;
3481 gcc_assert (opts
== &global_options
);
3482 gcc_assert (opts_set
== &global_options_set
);
3483 gcc_assert (kind
== DK_UNSPECIFIED
);
3484 gcc_assert (loc
== UNKNOWN_LOCATION
);
3485 gcc_assert (dc
== global_dc
);
3491 struct spec_list
*sl
;
3493 for (sl
= specs
; sl
; sl
= sl
->next
)
3494 printf ("*%s:\n%s\n\n", sl
->name
, *(sl
->ptr_spec
));
3495 if (link_command_spec
)
3496 printf ("*link_command:\n%s\n\n", link_command_spec
);
3500 case OPT_dumpversion
:
3501 printf ("%s\n", spec_version
);
3504 case OPT_dumpmachine
:
3505 printf ("%s\n", spec_machine
);
3511 /* CPP driver cannot obtain switch from cc1_options. */
3513 add_preprocessor_option ("--version", strlen ("--version"));
3514 add_assembler_option ("--version", strlen ("--version"));
3515 add_linker_option ("--version", strlen ("--version"));
3519 print_help_list
= 1;
3521 /* CPP driver cannot obtain switch from cc1_options. */
3523 add_preprocessor_option ("--help", 6);
3524 add_assembler_option ("--help", 6);
3525 add_linker_option ("--help", 6);
3529 print_subprocess_help
= 2;
3532 case OPT__target_help
:
3533 print_subprocess_help
= 1;
3535 /* CPP driver cannot obtain switch from cc1_options. */
3537 add_preprocessor_option ("--target-help", 13);
3538 add_assembler_option ("--target-help", 13);
3539 add_linker_option ("--target-help", 13);
3542 case OPT__no_sysroot_suffix
:
3543 case OPT_pass_exit_codes
:
3544 case OPT_print_search_dirs
:
3545 case OPT_print_file_name_
:
3546 case OPT_print_prog_name_
:
3547 case OPT_print_multi_lib
:
3548 case OPT_print_multi_directory
:
3549 case OPT_print_sysroot
:
3550 case OPT_print_multi_os_directory
:
3551 case OPT_print_multiarch
:
3552 case OPT_print_sysroot_headers_suffix
:
3555 /* These options set the variables specified in common.opt
3556 automatically, and do not need to be saved for spec
3561 case OPT_print_libgcc_file_name
:
3562 print_file_name
= "libgcc.a";
3566 case OPT_fuse_ld_bfd
:
3570 case OPT_fuse_ld_gold
:
3574 case OPT_fcompare_debug_second
:
3575 compare_debug_second
= 1;
3578 case OPT_fcompare_debug
:
3582 compare_debug_replacement_opt
= "-fcompare-debug=";
3584 goto compare_debug_with_arg
;
3587 compare_debug_replacement_opt
= "-fcompare-debug=-gtoggle";
3589 goto compare_debug_with_arg
;
3596 case OPT_fcompare_debug_
:
3597 compare_debug_replacement_opt
= decoded
->canonical_option
[0];
3598 compare_debug_with_arg
:
3599 gcc_assert (decoded
->canonical_option_num_elements
== 1);
3600 gcc_assert (arg
!= NULL
);
3605 if (compare_debug
< 0)
3606 compare_debug_opt
= NULL
;
3608 compare_debug_opt
= arg
;
3609 save_switch (compare_debug_replacement_opt
, 0, NULL
, validated
, true);
3612 case OPT_fdiagnostics_color_
:
3613 diagnostic_color_init (dc
, value
);
3619 /* Pass the rest of this option to the assembler. */
3621 /* Split the argument at commas. */
3623 for (j
= 0; arg
[j
]; j
++)
3626 add_assembler_option (arg
+ prev
, j
- prev
);
3630 /* Record the part after the last comma. */
3631 add_assembler_option (arg
+ prev
, j
- prev
);
3639 /* Pass the rest of this option to the preprocessor. */
3641 /* Split the argument at commas. */
3643 for (j
= 0; arg
[j
]; j
++)
3646 add_preprocessor_option (arg
+ prev
, j
- prev
);
3650 /* Record the part after the last comma. */
3651 add_preprocessor_option (arg
+ prev
, j
- prev
);
3659 /* Split the argument at commas. */
3661 for (j
= 0; arg
[j
]; j
++)
3664 add_infile (save_string (arg
+ prev
, j
- prev
), "*");
3667 /* Record the part after the last comma. */
3668 add_infile (arg
+ prev
, "*");
3674 add_infile (arg
, "*");
3678 case OPT_Xpreprocessor
:
3679 add_preprocessor_option (arg
, strlen (arg
));
3683 case OPT_Xassembler
:
3684 add_assembler_option (arg
, strlen (arg
));
3689 /* POSIX allows separation of -l and the lib arg; canonicalize
3690 by concatenating -l with its arg */
3691 add_infile (concat ("-l", arg
, NULL
), "*");
3696 /* Similarly, canonicalize -L for linkers that may not accept
3697 separate arguments. */
3698 save_switch (concat ("-L", arg
, NULL
), 0, NULL
, validated
, true);
3703 save_switch (concat ("-F", arg
, NULL
), 0, NULL
, validated
, true);
3706 case OPT_save_temps
:
3707 save_temps_flag
= SAVE_TEMPS_CWD
;
3711 case OPT_save_temps_
:
3712 if (strcmp (arg
, "cwd") == 0)
3713 save_temps_flag
= SAVE_TEMPS_CWD
;
3714 else if (strcmp (arg
, "obj") == 0
3715 || strcmp (arg
, "object") == 0)
3716 save_temps_flag
= SAVE_TEMPS_OBJ
;
3718 fatal_error ("%qs is an unknown -save-temps option",
3719 decoded
->orig_option_with_args_text
);
3722 case OPT_no_canonical_prefixes
:
3723 /* Already handled as a special case, so ignored here. */
3729 /* These options set the variables specified in common.opt
3730 automatically, but do need to be saved for spec
3736 struct user_specs
*user
= XNEW (struct user_specs
);
3738 user
->next
= (struct user_specs
*) 0;
3739 user
->filename
= arg
;
3740 if (user_specs_tail
)
3741 user_specs_tail
->next
= user
;
3743 user_specs_head
= user
;
3744 user_specs_tail
= user
;
3750 target_system_root
= arg
;
3751 target_system_root_changed
= 1;
3756 if (report_times_to_file
)
3757 fclose (report_times_to_file
);
3758 report_times_to_file
= fopen (arg
, "a");
3764 This is similar to -v except that there is no execution
3765 of the commands and the echoed arguments are quoted. It
3766 is intended for use in shell scripts to capture the
3767 driver-generated command line. */
3768 verbose_only_flag
++;
3775 size_t len
= strlen (arg
);
3777 /* Catch the case where the user has forgotten to append a
3778 directory separator to the path. Note, they may be using
3779 -B to add an executable name prefix, eg "i386-elf-", in
3780 order to distinguish between multiple installations of
3781 GCC in the same directory. Hence we must check to see
3782 if appending a directory separator actually makes a
3783 valid directory name. */
3784 if (!IS_DIR_SEPARATOR (arg
[len
- 1])
3785 && is_directory (arg
, false))
3787 char *tmp
= XNEWVEC (char, len
+ 2);
3789 tmp
[len
] = DIR_SEPARATOR
;
3794 add_prefix (&exec_prefixes
, arg
, NULL
,
3795 PREFIX_PRIORITY_B_OPT
, 0, 0);
3796 add_prefix (&startfile_prefixes
, arg
, NULL
,
3797 PREFIX_PRIORITY_B_OPT
, 0, 0);
3798 add_prefix (&include_prefixes
, arg
, NULL
,
3799 PREFIX_PRIORITY_B_OPT
, 0, 0);
3806 if (!strcmp (spec_lang
, "none"))
3807 /* Suppress the warning if -xnone comes after the last input
3808 file, because alternate command interfaces like g++ might
3809 find it useful to place -xnone after each input file. */
3812 last_language_n_infiles
= n_infiles
;
3818 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3819 arg
= convert_filename (arg
, ! have_c
, 0);
3822 /* Save the output name in case -save-temps=obj was used. */
3823 save_temps_prefix
= xstrdup (arg
);
3824 /* On some systems, ld cannot handle "-o" without a space. So
3825 split the option from its argument. */
3826 save_switch ("-o", 1, &arg
, validated
, true);
3829 case OPT_static_libgcc
:
3830 case OPT_shared_libgcc
:
3831 case OPT_static_libgfortran
:
3832 case OPT_static_libstdc__
:
3833 /* These are always valid, since gcc.c itself understands the
3834 first two, gfortranspec.c understands -static-libgfortran and
3835 g++spec.c understands -static-libstdc++ */
3844 handle_foffload_option (arg
);
3848 /* Various driver options need no special processing at this
3849 point, having been handled in a prescan above or being
3850 handled by specs. */
3855 save_switch (decoded
->canonical_option
[0],
3856 decoded
->canonical_option_num_elements
- 1,
3857 &decoded
->canonical_option
[1], validated
, true);
3861 /* Put the driver's standard set of option handlers in *HANDLERS. */
3864 set_option_handlers (struct cl_option_handlers
*handlers
)
3866 handlers
->unknown_option_callback
= driver_unknown_option_callback
;
3867 handlers
->wrong_lang_callback
= driver_wrong_lang_callback
;
3868 handlers
->num_handlers
= 3;
3869 handlers
->handlers
[0].handler
= driver_handle_option
;
3870 handlers
->handlers
[0].mask
= CL_DRIVER
;
3871 handlers
->handlers
[1].handler
= common_handle_option
;
3872 handlers
->handlers
[1].mask
= CL_COMMON
;
3873 handlers
->handlers
[2].handler
= target_handle_option
;
3874 handlers
->handlers
[2].mask
= CL_TARGET
;
3877 /* Create the vector `switches' and its contents.
3878 Store its length in `n_switches'. */
3881 process_command (unsigned int decoded_options_count
,
3882 struct cl_decoded_option
*decoded_options
)
3886 char *tooldir_prefix
, *tooldir_prefix2
;
3887 char *(*get_relative_prefix
) (const char *, const char *,
3888 const char *) = NULL
;
3889 struct cl_option_handlers handlers
;
3892 gcc_exec_prefix
= getenv ("GCC_EXEC_PREFIX");
3896 added_libraries
= 0;
3898 /* Figure compiler version from version string. */
3900 compiler_version
= temp1
= xstrdup (version_string
);
3902 for (; *temp1
; ++temp1
)
3911 /* Handle any -no-canonical-prefixes flag early, to assign the function
3912 that builds relative prefixes. This function creates default search
3913 paths that are needed later in normal option handling. */
3915 for (j
= 1; j
< decoded_options_count
; j
++)
3917 if (decoded_options
[j
].opt_index
== OPT_no_canonical_prefixes
)
3919 get_relative_prefix
= make_relative_prefix_ignore_links
;
3923 if (! get_relative_prefix
)
3924 get_relative_prefix
= make_relative_prefix
;
3926 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
3927 see if we can create it from the pathname specified in
3928 decoded_options[0].arg. */
3930 gcc_libexec_prefix
= standard_libexec_prefix
;
3932 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
3933 if (!gcc_exec_prefix
)
3935 gcc_exec_prefix
= get_relative_prefix (decoded_options
[0].arg
,
3936 standard_bindir_prefix
,
3937 standard_exec_prefix
);
3938 gcc_libexec_prefix
= get_relative_prefix (decoded_options
[0].arg
,
3939 standard_bindir_prefix
,
3940 standard_libexec_prefix
);
3941 if (gcc_exec_prefix
)
3942 xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix
, NULL
));
3946 /* make_relative_prefix requires a program name, but
3947 GCC_EXEC_PREFIX is typically a directory name with a trailing
3948 / (which is ignored by make_relative_prefix), so append a
3950 char *tmp_prefix
= concat (gcc_exec_prefix
, "gcc", NULL
);
3951 gcc_libexec_prefix
= get_relative_prefix (tmp_prefix
,
3952 standard_exec_prefix
,
3953 standard_libexec_prefix
);
3955 /* The path is unrelocated, so fallback to the original setting. */
3956 if (!gcc_libexec_prefix
)
3957 gcc_libexec_prefix
= standard_libexec_prefix
;
3963 /* From this point onward, gcc_exec_prefix is non-null if the toolchain
3964 is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
3965 or an automatically created GCC_EXEC_PREFIX from
3966 decoded_options[0].arg. */
3968 /* Do language-specific adjustment/addition of flags. */
3969 lang_specific_driver (&decoded_options
, &decoded_options_count
,
3972 if (gcc_exec_prefix
)
3974 int len
= strlen (gcc_exec_prefix
);
3976 if (len
> (int) sizeof ("/lib/gcc/") - 1
3977 && (IS_DIR_SEPARATOR (gcc_exec_prefix
[len
-1])))
3979 temp
= gcc_exec_prefix
+ len
- sizeof ("/lib/gcc/") + 1;
3980 if (IS_DIR_SEPARATOR (*temp
)
3981 && filename_ncmp (temp
+ 1, "lib", 3) == 0
3982 && IS_DIR_SEPARATOR (temp
[4])
3983 && filename_ncmp (temp
+ 5, "gcc", 3) == 0)
3984 len
-= sizeof ("/lib/gcc/") - 1;
3987 set_std_prefix (gcc_exec_prefix
, len
);
3988 add_prefix (&exec_prefixes
, gcc_libexec_prefix
, "GCC",
3989 PREFIX_PRIORITY_LAST
, 0, 0);
3990 add_prefix (&startfile_prefixes
, gcc_exec_prefix
, "GCC",
3991 PREFIX_PRIORITY_LAST
, 0, 0);
3994 /* COMPILER_PATH and LIBRARY_PATH have values
3995 that are lists of directory names with colons. */
3997 temp
= getenv ("COMPILER_PATH");
4000 const char *startp
, *endp
;
4001 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4003 startp
= endp
= temp
;
4006 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4008 strncpy (nstore
, startp
, endp
- startp
);
4010 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4011 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4013 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4014 nstore
[endp
- startp
+ 1] = 0;
4017 nstore
[endp
- startp
] = 0;
4018 add_prefix (&exec_prefixes
, nstore
, 0,
4019 PREFIX_PRIORITY_LAST
, 0, 0);
4020 add_prefix (&include_prefixes
, nstore
, 0,
4021 PREFIX_PRIORITY_LAST
, 0, 0);
4024 endp
= startp
= endp
+ 1;
4031 temp
= getenv (LIBRARY_PATH_ENV
);
4032 if (temp
&& *cross_compile
== '0')
4034 const char *startp
, *endp
;
4035 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4037 startp
= endp
= temp
;
4040 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4042 strncpy (nstore
, startp
, endp
- startp
);
4044 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4045 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4047 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4048 nstore
[endp
- startp
+ 1] = 0;
4051 nstore
[endp
- startp
] = 0;
4052 add_prefix (&startfile_prefixes
, nstore
, NULL
,
4053 PREFIX_PRIORITY_LAST
, 0, 1);
4056 endp
= startp
= endp
+ 1;
4063 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
4064 temp
= getenv ("LPATH");
4065 if (temp
&& *cross_compile
== '0')
4067 const char *startp
, *endp
;
4068 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4070 startp
= endp
= temp
;
4073 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4075 strncpy (nstore
, startp
, endp
- startp
);
4077 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4078 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4080 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4081 nstore
[endp
- startp
+ 1] = 0;
4084 nstore
[endp
- startp
] = 0;
4085 add_prefix (&startfile_prefixes
, nstore
, NULL
,
4086 PREFIX_PRIORITY_LAST
, 0, 1);
4089 endp
= startp
= endp
+ 1;
4096 /* Process the options and store input files and switches in their
4099 last_language_n_infiles
= -1;
4101 set_option_handlers (&handlers
);
4103 for (j
= 1; j
< decoded_options_count
; j
++)
4105 switch (decoded_options
[j
].opt_index
)
4117 for (j
= 1; j
< decoded_options_count
; j
++)
4119 if (decoded_options
[j
].opt_index
== OPT_SPECIAL_input_file
)
4121 const char *arg
= decoded_options
[j
].arg
;
4122 const char *p
= strrchr (arg
, '@');
4126 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4127 arg
= convert_filename (arg
, 0, access (arg
, F_OK
));
4129 /* For LTO static archive support we handle input file
4130 specifications that are composed of a filename and
4131 an offset like FNAME@OFFSET. */
4134 && sscanf (p
, "@%li%n", &offset
, &consumed
) >= 1
4135 && strlen (p
) == (unsigned int)consumed
)
4137 fname
= (char *)xmalloc (p
- arg
+ 1);
4138 memcpy (fname
, arg
, p
- arg
);
4139 fname
[p
- arg
] = '\0';
4140 /* Only accept non-stdin and existing FNAME parts, otherwise
4141 try with the full name. */
4142 if (strcmp (fname
, "-") == 0 || access (fname
, F_OK
) < 0)
4145 fname
= xstrdup (arg
);
4149 fname
= xstrdup (arg
);
4151 if (strcmp (fname
, "-") != 0 && access (fname
, F_OK
) < 0)
4152 perror_with_name (fname
);
4154 add_infile (arg
, spec_lang
);
4160 read_cmdline_option (&global_options
, &global_options_set
,
4161 decoded_options
+ j
, UNKNOWN_LOCATION
,
4162 CL_DRIVER
, &handlers
, global_dc
);
4166 && strcmp (output_file
, "-") != 0
4167 && strcmp (output_file
, HOST_BIT_BUCKET
) != 0)
4170 for (i
= 0; i
< n_infiles
; i
++)
4171 if ((!infiles
[i
].language
|| infiles
[i
].language
[0] != '*')
4172 && canonical_filename_eq (infiles
[i
].name
, output_file
))
4173 fatal_error ("input file %qs is the same as output file",
4177 /* If -save-temps=obj and -o name, create the prefix to use for %b.
4178 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
4179 if (save_temps_flag
== SAVE_TEMPS_OBJ
&& save_temps_prefix
!= NULL
)
4181 save_temps_length
= strlen (save_temps_prefix
);
4182 temp
= strrchr (lbasename (save_temps_prefix
), '.');
4185 save_temps_length
-= strlen (temp
);
4186 save_temps_prefix
[save_temps_length
] = '\0';
4190 else if (save_temps_prefix
!= NULL
)
4192 free (save_temps_prefix
);
4193 save_temps_prefix
= NULL
;
4196 if (save_temps_flag
&& use_pipes
)
4198 /* -save-temps overrides -pipe, so that temp files are produced */
4199 if (save_temps_flag
)
4200 warning (0, "-pipe ignored because -save-temps specified");
4206 const char *gcd
= getenv ("GCC_COMPARE_DEBUG");
4208 if (gcd
&& gcd
[0] == '-')
4211 compare_debug_opt
= gcd
;
4213 else if (gcd
&& *gcd
&& strcmp (gcd
, "0"))
4216 compare_debug_opt
= "-gtoggle";
4219 else if (compare_debug
< 0)
4222 gcc_assert (!compare_debug_opt
);
4225 /* Set up the search paths. We add directories that we expect to
4226 contain GNU Toolchain components before directories specified by
4227 the machine description so that we will find GNU components (like
4228 the GNU assembler) before those of the host system. */
4230 /* If we don't know where the toolchain has been installed, use the
4231 configured-in locations. */
4232 if (!gcc_exec_prefix
)
4235 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "GCC",
4236 PREFIX_PRIORITY_LAST
, 1, 0);
4237 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "BINUTILS",
4238 PREFIX_PRIORITY_LAST
, 2, 0);
4239 add_prefix (&exec_prefixes
, standard_exec_prefix
, "BINUTILS",
4240 PREFIX_PRIORITY_LAST
, 2, 0);
4242 add_prefix (&startfile_prefixes
, standard_exec_prefix
, "BINUTILS",
4243 PREFIX_PRIORITY_LAST
, 1, 0);
4246 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix
));
4247 tooldir_prefix2
= concat (tooldir_base_prefix
, spec_host_machine
,
4248 dir_separator_str
, NULL
);
4250 /* Look for tools relative to the location from which the driver is
4251 running, or, if that is not available, the configured prefix. */
4253 = concat (gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
4254 spec_host_machine
, dir_separator_str
, spec_version
,
4255 accel_dir_suffix
, dir_separator_str
, tooldir_prefix2
, NULL
);
4256 free (tooldir_prefix2
);
4258 add_prefix (&exec_prefixes
,
4259 concat (tooldir_prefix
, "bin", dir_separator_str
, NULL
),
4260 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 0);
4261 add_prefix (&startfile_prefixes
,
4262 concat (tooldir_prefix
, "lib", dir_separator_str
, NULL
),
4263 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 1);
4264 free (tooldir_prefix
);
4266 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
4267 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
4268 then consider it to relocate with the rest of the GCC installation
4269 if GCC_EXEC_PREFIX is set.
4270 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
4271 if (target_system_root
&& !target_system_root_changed
&& gcc_exec_prefix
)
4273 char *tmp_prefix
= get_relative_prefix (decoded_options
[0].arg
,
4274 standard_bindir_prefix
,
4275 target_system_root
);
4276 if (tmp_prefix
&& access_check (tmp_prefix
, F_OK
) == 0)
4278 target_system_root
= tmp_prefix
;
4279 target_system_root_changed
= 1;
4284 /* More prefixes are enabled in main, after we read the specs file
4285 and determine whether this is cross-compilation or not. */
4287 if (n_infiles
== last_language_n_infiles
&& spec_lang
!= 0)
4288 warning (0, "%<-x %s%> after last input file has no effect", spec_lang
);
4290 /* Synthesize -fcompare-debug flag from the GCC_COMPARE_DEBUG
4291 environment variable. */
4292 if (compare_debug
== 2 || compare_debug
== 3)
4294 const char *opt
= concat ("-fcompare-debug=", compare_debug_opt
, NULL
);
4295 save_switch (opt
, 0, NULL
, false, true);
4299 /* Ensure we only invoke each subprocess once. */
4300 if (print_subprocess_help
|| print_help_list
|| print_version
)
4304 /* Create a dummy input file, so that we can pass
4305 the help option on to the various sub-processes. */
4306 add_infile ("help-dummy", "c");
4310 switches
[n_switches
].part1
= 0;
4312 infiles
[n_infiles
].name
= 0;
4315 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4316 and place that in the environment. */
4319 set_collect_gcc_options (void)
4324 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4326 obstack_grow (&collect_obstack
, "COLLECT_GCC_OPTIONS=",
4327 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4330 for (i
= 0; (int) i
< n_switches
; i
++)
4332 const char *const *args
;
4335 obstack_grow (&collect_obstack
, " ", 1);
4339 /* Ignore elided switches. */
4340 if ((switches
[i
].live_cond
4341 & (SWITCH_IGNORE
| SWITCH_KEEP_FOR_GCC
))
4345 obstack_grow (&collect_obstack
, "'-", 2);
4346 q
= switches
[i
].part1
;
4347 while ((p
= strchr (q
, '\'')))
4349 obstack_grow (&collect_obstack
, q
, p
- q
);
4350 obstack_grow (&collect_obstack
, "'\\''", 4);
4353 obstack_grow (&collect_obstack
, q
, strlen (q
));
4354 obstack_grow (&collect_obstack
, "'", 1);
4356 for (args
= switches
[i
].args
; args
&& *args
; args
++)
4358 obstack_grow (&collect_obstack
, " '", 2);
4360 while ((p
= strchr (q
, '\'')))
4362 obstack_grow (&collect_obstack
, q
, p
- q
);
4363 obstack_grow (&collect_obstack
, "'\\''", 4);
4366 obstack_grow (&collect_obstack
, q
, strlen (q
));
4367 obstack_grow (&collect_obstack
, "'", 1);
4370 obstack_grow (&collect_obstack
, "\0", 1);
4371 xputenv (XOBFINISH (&collect_obstack
, char *));
4374 /* Process a spec string, accumulating and running commands. */
4376 /* These variables describe the input file name.
4377 input_file_number is the index on outfiles of this file,
4378 so that the output file name can be stored for later use by %o.
4379 input_basename is the start of the part of the input file
4380 sans all directory names, and basename_length is the number
4381 of characters starting there excluding the suffix .c or whatever. */
4383 static const char *gcc_input_filename
;
4384 static int input_file_number
;
4385 size_t input_filename_length
;
4386 static int basename_length
;
4387 static int suffixed_basename_length
;
4388 static const char *input_basename
;
4389 static const char *input_suffix
;
4390 #ifndef HOST_LACKS_INODE_NUMBERS
4391 static struct stat input_stat
;
4393 static int input_stat_set
;
4395 /* The compiler used to process the current input file. */
4396 static struct compiler
*input_file_compiler
;
4398 /* These are variables used within do_spec and do_spec_1. */
4400 /* Nonzero if an arg has been started and not yet terminated
4401 (with space, tab or newline). */
4402 static int arg_going
;
4404 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4405 is a temporary file name. */
4406 static int delete_this_arg
;
4408 /* Nonzero means %w has been seen; the next arg to be terminated
4409 is the output file name of this compilation. */
4410 static int this_is_output_file
;
4412 /* Nonzero means %s has been seen; the next arg to be terminated
4413 is the name of a library file and we should try the standard
4414 search dirs for it. */
4415 static int this_is_library_file
;
4417 /* Nonzero means %T has been seen; the next arg to be terminated
4418 is the name of a linker script and we should try all of the
4419 standard search dirs for it. If it is found insert a --script
4420 command line switch and then substitute the full path in place,
4421 otherwise generate an error message. */
4422 static int this_is_linker_script
;
4424 /* Nonzero means that the input of this command is coming from a pipe. */
4425 static int input_from_pipe
;
4427 /* Nonnull means substitute this for any suffix when outputting a switches
4429 static const char *suffix_subst
;
4431 /* If there is an argument being accumulated, terminate it and store it. */
4434 end_going_arg (void)
4440 obstack_1grow (&obstack
, 0);
4441 string
= XOBFINISH (&obstack
, const char *);
4442 if (this_is_library_file
)
4443 string
= find_file (string
);
4444 if (this_is_linker_script
)
4446 char * full_script_path
= find_a_file (&startfile_prefixes
, string
, R_OK
, true);
4448 if (full_script_path
== NULL
)
4450 error ("unable to locate default linker script %qs in the library search paths", string
);
4451 /* Script was not found on search path. */
4454 store_arg ("--script", false, false);
4455 string
= full_script_path
;
4457 store_arg (string
, delete_this_arg
, this_is_output_file
);
4458 if (this_is_output_file
)
4459 outfiles
[input_file_number
] = string
;
4465 /* Parse the WRAPPER string which is a comma separated list of the command line
4466 and insert them into the beginning of argbuf. */
4469 insert_wrapper (const char *wrapper
)
4473 char *buf
= xstrdup (wrapper
);
4475 unsigned int old_length
= argbuf
.length ();
4483 while ((p
= strchr (p
, ',')) != NULL
);
4485 argbuf
.safe_grow (old_length
+ n
);
4486 memmove (argbuf
.address () + n
,
4488 old_length
* sizeof (const_char_p
));
4502 while ((p
= strchr (p
, ',')) != NULL
);
4503 gcc_assert (i
== n
);
4506 /* Process the spec SPEC and run the commands specified therein.
4507 Returns 0 if the spec is successfully processed; -1 if failed. */
4510 do_spec (const char *spec
)
4514 value
= do_spec_2 (spec
);
4516 /* Force out any unfinished command.
4517 If -pipe, this forces out the last command if it ended in `|'. */
4520 if (argbuf
.length () > 0
4521 && !strcmp (argbuf
.last (), "|"))
4524 set_collect_gcc_options ();
4526 if (argbuf
.length () > 0)
4534 do_spec_2 (const char *spec
)
4540 delete_this_arg
= 0;
4541 this_is_output_file
= 0;
4542 this_is_library_file
= 0;
4543 this_is_linker_script
= 0;
4544 input_from_pipe
= 0;
4545 suffix_subst
= NULL
;
4547 result
= do_spec_1 (spec
, 0, NULL
);
4555 /* Process the given spec string and add any new options to the end
4556 of the switches/n_switches array. */
4559 do_option_spec (const char *name
, const char *spec
)
4561 unsigned int i
, value_count
, value_len
;
4562 const char *p
, *q
, *value
;
4563 char *tmp_spec
, *tmp_spec_p
;
4565 if (configure_default_options
[0].name
== NULL
)
4568 for (i
= 0; i
< ARRAY_SIZE (configure_default_options
); i
++)
4569 if (strcmp (configure_default_options
[i
].name
, name
) == 0)
4571 if (i
== ARRAY_SIZE (configure_default_options
))
4574 value
= configure_default_options
[i
].value
;
4575 value_len
= strlen (value
);
4577 /* Compute the size of the final spec. */
4580 while ((p
= strstr (p
, "%(VALUE)")) != NULL
)
4586 /* Replace each %(VALUE) by the specified value. */
4587 tmp_spec
= (char *) alloca (strlen (spec
) + 1
4588 + value_count
* (value_len
- strlen ("%(VALUE)")));
4589 tmp_spec_p
= tmp_spec
;
4591 while ((p
= strstr (q
, "%(VALUE)")) != NULL
)
4593 memcpy (tmp_spec_p
, q
, p
- q
);
4594 tmp_spec_p
= tmp_spec_p
+ (p
- q
);
4595 memcpy (tmp_spec_p
, value
, value_len
);
4596 tmp_spec_p
+= value_len
;
4597 q
= p
+ strlen ("%(VALUE)");
4599 strcpy (tmp_spec_p
, q
);
4601 do_self_spec (tmp_spec
);
4604 /* Process the given spec string and add any new options to the end
4605 of the switches/n_switches array. */
4608 do_self_spec (const char *spec
)
4613 do_spec_1 (" ", 0, NULL
);
4615 /* Mark %<S switches processed by do_self_spec to be ignored permanently.
4616 do_self_specs adds the replacements to switches array, so it shouldn't
4617 be processed afterwards. */
4618 for (i
= 0; i
< n_switches
; i
++)
4619 if ((switches
[i
].live_cond
& SWITCH_IGNORE
))
4620 switches
[i
].live_cond
|= SWITCH_IGNORE_PERMANENTLY
;
4622 if (argbuf
.length () > 0)
4624 const char **argbuf_copy
;
4625 struct cl_decoded_option
*decoded_options
;
4626 struct cl_option_handlers handlers
;
4627 unsigned int decoded_options_count
;
4630 /* Create a copy of argbuf with a dummy argv[0] entry for
4631 decode_cmdline_options_to_array. */
4632 argbuf_copy
= XNEWVEC (const char *,
4633 argbuf
.length () + 1);
4634 argbuf_copy
[0] = "";
4635 memcpy (argbuf_copy
+ 1, argbuf
.address (),
4636 argbuf
.length () * sizeof (const char *));
4638 decode_cmdline_options_to_array (argbuf
.length () + 1,
4640 CL_DRIVER
, &decoded_options
,
4641 &decoded_options_count
);
4644 set_option_handlers (&handlers
);
4646 for (j
= 1; j
< decoded_options_count
; j
++)
4648 switch (decoded_options
[j
].opt_index
)
4650 case OPT_SPECIAL_input_file
:
4651 /* Specs should only generate options, not input
4653 if (strcmp (decoded_options
[j
].arg
, "-") != 0)
4654 fatal_error ("switch %qs does not start with %<-%>",
4655 decoded_options
[j
].arg
);
4657 fatal_error ("spec-generated switch is just %<-%>");
4660 case OPT_fcompare_debug_second
:
4661 case OPT_fcompare_debug
:
4662 case OPT_fcompare_debug_
:
4664 /* Avoid duplicate processing of some options from
4665 compare-debug specs; just save them here. */
4666 save_switch (decoded_options
[j
].canonical_option
[0],
4667 (decoded_options
[j
].canonical_option_num_elements
4669 &decoded_options
[j
].canonical_option
[1], false, true);
4673 read_cmdline_option (&global_options
, &global_options_set
,
4674 decoded_options
+ j
, UNKNOWN_LOCATION
,
4675 CL_DRIVER
, &handlers
, global_dc
);
4681 switches
[n_switches
].part1
= 0;
4685 /* Callback for processing %D and %I specs. */
4687 struct spec_path_info
{
4692 bool separate_options
;
4696 spec_path (char *path
, void *data
)
4698 struct spec_path_info
*info
= (struct spec_path_info
*) data
;
4702 if (info
->omit_relative
&& !IS_ABSOLUTE_PATH (path
))
4705 if (info
->append_len
!= 0)
4707 len
= strlen (path
);
4708 memcpy (path
+ len
, info
->append
, info
->append_len
+ 1);
4711 if (!is_directory (path
, true))
4714 do_spec_1 (info
->option
, 1, NULL
);
4715 if (info
->separate_options
)
4716 do_spec_1 (" ", 0, NULL
);
4718 if (info
->append_len
== 0)
4720 len
= strlen (path
);
4721 save
= path
[len
- 1];
4722 if (IS_DIR_SEPARATOR (path
[len
- 1]))
4723 path
[len
- 1] = '\0';
4726 do_spec_1 (path
, 1, NULL
);
4727 do_spec_1 (" ", 0, NULL
);
4729 /* Must not damage the original path. */
4730 if (info
->append_len
== 0)
4731 path
[len
- 1] = save
;
4736 /* Create a temporary FILE with the contents of ARGV. Add @FILE to the
4740 create_at_file (char **argv
)
4742 char *temp_file
= make_temp_file ("");
4743 char *at_argument
= concat ("@", temp_file
, NULL
);
4744 FILE *f
= fopen (temp_file
, "w");
4748 fatal_error ("could not open temporary response file %s",
4751 status
= writeargv (argv
, f
);
4754 fatal_error ("could not write to temporary response file %s",
4757 status
= fclose (f
);
4760 fatal_error ("could not close temporary response file %s",
4763 store_arg (at_argument
, 0, 0);
4765 record_temp_file (temp_file
, !save_temps_flag
, !save_temps_flag
);
4768 /* True if we should compile INFILE. */
4771 compile_input_file_p (struct infile
*infile
)
4773 if ((!infile
->language
) || (infile
->language
[0] != '*'))
4774 if (infile
->incompiler
== input_file_compiler
)
4779 /* Process each member of VEC as a spec. */
4782 do_specs_vec (vec
<char_p
> vec
)
4787 FOR_EACH_VEC_ELT (vec
, ix
, opt
)
4789 do_spec_1 (opt
, 1, NULL
);
4790 /* Make each accumulated option a separate argument. */
4791 do_spec_1 (" ", 0, NULL
);
4795 /* Process the sub-spec SPEC as a portion of a larger spec.
4796 This is like processing a whole spec except that we do
4797 not initialize at the beginning and we do not supply a
4798 newline by default at the end.
4799 INSWITCH nonzero means don't process %-sequences in SPEC;
4800 in this case, % is treated as an ordinary character.
4801 This is used while substituting switches.
4802 INSWITCH nonzero also causes SPC not to terminate an argument.
4804 Value is zero unless a line was finished
4805 and the command on that line reported an error. */
4808 do_spec_1 (const char *spec
, int inswitch
, const char *soft_matched_part
)
4810 const char *p
= spec
;
4815 /* If it's an empty string argument to a switch, keep it as is. */
4816 if (inswitch
&& !*p
)
4820 /* If substituting a switch, treat all chars like letters.
4821 Otherwise, NL, SPC, TAB and % are special. */
4822 switch (inswitch
? 'a' : c
)
4827 if (argbuf
.length () > 0
4828 && !strcmp (argbuf
.last (), "|"))
4830 /* A `|' before the newline means use a pipe here,
4831 but only if -pipe was specified.
4832 Otherwise, execute now and don't pass the `|' as an arg. */
4835 input_from_pipe
= 1;
4842 set_collect_gcc_options ();
4844 if (argbuf
.length () > 0)
4850 /* Reinitialize for a new command, and for a new argument. */
4853 delete_this_arg
= 0;
4854 this_is_output_file
= 0;
4855 this_is_library_file
= 0;
4856 this_is_linker_script
= 0;
4857 input_from_pipe
= 0;
4864 obstack_1grow (&obstack
, c
);
4872 /* Reinitialize for a new argument. */
4873 delete_this_arg
= 0;
4874 this_is_output_file
= 0;
4875 this_is_library_file
= 0;
4876 this_is_linker_script
= 0;
4883 fatal_error ("spec %qs invalid", spec
);
4886 if (save_temps_length
)
4887 obstack_grow (&obstack
, save_temps_prefix
, save_temps_length
);
4889 obstack_grow (&obstack
, input_basename
, basename_length
);
4890 if (compare_debug
< 0)
4891 obstack_grow (&obstack
, ".gk", 3);
4896 if (save_temps_length
)
4897 obstack_grow (&obstack
, save_temps_prefix
, save_temps_length
);
4899 obstack_grow (&obstack
, input_basename
, suffixed_basename_length
);
4900 if (compare_debug
< 0)
4901 obstack_grow (&obstack
, ".gk", 3);
4906 delete_this_arg
= 2;
4909 /* Dump out the directories specified with LIBRARY_PATH,
4910 followed by the absolute directories
4911 that we search for startfiles. */
4914 struct spec_path_info info
;
4917 info
.append_len
= 0;
4918 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
4919 /* Used on systems which record the specified -L dirs
4920 and use them to search for dynamic linking.
4921 Relative directories always come from -B,
4922 and it is better not to use them for searching
4923 at run time. In particular, stage1 loses. */
4924 info
.omit_relative
= true;
4926 info
.omit_relative
= false;
4928 info
.separate_options
= false;
4930 for_each_path (&startfile_prefixes
, true, 0, spec_path
, &info
);
4935 /* %efoo means report an error with `foo' as error message
4936 and don't execute any more commands for this file. */
4940 while (*p
!= 0 && *p
!= '\n')
4942 buf
= (char *) alloca (p
- q
+ 1);
4943 strncpy (buf
, q
, p
- q
);
4945 error ("%s", _(buf
));
4950 /* %nfoo means report a notice with `foo' on stderr. */
4954 while (*p
!= 0 && *p
!= '\n')
4956 buf
= (char *) alloca (p
- q
+ 1);
4957 strncpy (buf
, q
, p
- q
);
4959 inform (0, "%s", _(buf
));
4969 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
4970 defined, and it is not a directory, and it is
4971 writable, use it. Otherwise, treat this like any
4972 other temporary file. */
4974 if ((!save_temps_flag
)
4975 && (stat (HOST_BIT_BUCKET
, &st
) == 0) && (!S_ISDIR (st
.st_mode
))
4976 && (access (HOST_BIT_BUCKET
, W_OK
) == 0))
4978 obstack_grow (&obstack
, HOST_BIT_BUCKET
,
4979 strlen (HOST_BIT_BUCKET
));
4980 delete_this_arg
= 0;
4985 goto create_temp_file
;
4989 obstack_1grow (&obstack
, '-');
4990 delete_this_arg
= 0;
4993 /* consume suffix */
4994 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
4996 if (p
[0] == '%' && p
[1] == 'O')
5001 goto create_temp_file
;
5005 /* consume suffix */
5006 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
5008 if (p
[0] == '%' && p
[1] == 'O')
5013 goto create_temp_file
;
5019 struct temp_name
*t
;
5021 const char *suffix
= p
;
5022 char *saved_suffix
= NULL
;
5024 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
5026 suffix_length
= p
- suffix
;
5027 if (p
[0] == '%' && p
[1] == 'O')
5030 /* We don't support extra suffix characters after %O. */
5031 if (*p
== '.' || ISALNUM ((unsigned char) *p
))
5032 fatal_error ("spec %qs has invalid %<%%0%c%>", spec
, *p
);
5033 if (suffix_length
== 0)
5034 suffix
= TARGET_OBJECT_SUFFIX
;
5038 = XNEWVEC (char, suffix_length
5039 + strlen (TARGET_OBJECT_SUFFIX
) + 1);
5040 strncpy (saved_suffix
, suffix
, suffix_length
);
5041 strcpy (saved_suffix
+ suffix_length
,
5042 TARGET_OBJECT_SUFFIX
);
5044 suffix_length
+= strlen (TARGET_OBJECT_SUFFIX
);
5047 if (compare_debug
< 0)
5049 suffix
= concat (".gk", suffix
, NULL
);
5053 /* If -save-temps=obj and -o were specified, use that for the
5055 if (save_temps_length
)
5058 temp_filename_length
5059 = save_temps_length
+ suffix_length
+ 1;
5060 tmp
= (char *) alloca (temp_filename_length
);
5061 memcpy (tmp
, save_temps_prefix
, save_temps_length
);
5062 memcpy (tmp
+ save_temps_length
, suffix
, suffix_length
);
5063 tmp
[save_temps_length
+ suffix_length
] = '\0';
5064 temp_filename
= save_string (tmp
, save_temps_length
5066 obstack_grow (&obstack
, temp_filename
,
5067 temp_filename_length
);
5069 delete_this_arg
= 0;
5073 /* If the gcc_input_filename has the same suffix specified
5074 for the %g, %u, or %U, and -save-temps is specified,
5075 we could end up using that file as an intermediate
5076 thus clobbering the user's source file (.e.g.,
5077 gcc -save-temps foo.s would clobber foo.s with the
5078 output of cpp0). So check for this condition and
5079 generate a temp file as the intermediate. */
5081 if (save_temps_flag
)
5084 temp_filename_length
= basename_length
+ suffix_length
+ 1;
5085 tmp
= (char *) alloca (temp_filename_length
);
5086 memcpy (tmp
, input_basename
, basename_length
);
5087 memcpy (tmp
+ basename_length
, suffix
, suffix_length
);
5088 tmp
[basename_length
+ suffix_length
] = '\0';
5089 temp_filename
= tmp
;
5091 if (filename_cmp (temp_filename
, gcc_input_filename
) != 0)
5093 #ifndef HOST_LACKS_INODE_NUMBERS
5094 struct stat st_temp
;
5096 /* Note, set_input() resets input_stat_set to 0. */
5097 if (input_stat_set
== 0)
5099 input_stat_set
= stat (gcc_input_filename
,
5101 if (input_stat_set
>= 0)
5105 /* If we have the stat for the gcc_input_filename
5106 and we can do the stat for the temp_filename
5107 then the they could still refer to the same
5108 file if st_dev/st_ino's are the same. */
5109 if (input_stat_set
!= 1
5110 || stat (temp_filename
, &st_temp
) < 0
5111 || input_stat
.st_dev
!= st_temp
.st_dev
5112 || input_stat
.st_ino
!= st_temp
.st_ino
)
5114 /* Just compare canonical pathnames. */
5115 char* input_realname
= lrealpath (gcc_input_filename
);
5116 char* temp_realname
= lrealpath (temp_filename
);
5117 bool files_differ
= filename_cmp (input_realname
, temp_realname
);
5118 free (input_realname
);
5119 free (temp_realname
);
5123 temp_filename
= save_string (temp_filename
,
5124 temp_filename_length
+ 1);
5125 obstack_grow (&obstack
, temp_filename
,
5126 temp_filename_length
);
5128 delete_this_arg
= 0;
5134 /* See if we already have an association of %g/%u/%U and
5136 for (t
= temp_names
; t
; t
= t
->next
)
5137 if (t
->length
== suffix_length
5138 && strncmp (t
->suffix
, suffix
, suffix_length
) == 0
5139 && t
->unique
== (c
== 'u' || c
== 'U' || c
== 'j'))
5142 /* Make a new association if needed. %u and %j
5144 if (t
== 0 || c
== 'u' || c
== 'j')
5148 t
= XNEW (struct temp_name
);
5149 t
->next
= temp_names
;
5152 t
->length
= suffix_length
;
5155 t
->suffix
= saved_suffix
;
5156 saved_suffix
= NULL
;
5159 t
->suffix
= save_string (suffix
, suffix_length
);
5160 t
->unique
= (c
== 'u' || c
== 'U' || c
== 'j');
5161 temp_filename
= make_temp_file (t
->suffix
);
5162 temp_filename_length
= strlen (temp_filename
);
5163 t
->filename
= temp_filename
;
5164 t
->filename_length
= temp_filename_length
;
5167 free (saved_suffix
);
5169 obstack_grow (&obstack
, t
->filename
, t
->filename_length
);
5170 delete_this_arg
= 1;
5178 if (at_file_supplied
)
5180 /* We are going to expand `%i' to `@FILE', where FILE
5181 is a newly-created temporary filename. The filenames
5182 that would usually be expanded in place of %o will be
5183 written to the temporary file. */
5188 for (i
= 0; i
< n_infiles
; i
++)
5189 if (compile_input_file_p (&infiles
[i
]))
5192 argv
= (char **) alloca (sizeof (char *) * (n_files
+ 1));
5194 /* Copy the strings over. */
5195 for (i
= 0, j
= 0; i
< n_infiles
; i
++)
5196 if (compile_input_file_p (&infiles
[i
]))
5198 argv
[j
] = CONST_CAST (char *, infiles
[i
].name
);
5199 infiles
[i
].compiled
= true;
5204 create_at_file (argv
);
5207 for (i
= 0; (int) i
< n_infiles
; i
++)
5208 if (compile_input_file_p (&infiles
[i
]))
5210 store_arg (infiles
[i
].name
, 0, 0);
5211 infiles
[i
].compiled
= true;
5216 obstack_grow (&obstack
, gcc_input_filename
,
5217 input_filename_length
);
5224 struct spec_path_info info
;
5228 do_spec_1 ("-imultilib", 1, NULL
);
5229 /* Make this a separate argument. */
5230 do_spec_1 (" ", 0, NULL
);
5231 do_spec_1 (multilib_dir
, 1, NULL
);
5232 do_spec_1 (" ", 0, NULL
);
5237 do_spec_1 ("-imultiarch", 1, NULL
);
5238 /* Make this a separate argument. */
5239 do_spec_1 (" ", 0, NULL
);
5240 do_spec_1 (multiarch_dir
, 1, NULL
);
5241 do_spec_1 (" ", 0, NULL
);
5244 if (gcc_exec_prefix
)
5246 do_spec_1 ("-iprefix", 1, NULL
);
5247 /* Make this a separate argument. */
5248 do_spec_1 (" ", 0, NULL
);
5249 do_spec_1 (gcc_exec_prefix
, 1, NULL
);
5250 do_spec_1 (" ", 0, NULL
);
5253 if (target_system_root_changed
||
5254 (target_system_root
&& target_sysroot_hdrs_suffix
))
5256 do_spec_1 ("-isysroot", 1, NULL
);
5257 /* Make this a separate argument. */
5258 do_spec_1 (" ", 0, NULL
);
5259 do_spec_1 (target_system_root
, 1, NULL
);
5260 if (target_sysroot_hdrs_suffix
)
5261 do_spec_1 (target_sysroot_hdrs_suffix
, 1, NULL
);
5262 do_spec_1 (" ", 0, NULL
);
5265 info
.option
= "-isystem";
5266 info
.append
= "include";
5267 info
.append_len
= strlen (info
.append
);
5268 info
.omit_relative
= false;
5269 info
.separate_options
= true;
5271 for_each_path (&include_prefixes
, false, info
.append_len
,
5274 info
.append
= "include-fixed";
5275 if (*sysroot_hdrs_suffix_spec
)
5276 info
.append
= concat (info
.append
, dir_separator_str
,
5277 multilib_dir
, NULL
);
5278 info
.append_len
= strlen (info
.append
);
5279 for_each_path (&include_prefixes
, false, info
.append_len
,
5286 int max
= n_infiles
;
5287 max
+= lang_specific_extra_outfiles
;
5289 if (HAVE_GNU_LD
&& at_file_supplied
)
5291 /* We are going to expand `%o' to `@FILE', where FILE
5292 is a newly-created temporary filename. The filenames
5293 that would usually be expanded in place of %o will be
5294 written to the temporary file. */
5299 /* Convert OUTFILES into a form suitable for writeargv. */
5301 /* Determine how many are non-NULL. */
5302 for (n_files
= 0, i
= 0; i
< max
; i
++)
5303 n_files
+= outfiles
[i
] != NULL
;
5305 argv
= (char **) alloca (sizeof (char *) * (n_files
+ 1));
5307 /* Copy the strings over. */
5308 for (i
= 0, j
= 0; i
< max
; i
++)
5311 argv
[j
] = CONST_CAST (char *, outfiles
[i
]);
5316 create_at_file (argv
);
5319 for (i
= 0; i
< max
; i
++)
5321 store_arg (outfiles
[i
], 0, 0);
5326 obstack_grow (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
5331 this_is_library_file
= 1;
5335 this_is_linker_script
= 1;
5339 outfiles
[input_file_number
] = NULL
;
5343 this_is_output_file
= 1;
5348 unsigned int cur_index
= argbuf
.length ();
5349 /* Handle the {...} following the %W. */
5351 fatal_error ("spec %qs has invalid %<%%W%c%>", spec
, *p
);
5352 p
= handle_braces (p
+ 1);
5356 /* If any args were output, mark the last one for deletion
5358 if (argbuf
.length () != cur_index
)
5359 record_temp_file (argbuf
.last (), 0, 1);
5363 /* %x{OPTION} records OPTION for %X to output. */
5371 /* Skip past the option value and make a copy. */
5373 fatal_error ("spec %qs has invalid %<%%x%c%>", spec
, *p
);
5376 string
= save_string (p1
+ 1, p
- p1
- 2);
5378 /* See if we already recorded this option. */
5379 FOR_EACH_VEC_ELT (linker_options
, ix
, opt
)
5380 if (! strcmp (string
, opt
))
5386 /* This option is new; add it. */
5387 add_linker_option (string
, strlen (string
));
5392 /* Dump out the options accumulated previously using %x. */
5394 do_specs_vec (linker_options
);
5397 /* Dump out the options accumulated previously using -Wa,. */
5399 do_specs_vec (assembler_options
);
5402 /* Dump out the options accumulated previously using -Wp,. */
5404 do_specs_vec (preprocessor_options
);
5407 /* Here are digits and numbers that just process
5408 a certain constant string as a spec. */
5411 value
= do_spec_1 (cc1_spec
, 0, NULL
);
5417 value
= do_spec_1 (cc1plus_spec
, 0, NULL
);
5423 value
= do_spec_1 (asm_spec
, 0, NULL
);
5429 value
= do_spec_1 (asm_final_spec
, 0, NULL
);
5436 const char *const spec
5437 = (input_file_compiler
->cpp_spec
5438 ? input_file_compiler
->cpp_spec
5440 value
= do_spec_1 (spec
, 0, NULL
);
5447 value
= do_spec_1 (endfile_spec
, 0, NULL
);
5453 value
= do_spec_1 (link_spec
, 0, NULL
);
5459 value
= do_spec_1 (lib_spec
, 0, NULL
);
5465 if (multilib_os_dir
== NULL
)
5466 obstack_1grow (&obstack
, '.');
5468 obstack_grow (&obstack
, multilib_os_dir
,
5469 strlen (multilib_os_dir
));
5473 value
= do_spec_1 (libgcc_spec
, 0, NULL
);
5479 /* We assume there is a directory
5480 separator at the end of this string. */
5481 if (target_system_root
)
5483 obstack_grow (&obstack
, target_system_root
,
5484 strlen (target_system_root
));
5485 if (target_sysroot_suffix
)
5486 obstack_grow (&obstack
, target_sysroot_suffix
,
5487 strlen (target_sysroot_suffix
));
5492 value
= do_spec_1 (startfile_spec
, 0, NULL
);
5497 /* Here we define characters other than letters and digits. */
5500 p
= handle_braces (p
);
5506 p
= handle_spec_function (p
, NULL
);
5512 obstack_1grow (&obstack
, '%');
5519 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '%')
5521 suffix_subst
= save_string (p
- 1, len
+ 1);
5526 /* Henceforth ignore the option(s) matching the pattern
5532 int have_wildcard
= 0;
5537 switch_option
= SWITCH_IGNORE
| SWITCH_KEEP_FOR_GCC
;
5539 switch_option
= SWITCH_IGNORE
;
5541 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '\t')
5544 if (p
[len
-1] == '*')
5547 for (i
= 0; i
< n_switches
; i
++)
5548 if (!strncmp (switches
[i
].part1
, p
, len
- have_wildcard
)
5549 && (have_wildcard
|| switches
[i
].part1
[len
] == '\0'))
5551 switches
[i
].live_cond
|= switch_option
;
5552 /* User switch be validated from validate_all_switches.
5553 when the definition is seen from the spec file.
5554 If not defined anywhere, will be rejected. */
5555 if (switches
[i
].known
)
5556 switches
[i
].validated
= true;
5564 if (soft_matched_part
)
5566 if (soft_matched_part
[0])
5567 do_spec_1 (soft_matched_part
, 1, NULL
);
5568 /* Only insert a space after the substitution if it is at the
5569 end of the current sequence. So if:
5571 "%{foo=*:bar%*}%{foo=*:one%*two}"
5573 matches -foo=hello then it will produce:
5575 barhello onehellotwo
5577 if (*p
== 0 || *p
== '}')
5578 do_spec_1 (" ", 0, NULL
);
5581 /* Catch the case where a spec string contains something like
5582 '%{foo:%*}'. i.e. there is no * in the pattern on the left
5583 hand side of the :. */
5584 error ("spec failure: %<%%*%> has not been initialized by pattern match");
5587 /* Process a string found as the value of a spec given by name.
5588 This feature allows individual machine descriptions
5589 to add and use their own specs. */
5592 const char *name
= p
;
5593 struct spec_list
*sl
;
5596 /* The string after the S/P is the name of a spec that is to be
5598 while (*p
&& *p
!= ')')
5601 /* See if it's in the list. */
5602 for (len
= p
- name
, sl
= specs
; sl
; sl
= sl
->next
)
5603 if (sl
->name_len
== len
&& !strncmp (sl
->name
, name
, len
))
5605 name
= *(sl
->ptr_spec
);
5607 fnotice (stderr
, "Processing spec (%s), which is '%s'\n",
5615 value
= do_spec_1 (name
, 0, NULL
);
5620 /* Discard the closing paren. */
5627 error ("spec failure: unrecognized spec option %qc", c
);
5633 /* Backslash: treat next character as ordinary. */
5638 /* Ordinary character: put it into the current argument. */
5639 obstack_1grow (&obstack
, c
);
5643 /* End of string. If we are processing a spec function, we need to
5644 end any pending argument. */
5645 if (processing_spec_function
)
5651 /* Look up a spec function. */
5653 static const struct spec_function
*
5654 lookup_spec_function (const char *name
)
5656 const struct spec_function
*sf
;
5658 for (sf
= static_spec_functions
; sf
->name
!= NULL
; sf
++)
5659 if (strcmp (sf
->name
, name
) == 0)
5665 /* Evaluate a spec function. */
5668 eval_spec_function (const char *func
, const char *args
)
5670 const struct spec_function
*sf
;
5671 const char *funcval
;
5673 /* Saved spec processing context. */
5674 vec
<const_char_p
> save_argbuf
;
5677 int save_delete_this_arg
;
5678 int save_this_is_output_file
;
5679 int save_this_is_library_file
;
5680 int save_input_from_pipe
;
5681 int save_this_is_linker_script
;
5682 const char *save_suffix_subst
;
5684 int save_growing_size
;
5685 void *save_growing_value
= NULL
;
5687 sf
= lookup_spec_function (func
);
5689 fatal_error ("unknown spec function %qs", func
);
5691 /* Push the spec processing context. */
5692 save_argbuf
= argbuf
;
5694 save_arg_going
= arg_going
;
5695 save_delete_this_arg
= delete_this_arg
;
5696 save_this_is_output_file
= this_is_output_file
;
5697 save_this_is_library_file
= this_is_library_file
;
5698 save_this_is_linker_script
= this_is_linker_script
;
5699 save_input_from_pipe
= input_from_pipe
;
5700 save_suffix_subst
= suffix_subst
;
5702 /* If we have some object growing now, finalize it so the args and function
5703 eval proceed from a cleared context. This is needed to prevent the first
5704 constructed arg from mistakenly including the growing value. We'll push
5705 this value back on the obstack once the function evaluation is done, to
5706 restore a consistent processing context for our caller. This is fine as
5707 the address of growing objects isn't guaranteed to remain stable until
5708 they are finalized, and we expect this situation to be rare enough for
5709 the extra copy not to be an issue. */
5710 save_growing_size
= obstack_object_size (&obstack
);
5711 if (save_growing_size
> 0)
5712 save_growing_value
= obstack_finish (&obstack
);
5714 /* Create a new spec processing context, and build the function
5718 if (do_spec_2 (args
) < 0)
5719 fatal_error ("error in args to spec function %qs", func
);
5721 /* argbuf_index is an index for the next argument to be inserted, and
5722 so contains the count of the args already inserted. */
5724 funcval
= (*sf
->func
) (argbuf
.length (),
5727 /* Pop the spec processing context. */
5729 argbuf
= save_argbuf
;
5731 arg_going
= save_arg_going
;
5732 delete_this_arg
= save_delete_this_arg
;
5733 this_is_output_file
= save_this_is_output_file
;
5734 this_is_library_file
= save_this_is_library_file
;
5735 this_is_linker_script
= save_this_is_linker_script
;
5736 input_from_pipe
= save_input_from_pipe
;
5737 suffix_subst
= save_suffix_subst
;
5739 if (save_growing_size
> 0)
5740 obstack_grow (&obstack
, save_growing_value
, save_growing_size
);
5745 /* Handle a spec function call of the form:
5749 ARGS is processed as a spec in a separate context and split into an
5750 argument vector in the normal fashion. The function returns a string
5751 containing a spec which we then process in the caller's context, or
5752 NULL if no processing is required.
5754 If RETVAL_NONNULL is not NULL, then store a bool whether function
5755 returned non-NULL. */
5758 handle_spec_function (const char *p
, bool *retval_nonnull
)
5761 const char *endp
, *funcval
;
5764 processing_spec_function
++;
5766 /* Get the function name. */
5767 for (endp
= p
; *endp
!= '\0'; endp
++)
5769 if (*endp
== '(') /* ) */
5771 /* Only allow [A-Za-z0-9], -, and _ in function names. */
5772 if (!ISALNUM (*endp
) && !(*endp
== '-' || *endp
== '_'))
5773 fatal_error ("malformed spec function name");
5775 if (*endp
!= '(') /* ) */
5776 fatal_error ("no arguments for spec function");
5777 func
= save_string (p
, endp
- p
);
5780 /* Get the arguments. */
5781 for (count
= 0; *endp
!= '\0'; endp
++)
5790 else if (*endp
== '(') /* ) */
5795 fatal_error ("malformed spec function arguments");
5796 args
= save_string (p
, endp
- p
);
5799 /* p now points to just past the end of the spec function expression. */
5801 funcval
= eval_spec_function (func
, args
);
5802 if (funcval
!= NULL
&& do_spec_1 (funcval
, 0, NULL
) < 0)
5805 *retval_nonnull
= funcval
!= NULL
;
5810 processing_spec_function
--;
5815 /* Inline subroutine of handle_braces. Returns true if the current
5816 input suffix matches the atom bracketed by ATOM and END_ATOM. */
5818 input_suffix_matches (const char *atom
, const char *end_atom
)
5820 return (input_suffix
5821 && !strncmp (input_suffix
, atom
, end_atom
- atom
)
5822 && input_suffix
[end_atom
- atom
] == '\0');
5825 /* Subroutine of handle_braces. Returns true if the current
5826 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
5828 input_spec_matches (const char *atom
, const char *end_atom
)
5830 return (input_file_compiler
5831 && input_file_compiler
->suffix
5832 && input_file_compiler
->suffix
[0] != '\0'
5833 && !strncmp (input_file_compiler
->suffix
+ 1, atom
,
5835 && input_file_compiler
->suffix
[end_atom
- atom
+ 1] == '\0');
5838 /* Subroutine of handle_braces. Returns true if a switch
5839 matching the atom bracketed by ATOM and END_ATOM appeared on the
5842 switch_matches (const char *atom
, const char *end_atom
, int starred
)
5845 int len
= end_atom
- atom
;
5846 int plen
= starred
? len
: -1;
5848 for (i
= 0; i
< n_switches
; i
++)
5849 if (!strncmp (switches
[i
].part1
, atom
, len
)
5850 && (starred
|| switches
[i
].part1
[len
] == '\0')
5851 && check_live_switch (i
, plen
))
5854 /* Check if a switch with separated form matching the atom.
5855 We check -D and -U switches. */
5856 else if (switches
[i
].args
!= 0)
5858 if ((*switches
[i
].part1
== 'D' || *switches
[i
].part1
== 'U')
5859 && *switches
[i
].part1
== atom
[0])
5861 if (!strncmp (switches
[i
].args
[0], &atom
[1], len
- 1)
5862 && (starred
|| (switches
[i
].part1
[1] == '\0'
5863 && switches
[i
].args
[0][len
- 1] == '\0'))
5864 && check_live_switch (i
, (starred
? 1 : -1)))
5872 /* Inline subroutine of handle_braces. Mark all of the switches which
5873 match ATOM (extends to END_ATOM; STARRED indicates whether there
5874 was a star after the atom) for later processing. */
5876 mark_matching_switches (const char *atom
, const char *end_atom
, int starred
)
5879 int len
= end_atom
- atom
;
5880 int plen
= starred
? len
: -1;
5882 for (i
= 0; i
< n_switches
; i
++)
5883 if (!strncmp (switches
[i
].part1
, atom
, len
)
5884 && (starred
|| switches
[i
].part1
[len
] == '\0')
5885 && check_live_switch (i
, plen
))
5886 switches
[i
].ordering
= 1;
5889 /* Inline subroutine of handle_braces. Process all the currently
5890 marked switches through give_switch, and clear the marks. */
5892 process_marked_switches (void)
5896 for (i
= 0; i
< n_switches
; i
++)
5897 if (switches
[i
].ordering
== 1)
5899 switches
[i
].ordering
= 0;
5904 /* Handle a %{ ... } construct. P points just inside the leading {.
5905 Returns a pointer one past the end of the brace block, or 0
5906 if we call do_spec_1 and that returns -1. */
5909 handle_braces (const char *p
)
5911 const char *atom
, *end_atom
;
5912 const char *d_atom
= NULL
, *d_end_atom
= NULL
;
5913 const char *orig
= p
;
5921 bool a_must_be_last
= false;
5922 bool ordered_set
= false;
5923 bool disjunct_set
= false;
5924 bool disj_matched
= false;
5925 bool disj_starred
= true;
5926 bool n_way_choice
= false;
5927 bool n_way_matched
= false;
5929 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
5936 /* Scan one "atom" (S in the description above of %{}, possibly
5937 with '!', '.', '@', ',', or '*' modifiers). */
5939 a_is_suffix
= false;
5940 a_is_starred
= false;
5941 a_is_negated
= false;
5942 a_is_spectype
= false;
5946 p
++, a_is_negated
= true;
5949 if (*p
== '%' && p
[1] == ':')
5953 p
= handle_spec_function (p
+ 2, &a_matched
);
5958 p
++, a_is_suffix
= true;
5960 p
++, a_is_spectype
= true;
5963 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
5964 || *p
== ',' || *p
== '.' || *p
== '@')
5969 p
++, a_is_starred
= 1;
5976 /* Substitute the switch(es) indicated by the current atom. */
5978 if (disjunct_set
|| n_way_choice
|| a_is_negated
|| a_is_suffix
5979 || a_is_spectype
|| atom
== end_atom
)
5982 mark_matching_switches (atom
, end_atom
, a_is_starred
);
5985 process_marked_switches ();
5989 /* Substitute some text if the current atom appears as a switch
5991 disjunct_set
= true;
5995 if (atom
&& atom
== end_atom
)
5997 if (!n_way_choice
|| disj_matched
|| *p
== '|'
5998 || a_is_negated
|| a_is_suffix
|| a_is_spectype
6002 /* An empty term may appear as the last choice of an
6003 N-way choice set; it means "otherwise". */
6004 a_must_be_last
= true;
6005 disj_matched
= !n_way_matched
;
6006 disj_starred
= false;
6010 if ((a_is_suffix
|| a_is_spectype
) && a_is_starred
)
6014 disj_starred
= false;
6016 /* Don't bother testing this atom if we already have a
6018 if (!disj_matched
&& !n_way_matched
)
6021 /* a_matched is already set by handle_spec_function. */;
6022 else if (a_is_suffix
)
6023 a_matched
= input_suffix_matches (atom
, end_atom
);
6024 else if (a_is_spectype
)
6025 a_matched
= input_spec_matches (atom
, end_atom
);
6027 a_matched
= switch_matches (atom
, end_atom
, a_is_starred
);
6029 if (a_matched
!= a_is_negated
)
6031 disj_matched
= true;
6033 d_end_atom
= end_atom
;
6040 /* Found the body, that is, the text to substitute if the
6041 current disjunction matches. */
6042 p
= process_brace_body (p
+ 1, d_atom
, d_end_atom
, disj_starred
,
6043 disj_matched
&& !n_way_matched
);
6047 /* If we have an N-way choice, reset state for the next
6051 n_way_choice
= true;
6052 n_way_matched
|= disj_matched
;
6053 disj_matched
= false;
6054 disj_starred
= true;
6055 d_atom
= d_end_atom
= NULL
;
6064 while (*p
++ != '}');
6069 fatal_error ("braced spec %qs is invalid at %qc", orig
, *p
);
6074 /* Subroutine of handle_braces. Scan and process a brace substitution body
6075 (X in the description of %{} syntax). P points one past the colon;
6076 ATOM and END_ATOM bracket the first atom which was found to be true
6077 (present) in the current disjunction; STARRED indicates whether all
6078 the atoms in the current disjunction were starred (for syntax validation);
6079 MATCHED indicates whether the disjunction matched or not, and therefore
6080 whether or not the body is to be processed through do_spec_1 or just
6081 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
6085 process_brace_body (const char *p
, const char *atom
, const char *end_atom
,
6086 int starred
, int matched
)
6088 const char *body
, *end_body
;
6089 unsigned int nesting_level
;
6090 bool have_subst
= false;
6092 /* Locate the closing } or ;, honoring nested braces.
6093 Trim trailing whitespace. */
6102 if (!--nesting_level
)
6105 else if (*p
== ';' && nesting_level
== 1)
6107 else if (*p
== '%' && p
[1] == '*' && nesting_level
== 1)
6109 else if (*p
== '\0')
6115 while (end_body
[-1] == ' ' || end_body
[-1] == '\t')
6118 if (have_subst
&& !starred
)
6123 /* Copy the substitution body to permanent storage and execute it.
6124 If have_subst is false, this is a simple matter of running the
6125 body through do_spec_1... */
6126 char *string
= save_string (body
, end_body
- body
);
6129 if (do_spec_1 (string
, 0, NULL
) < 0)
6134 /* ... but if have_subst is true, we have to process the
6135 body once for each matching switch, with %* set to the
6136 variant part of the switch. */
6137 unsigned int hard_match_len
= end_atom
- atom
;
6140 for (i
= 0; i
< n_switches
; i
++)
6141 if (!strncmp (switches
[i
].part1
, atom
, hard_match_len
)
6142 && check_live_switch (i
, hard_match_len
))
6144 if (do_spec_1 (string
, 0,
6145 &switches
[i
].part1
[hard_match_len
]) < 0)
6147 /* Pass any arguments this switch has. */
6149 suffix_subst
= NULL
;
6157 fatal_error ("braced spec body %qs is invalid", body
);
6160 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
6161 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
6162 spec, or -1 if either exact match or %* is used.
6164 A -O switch is obsoleted by a later -O switch. A -f, -g, -m, or -W switch
6165 whose value does not begin with "no-" is obsoleted by the same value
6166 with the "no-", similarly for a switch with the "no-" prefix. */
6169 check_live_switch (int switchnum
, int prefix_length
)
6171 const char *name
= switches
[switchnum
].part1
;
6174 /* If we already processed this switch and determined if it was
6175 live or not, return our past determination. */
6176 if (switches
[switchnum
].live_cond
!= 0)
6177 return ((switches
[switchnum
].live_cond
& SWITCH_LIVE
) != 0
6178 && (switches
[switchnum
].live_cond
& SWITCH_FALSE
) == 0
6179 && (switches
[switchnum
].live_cond
& SWITCH_IGNORE_PERMANENTLY
)
6182 /* In the common case of {<at-most-one-letter>*}, a negating
6183 switch would always match, so ignore that case. We will just
6184 send the conflicting switches to the compiler phase. */
6185 if (prefix_length
>= 0 && prefix_length
<= 1)
6188 /* Now search for duplicate in a manner that depends on the name. */
6192 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
6193 if (switches
[i
].part1
[0] == 'O')
6195 switches
[switchnum
].validated
= true;
6196 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
6201 case 'W': case 'f': case 'm': case 'g':
6202 if (! strncmp (name
+ 1, "no-", 3))
6204 /* We have Xno-YYY, search for XYYY. */
6205 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
6206 if (switches
[i
].part1
[0] == name
[0]
6207 && ! strcmp (&switches
[i
].part1
[1], &name
[4]))
6209 /* --specs are validated with the validate_switches mechanism. */
6210 if (switches
[switchnum
].known
)
6211 switches
[switchnum
].validated
= true;
6212 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
6218 /* We have XYYY, search for Xno-YYY. */
6219 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
6220 if (switches
[i
].part1
[0] == name
[0]
6221 && switches
[i
].part1
[1] == 'n'
6222 && switches
[i
].part1
[2] == 'o'
6223 && switches
[i
].part1
[3] == '-'
6224 && !strcmp (&switches
[i
].part1
[4], &name
[1]))
6226 /* --specs are validated with the validate_switches mechanism. */
6227 if (switches
[switchnum
].known
)
6228 switches
[switchnum
].validated
= true;
6229 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
6236 /* Otherwise the switch is live. */
6237 switches
[switchnum
].live_cond
|= SWITCH_LIVE
;
6241 /* Pass a switch to the current accumulating command
6242 in the same form that we received it.
6243 SWITCHNUM identifies the switch; it is an index into
6244 the vector of switches gcc received, which is `switches'.
6245 This cannot fail since it never finishes a command line.
6247 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
6250 give_switch (int switchnum
, int omit_first_word
)
6252 if ((switches
[switchnum
].live_cond
& SWITCH_IGNORE
) != 0)
6255 if (!omit_first_word
)
6257 do_spec_1 ("-", 0, NULL
);
6258 do_spec_1 (switches
[switchnum
].part1
, 1, NULL
);
6261 if (switches
[switchnum
].args
!= 0)
6264 for (p
= switches
[switchnum
].args
; *p
; p
++)
6266 const char *arg
= *p
;
6268 do_spec_1 (" ", 0, NULL
);
6271 unsigned length
= strlen (arg
);
6274 while (length
-- && !IS_DIR_SEPARATOR (arg
[length
]))
6275 if (arg
[length
] == '.')
6277 (CONST_CAST (char *, arg
))[length
] = 0;
6281 do_spec_1 (arg
, 1, NULL
);
6283 (CONST_CAST (char *, arg
))[length
] = '.';
6284 do_spec_1 (suffix_subst
, 1, NULL
);
6287 do_spec_1 (arg
, 1, NULL
);
6291 do_spec_1 (" ", 0, NULL
);
6292 switches
[switchnum
].validated
= true;
6295 /* Print GCC configuration (e.g. version, thread model, target,
6296 configuration_arguments) to a given FILE. */
6299 print_configuration (FILE *file
)
6304 fnotice (file
, "Target: %s\n", spec_machine
);
6305 fnotice (file
, "Configured with: %s\n", configuration_arguments
);
6307 #ifdef THREAD_MODEL_SPEC
6308 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
6309 but there's no point in doing all this processing just to get
6310 thread_model back. */
6311 obstack_init (&obstack
);
6312 do_spec_1 (THREAD_MODEL_SPEC
, 0, thread_model
);
6313 obstack_1grow (&obstack
, '\0');
6314 thrmod
= XOBFINISH (&obstack
, const char *);
6316 thrmod
= thread_model
;
6319 fnotice (file
, "Thread model: %s\n", thrmod
);
6321 /* compiler_version is truncated at the first space when initialized
6322 from version string, so truncate version_string at the first space
6323 before comparing. */
6324 for (n
= 0; version_string
[n
]; n
++)
6325 if (version_string
[n
] == ' ')
6328 if (! strncmp (version_string
, compiler_version
, n
)
6329 && compiler_version
[n
] == 0)
6330 fnotice (file
, "gcc version %s %s\n\n", version_string
,
6333 fnotice (file
, "gcc driver version %s %sexecuting gcc version %s\n\n",
6334 version_string
, pkgversion_string
, compiler_version
);
6338 #define RETRY_ICE_ATTEMPTS 3
6340 /* Returns true if FILE1 and FILE2 contain equivalent data, 0 otherwise. */
6343 files_equal_p (char *file1
, char *file2
)
6345 struct stat st1
, st2
;
6348 const int bufsize
= 8192;
6349 char *buf
= XNEWVEC (char, bufsize
);
6351 fd1
= open (file1
, O_RDONLY
);
6352 fd2
= open (file2
, O_RDONLY
);
6354 if (fd1
< 0 || fd2
< 0)
6357 if (fstat (fd1
, &st1
) < 0 || fstat (fd2
, &st2
) < 0)
6360 if (st1
.st_size
!= st2
.st_size
)
6363 for (n
= st1
.st_size
; n
; n
-= len
)
6366 if ((int) len
> bufsize
/ 2)
6369 if (read (fd1
, buf
, len
) != (int) len
6370 || read (fd2
, buf
+ bufsize
/ 2, len
) != (int) len
)
6375 if (memcmp (buf
, buf
+ bufsize
/ 2, len
) != 0)
6392 /* Check that compiler's output doesn't differ across runs.
6393 TEMP_STDOUT_FILES and TEMP_STDERR_FILES are arrays of files, containing
6394 stdout and stderr for each compiler run. Return true if all of
6395 TEMP_STDOUT_FILES and TEMP_STDERR_FILES are equivalent. */
6398 check_repro (char **temp_stdout_files
, char **temp_stderr_files
)
6401 for (i
= 0; i
< RETRY_ICE_ATTEMPTS
- 2; ++i
)
6403 if (!files_equal_p (temp_stdout_files
[i
], temp_stdout_files
[i
+ 1])
6404 || !files_equal_p (temp_stderr_files
[i
], temp_stderr_files
[i
+ 1]))
6406 fnotice (stderr
, "The bug is not reproducible, so it is"
6407 " likely a hardware or OS problem.\n");
6411 return i
== RETRY_ICE_ATTEMPTS
- 2;
6414 enum attempt_status
{
6415 ATTEMPT_STATUS_FAIL_TO_RUN
,
6416 ATTEMPT_STATUS_SUCCESS
,
6421 /* Run compiler with arguments NEW_ARGV to reproduce the ICE, storing stdout
6422 to OUT_TEMP and stderr to ERR_TEMP. If APPEND is TRUE, append to OUT_TEMP
6423 and ERR_TEMP instead of truncating. If EMIT_SYSTEM_INFO is TRUE, also write
6424 GCC configuration into to ERR_TEMP. Return ATTEMPT_STATUS_FAIL_TO_RUN if
6425 compiler failed to run, ATTEMPT_STATUS_ICE if compiled ICE-ed and
6426 ATTEMPT_STATUS_SUCCESS otherwise. */
6428 static enum attempt_status
6429 run_attempt (const char **new_argv
, const char *out_temp
,
6430 const char *err_temp
, int emit_system_info
, int append
)
6433 if (emit_system_info
)
6435 FILE *file_out
= fopen (err_temp
, "a");
6436 print_configuration (file_out
);
6442 struct pex_obj
*pex
;
6444 int pex_flags
= PEX_USE_PIPES
| PEX_LAST
;
6445 enum attempt_status status
= ATTEMPT_STATUS_FAIL_TO_RUN
;
6448 pex_flags
|= PEX_STDOUT_APPEND
| PEX_STDERR_APPEND
;
6450 pex
= pex_init (PEX_USE_PIPES
, new_argv
[0], NULL
);
6452 fatal_error ("pex_init failed: %m");
6454 errmsg
= pex_run (pex
, pex_flags
, new_argv
[0],
6455 CONST_CAST2 (char *const *, const char **, &new_argv
[1]), out_temp
,
6460 fatal_error (errmsg
);
6464 pfatal_with_name (errmsg
);
6468 if (!pex_get_status (pex
, 1, &exit_status
))
6471 switch (WEXITSTATUS (exit_status
))
6474 status
= ATTEMPT_STATUS_ICE
;
6477 case SUCCESS_EXIT_CODE
:
6478 status
= ATTEMPT_STATUS_SUCCESS
;
6490 /* This routine adds preprocessed source code into the given ERR_FILE.
6491 To do this, it adds "-E" to NEW_ARGV and execute RUN_ATTEMPT routine to
6492 add information in report file. RUN_ATTEMPT should return
6493 ATTEMPT_STATUS_SUCCESS, in other case we cannot generate the report. */
6496 do_report_bug (const char **new_argv
, const int nargs
,
6497 char **out_file
, char **err_file
)
6500 int fd
= open (*out_file
, O_RDWR
| O_APPEND
);
6503 write (fd
, "\n//", 3);
6504 for (i
= 0; i
< nargs
; i
++)
6507 write (fd
, new_argv
[i
], strlen (new_argv
[i
]));
6509 write (fd
, "\n\n", 2);
6511 new_argv
[nargs
] = "-E";
6512 new_argv
[nargs
+ 1] = NULL
;
6514 status
= run_attempt (new_argv
, *out_file
, *err_file
, 0, 1);
6516 if (status
== ATTEMPT_STATUS_SUCCESS
)
6518 fnotice (stderr
, "Preprocessed source stored into %s file,"
6519 " please attach this to your bugreport.\n", *out_file
);
6520 /* Make sure it is not deleted. */
6526 /* Append string STR to file FILE. */
6529 append_text (char *file
, const char *str
)
6531 int fd
= open (file
, O_RDWR
| O_APPEND
);
6535 write (fd
, str
, strlen (str
));
6539 /* Try to reproduce ICE. If bug is reproducible, generate report .err file
6540 containing GCC configuration, backtrace, compiler's command line options
6541 and preprocessed source code. */
6544 try_generate_repro (const char **argv
)
6546 int i
, nargs
, out_arg
= -1, quiet
= 0, attempt
;
6547 const char **new_argv
;
6548 char *temp_files
[RETRY_ICE_ATTEMPTS
* 2];
6549 char **temp_stdout_files
= &temp_files
[0];
6550 char **temp_stderr_files
= &temp_files
[RETRY_ICE_ATTEMPTS
];
6552 if (gcc_input_filename
== NULL
|| ! strcmp (gcc_input_filename
, "-"))
6555 for (nargs
= 0; argv
[nargs
] != NULL
; ++nargs
)
6556 /* Only retry compiler ICEs, not preprocessor ones. */
6557 if (! strcmp (argv
[nargs
], "-E"))
6559 else if (argv
[nargs
][0] == '-' && argv
[nargs
][1] == 'o')
6566 /* If the compiler is going to output any time information,
6567 it might varry between invocations. */
6568 else if (! strcmp (argv
[nargs
], "-quiet"))
6570 else if (! strcmp (argv
[nargs
], "-ftime-report"))
6573 if (out_arg
== -1 || !quiet
)
6576 memset (temp_files
, '\0', sizeof (temp_files
));
6577 new_argv
= XALLOCAVEC (const char *, nargs
+ 4);
6578 memcpy (new_argv
, argv
, (nargs
+ 1) * sizeof (const char *));
6579 new_argv
[nargs
++] = "-frandom-seed=0";
6580 new_argv
[nargs
++] = "-fdump-noaddr";
6581 new_argv
[nargs
] = NULL
;
6582 if (new_argv
[out_arg
][2] == '\0')
6583 new_argv
[out_arg
+ 1] = "-";
6585 new_argv
[out_arg
] = "-o-";
6588 for (attempt
= 0; attempt
< RETRY_ICE_ATTEMPTS
; ++attempt
)
6590 int emit_system_info
= 0;
6592 temp_stdout_files
[attempt
] = make_temp_file (".out");
6593 temp_stderr_files
[attempt
] = make_temp_file (".err");
6595 if (attempt
== RETRY_ICE_ATTEMPTS
- 1)
6598 emit_system_info
= 1;
6601 if (emit_system_info
)
6602 append_text (temp_stderr_files
[attempt
], "/*\n");
6604 status
= run_attempt (new_argv
, temp_stdout_files
[attempt
],
6605 temp_stderr_files
[attempt
], emit_system_info
,
6608 if (emit_system_info
)
6609 append_text (temp_stderr_files
[attempt
], "*/\n");
6611 if (status
!= ATTEMPT_STATUS_ICE
)
6613 fnotice (stderr
, "The bug is not reproducible, so it is"
6614 " likely a hardware or OS problem.\n");
6619 if (!check_repro (temp_stdout_files
, temp_stderr_files
))
6622 /* In final attempt we append compiler options and preprocesssed code to last
6623 generated .err file with configuration and backtrace. */
6624 do_report_bug (new_argv
, nargs
,
6625 &temp_stderr_files
[RETRY_ICE_ATTEMPTS
- 1],
6626 &temp_stdout_files
[RETRY_ICE_ATTEMPTS
- 1]);
6629 for (i
= 0; i
< RETRY_ICE_ATTEMPTS
* 2; i
++)
6632 unlink (temp_stdout_files
[i
]);
6633 free (temp_stdout_files
[i
]);
6637 /* Search for a file named NAME trying various prefixes including the
6638 user's -B prefix and some standard ones.
6639 Return the absolute file name found. If nothing is found, return NAME. */
6642 find_file (const char *name
)
6644 char *newname
= find_a_file (&startfile_prefixes
, name
, R_OK
, true);
6645 return newname
? newname
: name
;
6648 /* Determine whether a directory exists. If LINKER, return 0 for
6649 certain fixed names not needed by the linker. */
6652 is_directory (const char *path1
, bool linker
)
6659 /* Ensure the string ends with "/.". The resulting path will be a
6660 directory even if the given path is a symbolic link. */
6661 len1
= strlen (path1
);
6662 path
= (char *) alloca (3 + len1
);
6663 memcpy (path
, path1
, len1
);
6665 if (!IS_DIR_SEPARATOR (cp
[-1]))
6666 *cp
++ = DIR_SEPARATOR
;
6670 /* Exclude directories that the linker is known to search. */
6672 && IS_DIR_SEPARATOR (path
[0])
6674 && filename_ncmp (path
+ 1, "lib", 3) == 0)
6676 && filename_ncmp (path
+ 1, "usr", 3) == 0
6677 && IS_DIR_SEPARATOR (path
[4])
6678 && filename_ncmp (path
+ 5, "lib", 3) == 0)))
6681 return (stat (path
, &st
) >= 0 && S_ISDIR (st
.st_mode
));
6684 /* Set up the various global variables to indicate that we're processing
6685 the input file named FILENAME. */
6688 set_input (const char *filename
)
6692 gcc_input_filename
= filename
;
6693 input_filename_length
= strlen (gcc_input_filename
);
6694 input_basename
= lbasename (gcc_input_filename
);
6696 /* Find a suffix starting with the last period,
6697 and set basename_length to exclude that suffix. */
6698 basename_length
= strlen (input_basename
);
6699 suffixed_basename_length
= basename_length
;
6700 p
= input_basename
+ basename_length
;
6701 while (p
!= input_basename
&& *p
!= '.')
6703 if (*p
== '.' && p
!= input_basename
)
6705 basename_length
= p
- input_basename
;
6706 input_suffix
= p
+ 1;
6711 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
6712 we will need to do a stat on the gcc_input_filename. The
6713 INPUT_STAT_SET signals that the stat is needed. */
6717 /* On fatal signals, delete all the temporary files. */
6720 fatal_signal (int signum
)
6722 signal (signum
, SIG_DFL
);
6723 delete_failure_queue ();
6724 delete_temp_files ();
6725 /* Get the same signal again, this time not handled,
6726 so its normal effect occurs. */
6727 kill (getpid (), signum
);
6730 /* Compare the contents of the two files named CMPFILE[0] and
6731 CMPFILE[1]. Return zero if they're identical, nonzero
6735 compare_files (char *cmpfile
[])
6738 FILE *temp
[2] = { NULL
, NULL
};
6744 void *map
[2] = { NULL
, NULL
};
6746 for (i
= 0; i
< 2; i
++)
6750 if (stat (cmpfile
[i
], &st
) < 0 || !S_ISREG (st
.st_mode
))
6752 error ("%s: could not determine length of compare-debug file %s",
6753 gcc_input_filename
, cmpfile
[i
]);
6758 length
[i
] = st
.st_size
;
6761 if (!ret
&& length
[0] != length
[1])
6763 error ("%s: -fcompare-debug failure (length)", gcc_input_filename
);
6768 for (i
= 0; i
< 2; i
++)
6770 int fd
= open (cmpfile
[i
], O_RDONLY
);
6773 error ("%s: could not open compare-debug file %s",
6774 gcc_input_filename
, cmpfile
[i
]);
6779 map
[i
] = mmap (NULL
, length
[i
], PROT_READ
, MAP_PRIVATE
, fd
, 0);
6782 if (map
[i
] == (void *) MAP_FAILED
)
6791 if (memcmp (map
[0], map
[1], length
[0]) != 0)
6793 error ("%s: -fcompare-debug failure", gcc_input_filename
);
6798 for (i
= 0; i
< 2; i
++)
6800 munmap ((caddr_t
) map
[i
], length
[i
]);
6809 for (i
= 0; i
< 2; i
++)
6811 temp
[i
] = fopen (cmpfile
[i
], "r");
6814 error ("%s: could not open compare-debug file %s",
6815 gcc_input_filename
, cmpfile
[i
]);
6821 if (!ret
&& temp
[0] && temp
[1])
6825 c0
= fgetc (temp
[0]);
6826 c1
= fgetc (temp
[1]);
6830 error ("%s: -fcompare-debug failure",
6831 gcc_input_filename
);
6840 for (i
= 1; i
>= 0; i
--)
6849 /* The top-level "main" within the driver would be ~1000 lines long.
6850 This class breaks it up into smaller functions and contains some
6851 state shared by them. */
6856 int main (int argc
, char **argv
);
6859 void set_progname (const char *argv0
) const;
6860 void expand_at_files (int *argc
, char ***argv
) const;
6861 void decode_argv (int argc
, const char **argv
);
6862 void global_initializations ();
6863 void build_multilib_strings () const;
6864 void set_up_specs () const;
6865 void putenv_COLLECT_GCC (const char *argv0
) const;
6866 void maybe_putenv_COLLECT_LTO_WRAPPER () const;
6867 void maybe_putenv_OFFLOAD_TARGETS () const;
6868 void handle_unrecognized_options () const;
6869 int maybe_print_and_exit () const;
6870 bool prepare_infiles ();
6871 void do_spec_on_infiles () const;
6872 void maybe_run_linker (const char *argv0
) const;
6873 void final_actions () const;
6874 int get_exit_code () const;
6877 char *explicit_link_files
;
6878 struct cl_decoded_option
*decoded_options
;
6879 unsigned int decoded_options_count
;
6882 /* Implement the top-level "main" within the driver in terms of
6885 extern int main (int, char **);
6888 main (int argc
, char **argv
)
6892 return d
.main (argc
, argv
);
6895 /* driver::main is implemented as a series of driver:: method calls. */
6898 driver::main (int argc
, char **argv
)
6902 set_progname (argv
[0]);
6903 expand_at_files (&argc
, &argv
);
6904 decode_argv (argc
, const_cast <const char **> (argv
));
6905 global_initializations ();
6906 build_multilib_strings ();
6908 putenv_COLLECT_GCC (argv
[0]);
6909 maybe_putenv_COLLECT_LTO_WRAPPER ();
6910 maybe_putenv_OFFLOAD_TARGETS ();
6911 handle_unrecognized_options ();
6913 if (!maybe_print_and_exit ())
6916 early_exit
= prepare_infiles ();
6918 return get_exit_code ();
6920 do_spec_on_infiles ();
6921 maybe_run_linker (argv
[0]);
6923 return get_exit_code ();
6926 /* Locate the final component of argv[0] after any leading path, and set
6927 the program name accordingly. */
6930 driver::set_progname (const char *argv0
) const
6932 const char *p
= argv0
+ strlen (argv0
);
6933 while (p
!= argv0
&& !IS_DIR_SEPARATOR (p
[-1]))
6937 xmalloc_set_program_name (progname
);
6940 /* Expand any @ files within the command-line args,
6941 setting at_file_supplied if any were expanded. */
6944 driver::expand_at_files (int *argc
, char ***argv
) const
6946 char **old_argv
= *argv
;
6948 expandargv (argc
, argv
);
6950 /* Determine if any expansions were made. */
6951 if (*argv
!= old_argv
)
6952 at_file_supplied
= true;
6955 /* Decode the command-line arguments from argc/argv into the
6956 decoded_options array. */
6959 driver::decode_argv (int argc
, const char **argv
)
6961 /* Register the language-independent parameters. */
6962 global_init_params ();
6965 init_options_struct (&global_options
, &global_options_set
);
6967 decode_cmdline_options_to_array (argc
, argv
,
6969 &decoded_options
, &decoded_options_count
);
6972 /* Perform various initializations and setup. */
6975 driver::global_initializations ()
6977 /* Unlock the stdio streams. */
6978 unlock_std_streams ();
6980 gcc_init_libintl ();
6982 diagnostic_initialize (global_dc
, 0);
6983 diagnostic_color_init (global_dc
);
6985 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6986 /* Perform host dependent initialization when needed. */
6987 GCC_DRIVER_HOST_INITIALIZATION
;
6990 if (atexit (delete_temp_files
) != 0)
6991 fatal_error ("atexit failed");
6993 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
6994 signal (SIGINT
, fatal_signal
);
6996 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
6997 signal (SIGHUP
, fatal_signal
);
6999 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
7000 signal (SIGTERM
, fatal_signal
);
7002 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
7003 signal (SIGPIPE
, fatal_signal
);
7006 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
7007 receive the signal. A different setting is inheritable */
7008 signal (SIGCHLD
, SIG_DFL
);
7011 /* Parsing and gimplification sometimes need quite large stack.
7012 Increase stack size limits if possible. */
7013 stack_limit_increase (64 * 1024 * 1024);
7015 /* Allocate the argument vector. */
7018 obstack_init (&obstack
);
7021 /* Build multilib_select, et. al from the separate lines that make up each
7022 multilib selection. */
7025 driver::build_multilib_strings () const
7029 const char *const *q
= multilib_raw
;
7032 obstack_init (&multilib_obstack
);
7033 while ((p
= *q
++) != (char *) 0)
7034 obstack_grow (&multilib_obstack
, p
, strlen (p
));
7036 obstack_1grow (&multilib_obstack
, 0);
7037 multilib_select
= XOBFINISH (&multilib_obstack
, const char *);
7039 q
= multilib_matches_raw
;
7040 while ((p
= *q
++) != (char *) 0)
7041 obstack_grow (&multilib_obstack
, p
, strlen (p
));
7043 obstack_1grow (&multilib_obstack
, 0);
7044 multilib_matches
= XOBFINISH (&multilib_obstack
, const char *);
7046 q
= multilib_exclusions_raw
;
7047 while ((p
= *q
++) != (char *) 0)
7048 obstack_grow (&multilib_obstack
, p
, strlen (p
));
7050 obstack_1grow (&multilib_obstack
, 0);
7051 multilib_exclusions
= XOBFINISH (&multilib_obstack
, const char *);
7053 q
= multilib_reuse_raw
;
7054 while ((p
= *q
++) != (char *) 0)
7055 obstack_grow (&multilib_obstack
, p
, strlen (p
));
7057 obstack_1grow (&multilib_obstack
, 0);
7058 multilib_reuse
= XOBFINISH (&multilib_obstack
, const char *);
7061 for (size_t i
= 0; i
< ARRAY_SIZE (multilib_defaults_raw
); i
++)
7064 obstack_1grow (&multilib_obstack
, ' ');
7065 obstack_grow (&multilib_obstack
,
7066 multilib_defaults_raw
[i
],
7067 strlen (multilib_defaults_raw
[i
]));
7071 obstack_1grow (&multilib_obstack
, 0);
7072 multilib_defaults
= XOBFINISH (&multilib_obstack
, const char *);
7076 /* Set up the spec-handling machinery. */
7079 driver::set_up_specs () const
7081 const char *spec_machine_suffix
;
7085 #ifdef INIT_ENVIRONMENT
7086 /* Set up any other necessary machine specific environment variables. */
7087 xputenv (INIT_ENVIRONMENT
);
7090 /* Make a table of what switches there are (switches, n_switches).
7091 Make a table of specified input files (infiles, n_infiles).
7092 Decode switches that are handled locally. */
7094 process_command (decoded_options_count
, decoded_options
);
7096 /* Initialize the vector of specs to just the default.
7097 This means one element containing 0s, as a terminator. */
7099 compilers
= XNEWVAR (struct compiler
, sizeof default_compilers
);
7100 memcpy (compilers
, default_compilers
, sizeof default_compilers
);
7101 n_compilers
= n_default_compilers
;
7103 /* Read specs from a file if there is one. */
7105 machine_suffix
= concat (spec_host_machine
, dir_separator_str
, spec_version
,
7106 accel_dir_suffix
, dir_separator_str
, NULL
);
7107 just_machine_suffix
= concat (spec_machine
, dir_separator_str
, NULL
);
7109 specs_file
= find_a_file (&startfile_prefixes
, "specs", R_OK
, true);
7110 /* Read the specs file unless it is a default one. */
7111 if (specs_file
!= 0 && strcmp (specs_file
, "specs"))
7112 read_specs (specs_file
, true, false);
7116 #ifdef ACCEL_COMPILER
7117 spec_machine_suffix
= machine_suffix
;
7119 spec_machine_suffix
= just_machine_suffix
;
7122 /* We need to check standard_exec_prefix/spec_machine_suffix/specs
7123 for any override of as, ld and libraries. */
7124 specs_file
= (char *) alloca (strlen (standard_exec_prefix
)
7125 + strlen (spec_machine_suffix
) + sizeof ("specs"));
7126 strcpy (specs_file
, standard_exec_prefix
);
7127 strcat (specs_file
, spec_machine_suffix
);
7128 strcat (specs_file
, "specs");
7129 if (access (specs_file
, R_OK
) == 0)
7130 read_specs (specs_file
, true, false);
7132 /* Process any configure-time defaults specified for the command line
7133 options, via OPTION_DEFAULT_SPECS. */
7134 for (i
= 0; i
< ARRAY_SIZE (option_default_specs
); i
++)
7135 do_option_spec (option_default_specs
[i
].name
,
7136 option_default_specs
[i
].spec
);
7138 /* Process DRIVER_SELF_SPECS, adding any new options to the end
7139 of the command line. */
7141 for (i
= 0; i
< ARRAY_SIZE (driver_self_specs
); i
++)
7142 do_self_spec (driver_self_specs
[i
]);
7144 /* If not cross-compiling, look for executables in the standard
7146 if (*cross_compile
== '0')
7148 if (*md_exec_prefix
)
7150 add_prefix (&exec_prefixes
, md_exec_prefix
, "GCC",
7151 PREFIX_PRIORITY_LAST
, 0, 0);
7155 /* Process sysroot_suffix_spec. */
7156 if (*sysroot_suffix_spec
!= 0
7157 && !no_sysroot_suffix
7158 && do_spec_2 (sysroot_suffix_spec
) == 0)
7160 if (argbuf
.length () > 1)
7161 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
7162 else if (argbuf
.length () == 1)
7163 target_sysroot_suffix
= xstrdup (argbuf
.last ());
7166 #ifdef HAVE_LD_SYSROOT
7167 /* Pass the --sysroot option to the linker, if it supports that. If
7168 there is a sysroot_suffix_spec, it has already been processed by
7169 this point, so target_system_root really is the system root we
7171 if (target_system_root
)
7173 obstack_grow (&obstack
, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
7174 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
7175 set_spec ("link", XOBFINISH (&obstack
, const char *), false);
7179 /* Process sysroot_hdrs_suffix_spec. */
7180 if (*sysroot_hdrs_suffix_spec
!= 0
7181 && !no_sysroot_suffix
7182 && do_spec_2 (sysroot_hdrs_suffix_spec
) == 0)
7184 if (argbuf
.length () > 1)
7185 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
7186 else if (argbuf
.length () == 1)
7187 target_sysroot_hdrs_suffix
= xstrdup (argbuf
.last ());
7190 /* Look for startfiles in the standard places. */
7191 if (*startfile_prefix_spec
!= 0
7192 && do_spec_2 (startfile_prefix_spec
) == 0
7193 && do_spec_1 (" ", 0, NULL
) == 0)
7197 FOR_EACH_VEC_ELT (argbuf
, ndx
, arg
)
7198 add_sysrooted_prefix (&startfile_prefixes
, arg
, "BINUTILS",
7199 PREFIX_PRIORITY_LAST
, 0, 1);
7201 /* We should eventually get rid of all these and stick to
7202 startfile_prefix_spec exclusively. */
7203 else if (*cross_compile
== '0' || target_system_root
)
7205 if (*md_startfile_prefix
)
7206 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix
,
7207 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
7209 if (*md_startfile_prefix_1
)
7210 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix_1
,
7211 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
7213 /* If standard_startfile_prefix is relative, base it on
7214 standard_exec_prefix. This lets us move the installed tree
7215 as a unit. If GCC_EXEC_PREFIX is defined, base
7216 standard_startfile_prefix on that as well.
7218 If the prefix is relative, only search it for native compilers;
7219 otherwise we will search a directory containing host libraries. */
7220 if (IS_ABSOLUTE_PATH (standard_startfile_prefix
))
7221 add_sysrooted_prefix (&startfile_prefixes
,
7222 standard_startfile_prefix
, "BINUTILS",
7223 PREFIX_PRIORITY_LAST
, 0, 1);
7224 else if (*cross_compile
== '0')
7226 add_prefix (&startfile_prefixes
,
7227 concat (gcc_exec_prefix
7228 ? gcc_exec_prefix
: standard_exec_prefix
,
7230 standard_startfile_prefix
, NULL
),
7231 NULL
, PREFIX_PRIORITY_LAST
, 0, 1);
7234 /* Sysrooted prefixes are relocated because target_system_root is
7235 also relocated by gcc_exec_prefix. */
7236 if (*standard_startfile_prefix_1
)
7237 add_sysrooted_prefix (&startfile_prefixes
,
7238 standard_startfile_prefix_1
, "BINUTILS",
7239 PREFIX_PRIORITY_LAST
, 0, 1);
7240 if (*standard_startfile_prefix_2
)
7241 add_sysrooted_prefix (&startfile_prefixes
,
7242 standard_startfile_prefix_2
, "BINUTILS",
7243 PREFIX_PRIORITY_LAST
, 0, 1);
7246 /* Process any user specified specs in the order given on the command
7248 for (struct user_specs
*uptr
= user_specs_head
; uptr
; uptr
= uptr
->next
)
7250 char *filename
= find_a_file (&startfile_prefixes
, uptr
->filename
,
7252 read_specs (filename
? filename
: uptr
->filename
, false, true);
7255 /* Process any user self specs. */
7257 struct spec_list
*sl
;
7258 for (sl
= specs
; sl
; sl
= sl
->next
)
7259 if (sl
->name_len
== sizeof "self_spec" - 1
7260 && !strcmp (sl
->name
, "self_spec"))
7261 do_self_spec (*sl
->ptr_spec
);
7266 enum save_temps save
;
7268 if (!compare_debug_second
)
7270 n_switches_debug_check
[1] = n_switches
;
7271 n_switches_alloc_debug_check
[1] = n_switches_alloc
;
7272 switches_debug_check
[1] = XDUPVEC (struct switchstr
, switches
,
7275 do_self_spec ("%:compare-debug-self-opt()");
7276 n_switches_debug_check
[0] = n_switches
;
7277 n_switches_alloc_debug_check
[0] = n_switches_alloc
;
7278 switches_debug_check
[0] = switches
;
7280 n_switches
= n_switches_debug_check
[1];
7281 n_switches_alloc
= n_switches_alloc_debug_check
[1];
7282 switches
= switches_debug_check
[1];
7285 /* Avoid crash when computing %j in this early. */
7286 save
= save_temps_flag
;
7287 save_temps_flag
= SAVE_TEMPS_NONE
;
7289 compare_debug
= -compare_debug
;
7290 do_self_spec ("%:compare-debug-self-opt()");
7292 save_temps_flag
= save
;
7294 if (!compare_debug_second
)
7296 n_switches_debug_check
[1] = n_switches
;
7297 n_switches_alloc_debug_check
[1] = n_switches_alloc
;
7298 switches_debug_check
[1] = switches
;
7299 compare_debug
= -compare_debug
;
7300 n_switches
= n_switches_debug_check
[0];
7301 n_switches_alloc
= n_switches_debug_check
[0];
7302 switches
= switches_debug_check
[0];
7307 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
7308 if (gcc_exec_prefix
)
7309 gcc_exec_prefix
= concat (gcc_exec_prefix
, spec_host_machine
,
7310 dir_separator_str
, spec_version
,
7311 accel_dir_suffix
, dir_separator_str
, NULL
);
7313 /* Now we have the specs.
7314 Set the `valid' bits for switches that match anything in any spec. */
7316 validate_all_switches ();
7318 /* Now that we have the switches and the specs, set
7319 the subdirectory based on the options. */
7320 set_multilib_dir ();
7323 /* Set up to remember the pathname of gcc and any options
7324 needed for collect. We use argv[0] instead of progname because
7325 we need the complete pathname. */
7328 driver::putenv_COLLECT_GCC (const char *argv0
) const
7330 obstack_init (&collect_obstack
);
7331 obstack_grow (&collect_obstack
, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
7332 obstack_grow (&collect_obstack
, argv0
, strlen (argv0
) + 1);
7333 xputenv (XOBFINISH (&collect_obstack
, char *));
7336 /* Set up to remember the pathname of the lto wrapper. */
7339 driver::maybe_putenv_COLLECT_LTO_WRAPPER () const
7341 char *lto_wrapper_file
;
7344 lto_wrapper_file
= NULL
;
7346 lto_wrapper_file
= find_a_file (&exec_prefixes
, "lto-wrapper",
7348 if (lto_wrapper_file
)
7350 lto_wrapper_file
= convert_white_space (lto_wrapper_file
);
7351 lto_wrapper_spec
= lto_wrapper_file
;
7352 obstack_init (&collect_obstack
);
7353 obstack_grow (&collect_obstack
, "COLLECT_LTO_WRAPPER=",
7354 sizeof ("COLLECT_LTO_WRAPPER=") - 1);
7355 obstack_grow (&collect_obstack
, lto_wrapper_spec
,
7356 strlen (lto_wrapper_spec
) + 1);
7357 xputenv (XOBFINISH (&collect_obstack
, char *));
7362 /* Set up to remember the names of offload targets. */
7365 driver::maybe_putenv_OFFLOAD_TARGETS () const
7367 const char *targets
= offload_targets
;
7369 /* If no targets specified by -foffload, use all available targets. */
7371 targets
= OFFLOAD_TARGETS
;
7373 if (strlen (targets
) > 0)
7375 obstack_grow (&collect_obstack
, "OFFLOAD_TARGET_NAMES=",
7376 sizeof ("OFFLOAD_TARGET_NAMES=") - 1);
7377 obstack_grow (&collect_obstack
, targets
,
7378 strlen (targets
) + 1);
7379 xputenv (XOBFINISH (&collect_obstack
, char *));
7382 free (offload_targets
);
7385 /* Reject switches that no pass was interested in. */
7388 driver::handle_unrecognized_options () const
7390 for (size_t i
= 0; (int) i
< n_switches
; i
++)
7391 if (! switches
[i
].validated
)
7392 error ("unrecognized command line option %<-%s%>", switches
[i
].part1
);
7395 /* Handle the various -print-* options, returning 0 if the driver
7396 should exit, or nonzero if the driver should continue. */
7399 driver::maybe_print_and_exit () const
7401 if (print_search_dirs
)
7403 printf (_("install: %s%s\n"),
7404 gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
7405 gcc_exec_prefix
? "" : machine_suffix
);
7406 printf (_("programs: %s\n"),
7407 build_search_list (&exec_prefixes
, "", false, false));
7408 printf (_("libraries: %s\n"),
7409 build_search_list (&startfile_prefixes
, "", false, true));
7413 if (print_file_name
)
7415 printf ("%s\n", find_file (print_file_name
));
7419 if (print_prog_name
)
7421 if (use_ld
!= NULL
&& ! strcmp (print_prog_name
, "ld"))
7423 /* Append USE_LD to to the default linker. */
7424 #ifdef DEFAULT_LINKER
7426 # ifdef HAVE_HOST_EXECUTABLE_SUFFIX
7427 int len
= (sizeof (DEFAULT_LINKER
)
7428 - sizeof (HOST_EXECUTABLE_SUFFIX
));
7432 char *default_linker
= xstrdup (DEFAULT_LINKER
);
7433 /* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains
7434 HOST_EXECUTABLE_SUFFIX. */
7435 if (! strcmp (&default_linker
[len
], HOST_EXECUTABLE_SUFFIX
))
7437 default_linker
[len
] = '\0';
7438 ld
= concat (default_linker
, use_ld
,
7439 HOST_EXECUTABLE_SUFFIX
, NULL
);
7444 ld
= concat (DEFAULT_LINKER
, use_ld
, NULL
);
7445 if (access (ld
, X_OK
) == 0)
7447 printf ("%s\n", ld
);
7451 print_prog_name
= concat (print_prog_name
, use_ld
, NULL
);
7453 char *newname
= find_a_file (&exec_prefixes
, print_prog_name
, X_OK
, 0);
7454 printf ("%s\n", (newname
? newname
: print_prog_name
));
7458 if (print_multi_lib
)
7460 print_multilib_info ();
7464 if (print_multi_directory
)
7466 if (multilib_dir
== NULL
)
7469 printf ("%s\n", multilib_dir
);
7473 if (print_multiarch
)
7475 if (multiarch_dir
== NULL
)
7478 printf ("%s\n", multiarch_dir
);
7484 if (target_system_root
)
7486 if (target_sysroot_suffix
)
7487 printf ("%s%s\n", target_system_root
, target_sysroot_suffix
);
7489 printf ("%s\n", target_system_root
);
7494 if (print_multi_os_directory
)
7496 if (multilib_os_dir
== NULL
)
7499 printf ("%s\n", multilib_os_dir
);
7503 if (print_sysroot_headers_suffix
)
7505 if (*sysroot_hdrs_suffix_spec
)
7507 printf("%s\n", (target_sysroot_hdrs_suffix
7508 ? target_sysroot_hdrs_suffix
7513 /* The error status indicates that only one set of fixed
7514 headers should be built. */
7515 fatal_error ("not configured with sysroot headers suffix");
7518 if (print_help_list
)
7524 printf (_("\nFor bug reporting instructions, please see:\n"));
7525 printf ("%s.\n", bug_report_url
);
7530 /* We do not exit here. Instead we have created a fake input file
7531 called 'help-dummy' which needs to be compiled, and we pass this
7532 on the various sub-processes, along with the --help switch.
7533 Ensure their output appears after ours. */
7534 fputc ('\n', stdout
);
7540 printf (_("%s %s%s\n"), progname
, pkgversion_string
,
7542 printf ("Copyright %s 2014 Free Software Foundation, Inc.\n",
7544 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
7545 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
7550 /* We do not exit here. We use the same mechanism of --help to print
7551 the version of the sub-processes. */
7552 fputc ('\n', stdout
);
7558 print_configuration (stderr
);
7566 /* Figure out what to do with each input file.
7567 Return true if we need to exit early from "main", false otherwise. */
7570 driver::prepare_infiles ()
7573 int lang_n_infiles
= 0;
7575 if (n_infiles
== added_libraries
)
7576 fatal_error ("no input files");
7579 /* Early exit needed from main. */
7582 /* Make a place to record the compiler output file names
7583 that correspond to the input files. */
7586 i
+= lang_specific_extra_outfiles
;
7587 outfiles
= XCNEWVEC (const char *, i
);
7589 /* Record which files were specified explicitly as link input. */
7591 explicit_link_files
= XCNEWVEC (char, n_infiles
);
7593 combine_inputs
= have_o
|| flag_wpa
;
7595 for (i
= 0; (int) i
< n_infiles
; i
++)
7597 const char *name
= infiles
[i
].name
;
7598 struct compiler
*compiler
= lookup_compiler (name
,
7600 infiles
[i
].language
);
7602 if (compiler
&& !(compiler
->combinable
))
7603 combine_inputs
= false;
7605 if (lang_n_infiles
> 0 && compiler
!= input_file_compiler
7606 && infiles
[i
].language
&& infiles
[i
].language
[0] != '*')
7607 infiles
[i
].incompiler
= compiler
;
7611 input_file_compiler
= compiler
;
7612 infiles
[i
].incompiler
= compiler
;
7616 /* Since there is no compiler for this input file, assume it is a
7618 explicit_link_files
[i
] = 1;
7619 infiles
[i
].incompiler
= NULL
;
7621 infiles
[i
].compiled
= false;
7622 infiles
[i
].preprocessed
= false;
7625 if (!combine_inputs
&& have_c
&& have_o
&& lang_n_infiles
> 1)
7626 fatal_error ("cannot specify -o with -c, -S or -E with multiple files");
7628 /* No early exit needed from main; we can continue. */
7632 /* Run the spec machinery on each input file. */
7635 driver::do_spec_on_infiles () const
7639 for (i
= 0; (int) i
< n_infiles
; i
++)
7641 int this_file_error
= 0;
7643 /* Tell do_spec what to substitute for %i. */
7645 input_file_number
= i
;
7646 set_input (infiles
[i
].name
);
7648 if (infiles
[i
].compiled
)
7651 /* Use the same thing in %o, unless cp->spec says otherwise. */
7653 outfiles
[i
] = gcc_input_filename
;
7655 /* Figure out which compiler from the file's suffix. */
7658 = lookup_compiler (infiles
[i
].name
, input_filename_length
,
7659 infiles
[i
].language
);
7661 if (input_file_compiler
)
7663 /* Ok, we found an applicable compiler. Run its spec. */
7665 if (input_file_compiler
->spec
[0] == '#')
7667 error ("%s: %s compiler not installed on this system",
7668 gcc_input_filename
, &input_file_compiler
->spec
[1]);
7669 this_file_error
= 1;
7677 free (debug_check_temp_file
[0]);
7678 debug_check_temp_file
[0] = NULL
;
7680 free (debug_check_temp_file
[1]);
7681 debug_check_temp_file
[1] = NULL
;
7684 value
= do_spec (input_file_compiler
->spec
);
7685 infiles
[i
].compiled
= true;
7687 this_file_error
= 1;
7688 else if (compare_debug
&& debug_check_temp_file
[0])
7691 inform (0, "recompiling with -fcompare-debug");
7693 compare_debug
= -compare_debug
;
7694 n_switches
= n_switches_debug_check
[1];
7695 n_switches_alloc
= n_switches_alloc_debug_check
[1];
7696 switches
= switches_debug_check
[1];
7698 value
= do_spec (input_file_compiler
->spec
);
7700 compare_debug
= -compare_debug
;
7701 n_switches
= n_switches_debug_check
[0];
7702 n_switches_alloc
= n_switches_alloc_debug_check
[0];
7703 switches
= switches_debug_check
[0];
7707 error ("during -fcompare-debug recompilation");
7708 this_file_error
= 1;
7711 gcc_assert (debug_check_temp_file
[1]
7712 && filename_cmp (debug_check_temp_file
[0],
7713 debug_check_temp_file
[1]));
7716 inform (0, "comparing final insns dumps");
7718 if (compare_files (debug_check_temp_file
))
7719 this_file_error
= 1;
7724 free (debug_check_temp_file
[0]);
7725 debug_check_temp_file
[0] = NULL
;
7727 free (debug_check_temp_file
[1]);
7728 debug_check_temp_file
[1] = NULL
;
7733 /* If this file's name does not contain a recognized suffix,
7734 record it as explicit linker input. */
7737 explicit_link_files
[i
] = 1;
7739 /* Clear the delete-on-failure queue, deleting the files in it
7740 if this compilation failed. */
7742 if (this_file_error
)
7744 delete_failure_queue ();
7747 /* If this compilation succeeded, don't delete those files later. */
7748 clear_failure_queue ();
7751 /* Reset the input file name to the first compile/object file name, for use
7752 with %b in LINK_SPEC. We use the first input file that we can find
7753 a compiler to compile it instead of using infiles.language since for
7754 languages other than C we use aliases that we then lookup later. */
7759 for (i
= 0; i
< n_infiles
; i
++)
7760 if (infiles
[i
].incompiler
7761 || (infiles
[i
].language
&& infiles
[i
].language
[0] != '*'))
7763 set_input (infiles
[i
].name
);
7770 /* Make sure INPUT_FILE_NUMBER points to first available open
7772 input_file_number
= n_infiles
;
7773 if (lang_specific_pre_link ())
7778 /* If we have to run the linker, do it now. */
7781 driver::maybe_run_linker (const char *argv0
) const
7784 int linker_was_run
= 0;
7785 int num_linker_inputs
;
7787 /* Determine if there are any linker input files. */
7788 num_linker_inputs
= 0;
7789 for (i
= 0; (int) i
< n_infiles
; i
++)
7790 if (explicit_link_files
[i
] || outfiles
[i
] != NULL
)
7791 num_linker_inputs
++;
7793 /* Run ld to link all the compiler output files. */
7795 if (num_linker_inputs
> 0 && !seen_error () && print_subprocess_help
< 2)
7797 int tmp
= execution_count
;
7801 #if HAVE_LTO_PLUGIN > 0
7802 #if HAVE_LTO_PLUGIN == 2
7803 const char *fno_use_linker_plugin
= "fno-use-linker-plugin";
7805 const char *fuse_linker_plugin
= "fuse-linker-plugin";
7809 /* We'll use ld if we can't find collect2. */
7810 if (! strcmp (linker_name_spec
, "collect2"))
7812 char *s
= find_a_file (&exec_prefixes
, "collect2", X_OK
, false);
7814 linker_name_spec
= "ld";
7817 #if HAVE_LTO_PLUGIN > 0
7818 #if HAVE_LTO_PLUGIN == 2
7819 if (!switch_matches (fno_use_linker_plugin
,
7820 fno_use_linker_plugin
7821 + strlen (fno_use_linker_plugin
), 0))
7823 if (switch_matches (fuse_linker_plugin
,
7825 + strlen (fuse_linker_plugin
), 0))
7828 char *temp_spec
= find_a_file (&exec_prefixes
,
7829 LTOPLUGINSONAME
, R_OK
,
7832 fatal_error ("-fuse-linker-plugin, but %s not found",
7834 linker_plugin_file_spec
= convert_white_space (temp_spec
);
7837 lto_gcc_spec
= argv0
;
7840 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
7842 putenv_from_prefixes (&exec_prefixes
, "COMPILER_PATH", false);
7843 putenv_from_prefixes (&startfile_prefixes
, LIBRARY_PATH_ENV
, true);
7845 if (print_subprocess_help
== 1)
7847 printf (_("\nLinker options\n==============\n\n"));
7848 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
7849 " to the linker.\n\n"));
7852 int value
= do_spec (link_command_spec
);
7855 linker_was_run
= (tmp
!= execution_count
);
7858 /* If options said don't run linker,
7859 complain about input files to be given to the linker. */
7861 if (! linker_was_run
&& !seen_error ())
7862 for (i
= 0; (int) i
< n_infiles
; i
++)
7863 if (explicit_link_files
[i
]
7864 && !(infiles
[i
].language
&& infiles
[i
].language
[0] == '*'))
7865 warning (0, "%s: linker input file unused because linking not done",
7869 /* The end of "main". */
7872 driver::final_actions () const
7874 /* Delete some or all of the temporary files we made. */
7877 delete_failure_queue ();
7878 delete_temp_files ();
7880 if (print_help_list
)
7882 printf (("\nFor bug reporting instructions, please see:\n"));
7883 printf ("%s\n", bug_report_url
);
7887 /* Determine what the exit code of the driver should be. */
7890 driver::get_exit_code () const
7892 return (signal_count
!= 0 ? 2
7893 : seen_error () ? (pass_exit_codes
? greatest_status
: 1)
7897 /* Find the proper compilation spec for the file name NAME,
7898 whose length is LENGTH. LANGUAGE is the specified language,
7899 or 0 if this file is to be passed to the linker. */
7901 static struct compiler
*
7902 lookup_compiler (const char *name
, size_t length
, const char *language
)
7904 struct compiler
*cp
;
7906 /* If this was specified by the user to be a linker input, indicate that. */
7907 if (language
!= 0 && language
[0] == '*')
7910 /* Otherwise, look for the language, if one is spec'd. */
7913 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
7914 if (cp
->suffix
[0] == '@' && !strcmp (cp
->suffix
+ 1, language
))
7917 error ("language %s not recognized", language
);
7921 /* Look for a suffix. */
7922 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
7924 if (/* The suffix `-' matches only the file name `-'. */
7925 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
7926 || (strlen (cp
->suffix
) < length
7927 /* See if the suffix matches the end of NAME. */
7928 && !strcmp (cp
->suffix
,
7929 name
+ length
- strlen (cp
->suffix
))
7934 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
7935 /* Look again, but case-insensitively this time. */
7937 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
7939 if (/* The suffix `-' matches only the file name `-'. */
7940 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
7941 || (strlen (cp
->suffix
) < length
7942 /* See if the suffix matches the end of NAME. */
7943 && ((!strcmp (cp
->suffix
,
7944 name
+ length
- strlen (cp
->suffix
))
7945 || !strpbrk (cp
->suffix
, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
7946 && !strcasecmp (cp
->suffix
,
7947 name
+ length
- strlen (cp
->suffix
)))
7953 if (cp
>= compilers
)
7955 if (cp
->spec
[0] != '@')
7956 /* A non-alias entry: return it. */
7959 /* An alias entry maps a suffix to a language.
7960 Search for the language; pass 0 for NAME and LENGTH
7961 to avoid infinite recursion if language not found. */
7962 return lookup_compiler (NULL
, 0, cp
->spec
+ 1);
7968 save_string (const char *s
, int len
)
7970 char *result
= XNEWVEC (char, len
+ 1);
7972 memcpy (result
, s
, len
);
7978 pfatal_with_name (const char *name
)
7980 perror_with_name (name
);
7981 delete_temp_files ();
7986 perror_with_name (const char *name
)
7988 error ("%s: %m", name
);
7992 validate_switches_from_spec (const char *spec
, bool user
)
7994 const char *p
= spec
;
7997 if (c
== '%' && (*p
== '{' || *p
== '<' || (*p
== 'W' && *++p
== '{')))
7998 /* We have a switch spec. */
7999 p
= validate_switches (p
+ 1, user
);
8003 validate_all_switches (void)
8005 struct compiler
*comp
;
8006 struct spec_list
*spec
;
8008 for (comp
= compilers
; comp
->spec
; comp
++)
8009 validate_switches_from_spec (comp
->spec
, false);
8011 /* Look through the linked list of specs read from the specs file. */
8012 for (spec
= specs
; spec
; spec
= spec
->next
)
8013 validate_switches_from_spec (*spec
->ptr_spec
, spec
->user_p
);
8015 validate_switches_from_spec (link_command_spec
, false);
8018 /* Look at the switch-name that comes after START
8019 and mark as valid all supplied switches that match it. */
8022 validate_switches (const char *start
, bool user_spec
)
8024 const char *p
= start
;
8028 bool suffix
= false;
8029 bool starred
= false;
8031 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
8040 if (*p
== '.' || *p
== ',')
8044 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
8045 || *p
== ',' || *p
== '.' || *p
== '@')
8050 starred
= true, p
++;
8056 /* Mark all matching switches as valid. */
8057 for (i
= 0; i
< n_switches
; i
++)
8058 if (!strncmp (switches
[i
].part1
, atom
, len
)
8059 && (starred
|| switches
[i
].part1
[len
] == '\0')
8060 && (switches
[i
].known
|| user_spec
))
8061 switches
[i
].validated
= true;
8065 if (*p
&& (p
[-1] == '|' || p
[-1] == '&'))
8068 if (*p
&& p
[-1] == ':')
8070 while (*p
&& *p
!= ';' && *p
!= '}')
8075 if (*p
== '{' || *p
== '<')
8076 p
= validate_switches (p
+1, user_spec
);
8077 else if (p
[0] == 'W' && p
[1] == '{')
8078 p
= validate_switches (p
+2, user_spec
);
8085 if (*p
&& p
[-1] == ';')
8099 static struct mdswitchstr
*mdswitches
;
8100 static int n_mdswitches
;
8102 /* Check whether a particular argument was used. The first time we
8103 canonicalize the switches to keep only the ones we care about. */
8106 used_arg (const char *p
, int len
)
8111 const char *replace
;
8116 static struct mswitchstr
*mswitches
;
8117 static int n_mswitches
;
8122 struct mswitchstr
*matches
;
8126 /* Break multilib_matches into the component strings of string
8127 and replacement string. */
8128 for (q
= multilib_matches
; *q
!= '\0'; q
++)
8133 = (struct mswitchstr
*) alloca ((sizeof (struct mswitchstr
)) * cnt
);
8135 q
= multilib_matches
;
8144 fatal_error ("multilib spec %qs is invalid",
8149 matches
[i
].len
= q
- matches
[i
].str
;
8151 matches
[i
].replace
= ++q
;
8152 while (*q
!= ';' && *q
!= '\0')
8155 goto invalid_matches
;
8158 matches
[i
].rep_len
= q
- matches
[i
].replace
;
8164 /* Now build a list of the replacement string for switches that we care
8165 about. Make sure we allocate at least one entry. This prevents
8166 xmalloc from calling fatal, and prevents us from re-executing this
8169 = XNEWVEC (struct mswitchstr
, n_mdswitches
+ (n_switches
? n_switches
: 1));
8170 for (i
= 0; i
< n_switches
; i
++)
8171 if ((switches
[i
].live_cond
& SWITCH_IGNORE
) == 0)
8173 int xlen
= strlen (switches
[i
].part1
);
8174 for (j
= 0; j
< cnt
; j
++)
8175 if (xlen
== matches
[j
].len
8176 && ! strncmp (switches
[i
].part1
, matches
[j
].str
, xlen
))
8178 mswitches
[n_mswitches
].str
= matches
[j
].replace
;
8179 mswitches
[n_mswitches
].len
= matches
[j
].rep_len
;
8180 mswitches
[n_mswitches
].replace
= (char *) 0;
8181 mswitches
[n_mswitches
].rep_len
= 0;
8187 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
8188 on the command line nor any options mutually incompatible with
8190 for (i
= 0; i
< n_mdswitches
; i
++)
8194 for (q
= multilib_options
; *q
!= '\0'; *q
&& q
++)
8200 while (strncmp (q
, mdswitches
[i
].str
, mdswitches
[i
].len
) != 0
8201 || strchr (" /", q
[mdswitches
[i
].len
]) == NULL
)
8203 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
8210 if (*q
!= ' ' && *q
!= '\0')
8212 while (*r
!= ' ' && *r
!= '\0')
8215 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
8218 if (used_arg (r
, q
- r
))
8223 mswitches
[n_mswitches
].str
= mdswitches
[i
].str
;
8224 mswitches
[n_mswitches
].len
= mdswitches
[i
].len
;
8225 mswitches
[n_mswitches
].replace
= (char *) 0;
8226 mswitches
[n_mswitches
].rep_len
= 0;
8239 for (i
= 0; i
< n_mswitches
; i
++)
8240 if (len
== mswitches
[i
].len
&& ! strncmp (p
, mswitches
[i
].str
, len
))
8247 default_arg (const char *p
, int len
)
8251 for (i
= 0; i
< n_mdswitches
; i
++)
8252 if (len
== mdswitches
[i
].len
&& ! strncmp (p
, mdswitches
[i
].str
, len
))
8258 /* Work out the subdirectory to use based on the options. The format of
8259 multilib_select is a list of elements. Each element is a subdirectory
8260 name followed by a list of options followed by a semicolon. The format
8261 of multilib_exclusions is the same, but without the preceding
8262 directory. First gcc will check the exclusions, if none of the options
8263 beginning with an exclamation point are present, and all of the other
8264 options are present, then we will ignore this completely. Passing
8265 that, gcc will consider each multilib_select in turn using the same
8266 rules for matching the options. If a match is found, that subdirectory
8268 A subdirectory name is optionally followed by a colon and the corresponding
8272 set_multilib_dir (void)
8275 unsigned int this_path_len
;
8276 const char *this_path
, *this_arg
;
8277 const char *start
, *end
;
8279 int ok
, ndfltok
, first
;
8282 start
= multilib_defaults
;
8283 while (*start
== ' ' || *start
== '\t')
8285 while (*start
!= '\0')
8288 while (*start
!= ' ' && *start
!= '\t' && *start
!= '\0')
8290 while (*start
== ' ' || *start
== '\t')
8298 mdswitches
= XNEWVEC (struct mdswitchstr
, n_mdswitches
);
8299 for (start
= multilib_defaults
; *start
!= '\0'; start
= end
+ 1)
8301 while (*start
== ' ' || *start
== '\t')
8307 for (end
= start
+ 1;
8308 *end
!= ' ' && *end
!= '\t' && *end
!= '\0'; end
++)
8311 obstack_grow (&multilib_obstack
, start
, end
- start
);
8312 obstack_1grow (&multilib_obstack
, 0);
8313 mdswitches
[i
].str
= XOBFINISH (&multilib_obstack
, const char *);
8314 mdswitches
[i
++].len
= end
- start
;
8321 p
= multilib_exclusions
;
8324 /* Ignore newlines. */
8331 /* Check the arguments. */
8338 fatal_error ("multilib exclusions %qs is invalid",
8339 multilib_exclusions
);
8349 while (*p
!= ' ' && *p
!= ';')
8352 goto invalid_exclusions
;
8356 if (*this_arg
!= '!')
8364 ok
= used_arg (this_arg
, p
- this_arg
);
8379 p
= multilib_select
;
8381 /* Append multilib reuse rules if any. With those rules, we can reuse
8382 one multilib for certain different options sets. */
8383 if (strlen (multilib_reuse
) > 0)
8384 p
= concat (p
, multilib_reuse
, NULL
);
8388 /* Ignore newlines. */
8395 /* Get the initial path. */
8402 fatal_error ("multilib select %qs %qs is invalid",
8403 multilib_select
, multilib_reuse
);
8407 this_path_len
= p
- this_path
;
8409 /* Check the arguments. */
8416 goto invalid_select
;
8425 while (*p
!= ' ' && *p
!= ';')
8428 goto invalid_select
;
8432 if (*this_arg
!= '!')
8440 /* If this is a default argument, we can just ignore it.
8441 This is true even if this_arg begins with '!'. Beginning
8442 with '!' does not mean that this argument is necessarily
8443 inappropriate for this library: it merely means that
8444 there is a more specific library which uses this
8445 argument. If this argument is a default, we need not
8446 consider that more specific library. */
8447 ok
= used_arg (this_arg
, p
- this_arg
);
8454 if (default_arg (this_arg
, p
- this_arg
))
8463 if (this_path_len
!= 1
8464 || this_path
[0] != '.')
8466 char *new_multilib_dir
= XNEWVEC (char, this_path_len
+ 1);
8469 strncpy (new_multilib_dir
, this_path
, this_path_len
);
8470 new_multilib_dir
[this_path_len
] = '\0';
8471 q
= strchr (new_multilib_dir
, ':');
8474 multilib_dir
= new_multilib_dir
;
8481 const char *q
= this_path
, *end
= this_path
+ this_path_len
;
8483 while (q
< end
&& *q
!= ':')
8487 const char *q2
= q
+ 1, *ml_end
= end
;
8488 char *new_multilib_os_dir
;
8490 while (q2
< end
&& *q2
!= ':')
8494 if (ml_end
- q
== 1)
8495 multilib_os_dir
= xstrdup (".");
8498 new_multilib_os_dir
= XNEWVEC (char, ml_end
- q
);
8499 memcpy (new_multilib_os_dir
, q
+ 1, ml_end
- q
- 1);
8500 new_multilib_os_dir
[ml_end
- q
- 1] = '\0';
8501 multilib_os_dir
= new_multilib_os_dir
;
8504 if (q2
< end
&& *q2
== ':')
8506 char *new_multiarch_dir
= XNEWVEC (char, end
- q2
);
8507 memcpy (new_multiarch_dir
, q2
+ 1, end
- q2
- 1);
8508 new_multiarch_dir
[end
- q2
- 1] = '\0';
8509 multiarch_dir
= new_multiarch_dir
;
8518 if (multilib_dir
== NULL
&& multilib_os_dir
!= NULL
8519 && strcmp (multilib_os_dir
, ".") == 0)
8521 free (CONST_CAST (char *, multilib_os_dir
));
8522 multilib_os_dir
= NULL
;
8524 else if (multilib_dir
!= NULL
&& multilib_os_dir
== NULL
)
8525 multilib_os_dir
= multilib_dir
;
8528 /* Print out the multiple library subdirectory selection
8529 information. This prints out a series of lines. Each line looks
8530 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
8531 required. Only the desired options are printed out, the negative
8532 matches. The options are print without a leading dash. There are
8533 no spaces to make it easy to use the information in the shell.
8534 Each subdirectory is printed only once. This assumes the ordering
8535 generated by the genmultilib script. Also, we leave out ones that match
8539 print_multilib_info (void)
8541 const char *p
= multilib_select
;
8542 const char *last_path
= 0, *this_path
;
8544 unsigned int last_path_len
= 0;
8549 /* Ignore newlines. */
8556 /* Get the initial path. */
8563 fatal_error ("multilib select %qs is invalid", multilib_select
);
8569 /* When --disable-multilib was used but target defines
8570 MULTILIB_OSDIRNAMES, entries starting with .: (and not starting
8571 with .:: for multiarch configurations) are there just to find
8572 multilib_os_dir, so skip them from output. */
8573 if (this_path
[0] == '.' && this_path
[1] == ':' && this_path
[2] != ':')
8576 /* Check for matches with the multilib_exclusions. We don't bother
8577 with the '!' in either list. If any of the exclusion rules match
8578 all of its options with the select rule, we skip it. */
8580 const char *e
= multilib_exclusions
;
8581 const char *this_arg
;
8586 /* Ignore newlines. */
8593 /* Check the arguments. */
8602 fatal_error ("multilib exclusion %qs is invalid",
8603 multilib_exclusions
);
8614 while (*e
!= ' ' && *e
!= ';')
8617 goto invalid_exclusion
;
8625 int len
= e
- this_arg
;
8628 goto invalid_select
;
8632 while (*q
!= ' ' && *q
!= ';')
8635 goto invalid_select
;
8639 if (! strncmp (arg
, this_arg
,
8640 (len
< q
- arg
) ? q
- arg
: len
)
8641 || default_arg (this_arg
, e
- this_arg
))
8671 /* If this is a duplicate, skip it. */
8672 skip
= (last_path
!= 0
8673 && (unsigned int) (p
- this_path
) == last_path_len
8674 && ! filename_ncmp (last_path
, this_path
, last_path_len
));
8676 last_path
= this_path
;
8677 last_path_len
= p
- this_path
;
8680 /* If this directory requires any default arguments, we can skip
8681 it. We will already have printed a directory identical to
8682 this one which does not require that default argument. */
8693 goto invalid_select
;
8700 while (*q
!= ' ' && *q
!= ';')
8703 goto invalid_select
;
8708 && default_arg (arg
, q
- arg
))
8723 for (p1
= last_path
; p1
< p
&& *p1
!= ':'; p1
++)
8734 goto invalid_select
;
8742 use_arg
= *p
!= '!';
8747 while (*p
!= ' ' && *p
!= ';')
8750 goto invalid_select
;
8762 /* If there are extra options, print them now. */
8763 if (multilib_extra
&& *multilib_extra
)
8765 int print_at
= TRUE
;
8768 for (q
= multilib_extra
; *q
!= '\0'; q
++)
8789 /* getenv built-in spec function.
8791 Returns the value of the environment variable given by its first
8792 argument, concatenated with the second argument. If the
8793 environment variable is not defined, a fatal error is issued. */
8796 getenv_spec_function (int argc
, const char **argv
)
8806 value
= getenv (argv
[0]);
8808 fatal_error ("environment variable %qs not defined", argv
[0]);
8810 /* We have to escape every character of the environment variable so
8811 they are not interpreted as active spec characters. A
8812 particularly painful case is when we are reading a variable
8813 holding a windows path complete with \ separators. */
8814 len
= strlen (value
) * 2 + strlen (argv
[1]) + 1;
8815 result
= XNEWVAR (char, len
);
8816 for (ptr
= result
; *value
; ptr
+= 2)
8822 strcpy (ptr
, argv
[1]);
8827 /* if-exists built-in spec function.
8829 Checks to see if the file specified by the absolute pathname in
8830 ARGS exists. Returns that pathname if found.
8832 The usual use for this function is to check for a library file
8833 (whose name has been expanded with %s). */
8836 if_exists_spec_function (int argc
, const char **argv
)
8838 /* Must have only one argument. */
8839 if (argc
== 1 && IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
8845 /* if-exists-else built-in spec function.
8847 This is like if-exists, but takes an additional argument which
8848 is returned if the first argument does not exist. */
8851 if_exists_else_spec_function (int argc
, const char **argv
)
8853 /* Must have exactly two arguments. */
8857 if (IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
8863 /* sanitize built-in spec function.
8865 This returns non-NULL, if sanitizing address, thread or
8866 any of the undefined behavior sanitizers. */
8869 sanitize_spec_function (int argc
, const char **argv
)
8874 if (strcmp (argv
[0], "address") == 0)
8875 return (flag_sanitize
& SANITIZE_USER_ADDRESS
) ? "" : NULL
;
8876 if (strcmp (argv
[0], "kernel-address") == 0)
8877 return (flag_sanitize
& SANITIZE_KERNEL_ADDRESS
) ? "" : NULL
;
8878 if (strcmp (argv
[0], "thread") == 0)
8879 return (flag_sanitize
& SANITIZE_THREAD
) ? "" : NULL
;
8880 if (strcmp (argv
[0], "undefined") == 0)
8881 return ((flag_sanitize
& (SANITIZE_UNDEFINED
| SANITIZE_NONDEFAULT
))
8882 && !flag_sanitize_undefined_trap_on_error
) ? "" : NULL
;
8883 if (strcmp (argv
[0], "leak") == 0)
8884 return ((flag_sanitize
8885 & (SANITIZE_ADDRESS
| SANITIZE_LEAK
| SANITIZE_THREAD
))
8886 == SANITIZE_LEAK
) ? "" : NULL
;
8890 /* replace-outfile built-in spec function.
8892 This looks for the first argument in the outfiles array's name and
8893 replaces it with the second argument. */
8896 replace_outfile_spec_function (int argc
, const char **argv
)
8899 /* Must have exactly two arguments. */
8903 for (i
= 0; i
< n_infiles
; i
++)
8905 if (outfiles
[i
] && !filename_cmp (outfiles
[i
], argv
[0]))
8906 outfiles
[i
] = xstrdup (argv
[1]);
8911 /* remove-outfile built-in spec function.
8913 * This looks for the first argument in the outfiles array's name and
8917 remove_outfile_spec_function (int argc
, const char **argv
)
8920 /* Must have exactly one argument. */
8924 for (i
= 0; i
< n_infiles
; i
++)
8926 if (outfiles
[i
] && !filename_cmp (outfiles
[i
], argv
[0]))
8932 /* Given two version numbers, compares the two numbers.
8933 A version number must match the regular expression
8934 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
8937 compare_version_strings (const char *v1
, const char *v2
)
8942 if (regcomp (&r
, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
8943 REG_EXTENDED
| REG_NOSUB
) != 0)
8945 rresult
= regexec (&r
, v1
, 0, NULL
, 0);
8946 if (rresult
== REG_NOMATCH
)
8947 fatal_error ("invalid version number %qs", v1
);
8948 else if (rresult
!= 0)
8950 rresult
= regexec (&r
, v2
, 0, NULL
, 0);
8951 if (rresult
== REG_NOMATCH
)
8952 fatal_error ("invalid version number %qs", v2
);
8953 else if (rresult
!= 0)
8956 return strverscmp (v1
, v2
);
8960 /* version_compare built-in spec function.
8962 This takes an argument of the following form:
8964 <comparison-op> <arg1> [<arg2>] <switch> <result>
8966 and produces "result" if the comparison evaluates to true,
8967 and nothing if it doesn't.
8969 The supported <comparison-op> values are:
8971 >= true if switch is a later (or same) version than arg1
8973 < true if switch is an earlier version than arg1
8975 >< true if switch is arg1 or later, and earlier than arg2
8976 <> true if switch is earlier than arg1 or is arg2 or later
8978 If the switch is not present, the condition is false unless
8979 the first character of the <comparison-op> is '!'.
8982 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
8983 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
8986 version_compare_spec_function (int argc
, const char **argv
)
8990 const char *switch_value
= NULL
;
8995 fatal_error ("too few arguments to %%:version-compare");
8996 if (argv
[0][0] == '\0')
8998 if ((argv
[0][1] == '<' || argv
[0][1] == '>') && argv
[0][0] != '!')
9000 if (argc
!= nargs
+ 3)
9001 fatal_error ("too many arguments to %%:version-compare");
9003 switch_len
= strlen (argv
[nargs
+ 1]);
9004 for (i
= 0; i
< n_switches
; i
++)
9005 if (!strncmp (switches
[i
].part1
, argv
[nargs
+ 1], switch_len
)
9006 && check_live_switch (i
, switch_len
))
9007 switch_value
= switches
[i
].part1
+ switch_len
;
9009 if (switch_value
== NULL
)
9013 comp1
= compare_version_strings (switch_value
, argv
[1]);
9015 comp2
= compare_version_strings (switch_value
, argv
[2]);
9017 comp2
= -1; /* This value unused. */
9020 switch (argv
[0][0] << 8 | argv
[0][1])
9022 case '>' << 8 | '=':
9023 result
= comp1
>= 0;
9025 case '!' << 8 | '<':
9026 result
= comp1
>= 0 || switch_value
== NULL
;
9031 case '!' << 8 | '>':
9032 result
= comp1
< 0 || switch_value
== NULL
;
9034 case '>' << 8 | '<':
9035 result
= comp1
>= 0 && comp2
< 0;
9037 case '<' << 8 | '>':
9038 result
= comp1
< 0 || comp2
>= 0;
9042 fatal_error ("unknown operator %qs in %%:version-compare", argv
[0]);
9047 return argv
[nargs
+ 2];
9050 /* %:include builtin spec function. This differs from %include in that it
9051 can be nested inside a spec, and thus be conditionalized. It takes
9052 one argument, the filename, and looks for it in the startfile path.
9053 The result is always NULL, i.e. an empty expansion. */
9056 include_spec_function (int argc
, const char **argv
)
9063 file
= find_a_file (&startfile_prefixes
, argv
[0], R_OK
, true);
9064 read_specs (file
? file
: argv
[0], false, false);
9069 /* %:find-file spec function. This function replaces its argument by
9070 the file found through find_file, that is the -print-file-name gcc
9073 find_file_spec_function (int argc
, const char **argv
)
9080 file
= find_file (argv
[0]);
9085 /* %:find-plugindir spec function. This function replaces its argument
9086 by the -iplugindir=<dir> option. `dir' is found through find_file, that
9087 is the -print-file-name gcc program option. */
9089 find_plugindir_spec_function (int argc
, const char **argv ATTRIBUTE_UNUSED
)
9096 option
= concat ("-iplugindir=", find_file ("plugin"), NULL
);
9101 /* %:print-asm-header spec function. Print a banner to say that the
9102 following output is from the assembler. */
9105 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED
,
9106 const char **argv ATTRIBUTE_UNUSED
)
9108 printf (_("Assembler options\n=================\n\n"));
9109 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
9114 /* Get a random number for -frandom-seed */
9116 static unsigned HOST_WIDE_INT
9117 get_random_number (void)
9119 unsigned HOST_WIDE_INT ret
= 0;
9122 fd
= open ("/dev/urandom", O_RDONLY
);
9125 read (fd
, &ret
, sizeof (HOST_WIDE_INT
));
9131 /* Get some more or less random data. */
9132 #ifdef HAVE_GETTIMEOFDAY
9136 gettimeofday (&tv
, NULL
);
9137 ret
= tv
.tv_sec
* 1000 + tv
.tv_usec
/ 1000;
9141 time_t now
= time (NULL
);
9143 if (now
!= (time_t)-1)
9144 ret
= (unsigned) now
;
9148 return ret
^ getpid ();
9151 /* %:compare-debug-dump-opt spec function. Save the last argument,
9152 expected to be the last -fdump-final-insns option, or generate a
9156 compare_debug_dump_opt_spec_function (int arg
,
9157 const char **argv ATTRIBUTE_UNUSED
)
9162 static char random_seed
[HOST_BITS_PER_WIDE_INT
/ 4 + 3];
9165 fatal_error ("too many arguments to %%:compare-debug-dump-opt");
9167 do_spec_2 ("%{fdump-final-insns=*:%*}");
9168 do_spec_1 (" ", 0, NULL
);
9170 if (argbuf
.length () > 0
9171 && strcmp (argv
[argbuf
.length () - 1], "."))
9176 name
= xstrdup (argv
[argbuf
.length () - 1]);
9181 const char *ext
= NULL
;
9183 if (argbuf
.length () > 0)
9185 do_spec_2 ("%{o*:%*}%{!o:%{!S:%b%O}%{S:%b.s}}");
9188 else if (!compare_debug
)
9191 do_spec_2 ("%g.gkd");
9193 do_spec_1 (" ", 0, NULL
);
9195 gcc_assert (argbuf
.length () > 0);
9197 name
= concat (argbuf
.last (), ext
, NULL
);
9199 ret
= concat ("-fdump-final-insns=", name
, NULL
);
9202 which
= compare_debug
< 0;
9203 debug_check_temp_file
[which
] = name
;
9207 unsigned HOST_WIDE_INT value
= get_random_number ();
9209 sprintf (random_seed
, HOST_WIDE_INT_PRINT_HEX
, value
);
9215 ret
= concat ("%{!frandom-seed=*:-frandom-seed=", random_seed
, "} ",
9226 static const char *debug_auxbase_opt
;
9228 /* %:compare-debug-self-opt spec function. Expands to the options
9229 that are to be passed in the second compilation of
9233 compare_debug_self_opt_spec_function (int arg
,
9234 const char **argv ATTRIBUTE_UNUSED
)
9237 fatal_error ("too many arguments to %%:compare-debug-self-opt");
9239 if (compare_debug
>= 0)
9242 do_spec_2 ("%{c|S:%{o*:%*}}");
9243 do_spec_1 (" ", 0, NULL
);
9245 if (argbuf
.length () > 0)
9246 debug_auxbase_opt
= concat ("-auxbase-strip ",
9250 debug_auxbase_opt
= NULL
;
9253 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
9254 %<fdump-final-insns=* -w -S -o %j \
9255 %{!fcompare-debug-second:-fcompare-debug-second} \
9256 ", compare_debug_opt
, NULL
);
9259 /* %:compare-debug-auxbase-opt spec function. Expands to the auxbase
9260 options that are to be passed in the second compilation of
9261 compare-debug. It expects, as an argument, the basename of the
9262 current input file name, with the .gk suffix appended to it. */
9265 compare_debug_auxbase_opt_spec_function (int arg
,
9272 fatal_error ("too few arguments to %%:compare-debug-auxbase-opt");
9275 fatal_error ("too many arguments to %%:compare-debug-auxbase-opt");
9277 if (compare_debug
>= 0)
9280 len
= strlen (argv
[0]);
9281 if (len
< 3 || strcmp (argv
[0] + len
- 3, ".gk") != 0)
9282 fatal_error ("argument to %%:compare-debug-auxbase-opt "
9283 "does not end in .gk");
9285 if (debug_auxbase_opt
)
9286 return debug_auxbase_opt
;
9288 #define OPT "-auxbase "
9291 name
= (char*) xmalloc (sizeof (OPT
) + len
);
9292 memcpy (name
, OPT
, sizeof (OPT
) - 1);
9293 memcpy (name
+ sizeof (OPT
) - 1, argv
[0], len
);
9294 name
[sizeof (OPT
) - 1 + len
] = '\0';
9301 /* %:pass-through-libs spec function. Finds all -l options and input
9302 file names in the lib spec passed to it, and makes a list of them
9303 prepended with the plugin option to cause them to be passed through
9304 to the final link after all the new object files have been added. */
9307 pass_through_libs_spec_func (int argc
, const char **argv
)
9309 char *prepended
= xstrdup (" ");
9311 /* Shlemiel the painter's algorithm. Innately horrible, but at least
9312 we know that there will never be more than a handful of strings to
9313 concat, and it's only once per run, so it's not worth optimising. */
9314 for (n
= 0; n
< argc
; n
++)
9316 char *old
= prepended
;
9317 /* Anything that isn't an option is a full path to an output
9318 file; pass it through if it ends in '.a'. Among options,
9320 if (argv
[n
][0] == '-' && argv
[n
][1] == 'l')
9322 const char *lopt
= argv
[n
] + 2;
9323 /* Handle both joined and non-joined -l options. If for any
9324 reason there's a trailing -l with no joined or following
9325 arg just discard it. */
9326 if (!*lopt
&& ++n
>= argc
)
9330 prepended
= concat (prepended
, "-plugin-opt=-pass-through=-l",
9333 else if (!strcmp (".a", argv
[n
] + strlen (argv
[n
]) - 2))
9335 prepended
= concat (prepended
, "-plugin-opt=-pass-through=",
9336 argv
[n
], " ", NULL
);
9338 if (prepended
!= old
)
9344 /* %:replace-extension spec function. Replaces the extension of the
9345 first argument with the second argument. */
9348 replace_extension_spec_func (int argc
, const char **argv
)
9356 fatal_error ("too few arguments to %%:replace-extension");
9358 name
= xstrdup (argv
[0]);
9360 for (i
= strlen (name
) - 1; i
>= 0; i
--)
9361 if (IS_DIR_SEPARATOR (name
[i
]))
9364 p
= strrchr (name
+ i
+ 1, '.');
9368 result
= concat (name
, argv
[1], NULL
);
9374 /* Insert backslash before spaces in ORIG (usually a file path), to
9375 avoid being broken by spec parser.
9377 This function is needed as do_spec_1 treats white space (' ' and '\t')
9378 as the end of an argument. But in case of -plugin /usr/gcc install/xxx.so,
9379 the file name should be treated as a single argument rather than being
9380 broken into multiple. Solution is to insert '\\' before the space in a
9383 This function converts and only converts all occurrence of ' '
9384 to '\\' + ' ' and '\t' to '\\' + '\t'. For example:
9388 "a\\ b" -> "a\\\\ b"
9390 orig: input null-terminating string that was allocated by xalloc. The
9391 memory it points to might be freed in this function. Behavior undefined
9392 if ORIG wasn't xalloced or was freed already at entry.
9394 Return: ORIG if no conversion needed. Otherwise a newly allocated string
9395 that was converted from ORIG. */
9398 convert_white_space (char *orig
)
9400 int len
, number_of_space
= 0;
9402 for (len
= 0; orig
[len
]; len
++)
9403 if (orig
[len
] == ' ' || orig
[len
] == '\t') number_of_space
++;
9405 if (number_of_space
)
9407 char *new_spec
= (char *) xmalloc (len
+ number_of_space
+ 1);
9409 for (j
= 0, k
= 0; j
<= len
; j
++, k
++)
9411 if (orig
[j
] == ' ' || orig
[j
] == '\t')
9412 new_spec
[k
++] = '\\';
9413 new_spec
[k
] = orig
[j
];