1 /* Compiler driver program that can handle many languages.
2 Copyright (C) 1987-2022 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". */
30 #define INCLUDE_STRING
33 #include "coretypes.h"
34 #include "multilib.h" /* before tm.h */
40 #include "opt-suggestions.h"
42 #include "diagnostic.h"
45 #include "filenames.h"
46 #include "spellcheck.h"
47 #include "opts-jobserver.h"
48 #include "common/common-target.h"
52 /* Manage the manipulation of env vars.
54 We poison "getenv" and "putenv", so that all enviroment-handling is
55 done through this class. Note that poisoning happens in the
56 preprocessor at the identifier level, and doesn't distinguish between
60 Hence we need to use "get" for the accessor method, not "getenv". */
65 void init (bool can_restore
, bool debug
);
66 const char *get (const char *name
);
67 void xput (const char *string
);
82 /* The singleton instance of class env_manager. */
84 static env_manager env
;
86 /* Initializer for class env_manager.
88 We can't do this as a constructor since we have a statically
89 allocated instance ("env" above). */
92 env_manager::init (bool can_restore
, bool debug
)
94 m_can_restore
= can_restore
;
98 /* Get the value of NAME within the environment. Essentially
99 a wrapper for ::getenv, but adding logging, and the possibility
100 of caching results. */
103 env_manager::get (const char *name
)
105 const char *result
= ::getenv (name
);
107 fprintf (stderr
, "env_manager::getenv (%s) -> %s\n", name
, result
);
111 /* Put the given KEY=VALUE entry STRING into the environment.
112 If the env_manager was initialized with CAN_RESTORE set, then
113 also record the old value of KEY within the environment, so that it
114 can be later restored. */
117 env_manager::xput (const char *string
)
120 fprintf (stderr
, "env_manager::xput (%s)\n", string
);
122 fnotice (stderr
, "%s\n", string
);
126 char *equals
= strchr (const_cast <char *> (string
), '=');
130 kv
.m_key
= xstrndup (string
, equals
- string
);
131 const char *cur_value
= ::getenv (kv
.m_key
);
133 fprintf (stderr
, "saving old value: %s\n",cur_value
);
134 kv
.m_value
= cur_value
? xstrdup (cur_value
) : NULL
;
135 m_keys
.safe_push (kv
);
138 ::putenv (CONST_CAST (char *, string
));
141 /* Undo any xputenv changes made since last restore.
142 Can only be called if the env_manager was initialized with
143 CAN_RESTORE enabled. */
146 env_manager::restore ()
151 gcc_assert (m_can_restore
);
153 FOR_EACH_VEC_ELT_REVERSE (m_keys
, i
, item
)
156 printf ("restoring saved key: %s value: %s\n", item
->m_key
, item
->m_value
);
158 ::setenv (item
->m_key
, item
->m_value
, 1);
160 ::unsetenv (item
->m_key
);
162 free (item
->m_value
);
168 /* Forbid other uses of getenv and putenv. */
169 #if (GCC_VERSION >= 3000)
170 #pragma GCC poison getenv putenv
175 /* By default there is no special suffix for target executables. */
176 #ifdef TARGET_EXECUTABLE_SUFFIX
177 #define HAVE_TARGET_EXECUTABLE_SUFFIX
179 #define TARGET_EXECUTABLE_SUFFIX ""
182 /* By default there is no special suffix for host executables. */
183 #ifdef HOST_EXECUTABLE_SUFFIX
184 #define HAVE_HOST_EXECUTABLE_SUFFIX
186 #define HOST_EXECUTABLE_SUFFIX ""
189 /* By default, the suffix for target object files is ".o". */
190 #ifdef TARGET_OBJECT_SUFFIX
191 #define HAVE_TARGET_OBJECT_SUFFIX
193 #define TARGET_OBJECT_SUFFIX ".o"
196 static const char dir_separator_str
[] = { DIR_SEPARATOR
, 0 };
198 /* Most every one is fine with LIBRARY_PATH. For some, it conflicts. */
199 #ifndef LIBRARY_PATH_ENV
200 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
203 /* If a stage of compilation returns an exit status >= 1,
204 compilation of that file ceases. */
206 #define MIN_FATAL_STATUS 1
208 /* Flag set by cppspec.cc to 1. */
211 /* Flag set to nonzero if an @file argument has been supplied to gcc. */
212 static bool at_file_supplied
;
214 /* Definition of string containing the arguments given to configure. */
215 #include "configargs.h"
217 /* Flag saying to print the command line options understood by gcc and its
220 static int print_help_list
;
222 /* Flag saying to print the version of gcc and its sub-processes. */
224 static int print_version
;
226 /* Flag that stores string prefix for which we provide bash completion. */
228 static const char *completion
= NULL
;
230 /* Flag indicating whether we should ONLY print the command and
231 arguments (like verbose_flag) without executing the command.
232 Displayed arguments are quoted so that the generated command
233 line is suitable for execution. This is intended for use in
234 shell scripts to capture the driver-generated command line. */
235 static int verbose_only_flag
;
237 /* Flag indicating how to print command line options of sub-processes. */
239 static int print_subprocess_help
;
241 /* Linker suffix passed to -fuse-ld=... */
242 static const char *use_ld
;
244 /* Whether we should report subprocess execution times to a file. */
246 FILE *report_times_to_file
= NULL
;
248 /* Nonzero means place this string before uses of /, so that include
249 and library files can be found in an alternate location. */
251 #ifdef TARGET_SYSTEM_ROOT
252 #define DEFAULT_TARGET_SYSTEM_ROOT (TARGET_SYSTEM_ROOT)
254 #define DEFAULT_TARGET_SYSTEM_ROOT (0)
256 static const char *target_system_root
= DEFAULT_TARGET_SYSTEM_ROOT
;
258 /* Nonzero means pass the updated target_system_root to the compiler. */
260 static int target_system_root_changed
;
262 /* Nonzero means append this string to target_system_root. */
264 static const char *target_sysroot_suffix
= 0;
266 /* Nonzero means append this string to target_system_root for headers. */
268 static const char *target_sysroot_hdrs_suffix
= 0;
270 /* Nonzero means write "temp" files in source directory
271 and use the source file's name in them, and don't delete them. */
273 static enum save_temps
{
274 SAVE_TEMPS_NONE
, /* no -save-temps */
275 SAVE_TEMPS_CWD
, /* -save-temps in current directory */
276 SAVE_TEMPS_DUMP
, /* -save-temps in dumpdir */
277 SAVE_TEMPS_OBJ
/* -save-temps in object directory */
280 /* Set this iff the dumppfx implied by a -save-temps=* option is to
281 override a -dumpdir option, if any. */
282 static bool save_temps_overrides_dumpdir
= false;
284 /* -dumpdir, -dumpbase and -dumpbase-ext flags passed in, possibly
285 rearranged as they are to be passed down, e.g., dumpbase and
286 dumpbase_ext may be cleared if integrated with dumpdir or
288 static char *dumpdir
, *dumpbase
, *dumpbase_ext
;
290 /* Usually the length of the string in dumpdir. However, during
291 linking, it may be shortened to omit a driver-added trailing dash,
292 by then replaced with a trailing period, that is still to be passed
293 to sub-processes in -dumpdir, but not to be generally used in spec
294 filename expansions. See maybe_run_linker. */
295 static size_t dumpdir_length
= 0;
297 /* Set if the last character in dumpdir is (or was) a dash that the
298 driver added to dumpdir after dumpbase or linker output name. */
299 static bool dumpdir_trailing_dash_added
= false;
301 /* Basename of dump and aux outputs, computed from dumpbase (given or
302 derived from output name), to override input_basename in non-%w %b
304 static char *outbase
;
305 static size_t outbase_length
= 0;
307 /* The compiler version. */
309 static const char *compiler_version
;
311 /* The target version. */
313 static const char *const spec_version
= DEFAULT_TARGET_VERSION
;
315 /* The target machine. */
317 static const char *spec_machine
= DEFAULT_TARGET_MACHINE
;
318 static const char *spec_host_machine
= DEFAULT_REAL_TARGET_MACHINE
;
320 /* List of offload targets. Separated by colon. Empty string for
321 -foffload=disable. */
323 static char *offload_targets
= NULL
;
325 #if OFFLOAD_DEFAULTED
326 /* Set to true if -foffload has not been used and offload_targets
327 is set to the configured in default. */
328 static bool offload_targets_default
;
331 /* Nonzero if cross-compiling.
332 When -b is used, the value comes from the `specs' file. */
334 #ifdef CROSS_DIRECTORY_STRUCTURE
335 static const char *cross_compile
= "1";
337 static const char *cross_compile
= "0";
340 /* Greatest exit code of sub-processes that has been encountered up to
342 static int greatest_status
= 1;
344 /* This is the obstack which we use to allocate many strings. */
346 static struct obstack obstack
;
348 /* This is the obstack to build an environment variable to pass to
349 collect2 that describes all of the relevant switches of what to
350 pass the compiler in building the list of pointers to constructors
353 static struct obstack collect_obstack
;
355 /* Forward declaration for prototypes. */
359 static void init_spec (void);
360 static void store_arg (const char *, int, int);
361 static void insert_wrapper (const char *);
362 static char *load_specs (const char *);
363 static void read_specs (const char *, bool, bool);
364 static void set_spec (const char *, const char *, bool);
365 static struct compiler
*lookup_compiler (const char *, size_t, const char *);
366 static char *build_search_list (const struct path_prefix
*, const char *,
368 static void xputenv (const char *);
369 static void putenv_from_prefixes (const struct path_prefix
*, const char *,
371 static int access_check (const char *, int);
372 static char *find_a_file (const struct path_prefix
*, const char *, int, bool);
373 static char *find_a_program (const char *);
374 static void add_prefix (struct path_prefix
*, const char *, const char *,
376 static void add_sysrooted_prefix (struct path_prefix
*, const char *,
377 const char *, int, int, int);
378 static char *skip_whitespace (char *);
379 static void delete_if_ordinary (const char *);
380 static void delete_temp_files (void);
381 static void delete_failure_queue (void);
382 static void clear_failure_queue (void);
383 static int check_live_switch (int, int);
384 static const char *handle_braces (const char *);
385 static inline bool input_suffix_matches (const char *, const char *);
386 static inline bool switch_matches (const char *, const char *, int);
387 static inline void mark_matching_switches (const char *, const char *, int);
388 static inline void process_marked_switches (void);
389 static const char *process_brace_body (const char *, const char *, const char *, int, int);
390 static const struct spec_function
*lookup_spec_function (const char *);
391 static const char *eval_spec_function (const char *, const char *, const char *);
392 static const char *handle_spec_function (const char *, bool *, const char *);
393 static char *save_string (const char *, int);
394 static void set_collect_gcc_options (void);
395 static int do_spec_1 (const char *, int, const char *);
396 static int do_spec_2 (const char *, const char *);
397 static void do_option_spec (const char *, const char *);
398 static void do_self_spec (const char *);
399 static const char *find_file (const char *);
400 static int is_directory (const char *, bool);
401 static const char *validate_switches (const char *, bool, bool);
402 static void validate_all_switches (void);
403 static inline void validate_switches_from_spec (const char *, bool);
404 static void give_switch (int, int);
405 static int default_arg (const char *, int);
406 static void set_multilib_dir (void);
407 static void print_multilib_info (void);
408 static void display_help (void);
409 static void add_preprocessor_option (const char *, int);
410 static void add_assembler_option (const char *, int);
411 static void add_linker_option (const char *, int);
412 static void process_command (unsigned int, struct cl_decoded_option
*);
413 static int execute (void);
414 static void alloc_args (void);
415 static void clear_args (void);
416 static void fatal_signal (int);
417 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
418 static void init_gcc_specs (struct obstack
*, const char *, const char *,
421 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
422 static const char *convert_filename (const char *, int, int);
425 static void try_generate_repro (const char **argv
);
426 static const char *getenv_spec_function (int, const char **);
427 static const char *if_exists_spec_function (int, const char **);
428 static const char *if_exists_else_spec_function (int, const char **);
429 static const char *if_exists_then_else_spec_function (int, const char **);
430 static const char *sanitize_spec_function (int, const char **);
431 static const char *replace_outfile_spec_function (int, const char **);
432 static const char *remove_outfile_spec_function (int, const char **);
433 static const char *version_compare_spec_function (int, const char **);
434 static const char *include_spec_function (int, const char **);
435 static const char *find_file_spec_function (int, const char **);
436 static const char *find_plugindir_spec_function (int, const char **);
437 static const char *print_asm_header_spec_function (int, const char **);
438 static const char *compare_debug_dump_opt_spec_function (int, const char **);
439 static const char *compare_debug_self_opt_spec_function (int, const char **);
440 static const char *pass_through_libs_spec_func (int, const char **);
441 static const char *dumps_spec_func (int, const char **);
442 static const char *greater_than_spec_func (int, const char **);
443 static const char *debug_level_greater_than_spec_func (int, const char **);
444 static const char *dwarf_version_greater_than_spec_func (int, const char **);
445 static const char *find_fortran_preinclude_file (int, const char **);
446 static char *convert_white_space (char *);
447 static char *quote_spec (char *);
448 static char *quote_spec_arg (char *);
449 static bool not_actual_file_p (const char *);
452 /* The Specs Language
454 Specs are strings containing lines, each of which (if not blank)
455 is made up of a program name, and arguments separated by spaces.
456 The program name must be exact and start from root, since no path
457 is searched and it is unreliable to depend on the current working directory.
458 Redirection of input or output is not supported; the subprograms must
459 accept filenames saying what files to read and write.
461 In addition, the specs can contain %-sequences to substitute variable text
462 or for conditional text. Here is a table of all defined %-sequences.
463 Note that spaces are not generated automatically around the results of
464 expanding these sequences; therefore, you can concatenate them together
465 or with constant text in a single argument.
467 %% substitute one % into the program name or argument.
468 %" substitute an empty argument.
469 %i substitute the name of the input file being processed.
470 %b substitute the basename for outputs related with the input file
471 being processed. This is often a substring of the input file name,
472 up to (and not including) the last period but, unless %w is active,
473 it is affected by the directory selected by -save-temps=*, by
474 -dumpdir, and, in case of multiple compilations, even by -dumpbase
475 and -dumpbase-ext and, in case of linking, by the linker output
476 name. When %w is active, it derives the main output name only from
477 the input file base name; when it is not, it names aux/dump output
479 %B same as %b, but include the input file suffix (text after the last
482 substitute a file name that has suffix SUFFIX and is chosen
483 once per compilation, and mark the argument a la %d. To reduce
484 exposure to denial-of-service attacks, the file name is now
485 chosen in a way that is hard to predict even when previously
486 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
487 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
488 the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
489 had been pre-processed. Previously, %g was simply substituted
490 with a file name chosen once per compilation, without regard
491 to any appended suffix (which was therefore treated just like
492 ordinary text), making such attacks more likely to succeed.
494 like %g, but if -pipe is in effect, expands simply to "-".
496 like %g, but if -pipe is in effect, expands to nothing. (We have both
497 %| and %m to accommodate differences between system assemblers; see
498 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
500 like %g, but generates a new temporary file name even if %uSUFFIX
503 substitutes the last file name generated with %uSUFFIX, generating a
504 new one if there is no such last file name. In the absence of any
505 %uSUFFIX, this is just like %gSUFFIX, except they don't share
506 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
507 would involve the generation of two distinct file names, one
508 for each `%g.s' and another for each `%U.s'. Previously, %U was
509 simply substituted with a file name chosen for the previous %u,
510 without regard to any appended suffix.
512 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
513 writable, and if save-temps is off; otherwise, substitute the name
514 of a temporary file, just like %u. This temporary file is not
515 meant for communication between processes, but rather as a junk
518 substitutes .SUFFIX for the suffixes of a matched switch's args when
519 it is subsequently output with %*. SUFFIX is terminated by the next
521 %d marks the argument containing or following the %d as a
522 temporary file name, so that file will be deleted if GCC exits
523 successfully. Unlike %g, this contributes no text to the argument.
524 %w marks the argument containing or following the %w as the
525 "output file" of this compilation. This puts the argument
526 into the sequence of arguments that %o will substitute later.
527 %V indicates that this compilation produces no "output file".
529 like %{...} but marks the last argument supplied within as a file
530 to be deleted on failure.
532 like %{...} but puts the result into a FILE and substitutes @FILE
533 if an @file argument has been supplied.
534 %o substitutes the names of all the output files, with spaces
535 automatically placed around them. You should write spaces
536 around the %o as well or the results are undefined.
537 %o is for use in the specs for running the linker.
538 Input files whose names have no recognized suffix are not compiled
539 at all, but they are included among the output files, so they will
541 %O substitutes the suffix for object files. Note that this is
542 handled specially when it immediately follows %g, %u, or %U
543 (with or without a suffix argument) because of the need for
544 those to form complete file names. The handling is such that
545 %O is treated exactly as if it had already been substituted,
546 except that %g, %u, and %U do not currently support additional
547 SUFFIX characters following %O as they would following, for
549 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
550 (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
551 and -B options) and -imultilib as necessary.
552 %s current argument is the name of a library or startup file of some sort.
553 Search for that file in a standard list of directories
554 and substitute the full name found.
555 %T current argument is the name of a linker script.
556 Search for that file in the current list of directories to scan for
557 libraries. If the file is located, insert a --script option into the
558 command line followed by the full path name found. If the file is
559 not found then generate an error message.
560 Note: the current working directory is not searched.
561 %eSTR Print STR as an error message. STR is terminated by a newline.
562 Use this when inconsistent options are detected.
563 %nSTR Print STR as a notice. STR is terminated by a newline.
564 %x{OPTION} Accumulate an option for %X.
565 %X Output the accumulated linker options specified by compilations.
566 %Y Output the accumulated assembler options specified by compilations.
567 %Z Output the accumulated preprocessor options specified by compilations.
568 %a process ASM_SPEC as a spec.
569 This allows config.h to specify part of the spec for running as.
570 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
571 used here. This can be used to run a post-processor after the
572 assembler has done its job.
573 %D Dump out a -L option for each directory in startfile_prefixes.
574 If multilib_dir is set, extra entries are generated with it affixed.
575 %l process LINK_SPEC as a spec.
576 %L process LIB_SPEC as a spec.
577 %M Output multilib_os_dir.
578 %G process LIBGCC_SPEC as a spec.
579 %R Output the concatenation of target_system_root and
580 target_sysroot_suffix.
581 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
582 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
583 %C process CPP_SPEC as a spec.
584 %1 process CC1_SPEC as a spec.
585 %2 process CC1PLUS_SPEC as a spec.
586 %* substitute the variable part of a matched option. (See below.)
587 Note that each comma in the substituted string is replaced by
588 a single space. A space is appended after the last substition
589 unless there is more text in current sequence.
590 %<S remove all occurrences of -S from the command line.
591 Note - this command is position dependent. % commands in the
592 spec string before this one will see -S, % commands in the
593 spec string after this one will not.
594 %>S Similar to "%<S", but keep it in the GCC command line.
595 %<S* remove all occurrences of all switches beginning with -S from the
598 Call the named function FUNCTION, passing it ARGS. ARGS is
599 first processed as a nested spec string, then split into an
600 argument vector in the usual fashion. The function returns
601 a string which is processed as if it had appeared literally
602 as part of the current spec.
603 %{S} substitutes the -S switch, if that switch was given to GCC.
604 If that switch was not specified, this substitutes nothing.
605 Here S is a metasyntactic variable.
606 %{S*} substitutes all the switches specified to GCC whose names start
607 with -S. This is used for -o, -I, etc; switches that take
608 arguments. GCC considers `-o foo' as being one switch whose
609 name starts with `o'. %{o*} would substitute this text,
610 including the space; thus, two arguments would be generated.
611 %{S*&T*} likewise, but preserve order of S and T options (the order
612 of S and T in the spec is not significant). Can be any number
613 of ampersand-separated variables; for each the wild card is
614 optional. Useful for CPP as %{D*&U*&A*}.
616 %{S:X} substitutes X, if the -S switch was given to GCC.
617 %{!S:X} substitutes X, if the -S switch was NOT given to GCC.
618 %{S*:X} substitutes X if one or more switches whose names start
619 with -S was given to GCC. Normally X is substituted only
620 once, no matter how many such switches appeared. However,
621 if %* appears somewhere in X, then X will be substituted
622 once for each matching switch, with the %* replaced by the
623 part of that switch that matched the '*'. A space will be
624 appended after the last substition unless there is more
625 text in current sequence.
626 %{.S:X} substitutes X, if processing a file with suffix S.
627 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
628 %{,S:X} substitutes X, if processing a file which will use spec S.
629 %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
631 %{S|T:X} substitutes X if either -S or -T was given to GCC. This may be
632 combined with '!', '.', ',', and '*' as above binding stronger
634 If %* appears in X, all of the alternatives must be starred, and
635 only the first matching alternative is substituted.
636 %{%:function(args):X}
637 Call function named FUNCTION with args ARGS. If the function
638 returns non-NULL, then X is substituted, if it returns
639 NULL, it isn't substituted.
640 %{S:X; if S was given to GCC, substitutes X;
641 T:Y; else if T was given to GCC, substitutes Y;
642 :D} else substitutes D. There can be as many clauses as you need.
643 This may be combined with '.', '!', ',', '|', and '*' as above.
645 %(Spec) processes a specification defined in a specs file as *Spec:
647 The switch matching text S in a %{S}, %{S:X}, or similar construct can use
648 a backslash to ignore the special meaning of the character following it,
649 thus allowing literal matching of a character that is otherwise specially
650 treated. For example, %{std=iso9899\:1999:X} substitutes X if the
651 -std=iso9899:1999 option is given.
653 The conditional text X in a %{S:X} or similar construct may contain
654 other nested % constructs or spaces, or even newlines. They are
655 processed as usual, as described above. Trailing white space in X is
656 ignored. White space may also appear anywhere on the left side of the
657 colon in these constructs, except between . or * and the corresponding
660 The -O, -f, -g, -m, and -W switches are handled specifically in these
661 constructs. If another value of -O or the negated form of a -f, -m, or
662 -W switch is found later in the command line, the earlier switch
663 value is ignored, except with {S*} where S is just one letter; this
664 passes all matching options.
666 The character | at the beginning of the predicate text is used to indicate
667 that a command should be piped to the following command, but only if -pipe
670 Note that it is built into GCC which switches take arguments and which
671 do not. You might think it would be useful to generalize this to
672 allow each compiler's spec to say which switches take arguments. But
673 this cannot be done in a consistent fashion. GCC cannot even decide
674 which input files have been specified without knowing which switches
675 take arguments, and it must know which input files to compile in order
676 to tell which compilers to run.
678 GCC also knows implicitly that arguments starting in `-l' are to be
679 treated as compiler output files, and passed to the linker in their
680 proper position among the other output files. */
682 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
684 /* config.h can define ASM_SPEC to provide extra args to the assembler
685 or extra switch-translations. */
690 /* config.h can define ASM_FINAL_SPEC to run a post processor after
691 the assembler has run. */
692 #ifndef ASM_FINAL_SPEC
693 #define ASM_FINAL_SPEC \
695 objcopy --extract-dwo \
696 %{c:%{o*:%*}%{!o*:%w%b%O}}%{!c:%U%O} \
698 objcopy --strip-dwo \
699 %{c:%{o*:%*}%{!o*:%w%b%O}}%{!c:%U%O} \
703 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
704 or extra switch-translations. */
709 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
710 or extra switch-translations. */
715 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
716 or extra switch-translations. */
718 #define CC1PLUS_SPEC ""
721 /* config.h can define LINK_SPEC to provide extra args to the linker
722 or extra switch-translations. */
727 /* config.h can define LIB_SPEC to override the default libraries. */
729 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
732 /* When using -fsplit-stack we need to wrap pthread_create, in order
733 to initialize the stack guard. We always use wrapping, rather than
734 shared library ordering, and we keep the wrapper function in
735 libgcc. This is not yet a real spec, though it could become one;
736 it is currently just stuffed into LINK_SPEC. FIXME: This wrapping
737 only works with GNU ld and gold. */
738 #ifdef HAVE_GOLD_NON_DEFAULT_SPLIT_STACK
739 #define STACK_SPLIT_SPEC " %{fsplit-stack: -fuse-ld=gold --wrap=pthread_create}"
741 #define STACK_SPLIT_SPEC " %{fsplit-stack: --wrap=pthread_create}"
745 #define STATIC_LIBASAN_LIBS \
746 " %{static-libasan|static:%:include(libsanitizer.spec)%(link_libasan)}"
747 #ifdef LIBASAN_EARLY_SPEC
748 #define LIBASAN_SPEC STATIC_LIBASAN_LIBS
749 #elif defined(HAVE_LD_STATIC_DYNAMIC)
750 #define LIBASAN_SPEC "%{static-libasan:" LD_STATIC_OPTION \
751 "} -lasan %{static-libasan:" LD_DYNAMIC_OPTION "}" \
754 #define LIBASAN_SPEC "-lasan" STATIC_LIBASAN_LIBS
758 #ifndef LIBASAN_EARLY_SPEC
759 #define LIBASAN_EARLY_SPEC ""
762 #ifndef LIBHWASAN_SPEC
763 #define STATIC_LIBHWASAN_LIBS \
764 " %{static-libhwasan|static:%:include(libsanitizer.spec)%(link_libhwasan)}"
765 #ifdef LIBHWASAN_EARLY_SPEC
766 #define LIBHWASAN_SPEC STATIC_LIBHWASAN_LIBS
767 #elif defined(HAVE_LD_STATIC_DYNAMIC)
768 #define LIBHWASAN_SPEC "%{static-libhwasan:" LD_STATIC_OPTION \
769 "} -lhwasan %{static-libhwasan:" LD_DYNAMIC_OPTION "}" \
770 STATIC_LIBHWASAN_LIBS
772 #define LIBHWASAN_SPEC "-lhwasan" STATIC_LIBHWASAN_LIBS
776 #ifndef LIBHWASAN_EARLY_SPEC
777 #define LIBHWASAN_EARLY_SPEC ""
781 #define STATIC_LIBTSAN_LIBS \
782 " %{static-libtsan|static:%:include(libsanitizer.spec)%(link_libtsan)}"
783 #ifdef LIBTSAN_EARLY_SPEC
784 #define LIBTSAN_SPEC STATIC_LIBTSAN_LIBS
785 #elif defined(HAVE_LD_STATIC_DYNAMIC)
786 #define LIBTSAN_SPEC "%{static-libtsan:" LD_STATIC_OPTION \
787 "} -ltsan %{static-libtsan:" LD_DYNAMIC_OPTION "}" \
790 #define LIBTSAN_SPEC "-ltsan" STATIC_LIBTSAN_LIBS
794 #ifndef LIBTSAN_EARLY_SPEC
795 #define LIBTSAN_EARLY_SPEC ""
799 #define STATIC_LIBLSAN_LIBS \
800 " %{static-liblsan|static:%:include(libsanitizer.spec)%(link_liblsan)}"
801 #ifdef LIBLSAN_EARLY_SPEC
802 #define LIBLSAN_SPEC STATIC_LIBLSAN_LIBS
803 #elif defined(HAVE_LD_STATIC_DYNAMIC)
804 #define LIBLSAN_SPEC "%{static-liblsan:" LD_STATIC_OPTION \
805 "} -llsan %{static-liblsan:" LD_DYNAMIC_OPTION "}" \
808 #define LIBLSAN_SPEC "-llsan" STATIC_LIBLSAN_LIBS
812 #ifndef LIBLSAN_EARLY_SPEC
813 #define LIBLSAN_EARLY_SPEC ""
816 #ifndef LIBUBSAN_SPEC
817 #define STATIC_LIBUBSAN_LIBS \
818 " %{static-libubsan|static:%:include(libsanitizer.spec)%(link_libubsan)}"
819 #ifdef HAVE_LD_STATIC_DYNAMIC
820 #define LIBUBSAN_SPEC "%{static-libubsan:" LD_STATIC_OPTION \
821 "} -lubsan %{static-libubsan:" LD_DYNAMIC_OPTION "}" \
824 #define LIBUBSAN_SPEC "-lubsan" STATIC_LIBUBSAN_LIBS
828 /* Linker options for compressed debug sections. */
829 #if HAVE_LD_COMPRESS_DEBUG == 0
830 /* No linker support. */
831 #define LINK_COMPRESS_DEBUG_SPEC \
832 " %{gz*:%e-gz is not supported in this configuration} "
833 #elif HAVE_LD_COMPRESS_DEBUG == 1
834 /* GNU style on input, GNU ld options. Reject, not useful. */
835 #define LINK_COMPRESS_DEBUG_SPEC \
836 " %{gz*:%e-gz is not supported in this configuration} "
837 #elif HAVE_LD_COMPRESS_DEBUG == 2
838 /* GNU style, GNU gold options. */
839 #define LINK_COMPRESS_DEBUG_SPEC \
840 " %{gz|gz=zlib-gnu:" LD_COMPRESS_DEBUG_OPTION "=zlib}" \
841 " %{gz=none:" LD_COMPRESS_DEBUG_OPTION "=none}" \
842 " %{gz=zlib:%e-gz=zlib is not supported in this configuration} "
843 #elif HAVE_LD_COMPRESS_DEBUG == 3
844 /* ELF gABI style. */
845 #define LINK_COMPRESS_DEBUG_SPEC \
846 " %{gz|gz=zlib:" LD_COMPRESS_DEBUG_OPTION "=zlib}" \
847 " %{gz=none:" LD_COMPRESS_DEBUG_OPTION "=none}" \
848 " %{gz=zlib-gnu:" LD_COMPRESS_DEBUG_OPTION "=zlib-gnu} "
850 #error Unknown value for HAVE_LD_COMPRESS_DEBUG.
853 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
856 #if defined(REAL_LIBGCC_SPEC)
857 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
858 #elif defined(LINK_LIBGCC_SPECIAL_1)
859 /* Have gcc do the search for libgcc.a. */
860 #define LIBGCC_SPEC "libgcc.a%s"
862 #define LIBGCC_SPEC "-lgcc"
866 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
867 #ifndef STARTFILE_SPEC
868 #define STARTFILE_SPEC \
869 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
872 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
874 #define ENDFILE_SPEC ""
878 #define LINKER_NAME "collect2"
881 #ifdef HAVE_AS_DEBUG_PREFIX_MAP
882 #define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
887 /* Assembler options for compressed debug sections. */
888 #if HAVE_LD_COMPRESS_DEBUG < 2
889 /* Reject if the linker cannot write compressed debug sections. */
890 #define ASM_COMPRESS_DEBUG_SPEC \
891 " %{gz*:%e-gz is not supported in this configuration} "
892 #else /* HAVE_LD_COMPRESS_DEBUG >= 2 */
893 #if HAVE_AS_COMPRESS_DEBUG == 0
894 /* No assembler support. Ignore silently. */
895 #define ASM_COMPRESS_DEBUG_SPEC \
897 #elif HAVE_AS_COMPRESS_DEBUG == 1
898 /* GNU style, GNU as options. */
899 #define ASM_COMPRESS_DEBUG_SPEC \
900 " %{gz|gz=zlib-gnu:" AS_COMPRESS_DEBUG_OPTION "}" \
901 " %{gz=none:" AS_NO_COMPRESS_DEBUG_OPTION "}" \
902 " %{gz=zlib:%e-gz=zlib is not supported in this configuration} "
903 #elif HAVE_AS_COMPRESS_DEBUG == 2
904 /* ELF gABI style. */
905 #define ASM_COMPRESS_DEBUG_SPEC \
906 " %{gz|gz=zlib:" AS_COMPRESS_DEBUG_OPTION "=zlib}" \
907 " %{gz=none:" AS_COMPRESS_DEBUG_OPTION "=none}" \
908 " %{gz=zlib-gnu:" AS_COMPRESS_DEBUG_OPTION "=zlib-gnu} "
910 #error Unknown value for HAVE_AS_COMPRESS_DEBUG.
912 #endif /* HAVE_LD_COMPRESS_DEBUG >= 2 */
914 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
915 to the assembler, when compiling assembly sources only. */
916 #ifndef ASM_DEBUG_SPEC
917 # if defined(HAVE_AS_GDWARF_5_DEBUG_FLAG) && defined(HAVE_AS_WORKING_DWARF_N_FLAG)
918 /* If --gdwarf-N is supported and as can handle even compiler generated
919 .debug_line with it, supply --gdwarf-N in ASM_DEBUG_OPTION_SPEC rather
920 than in ASM_DEBUG_SPEC, so that it applies to both .s and .c etc.
922 # define ASM_DEBUG_DWARF_OPTION ""
923 # elif defined(HAVE_AS_GDWARF_5_DEBUG_FLAG) && !defined(HAVE_LD_BROKEN_PE_DWARF5)
924 # define ASM_DEBUG_DWARF_OPTION "%{%:dwarf-version-gt(4):--gdwarf-5;" \
925 "%:dwarf-version-gt(3):--gdwarf-4;" \
926 "%:dwarf-version-gt(2):--gdwarf-3;" \
929 # define ASM_DEBUG_DWARF_OPTION "--gdwarf2"
931 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
932 # define ASM_DEBUG_SPEC "%{g*:%{%:debug-level-gt(0):" \
933 ASM_DEBUG_DWARF_OPTION "}}" ASM_MAP
936 #ifndef ASM_DEBUG_SPEC
937 # define ASM_DEBUG_SPEC ""
940 /* Define ASM_DEBUG_OPTION_SPEC to be a spec suitable for translating '-g'
941 to the assembler when compiling all sources. */
942 #ifndef ASM_DEBUG_OPTION_SPEC
943 # if defined(HAVE_AS_GDWARF_5_DEBUG_FLAG) && defined(HAVE_AS_WORKING_DWARF_N_FLAG)
944 # define ASM_DEBUG_OPTION_DWARF_OPT \
945 "%{%:dwarf-version-gt(4):--gdwarf-5 ;" \
946 "%:dwarf-version-gt(3):--gdwarf-4 ;" \
947 "%:dwarf-version-gt(2):--gdwarf-3 ;" \
949 # if defined(DWARF2_DEBUGGING_INFO)
950 # define ASM_DEBUG_OPTION_SPEC "%{g*:%{%:debug-level-gt(0):" \
951 ASM_DEBUG_OPTION_DWARF_OPT "}}"
955 #ifndef ASM_DEBUG_OPTION_SPEC
956 # define ASM_DEBUG_OPTION_SPEC ""
959 /* Here is the spec for running the linker, after compiling all files. */
961 /* This is overridable by the target in case they need to specify the
962 -lgcc and -lc order specially, yet not require them to override all
963 of LINK_COMMAND_SPEC. */
964 #ifndef LINK_GCC_C_SEQUENCE_SPEC
965 #define LINK_GCC_C_SEQUENCE_SPEC "%G %{!nolibc:%L %G}"
968 #ifndef LINK_SSP_SPEC
969 #ifdef TARGET_LIBC_PROVIDES_SSP
970 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all" \
971 "|fstack-protector-strong|fstack-protector-explicit:}"
973 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all" \
974 "|fstack-protector-strong|fstack-protector-explicit" \
975 ":-lssp_nonshared -lssp}"
979 #ifdef ENABLE_DEFAULT_PIE
980 #define PIE_SPEC "!no-pie"
981 #define NO_FPIE1_SPEC "fno-pie"
982 #define FPIE1_SPEC NO_FPIE1_SPEC ":;"
983 #define NO_FPIE2_SPEC "fno-PIE"
984 #define FPIE2_SPEC NO_FPIE2_SPEC ":;"
985 #define NO_FPIE_SPEC NO_FPIE1_SPEC "|" NO_FPIE2_SPEC
986 #define FPIE_SPEC NO_FPIE_SPEC ":;"
987 #define NO_FPIC1_SPEC "fno-pic"
988 #define FPIC1_SPEC NO_FPIC1_SPEC ":;"
989 #define NO_FPIC2_SPEC "fno-PIC"
990 #define FPIC2_SPEC NO_FPIC2_SPEC ":;"
991 #define NO_FPIC_SPEC NO_FPIC1_SPEC "|" NO_FPIC2_SPEC
992 #define FPIC_SPEC NO_FPIC_SPEC ":;"
993 #define NO_FPIE1_AND_FPIC1_SPEC NO_FPIE1_SPEC "|" NO_FPIC1_SPEC
994 #define FPIE1_OR_FPIC1_SPEC NO_FPIE1_AND_FPIC1_SPEC ":;"
995 #define NO_FPIE2_AND_FPIC2_SPEC NO_FPIE2_SPEC "|" NO_FPIC2_SPEC
996 #define FPIE2_OR_FPIC2_SPEC NO_FPIE2_AND_FPIC2_SPEC ":;"
997 #define NO_FPIE_AND_FPIC_SPEC NO_FPIE_SPEC "|" NO_FPIC_SPEC
998 #define FPIE_OR_FPIC_SPEC NO_FPIE_AND_FPIC_SPEC ":;"
1000 #define PIE_SPEC "pie"
1001 #define FPIE1_SPEC "fpie"
1002 #define NO_FPIE1_SPEC FPIE1_SPEC ":;"
1003 #define FPIE2_SPEC "fPIE"
1004 #define NO_FPIE2_SPEC FPIE2_SPEC ":;"
1005 #define FPIE_SPEC FPIE1_SPEC "|" FPIE2_SPEC
1006 #define NO_FPIE_SPEC FPIE_SPEC ":;"
1007 #define FPIC1_SPEC "fpic"
1008 #define NO_FPIC1_SPEC FPIC1_SPEC ":;"
1009 #define FPIC2_SPEC "fPIC"
1010 #define NO_FPIC2_SPEC FPIC2_SPEC ":;"
1011 #define FPIC_SPEC FPIC1_SPEC "|" FPIC2_SPEC
1012 #define NO_FPIC_SPEC FPIC_SPEC ":;"
1013 #define FPIE1_OR_FPIC1_SPEC FPIE1_SPEC "|" FPIC1_SPEC
1014 #define NO_FPIE1_AND_FPIC1_SPEC FPIE1_OR_FPIC1_SPEC ":;"
1015 #define FPIE2_OR_FPIC2_SPEC FPIE2_SPEC "|" FPIC2_SPEC
1016 #define NO_FPIE2_AND_FPIC2_SPEC FPIE1_OR_FPIC2_SPEC ":;"
1017 #define FPIE_OR_FPIC_SPEC FPIE_SPEC "|" FPIC_SPEC
1018 #define NO_FPIE_AND_FPIC_SPEC FPIE_OR_FPIC_SPEC ":;"
1021 #ifndef LINK_PIE_SPEC
1024 #define LD_PIE_SPEC "-pie"
1027 #define LD_PIE_SPEC ""
1029 #define LINK_PIE_SPEC "%{static|shared|r:;" PIE_SPEC ":" LD_PIE_SPEC "} "
1032 #ifndef LINK_BUILDID_SPEC
1033 # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
1034 # define LINK_BUILDID_SPEC "%{!r:--build-id} "
1038 #ifndef LTO_PLUGIN_SPEC
1039 #define LTO_PLUGIN_SPEC ""
1042 /* Conditional to test whether the LTO plugin is used or not.
1043 FIXME: For slim LTO we will need to enable plugin unconditionally. This
1044 still cause problems with PLUGIN_LD != LD and when plugin is built but
1045 not useable. For GCC 4.6 we don't support slim LTO and thus we can enable
1046 plugin only when LTO is enabled. We still honor explicit
1047 -fuse-linker-plugin if the linker used understands -plugin. */
1049 /* The linker has some plugin support. */
1050 #if HAVE_LTO_PLUGIN > 0
1051 /* The linker used has full plugin support, use LTO plugin by default. */
1052 #if HAVE_LTO_PLUGIN == 2
1053 #define PLUGIN_COND "!fno-use-linker-plugin:%{!fno-lto"
1054 #define PLUGIN_COND_CLOSE "}"
1056 /* The linker used has limited plugin support, use LTO plugin with explicit
1057 -fuse-linker-plugin. */
1058 #define PLUGIN_COND "fuse-linker-plugin"
1059 #define PLUGIN_COND_CLOSE ""
1061 #define LINK_PLUGIN_SPEC \
1062 "%{" PLUGIN_COND": \
1063 -plugin %(linker_plugin_file) \
1064 -plugin-opt=%(lto_wrapper) \
1065 -plugin-opt=-fresolution=%u.res \
1066 " LTO_PLUGIN_SPEC "\
1067 %{flinker-output=*:-plugin-opt=-linker-output-known} \
1068 %{!nostdlib:%{!nodefaultlibs:%:pass-through-libs(%(link_gcc_c_sequence))}} \
1069 }" PLUGIN_COND_CLOSE
1071 /* The linker used doesn't support -plugin, reject -fuse-linker-plugin. */
1072 #define LINK_PLUGIN_SPEC "%{fuse-linker-plugin:\
1073 %e-fuse-linker-plugin is not supported in this configuration}"
1076 /* Linker command line options for -fsanitize= early on the command line. */
1077 #ifndef SANITIZER_EARLY_SPEC
1078 #define SANITIZER_EARLY_SPEC "\
1079 %{!nostdlib:%{!r:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_EARLY_SPEC "} \
1080 %{%:sanitize(hwaddress):" LIBHWASAN_EARLY_SPEC "} \
1081 %{%:sanitize(thread):" LIBTSAN_EARLY_SPEC "} \
1082 %{%:sanitize(leak):" LIBLSAN_EARLY_SPEC "}}}}"
1085 /* Linker command line options for -fsanitize= late on the command line. */
1086 #ifndef SANITIZER_SPEC
1087 #define SANITIZER_SPEC "\
1088 %{!nostdlib:%{!r:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_SPEC "\
1089 %{static:%ecannot specify -static with -fsanitize=address}}\
1090 %{%:sanitize(hwaddress):" LIBHWASAN_SPEC "\
1091 %{static:%ecannot specify -static with -fsanitize=hwaddress}}\
1092 %{%:sanitize(thread):" LIBTSAN_SPEC "\
1093 %{static:%ecannot specify -static with -fsanitize=thread}}\
1094 %{%:sanitize(undefined):" LIBUBSAN_SPEC "}\
1095 %{%:sanitize(leak):" LIBLSAN_SPEC "}}}}"
1098 #ifndef POST_LINK_SPEC
1099 #define POST_LINK_SPEC ""
1102 /* This is the spec to use, once the code for creating the vtable
1103 verification runtime library, libvtv.so, has been created. Currently
1104 the vtable verification runtime functions are in libstdc++, so we use
1105 the spec just below this one. */
1106 #ifndef VTABLE_VERIFICATION_SPEC
1107 #if ENABLE_VTABLE_VERIFY
1108 #define VTABLE_VERIFICATION_SPEC "\
1109 %{!nostdlib:%{!r:%{fvtable-verify=std: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}\
1110 %{fvtable-verify=preinit: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}}}"
1112 #define VTABLE_VERIFICATION_SPEC "\
1113 %{fvtable-verify=none:} \
1114 %{fvtable-verify=std: \
1115 %e-fvtable-verify=std is not supported in this configuration} \
1116 %{fvtable-verify=preinit: \
1117 %e-fvtable-verify=preinit is not supported in this configuration}"
1121 /* -u* was put back because both BSD and SysV seem to support it. */
1122 /* %{static|no-pie|static-pie:} simply prevents an error message:
1123 1. If the target machine doesn't handle -static.
1124 2. If PIE isn't enabled by default.
1125 3. If the target machine doesn't handle -static-pie.
1127 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
1128 scripts which exist in user specified directories, or in standard
1130 /* We pass any -flto flags on to the linker, which is expected
1131 to understand them. In practice, this means it had better be collect2. */
1132 /* %{e*} includes -export-dynamic; see comment in common.opt. */
1133 #ifndef LINK_COMMAND_SPEC
1134 #define LINK_COMMAND_SPEC "\
1135 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
1138 "%{flto|flto=*:%<fcompare-debug*} \
1139 %{flto} %{fno-lto} %{flto=*} %l " LINK_PIE_SPEC \
1140 "%{fuse-ld=*:-fuse-ld=%*} " LINK_COMPRESS_DEBUG_SPEC \
1141 "%X %{o*} %{e*} %{N} %{n} %{r}\
1142 %{s} %{t} %{u*} %{z} %{Z} %{!nostdlib:%{!r:%{!nostartfiles:%S}}} \
1143 %{static|no-pie|static-pie:} %@{L*} %(mfwrap) %(link_libgcc) " \
1144 VTABLE_VERIFICATION_SPEC " " SANITIZER_EARLY_SPEC " %o "" \
1145 %{fopenacc|fopenmp|%:gt(%{ftree-parallelize-loops=*:%*} 1):\
1146 %:include(libgomp.spec)%(link_gomp)}\
1147 %{fgnu-tm:%:include(libitm.spec)%(link_itm)}\
1148 %(mflib) " STACK_SPLIT_SPEC "\
1149 %{fprofile-arcs|fprofile-generate*|coverage:-lgcov} " SANITIZER_SPEC " \
1150 %{!nostdlib:%{!r:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}}\
1151 %{!nostdlib:%{!r:%{!nostartfiles:%E}}} %{T*} \n%(post_link) }}}}}}"
1154 #ifndef LINK_LIBGCC_SPEC
1155 /* Generate -L options for startfile prefix list. */
1156 # define LINK_LIBGCC_SPEC "%D"
1159 #ifndef STARTFILE_PREFIX_SPEC
1160 # define STARTFILE_PREFIX_SPEC ""
1163 #ifndef SYSROOT_SPEC
1164 # define SYSROOT_SPEC "--sysroot=%R"
1167 #ifndef SYSROOT_SUFFIX_SPEC
1168 # define SYSROOT_SUFFIX_SPEC ""
1171 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
1172 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
1175 static const char *asm_debug
= ASM_DEBUG_SPEC
;
1176 static const char *asm_debug_option
= ASM_DEBUG_OPTION_SPEC
;
1177 static const char *cpp_spec
= CPP_SPEC
;
1178 static const char *cc1_spec
= CC1_SPEC
;
1179 static const char *cc1plus_spec
= CC1PLUS_SPEC
;
1180 static const char *link_gcc_c_sequence_spec
= LINK_GCC_C_SEQUENCE_SPEC
;
1181 static const char *link_ssp_spec
= LINK_SSP_SPEC
;
1182 static const char *asm_spec
= ASM_SPEC
;
1183 static const char *asm_final_spec
= ASM_FINAL_SPEC
;
1184 static const char *link_spec
= LINK_SPEC
;
1185 static const char *lib_spec
= LIB_SPEC
;
1186 static const char *link_gomp_spec
= "";
1187 static const char *libgcc_spec
= LIBGCC_SPEC
;
1188 static const char *endfile_spec
= ENDFILE_SPEC
;
1189 static const char *startfile_spec
= STARTFILE_SPEC
;
1190 static const char *linker_name_spec
= LINKER_NAME
;
1191 static const char *linker_plugin_file_spec
= "";
1192 static const char *lto_wrapper_spec
= "";
1193 static const char *lto_gcc_spec
= "";
1194 static const char *post_link_spec
= POST_LINK_SPEC
;
1195 static const char *link_command_spec
= LINK_COMMAND_SPEC
;
1196 static const char *link_libgcc_spec
= LINK_LIBGCC_SPEC
;
1197 static const char *startfile_prefix_spec
= STARTFILE_PREFIX_SPEC
;
1198 static const char *sysroot_spec
= SYSROOT_SPEC
;
1199 static const char *sysroot_suffix_spec
= SYSROOT_SUFFIX_SPEC
;
1200 static const char *sysroot_hdrs_suffix_spec
= SYSROOT_HEADERS_SUFFIX_SPEC
;
1201 static const char *self_spec
= "";
1203 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
1204 There should be no need to override these in target dependent files,
1205 but we need to copy them to the specs file so that newer versions
1206 of the GCC driver can correctly drive older tool chains with the
1207 appropriate -B options. */
1209 /* When cpplib handles traditional preprocessing, get rid of this, and
1210 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
1211 that we default the front end language better. */
1212 static const char *trad_capable_cpp
=
1213 "cc1 -E %{traditional|traditional-cpp:-traditional-cpp}";
1215 /* We don't wrap .d files in %W{} since a missing .d file, and
1216 therefore no dependency entry, confuses make into thinking a .o
1217 file that happens to exist is up-to-date. */
1218 static const char *cpp_unique_options
=
1219 "%{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %@{I*&F*} %{P} %I\
1220 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
1221 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
1222 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
1223 %{Mmodules} %{Mno-modules}\
1224 %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
1225 %{remap} %{%:debug-level-gt(2):-dD}\
1226 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
1227 %{H} %C %{D*&U*&A*} %{i*} %Z %i\
1230 /* This contains cpp options which are common with cc1_options and are passed
1231 only when preprocessing only to avoid duplication. We pass the cc1 spec
1232 options to the preprocessor so that it the cc1 spec may manipulate
1233 options used to set target flags. Those special target flags settings may
1234 in turn cause preprocessor symbols to be defined specially. */
1235 static const char *cpp_options
=
1236 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
1237 %{f*} %{g*:%{%:debug-level-gt(0):%{g*}\
1238 %{!fno-working-directory:-fworking-directory}}} %{O*}\
1239 %{undef} %{save-temps*:-fpch-preprocess}";
1241 /* Pass -d* flags, possibly modifying -dumpdir, -dumpbase et al.
1243 Make it easy for a language to override the argument for the
1244 %:dumps specs function call. */
1245 #define DUMPS_OPTIONS(EXTS) \
1246 "%<dumpdir %<dumpbase %<dumpbase-ext %{d*} %:dumps(" EXTS ")"
1248 /* This contains cpp options which are not passed when the preprocessor
1249 output will be used by another program. */
1250 static const char *cpp_debug_options
= DUMPS_OPTIONS ("");
1252 /* NB: This is shared amongst all front-ends, except for Ada. */
1253 static const char *cc1_options
=
1254 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
1255 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
1256 %1 %{!Q:-quiet} %(cpp_debug_options) %{m*} %{aux-info*}\
1257 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
1258 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
1259 %{Qn:-fno-ident} %{Qy:} %{-help:--help}\
1260 %{-target-help:--target-help}\
1261 %{-version:--version}\
1262 %{-help=*:--help=%*}\
1263 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %w%b.s}}}\
1264 %{fsyntax-only:-o %j} %{-param*}\
1265 %{coverage:-fprofile-arcs -ftest-coverage}\
1266 %{fprofile-arcs|fprofile-generate*|coverage:\
1267 %{!fprofile-update=single:\
1268 %{pthread:-fprofile-update=prefer-atomic}}}";
1270 static const char *asm_options
=
1271 "%{-target-help:%:print-asm-header()} "
1273 /* If GNU AS is used, then convert -w (no warnings), -I, and -v
1274 to the assembler equivalents. */
1275 "%{v} %{w:-W} %{I*} "
1277 "%(asm_debug_option)"
1278 ASM_COMPRESS_DEBUG_SPEC
1279 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
1281 static const char *invoke_as
=
1282 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1284 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
1285 %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
1289 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
1290 %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
1294 /* Some compilers have limits on line lengths, and the multilib_select
1295 and/or multilib_matches strings can be very long, so we build them at
1297 static struct obstack multilib_obstack
;
1298 static const char *multilib_select
;
1299 static const char *multilib_matches
;
1300 static const char *multilib_defaults
;
1301 static const char *multilib_exclusions
;
1302 static const char *multilib_reuse
;
1304 /* Check whether a particular argument is a default argument. */
1306 #ifndef MULTILIB_DEFAULTS
1307 #define MULTILIB_DEFAULTS { "" }
1310 static const char *const multilib_defaults_raw
[] = MULTILIB_DEFAULTS
;
1312 #ifndef DRIVER_SELF_SPECS
1313 #define DRIVER_SELF_SPECS ""
1316 /* Linking to libgomp implies pthreads. This is particularly important
1317 for targets that use different start files and suchlike. */
1318 #ifndef GOMP_SELF_SPECS
1319 #define GOMP_SELF_SPECS \
1320 "%{fopenacc|fopenmp|%:gt(%{ftree-parallelize-loops=*:%*} 1): " \
1324 /* Likewise for -fgnu-tm. */
1325 #ifndef GTM_SELF_SPECS
1326 #define GTM_SELF_SPECS "%{fgnu-tm: -pthread}"
1329 static const char *const driver_self_specs
[] = {
1330 "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
1331 DRIVER_SELF_SPECS
, CONFIGURE_SPECS
, GOMP_SELF_SPECS
, GTM_SELF_SPECS
1334 #ifndef OPTION_DEFAULT_SPECS
1335 #define OPTION_DEFAULT_SPECS { "", "" }
1344 static const struct default_spec
1345 option_default_specs
[] = { OPTION_DEFAULT_SPECS
};
1349 struct user_specs
*next
;
1350 const char *filename
;
1353 static struct user_specs
*user_specs_head
, *user_specs_tail
;
1356 /* Record the mapping from file suffixes for compilation specs. */
1360 const char *suffix
; /* Use this compiler for input files
1361 whose names end in this suffix. */
1363 const char *spec
; /* To use this compiler, run this spec. */
1365 const char *cpp_spec
; /* If non-NULL, substitute this spec
1366 for `%C', rather than the usual
1368 int combinable
; /* If nonzero, compiler can deal with
1369 multiple source files at once (IMA). */
1370 int needs_preprocessing
; /* If nonzero, source files need to
1371 be run through a preprocessor. */
1374 /* Pointer to a vector of `struct compiler' that gives the spec for
1375 compiling a file, based on its suffix.
1376 A file that does not end in any of these suffixes will be passed
1377 unchanged to the loader and nothing else will be done to it.
1379 An entry containing two 0s is used to terminate the vector.
1381 If multiple entries match a file, the last matching one is used. */
1383 static struct compiler
*compilers
;
1385 /* Number of entries in `compilers', not counting the null terminator. */
1387 static int n_compilers
;
1389 /* The default list of file name suffixes and their compilation specs. */
1391 static const struct compiler default_compilers
[] =
1393 /* Add lists of suffixes of known languages here. If those languages
1394 were not present when we built the driver, we will hit these copies
1395 and be given a more meaningful error than "file not used since
1396 linking is not done". */
1397 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0},
1398 {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
1399 {".mii", "#Objective-C++", 0, 0, 0},
1400 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
1401 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
1402 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
1403 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
1404 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
1405 {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
1406 {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
1407 {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
1408 {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
1409 {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
1410 {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
1411 {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
1412 {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
1413 {".r", "#Ratfor", 0, 0, 0},
1414 {".go", "#Go", 0, 1, 0},
1415 {".d", "#D", 0, 1, 0}, {".dd", "#D", 0, 1, 0}, {".di", "#D", 0, 1, 0},
1416 /* Next come the entries for C. */
1417 {".c", "@c", 0, 0, 1},
1419 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1420 external preprocessor if -save-temps is given. */
1421 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1424 %eGNU C no longer supports -traditional without -E}\
1425 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1426 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1427 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1429 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1430 cc1 %(cpp_unique_options) %(cc1_options)}}}\
1431 %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 1},
1433 "%{!E:%e-E or -x required when input is from standard input}\
1434 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
1435 {".h", "@c-header", 0, 0, 0},
1437 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1438 external preprocessor if -save-temps is given. */
1439 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1441 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1442 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1443 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1445 %{!fsyntax-only:%{!S:-o %g.s} \
1446 %{!fdump-ada-spec*:%{!o*:--output-pch %i.gch}\
1447 %W{o*:--output-pch %*}}%V}}\
1448 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1449 cc1 %(cpp_unique_options) %(cc1_options)\
1450 %{!fsyntax-only:%{!S:-o %g.s} \
1451 %{!fdump-ada-spec*:%{!o*:--output-pch %i.gch}\
1452 %W{o*:--output-pch %*}}%V}}}}}}}", 0, 0, 0},
1453 {".i", "@cpp-output", 0, 0, 0},
1455 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 0},
1456 {".s", "@assembler", 0, 0, 0},
1458 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 0, 0},
1459 {".sx", "@assembler-with-cpp", 0, 0, 0},
1460 {".S", "@assembler-with-cpp", 0, 0, 0},
1461 {"@assembler-with-cpp",
1462 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1463 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1464 %{E|M|MM:%(cpp_debug_options)}\
1465 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1466 as %(asm_debug) %(asm_options) %|.s %A }}}}"
1468 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1469 %{E|M|MM:%(cpp_debug_options)}\
1470 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1471 as %(asm_debug) %(asm_options) %m.s %A }}}}"
1476 /* Mark end of table. */
1480 /* Number of elements in default_compilers, not counting the terminator. */
1482 static const int n_default_compilers
= ARRAY_SIZE (default_compilers
) - 1;
1484 typedef char *char_p
; /* For DEF_VEC_P. */
1486 /* A vector of options to give to the linker.
1487 These options are accumulated by %x,
1488 and substituted into the linker command with %X. */
1489 static vec
<char_p
> linker_options
;
1491 /* A vector of options to give to the assembler.
1492 These options are accumulated by -Wa,
1493 and substituted into the assembler command with %Y. */
1494 static vec
<char_p
> assembler_options
;
1496 /* A vector of options to give to the preprocessor.
1497 These options are accumulated by -Wp,
1498 and substituted into the preprocessor command with %Z. */
1499 static vec
<char_p
> preprocessor_options
;
1502 skip_whitespace (char *p
)
1506 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1507 be considered whitespace. */
1508 if (p
[0] == '\n' && p
[1] == '\n' && p
[2] == '\n')
1510 else if (*p
== '\n' || *p
== ' ' || *p
== '\t')
1524 /* Structures to keep track of prefixes to try when looking for files. */
1528 const char *prefix
; /* String to prepend to the path. */
1529 struct prefix_list
*next
; /* Next in linked list. */
1530 int require_machine_suffix
; /* Don't use without machine_suffix. */
1531 /* 2 means try both machine_suffix and just_machine_suffix. */
1532 int priority
; /* Sort key - priority within list. */
1533 int os_multilib
; /* 1 if OS multilib scheme should be used,
1534 0 for GCC multilib scheme. */
1539 struct prefix_list
*plist
; /* List of prefixes to try */
1540 int max_len
; /* Max length of a prefix in PLIST */
1541 const char *name
; /* Name of this list (used in config stuff) */
1544 /* List of prefixes to try when looking for executables. */
1546 static struct path_prefix exec_prefixes
= { 0, 0, "exec" };
1548 /* List of prefixes to try when looking for startup (crt0) files. */
1550 static struct path_prefix startfile_prefixes
= { 0, 0, "startfile" };
1552 /* List of prefixes to try when looking for include files. */
1554 static struct path_prefix include_prefixes
= { 0, 0, "include" };
1556 /* Suffix to attach to directories searched for commands.
1557 This looks like `MACHINE/VERSION/'. */
1559 static const char *machine_suffix
= 0;
1561 /* Suffix to attach to directories searched for commands.
1562 This is just `MACHINE/'. */
1564 static const char *just_machine_suffix
= 0;
1566 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1568 static const char *gcc_exec_prefix
;
1570 /* Adjusted value of standard_libexec_prefix. */
1572 static const char *gcc_libexec_prefix
;
1574 /* Default prefixes to attach to command names. */
1576 #ifndef STANDARD_STARTFILE_PREFIX_1
1577 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1579 #ifndef STANDARD_STARTFILE_PREFIX_2
1580 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1583 #ifdef CROSS_DIRECTORY_STRUCTURE /* Don't use these prefixes for a cross compiler. */
1584 #undef MD_EXEC_PREFIX
1585 #undef MD_STARTFILE_PREFIX
1586 #undef MD_STARTFILE_PREFIX_1
1589 /* If no prefixes defined, use the null string, which will disable them. */
1590 #ifndef MD_EXEC_PREFIX
1591 #define MD_EXEC_PREFIX ""
1593 #ifndef MD_STARTFILE_PREFIX
1594 #define MD_STARTFILE_PREFIX ""
1596 #ifndef MD_STARTFILE_PREFIX_1
1597 #define MD_STARTFILE_PREFIX_1 ""
1600 /* These directories are locations set at configure-time based on the
1601 --prefix option provided to configure. Their initializers are
1602 defined in Makefile.in. These paths are not *directly* used when
1603 gcc_exec_prefix is set because, in that case, we know where the
1604 compiler has been installed, and use paths relative to that
1605 location instead. */
1606 static const char *const standard_exec_prefix
= STANDARD_EXEC_PREFIX
;
1607 static const char *const standard_libexec_prefix
= STANDARD_LIBEXEC_PREFIX
;
1608 static const char *const standard_bindir_prefix
= STANDARD_BINDIR_PREFIX
;
1609 static const char *const standard_startfile_prefix
= STANDARD_STARTFILE_PREFIX
;
1611 /* For native compilers, these are well-known paths containing
1612 components that may be provided by the system. For cross
1613 compilers, these paths are not used. */
1614 static const char *md_exec_prefix
= MD_EXEC_PREFIX
;
1615 static const char *md_startfile_prefix
= MD_STARTFILE_PREFIX
;
1616 static const char *md_startfile_prefix_1
= MD_STARTFILE_PREFIX_1
;
1617 static const char *const standard_startfile_prefix_1
1618 = STANDARD_STARTFILE_PREFIX_1
;
1619 static const char *const standard_startfile_prefix_2
1620 = STANDARD_STARTFILE_PREFIX_2
;
1622 /* A relative path to be used in finding the location of tools
1623 relative to the driver. */
1624 static const char *const tooldir_base_prefix
= TOOLDIR_BASE_PREFIX
;
1626 /* A prefix to be used when this is an accelerator compiler. */
1627 static const char *const accel_dir_suffix
= ACCEL_DIR_SUFFIX
;
1629 /* Subdirectory to use for locating libraries. Set by
1630 set_multilib_dir based on the compilation options. */
1632 static const char *multilib_dir
;
1634 /* Subdirectory to use for locating libraries in OS conventions. Set by
1635 set_multilib_dir based on the compilation options. */
1637 static const char *multilib_os_dir
;
1639 /* Subdirectory to use for locating libraries in multiarch conventions. Set by
1640 set_multilib_dir based on the compilation options. */
1642 static const char *multiarch_dir
;
1644 /* Structure to keep track of the specs that have been defined so far.
1645 These are accessed using %(specname) in a compiler or link
1650 /* The following 2 fields must be first */
1651 /* to allow EXTRA_SPECS to be initialized */
1652 const char *name
; /* name of the spec. */
1653 const char *ptr
; /* available ptr if no static pointer */
1655 /* The following fields are not initialized */
1656 /* by EXTRA_SPECS */
1657 const char **ptr_spec
; /* pointer to the spec itself. */
1658 struct spec_list
*next
; /* Next spec in linked list. */
1659 int name_len
; /* length of the name */
1660 bool user_p
; /* whether string come from file spec. */
1661 bool alloc_p
; /* whether string was allocated */
1662 const char *default_ptr
; /* The default value of *ptr_spec. */
1665 #define INIT_STATIC_SPEC(NAME,PTR) \
1666 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, false, false, \
1669 /* List of statically defined specs. */
1670 static struct spec_list static_specs
[] =
1672 INIT_STATIC_SPEC ("asm", &asm_spec
),
1673 INIT_STATIC_SPEC ("asm_debug", &asm_debug
),
1674 INIT_STATIC_SPEC ("asm_debug_option", &asm_debug_option
),
1675 INIT_STATIC_SPEC ("asm_final", &asm_final_spec
),
1676 INIT_STATIC_SPEC ("asm_options", &asm_options
),
1677 INIT_STATIC_SPEC ("invoke_as", &invoke_as
),
1678 INIT_STATIC_SPEC ("cpp", &cpp_spec
),
1679 INIT_STATIC_SPEC ("cpp_options", &cpp_options
),
1680 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options
),
1681 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options
),
1682 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp
),
1683 INIT_STATIC_SPEC ("cc1", &cc1_spec
),
1684 INIT_STATIC_SPEC ("cc1_options", &cc1_options
),
1685 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec
),
1686 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec
),
1687 INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec
),
1688 INIT_STATIC_SPEC ("endfile", &endfile_spec
),
1689 INIT_STATIC_SPEC ("link", &link_spec
),
1690 INIT_STATIC_SPEC ("lib", &lib_spec
),
1691 INIT_STATIC_SPEC ("link_gomp", &link_gomp_spec
),
1692 INIT_STATIC_SPEC ("libgcc", &libgcc_spec
),
1693 INIT_STATIC_SPEC ("startfile", &startfile_spec
),
1694 INIT_STATIC_SPEC ("cross_compile", &cross_compile
),
1695 INIT_STATIC_SPEC ("version", &compiler_version
),
1696 INIT_STATIC_SPEC ("multilib", &multilib_select
),
1697 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults
),
1698 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra
),
1699 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches
),
1700 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions
),
1701 INIT_STATIC_SPEC ("multilib_options", &multilib_options
),
1702 INIT_STATIC_SPEC ("multilib_reuse", &multilib_reuse
),
1703 INIT_STATIC_SPEC ("linker", &linker_name_spec
),
1704 INIT_STATIC_SPEC ("linker_plugin_file", &linker_plugin_file_spec
),
1705 INIT_STATIC_SPEC ("lto_wrapper", <o_wrapper_spec
),
1706 INIT_STATIC_SPEC ("lto_gcc", <o_gcc_spec
),
1707 INIT_STATIC_SPEC ("post_link", &post_link_spec
),
1708 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec
),
1709 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix
),
1710 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix
),
1711 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1
),
1712 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec
),
1713 INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec
),
1714 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec
),
1715 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec
),
1716 INIT_STATIC_SPEC ("self_spec", &self_spec
),
1719 #ifdef EXTRA_SPECS /* additional specs needed */
1720 /* Structure to keep track of just the first two args of a spec_list.
1721 That is all that the EXTRA_SPECS macro gives us. */
1724 const char *const name
;
1725 const char *const ptr
;
1728 static const struct spec_list_1 extra_specs_1
[] = { EXTRA_SPECS
};
1729 static struct spec_list
*extra_specs
= (struct spec_list
*) 0;
1732 /* List of dynamically allocates specs that have been defined so far. */
1734 static struct spec_list
*specs
= (struct spec_list
*) 0;
1736 /* List of static spec functions. */
1738 static const struct spec_function static_spec_functions
[] =
1740 { "getenv", getenv_spec_function
},
1741 { "if-exists", if_exists_spec_function
},
1742 { "if-exists-else", if_exists_else_spec_function
},
1743 { "if-exists-then-else", if_exists_then_else_spec_function
},
1744 { "sanitize", sanitize_spec_function
},
1745 { "replace-outfile", replace_outfile_spec_function
},
1746 { "remove-outfile", remove_outfile_spec_function
},
1747 { "version-compare", version_compare_spec_function
},
1748 { "include", include_spec_function
},
1749 { "find-file", find_file_spec_function
},
1750 { "find-plugindir", find_plugindir_spec_function
},
1751 { "print-asm-header", print_asm_header_spec_function
},
1752 { "compare-debug-dump-opt", compare_debug_dump_opt_spec_function
},
1753 { "compare-debug-self-opt", compare_debug_self_opt_spec_function
},
1754 { "pass-through-libs", pass_through_libs_spec_func
},
1755 { "dumps", dumps_spec_func
},
1756 { "gt", greater_than_spec_func
},
1757 { "debug-level-gt", debug_level_greater_than_spec_func
},
1758 { "dwarf-version-gt", dwarf_version_greater_than_spec_func
},
1759 { "fortran-preinclude-file", find_fortran_preinclude_file
},
1760 #ifdef EXTRA_SPEC_FUNCTIONS
1761 EXTRA_SPEC_FUNCTIONS
1766 static int processing_spec_function
;
1768 /* Add appropriate libgcc specs to OBSTACK, taking into account
1769 various permutations of -shared-libgcc, -shared, and such. */
1771 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1773 #ifndef USE_LD_AS_NEEDED
1774 #define USE_LD_AS_NEEDED 0
1778 init_gcc_specs (struct obstack
*obstack
, const char *shared_name
,
1779 const char *static_name
, const char *eh_name
)
1783 #if USE_LD_AS_NEEDED
1784 buf
= concat ("%{static|static-libgcc|static-pie:", static_name
, " ", eh_name
, "}"
1785 "%{!static:%{!static-libgcc:%{!static-pie:"
1786 "%{!shared-libgcc:",
1787 static_name
, " " LD_AS_NEEDED_OPTION
" ",
1788 shared_name
, " " LD_NO_AS_NEEDED_OPTION
1791 shared_name
, "%{!shared: ", static_name
, "}"
1794 buf
= concat ("%{static|static-libgcc:", static_name
, " ", eh_name
, "}"
1795 "%{!static:%{!static-libgcc:"
1797 "%{!shared-libgcc:", static_name
, " ", eh_name
, "}"
1798 "%{shared-libgcc:", shared_name
, " ", static_name
, "}"
1802 "%{shared-libgcc:", shared_name
, "}"
1803 "%{!shared-libgcc:", static_name
, "}"
1806 "%{shared:", shared_name
, "}"
1811 obstack_grow (obstack
, buf
, strlen (buf
));
1814 #endif /* ENABLE_SHARED_LIBGCC */
1816 /* Initialize the specs lookup routines. */
1821 struct spec_list
*next
= (struct spec_list
*) 0;
1822 struct spec_list
*sl
= (struct spec_list
*) 0;
1826 return; /* Already initialized. */
1829 fnotice (stderr
, "Using built-in specs.\n");
1832 extra_specs
= XCNEWVEC (struct spec_list
, ARRAY_SIZE (extra_specs_1
));
1834 for (i
= ARRAY_SIZE (extra_specs_1
) - 1; i
>= 0; i
--)
1836 sl
= &extra_specs
[i
];
1837 sl
->name
= extra_specs_1
[i
].name
;
1838 sl
->ptr
= extra_specs_1
[i
].ptr
;
1840 sl
->name_len
= strlen (sl
->name
);
1841 sl
->ptr_spec
= &sl
->ptr
;
1842 gcc_assert (sl
->ptr_spec
!= NULL
);
1843 sl
->default_ptr
= sl
->ptr
;
1848 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1850 sl
= &static_specs
[i
];
1855 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1856 /* ??? If neither -shared-libgcc nor --static-libgcc was
1857 seen, then we should be making an educated guess. Some proposed
1858 heuristics for ELF include:
1860 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1861 program will be doing dynamic loading, which will likely
1862 need the shared libgcc.
1864 (2) If "-ldl", then it's also a fair bet that we're doing
1867 (3) For each ET_DYN we're linking against (either through -lfoo
1868 or /some/path/foo.so), check to see whether it or one of
1869 its dependencies depends on a shared libgcc.
1873 If the runtime is fixed to look for program headers instead
1874 of calling __register_frame_info at all, for each object,
1875 use the shared libgcc if any EH symbol referenced.
1877 If crtstuff is fixed to not invoke __register_frame_info
1878 automatically, for each object, use the shared libgcc if
1879 any non-empty unwind section found.
1881 Doing any of this probably requires invoking an external program to
1882 do the actual object file scanning. */
1884 const char *p
= libgcc_spec
;
1887 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1888 when given the proper command line arguments. */
1891 if (in_sep
&& *p
== '-' && startswith (p
, "-lgcc"))
1893 init_gcc_specs (&obstack
,
1895 #ifdef USE_LIBUNWIND_EXCEPTIONS
1901 #ifdef USE_LIBUNWIND_EXCEPTIONS
1902 # ifdef HAVE_LD_STATIC_DYNAMIC
1903 " %{!static:%{!static-pie:" LD_STATIC_OPTION
"}} -lunwind"
1904 " %{!static:%{!static-pie:" LD_DYNAMIC_OPTION
"}}"
1914 else if (in_sep
&& *p
== 'l' && startswith (p
, "libgcc.a%s"))
1916 /* Ug. We don't know shared library extensions. Hope that
1917 systems that use this form don't do shared libraries. */
1918 init_gcc_specs (&obstack
,
1922 #ifdef USE_LIBUNWIND_EXCEPTIONS
1931 obstack_1grow (&obstack
, *p
);
1932 in_sep
= (*p
== ' ');
1937 obstack_1grow (&obstack
, '\0');
1938 libgcc_spec
= XOBFINISH (&obstack
, const char *);
1941 #ifdef USE_AS_TRADITIONAL_FORMAT
1942 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1944 static const char tf
[] = "--traditional-format ";
1945 obstack_grow (&obstack
, tf
, sizeof (tf
) - 1);
1946 obstack_grow0 (&obstack
, asm_spec
, strlen (asm_spec
));
1947 asm_spec
= XOBFINISH (&obstack
, const char *);
1951 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC || \
1952 defined LINKER_HASH_STYLE
1953 # ifdef LINK_BUILDID_SPEC
1954 /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. */
1955 obstack_grow (&obstack
, LINK_BUILDID_SPEC
, sizeof (LINK_BUILDID_SPEC
) - 1);
1957 # ifdef LINK_EH_SPEC
1958 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1959 obstack_grow (&obstack
, LINK_EH_SPEC
, sizeof (LINK_EH_SPEC
) - 1);
1961 # ifdef LINKER_HASH_STYLE
1962 /* Prepend --hash-style=LINKER_HASH_STYLE to whatever link_spec we had
1965 static const char hash_style
[] = "--hash-style=";
1966 obstack_grow (&obstack
, hash_style
, sizeof (hash_style
) - 1);
1967 obstack_grow (&obstack
, LINKER_HASH_STYLE
, sizeof (LINKER_HASH_STYLE
) - 1);
1968 obstack_1grow (&obstack
, ' ');
1971 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
1972 link_spec
= XOBFINISH (&obstack
, const char *);
1978 /* Update the entry for SPEC in the static_specs table to point to VALUE,
1979 ensuring that we free the previous value if necessary. Set alloc_p for the
1980 entry to ALLOC_P: this determines whether we take ownership of VALUE (i.e.
1981 whether we need to free it later on). */
1983 set_static_spec (const char **spec
, const char *value
, bool alloc_p
)
1985 struct spec_list
*sl
= NULL
;
1987 for (unsigned i
= 0; i
< ARRAY_SIZE (static_specs
); i
++)
1989 if (static_specs
[i
].ptr_spec
== spec
)
1991 sl
= static_specs
+ i
;
2000 const char *old
= *spec
;
2001 free (const_cast <char *> (old
));
2005 sl
->alloc_p
= alloc_p
;
2008 /* Update a static spec to a new string, taking ownership of that
2010 static void set_static_spec_owned (const char **spec
, const char *val
)
2012 return set_static_spec (spec
, val
, true);
2015 /* Update a static spec to point to a new value, but don't take
2016 ownership of (i.e. don't free) that string. */
2017 static void set_static_spec_shared (const char **spec
, const char *val
)
2019 return set_static_spec (spec
, val
, false);
2023 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
2024 removed; If the spec starts with a + then SPEC is added to the end of the
2028 set_spec (const char *name
, const char *spec
, bool user_p
)
2030 struct spec_list
*sl
;
2031 const char *old_spec
;
2032 int name_len
= strlen (name
);
2035 /* If this is the first call, initialize the statically allocated specs. */
2038 struct spec_list
*next
= (struct spec_list
*) 0;
2039 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
2041 sl
= &static_specs
[i
];
2048 /* See if the spec already exists. */
2049 for (sl
= specs
; sl
; sl
= sl
->next
)
2050 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, name
))
2055 /* Not found - make it. */
2056 sl
= XNEW (struct spec_list
);
2057 sl
->name
= xstrdup (name
);
2058 sl
->name_len
= name_len
;
2059 sl
->ptr_spec
= &sl
->ptr
;
2061 *(sl
->ptr_spec
) = "";
2063 sl
->default_ptr
= NULL
;
2067 old_spec
= *(sl
->ptr_spec
);
2068 *(sl
->ptr_spec
) = ((spec
[0] == '+' && ISSPACE ((unsigned char)spec
[1]))
2069 ? concat (old_spec
, spec
+ 1, NULL
)
2074 fnotice (stderr
, "Setting spec %s to '%s'\n\n", name
, *(sl
->ptr_spec
));
2077 /* Free the old spec. */
2078 if (old_spec
&& sl
->alloc_p
)
2079 free (CONST_CAST (char *, old_spec
));
2081 sl
->user_p
= user_p
;
2085 /* Accumulate a command (program name and args), and run it. */
2087 typedef const char *const_char_p
; /* For DEF_VEC_P. */
2089 /* Vector of pointers to arguments in the current line of specifications. */
2090 static vec
<const_char_p
> argbuf
;
2092 /* Likewise, but for the current @file. */
2093 static vec
<const_char_p
> at_file_argbuf
;
2095 /* Whether an @file is currently open. */
2096 static bool in_at_file
= false;
2098 /* Were the options -c, -S or -E passed. */
2099 static int have_c
= 0;
2101 /* Was the option -o passed. */
2102 static int have_o
= 0;
2104 /* Was the option -E passed. */
2105 static int have_E
= 0;
2107 /* Pointer to output file name passed in with -o. */
2108 static const char *output_file
= 0;
2110 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
2111 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
2114 static struct temp_name
{
2115 const char *suffix
; /* suffix associated with the code. */
2116 int length
; /* strlen (suffix). */
2117 int unique
; /* Indicates whether %g or %u/%U was used. */
2118 const char *filename
; /* associated filename. */
2119 int filename_length
; /* strlen (filename). */
2120 struct temp_name
*next
;
2123 /* Number of commands executed so far. */
2125 static int execution_count
;
2127 /* Number of commands that exited with a signal. */
2129 static int signal_count
;
2131 /* Allocate the argument vector. */
2137 at_file_argbuf
.create (10);
2140 /* Clear out the vector of arguments (after a command is executed). */
2145 argbuf
.truncate (0);
2146 at_file_argbuf
.truncate (0);
2149 /* Add one argument to the vector at the end.
2150 This is done when a space is seen or at the end of the line.
2151 If DELETE_ALWAYS is nonzero, the arg is a filename
2152 and the file should be deleted eventually.
2153 If DELETE_FAILURE is nonzero, the arg is a filename
2154 and the file should be deleted if this compilation fails. */
2157 store_arg (const char *arg
, int delete_always
, int delete_failure
)
2160 at_file_argbuf
.safe_push (arg
);
2162 argbuf
.safe_push (arg
);
2164 if (delete_always
|| delete_failure
)
2167 /* If the temporary file we should delete is specified as
2168 part of a joined argument extract the filename. */
2170 && (p
= strrchr (arg
, '=')))
2172 record_temp_file (arg
, delete_always
, delete_failure
);
2176 /* Open a temporary @file into which subsequent arguments will be stored. */
2182 fatal_error (input_location
, "cannot open nested response file");
2187 /* Create a temporary @file name. */
2189 static char *make_at_file (void)
2191 static int fileno
= 0;
2193 const char *base
, *ext
;
2195 if (!save_temps_flag
)
2196 return make_temp_file ("");
2199 if (!(base
&& *base
))
2201 if (!(base
&& *base
))
2204 sprintf (filename
, ".args.%d", fileno
++);
2207 if (base
== dumpdir
&& dumpdir_trailing_dash_added
)
2210 return concat (base
, ext
, NULL
);
2213 /* Close the temporary @file and add @file to the argument list. */
2216 close_at_file (void)
2219 fatal_error (input_location
, "cannot close nonexistent response file");
2223 const unsigned int n_args
= at_file_argbuf
.length ();
2227 char **argv
= XALLOCAVEC (char *, n_args
+ 1);
2228 char *temp_file
= make_at_file ();
2229 char *at_argument
= concat ("@", temp_file
, NULL
);
2230 FILE *f
= fopen (temp_file
, "w");
2234 /* Copy the strings over. */
2235 for (i
= 0; i
< n_args
; i
++)
2236 argv
[i
] = CONST_CAST (char *, at_file_argbuf
[i
]);
2239 at_file_argbuf
.truncate (0);
2242 fatal_error (input_location
, "could not open temporary response file %s",
2245 status
= writeargv (argv
, f
);
2248 fatal_error (input_location
,
2249 "could not write to temporary response file %s",
2252 status
= fclose (f
);
2255 fatal_error (input_location
, "could not close temporary response file %s",
2258 store_arg (at_argument
, 0, 0);
2260 record_temp_file (temp_file
, !save_temps_flag
, !save_temps_flag
);
2263 /* Load specs from a file name named FILENAME, replacing occurrences of
2264 various different types of line-endings, \r\n, \n\r and just \r, with
2268 load_specs (const char *filename
)
2272 struct stat statbuf
;
2279 fnotice (stderr
, "Reading specs from %s\n", filename
);
2281 /* Open and stat the file. */
2282 desc
= open (filename
, O_RDONLY
, 0);
2286 /* This leaves DESC open, but the OS will save us. */
2287 fatal_error (input_location
, "cannot read spec file %qs: %m", filename
);
2290 if (stat (filename
, &statbuf
) < 0)
2293 /* Read contents of file into BUFFER. */
2294 buffer
= XNEWVEC (char, statbuf
.st_size
+ 1);
2295 readlen
= read (desc
, buffer
, (unsigned) statbuf
.st_size
);
2298 buffer
[readlen
] = 0;
2301 specs
= XNEWVEC (char, readlen
+ 1);
2303 for (buffer_p
= buffer
; buffer_p
&& *buffer_p
; buffer_p
++)
2309 if (buffer_p
> buffer
&& *(buffer_p
- 1) == '\n') /* \n\r */
2311 else if (*(buffer_p
+ 1) == '\n') /* \r\n */
2325 /* Read compilation specs from a file named FILENAME,
2326 replacing the default ones.
2328 A suffix which starts with `*' is a definition for
2329 one of the machine-specific sub-specs. The "suffix" should be
2330 *asm, *cc1, *cpp, *link, *startfile, etc.
2331 The corresponding spec is stored in asm_spec, etc.,
2332 rather than in the `compilers' vector.
2334 Anything invalid in the file is a fatal error. */
2337 read_specs (const char *filename
, bool main_p
, bool user_p
)
2342 buffer
= load_specs (filename
);
2344 /* Scan BUFFER for specs, putting them in the vector. */
2350 char *in
, *out
, *p1
, *p2
, *p3
;
2352 /* Advance P in BUFFER to the next nonblank nocomment line. */
2353 p
= skip_whitespace (p
);
2357 /* Is this a special command that starts with '%'? */
2358 /* Don't allow this for the main specs file, since it would
2359 encourage people to overwrite it. */
2360 if (*p
== '%' && !main_p
)
2363 while (*p
&& *p
!= '\n')
2369 if (startswith (p1
, "%include")
2370 && (p1
[sizeof "%include" - 1] == ' '
2371 || p1
[sizeof "%include" - 1] == '\t'))
2375 p1
+= sizeof ("%include");
2376 while (*p1
== ' ' || *p1
== '\t')
2379 if (*p1
++ != '<' || p
[-2] != '>')
2380 fatal_error (input_location
,
2381 "specs %%include syntax malformed after "
2383 (long) (p1
- buffer
+ 1));
2386 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
2387 read_specs (new_filename
? new_filename
: p1
, false, user_p
);
2390 else if (startswith (p1
, "%include_noerr")
2391 && (p1
[sizeof "%include_noerr" - 1] == ' '
2392 || p1
[sizeof "%include_noerr" - 1] == '\t'))
2396 p1
+= sizeof "%include_noerr";
2397 while (*p1
== ' ' || *p1
== '\t')
2400 if (*p1
++ != '<' || p
[-2] != '>')
2401 fatal_error (input_location
,
2402 "specs %%include syntax malformed after "
2404 (long) (p1
- buffer
+ 1));
2407 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
2409 read_specs (new_filename
, false, user_p
);
2410 else if (verbose_flag
)
2411 fnotice (stderr
, "could not find specs file %s\n", p1
);
2414 else if (startswith (p1
, "%rename")
2415 && (p1
[sizeof "%rename" - 1] == ' '
2416 || p1
[sizeof "%rename" - 1] == '\t'))
2419 struct spec_list
*sl
;
2420 struct spec_list
*newsl
;
2422 /* Get original name. */
2423 p1
+= sizeof "%rename";
2424 while (*p1
== ' ' || *p1
== '\t')
2427 if (! ISALPHA ((unsigned char) *p1
))
2428 fatal_error (input_location
,
2429 "specs %%rename syntax malformed after "
2431 (long) (p1
- buffer
));
2434 while (*p2
&& !ISSPACE ((unsigned char) *p2
))
2437 if (*p2
!= ' ' && *p2
!= '\t')
2438 fatal_error (input_location
,
2439 "specs %%rename syntax malformed after "
2441 (long) (p2
- buffer
));
2445 while (*p2
== ' ' || *p2
== '\t')
2448 if (! ISALPHA ((unsigned char) *p2
))
2449 fatal_error (input_location
,
2450 "specs %%rename syntax malformed after "
2452 (long) (p2
- buffer
));
2454 /* Get new spec name. */
2456 while (*p3
&& !ISSPACE ((unsigned char) *p3
))
2460 fatal_error (input_location
,
2461 "specs %%rename syntax malformed after "
2463 (long) (p3
- buffer
));
2466 for (sl
= specs
; sl
; sl
= sl
->next
)
2467 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, p1
))
2471 fatal_error (input_location
,
2472 "specs %s spec was not found to be renamed", p1
);
2474 if (strcmp (p1
, p2
) == 0)
2477 for (newsl
= specs
; newsl
; newsl
= newsl
->next
)
2478 if (strcmp (newsl
->name
, p2
) == 0)
2479 fatal_error (input_location
,
2480 "%s: attempt to rename spec %qs to "
2481 "already defined spec %qs",
2486 fnotice (stderr
, "rename spec %s to %s\n", p1
, p2
);
2488 fnotice (stderr
, "spec is '%s'\n\n", *(sl
->ptr_spec
));
2492 set_spec (p2
, *(sl
->ptr_spec
), user_p
);
2494 free (CONST_CAST (char *, *(sl
->ptr_spec
)));
2496 *(sl
->ptr_spec
) = "";
2501 fatal_error (input_location
,
2502 "specs unknown %% command after %ld characters",
2503 (long) (p1
- buffer
));
2506 /* Find the colon that should end the suffix. */
2508 while (*p1
&& *p1
!= ':' && *p1
!= '\n')
2511 /* The colon shouldn't be missing. */
2513 fatal_error (input_location
,
2514 "specs file malformed after %ld characters",
2515 (long) (p1
- buffer
));
2517 /* Skip back over trailing whitespace. */
2519 while (p2
> buffer
&& (p2
[-1] == ' ' || p2
[-1] == '\t'))
2522 /* Copy the suffix to a string. */
2523 suffix
= save_string (p
, p2
- p
);
2524 /* Find the next line. */
2525 p
= skip_whitespace (p1
+ 1);
2527 fatal_error (input_location
,
2528 "specs file malformed after %ld characters",
2529 (long) (p
- buffer
));
2532 /* Find next blank line or end of string. */
2533 while (*p1
&& !(*p1
== '\n' && (p1
[1] == '\n' || p1
[1] == '\0')))
2536 /* Specs end at the blank line and do not include the newline. */
2537 spec
= save_string (p
, p1
- p
);
2540 /* Delete backslash-newline sequences from the spec. */
2545 if (in
[0] == '\\' && in
[1] == '\n')
2547 else if (in
[0] == '#')
2548 while (*in
&& *in
!= '\n')
2556 if (suffix
[0] == '*')
2558 if (! strcmp (suffix
, "*link_command"))
2559 link_command_spec
= spec
;
2562 set_spec (suffix
+ 1, spec
, user_p
);
2568 /* Add this pair to the vector. */
2570 = XRESIZEVEC (struct compiler
, compilers
, n_compilers
+ 2);
2572 compilers
[n_compilers
].suffix
= suffix
;
2573 compilers
[n_compilers
].spec
= spec
;
2575 memset (&compilers
[n_compilers
], 0, sizeof compilers
[n_compilers
]);
2579 link_command_spec
= spec
;
2582 if (link_command_spec
== 0)
2583 fatal_error (input_location
, "spec file has no spec for linking");
2585 XDELETEVEC (buffer
);
2588 /* Record the names of temporary files we tell compilers to write,
2589 and delete them at the end of the run. */
2591 /* This is the common prefix we use to make temp file names.
2592 It is chosen once for each run of this program.
2593 It is substituted into a spec by %g or %j.
2594 Thus, all temp file names contain this prefix.
2595 In practice, all temp file names start with this prefix.
2597 This prefix comes from the envvar TMPDIR if it is defined;
2598 otherwise, from the P_tmpdir macro if that is defined;
2599 otherwise, in /usr/tmp or /tmp;
2600 or finally the current directory if all else fails. */
2602 static const char *temp_filename
;
2604 /* Length of the prefix. */
2606 static int temp_filename_length
;
2608 /* Define the list of temporary files to delete. */
2613 struct temp_file
*next
;
2616 /* Queue of files to delete on success or failure of compilation. */
2617 static struct temp_file
*always_delete_queue
;
2618 /* Queue of files to delete on failure of compilation. */
2619 static struct temp_file
*failure_delete_queue
;
2621 /* Record FILENAME as a file to be deleted automatically.
2622 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2623 otherwise delete it in any case.
2624 FAIL_DELETE nonzero means delete it if a compilation step fails;
2625 otherwise delete it in any case. */
2628 record_temp_file (const char *filename
, int always_delete
, int fail_delete
)
2630 char *const name
= xstrdup (filename
);
2634 struct temp_file
*temp
;
2635 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2636 if (! filename_cmp (name
, temp
->name
))
2642 temp
= XNEW (struct temp_file
);
2643 temp
->next
= always_delete_queue
;
2645 always_delete_queue
= temp
;
2652 struct temp_file
*temp
;
2653 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2654 if (! filename_cmp (name
, temp
->name
))
2660 temp
= XNEW (struct temp_file
);
2661 temp
->next
= failure_delete_queue
;
2663 failure_delete_queue
= temp
;
2669 /* Delete all the temporary files whose names we previously recorded. */
2671 #ifndef DELETE_IF_ORDINARY
2672 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2675 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2676 if (unlink (NAME) < 0) \
2678 error ("%s: %m", (NAME)); \
2683 delete_if_ordinary (const char *name
)
2689 printf ("Delete %s? (y or n) ", name
);
2693 while ((c
= getchar ()) != '\n' && c
!= EOF
)
2696 if (i
== 'y' || i
== 'Y')
2698 DELETE_IF_ORDINARY (name
, st
, verbose_flag
);
2702 delete_temp_files (void)
2704 struct temp_file
*temp
;
2706 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2707 delete_if_ordinary (temp
->name
);
2708 always_delete_queue
= 0;
2711 /* Delete all the files to be deleted on error. */
2714 delete_failure_queue (void)
2716 struct temp_file
*temp
;
2718 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2719 delete_if_ordinary (temp
->name
);
2723 clear_failure_queue (void)
2725 failure_delete_queue
= 0;
2728 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2730 If DO_MULTI is true iterate over the paths twice, first with multilib
2731 suffix then without, otherwise iterate over the paths once without
2732 adding a multilib suffix. When DO_MULTI is true, some attempt is made
2733 to avoid visiting the same path twice, but we could do better. For
2734 instance, /usr/lib/../lib is considered different from /usr/lib.
2735 At least EXTRA_SPACE chars past the end of the path passed to
2736 CALLBACK are available for use by the callback.
2737 CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2739 Returns the value returned by CALLBACK. */
2742 for_each_path (const struct path_prefix
*paths
,
2745 void *(*callback
) (char *, void *),
2746 void *callback_info
)
2748 struct prefix_list
*pl
;
2749 const char *multi_dir
= NULL
;
2750 const char *multi_os_dir
= NULL
;
2751 const char *multiarch_suffix
= NULL
;
2752 const char *multi_suffix
;
2753 const char *just_multi_suffix
;
2756 bool skip_multi_dir
= false;
2757 bool skip_multi_os_dir
= false;
2759 multi_suffix
= machine_suffix
;
2760 just_multi_suffix
= just_machine_suffix
;
2761 if (do_multi
&& multilib_dir
&& strcmp (multilib_dir
, ".") != 0)
2763 multi_dir
= concat (multilib_dir
, dir_separator_str
, NULL
);
2764 multi_suffix
= concat (multi_suffix
, multi_dir
, NULL
);
2765 just_multi_suffix
= concat (just_multi_suffix
, multi_dir
, NULL
);
2767 if (do_multi
&& multilib_os_dir
&& strcmp (multilib_os_dir
, ".") != 0)
2768 multi_os_dir
= concat (multilib_os_dir
, dir_separator_str
, NULL
);
2770 multiarch_suffix
= concat (multiarch_dir
, dir_separator_str
, NULL
);
2774 size_t multi_dir_len
= 0;
2775 size_t multi_os_dir_len
= 0;
2776 size_t multiarch_len
= 0;
2778 size_t just_suffix_len
;
2782 multi_dir_len
= strlen (multi_dir
);
2784 multi_os_dir_len
= strlen (multi_os_dir
);
2785 if (multiarch_suffix
)
2786 multiarch_len
= strlen (multiarch_suffix
);
2787 suffix_len
= strlen (multi_suffix
);
2788 just_suffix_len
= strlen (just_multi_suffix
);
2792 len
= paths
->max_len
+ extra_space
+ 1;
2793 len
+= MAX (MAX (suffix_len
, multi_os_dir_len
), multiarch_len
);
2794 path
= XNEWVEC (char, len
);
2797 for (pl
= paths
->plist
; pl
!= 0; pl
= pl
->next
)
2799 len
= strlen (pl
->prefix
);
2800 memcpy (path
, pl
->prefix
, len
);
2802 /* Look first in MACHINE/VERSION subdirectory. */
2803 if (!skip_multi_dir
)
2805 memcpy (path
+ len
, multi_suffix
, suffix_len
+ 1);
2806 ret
= callback (path
, callback_info
);
2811 /* Some paths are tried with just the machine (ie. target)
2812 subdir. This is used for finding as, ld, etc. */
2814 && pl
->require_machine_suffix
== 2)
2816 memcpy (path
+ len
, just_multi_suffix
, just_suffix_len
+ 1);
2817 ret
= callback (path
, callback_info
);
2822 /* Now try the multiarch path. */
2824 && !pl
->require_machine_suffix
&& multiarch_dir
)
2826 memcpy (path
+ len
, multiarch_suffix
, multiarch_len
+ 1);
2827 ret
= callback (path
, callback_info
);
2832 /* Now try the base path. */
2833 if (!pl
->require_machine_suffix
2834 && !(pl
->os_multilib
? skip_multi_os_dir
: skip_multi_dir
))
2836 const char *this_multi
;
2837 size_t this_multi_len
;
2839 if (pl
->os_multilib
)
2841 this_multi
= multi_os_dir
;
2842 this_multi_len
= multi_os_dir_len
;
2846 this_multi
= multi_dir
;
2847 this_multi_len
= multi_dir_len
;
2851 memcpy (path
+ len
, this_multi
, this_multi_len
+ 1);
2855 ret
= callback (path
, callback_info
);
2863 if (multi_dir
== NULL
&& multi_os_dir
== NULL
)
2866 /* Run through the paths again, this time without multilibs.
2867 Don't repeat any we have already seen. */
2870 free (CONST_CAST (char *, multi_dir
));
2872 free (CONST_CAST (char *, multi_suffix
));
2873 multi_suffix
= machine_suffix
;
2874 free (CONST_CAST (char *, just_multi_suffix
));
2875 just_multi_suffix
= just_machine_suffix
;
2878 skip_multi_dir
= true;
2881 free (CONST_CAST (char *, multi_os_dir
));
2882 multi_os_dir
= NULL
;
2885 skip_multi_os_dir
= true;
2890 free (CONST_CAST (char *, multi_dir
));
2891 free (CONST_CAST (char *, multi_suffix
));
2892 free (CONST_CAST (char *, just_multi_suffix
));
2895 free (CONST_CAST (char *, multi_os_dir
));
2901 /* Callback for build_search_list. Adds path to obstack being built. */
2903 struct add_to_obstack_info
{
2910 add_to_obstack (char *path
, void *data
)
2912 struct add_to_obstack_info
*info
= (struct add_to_obstack_info
*) data
;
2914 if (info
->check_dir
&& !is_directory (path
, false))
2917 if (!info
->first_time
)
2918 obstack_1grow (info
->ob
, PATH_SEPARATOR
);
2920 obstack_grow (info
->ob
, path
, strlen (path
));
2922 info
->first_time
= false;
2926 /* Add or change the value of an environment variable, outputting the
2927 change to standard error if in verbose mode. */
2929 xputenv (const char *string
)
2934 /* Build a list of search directories from PATHS.
2935 PREFIX is a string to prepend to the list.
2936 If CHECK_DIR_P is true we ensure the directory exists.
2937 If DO_MULTI is true, multilib paths are output first, then
2939 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2940 It is also used by the --print-search-dirs flag. */
2943 build_search_list (const struct path_prefix
*paths
, const char *prefix
,
2944 bool check_dir
, bool do_multi
)
2946 struct add_to_obstack_info info
;
2948 info
.ob
= &collect_obstack
;
2949 info
.check_dir
= check_dir
;
2950 info
.first_time
= true;
2952 obstack_grow (&collect_obstack
, prefix
, strlen (prefix
));
2953 obstack_1grow (&collect_obstack
, '=');
2955 for_each_path (paths
, do_multi
, 0, add_to_obstack
, &info
);
2957 obstack_1grow (&collect_obstack
, '\0');
2958 return XOBFINISH (&collect_obstack
, char *);
2961 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2965 putenv_from_prefixes (const struct path_prefix
*paths
, const char *env_var
,
2968 xputenv (build_search_list (paths
, env_var
, true, do_multi
));
2971 /* Check whether NAME can be accessed in MODE. This is like access,
2972 except that it never considers directories to be executable. */
2975 access_check (const char *name
, int mode
)
2981 if (stat (name
, &st
) < 0
2982 || S_ISDIR (st
.st_mode
))
2986 return access (name
, mode
);
2989 /* Callback for find_a_file. Appends the file name to the directory
2990 path. If the resulting file exists in the right mode, return the
2991 full pathname to the file. */
2993 struct file_at_path_info
{
3002 file_at_path (char *path
, void *data
)
3004 struct file_at_path_info
*info
= (struct file_at_path_info
*) data
;
3005 size_t len
= strlen (path
);
3007 memcpy (path
+ len
, info
->name
, info
->name_len
);
3008 len
+= info
->name_len
;
3010 /* Some systems have a suffix for executable files.
3011 So try appending that first. */
3012 if (info
->suffix_len
)
3014 memcpy (path
+ len
, info
->suffix
, info
->suffix_len
+ 1);
3015 if (access_check (path
, info
->mode
) == 0)
3020 if (access_check (path
, info
->mode
) == 0)
3026 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
3027 access to check permissions. If DO_MULTI is true, search multilib
3028 paths then non-multilib paths, otherwise do not search multilib paths.
3029 Return 0 if not found, otherwise return its name, allocated with malloc. */
3032 find_a_file (const struct path_prefix
*pprefix
, const char *name
, int mode
,
3035 struct file_at_path_info info
;
3037 /* Find the filename in question (special case for absolute paths). */
3039 if (IS_ABSOLUTE_PATH (name
))
3041 if (access (name
, mode
) == 0)
3042 return xstrdup (name
);
3048 info
.suffix
= (mode
& X_OK
) != 0 ? HOST_EXECUTABLE_SUFFIX
: "";
3049 info
.name_len
= strlen (info
.name
);
3050 info
.suffix_len
= strlen (info
.suffix
);
3053 return (char*) for_each_path (pprefix
, do_multi
,
3054 info
.name_len
+ info
.suffix_len
,
3055 file_at_path
, &info
);
3058 /* Specialization of find_a_file for programs that also takes into account
3059 configure-specified default programs. */
3062 find_a_program (const char *name
)
3064 /* Do not search if default matches query. */
3066 #ifdef DEFAULT_ASSEMBLER
3067 if (! strcmp (name
, "as") && access (DEFAULT_ASSEMBLER
, X_OK
) == 0)
3068 return xstrdup (DEFAULT_ASSEMBLER
);
3071 #ifdef DEFAULT_LINKER
3072 if (! strcmp (name
, "ld") && access (DEFAULT_LINKER
, X_OK
) == 0)
3073 return xstrdup (DEFAULT_LINKER
);
3076 #ifdef DEFAULT_DSYMUTIL
3077 if (! strcmp (name
, "dsymutil") && access (DEFAULT_DSYMUTIL
, X_OK
) == 0)
3078 return xstrdup (DEFAULT_DSYMUTIL
);
3081 return find_a_file (&exec_prefixes
, name
, X_OK
, false);
3084 /* Ranking of prefixes in the sort list. -B prefixes are put before
3087 enum path_prefix_priority
3089 PREFIX_PRIORITY_B_OPT
,
3090 PREFIX_PRIORITY_LAST
3093 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
3094 order according to PRIORITY. Within each PRIORITY, new entries are
3097 If WARN is nonzero, we will warn if no file is found
3098 through this prefix. WARN should point to an int
3099 which will be set to 1 if this entry is used.
3101 COMPONENT is the value to be passed to update_path.
3103 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
3104 the complete value of machine_suffix.
3105 2 means try both machine_suffix and just_machine_suffix. */
3108 add_prefix (struct path_prefix
*pprefix
, const char *prefix
,
3109 const char *component
, /* enum prefix_priority */ int priority
,
3110 int require_machine_suffix
, int os_multilib
)
3112 struct prefix_list
*pl
, **prev
;
3115 for (prev
= &pprefix
->plist
;
3116 (*prev
) != NULL
&& (*prev
)->priority
<= priority
;
3117 prev
= &(*prev
)->next
)
3120 /* Keep track of the longest prefix. */
3122 prefix
= update_path (prefix
, component
);
3123 len
= strlen (prefix
);
3124 if (len
> pprefix
->max_len
)
3125 pprefix
->max_len
= len
;
3127 pl
= XNEW (struct prefix_list
);
3128 pl
->prefix
= prefix
;
3129 pl
->require_machine_suffix
= require_machine_suffix
;
3130 pl
->priority
= priority
;
3131 pl
->os_multilib
= os_multilib
;
3133 /* Insert after PREV. */
3138 /* Same as add_prefix, but prepending target_system_root to prefix. */
3139 /* The target_system_root prefix has been relocated by gcc_exec_prefix. */
3141 add_sysrooted_prefix (struct path_prefix
*pprefix
, const char *prefix
,
3142 const char *component
,
3143 /* enum prefix_priority */ int priority
,
3144 int require_machine_suffix
, int os_multilib
)
3146 if (!IS_ABSOLUTE_PATH (prefix
))
3147 fatal_error (input_location
, "system path %qs is not absolute", prefix
);
3149 if (target_system_root
)
3151 char *sysroot_no_trailing_dir_separator
= xstrdup (target_system_root
);
3152 size_t sysroot_len
= strlen (target_system_root
);
3155 && target_system_root
[sysroot_len
- 1] == DIR_SEPARATOR
)
3156 sysroot_no_trailing_dir_separator
[sysroot_len
- 1] = '\0';
3158 if (target_sysroot_suffix
)
3159 prefix
= concat (sysroot_no_trailing_dir_separator
,
3160 target_sysroot_suffix
, prefix
, NULL
);
3162 prefix
= concat (sysroot_no_trailing_dir_separator
, prefix
, NULL
);
3164 free (sysroot_no_trailing_dir_separator
);
3166 /* We have to override this because GCC's notion of sysroot
3167 moves along with GCC. */
3171 add_prefix (pprefix
, prefix
, component
, priority
,
3172 require_machine_suffix
, os_multilib
);
3175 /* Same as add_prefix, but prepending target_sysroot_hdrs_suffix to prefix. */
3178 add_sysrooted_hdrs_prefix (struct path_prefix
*pprefix
, const char *prefix
,
3179 const char *component
,
3180 /* enum prefix_priority */ int priority
,
3181 int require_machine_suffix
, int os_multilib
)
3183 if (!IS_ABSOLUTE_PATH (prefix
))
3184 fatal_error (input_location
, "system path %qs is not absolute", prefix
);
3186 if (target_system_root
)
3188 char *sysroot_no_trailing_dir_separator
= xstrdup (target_system_root
);
3189 size_t sysroot_len
= strlen (target_system_root
);
3192 && target_system_root
[sysroot_len
- 1] == DIR_SEPARATOR
)
3193 sysroot_no_trailing_dir_separator
[sysroot_len
- 1] = '\0';
3195 if (target_sysroot_hdrs_suffix
)
3196 prefix
= concat (sysroot_no_trailing_dir_separator
,
3197 target_sysroot_hdrs_suffix
, prefix
, NULL
);
3199 prefix
= concat (sysroot_no_trailing_dir_separator
, prefix
, NULL
);
3201 free (sysroot_no_trailing_dir_separator
);
3203 /* We have to override this because GCC's notion of sysroot
3204 moves along with GCC. */
3208 add_prefix (pprefix
, prefix
, component
, priority
,
3209 require_machine_suffix
, os_multilib
);
3213 /* Execute the command specified by the arguments on the current line of spec.
3214 When using pipes, this includes several piped-together commands
3215 with `|' between them.
3217 Return 0 if successful, -1 if failed. */
3223 int n_commands
; /* # of command. */
3225 struct pex_obj
*pex
;
3228 const char *prog
; /* program name. */
3229 const char **argv
; /* vector of args. */
3233 struct command
*commands
; /* each command buffer with above info. */
3235 gcc_assert (!processing_spec_function
);
3239 string
= find_a_program (argbuf
[0]);
3242 insert_wrapper (wrapper_string
);
3245 /* Count # of piped commands. */
3246 for (n_commands
= 1, i
= 0; argbuf
.iterate (i
, &arg
); i
++)
3247 if (strcmp (arg
, "|") == 0)
3250 /* Get storage for each command. */
3251 commands
= XALLOCAVEC (struct command
, n_commands
);
3253 /* Split argbuf into its separate piped processes,
3254 and record info about each one.
3255 Also search for the programs that are to be run. */
3257 argbuf
.safe_push (0);
3259 commands
[0].prog
= argbuf
[0]; /* first command. */
3260 commands
[0].argv
= argbuf
.address ();
3262 if (!wrapper_string
)
3264 string
= find_a_program(commands
[0].prog
);
3266 commands
[0].argv
[0] = string
;
3269 for (n_commands
= 1, i
= 0; argbuf
.iterate (i
, &arg
); i
++)
3270 if (arg
&& strcmp (arg
, "|") == 0)
3271 { /* each command. */
3272 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
3273 fatal_error (input_location
, "%<-pipe%> not supported");
3275 argbuf
[i
] = 0; /* Termination of command args. */
3276 commands
[n_commands
].prog
= argbuf
[i
+ 1];
3277 commands
[n_commands
].argv
3278 = &(argbuf
.address ())[i
+ 1];
3279 string
= find_a_program(commands
[n_commands
].prog
);
3281 commands
[n_commands
].argv
[0] = string
;
3285 /* If -v, print what we are about to do, and maybe query. */
3289 /* For help listings, put a blank line between sub-processes. */
3290 if (print_help_list
)
3291 fputc ('\n', stderr
);
3293 /* Print each piped command as a separate line. */
3294 for (i
= 0; i
< n_commands
; i
++)
3296 const char *const *j
;
3298 if (verbose_only_flag
)
3300 for (j
= commands
[i
].argv
; *j
; j
++)
3303 for (p
= *j
; *p
; ++p
)
3304 if (!ISALNUM ((unsigned char) *p
)
3305 && *p
!= '_' && *p
!= '/' && *p
!= '-' && *p
!= '.')
3309 fprintf (stderr
, " \"");
3310 for (p
= *j
; *p
; ++p
)
3312 if (*p
== '"' || *p
== '\\' || *p
== '$')
3313 fputc ('\\', stderr
);
3316 fputc ('"', stderr
);
3318 /* If it's empty, print "". */
3320 fprintf (stderr
, " \"\"");
3322 fprintf (stderr
, " %s", *j
);
3326 for (j
= commands
[i
].argv
; *j
; j
++)
3327 /* If it's empty, print "". */
3329 fprintf (stderr
, " \"\"");
3331 fprintf (stderr
, " %s", *j
);
3333 /* Print a pipe symbol after all but the last command. */
3334 if (i
+ 1 != n_commands
)
3335 fprintf (stderr
, " |");
3336 fprintf (stderr
, "\n");
3339 if (verbose_only_flag
!= 0)
3341 /* verbose_only_flag should act as if the spec was
3342 executed, so increment execution_count before
3343 returning. This prevents spurious warnings about
3344 unused linker input files, etc. */
3349 fnotice (stderr
, "\nGo ahead? (y or n) ");
3353 while (getchar () != '\n')
3356 if (i
!= 'y' && i
!= 'Y')
3361 #ifdef ENABLE_VALGRIND_CHECKING
3362 /* Run the each command through valgrind. To simplify prepending the
3363 path to valgrind and the option "-q" (for quiet operation unless
3364 something triggers), we allocate a separate argv array. */
3366 for (i
= 0; i
< n_commands
; i
++)
3372 for (argc
= 0; commands
[i
].argv
[argc
] != NULL
; argc
++)
3375 argv
= XALLOCAVEC (const char *, argc
+ 3);
3377 argv
[0] = VALGRIND_PATH
;
3379 for (j
= 2; j
< argc
+ 2; j
++)
3380 argv
[j
] = commands
[i
].argv
[j
- 2];
3383 commands
[i
].argv
= argv
;
3384 commands
[i
].prog
= argv
[0];
3388 /* Run each piped subprocess. */
3390 pex
= pex_init (PEX_USE_PIPES
| ((report_times
|| report_times_to_file
)
3391 ? PEX_RECORD_TIMES
: 0),
3392 progname
, temp_filename
);
3394 fatal_error (input_location
, "%<pex_init%> failed: %m");
3396 for (i
= 0; i
< n_commands
; i
++)
3400 const char *string
= commands
[i
].argv
[0];
3402 errmsg
= pex_run (pex
,
3403 ((i
+ 1 == n_commands
? PEX_LAST
: 0)
3404 | (string
== commands
[i
].prog
? PEX_SEARCH
: 0)),
3405 string
, CONST_CAST (char **, commands
[i
].argv
),
3410 fatal_error (input_location
,
3411 err
? G_("cannot execute %qs: %s: %m")
3412 : G_("cannot execute %qs: %s"),
3416 if (i
&& string
!= commands
[i
].prog
)
3417 free (CONST_CAST (char *, string
));
3422 /* Wait for all the subprocesses to finish. */
3426 struct pex_time
*times
= NULL
;
3429 statuses
= XALLOCAVEC (int, n_commands
);
3430 if (!pex_get_status (pex
, n_commands
, statuses
))
3431 fatal_error (input_location
, "failed to get exit status: %m");
3433 if (report_times
|| report_times_to_file
)
3435 times
= XALLOCAVEC (struct pex_time
, n_commands
);
3436 if (!pex_get_times (pex
, n_commands
, times
))
3437 fatal_error (input_location
, "failed to get process times: %m");
3442 for (i
= 0; i
< n_commands
; ++i
)
3444 int status
= statuses
[i
];
3446 if (WIFSIGNALED (status
))
3447 switch (WTERMSIG (status
))
3451 /* SIGQUIT and SIGKILL are not available on MinGW. */
3458 /* The user (or environment) did something to the
3459 inferior. Making this an ICE confuses the user into
3460 thinking there's a compiler bug. Much more likely is
3461 the user or OOM killer nuked it. */
3462 fatal_error (input_location
,
3463 "%s signal terminated program %s",
3464 strsignal (WTERMSIG (status
)),
3470 /* SIGPIPE is a special case. It happens in -pipe mode
3471 when the compiler dies before the preprocessor is
3472 done, or the assembler dies before the compiler is
3473 done. There's generally been an error already, and
3474 this is just fallout. So don't generate another
3475 error unless we would otherwise have succeeded. */
3476 if (signal_count
|| greatest_status
>= MIN_FATAL_STATUS
)
3486 /* The inferior failed to catch the signal. */
3487 internal_error_no_backtrace ("%s signal terminated program %s",
3488 strsignal (WTERMSIG (status
)),
3491 else if (WIFEXITED (status
)
3492 && WEXITSTATUS (status
) >= MIN_FATAL_STATUS
)
3494 /* For ICEs in cc1, cc1obj, cc1plus see if it is
3495 reproducible or not. */
3498 && WEXITSTATUS (status
) == ICE_EXIT_CODE
3500 && (p
= strrchr (commands
[0].argv
[0], DIR_SEPARATOR
))
3501 && startswith (p
+ 1, "cc1"))
3502 try_generate_repro (commands
[0].argv
);
3503 if (WEXITSTATUS (status
) > greatest_status
)
3504 greatest_status
= WEXITSTATUS (status
);
3508 if (report_times
|| report_times_to_file
)
3510 struct pex_time
*pt
= ×
[i
];
3513 ut
= ((double) pt
->user_seconds
3514 + (double) pt
->user_microseconds
/ 1.0e6
);
3515 st
= ((double) pt
->system_seconds
3516 + (double) pt
->system_microseconds
/ 1.0e6
);
3521 fnotice (stderr
, "# %s %.2f %.2f\n",
3522 commands
[i
].prog
, ut
, st
);
3524 if (report_times_to_file
)
3527 const char *const *j
;
3529 fprintf (report_times_to_file
, "%g %g", ut
, st
);
3531 for (j
= &commands
[i
].prog
; *j
; j
= &commands
[i
].argv
[++c
])
3534 for (p
= *j
; *p
; ++p
)
3535 if (*p
== '"' || *p
== '\\' || *p
== '$'
3541 fprintf (report_times_to_file
, " \"");
3542 for (p
= *j
; *p
; ++p
)
3544 if (*p
== '"' || *p
== '\\' || *p
== '$')
3545 fputc ('\\', report_times_to_file
);
3546 fputc (*p
, report_times_to_file
);
3548 fputc ('"', report_times_to_file
);
3551 fprintf (report_times_to_file
, " %s", *j
);
3554 fputc ('\n', report_times_to_file
);
3560 if (commands
[0].argv
[0] != commands
[0].prog
)
3561 free (CONST_CAST (char *, commands
[0].argv
[0]));
3567 static struct switchstr
*switches
;
3569 static int n_switches
;
3571 static int n_switches_alloc
;
3573 /* Set to zero if -fcompare-debug is disabled, positive if it's
3574 enabled and we're running the first compilation, negative if it's
3575 enabled and we're running the second compilation. For most of the
3576 time, it's in the range -1..1, but it can be temporarily set to 2
3577 or 3 to indicate that the -fcompare-debug flags didn't come from
3578 the command-line, but rather from the GCC_COMPARE_DEBUG environment
3579 variable, until a synthesized -fcompare-debug flag is added to the
3583 /* Set to nonzero if we've seen the -fcompare-debug-second flag. */
3584 int compare_debug_second
;
3586 /* Set to the flags that should be passed to the second compilation in
3587 a -fcompare-debug compilation. */
3588 const char *compare_debug_opt
;
3590 static struct switchstr
*switches_debug_check
[2];
3592 static int n_switches_debug_check
[2];
3594 static int n_switches_alloc_debug_check
[2];
3596 static char *debug_check_temp_file
[2];
3598 /* Language is one of three things:
3600 1) The name of a real programming language.
3601 2) NULL, indicating that no one has figured out
3603 3) '*', indicating that the file should be passed
3608 const char *language
;
3609 struct compiler
*incompiler
;
3614 /* Also a vector of input files specified. */
3616 static struct infile
*infiles
;
3620 static int n_infiles_alloc
;
3622 /* True if undefined environment variables encountered during spec processing
3623 are ok to ignore, typically when we're running for --help or --version. */
3625 static bool spec_undefvar_allowed
;
3627 /* True if multiple input files are being compiled to a single
3630 static bool combine_inputs
;
3632 /* This counts the number of libraries added by lang_specific_driver, so that
3633 we can tell if there were any user supplied any files or libraries. */
3635 static int added_libraries
;
3637 /* And a vector of corresponding output files is made up later. */
3639 const char **outfiles
;
3641 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3643 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
3644 is true if we should look for an executable suffix. DO_OBJ
3645 is true if we should look for an object suffix. */
3648 convert_filename (const char *name
, int do_exe ATTRIBUTE_UNUSED
,
3649 int do_obj ATTRIBUTE_UNUSED
)
3651 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3659 len
= strlen (name
);
3661 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3662 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
3663 if (do_obj
&& len
> 2
3664 && name
[len
- 2] == '.'
3665 && name
[len
- 1] == 'o')
3667 obstack_grow (&obstack
, name
, len
- 2);
3668 obstack_grow0 (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
3669 name
= XOBFINISH (&obstack
, const char *);
3673 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3674 /* If there is no filetype, make it the executable suffix (which includes
3675 the "."). But don't get confused if we have just "-o". */
3676 if (! do_exe
|| TARGET_EXECUTABLE_SUFFIX
[0] == 0 || not_actual_file_p (name
))
3679 for (i
= len
- 1; i
>= 0; i
--)
3680 if (IS_DIR_SEPARATOR (name
[i
]))
3683 for (i
++; i
< len
; i
++)
3687 obstack_grow (&obstack
, name
, len
);
3688 obstack_grow0 (&obstack
, TARGET_EXECUTABLE_SUFFIX
,
3689 strlen (TARGET_EXECUTABLE_SUFFIX
));
3690 name
= XOBFINISH (&obstack
, const char *);
3697 /* Display the command line switches accepted by gcc. */
3701 printf (_("Usage: %s [options] file...\n"), progname
);
3702 fputs (_("Options:\n"), stdout
);
3704 fputs (_(" -pass-exit-codes Exit with highest error code from a phase.\n"), stdout
);
3705 fputs (_(" --help Display this information.\n"), stdout
);
3706 fputs (_(" --target-help Display target specific command line options "
3707 "(including assembler and linker options).\n"), stdout
);
3708 fputs (_(" --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...].\n"), stdout
);
3709 fputs (_(" Display specific types of command line options.\n"), stdout
);
3711 fputs (_(" (Use '-v --help' to display command line options of sub-processes).\n"), stdout
);
3712 fputs (_(" --version Display compiler version information.\n"), stdout
);
3713 fputs (_(" -dumpspecs Display all of the built in spec strings.\n"), stdout
);
3714 fputs (_(" -dumpversion Display the version of the compiler.\n"), stdout
);
3715 fputs (_(" -dumpmachine Display the compiler's target processor.\n"), stdout
);
3716 fputs (_(" -foffload=<targets> Specify offloading targets.\n"), stdout
);
3717 fputs (_(" -print-search-dirs Display the directories in the compiler's search path.\n"), stdout
);
3718 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library.\n"), stdout
);
3719 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>.\n"), stdout
);
3720 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>.\n"), stdout
);
3722 -print-multiarch Display the target's normalized GNU triplet, used as\n\
3723 a component in the library path.\n"), stdout
);
3724 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc.\n"), stdout
);
3726 -print-multi-lib Display the mapping between command line options and\n\
3727 multiple library search directories.\n"), stdout
);
3728 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries.\n"), stdout
);
3729 fputs (_(" -print-sysroot Display the target libraries directory.\n"), stdout
);
3730 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers.\n"), stdout
);
3731 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler.\n"), stdout
);
3732 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor.\n"), stdout
);
3733 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker.\n"), stdout
);
3734 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler.\n"), stdout
);
3735 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor.\n"), stdout
);
3736 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker.\n"), stdout
);
3737 fputs (_(" -save-temps Do not delete intermediate files.\n"), stdout
);
3738 fputs (_(" -save-temps=<arg> Do not delete intermediate files.\n"), stdout
);
3740 -no-canonical-prefixes Do not canonicalize paths when building relative\n\
3741 prefixes to other gcc components.\n"), stdout
);
3742 fputs (_(" -pipe Use pipes rather than intermediate files.\n"), stdout
);
3743 fputs (_(" -time Time the execution of each subprocess.\n"), stdout
);
3744 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>.\n"), stdout
);
3745 fputs (_(" -std=<standard> Assume that the input sources are for <standard>.\n"), stdout
);
3747 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3748 and libraries.\n"), stdout
);
3749 fputs (_(" -B <directory> Add <directory> to the compiler's search paths.\n"), stdout
);
3750 fputs (_(" -v Display the programs invoked by the compiler.\n"), stdout
);
3751 fputs (_(" -### Like -v but options quoted and commands not executed.\n"), stdout
);
3752 fputs (_(" -E Preprocess only; do not compile, assemble or link.\n"), stdout
);
3753 fputs (_(" -S Compile only; do not assemble or link.\n"), stdout
);
3754 fputs (_(" -c Compile and assemble, but do not link.\n"), stdout
);
3755 fputs (_(" -o <file> Place the output into <file>.\n"), stdout
);
3756 fputs (_(" -pie Create a dynamically linked position independent\n\
3757 executable.\n"), stdout
);
3758 fputs (_(" -shared Create a shared library.\n"), stdout
);
3760 -x <language> Specify the language of the following input files.\n\
3761 Permissible languages include: c c++ assembler none\n\
3762 'none' means revert to the default behavior of\n\
3763 guessing the language based on the file's extension.\n\
3767 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3768 passed on to the various sub-processes invoked by %s. In order to pass\n\
3769 other options on to these processes the -W<letter> options must be used.\n\
3772 /* The rest of the options are displayed by invocations of the various
3777 add_preprocessor_option (const char *option
, int len
)
3779 preprocessor_options
.safe_push (save_string (option
, len
));
3783 add_assembler_option (const char *option
, int len
)
3785 assembler_options
.safe_push (save_string (option
, len
));
3789 add_linker_option (const char *option
, int len
)
3791 linker_options
.safe_push (save_string (option
, len
));
3794 /* Allocate space for an input file in infiles. */
3799 if (n_infiles_alloc
== 0)
3801 n_infiles_alloc
= 16;
3802 infiles
= XNEWVEC (struct infile
, n_infiles_alloc
);
3804 else if (n_infiles_alloc
== n_infiles
)
3806 n_infiles_alloc
*= 2;
3807 infiles
= XRESIZEVEC (struct infile
, infiles
, n_infiles_alloc
);
3811 /* Store an input file with the given NAME and LANGUAGE in
3815 add_infile (const char *name
, const char *language
)
3818 infiles
[n_infiles
].name
= name
;
3819 infiles
[n_infiles
++].language
= language
;
3822 /* Allocate space for a switch in switches. */
3827 if (n_switches_alloc
== 0)
3829 n_switches_alloc
= 16;
3830 switches
= XNEWVEC (struct switchstr
, n_switches_alloc
);
3832 else if (n_switches_alloc
== n_switches
)
3834 n_switches_alloc
*= 2;
3835 switches
= XRESIZEVEC (struct switchstr
, switches
, n_switches_alloc
);
3839 /* Save an option OPT with N_ARGS arguments in array ARGS, marking it
3840 as validated if VALIDATED and KNOWN if it is an internal switch. */
3843 save_switch (const char *opt
, size_t n_args
, const char *const *args
,
3844 bool validated
, bool known
)
3847 switches
[n_switches
].part1
= opt
+ 1;
3849 switches
[n_switches
].args
= 0;
3852 switches
[n_switches
].args
= XNEWVEC (const char *, n_args
+ 1);
3853 memcpy (switches
[n_switches
].args
, args
, n_args
* sizeof (const char *));
3854 switches
[n_switches
].args
[n_args
] = NULL
;
3857 switches
[n_switches
].live_cond
= 0;
3858 switches
[n_switches
].validated
= validated
;
3859 switches
[n_switches
].known
= known
;
3860 switches
[n_switches
].ordering
= 0;
3864 /* Set the SOURCE_DATE_EPOCH environment variable to the current time if it is
3868 set_source_date_epoch_envvar ()
3870 /* Array size is 21 = ceil(log_10(2^64)) + 1 to hold string representations
3871 of 64 bit integers. */
3872 char source_date_epoch
[21];
3877 if (tt
< (time_t) 0 || errno
!= 0)
3880 snprintf (source_date_epoch
, 21, "%llu", (unsigned long long) tt
);
3881 /* Using setenv instead of xputenv because we want the variable to remain
3882 after finalizing so that it's still set in the second run when using
3884 setenv ("SOURCE_DATE_EPOCH", source_date_epoch
, 0);
3887 /* Handle an option DECODED that is unknown to the option-processing
3891 driver_unknown_option_callback (const struct cl_decoded_option
*decoded
)
3893 const char *opt
= decoded
->arg
;
3894 if (opt
[1] == 'W' && opt
[2] == 'n' && opt
[3] == 'o' && opt
[4] == '-'
3895 && !(decoded
->errors
& CL_ERR_NEGATIVE
))
3897 /* Leave unknown -Wno-* options for the compiler proper, to be
3898 diagnosed only if there are warnings. */
3899 save_switch (decoded
->canonical_option
[0],
3900 decoded
->canonical_option_num_elements
- 1,
3901 &decoded
->canonical_option
[1], false, true);
3904 if (decoded
->opt_index
== OPT_SPECIAL_unknown
)
3906 /* Give it a chance to define it a spec file. */
3907 save_switch (decoded
->canonical_option
[0],
3908 decoded
->canonical_option_num_elements
- 1,
3909 &decoded
->canonical_option
[1], false, false);
3916 /* Handle an option DECODED that is not marked as CL_DRIVER.
3917 LANG_MASK will always be CL_DRIVER. */
3920 driver_wrong_lang_callback (const struct cl_decoded_option
*decoded
,
3921 unsigned int lang_mask ATTRIBUTE_UNUSED
)
3923 /* At this point, non-driver options are accepted (and expected to
3924 be passed down by specs) unless marked to be rejected by the
3925 driver. Options to be rejected by the driver but accepted by the
3926 compilers proper are treated just like completely unknown
3928 const struct cl_option
*option
= &cl_options
[decoded
->opt_index
];
3930 if (option
->cl_reject_driver
)
3931 error ("unrecognized command-line option %qs",
3932 decoded
->orig_option_with_args_text
);
3934 save_switch (decoded
->canonical_option
[0],
3935 decoded
->canonical_option_num_elements
- 1,
3936 &decoded
->canonical_option
[1], false, true);
3939 static const char *spec_lang
= 0;
3940 static int last_language_n_infiles
;
3943 /* Check that GCC is configured to support the offload target. */
3946 check_offload_target_name (const char *target
, ptrdiff_t len
)
3948 const char *n
, *c
= OFFLOAD_TARGETS
;
3951 n
= strchr (c
, ',');
3953 n
= strchr (c
, '\0');
3954 if (len
== n
- c
&& strncmp (target
, c
, n
- c
) == 0)
3956 c
= *n
? n
+ 1 : NULL
;
3960 auto_vec
<const char*> candidates
;
3961 size_t olen
= strlen (OFFLOAD_TARGETS
) + 1;
3962 char *cand
= XALLOCAVEC (char, olen
);
3963 memcpy (cand
, OFFLOAD_TARGETS
, olen
);
3964 for (c
= strtok (cand
, ","); c
; c
= strtok (NULL
, ","))
3965 candidates
.safe_push (c
);
3966 candidates
.safe_push ("default");
3967 candidates
.safe_push ("disable");
3969 char *target2
= XALLOCAVEC (char, len
+ 1);
3970 memcpy (target2
, target
, len
);
3971 target2
[len
] = '\0';
3973 error ("GCC is not configured to support %qs as %<-foffload=%> argument",
3977 const char *hint
= candidates_list_and_hint (target2
, s
, candidates
);
3979 inform (UNKNOWN_LOCATION
,
3980 "valid %<-foffload=%> arguments are: %s; "
3981 "did you mean %qs?", s
, hint
);
3983 inform (UNKNOWN_LOCATION
, "valid %<-foffload=%> arguments are: %s", s
);
3990 /* Sanity check for -foffload-options. */
3993 check_foffload_target_names (const char *arg
)
3995 const char *cur
, *next
, *end
;
3996 /* If option argument starts with '-' then no target is specified and we
3997 do not need to parse it. */
4000 end
= strchr (arg
, '=');
4003 error ("%<=%>options missing after %<-foffload-options=%>target");
4010 next
= strchr (cur
, ',');
4013 next
= (next
> end
) ? end
: next
;
4015 /* Retain non-supported targets after printing an error as those will not
4016 be processed; each enabled target only processes its triplet. */
4017 check_offload_target_name (cur
, next
- cur
);
4022 /* Parse -foffload option argument. */
4025 handle_foffload_option (const char *arg
)
4027 const char *c
, *cur
, *n
, *next
, *end
;
4030 /* If option argument starts with '-' then no target is specified and we
4031 do not need to parse it. */
4035 end
= strchr (arg
, '=');
4037 end
= strchr (arg
, '\0');
4042 next
= strchr (cur
, ',');
4045 next
= (next
> end
) ? end
: next
;
4047 target
= XNEWVEC (char, next
- cur
+ 1);
4048 memcpy (target
, cur
, next
- cur
);
4049 target
[next
- cur
] = '\0';
4051 /* Reset offloading list and continue. */
4052 if (strcmp (target
, "default") == 0)
4054 free (offload_targets
);
4055 offload_targets
= NULL
;
4059 /* If 'disable' is passed to the option, clean the list of
4060 offload targets and return, even if more targets follow.
4061 Likewise if GCC is not configured to support that offload target. */
4062 if (strcmp (target
, "disable") == 0
4063 || !check_offload_target_name (target
, next
- cur
))
4065 free (offload_targets
);
4066 offload_targets
= xstrdup ("");
4070 if (!offload_targets
)
4072 offload_targets
= target
;
4077 /* Check that the target hasn't already presented in the list. */
4078 c
= offload_targets
;
4081 n
= strchr (c
, ':');
4083 n
= strchr (c
, '\0');
4085 if (next
- cur
== n
- c
&& strncmp (c
, target
, n
- c
) == 0)
4092 /* If duplicate is not found, append the target to the list. */
4095 size_t offload_targets_len
= strlen (offload_targets
);
4097 = XRESIZEVEC (char, offload_targets
,
4098 offload_targets_len
+ 1 + next
- cur
+ 1);
4099 offload_targets
[offload_targets_len
++] = ':';
4100 memcpy (offload_targets
+ offload_targets_len
, target
, next
- cur
+ 1);
4105 XDELETEVEC (target
);
4109 /* Handle a driver option; arguments and return value as for
4113 driver_handle_option (struct gcc_options
*opts
,
4114 struct gcc_options
*opts_set
,
4115 const struct cl_decoded_option
*decoded
,
4116 unsigned int lang_mask ATTRIBUTE_UNUSED
, int kind
,
4118 const struct cl_option_handlers
*handlers ATTRIBUTE_UNUSED
,
4119 diagnostic_context
*dc
,
4122 size_t opt_index
= decoded
->opt_index
;
4123 const char *arg
= decoded
->arg
;
4124 const char *compare_debug_replacement_opt
;
4125 int value
= decoded
->value
;
4126 bool validated
= false;
4127 bool do_save
= true;
4129 gcc_assert (opts
== &global_options
);
4130 gcc_assert (opts_set
== &global_options_set
);
4131 gcc_assert (kind
== DK_UNSPECIFIED
);
4132 gcc_assert (loc
== UNKNOWN_LOCATION
);
4133 gcc_assert (dc
== global_dc
);
4139 struct spec_list
*sl
;
4141 for (sl
= specs
; sl
; sl
= sl
->next
)
4142 printf ("*%s:\n%s\n\n", sl
->name
, *(sl
->ptr_spec
));
4143 if (link_command_spec
)
4144 printf ("*link_command:\n%s\n\n", link_command_spec
);
4148 case OPT_dumpversion
:
4149 printf ("%s\n", spec_version
);
4152 case OPT_dumpmachine
:
4153 printf ("%s\n", spec_machine
);
4156 case OPT_dumpfullversion
:
4157 printf ("%s\n", BASEVER
);
4163 /* CPP driver cannot obtain switch from cc1_options. */
4165 add_preprocessor_option ("--version", strlen ("--version"));
4166 add_assembler_option ("--version", strlen ("--version"));
4167 add_linker_option ("--version", strlen ("--version"));
4170 case OPT__completion_
:
4172 completion
= decoded
->arg
;
4176 print_help_list
= 1;
4178 /* CPP driver cannot obtain switch from cc1_options. */
4180 add_preprocessor_option ("--help", 6);
4181 add_assembler_option ("--help", 6);
4182 add_linker_option ("--help", 6);
4186 print_subprocess_help
= 2;
4189 case OPT__target_help
:
4190 print_subprocess_help
= 1;
4192 /* CPP driver cannot obtain switch from cc1_options. */
4194 add_preprocessor_option ("--target-help", 13);
4195 add_assembler_option ("--target-help", 13);
4196 add_linker_option ("--target-help", 13);
4199 case OPT__no_sysroot_suffix
:
4200 case OPT_pass_exit_codes
:
4201 case OPT_print_search_dirs
:
4202 case OPT_print_file_name_
:
4203 case OPT_print_prog_name_
:
4204 case OPT_print_multi_lib
:
4205 case OPT_print_multi_directory
:
4206 case OPT_print_sysroot
:
4207 case OPT_print_multi_os_directory
:
4208 case OPT_print_multiarch
:
4209 case OPT_print_sysroot_headers_suffix
:
4212 /* These options set the variables specified in common.opt
4213 automatically, and do not need to be saved for spec
4218 case OPT_print_libgcc_file_name
:
4219 print_file_name
= "libgcc.a";
4223 case OPT_fuse_ld_bfd
:
4227 case OPT_fuse_ld_gold
:
4231 case OPT_fuse_ld_mold
:
4235 case OPT_fcompare_debug_second
:
4236 compare_debug_second
= 1;
4239 case OPT_fcompare_debug
:
4243 compare_debug_replacement_opt
= "-fcompare-debug=";
4245 goto compare_debug_with_arg
;
4248 compare_debug_replacement_opt
= "-fcompare-debug=-gtoggle";
4250 goto compare_debug_with_arg
;
4257 case OPT_fcompare_debug_
:
4258 compare_debug_replacement_opt
= decoded
->canonical_option
[0];
4259 compare_debug_with_arg
:
4260 gcc_assert (decoded
->canonical_option_num_elements
== 1);
4261 gcc_assert (arg
!= NULL
);
4266 if (compare_debug
< 0)
4267 compare_debug_opt
= NULL
;
4269 compare_debug_opt
= arg
;
4270 save_switch (compare_debug_replacement_opt
, 0, NULL
, validated
, true);
4271 set_source_date_epoch_envvar ();
4274 case OPT_fdiagnostics_color_
:
4275 diagnostic_color_init (dc
, value
);
4278 case OPT_fdiagnostics_urls_
:
4279 diagnostic_urls_init (dc
, value
);
4282 case OPT_fdiagnostics_format_
:
4283 diagnostic_output_format_init (dc
, opts
->x_dump_base_name
,
4284 (enum diagnostics_output_format
)value
);
4290 /* Pass the rest of this option to the assembler. */
4292 /* Split the argument at commas. */
4294 for (j
= 0; arg
[j
]; j
++)
4297 add_assembler_option (arg
+ prev
, j
- prev
);
4301 /* Record the part after the last comma. */
4302 add_assembler_option (arg
+ prev
, j
- prev
);
4310 /* Pass the rest of this option to the preprocessor. */
4312 /* Split the argument at commas. */
4314 for (j
= 0; arg
[j
]; j
++)
4317 add_preprocessor_option (arg
+ prev
, j
- prev
);
4321 /* Record the part after the last comma. */
4322 add_preprocessor_option (arg
+ prev
, j
- prev
);
4330 /* Split the argument at commas. */
4332 for (j
= 0; arg
[j
]; j
++)
4335 add_infile (save_string (arg
+ prev
, j
- prev
), "*");
4338 /* Record the part after the last comma. */
4339 add_infile (arg
+ prev
, "*");
4345 add_infile (arg
, "*");
4349 case OPT_Xpreprocessor
:
4350 add_preprocessor_option (arg
, strlen (arg
));
4354 case OPT_Xassembler
:
4355 add_assembler_option (arg
, strlen (arg
));
4360 /* POSIX allows separation of -l and the lib arg; canonicalize
4361 by concatenating -l with its arg */
4362 add_infile (concat ("-l", arg
, NULL
), "*");
4367 /* Similarly, canonicalize -L for linkers that may not accept
4368 separate arguments. */
4369 save_switch (concat ("-L", arg
, NULL
), 0, NULL
, validated
, true);
4374 save_switch (concat ("-F", arg
, NULL
), 0, NULL
, validated
, true);
4377 case OPT_save_temps
:
4378 if (!save_temps_flag
)
4379 save_temps_flag
= SAVE_TEMPS_DUMP
;
4383 case OPT_save_temps_
:
4384 if (strcmp (arg
, "cwd") == 0)
4385 save_temps_flag
= SAVE_TEMPS_CWD
;
4386 else if (strcmp (arg
, "obj") == 0
4387 || strcmp (arg
, "object") == 0)
4388 save_temps_flag
= SAVE_TEMPS_OBJ
;
4390 fatal_error (input_location
, "%qs is an unknown %<-save-temps%> option",
4391 decoded
->orig_option_with_args_text
);
4392 save_temps_overrides_dumpdir
= true;
4397 dumpdir
= xstrdup (arg
);
4398 save_temps_overrides_dumpdir
= false;
4403 dumpbase
= xstrdup (arg
);
4406 case OPT_dumpbase_ext
:
4407 free (dumpbase_ext
);
4408 dumpbase_ext
= xstrdup (arg
);
4411 case OPT_no_canonical_prefixes
:
4412 /* Already handled as a special case, so ignored here. */
4418 /* These options set the variables specified in common.opt
4419 automatically, but do need to be saved for spec
4425 struct user_specs
*user
= XNEW (struct user_specs
);
4427 user
->next
= (struct user_specs
*) 0;
4428 user
->filename
= arg
;
4429 if (user_specs_tail
)
4430 user_specs_tail
->next
= user
;
4432 user_specs_head
= user
;
4433 user_specs_tail
= user
;
4439 target_system_root
= arg
;
4440 target_system_root_changed
= 1;
4441 /* Saving this option is useful to let self-specs decide to
4442 provide a default one. */
4448 if (report_times_to_file
)
4449 fclose (report_times_to_file
);
4450 report_times_to_file
= fopen (arg
, "a");
4456 This is similar to -v except that there is no execution
4457 of the commands and the echoed arguments are quoted. It
4458 is intended for use in shell scripts to capture the
4459 driver-generated command line. */
4460 verbose_only_flag
++;
4467 size_t len
= strlen (arg
);
4469 /* Catch the case where the user has forgotten to append a
4470 directory separator to the path. Note, they may be using
4471 -B to add an executable name prefix, eg "i386-elf-", in
4472 order to distinguish between multiple installations of
4473 GCC in the same directory. Hence we must check to see
4474 if appending a directory separator actually makes a
4475 valid directory name. */
4476 if (!IS_DIR_SEPARATOR (arg
[len
- 1])
4477 && is_directory (arg
, false))
4479 char *tmp
= XNEWVEC (char, len
+ 2);
4481 tmp
[len
] = DIR_SEPARATOR
;
4486 add_prefix (&exec_prefixes
, arg
, NULL
,
4487 PREFIX_PRIORITY_B_OPT
, 0, 0);
4488 add_prefix (&startfile_prefixes
, arg
, NULL
,
4489 PREFIX_PRIORITY_B_OPT
, 0, 0);
4490 add_prefix (&include_prefixes
, arg
, NULL
,
4491 PREFIX_PRIORITY_B_OPT
, 0, 0);
4502 if (!strcmp (spec_lang
, "none"))
4503 /* Suppress the warning if -xnone comes after the last input
4504 file, because alternate command interfaces like g++ might
4505 find it useful to place -xnone after each input file. */
4508 last_language_n_infiles
= n_infiles
;
4514 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
4515 arg
= convert_filename (arg
, ! have_c
, 0);
4518 /* On some systems, ld cannot handle "-o" without a space. So
4519 split the option from its argument. */
4520 save_switch ("-o", 1, &arg
, validated
, true);
4523 #ifdef ENABLE_DEFAULT_PIE
4525 /* -pie is turned on by default. */
4528 case OPT_static_libgcc
:
4529 case OPT_shared_libgcc
:
4530 case OPT_static_libgfortran
:
4531 case OPT_static_libquadmath
:
4532 case OPT_static_libphobos
:
4533 case OPT_static_libstdc__
:
4534 /* These are always valid, since gcc.cc itself understands the
4535 first two, gfortranspec.cc understands -static-libgfortran,
4536 d-spec.cc understands -static-libphobos, g++spec.cc
4537 understands -static-libstdc++ and libgfortran.spec handles
4538 -static-libquadmath. */
4546 case OPT_foffload_options_
:
4547 check_foffload_target_names (arg
);
4551 handle_foffload_option (arg
);
4552 if (arg
[0] == '-' || NULL
!= strchr (arg
, '='))
4553 save_switch (concat ("-foffload-options=", arg
, NULL
),
4554 0, NULL
, validated
, true);
4559 /* Various driver options need no special processing at this
4560 point, having been handled in a prescan above or being
4561 handled by specs. */
4566 save_switch (decoded
->canonical_option
[0],
4567 decoded
->canonical_option_num_elements
- 1,
4568 &decoded
->canonical_option
[1], validated
, true);
4572 /* Return true if F2 is F1 followed by a single suffix, i.e., by a
4573 period and additional characters other than a period. */
4576 adds_single_suffix_p (const char *f2
, const char *f1
)
4578 size_t len
= strlen (f1
);
4580 return (strncmp (f1
, f2
, len
) == 0
4582 && strchr (f2
+ len
+ 1, '.') == NULL
);
4585 /* Put the driver's standard set of option handlers in *HANDLERS. */
4588 set_option_handlers (struct cl_option_handlers
*handlers
)
4590 handlers
->unknown_option_callback
= driver_unknown_option_callback
;
4591 handlers
->wrong_lang_callback
= driver_wrong_lang_callback
;
4592 handlers
->num_handlers
= 3;
4593 handlers
->handlers
[0].handler
= driver_handle_option
;
4594 handlers
->handlers
[0].mask
= CL_DRIVER
;
4595 handlers
->handlers
[1].handler
= common_handle_option
;
4596 handlers
->handlers
[1].mask
= CL_COMMON
;
4597 handlers
->handlers
[2].handler
= target_handle_option
;
4598 handlers
->handlers
[2].mask
= CL_TARGET
;
4602 /* Return the index into infiles for the single non-library
4603 non-lto-wpa input file, -1 if there isn't any, or -2 if there is
4606 single_input_file_index ()
4610 for (int i
= 0; i
< n_infiles
; i
++)
4612 if (infiles
[i
].language
4613 && (infiles
[i
].language
[0] == '*'
4615 && strcmp (infiles
[i
].language
, "lto") == 0)))
4627 /* Create the vector `switches' and its contents.
4628 Store its length in `n_switches'. */
4631 process_command (unsigned int decoded_options_count
,
4632 struct cl_decoded_option
*decoded_options
)
4636 char *tooldir_prefix
, *tooldir_prefix2
;
4637 char *(*get_relative_prefix
) (const char *, const char *,
4638 const char *) = NULL
;
4639 struct cl_option_handlers handlers
;
4642 gcc_exec_prefix
= env
.get ("GCC_EXEC_PREFIX");
4646 added_libraries
= 0;
4648 /* Figure compiler version from version string. */
4650 compiler_version
= temp1
= xstrdup (version_string
);
4652 for (; *temp1
; ++temp1
)
4661 /* Handle any -no-canonical-prefixes flag early, to assign the function
4662 that builds relative prefixes. This function creates default search
4663 paths that are needed later in normal option handling. */
4665 for (j
= 1; j
< decoded_options_count
; j
++)
4667 if (decoded_options
[j
].opt_index
== OPT_no_canonical_prefixes
)
4669 get_relative_prefix
= make_relative_prefix_ignore_links
;
4673 if (! get_relative_prefix
)
4674 get_relative_prefix
= make_relative_prefix
;
4676 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
4677 see if we can create it from the pathname specified in
4678 decoded_options[0].arg. */
4680 gcc_libexec_prefix
= standard_libexec_prefix
;
4682 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
4683 if (!gcc_exec_prefix
)
4685 gcc_exec_prefix
= get_relative_prefix (decoded_options
[0].arg
,
4686 standard_bindir_prefix
,
4687 standard_exec_prefix
);
4688 gcc_libexec_prefix
= get_relative_prefix (decoded_options
[0].arg
,
4689 standard_bindir_prefix
,
4690 standard_libexec_prefix
);
4691 if (gcc_exec_prefix
)
4692 xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix
, NULL
));
4696 /* make_relative_prefix requires a program name, but
4697 GCC_EXEC_PREFIX is typically a directory name with a trailing
4698 / (which is ignored by make_relative_prefix), so append a
4700 char *tmp_prefix
= concat (gcc_exec_prefix
, "gcc", NULL
);
4701 gcc_libexec_prefix
= get_relative_prefix (tmp_prefix
,
4702 standard_exec_prefix
,
4703 standard_libexec_prefix
);
4705 /* The path is unrelocated, so fallback to the original setting. */
4706 if (!gcc_libexec_prefix
)
4707 gcc_libexec_prefix
= standard_libexec_prefix
;
4713 /* From this point onward, gcc_exec_prefix is non-null if the toolchain
4714 is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
4715 or an automatically created GCC_EXEC_PREFIX from
4716 decoded_options[0].arg. */
4718 /* Do language-specific adjustment/addition of flags. */
4719 lang_specific_driver (&decoded_options
, &decoded_options_count
,
4722 if (gcc_exec_prefix
)
4724 int len
= strlen (gcc_exec_prefix
);
4726 if (len
> (int) sizeof ("/lib/gcc/") - 1
4727 && (IS_DIR_SEPARATOR (gcc_exec_prefix
[len
-1])))
4729 temp
= gcc_exec_prefix
+ len
- sizeof ("/lib/gcc/") + 1;
4730 if (IS_DIR_SEPARATOR (*temp
)
4731 && filename_ncmp (temp
+ 1, "lib", 3) == 0
4732 && IS_DIR_SEPARATOR (temp
[4])
4733 && filename_ncmp (temp
+ 5, "gcc", 3) == 0)
4734 len
-= sizeof ("/lib/gcc/") - 1;
4737 set_std_prefix (gcc_exec_prefix
, len
);
4738 add_prefix (&exec_prefixes
, gcc_libexec_prefix
, "GCC",
4739 PREFIX_PRIORITY_LAST
, 0, 0);
4740 add_prefix (&startfile_prefixes
, gcc_exec_prefix
, "GCC",
4741 PREFIX_PRIORITY_LAST
, 0, 0);
4744 /* COMPILER_PATH and LIBRARY_PATH have values
4745 that are lists of directory names with colons. */
4747 temp
= env
.get ("COMPILER_PATH");
4750 const char *startp
, *endp
;
4751 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4753 startp
= endp
= temp
;
4756 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4758 strncpy (nstore
, startp
, endp
- startp
);
4760 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4761 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4763 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4764 nstore
[endp
- startp
+ 1] = 0;
4767 nstore
[endp
- startp
] = 0;
4768 add_prefix (&exec_prefixes
, nstore
, 0,
4769 PREFIX_PRIORITY_LAST
, 0, 0);
4770 add_prefix (&include_prefixes
, nstore
, 0,
4771 PREFIX_PRIORITY_LAST
, 0, 0);
4774 endp
= startp
= endp
+ 1;
4781 temp
= env
.get (LIBRARY_PATH_ENV
);
4782 if (temp
&& *cross_compile
== '0')
4784 const char *startp
, *endp
;
4785 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4787 startp
= endp
= temp
;
4790 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4792 strncpy (nstore
, startp
, endp
- startp
);
4794 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4795 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4797 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4798 nstore
[endp
- startp
+ 1] = 0;
4801 nstore
[endp
- startp
] = 0;
4802 add_prefix (&startfile_prefixes
, nstore
, NULL
,
4803 PREFIX_PRIORITY_LAST
, 0, 1);
4806 endp
= startp
= endp
+ 1;
4813 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
4814 temp
= env
.get ("LPATH");
4815 if (temp
&& *cross_compile
== '0')
4817 const char *startp
, *endp
;
4818 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4820 startp
= endp
= temp
;
4823 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4825 strncpy (nstore
, startp
, endp
- startp
);
4827 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4828 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4830 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4831 nstore
[endp
- startp
+ 1] = 0;
4834 nstore
[endp
- startp
] = 0;
4835 add_prefix (&startfile_prefixes
, nstore
, NULL
,
4836 PREFIX_PRIORITY_LAST
, 0, 1);
4839 endp
= startp
= endp
+ 1;
4846 /* Process the options and store input files and switches in their
4849 last_language_n_infiles
= -1;
4851 set_option_handlers (&handlers
);
4853 for (j
= 1; j
< decoded_options_count
; j
++)
4855 switch (decoded_options
[j
].opt_index
)
4867 for (j
= 1; j
< decoded_options_count
; j
++)
4869 if (decoded_options
[j
].opt_index
== OPT_SPECIAL_input_file
)
4871 const char *arg
= decoded_options
[j
].arg
;
4873 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4874 arg
= convert_filename (arg
, 0, access (arg
, F_OK
));
4876 add_infile (arg
, spec_lang
);
4881 read_cmdline_option (&global_options
, &global_options_set
,
4882 decoded_options
+ j
, UNKNOWN_LOCATION
,
4883 CL_DRIVER
, &handlers
, global_dc
);
4886 /* If the user didn't specify any, default to all configured offload
4888 if (ENABLE_OFFLOADING
&& offload_targets
== NULL
)
4890 handle_foffload_option (OFFLOAD_TARGETS
);
4891 #if OFFLOAD_DEFAULTED
4892 offload_targets_default
= true;
4896 /* Handle -gtoggle as it would later in toplev.cc:process_options to
4897 make the debug-level-gt spec function work as expected. */
4900 if (debug_info_level
== DINFO_LEVEL_NONE
)
4901 debug_info_level
= DINFO_LEVEL_NORMAL
;
4903 debug_info_level
= DINFO_LEVEL_NONE
;
4907 && strcmp (output_file
, "-") != 0
4908 && strcmp (output_file
, HOST_BIT_BUCKET
) != 0)
4911 for (i
= 0; i
< n_infiles
; i
++)
4912 if ((!infiles
[i
].language
|| infiles
[i
].language
[0] != '*')
4913 && canonical_filename_eq (infiles
[i
].name
, output_file
))
4914 fatal_error (input_location
,
4915 "input file %qs is the same as output file",
4919 if (output_file
!= NULL
&& output_file
[0] == '\0')
4920 fatal_error (input_location
, "output filename may not be empty");
4922 /* -dumpdir and -save-temps=* both specify the location of aux/dump
4923 outputs; the one that appears last prevails. When compiling
4924 multiple sources, an explicit dumpbase (minus -ext) may be
4925 combined with an explicit or implicit dumpdir, whereas when
4926 linking, a specified or implied link output name (minus
4927 extension) may be combined with a prevailing -save-temps=* or an
4928 otherwise implied dumpdir, but not override a prevailing
4929 -dumpdir. Primary outputs (e.g., linker output when linking
4930 without -o, or .i, .s or .o outputs when processing multiple
4931 inputs with -E, -S or -c, respectively) are NOT affected by these
4932 -save-temps=/-dump* options, always landing in the current
4933 directory and with the same basename as the input when an output
4934 name is not given, but when they're intermediate outputs, they
4935 are named like other aux outputs, so the options affect their
4938 Here are some examples. There are several more in the
4939 documentation of -o and -dump*, and some quite exhaustive tests
4940 in gcc.misc-tests/outputs.exp.
4942 When compiling any number of sources, no -dump* nor
4943 -save-temps=*, all outputs in cwd without prefix:
4945 # gcc -c b.c -gsplit-dwarf
4946 -> cc1 [-dumpdir ./] -dumpbase b.c -dumpbase-ext .c # b.o b.dwo
4948 # gcc -c b.c d.c -gsplit-dwarf
4949 -> cc1 [-dumpdir ./] -dumpbase b.c -dumpbase-ext .c # b.o b.dwo
4950 && cc1 [-dumpdir ./] -dumpbase d.c -dumpbase-ext .c # d.o d.dwo
4952 When compiling and linking, no -dump* nor -save-temps=*, .o
4953 outputs are temporary, aux outputs land in the dir of the output,
4954 prefixed with the basename of the linker output:
4956 # gcc b.c d.c -o ab -gsplit-dwarf
4957 -> cc1 -dumpdir ab- -dumpbase b.c -dumpbase-ext .c # ab-b.dwo
4958 && cc1 -dumpdir ab- -dumpbase d.c -dumpbase-ext .c # ab-d.dwo
4961 # gcc b.c d.c [-o a.out] -gsplit-dwarf
4962 -> cc1 -dumpdir a- -dumpbase b.c -dumpbase-ext .c # a-b.dwo
4963 && cc1 -dumpdir a- -dumpbase d.c -dumpbase-ext .c # a-d.dwo
4964 && link ... [-o a.out]
4966 When compiling and linking, a prevailing -dumpdir fully overrides
4967 the prefix of aux outputs given by the output name:
4969 # gcc -dumpdir f b.c d.c -gsplit-dwarf [-o [dir/]whatever]
4970 -> cc1 -dumpdir f -dumpbase b.c -dumpbase-ext .c # fb.dwo
4971 && cc1 -dumpdir f -dumpbase d.c -dumpbase-ext .c # fd.dwo
4972 && link ... [-o whatever]
4974 When compiling multiple inputs, an explicit -dumpbase is combined
4975 with -dumpdir, affecting aux outputs, but not the .o outputs:
4977 # gcc -dumpdir f -dumpbase g- b.c d.c -gsplit-dwarf -c
4978 -> cc1 -dumpdir fg- -dumpbase b.c -dumpbase-ext .c # b.o fg-b.dwo
4979 && cc1 -dumpdir fg- -dumpbase d.c -dumpbase-ext .c # d.o fg-d.dwo
4981 When compiling and linking with -save-temps, the .o outputs that
4982 would have been temporary become aux outputs, so they get
4983 affected by -dump* flags:
4985 # gcc -dumpdir f -dumpbase g- -save-temps b.c d.c
4986 -> cc1 -dumpdir fg- -dumpbase b.c -dumpbase-ext .c # fg-b.o
4987 && cc1 -dumpdir fg- -dumpbase d.c -dumpbase-ext .c # fg-d.o
4990 If -save-temps=* prevails over -dumpdir, however, the explicit
4991 -dumpdir is discarded, as if it wasn't there. The basename of
4992 the implicit linker output, a.out or a.exe, becomes a- as the aux
4993 output prefix for all compilations:
4995 # gcc [-dumpdir f] -save-temps=cwd b.c d.c
4996 -> cc1 -dumpdir a- -dumpbase b.c -dumpbase-ext .c # a-b.o
4997 && cc1 -dumpdir a- -dumpbase d.c -dumpbase-ext .c # a-d.o
5000 A single -dumpbase, applying to multiple inputs, overrides the
5001 linker output name, implied or explicit, as the aux output prefix:
5003 # gcc [-dumpdir f] -dumpbase g- -save-temps=cwd b.c d.c
5004 -> cc1 -dumpdir g- -dumpbase b.c -dumpbase-ext .c # g-b.o
5005 && cc1 -dumpdir g- -dumpbase d.c -dumpbase-ext .c # g-d.o
5008 # gcc [-dumpdir f] -dumpbase g- -save-temps=cwd b.c d.c -o dir/h.out
5009 -> cc1 -dumpdir g- -dumpbase b.c -dumpbase-ext .c # g-b.o
5010 && cc1 -dumpdir g- -dumpbase d.c -dumpbase-ext .c # g-d.o
5011 && link -o dir/h.out
5013 Now, if the linker output is NOT overridden as a prefix, but
5014 -save-temps=* overrides implicit or explicit -dumpdir, the
5015 effective dump dir combines the dir selected by the -save-temps=*
5016 option with the basename of the specified or implied link output:
5018 # gcc [-dumpdir f] -save-temps=cwd b.c d.c -o dir/h.out
5019 -> cc1 -dumpdir h- -dumpbase b.c -dumpbase-ext .c # h-b.o
5020 && cc1 -dumpdir h- -dumpbase d.c -dumpbase-ext .c # h-d.o
5021 && link -o dir/h.out
5023 # gcc [-dumpdir f] -save-temps=obj b.c d.c -o dir/h.out
5024 -> cc1 -dumpdir dir/h- -dumpbase b.c -dumpbase-ext .c # dir/h-b.o
5025 && cc1 -dumpdir dir/h- -dumpbase d.c -dumpbase-ext .c # dir/h-d.o
5026 && link -o dir/h.out
5028 But then again, a single -dumpbase applying to multiple inputs
5029 gets used instead of the linker output basename in the combined
5032 # gcc [-dumpdir f] -dumpbase g- -save-temps=obj b.c d.c -o dir/h.out
5033 -> cc1 -dumpdir dir/g- -dumpbase b.c -dumpbase-ext .c # dir/g-b.o
5034 && cc1 -dumpdir dir/g- -dumpbase d.c -dumpbase-ext .c # dir/g-d.o
5035 && link -o dir/h.out
5037 With a single input being compiled, the output basename does NOT
5038 affect the dumpdir prefix.
5040 # gcc -save-temps=obj b.c -gsplit-dwarf -c -o dir/b.o
5041 -> cc1 -dumpdir dir/ -dumpbase b.c -dumpbase-ext .c # dir/b.o dir/b.dwo
5043 but when compiling and linking even a single file, it does:
5045 # gcc -save-temps=obj b.c -o dir/h.out
5046 -> cc1 -dumpdir dir/h- -dumpbase b.c -dumpbase-ext .c # dir/h-b.o
5048 unless an explicit -dumpdir prevails:
5050 # gcc -save-temps[=obj] -dumpdir g- b.c -o dir/h.out
5051 -> cc1 -dumpdir g- -dumpbase b.c -dumpbase-ext .c # g-b.o
5055 bool explicit_dumpdir
= dumpdir
;
5057 if ((!save_temps_overrides_dumpdir
&& explicit_dumpdir
)
5058 || (output_file
&& not_actual_file_p (output_file
)))
5063 /* If -save-temps=obj and -o name, create the prefix to use for %b.
5064 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
5065 else if (save_temps_flag
!= SAVE_TEMPS_CWD
&& output_file
!= NULL
)
5069 temp
= lbasename (output_file
);
5070 if (temp
!= output_file
)
5071 dumpdir
= xstrndup (output_file
,
5072 strlen (output_file
) - strlen (temp
));
5080 if (save_temps_flag
)
5081 save_temps_flag
= SAVE_TEMPS_DUMP
;
5083 /* If there is any pathname component in an explicit -dumpbase, it
5084 overrides dumpdir entirely, so discard it right away. Although
5085 the presence of an explicit -dumpdir matters for the driver, it
5086 shouldn't matter for other processes, that get all that's needed
5087 from the -dumpdir and -dumpbase always passed to them. */
5088 if (dumpdir
&& dumpbase
&& lbasename (dumpbase
) != dumpbase
)
5094 /* Check that dumpbase_ext matches the end of dumpbase, drop it
5096 if (dumpbase_ext
&& dumpbase
&& *dumpbase
)
5098 int lendb
= strlen (dumpbase
);
5099 int lendbx
= strlen (dumpbase_ext
);
5101 /* -dumpbase-ext must be a suffix proper; discard it if it
5102 matches all of -dumpbase, as that would make for an empty
5105 || strcmp (dumpbase
+ lendb
- lendbx
, dumpbase_ext
) != 0)
5107 free (dumpbase_ext
);
5108 dumpbase_ext
= NULL
;
5112 /* -dumpbase with multiple sources goes into dumpdir. With a single
5113 source, it does only if linking and if dumpdir was not explicitly
5115 if (dumpbase
&& *dumpbase
5116 && (single_input_file_index () == -2
5117 || (!have_c
&& !explicit_dumpdir
)))
5122 /* We checked that they match above. */
5123 dumpbase
[strlen (dumpbase
) - strlen (dumpbase_ext
)] = '\0';
5126 prefix
= concat (dumpdir
, dumpbase
, "-", NULL
);
5128 prefix
= concat (dumpbase
, "-", NULL
);
5132 free (dumpbase_ext
);
5133 dumpbase
= dumpbase_ext
= NULL
;
5135 dumpdir_trailing_dash_added
= true;
5138 /* If dumpbase was not brought into dumpdir but we're linking, bring
5139 output_file into dumpdir unless dumpdir was explicitly specified.
5140 The test for !explicit_dumpdir is further below, because we want
5141 to use the obase computation for a ghost outbase, passed to
5142 GCC_COLLECT_OPTIONS. */
5143 else if (!have_c
&& (!explicit_dumpdir
|| (dumpbase
&& !*dumpbase
)))
5145 /* If we get here, we know dumpbase was not specified, or it was
5146 specified as an empty string. If it was anything else, it
5147 would have combined with dumpdir above, because the condition
5148 for dumpbase to be used when present is broader than the
5149 condition that gets us here. */
5150 gcc_assert (!dumpbase
|| !*dumpbase
);
5153 char *tofree
= NULL
;
5154 if (!output_file
|| not_actual_file_p (output_file
))
5158 obase
= lbasename (output_file
);
5159 size_t blen
= strlen (obase
), xlen
;
5160 /* Drop the suffix if it's dumpbase_ext, if given,
5161 otherwise .exe or the target executable suffix, or if the
5162 output was explicitly named a.out, but not otherwise. */
5164 ? (blen
> (xlen
= strlen (dumpbase_ext
))
5165 && strcmp ((temp
= (obase
+ blen
- xlen
)),
5167 : ((temp
= strrchr (obase
+ 1, '.'))
5168 && (xlen
= strlen (temp
))
5169 && (strcmp (temp
, ".exe") == 0
5170 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
5171 || strcmp (temp
, TARGET_EXECUTABLE_SUFFIX
) == 0
5173 || strcmp (obase
, "a.out") == 0)))
5175 tofree
= xstrndup (obase
, blen
- xlen
);
5180 /* We wish to save this basename to the -dumpdir passed through
5181 GCC_COLLECT_OPTIONS within maybe_run_linker, for e.g. LTO,
5182 but we do NOT wish to add it to e.g. %b, so we keep
5183 outbase_length as zero. */
5184 gcc_assert (!outbase
);
5187 /* If we're building [dir1/]foo[.exe] out of a single input
5188 [dir2/]foo.c that shares the same basename, dump to
5189 [dir2/]foo.c.* rather than duplicating the basename into
5190 [dir2/]foo-foo.c.*. */
5193 || ((idxin
= single_input_file_index ()) >= 0
5194 && adds_single_suffix_p (lbasename (infiles
[idxin
].name
),
5197 if (obase
== tofree
)
5201 outbase
= xstrdup (obase
);
5204 obase
= tofree
= NULL
;
5210 char *p
= concat (dumpdir
, obase
, "-", NULL
);
5215 dumpdir
= concat (obase
, "-", NULL
);
5217 dumpdir_trailing_dash_added
= true;
5220 obase
= tofree
= NULL
;
5223 if (!explicit_dumpdir
|| dumpbase
)
5225 /* Absent -dumpbase and present -dumpbase-ext have been applied
5226 to the linker output name, so compute fresh defaults for each
5228 free (dumpbase_ext
);
5229 dumpbase_ext
= NULL
;
5233 /* Now, if we're compiling, or if we haven't used the dumpbase
5234 above, then outbase (%B) is derived from dumpbase, if given, or
5235 from the output name, given or implied. We can't precompute
5236 implied output names, but that's ok, since they're derived from
5237 input names. Just make sure we skip this if dumpbase is the
5238 empty string: we want to use input names then, so don't set
5240 if ((dumpbase
|| have_c
)
5241 && !(dumpbase
&& !*dumpbase
))
5243 gcc_assert (!outbase
);
5247 gcc_assert (single_input_file_index () != -2);
5248 /* We do not want lbasename here; dumpbase with dirnames
5249 overrides dumpdir entirely, even if dumpdir is
5252 /* We've already checked above that the suffix matches. */
5253 outbase
= xstrndup (dumpbase
,
5254 strlen (dumpbase
) - strlen (dumpbase_ext
));
5256 outbase
= xstrdup (dumpbase
);
5258 else if (output_file
&& !not_actual_file_p (output_file
))
5260 outbase
= xstrdup (lbasename (output_file
));
5261 char *p
= strrchr (outbase
+ 1, '.');
5267 outbase_length
= strlen (outbase
);
5270 /* If there is any pathname component in an explicit -dumpbase, do
5271 not use dumpdir, but retain it to pass it on to the compiler. */
5273 dumpdir_length
= strlen (dumpdir
);
5277 /* Check that dumpbase_ext, if still present, still matches the end
5278 of dumpbase, if present, and drop it otherwise. We only retained
5279 it above when dumpbase was absent to maybe use it to drop the
5280 extension from output_name before combining it with dumpdir. We
5281 won't deal with -dumpbase-ext when -dumpbase is not explicitly
5282 given, even if just to activate backward-compatible dumpbase:
5283 dropping it on the floor is correct, expected and documented
5284 behavior. Attempting to deal with a -dumpbase-ext that might
5285 match the end of some input filename, or of the combination of
5286 the output basename with the suffix of the input filename,
5287 possible with an intermediate .gk extension for -fcompare-debug,
5288 is just calling for trouble. */
5291 if (!dumpbase
|| !*dumpbase
)
5293 free (dumpbase_ext
);
5294 dumpbase_ext
= NULL
;
5297 gcc_assert (strcmp (dumpbase
+ strlen (dumpbase
)
5298 - strlen (dumpbase_ext
), dumpbase_ext
) == 0);
5301 if (save_temps_flag
&& use_pipes
)
5303 /* -save-temps overrides -pipe, so that temp files are produced */
5304 if (save_temps_flag
)
5305 warning (0, "%<-pipe%> ignored because %<-save-temps%> specified");
5311 const char *gcd
= env
.get ("GCC_COMPARE_DEBUG");
5313 if (gcd
&& gcd
[0] == '-')
5316 compare_debug_opt
= gcd
;
5318 else if (gcd
&& *gcd
&& strcmp (gcd
, "0"))
5321 compare_debug_opt
= "-gtoggle";
5324 else if (compare_debug
< 0)
5327 gcc_assert (!compare_debug_opt
);
5330 /* Set up the search paths. We add directories that we expect to
5331 contain GNU Toolchain components before directories specified by
5332 the machine description so that we will find GNU components (like
5333 the GNU assembler) before those of the host system. */
5335 /* If we don't know where the toolchain has been installed, use the
5336 configured-in locations. */
5337 if (!gcc_exec_prefix
)
5340 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "GCC",
5341 PREFIX_PRIORITY_LAST
, 1, 0);
5342 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "BINUTILS",
5343 PREFIX_PRIORITY_LAST
, 2, 0);
5344 add_prefix (&exec_prefixes
, standard_exec_prefix
, "BINUTILS",
5345 PREFIX_PRIORITY_LAST
, 2, 0);
5347 add_prefix (&startfile_prefixes
, standard_exec_prefix
, "BINUTILS",
5348 PREFIX_PRIORITY_LAST
, 1, 0);
5351 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix
));
5352 tooldir_prefix2
= concat (tooldir_base_prefix
, spec_machine
,
5353 dir_separator_str
, NULL
);
5355 /* Look for tools relative to the location from which the driver is
5356 running, or, if that is not available, the configured prefix. */
5358 = concat (gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
5359 spec_host_machine
, dir_separator_str
, spec_version
,
5360 accel_dir_suffix
, dir_separator_str
, tooldir_prefix2
, NULL
);
5361 free (tooldir_prefix2
);
5363 add_prefix (&exec_prefixes
,
5364 concat (tooldir_prefix
, "bin", dir_separator_str
, NULL
),
5365 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 0);
5366 add_prefix (&startfile_prefixes
,
5367 concat (tooldir_prefix
, "lib", dir_separator_str
, NULL
),
5368 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 1);
5369 free (tooldir_prefix
);
5371 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
5372 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
5373 then consider it to relocate with the rest of the GCC installation
5374 if GCC_EXEC_PREFIX is set.
5375 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
5376 if (target_system_root
&& !target_system_root_changed
&& gcc_exec_prefix
)
5378 char *tmp_prefix
= get_relative_prefix (decoded_options
[0].arg
,
5379 standard_bindir_prefix
,
5380 target_system_root
);
5381 if (tmp_prefix
&& access_check (tmp_prefix
, F_OK
) == 0)
5383 target_system_root
= tmp_prefix
;
5384 target_system_root_changed
= 1;
5389 /* More prefixes are enabled in main, after we read the specs file
5390 and determine whether this is cross-compilation or not. */
5392 if (n_infiles
!= 0 && n_infiles
== last_language_n_infiles
&& spec_lang
!= 0)
5393 warning (0, "%<-x %s%> after last input file has no effect", spec_lang
);
5395 /* Synthesize -fcompare-debug flag from the GCC_COMPARE_DEBUG
5396 environment variable. */
5397 if (compare_debug
== 2 || compare_debug
== 3)
5399 const char *opt
= concat ("-fcompare-debug=", compare_debug_opt
, NULL
);
5400 save_switch (opt
, 0, NULL
, false, true);
5404 /* Ensure we only invoke each subprocess once. */
5406 && (print_subprocess_help
|| print_help_list
|| print_version
))
5408 /* Create a dummy input file, so that we can pass
5409 the help option on to the various sub-processes. */
5410 add_infile ("help-dummy", "c");
5413 /* Decide if undefined variable references are allowed in specs. */
5415 /* -v alone is safe. --version and --help alone or together are safe. Note
5416 that -v would make them unsafe, as they'd then be run for subprocesses as
5417 well, the location of which might depend on variables possibly coming
5418 from self-specs. Note also that the command name is counted in
5419 decoded_options_count. */
5421 unsigned help_version_count
= 0;
5424 help_version_count
++;
5426 if (print_help_list
)
5427 help_version_count
++;
5429 spec_undefvar_allowed
=
5430 ((verbose_flag
&& decoded_options_count
== 2)
5431 || help_version_count
== decoded_options_count
- 1);
5434 switches
[n_switches
].part1
= 0;
5436 infiles
[n_infiles
].name
= 0;
5439 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
5440 and place that in the environment. */
5443 set_collect_gcc_options (void)
5448 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
5450 obstack_grow (&collect_obstack
, "COLLECT_GCC_OPTIONS=",
5451 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
5454 for (i
= 0; (int) i
< n_switches
; i
++)
5456 const char *const *args
;
5459 obstack_grow (&collect_obstack
, " ", 1);
5463 /* Ignore elided switches. */
5464 if ((switches
[i
].live_cond
5465 & (SWITCH_IGNORE
| SWITCH_KEEP_FOR_GCC
))
5469 obstack_grow (&collect_obstack
, "'-", 2);
5470 q
= switches
[i
].part1
;
5471 while ((p
= strchr (q
, '\'')))
5473 obstack_grow (&collect_obstack
, q
, p
- q
);
5474 obstack_grow (&collect_obstack
, "'\\''", 4);
5477 obstack_grow (&collect_obstack
, q
, strlen (q
));
5478 obstack_grow (&collect_obstack
, "'", 1);
5480 for (args
= switches
[i
].args
; args
&& *args
; args
++)
5482 obstack_grow (&collect_obstack
, " '", 2);
5484 while ((p
= strchr (q
, '\'')))
5486 obstack_grow (&collect_obstack
, q
, p
- q
);
5487 obstack_grow (&collect_obstack
, "'\\''", 4);
5490 obstack_grow (&collect_obstack
, q
, strlen (q
));
5491 obstack_grow (&collect_obstack
, "'", 1);
5498 obstack_grow (&collect_obstack
, " ", 1);
5501 obstack_grow (&collect_obstack
, "'-dumpdir' '", 12);
5505 while ((p
= strchr (q
, '\'')))
5507 obstack_grow (&collect_obstack
, q
, p
- q
);
5508 obstack_grow (&collect_obstack
, "'\\''", 4);
5511 obstack_grow (&collect_obstack
, q
, strlen (q
));
5513 obstack_grow (&collect_obstack
, "'", 1);
5516 obstack_grow (&collect_obstack
, "\0", 1);
5517 xputenv (XOBFINISH (&collect_obstack
, char *));
5520 /* Process a spec string, accumulating and running commands. */
5522 /* These variables describe the input file name.
5523 input_file_number is the index on outfiles of this file,
5524 so that the output file name can be stored for later use by %o.
5525 input_basename is the start of the part of the input file
5526 sans all directory names, and basename_length is the number
5527 of characters starting there excluding the suffix .c or whatever. */
5529 static const char *gcc_input_filename
;
5530 static int input_file_number
;
5531 size_t input_filename_length
;
5532 static int basename_length
;
5533 static int suffixed_basename_length
;
5534 static const char *input_basename
;
5535 static const char *input_suffix
;
5536 #ifndef HOST_LACKS_INODE_NUMBERS
5537 static struct stat input_stat
;
5539 static int input_stat_set
;
5541 /* The compiler used to process the current input file. */
5542 static struct compiler
*input_file_compiler
;
5544 /* These are variables used within do_spec and do_spec_1. */
5546 /* Nonzero if an arg has been started and not yet terminated
5547 (with space, tab or newline). */
5548 static int arg_going
;
5550 /* Nonzero means %d or %g has been seen; the next arg to be terminated
5551 is a temporary file name. */
5552 static int delete_this_arg
;
5554 /* Nonzero means %w has been seen; the next arg to be terminated
5555 is the output file name of this compilation. */
5556 static int this_is_output_file
;
5558 /* Nonzero means %s has been seen; the next arg to be terminated
5559 is the name of a library file and we should try the standard
5560 search dirs for it. */
5561 static int this_is_library_file
;
5563 /* Nonzero means %T has been seen; the next arg to be terminated
5564 is the name of a linker script and we should try all of the
5565 standard search dirs for it. If it is found insert a --script
5566 command line switch and then substitute the full path in place,
5567 otherwise generate an error message. */
5568 static int this_is_linker_script
;
5570 /* Nonzero means that the input of this command is coming from a pipe. */
5571 static int input_from_pipe
;
5573 /* Nonnull means substitute this for any suffix when outputting a switches
5575 static const char *suffix_subst
;
5577 /* If there is an argument being accumulated, terminate it and store it. */
5580 end_going_arg (void)
5586 obstack_1grow (&obstack
, 0);
5587 string
= XOBFINISH (&obstack
, const char *);
5588 if (this_is_library_file
)
5589 string
= find_file (string
);
5590 if (this_is_linker_script
)
5592 char * full_script_path
= find_a_file (&startfile_prefixes
, string
, R_OK
, true);
5594 if (full_script_path
== NULL
)
5596 error ("unable to locate default linker script %qs in the library search paths", string
);
5597 /* Script was not found on search path. */
5600 store_arg ("--script", false, false);
5601 string
= full_script_path
;
5603 store_arg (string
, delete_this_arg
, this_is_output_file
);
5604 if (this_is_output_file
)
5605 outfiles
[input_file_number
] = string
;
5611 /* Parse the WRAPPER string which is a comma separated list of the command line
5612 and insert them into the beginning of argbuf. */
5615 insert_wrapper (const char *wrapper
)
5619 char *buf
= xstrdup (wrapper
);
5621 unsigned int old_length
= argbuf
.length ();
5629 while ((p
= strchr (p
, ',')) != NULL
);
5631 argbuf
.safe_grow (old_length
+ n
, true);
5632 memmove (argbuf
.address () + n
,
5634 old_length
* sizeof (const_char_p
));
5648 while ((p
= strchr (p
, ',')) != NULL
);
5649 gcc_assert (i
== n
);
5652 /* Process the spec SPEC and run the commands specified therein.
5653 Returns 0 if the spec is successfully processed; -1 if failed. */
5656 do_spec (const char *spec
)
5660 value
= do_spec_2 (spec
, NULL
);
5662 /* Force out any unfinished command.
5663 If -pipe, this forces out the last command if it ended in `|'. */
5666 if (argbuf
.length () > 0
5667 && !strcmp (argbuf
.last (), "|"))
5670 set_collect_gcc_options ();
5672 if (argbuf
.length () > 0)
5679 /* Process the spec SPEC, with SOFT_MATCHED_PART designating the current value
5680 of a matched * pattern which may be re-injected by way of %*. */
5683 do_spec_2 (const char *spec
, const char *soft_matched_part
)
5689 delete_this_arg
= 0;
5690 this_is_output_file
= 0;
5691 this_is_library_file
= 0;
5692 this_is_linker_script
= 0;
5693 input_from_pipe
= 0;
5694 suffix_subst
= NULL
;
5696 result
= do_spec_1 (spec
, 0, soft_matched_part
);
5703 /* Process the given spec string and add any new options to the end
5704 of the switches/n_switches array. */
5707 do_option_spec (const char *name
, const char *spec
)
5709 unsigned int i
, value_count
, value_len
;
5710 const char *p
, *q
, *value
;
5711 char *tmp_spec
, *tmp_spec_p
;
5713 if (configure_default_options
[0].name
== NULL
)
5716 for (i
= 0; i
< ARRAY_SIZE (configure_default_options
); i
++)
5717 if (strcmp (configure_default_options
[i
].name
, name
) == 0)
5719 if (i
== ARRAY_SIZE (configure_default_options
))
5722 value
= configure_default_options
[i
].value
;
5723 value_len
= strlen (value
);
5725 /* Compute the size of the final spec. */
5728 while ((p
= strstr (p
, "%(VALUE)")) != NULL
)
5734 /* Replace each %(VALUE) by the specified value. */
5735 tmp_spec
= (char *) alloca (strlen (spec
) + 1
5736 + value_count
* (value_len
- strlen ("%(VALUE)")));
5737 tmp_spec_p
= tmp_spec
;
5739 while ((p
= strstr (q
, "%(VALUE)")) != NULL
)
5741 memcpy (tmp_spec_p
, q
, p
- q
);
5742 tmp_spec_p
= tmp_spec_p
+ (p
- q
);
5743 memcpy (tmp_spec_p
, value
, value_len
);
5744 tmp_spec_p
+= value_len
;
5745 q
= p
+ strlen ("%(VALUE)");
5747 strcpy (tmp_spec_p
, q
);
5749 do_self_spec (tmp_spec
);
5752 /* Process the given spec string and add any new options to the end
5753 of the switches/n_switches array. */
5756 do_self_spec (const char *spec
)
5760 do_spec_2 (spec
, NULL
);
5761 do_spec_1 (" ", 0, NULL
);
5763 /* Mark %<S switches processed by do_self_spec to be ignored permanently.
5764 do_self_specs adds the replacements to switches array, so it shouldn't
5765 be processed afterwards. */
5766 for (i
= 0; i
< n_switches
; i
++)
5767 if ((switches
[i
].live_cond
& SWITCH_IGNORE
))
5768 switches
[i
].live_cond
|= SWITCH_IGNORE_PERMANENTLY
;
5770 if (argbuf
.length () > 0)
5772 const char **argbuf_copy
;
5773 struct cl_decoded_option
*decoded_options
;
5774 struct cl_option_handlers handlers
;
5775 unsigned int decoded_options_count
;
5778 /* Create a copy of argbuf with a dummy argv[0] entry for
5779 decode_cmdline_options_to_array. */
5780 argbuf_copy
= XNEWVEC (const char *,
5781 argbuf
.length () + 1);
5782 argbuf_copy
[0] = "";
5783 memcpy (argbuf_copy
+ 1, argbuf
.address (),
5784 argbuf
.length () * sizeof (const char *));
5786 decode_cmdline_options_to_array (argbuf
.length () + 1,
5788 CL_DRIVER
, &decoded_options
,
5789 &decoded_options_count
);
5792 set_option_handlers (&handlers
);
5794 for (j
= 1; j
< decoded_options_count
; j
++)
5796 switch (decoded_options
[j
].opt_index
)
5798 case OPT_SPECIAL_input_file
:
5799 /* Specs should only generate options, not input
5801 if (strcmp (decoded_options
[j
].arg
, "-") != 0)
5802 fatal_error (input_location
,
5803 "switch %qs does not start with %<-%>",
5804 decoded_options
[j
].arg
);
5806 fatal_error (input_location
,
5807 "spec-generated switch is just %<-%>");
5810 case OPT_fcompare_debug_second
:
5811 case OPT_fcompare_debug
:
5812 case OPT_fcompare_debug_
:
5814 /* Avoid duplicate processing of some options from
5815 compare-debug specs; just save them here. */
5816 save_switch (decoded_options
[j
].canonical_option
[0],
5817 (decoded_options
[j
].canonical_option_num_elements
5819 &decoded_options
[j
].canonical_option
[1], false, true);
5823 read_cmdline_option (&global_options
, &global_options_set
,
5824 decoded_options
+ j
, UNKNOWN_LOCATION
,
5825 CL_DRIVER
, &handlers
, global_dc
);
5830 free (decoded_options
);
5833 switches
[n_switches
].part1
= 0;
5837 /* Callback for processing %D and %I specs. */
5839 struct spec_path_info
{
5844 bool separate_options
;
5848 spec_path (char *path
, void *data
)
5850 struct spec_path_info
*info
= (struct spec_path_info
*) data
;
5854 if (info
->omit_relative
&& !IS_ABSOLUTE_PATH (path
))
5857 if (info
->append_len
!= 0)
5859 len
= strlen (path
);
5860 memcpy (path
+ len
, info
->append
, info
->append_len
+ 1);
5863 if (!is_directory (path
, true))
5866 do_spec_1 (info
->option
, 1, NULL
);
5867 if (info
->separate_options
)
5868 do_spec_1 (" ", 0, NULL
);
5870 if (info
->append_len
== 0)
5872 len
= strlen (path
);
5873 save
= path
[len
- 1];
5874 if (IS_DIR_SEPARATOR (path
[len
- 1]))
5875 path
[len
- 1] = '\0';
5878 do_spec_1 (path
, 1, NULL
);
5879 do_spec_1 (" ", 0, NULL
);
5881 /* Must not damage the original path. */
5882 if (info
->append_len
== 0)
5883 path
[len
- 1] = save
;
5888 /* True if we should compile INFILE. */
5891 compile_input_file_p (struct infile
*infile
)
5893 if ((!infile
->language
) || (infile
->language
[0] != '*'))
5894 if (infile
->incompiler
== input_file_compiler
)
5899 /* Process each member of VEC as a spec. */
5902 do_specs_vec (vec
<char_p
> vec
)
5904 for (char *opt
: vec
)
5906 do_spec_1 (opt
, 1, NULL
);
5907 /* Make each accumulated option a separate argument. */
5908 do_spec_1 (" ", 0, NULL
);
5912 /* Add options passed via -Xassembler or -Wa to COLLECT_AS_OPTIONS. */
5915 putenv_COLLECT_AS_OPTIONS (vec
<char_p
> vec
)
5917 if (vec
.is_empty ())
5920 obstack_init (&collect_obstack
);
5921 obstack_grow (&collect_obstack
, "COLLECT_AS_OPTIONS=",
5922 strlen ("COLLECT_AS_OPTIONS="));
5927 FOR_EACH_VEC_ELT (vec
, ix
, opt
)
5929 obstack_1grow (&collect_obstack
, '\'');
5930 obstack_grow (&collect_obstack
, opt
, strlen (opt
));
5931 obstack_1grow (&collect_obstack
, '\'');
5932 if (ix
< vec
.length () - 1)
5933 obstack_1grow(&collect_obstack
, ' ');
5936 obstack_1grow (&collect_obstack
, '\0');
5937 xputenv (XOBFINISH (&collect_obstack
, char *));
5940 /* Process the sub-spec SPEC as a portion of a larger spec.
5941 This is like processing a whole spec except that we do
5942 not initialize at the beginning and we do not supply a
5943 newline by default at the end.
5944 INSWITCH nonzero means don't process %-sequences in SPEC;
5945 in this case, % is treated as an ordinary character.
5946 This is used while substituting switches.
5947 INSWITCH nonzero also causes SPC not to terminate an argument.
5949 Value is zero unless a line was finished
5950 and the command on that line reported an error. */
5953 do_spec_1 (const char *spec
, int inswitch
, const char *soft_matched_part
)
5955 const char *p
= spec
;
5960 /* If it's an empty string argument to a switch, keep it as is. */
5961 if (inswitch
&& !*p
)
5965 /* If substituting a switch, treat all chars like letters.
5966 Otherwise, NL, SPC, TAB and % are special. */
5967 switch (inswitch
? 'a' : c
)
5972 if (argbuf
.length () > 0
5973 && !strcmp (argbuf
.last (), "|"))
5975 /* A `|' before the newline means use a pipe here,
5976 but only if -pipe was specified.
5977 Otherwise, execute now and don't pass the `|' as an arg. */
5980 input_from_pipe
= 1;
5987 set_collect_gcc_options ();
5989 if (argbuf
.length () > 0)
5995 /* Reinitialize for a new command, and for a new argument. */
5998 delete_this_arg
= 0;
5999 this_is_output_file
= 0;
6000 this_is_library_file
= 0;
6001 this_is_linker_script
= 0;
6002 input_from_pipe
= 0;
6009 obstack_1grow (&obstack
, c
);
6017 /* Reinitialize for a new argument. */
6018 delete_this_arg
= 0;
6019 this_is_output_file
= 0;
6020 this_is_library_file
= 0;
6021 this_is_linker_script
= 0;
6028 fatal_error (input_location
, "spec %qs invalid", spec
);
6031 /* Don't use %b in the linker command. */
6032 gcc_assert (suffixed_basename_length
);
6033 if (!this_is_output_file
&& dumpdir_length
)
6034 obstack_grow (&obstack
, dumpdir
, dumpdir_length
);
6035 if (this_is_output_file
|| !outbase_length
)
6036 obstack_grow (&obstack
, input_basename
, basename_length
);
6038 obstack_grow (&obstack
, outbase
, outbase_length
);
6039 if (compare_debug
< 0)
6040 obstack_grow (&obstack
, ".gk", 3);
6045 /* Don't use %B in the linker command. */
6046 gcc_assert (suffixed_basename_length
);
6047 if (!this_is_output_file
&& dumpdir_length
)
6048 obstack_grow (&obstack
, dumpdir
, dumpdir_length
);
6049 if (this_is_output_file
|| !outbase_length
)
6050 obstack_grow (&obstack
, input_basename
, basename_length
);
6052 obstack_grow (&obstack
, outbase
, outbase_length
);
6053 if (compare_debug
< 0)
6054 obstack_grow (&obstack
, ".gk", 3);
6055 obstack_grow (&obstack
, input_basename
+ basename_length
,
6056 suffixed_basename_length
- basename_length
);
6062 delete_this_arg
= 2;
6065 /* Dump out the directories specified with LIBRARY_PATH,
6066 followed by the absolute directories
6067 that we search for startfiles. */
6070 struct spec_path_info info
;
6073 info
.append_len
= 0;
6074 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
6075 /* Used on systems which record the specified -L dirs
6076 and use them to search for dynamic linking.
6077 Relative directories always come from -B,
6078 and it is better not to use them for searching
6079 at run time. In particular, stage1 loses. */
6080 info
.omit_relative
= true;
6082 info
.omit_relative
= false;
6084 info
.separate_options
= false;
6086 for_each_path (&startfile_prefixes
, true, 0, spec_path
, &info
);
6091 /* %efoo means report an error with `foo' as error message
6092 and don't execute any more commands for this file. */
6096 while (*p
!= 0 && *p
!= '\n')
6098 buf
= (char *) alloca (p
- q
+ 1);
6099 strncpy (buf
, q
, p
- q
);
6101 error ("%s", _(buf
));
6106 /* %nfoo means report a notice with `foo' on stderr. */
6110 while (*p
!= 0 && *p
!= '\n')
6112 buf
= (char *) alloca (p
- q
+ 1);
6113 strncpy (buf
, q
, p
- q
);
6115 inform (UNKNOWN_LOCATION
, "%s", _(buf
));
6125 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
6126 defined, and it is not a directory, and it is
6127 writable, use it. Otherwise, treat this like any
6128 other temporary file. */
6130 if ((!save_temps_flag
)
6131 && (stat (HOST_BIT_BUCKET
, &st
) == 0) && (!S_ISDIR (st
.st_mode
))
6132 && (access (HOST_BIT_BUCKET
, W_OK
) == 0))
6134 obstack_grow (&obstack
, HOST_BIT_BUCKET
,
6135 strlen (HOST_BIT_BUCKET
));
6136 delete_this_arg
= 0;
6141 goto create_temp_file
;
6145 obstack_1grow (&obstack
, '-');
6146 delete_this_arg
= 0;
6149 /* consume suffix */
6150 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
6152 if (p
[0] == '%' && p
[1] == 'O')
6157 goto create_temp_file
;
6161 /* consume suffix */
6162 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
6164 if (p
[0] == '%' && p
[1] == 'O')
6169 goto create_temp_file
;
6175 struct temp_name
*t
;
6177 const char *suffix
= p
;
6178 char *saved_suffix
= NULL
;
6180 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
6182 suffix_length
= p
- suffix
;
6183 if (p
[0] == '%' && p
[1] == 'O')
6186 /* We don't support extra suffix characters after %O. */
6187 if (*p
== '.' || ISALNUM ((unsigned char) *p
))
6188 fatal_error (input_location
,
6189 "spec %qs has invalid %<%%0%c%>", spec
, *p
);
6190 if (suffix_length
== 0)
6191 suffix
= TARGET_OBJECT_SUFFIX
;
6195 = XNEWVEC (char, suffix_length
6196 + strlen (TARGET_OBJECT_SUFFIX
) + 1);
6197 strncpy (saved_suffix
, suffix
, suffix_length
);
6198 strcpy (saved_suffix
+ suffix_length
,
6199 TARGET_OBJECT_SUFFIX
);
6201 suffix_length
+= strlen (TARGET_OBJECT_SUFFIX
);
6204 if (compare_debug
< 0)
6206 suffix
= concat (".gk", suffix
, NULL
);
6210 /* If -save-temps was specified, use that for the
6212 if (save_temps_flag
)
6215 bool adjusted_suffix
= false;
6217 && !outbase_length
&& !basename_length
6218 && !dumpdir_trailing_dash_added
)
6220 adjusted_suffix
= true;
6224 temp_filename_length
6225 = dumpdir_length
+ suffix_length
+ 1;
6227 temp_filename_length
+= outbase_length
;
6229 temp_filename_length
+= basename_length
;
6230 tmp
= (char *) alloca (temp_filename_length
);
6232 memcpy (tmp
, dumpdir
, dumpdir_length
);
6234 memcpy (tmp
+ dumpdir_length
, outbase
,
6236 else if (basename_length
)
6237 memcpy (tmp
+ dumpdir_length
, input_basename
,
6239 memcpy (tmp
+ temp_filename_length
- suffix_length
- 1,
6240 suffix
, suffix_length
);
6241 if (adjusted_suffix
)
6243 adjusted_suffix
= false;
6247 tmp
[temp_filename_length
- 1] = '\0';
6248 temp_filename
= tmp
;
6250 if (filename_cmp (temp_filename
, gcc_input_filename
) != 0)
6252 #ifndef HOST_LACKS_INODE_NUMBERS
6253 struct stat st_temp
;
6255 /* Note, set_input() resets input_stat_set to 0. */
6256 if (input_stat_set
== 0)
6258 input_stat_set
= stat (gcc_input_filename
,
6260 if (input_stat_set
>= 0)
6264 /* If we have the stat for the gcc_input_filename
6265 and we can do the stat for the temp_filename
6266 then the they could still refer to the same
6267 file if st_dev/st_ino's are the same. */
6268 if (input_stat_set
!= 1
6269 || stat (temp_filename
, &st_temp
) < 0
6270 || input_stat
.st_dev
!= st_temp
.st_dev
6271 || input_stat
.st_ino
!= st_temp
.st_ino
)
6273 /* Just compare canonical pathnames. */
6274 char* input_realname
= lrealpath (gcc_input_filename
);
6275 char* temp_realname
= lrealpath (temp_filename
);
6276 bool files_differ
= filename_cmp (input_realname
, temp_realname
);
6277 free (input_realname
);
6278 free (temp_realname
);
6283 = save_string (temp_filename
,
6284 temp_filename_length
- 1);
6285 obstack_grow (&obstack
, temp_filename
,
6286 temp_filename_length
);
6288 delete_this_arg
= 0;
6294 /* See if we already have an association of %g/%u/%U and
6296 for (t
= temp_names
; t
; t
= t
->next
)
6297 if (t
->length
== suffix_length
6298 && strncmp (t
->suffix
, suffix
, suffix_length
) == 0
6299 && t
->unique
== (c
== 'u' || c
== 'U' || c
== 'j'))
6302 /* Make a new association if needed. %u and %j
6304 if (t
== 0 || c
== 'u' || c
== 'j')
6308 t
= XNEW (struct temp_name
);
6309 t
->next
= temp_names
;
6312 t
->length
= suffix_length
;
6315 t
->suffix
= saved_suffix
;
6316 saved_suffix
= NULL
;
6319 t
->suffix
= save_string (suffix
, suffix_length
);
6320 t
->unique
= (c
== 'u' || c
== 'U' || c
== 'j');
6321 temp_filename
= make_temp_file (t
->suffix
);
6322 temp_filename_length
= strlen (temp_filename
);
6323 t
->filename
= temp_filename
;
6324 t
->filename_length
= temp_filename_length
;
6327 free (saved_suffix
);
6329 obstack_grow (&obstack
, t
->filename
, t
->filename_length
);
6330 delete_this_arg
= 1;
6338 /* We are going to expand `%i' into `@FILE', where FILE
6339 is a newly-created temporary filename. The filenames
6340 that would usually be expanded in place of %o will be
6341 written to the temporary file. */
6342 if (at_file_supplied
)
6345 for (i
= 0; (int) i
< n_infiles
; i
++)
6346 if (compile_input_file_p (&infiles
[i
]))
6348 store_arg (infiles
[i
].name
, 0, 0);
6349 infiles
[i
].compiled
= true;
6352 if (at_file_supplied
)
6357 obstack_grow (&obstack
, gcc_input_filename
,
6358 input_filename_length
);
6365 struct spec_path_info info
;
6369 do_spec_1 ("-imultilib", 1, NULL
);
6370 /* Make this a separate argument. */
6371 do_spec_1 (" ", 0, NULL
);
6372 do_spec_1 (multilib_dir
, 1, NULL
);
6373 do_spec_1 (" ", 0, NULL
);
6378 do_spec_1 ("-imultiarch", 1, NULL
);
6379 /* Make this a separate argument. */
6380 do_spec_1 (" ", 0, NULL
);
6381 do_spec_1 (multiarch_dir
, 1, NULL
);
6382 do_spec_1 (" ", 0, NULL
);
6385 if (gcc_exec_prefix
)
6387 do_spec_1 ("-iprefix", 1, NULL
);
6388 /* Make this a separate argument. */
6389 do_spec_1 (" ", 0, NULL
);
6390 do_spec_1 (gcc_exec_prefix
, 1, NULL
);
6391 do_spec_1 (" ", 0, NULL
);
6394 if (target_system_root_changed
||
6395 (target_system_root
&& target_sysroot_hdrs_suffix
))
6397 do_spec_1 ("-isysroot", 1, NULL
);
6398 /* Make this a separate argument. */
6399 do_spec_1 (" ", 0, NULL
);
6400 do_spec_1 (target_system_root
, 1, NULL
);
6401 if (target_sysroot_hdrs_suffix
)
6402 do_spec_1 (target_sysroot_hdrs_suffix
, 1, NULL
);
6403 do_spec_1 (" ", 0, NULL
);
6406 info
.option
= "-isystem";
6407 info
.append
= "include";
6408 info
.append_len
= strlen (info
.append
);
6409 info
.omit_relative
= false;
6410 info
.separate_options
= true;
6412 for_each_path (&include_prefixes
, false, info
.append_len
,
6415 info
.append
= "include-fixed";
6416 if (*sysroot_hdrs_suffix_spec
)
6417 info
.append
= concat (info
.append
, dir_separator_str
,
6418 multilib_dir
, NULL
);
6419 info
.append_len
= strlen (info
.append
);
6420 for_each_path (&include_prefixes
, false, info
.append_len
,
6426 /* We are going to expand `%o' into `@FILE', where FILE
6427 is a newly-created temporary filename. The filenames
6428 that would usually be expanded in place of %o will be
6429 written to the temporary file. */
6430 if (at_file_supplied
)
6433 for (i
= 0; i
< n_infiles
+ lang_specific_extra_outfiles
; i
++)
6435 store_arg (outfiles
[i
], 0, 0);
6437 if (at_file_supplied
)
6442 obstack_grow (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
6447 this_is_library_file
= 1;
6451 this_is_linker_script
= 1;
6455 outfiles
[input_file_number
] = NULL
;
6459 this_is_output_file
= 1;
6464 unsigned int cur_index
= argbuf
.length ();
6465 /* Handle the {...} following the %W. */
6467 fatal_error (input_location
,
6468 "spec %qs has invalid %<%%W%c%>", spec
, *p
);
6469 p
= handle_braces (p
+ 1);
6473 /* If any args were output, mark the last one for deletion
6475 if (argbuf
.length () != cur_index
)
6476 record_temp_file (argbuf
.last (), 0, 1);
6481 /* Handle the {...} following the %@. */
6483 fatal_error (input_location
,
6484 "spec %qs has invalid %<%%@%c%>", spec
, *p
);
6485 if (at_file_supplied
)
6487 p
= handle_braces (p
+ 1);
6488 if (at_file_supplied
)
6494 /* %x{OPTION} records OPTION for %X to output. */
6500 /* Skip past the option value and make a copy. */
6502 fatal_error (input_location
,
6503 "spec %qs has invalid %<%%x%c%>", spec
, *p
);
6506 string
= save_string (p1
+ 1, p
- p1
- 2);
6508 /* See if we already recorded this option. */
6509 for (const char *opt
: linker_options
)
6510 if (! strcmp (string
, opt
))
6516 /* This option is new; add it. */
6517 add_linker_option (string
, strlen (string
));
6522 /* Dump out the options accumulated previously using %x. */
6524 do_specs_vec (linker_options
);
6527 /* Dump out the options accumulated previously using -Wa,. */
6529 do_specs_vec (assembler_options
);
6532 /* Dump out the options accumulated previously using -Wp,. */
6534 do_specs_vec (preprocessor_options
);
6537 /* Here are digits and numbers that just process
6538 a certain constant string as a spec. */
6541 value
= do_spec_1 (cc1_spec
, 0, NULL
);
6547 value
= do_spec_1 (cc1plus_spec
, 0, NULL
);
6553 value
= do_spec_1 (asm_spec
, 0, NULL
);
6559 value
= do_spec_1 (asm_final_spec
, 0, NULL
);
6566 const char *const spec
6567 = (input_file_compiler
->cpp_spec
6568 ? input_file_compiler
->cpp_spec
6570 value
= do_spec_1 (spec
, 0, NULL
);
6577 value
= do_spec_1 (endfile_spec
, 0, NULL
);
6583 value
= do_spec_1 (link_spec
, 0, NULL
);
6589 value
= do_spec_1 (lib_spec
, 0, NULL
);
6595 if (multilib_os_dir
== NULL
)
6596 obstack_1grow (&obstack
, '.');
6598 obstack_grow (&obstack
, multilib_os_dir
,
6599 strlen (multilib_os_dir
));
6603 value
= do_spec_1 (libgcc_spec
, 0, NULL
);
6609 /* We assume there is a directory
6610 separator at the end of this string. */
6611 if (target_system_root
)
6613 obstack_grow (&obstack
, target_system_root
,
6614 strlen (target_system_root
));
6615 if (target_sysroot_suffix
)
6616 obstack_grow (&obstack
, target_sysroot_suffix
,
6617 strlen (target_sysroot_suffix
));
6622 value
= do_spec_1 (startfile_spec
, 0, NULL
);
6627 /* Here we define characters other than letters and digits. */
6630 p
= handle_braces (p
);
6636 p
= handle_spec_function (p
, NULL
, soft_matched_part
);
6642 obstack_1grow (&obstack
, '%');
6649 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '%')
6651 suffix_subst
= save_string (p
- 1, len
+ 1);
6656 /* Henceforth ignore the option(s) matching the pattern
6662 int have_wildcard
= 0;
6667 switch_option
= SWITCH_IGNORE
| SWITCH_KEEP_FOR_GCC
;
6669 switch_option
= SWITCH_IGNORE
;
6671 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '\t')
6674 if (p
[len
-1] == '*')
6677 for (i
= 0; i
< n_switches
; i
++)
6678 if (!strncmp (switches
[i
].part1
, p
, len
- have_wildcard
)
6679 && (have_wildcard
|| switches
[i
].part1
[len
] == '\0'))
6681 switches
[i
].live_cond
|= switch_option
;
6682 /* User switch be validated from validate_all_switches.
6683 when the definition is seen from the spec file.
6684 If not defined anywhere, will be rejected. */
6685 if (switches
[i
].known
)
6686 switches
[i
].validated
= true;
6694 if (soft_matched_part
)
6696 if (soft_matched_part
[0])
6697 do_spec_1 (soft_matched_part
, 1, NULL
);
6698 /* Only insert a space after the substitution if it is at the
6699 end of the current sequence. So if:
6701 "%{foo=*:bar%*}%{foo=*:one%*two}"
6703 matches -foo=hello then it will produce:
6705 barhello onehellotwo
6707 if (*p
== 0 || *p
== '}')
6708 do_spec_1 (" ", 0, NULL
);
6711 /* Catch the case where a spec string contains something like
6712 '%{foo:%*}'. i.e. there is no * in the pattern on the left
6713 hand side of the :. */
6714 error ("spec failure: %<%%*%> has not been initialized by pattern match");
6717 /* Process a string found as the value of a spec given by name.
6718 This feature allows individual machine descriptions
6719 to add and use their own specs. */
6722 const char *name
= p
;
6723 struct spec_list
*sl
;
6726 /* The string after the S/P is the name of a spec that is to be
6728 while (*p
&& *p
!= ')')
6731 /* See if it's in the list. */
6732 for (len
= p
- name
, sl
= specs
; sl
; sl
= sl
->next
)
6733 if (sl
->name_len
== len
&& !strncmp (sl
->name
, name
, len
))
6735 name
= *(sl
->ptr_spec
);
6737 fnotice (stderr
, "Processing spec (%s), which is '%s'\n",
6745 value
= do_spec_1 (name
, 0, NULL
);
6750 /* Discard the closing paren. */
6757 /* End a previous argument, if there is one, then issue an
6765 error ("spec failure: unrecognized spec option %qc", c
);
6771 /* Backslash: treat next character as ordinary. */
6774 /* When adding more cases that previously matched default, make
6775 sure to adjust quote_spec_char_p as well. */
6779 /* Ordinary character: put it into the current argument. */
6780 obstack_1grow (&obstack
, c
);
6784 /* End of string. If we are processing a spec function, we need to
6785 end any pending argument. */
6786 if (processing_spec_function
)
6792 /* Look up a spec function. */
6794 static const struct spec_function
*
6795 lookup_spec_function (const char *name
)
6797 const struct spec_function
*sf
;
6799 for (sf
= static_spec_functions
; sf
->name
!= NULL
; sf
++)
6800 if (strcmp (sf
->name
, name
) == 0)
6806 /* Evaluate a spec function. */
6809 eval_spec_function (const char *func
, const char *args
,
6810 const char *soft_matched_part
)
6812 const struct spec_function
*sf
;
6813 const char *funcval
;
6815 /* Saved spec processing context. */
6816 vec
<const_char_p
> save_argbuf
;
6819 int save_delete_this_arg
;
6820 int save_this_is_output_file
;
6821 int save_this_is_library_file
;
6822 int save_input_from_pipe
;
6823 int save_this_is_linker_script
;
6824 const char *save_suffix_subst
;
6826 int save_growing_size
;
6827 void *save_growing_value
= NULL
;
6829 sf
= lookup_spec_function (func
);
6831 fatal_error (input_location
, "unknown spec function %qs", func
);
6833 /* Push the spec processing context. */
6834 save_argbuf
= argbuf
;
6836 save_arg_going
= arg_going
;
6837 save_delete_this_arg
= delete_this_arg
;
6838 save_this_is_output_file
= this_is_output_file
;
6839 save_this_is_library_file
= this_is_library_file
;
6840 save_this_is_linker_script
= this_is_linker_script
;
6841 save_input_from_pipe
= input_from_pipe
;
6842 save_suffix_subst
= suffix_subst
;
6844 /* If we have some object growing now, finalize it so the args and function
6845 eval proceed from a cleared context. This is needed to prevent the first
6846 constructed arg from mistakenly including the growing value. We'll push
6847 this value back on the obstack once the function evaluation is done, to
6848 restore a consistent processing context for our caller. This is fine as
6849 the address of growing objects isn't guaranteed to remain stable until
6850 they are finalized, and we expect this situation to be rare enough for
6851 the extra copy not to be an issue. */
6852 save_growing_size
= obstack_object_size (&obstack
);
6853 if (save_growing_size
> 0)
6854 save_growing_value
= obstack_finish (&obstack
);
6856 /* Create a new spec processing context, and build the function
6860 if (do_spec_2 (args
, soft_matched_part
) < 0)
6861 fatal_error (input_location
, "error in arguments to spec function %qs",
6864 /* argbuf_index is an index for the next argument to be inserted, and
6865 so contains the count of the args already inserted. */
6867 funcval
= (*sf
->func
) (argbuf
.length (),
6870 /* Pop the spec processing context. */
6872 argbuf
= save_argbuf
;
6874 arg_going
= save_arg_going
;
6875 delete_this_arg
= save_delete_this_arg
;
6876 this_is_output_file
= save_this_is_output_file
;
6877 this_is_library_file
= save_this_is_library_file
;
6878 this_is_linker_script
= save_this_is_linker_script
;
6879 input_from_pipe
= save_input_from_pipe
;
6880 suffix_subst
= save_suffix_subst
;
6882 if (save_growing_size
> 0)
6883 obstack_grow (&obstack
, save_growing_value
, save_growing_size
);
6888 /* Handle a spec function call of the form:
6892 ARGS is processed as a spec in a separate context and split into an
6893 argument vector in the normal fashion. The function returns a string
6894 containing a spec which we then process in the caller's context, or
6895 NULL if no processing is required.
6897 If RETVAL_NONNULL is not NULL, then store a bool whether function
6900 SOFT_MATCHED_PART holds the current value of a matched * pattern, which
6901 may be re-expanded with a %* as part of the function arguments. */
6904 handle_spec_function (const char *p
, bool *retval_nonnull
,
6905 const char *soft_matched_part
)
6908 const char *endp
, *funcval
;
6911 processing_spec_function
++;
6913 /* Get the function name. */
6914 for (endp
= p
; *endp
!= '\0'; endp
++)
6916 if (*endp
== '(') /* ) */
6918 /* Only allow [A-Za-z0-9], -, and _ in function names. */
6919 if (!ISALNUM (*endp
) && !(*endp
== '-' || *endp
== '_'))
6920 fatal_error (input_location
, "malformed spec function name");
6922 if (*endp
!= '(') /* ) */
6923 fatal_error (input_location
, "no arguments for spec function");
6924 func
= save_string (p
, endp
- p
);
6927 /* Get the arguments. */
6928 for (count
= 0; *endp
!= '\0'; endp
++)
6937 else if (*endp
== '(') /* ) */
6942 fatal_error (input_location
, "malformed spec function arguments");
6943 args
= save_string (p
, endp
- p
);
6946 /* p now points to just past the end of the spec function expression. */
6948 funcval
= eval_spec_function (func
, args
, soft_matched_part
);
6949 if (funcval
!= NULL
&& do_spec_1 (funcval
, 0, NULL
) < 0)
6952 *retval_nonnull
= funcval
!= NULL
;
6957 processing_spec_function
--;
6962 /* Inline subroutine of handle_braces. Returns true if the current
6963 input suffix matches the atom bracketed by ATOM and END_ATOM. */
6965 input_suffix_matches (const char *atom
, const char *end_atom
)
6967 return (input_suffix
6968 && !strncmp (input_suffix
, atom
, end_atom
- atom
)
6969 && input_suffix
[end_atom
- atom
] == '\0');
6972 /* Subroutine of handle_braces. Returns true if the current
6973 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
6975 input_spec_matches (const char *atom
, const char *end_atom
)
6977 return (input_file_compiler
6978 && input_file_compiler
->suffix
6979 && input_file_compiler
->suffix
[0] != '\0'
6980 && !strncmp (input_file_compiler
->suffix
+ 1, atom
,
6982 && input_file_compiler
->suffix
[end_atom
- atom
+ 1] == '\0');
6985 /* Subroutine of handle_braces. Returns true if a switch
6986 matching the atom bracketed by ATOM and END_ATOM appeared on the
6989 switch_matches (const char *atom
, const char *end_atom
, int starred
)
6992 int len
= end_atom
- atom
;
6993 int plen
= starred
? len
: -1;
6995 for (i
= 0; i
< n_switches
; i
++)
6996 if (!strncmp (switches
[i
].part1
, atom
, len
)
6997 && (starred
|| switches
[i
].part1
[len
] == '\0')
6998 && check_live_switch (i
, plen
))
7001 /* Check if a switch with separated form matching the atom.
7002 We check -D and -U switches. */
7003 else if (switches
[i
].args
!= 0)
7005 if ((*switches
[i
].part1
== 'D' || *switches
[i
].part1
== 'U')
7006 && *switches
[i
].part1
== atom
[0])
7008 if (!strncmp (switches
[i
].args
[0], &atom
[1], len
- 1)
7009 && (starred
|| (switches
[i
].part1
[1] == '\0'
7010 && switches
[i
].args
[0][len
- 1] == '\0'))
7011 && check_live_switch (i
, (starred
? 1 : -1)))
7019 /* Inline subroutine of handle_braces. Mark all of the switches which
7020 match ATOM (extends to END_ATOM; STARRED indicates whether there
7021 was a star after the atom) for later processing. */
7023 mark_matching_switches (const char *atom
, const char *end_atom
, int starred
)
7026 int len
= end_atom
- atom
;
7027 int plen
= starred
? len
: -1;
7029 for (i
= 0; i
< n_switches
; i
++)
7030 if (!strncmp (switches
[i
].part1
, atom
, len
)
7031 && (starred
|| switches
[i
].part1
[len
] == '\0')
7032 && check_live_switch (i
, plen
))
7033 switches
[i
].ordering
= 1;
7036 /* Inline subroutine of handle_braces. Process all the currently
7037 marked switches through give_switch, and clear the marks. */
7039 process_marked_switches (void)
7043 for (i
= 0; i
< n_switches
; i
++)
7044 if (switches
[i
].ordering
== 1)
7046 switches
[i
].ordering
= 0;
7051 /* Handle a %{ ... } construct. P points just inside the leading {.
7052 Returns a pointer one past the end of the brace block, or 0
7053 if we call do_spec_1 and that returns -1. */
7056 handle_braces (const char *p
)
7058 const char *atom
, *end_atom
;
7059 const char *d_atom
= NULL
, *d_end_atom
= NULL
;
7060 char *esc_buf
= NULL
, *d_esc_buf
= NULL
;
7062 const char *orig
= p
;
7070 bool a_must_be_last
= false;
7071 bool ordered_set
= false;
7072 bool disjunct_set
= false;
7073 bool disj_matched
= false;
7074 bool disj_starred
= true;
7075 bool n_way_choice
= false;
7076 bool n_way_matched
= false;
7078 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7085 /* Scan one "atom" (S in the description above of %{}, possibly
7086 with '!', '.', '@', ',', or '*' modifiers). */
7088 a_is_suffix
= false;
7089 a_is_starred
= false;
7090 a_is_negated
= false;
7091 a_is_spectype
= false;
7095 p
++, a_is_negated
= true;
7098 if (*p
== '%' && p
[1] == ':')
7102 p
= handle_spec_function (p
+ 2, &a_matched
, NULL
);
7107 p
++, a_is_suffix
= true;
7109 p
++, a_is_spectype
= true;
7113 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
7114 || *p
== ',' || *p
== '.' || *p
== '@' || *p
== '\\')
7120 fatal_error (input_location
,
7121 "braced spec %qs ends in escape", orig
);
7133 if (esc_buf
&& esc_buf
!= d_esc_buf
)
7136 ep
= esc_buf
= (char *) xmalloc (end_atom
- atom
- esc
+ 1);
7137 for (ap
= atom
; ap
!= end_atom
; ap
++, ep
++)
7149 p
++, a_is_starred
= 1;
7156 /* Substitute the switch(es) indicated by the current atom. */
7158 if (disjunct_set
|| n_way_choice
|| a_is_negated
|| a_is_suffix
7159 || a_is_spectype
|| atom
== end_atom
)
7162 mark_matching_switches (atom
, end_atom
, a_is_starred
);
7165 process_marked_switches ();
7169 /* Substitute some text if the current atom appears as a switch
7171 disjunct_set
= true;
7175 if (atom
&& atom
== end_atom
)
7177 if (!n_way_choice
|| disj_matched
|| *p
== '|'
7178 || a_is_negated
|| a_is_suffix
|| a_is_spectype
7182 /* An empty term may appear as the last choice of an
7183 N-way choice set; it means "otherwise". */
7184 a_must_be_last
= true;
7185 disj_matched
= !n_way_matched
;
7186 disj_starred
= false;
7190 if ((a_is_suffix
|| a_is_spectype
) && a_is_starred
)
7194 disj_starred
= false;
7196 /* Don't bother testing this atom if we already have a
7198 if (!disj_matched
&& !n_way_matched
)
7201 /* a_matched is already set by handle_spec_function. */;
7202 else if (a_is_suffix
)
7203 a_matched
= input_suffix_matches (atom
, end_atom
);
7204 else if (a_is_spectype
)
7205 a_matched
= input_spec_matches (atom
, end_atom
);
7207 a_matched
= switch_matches (atom
, end_atom
, a_is_starred
);
7209 if (a_matched
!= a_is_negated
)
7211 disj_matched
= true;
7213 d_end_atom
= end_atom
;
7214 d_esc_buf
= esc_buf
;
7221 /* Found the body, that is, the text to substitute if the
7222 current disjunction matches. */
7223 p
= process_brace_body (p
+ 1, d_atom
, d_end_atom
, disj_starred
,
7224 disj_matched
&& !n_way_matched
);
7228 /* If we have an N-way choice, reset state for the next
7232 n_way_choice
= true;
7233 n_way_matched
|= disj_matched
;
7234 disj_matched
= false;
7235 disj_starred
= true;
7236 d_atom
= d_end_atom
= NULL
;
7245 while (*p
++ != '}');
7248 if (d_esc_buf
&& d_esc_buf
!= esc_buf
)
7256 fatal_error (input_location
, "braced spec %qs is invalid at %qc", orig
, *p
);
7261 /* Subroutine of handle_braces. Scan and process a brace substitution body
7262 (X in the description of %{} syntax). P points one past the colon;
7263 ATOM and END_ATOM bracket the first atom which was found to be true
7264 (present) in the current disjunction; STARRED indicates whether all
7265 the atoms in the current disjunction were starred (for syntax validation);
7266 MATCHED indicates whether the disjunction matched or not, and therefore
7267 whether or not the body is to be processed through do_spec_1 or just
7268 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
7272 process_brace_body (const char *p
, const char *atom
, const char *end_atom
,
7273 int starred
, int matched
)
7275 const char *body
, *end_body
;
7276 unsigned int nesting_level
;
7277 bool have_subst
= false;
7279 /* Locate the closing } or ;, honoring nested braces.
7280 Trim trailing whitespace. */
7289 if (!--nesting_level
)
7292 else if (*p
== ';' && nesting_level
== 1)
7294 else if (*p
== '%' && p
[1] == '*' && nesting_level
== 1)
7296 else if (*p
== '\0')
7302 while (end_body
[-1] == ' ' || end_body
[-1] == '\t')
7305 if (have_subst
&& !starred
)
7310 /* Copy the substitution body to permanent storage and execute it.
7311 If have_subst is false, this is a simple matter of running the
7312 body through do_spec_1... */
7313 char *string
= save_string (body
, end_body
- body
);
7316 if (do_spec_1 (string
, 0, NULL
) < 0)
7324 /* ... but if have_subst is true, we have to process the
7325 body once for each matching switch, with %* set to the
7326 variant part of the switch. */
7327 unsigned int hard_match_len
= end_atom
- atom
;
7330 for (i
= 0; i
< n_switches
; i
++)
7331 if (!strncmp (switches
[i
].part1
, atom
, hard_match_len
)
7332 && check_live_switch (i
, hard_match_len
))
7334 if (do_spec_1 (string
, 0,
7335 &switches
[i
].part1
[hard_match_len
]) < 0)
7340 /* Pass any arguments this switch has. */
7342 suffix_subst
= NULL
;
7351 fatal_error (input_location
, "braced spec body %qs is invalid", body
);
7354 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
7355 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
7356 spec, or -1 if either exact match or %* is used.
7358 A -O switch is obsoleted by a later -O switch. A -f, -g, -m, or -W switch
7359 whose value does not begin with "no-" is obsoleted by the same value
7360 with the "no-", similarly for a switch with the "no-" prefix. */
7363 check_live_switch (int switchnum
, int prefix_length
)
7365 const char *name
= switches
[switchnum
].part1
;
7368 /* If we already processed this switch and determined if it was
7369 live or not, return our past determination. */
7370 if (switches
[switchnum
].live_cond
!= 0)
7371 return ((switches
[switchnum
].live_cond
& SWITCH_LIVE
) != 0
7372 && (switches
[switchnum
].live_cond
& SWITCH_FALSE
) == 0
7373 && (switches
[switchnum
].live_cond
& SWITCH_IGNORE_PERMANENTLY
)
7376 /* In the common case of {<at-most-one-letter>*}, a negating
7377 switch would always match, so ignore that case. We will just
7378 send the conflicting switches to the compiler phase. */
7379 if (prefix_length
>= 0 && prefix_length
<= 1)
7382 /* Now search for duplicate in a manner that depends on the name. */
7386 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
7387 if (switches
[i
].part1
[0] == 'O')
7389 switches
[switchnum
].validated
= true;
7390 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
7395 case 'W': case 'f': case 'm': case 'g':
7396 if (startswith (name
+ 1, "no-"))
7398 /* We have Xno-YYY, search for XYYY. */
7399 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
7400 if (switches
[i
].part1
[0] == name
[0]
7401 && ! strcmp (&switches
[i
].part1
[1], &name
[4]))
7403 /* --specs are validated with the validate_switches mechanism. */
7404 if (switches
[switchnum
].known
)
7405 switches
[switchnum
].validated
= true;
7406 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
7412 /* We have XYYY, search for Xno-YYY. */
7413 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
7414 if (switches
[i
].part1
[0] == name
[0]
7415 && switches
[i
].part1
[1] == 'n'
7416 && switches
[i
].part1
[2] == 'o'
7417 && switches
[i
].part1
[3] == '-'
7418 && !strcmp (&switches
[i
].part1
[4], &name
[1]))
7420 /* --specs are validated with the validate_switches mechanism. */
7421 if (switches
[switchnum
].known
)
7422 switches
[switchnum
].validated
= true;
7423 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
7430 /* Otherwise the switch is live. */
7431 switches
[switchnum
].live_cond
|= SWITCH_LIVE
;
7435 /* Pass a switch to the current accumulating command
7436 in the same form that we received it.
7437 SWITCHNUM identifies the switch; it is an index into
7438 the vector of switches gcc received, which is `switches'.
7439 This cannot fail since it never finishes a command line.
7441 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
7444 give_switch (int switchnum
, int omit_first_word
)
7446 if ((switches
[switchnum
].live_cond
& SWITCH_IGNORE
) != 0)
7449 if (!omit_first_word
)
7451 do_spec_1 ("-", 0, NULL
);
7452 do_spec_1 (switches
[switchnum
].part1
, 1, NULL
);
7455 if (switches
[switchnum
].args
!= 0)
7458 for (p
= switches
[switchnum
].args
; *p
; p
++)
7460 const char *arg
= *p
;
7462 do_spec_1 (" ", 0, NULL
);
7465 unsigned length
= strlen (arg
);
7468 while (length
-- && !IS_DIR_SEPARATOR (arg
[length
]))
7469 if (arg
[length
] == '.')
7471 (CONST_CAST (char *, arg
))[length
] = 0;
7475 do_spec_1 (arg
, 1, NULL
);
7477 (CONST_CAST (char *, arg
))[length
] = '.';
7478 do_spec_1 (suffix_subst
, 1, NULL
);
7481 do_spec_1 (arg
, 1, NULL
);
7485 do_spec_1 (" ", 0, NULL
);
7486 switches
[switchnum
].validated
= true;
7489 /* Print GCC configuration (e.g. version, thread model, target,
7490 configuration_arguments) to a given FILE. */
7493 print_configuration (FILE *file
)
7498 fnotice (file
, "Target: %s\n", spec_machine
);
7499 fnotice (file
, "Configured with: %s\n", configuration_arguments
);
7501 #ifdef THREAD_MODEL_SPEC
7502 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
7503 but there's no point in doing all this processing just to get
7504 thread_model back. */
7505 obstack_init (&obstack
);
7506 do_spec_1 (THREAD_MODEL_SPEC
, 0, thread_model
);
7507 obstack_1grow (&obstack
, '\0');
7508 thrmod
= XOBFINISH (&obstack
, const char *);
7510 thrmod
= thread_model
;
7513 fnotice (file
, "Thread model: %s\n", thrmod
);
7514 fnotice (file
, "Supported LTO compression algorithms: zlib");
7516 fnotice (file
, " zstd");
7518 fnotice (file
, "\n");
7520 /* compiler_version is truncated at the first space when initialized
7521 from version string, so truncate version_string at the first space
7522 before comparing. */
7523 for (n
= 0; version_string
[n
]; n
++)
7524 if (version_string
[n
] == ' ')
7527 if (! strncmp (version_string
, compiler_version
, n
)
7528 && compiler_version
[n
] == 0)
7529 fnotice (file
, "gcc version %s %s\n", version_string
,
7532 fnotice (file
, "gcc driver version %s %sexecuting gcc version %s\n",
7533 version_string
, pkgversion_string
, compiler_version
);
7537 #define RETRY_ICE_ATTEMPTS 3
7539 /* Returns true if FILE1 and FILE2 contain equivalent data, 0 otherwise. */
7542 files_equal_p (char *file1
, char *file2
)
7544 struct stat st1
, st2
;
7547 const int bufsize
= 8192;
7548 char *buf
= XNEWVEC (char, bufsize
);
7550 fd1
= open (file1
, O_RDONLY
);
7551 fd2
= open (file2
, O_RDONLY
);
7553 if (fd1
< 0 || fd2
< 0)
7556 if (fstat (fd1
, &st1
) < 0 || fstat (fd2
, &st2
) < 0)
7559 if (st1
.st_size
!= st2
.st_size
)
7562 for (n
= st1
.st_size
; n
; n
-= len
)
7565 if ((int) len
> bufsize
/ 2)
7568 if (read (fd1
, buf
, len
) != (int) len
7569 || read (fd2
, buf
+ bufsize
/ 2, len
) != (int) len
)
7574 if (memcmp (buf
, buf
+ bufsize
/ 2, len
) != 0)
7591 /* Check that compiler's output doesn't differ across runs.
7592 TEMP_STDOUT_FILES and TEMP_STDERR_FILES are arrays of files, containing
7593 stdout and stderr for each compiler run. Return true if all of
7594 TEMP_STDOUT_FILES and TEMP_STDERR_FILES are equivalent. */
7597 check_repro (char **temp_stdout_files
, char **temp_stderr_files
)
7600 for (i
= 0; i
< RETRY_ICE_ATTEMPTS
- 2; ++i
)
7602 if (!files_equal_p (temp_stdout_files
[i
], temp_stdout_files
[i
+ 1])
7603 || !files_equal_p (temp_stderr_files
[i
], temp_stderr_files
[i
+ 1]))
7605 fnotice (stderr
, "The bug is not reproducible, so it is"
7606 " likely a hardware or OS problem.\n");
7610 return i
== RETRY_ICE_ATTEMPTS
- 2;
7613 enum attempt_status
{
7614 ATTEMPT_STATUS_FAIL_TO_RUN
,
7615 ATTEMPT_STATUS_SUCCESS
,
7620 /* Run compiler with arguments NEW_ARGV to reproduce the ICE, storing stdout
7621 to OUT_TEMP and stderr to ERR_TEMP. If APPEND is TRUE, append to OUT_TEMP
7622 and ERR_TEMP instead of truncating. If EMIT_SYSTEM_INFO is TRUE, also write
7623 GCC configuration into to ERR_TEMP. Return ATTEMPT_STATUS_FAIL_TO_RUN if
7624 compiler failed to run, ATTEMPT_STATUS_ICE if compiled ICE-ed and
7625 ATTEMPT_STATUS_SUCCESS otherwise. */
7627 static enum attempt_status
7628 run_attempt (const char **new_argv
, const char *out_temp
,
7629 const char *err_temp
, int emit_system_info
, int append
)
7632 if (emit_system_info
)
7634 FILE *file_out
= fopen (err_temp
, "a");
7635 print_configuration (file_out
);
7636 fputs ("\n", file_out
);
7642 struct pex_obj
*pex
;
7644 int pex_flags
= PEX_USE_PIPES
| PEX_LAST
;
7645 enum attempt_status status
= ATTEMPT_STATUS_FAIL_TO_RUN
;
7648 pex_flags
|= PEX_STDOUT_APPEND
| PEX_STDERR_APPEND
;
7650 pex
= pex_init (PEX_USE_PIPES
, new_argv
[0], NULL
);
7652 fatal_error (input_location
, "%<pex_init%> failed: %m");
7654 errmsg
= pex_run (pex
, pex_flags
, new_argv
[0],
7655 CONST_CAST2 (char *const *, const char **, &new_argv
[1]),
7656 out_temp
, err_temp
, &err
);
7660 fatal_error (input_location
,
7661 err
? G_ ("cannot execute %qs: %s: %m")
7662 : G_ ("cannot execute %qs: %s"),
7663 new_argv
[0], errmsg
);
7666 if (!pex_get_status (pex
, 1, &exit_status
))
7669 switch (WEXITSTATUS (exit_status
))
7672 status
= ATTEMPT_STATUS_ICE
;
7675 case SUCCESS_EXIT_CODE
:
7676 status
= ATTEMPT_STATUS_SUCCESS
;
7688 /* This routine reads lines from IN file, adds C++ style comments
7689 at the begining of each line and writes result into OUT. */
7692 insert_comments (const char *file_in
, const char *file_out
)
7694 FILE *in
= fopen (file_in
, "rb");
7695 FILE *out
= fopen (file_out
, "wb");
7698 bool add_comment
= true;
7699 while (fgets (line
, sizeof (line
), in
))
7704 add_comment
= strchr (line
, '\n') != NULL
;
7711 /* This routine adds preprocessed source code into the given ERR_FILE.
7712 To do this, it adds "-E" to NEW_ARGV and execute RUN_ATTEMPT routine to
7713 add information in report file. RUN_ATTEMPT should return
7714 ATTEMPT_STATUS_SUCCESS, in other case we cannot generate the report. */
7717 do_report_bug (const char **new_argv
, const int nargs
,
7718 char **out_file
, char **err_file
)
7721 int fd
= open (*out_file
, O_RDWR
| O_APPEND
);
7724 write (fd
, "\n//", 3);
7725 for (i
= 0; i
< nargs
; i
++)
7728 write (fd
, new_argv
[i
], strlen (new_argv
[i
]));
7730 write (fd
, "\n\n", 2);
7732 new_argv
[nargs
] = "-E";
7733 new_argv
[nargs
+ 1] = NULL
;
7735 status
= run_attempt (new_argv
, *out_file
, *err_file
, 0, 1);
7737 if (status
== ATTEMPT_STATUS_SUCCESS
)
7739 fnotice (stderr
, "Preprocessed source stored into %s file,"
7740 " please attach this to your bugreport.\n", *out_file
);
7741 /* Make sure it is not deleted. */
7747 /* Try to reproduce ICE. If bug is reproducible, generate report .err file
7748 containing GCC configuration, backtrace, compiler's command line options
7749 and preprocessed source code. */
7752 try_generate_repro (const char **argv
)
7754 int i
, nargs
, out_arg
= -1, quiet
= 0, attempt
;
7755 const char **new_argv
;
7756 char *temp_files
[RETRY_ICE_ATTEMPTS
* 2];
7757 char **temp_stdout_files
= &temp_files
[0];
7758 char **temp_stderr_files
= &temp_files
[RETRY_ICE_ATTEMPTS
];
7760 if (gcc_input_filename
== NULL
|| ! strcmp (gcc_input_filename
, "-"))
7763 for (nargs
= 0; argv
[nargs
] != NULL
; ++nargs
)
7764 /* Only retry compiler ICEs, not preprocessor ones. */
7765 if (! strcmp (argv
[nargs
], "-E"))
7767 else if (argv
[nargs
][0] == '-' && argv
[nargs
][1] == 'o')
7774 /* If the compiler is going to output any time information,
7775 it might varry between invocations. */
7776 else if (! strcmp (argv
[nargs
], "-quiet"))
7778 else if (! strcmp (argv
[nargs
], "-ftime-report"))
7781 if (out_arg
== -1 || !quiet
)
7784 memset (temp_files
, '\0', sizeof (temp_files
));
7785 new_argv
= XALLOCAVEC (const char *, nargs
+ 4);
7786 memcpy (new_argv
, argv
, (nargs
+ 1) * sizeof (const char *));
7787 new_argv
[nargs
++] = "-frandom-seed=0";
7788 new_argv
[nargs
++] = "-fdump-noaddr";
7789 new_argv
[nargs
] = NULL
;
7790 if (new_argv
[out_arg
][2] == '\0')
7791 new_argv
[out_arg
+ 1] = "-";
7793 new_argv
[out_arg
] = "-o-";
7796 for (attempt
= 0; attempt
< RETRY_ICE_ATTEMPTS
; ++attempt
)
7798 int emit_system_info
= 0;
7800 temp_stdout_files
[attempt
] = make_temp_file (".out");
7801 temp_stderr_files
[attempt
] = make_temp_file (".err");
7803 if (attempt
== RETRY_ICE_ATTEMPTS
- 1)
7806 emit_system_info
= 1;
7809 status
= run_attempt (new_argv
, temp_stdout_files
[attempt
],
7810 temp_stderr_files
[attempt
], emit_system_info
,
7813 if (status
!= ATTEMPT_STATUS_ICE
)
7815 fnotice (stderr
, "The bug is not reproducible, so it is"
7816 " likely a hardware or OS problem.\n");
7821 if (!check_repro (temp_stdout_files
, temp_stderr_files
))
7825 /* Insert commented out backtrace into report file. */
7826 char **stderr_commented
= &temp_stdout_files
[RETRY_ICE_ATTEMPTS
- 1];
7827 insert_comments (temp_stderr_files
[RETRY_ICE_ATTEMPTS
- 1],
7830 /* In final attempt we append compiler options and preprocesssed code to last
7831 generated .out file with configuration and backtrace. */
7832 char **err
= &temp_stderr_files
[RETRY_ICE_ATTEMPTS
- 1];
7833 do_report_bug (new_argv
, nargs
, stderr_commented
, err
);
7837 for (i
= 0; i
< RETRY_ICE_ATTEMPTS
* 2; i
++)
7840 unlink (temp_stdout_files
[i
]);
7841 free (temp_stdout_files
[i
]);
7845 /* Search for a file named NAME trying various prefixes including the
7846 user's -B prefix and some standard ones.
7847 Return the absolute file name found. If nothing is found, return NAME. */
7850 find_file (const char *name
)
7852 char *newname
= find_a_file (&startfile_prefixes
, name
, R_OK
, true);
7853 return newname
? newname
: name
;
7856 /* Determine whether a directory exists. If LINKER, return 0 for
7857 certain fixed names not needed by the linker. */
7860 is_directory (const char *path1
, bool linker
)
7867 /* Ensure the string ends with "/.". The resulting path will be a
7868 directory even if the given path is a symbolic link. */
7869 len1
= strlen (path1
);
7870 path
= (char *) alloca (3 + len1
);
7871 memcpy (path
, path1
, len1
);
7873 if (!IS_DIR_SEPARATOR (cp
[-1]))
7874 *cp
++ = DIR_SEPARATOR
;
7878 /* Exclude directories that the linker is known to search. */
7880 && IS_DIR_SEPARATOR (path
[0])
7882 && filename_ncmp (path
+ 1, "lib", 3) == 0)
7884 && filename_ncmp (path
+ 1, "usr", 3) == 0
7885 && IS_DIR_SEPARATOR (path
[4])
7886 && filename_ncmp (path
+ 5, "lib", 3) == 0)))
7889 return (stat (path
, &st
) >= 0 && S_ISDIR (st
.st_mode
));
7892 /* Set up the various global variables to indicate that we're processing
7893 the input file named FILENAME. */
7896 set_input (const char *filename
)
7900 gcc_input_filename
= filename
;
7901 input_filename_length
= strlen (gcc_input_filename
);
7902 input_basename
= lbasename (gcc_input_filename
);
7904 /* Find a suffix starting with the last period,
7905 and set basename_length to exclude that suffix. */
7906 basename_length
= strlen (input_basename
);
7907 suffixed_basename_length
= basename_length
;
7908 p
= input_basename
+ basename_length
;
7909 while (p
!= input_basename
&& *p
!= '.')
7911 if (*p
== '.' && p
!= input_basename
)
7913 basename_length
= p
- input_basename
;
7914 input_suffix
= p
+ 1;
7919 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
7920 we will need to do a stat on the gcc_input_filename. The
7921 INPUT_STAT_SET signals that the stat is needed. */
7925 /* On fatal signals, delete all the temporary files. */
7928 fatal_signal (int signum
)
7930 signal (signum
, SIG_DFL
);
7931 delete_failure_queue ();
7932 delete_temp_files ();
7933 /* Get the same signal again, this time not handled,
7934 so its normal effect occurs. */
7935 kill (getpid (), signum
);
7938 /* Compare the contents of the two files named CMPFILE[0] and
7939 CMPFILE[1]. Return zero if they're identical, nonzero
7943 compare_files (char *cmpfile
[])
7946 FILE *temp
[2] = { NULL
, NULL
};
7952 void *map
[2] = { NULL
, NULL
};
7954 for (i
= 0; i
< 2; i
++)
7958 if (stat (cmpfile
[i
], &st
) < 0 || !S_ISREG (st
.st_mode
))
7960 error ("%s: could not determine length of compare-debug file %s",
7961 gcc_input_filename
, cmpfile
[i
]);
7966 length
[i
] = st
.st_size
;
7969 if (!ret
&& length
[0] != length
[1])
7971 error ("%s: %<-fcompare-debug%> failure (length)", gcc_input_filename
);
7976 for (i
= 0; i
< 2; i
++)
7978 int fd
= open (cmpfile
[i
], O_RDONLY
);
7981 error ("%s: could not open compare-debug file %s",
7982 gcc_input_filename
, cmpfile
[i
]);
7987 map
[i
] = mmap (NULL
, length
[i
], PROT_READ
, MAP_PRIVATE
, fd
, 0);
7990 if (map
[i
] == (void *) MAP_FAILED
)
7999 if (memcmp (map
[0], map
[1], length
[0]) != 0)
8001 error ("%s: %<-fcompare-debug%> failure", gcc_input_filename
);
8006 for (i
= 0; i
< 2; i
++)
8008 munmap ((caddr_t
) map
[i
], length
[i
]);
8017 for (i
= 0; i
< 2; i
++)
8019 temp
[i
] = fopen (cmpfile
[i
], "r");
8022 error ("%s: could not open compare-debug file %s",
8023 gcc_input_filename
, cmpfile
[i
]);
8029 if (!ret
&& temp
[0] && temp
[1])
8033 c0
= fgetc (temp
[0]);
8034 c1
= fgetc (temp
[1]);
8038 error ("%s: %<-fcompare-debug%> failure",
8039 gcc_input_filename
);
8048 for (i
= 1; i
>= 0; i
--)
8057 driver::driver (bool can_finalize
, bool debug
) :
8058 explicit_link_files (NULL
),
8059 decoded_options (NULL
)
8061 env
.init (can_finalize
, debug
);
8066 XDELETEVEC (explicit_link_files
);
8067 XDELETEVEC (decoded_options
);
8070 /* driver::main is implemented as a series of driver:: method calls. */
8073 driver::main (int argc
, char **argv
)
8077 set_progname (argv
[0]);
8078 expand_at_files (&argc
, &argv
);
8079 decode_argv (argc
, const_cast <const char **> (argv
));
8080 global_initializations ();
8081 build_multilib_strings ();
8083 putenv_COLLECT_AS_OPTIONS (assembler_options
);
8084 putenv_COLLECT_GCC (argv
[0]);
8085 maybe_putenv_COLLECT_LTO_WRAPPER ();
8086 maybe_putenv_OFFLOAD_TARGETS ();
8087 handle_unrecognized_options ();
8091 m_option_proposer
.suggest_completion (completion
);
8095 if (!maybe_print_and_exit ())
8098 early_exit
= prepare_infiles ();
8100 return get_exit_code ();
8102 do_spec_on_infiles ();
8103 maybe_run_linker (argv
[0]);
8105 return get_exit_code ();
8108 /* Locate the final component of argv[0] after any leading path, and set
8109 the program name accordingly. */
8112 driver::set_progname (const char *argv0
) const
8114 const char *p
= argv0
+ strlen (argv0
);
8115 while (p
!= argv0
&& !IS_DIR_SEPARATOR (p
[-1]))
8119 xmalloc_set_program_name (progname
);
8122 /* Expand any @ files within the command-line args,
8123 setting at_file_supplied if any were expanded. */
8126 driver::expand_at_files (int *argc
, char ***argv
) const
8128 char **old_argv
= *argv
;
8130 expandargv (argc
, argv
);
8132 /* Determine if any expansions were made. */
8133 if (*argv
!= old_argv
)
8134 at_file_supplied
= true;
8137 /* Decode the command-line arguments from argc/argv into the
8138 decoded_options array. */
8141 driver::decode_argv (int argc
, const char **argv
)
8143 init_opts_obstack ();
8144 init_options_struct (&global_options
, &global_options_set
);
8146 decode_cmdline_options_to_array (argc
, argv
,
8148 &decoded_options
, &decoded_options_count
);
8151 /* Perform various initializations and setup. */
8154 driver::global_initializations ()
8156 /* Unlock the stdio streams. */
8157 unlock_std_streams ();
8159 gcc_init_libintl ();
8161 diagnostic_initialize (global_dc
, 0);
8162 diagnostic_color_init (global_dc
);
8163 diagnostic_urls_init (global_dc
);
8165 #ifdef GCC_DRIVER_HOST_INITIALIZATION
8166 /* Perform host dependent initialization when needed. */
8167 GCC_DRIVER_HOST_INITIALIZATION
;
8170 if (atexit (delete_temp_files
) != 0)
8171 fatal_error (input_location
, "atexit failed");
8173 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
8174 signal (SIGINT
, fatal_signal
);
8176 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
8177 signal (SIGHUP
, fatal_signal
);
8179 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
8180 signal (SIGTERM
, fatal_signal
);
8182 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
8183 signal (SIGPIPE
, fatal_signal
);
8186 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
8187 receive the signal. A different setting is inheritable */
8188 signal (SIGCHLD
, SIG_DFL
);
8191 /* Parsing and gimplification sometimes need quite large stack.
8192 Increase stack size limits if possible. */
8193 stack_limit_increase (64 * 1024 * 1024);
8195 /* Allocate the argument vector. */
8198 obstack_init (&obstack
);
8201 /* Build multilib_select, et. al from the separate lines that make up each
8202 multilib selection. */
8205 driver::build_multilib_strings () const
8209 const char *const *q
= multilib_raw
;
8212 obstack_init (&multilib_obstack
);
8213 while ((p
= *q
++) != (char *) 0)
8214 obstack_grow (&multilib_obstack
, p
, strlen (p
));
8216 obstack_1grow (&multilib_obstack
, 0);
8217 multilib_select
= XOBFINISH (&multilib_obstack
, const char *);
8219 q
= multilib_matches_raw
;
8220 while ((p
= *q
++) != (char *) 0)
8221 obstack_grow (&multilib_obstack
, p
, strlen (p
));
8223 obstack_1grow (&multilib_obstack
, 0);
8224 multilib_matches
= XOBFINISH (&multilib_obstack
, const char *);
8226 q
= multilib_exclusions_raw
;
8227 while ((p
= *q
++) != (char *) 0)
8228 obstack_grow (&multilib_obstack
, p
, strlen (p
));
8230 obstack_1grow (&multilib_obstack
, 0);
8231 multilib_exclusions
= XOBFINISH (&multilib_obstack
, const char *);
8233 q
= multilib_reuse_raw
;
8234 while ((p
= *q
++) != (char *) 0)
8235 obstack_grow (&multilib_obstack
, p
, strlen (p
));
8237 obstack_1grow (&multilib_obstack
, 0);
8238 multilib_reuse
= XOBFINISH (&multilib_obstack
, const char *);
8241 for (size_t i
= 0; i
< ARRAY_SIZE (multilib_defaults_raw
); i
++)
8244 obstack_1grow (&multilib_obstack
, ' ');
8245 obstack_grow (&multilib_obstack
,
8246 multilib_defaults_raw
[i
],
8247 strlen (multilib_defaults_raw
[i
]));
8251 obstack_1grow (&multilib_obstack
, 0);
8252 multilib_defaults
= XOBFINISH (&multilib_obstack
, const char *);
8256 /* Set up the spec-handling machinery. */
8259 driver::set_up_specs () const
8261 const char *spec_machine_suffix
;
8265 #ifdef INIT_ENVIRONMENT
8266 /* Set up any other necessary machine specific environment variables. */
8267 xputenv (INIT_ENVIRONMENT
);
8270 /* Make a table of what switches there are (switches, n_switches).
8271 Make a table of specified input files (infiles, n_infiles).
8272 Decode switches that are handled locally. */
8274 process_command (decoded_options_count
, decoded_options
);
8276 /* Initialize the vector of specs to just the default.
8277 This means one element containing 0s, as a terminator. */
8279 compilers
= XNEWVAR (struct compiler
, sizeof default_compilers
);
8280 memcpy (compilers
, default_compilers
, sizeof default_compilers
);
8281 n_compilers
= n_default_compilers
;
8283 /* Read specs from a file if there is one. */
8285 machine_suffix
= concat (spec_host_machine
, dir_separator_str
, spec_version
,
8286 accel_dir_suffix
, dir_separator_str
, NULL
);
8287 just_machine_suffix
= concat (spec_machine
, dir_separator_str
, NULL
);
8289 specs_file
= find_a_file (&startfile_prefixes
, "specs", R_OK
, true);
8290 /* Read the specs file unless it is a default one. */
8291 if (specs_file
!= 0 && strcmp (specs_file
, "specs"))
8292 read_specs (specs_file
, true, false);
8296 #ifdef ACCEL_COMPILER
8297 spec_machine_suffix
= machine_suffix
;
8299 spec_machine_suffix
= just_machine_suffix
;
8302 /* We need to check standard_exec_prefix/spec_machine_suffix/specs
8303 for any override of as, ld and libraries. */
8304 specs_file
= (char *) alloca (strlen (standard_exec_prefix
)
8305 + strlen (spec_machine_suffix
) + sizeof ("specs"));
8306 strcpy (specs_file
, standard_exec_prefix
);
8307 strcat (specs_file
, spec_machine_suffix
);
8308 strcat (specs_file
, "specs");
8309 if (access (specs_file
, R_OK
) == 0)
8310 read_specs (specs_file
, true, false);
8312 /* Process any configure-time defaults specified for the command line
8313 options, via OPTION_DEFAULT_SPECS. */
8314 for (i
= 0; i
< ARRAY_SIZE (option_default_specs
); i
++)
8315 do_option_spec (option_default_specs
[i
].name
,
8316 option_default_specs
[i
].spec
);
8318 /* Process DRIVER_SELF_SPECS, adding any new options to the end
8319 of the command line. */
8321 for (i
= 0; i
< ARRAY_SIZE (driver_self_specs
); i
++)
8322 do_self_spec (driver_self_specs
[i
]);
8324 /* If not cross-compiling, look for executables in the standard
8326 if (*cross_compile
== '0')
8328 if (*md_exec_prefix
)
8330 add_prefix (&exec_prefixes
, md_exec_prefix
, "GCC",
8331 PREFIX_PRIORITY_LAST
, 0, 0);
8335 /* Process sysroot_suffix_spec. */
8336 if (*sysroot_suffix_spec
!= 0
8337 && !no_sysroot_suffix
8338 && do_spec_2 (sysroot_suffix_spec
, NULL
) == 0)
8340 if (argbuf
.length () > 1)
8341 error ("spec failure: more than one argument to "
8342 "%<SYSROOT_SUFFIX_SPEC%>");
8343 else if (argbuf
.length () == 1)
8344 target_sysroot_suffix
= xstrdup (argbuf
.last ());
8347 #ifdef HAVE_LD_SYSROOT
8348 /* Pass the --sysroot option to the linker, if it supports that. If
8349 there is a sysroot_suffix_spec, it has already been processed by
8350 this point, so target_system_root really is the system root we
8352 if (target_system_root
)
8354 obstack_grow (&obstack
, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
8355 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
8356 set_spec ("link", XOBFINISH (&obstack
, const char *), false);
8360 /* Process sysroot_hdrs_suffix_spec. */
8361 if (*sysroot_hdrs_suffix_spec
!= 0
8362 && !no_sysroot_suffix
8363 && do_spec_2 (sysroot_hdrs_suffix_spec
, NULL
) == 0)
8365 if (argbuf
.length () > 1)
8366 error ("spec failure: more than one argument "
8367 "to %<SYSROOT_HEADERS_SUFFIX_SPEC%>");
8368 else if (argbuf
.length () == 1)
8369 target_sysroot_hdrs_suffix
= xstrdup (argbuf
.last ());
8372 /* Look for startfiles in the standard places. */
8373 if (*startfile_prefix_spec
!= 0
8374 && do_spec_2 (startfile_prefix_spec
, NULL
) == 0
8375 && do_spec_1 (" ", 0, NULL
) == 0)
8377 for (const char *arg
: argbuf
)
8378 add_sysrooted_prefix (&startfile_prefixes
, arg
, "BINUTILS",
8379 PREFIX_PRIORITY_LAST
, 0, 1);
8381 /* We should eventually get rid of all these and stick to
8382 startfile_prefix_spec exclusively. */
8383 else if (*cross_compile
== '0' || target_system_root
)
8385 if (*md_startfile_prefix
)
8386 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix
,
8387 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
8389 if (*md_startfile_prefix_1
)
8390 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix_1
,
8391 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
8393 /* If standard_startfile_prefix is relative, base it on
8394 standard_exec_prefix. This lets us move the installed tree
8395 as a unit. If GCC_EXEC_PREFIX is defined, base
8396 standard_startfile_prefix on that as well.
8398 If the prefix is relative, only search it for native compilers;
8399 otherwise we will search a directory containing host libraries. */
8400 if (IS_ABSOLUTE_PATH (standard_startfile_prefix
))
8401 add_sysrooted_prefix (&startfile_prefixes
,
8402 standard_startfile_prefix
, "BINUTILS",
8403 PREFIX_PRIORITY_LAST
, 0, 1);
8404 else if (*cross_compile
== '0')
8406 add_prefix (&startfile_prefixes
,
8407 concat (gcc_exec_prefix
8408 ? gcc_exec_prefix
: standard_exec_prefix
,
8410 standard_startfile_prefix
, NULL
),
8411 NULL
, PREFIX_PRIORITY_LAST
, 0, 1);
8414 /* Sysrooted prefixes are relocated because target_system_root is
8415 also relocated by gcc_exec_prefix. */
8416 if (*standard_startfile_prefix_1
)
8417 add_sysrooted_prefix (&startfile_prefixes
,
8418 standard_startfile_prefix_1
, "BINUTILS",
8419 PREFIX_PRIORITY_LAST
, 0, 1);
8420 if (*standard_startfile_prefix_2
)
8421 add_sysrooted_prefix (&startfile_prefixes
,
8422 standard_startfile_prefix_2
, "BINUTILS",
8423 PREFIX_PRIORITY_LAST
, 0, 1);
8426 /* Process any user specified specs in the order given on the command
8428 for (struct user_specs
*uptr
= user_specs_head
; uptr
; uptr
= uptr
->next
)
8430 char *filename
= find_a_file (&startfile_prefixes
, uptr
->filename
,
8432 read_specs (filename
? filename
: uptr
->filename
, false, true);
8435 /* Process any user self specs. */
8437 struct spec_list
*sl
;
8438 for (sl
= specs
; sl
; sl
= sl
->next
)
8439 if (sl
->name_len
== sizeof "self_spec" - 1
8440 && !strcmp (sl
->name
, "self_spec"))
8441 do_self_spec (*sl
->ptr_spec
);
8446 enum save_temps save
;
8448 if (!compare_debug_second
)
8450 n_switches_debug_check
[1] = n_switches
;
8451 n_switches_alloc_debug_check
[1] = n_switches_alloc
;
8452 switches_debug_check
[1] = XDUPVEC (struct switchstr
, switches
,
8455 do_self_spec ("%:compare-debug-self-opt()");
8456 n_switches_debug_check
[0] = n_switches
;
8457 n_switches_alloc_debug_check
[0] = n_switches_alloc
;
8458 switches_debug_check
[0] = switches
;
8460 n_switches
= n_switches_debug_check
[1];
8461 n_switches_alloc
= n_switches_alloc_debug_check
[1];
8462 switches
= switches_debug_check
[1];
8465 /* Avoid crash when computing %j in this early. */
8466 save
= save_temps_flag
;
8467 save_temps_flag
= SAVE_TEMPS_NONE
;
8469 compare_debug
= -compare_debug
;
8470 do_self_spec ("%:compare-debug-self-opt()");
8472 save_temps_flag
= save
;
8474 if (!compare_debug_second
)
8476 n_switches_debug_check
[1] = n_switches
;
8477 n_switches_alloc_debug_check
[1] = n_switches_alloc
;
8478 switches_debug_check
[1] = switches
;
8479 compare_debug
= -compare_debug
;
8480 n_switches
= n_switches_debug_check
[0];
8481 n_switches_alloc
= n_switches_debug_check
[0];
8482 switches
= switches_debug_check
[0];
8487 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
8488 if (gcc_exec_prefix
)
8489 gcc_exec_prefix
= concat (gcc_exec_prefix
, spec_host_machine
,
8490 dir_separator_str
, spec_version
,
8491 accel_dir_suffix
, dir_separator_str
, NULL
);
8493 /* Now we have the specs.
8494 Set the `valid' bits for switches that match anything in any spec. */
8496 validate_all_switches ();
8498 /* Now that we have the switches and the specs, set
8499 the subdirectory based on the options. */
8500 set_multilib_dir ();
8503 /* Set up to remember the pathname of gcc and any options
8504 needed for collect. We use argv[0] instead of progname because
8505 we need the complete pathname. */
8508 driver::putenv_COLLECT_GCC (const char *argv0
) const
8510 obstack_init (&collect_obstack
);
8511 obstack_grow (&collect_obstack
, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
8512 obstack_grow (&collect_obstack
, argv0
, strlen (argv0
) + 1);
8513 xputenv (XOBFINISH (&collect_obstack
, char *));
8516 /* Set up to remember the pathname of the lto wrapper. */
8519 driver::maybe_putenv_COLLECT_LTO_WRAPPER () const
8521 char *lto_wrapper_file
;
8524 lto_wrapper_file
= NULL
;
8526 lto_wrapper_file
= find_a_program ("lto-wrapper");
8527 if (lto_wrapper_file
)
8529 lto_wrapper_file
= convert_white_space (lto_wrapper_file
);
8530 set_static_spec_owned (<o_wrapper_spec
, lto_wrapper_file
);
8531 obstack_init (&collect_obstack
);
8532 obstack_grow (&collect_obstack
, "COLLECT_LTO_WRAPPER=",
8533 sizeof ("COLLECT_LTO_WRAPPER=") - 1);
8534 obstack_grow (&collect_obstack
, lto_wrapper_spec
,
8535 strlen (lto_wrapper_spec
) + 1);
8536 xputenv (XOBFINISH (&collect_obstack
, char *));
8541 /* Set up to remember the names of offload targets. */
8544 driver::maybe_putenv_OFFLOAD_TARGETS () const
8546 if (offload_targets
&& offload_targets
[0] != '\0')
8548 obstack_grow (&collect_obstack
, "OFFLOAD_TARGET_NAMES=",
8549 sizeof ("OFFLOAD_TARGET_NAMES=") - 1);
8550 obstack_grow (&collect_obstack
, offload_targets
,
8551 strlen (offload_targets
) + 1);
8552 xputenv (XOBFINISH (&collect_obstack
, char *));
8553 #if OFFLOAD_DEFAULTED
8554 if (offload_targets_default
)
8555 xputenv ("OFFLOAD_TARGET_DEFAULT=1");
8559 free (offload_targets
);
8560 offload_targets
= NULL
;
8563 /* Reject switches that no pass was interested in. */
8566 driver::handle_unrecognized_options ()
8568 for (size_t i
= 0; (int) i
< n_switches
; i
++)
8569 if (! switches
[i
].validated
)
8571 const char *hint
= m_option_proposer
.suggest_option (switches
[i
].part1
);
8573 error ("unrecognized command-line option %<-%s%>;"
8574 " did you mean %<-%s%>?",
8575 switches
[i
].part1
, hint
);
8577 error ("unrecognized command-line option %<-%s%>",
8582 /* Handle the various -print-* options, returning 0 if the driver
8583 should exit, or nonzero if the driver should continue. */
8586 driver::maybe_print_and_exit () const
8588 if (print_search_dirs
)
8590 printf (_("install: %s%s\n"),
8591 gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
8592 gcc_exec_prefix
? "" : machine_suffix
);
8593 printf (_("programs: %s\n"),
8594 build_search_list (&exec_prefixes
, "", false, false));
8595 printf (_("libraries: %s\n"),
8596 build_search_list (&startfile_prefixes
, "", false, true));
8600 if (print_file_name
)
8602 printf ("%s\n", find_file (print_file_name
));
8606 if (print_prog_name
)
8608 if (use_ld
!= NULL
&& ! strcmp (print_prog_name
, "ld"))
8610 /* Append USE_LD to the default linker. */
8611 #ifdef DEFAULT_LINKER
8613 # ifdef HAVE_HOST_EXECUTABLE_SUFFIX
8614 int len
= (sizeof (DEFAULT_LINKER
)
8615 - sizeof (HOST_EXECUTABLE_SUFFIX
));
8619 char *default_linker
= xstrdup (DEFAULT_LINKER
);
8620 /* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains
8621 HOST_EXECUTABLE_SUFFIX. */
8622 if (! strcmp (&default_linker
[len
], HOST_EXECUTABLE_SUFFIX
))
8624 default_linker
[len
] = '\0';
8625 ld
= concat (default_linker
, use_ld
,
8626 HOST_EXECUTABLE_SUFFIX
, NULL
);
8631 ld
= concat (DEFAULT_LINKER
, use_ld
, NULL
);
8632 if (access (ld
, X_OK
) == 0)
8634 printf ("%s\n", ld
);
8638 print_prog_name
= concat (print_prog_name
, use_ld
, NULL
);
8640 char *newname
= find_a_program (print_prog_name
);
8641 printf ("%s\n", (newname
? newname
: print_prog_name
));
8645 if (print_multi_lib
)
8647 print_multilib_info ();
8651 if (print_multi_directory
)
8653 if (multilib_dir
== NULL
)
8656 printf ("%s\n", multilib_dir
);
8660 if (print_multiarch
)
8662 if (multiarch_dir
== NULL
)
8665 printf ("%s\n", multiarch_dir
);
8671 if (target_system_root
)
8673 if (target_sysroot_suffix
)
8674 printf ("%s%s\n", target_system_root
, target_sysroot_suffix
);
8676 printf ("%s\n", target_system_root
);
8681 if (print_multi_os_directory
)
8683 if (multilib_os_dir
== NULL
)
8686 printf ("%s\n", multilib_os_dir
);
8690 if (print_sysroot_headers_suffix
)
8692 if (*sysroot_hdrs_suffix_spec
)
8694 printf("%s\n", (target_sysroot_hdrs_suffix
8695 ? target_sysroot_hdrs_suffix
8700 /* The error status indicates that only one set of fixed
8701 headers should be built. */
8702 fatal_error (input_location
,
8703 "not configured with sysroot headers suffix");
8706 if (print_help_list
)
8712 printf (_("\nFor bug reporting instructions, please see:\n"));
8713 printf ("%s.\n", bug_report_url
);
8718 /* We do not exit here. Instead we have created a fake input file
8719 called 'help-dummy' which needs to be compiled, and we pass this
8720 on the various sub-processes, along with the --help switch.
8721 Ensure their output appears after ours. */
8722 fputc ('\n', stdout
);
8728 printf (_("%s %s%s\n"), progname
, pkgversion_string
,
8730 printf ("Copyright %s 2022 Free Software Foundation, Inc.\n",
8732 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
8733 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
8738 /* We do not exit here. We use the same mechanism of --help to print
8739 the version of the sub-processes. */
8740 fputc ('\n', stdout
);
8746 print_configuration (stderr
);
8754 /* Figure out what to do with each input file.
8755 Return true if we need to exit early from "main", false otherwise. */
8758 driver::prepare_infiles ()
8761 int lang_n_infiles
= 0;
8763 if (n_infiles
== added_libraries
)
8764 fatal_error (input_location
, "no input files");
8767 /* Early exit needed from main. */
8770 /* Make a place to record the compiler output file names
8771 that correspond to the input files. */
8774 i
+= lang_specific_extra_outfiles
;
8775 outfiles
= XCNEWVEC (const char *, i
);
8777 /* Record which files were specified explicitly as link input. */
8779 explicit_link_files
= XCNEWVEC (char, n_infiles
);
8781 combine_inputs
= have_o
|| flag_wpa
;
8783 for (i
= 0; (int) i
< n_infiles
; i
++)
8785 const char *name
= infiles
[i
].name
;
8786 struct compiler
*compiler
= lookup_compiler (name
,
8788 infiles
[i
].language
);
8790 if (compiler
&& !(compiler
->combinable
))
8791 combine_inputs
= false;
8793 if (lang_n_infiles
> 0 && compiler
!= input_file_compiler
8794 && infiles
[i
].language
&& infiles
[i
].language
[0] != '*')
8795 infiles
[i
].incompiler
= compiler
;
8799 input_file_compiler
= compiler
;
8800 infiles
[i
].incompiler
= compiler
;
8804 /* Since there is no compiler for this input file, assume it is a
8806 explicit_link_files
[i
] = 1;
8807 infiles
[i
].incompiler
= NULL
;
8809 infiles
[i
].compiled
= false;
8810 infiles
[i
].preprocessed
= false;
8813 if (!combine_inputs
&& have_c
&& have_o
&& lang_n_infiles
> 1)
8814 fatal_error (input_location
,
8815 "cannot specify %<-o%> with %<-c%>, %<-S%> or %<-E%> "
8816 "with multiple files");
8818 /* No early exit needed from main; we can continue. */
8822 /* Run the spec machinery on each input file. */
8825 driver::do_spec_on_infiles () const
8829 for (i
= 0; (int) i
< n_infiles
; i
++)
8831 int this_file_error
= 0;
8833 /* Tell do_spec what to substitute for %i. */
8835 input_file_number
= i
;
8836 set_input (infiles
[i
].name
);
8838 if (infiles
[i
].compiled
)
8841 /* Use the same thing in %o, unless cp->spec says otherwise. */
8843 outfiles
[i
] = gcc_input_filename
;
8845 /* Figure out which compiler from the file's suffix. */
8848 = lookup_compiler (infiles
[i
].name
, input_filename_length
,
8849 infiles
[i
].language
);
8851 if (input_file_compiler
)
8853 /* Ok, we found an applicable compiler. Run its spec. */
8855 if (input_file_compiler
->spec
[0] == '#')
8857 error ("%s: %s compiler not installed on this system",
8858 gcc_input_filename
, &input_file_compiler
->spec
[1]);
8859 this_file_error
= 1;
8867 free (debug_check_temp_file
[0]);
8868 debug_check_temp_file
[0] = NULL
;
8870 free (debug_check_temp_file
[1]);
8871 debug_check_temp_file
[1] = NULL
;
8874 value
= do_spec (input_file_compiler
->spec
);
8875 infiles
[i
].compiled
= true;
8877 this_file_error
= 1;
8878 else if (compare_debug
&& debug_check_temp_file
[0])
8881 inform (UNKNOWN_LOCATION
,
8882 "recompiling with %<-fcompare-debug%>");
8884 compare_debug
= -compare_debug
;
8885 n_switches
= n_switches_debug_check
[1];
8886 n_switches_alloc
= n_switches_alloc_debug_check
[1];
8887 switches
= switches_debug_check
[1];
8889 value
= do_spec (input_file_compiler
->spec
);
8891 compare_debug
= -compare_debug
;
8892 n_switches
= n_switches_debug_check
[0];
8893 n_switches_alloc
= n_switches_alloc_debug_check
[0];
8894 switches
= switches_debug_check
[0];
8898 error ("during %<-fcompare-debug%> recompilation");
8899 this_file_error
= 1;
8902 gcc_assert (debug_check_temp_file
[1]
8903 && filename_cmp (debug_check_temp_file
[0],
8904 debug_check_temp_file
[1]));
8907 inform (UNKNOWN_LOCATION
, "comparing final insns dumps");
8909 if (compare_files (debug_check_temp_file
))
8910 this_file_error
= 1;
8915 free (debug_check_temp_file
[0]);
8916 debug_check_temp_file
[0] = NULL
;
8918 free (debug_check_temp_file
[1]);
8919 debug_check_temp_file
[1] = NULL
;
8924 /* If this file's name does not contain a recognized suffix,
8925 record it as explicit linker input. */
8928 explicit_link_files
[i
] = 1;
8930 /* Clear the delete-on-failure queue, deleting the files in it
8931 if this compilation failed. */
8933 if (this_file_error
)
8935 delete_failure_queue ();
8938 /* If this compilation succeeded, don't delete those files later. */
8939 clear_failure_queue ();
8942 /* Reset the input file name to the first compile/object file name, for use
8943 with %b in LINK_SPEC. We use the first input file that we can find
8944 a compiler to compile it instead of using infiles.language since for
8945 languages other than C we use aliases that we then lookup later. */
8950 for (i
= 0; i
< n_infiles
; i
++)
8951 if (infiles
[i
].incompiler
8952 || (infiles
[i
].language
&& infiles
[i
].language
[0] != '*'))
8954 set_input (infiles
[i
].name
);
8961 /* Make sure INPUT_FILE_NUMBER points to first available open
8963 input_file_number
= n_infiles
;
8964 if (lang_specific_pre_link ())
8969 /* If we have to run the linker, do it now. */
8972 driver::maybe_run_linker (const char *argv0
) const
8975 int linker_was_run
= 0;
8976 int num_linker_inputs
;
8978 /* Determine if there are any linker input files. */
8979 num_linker_inputs
= 0;
8980 for (i
= 0; (int) i
< n_infiles
; i
++)
8981 if (explicit_link_files
[i
] || outfiles
[i
] != NULL
)
8982 num_linker_inputs
++;
8984 /* Arrange for temporary file names created during linking to take
8985 on names related with the linker output rather than with the
8986 inputs when appropriate. */
8987 if (outbase
&& *outbase
)
8991 char *tofree
= dumpdir
;
8992 gcc_checking_assert (strlen (dumpdir
) == dumpdir_length
);
8993 dumpdir
= concat (dumpdir
, outbase
, ".", NULL
);
8997 dumpdir
= concat (outbase
, ".", NULL
);
8998 dumpdir_length
+= strlen (outbase
) + 1;
8999 dumpdir_trailing_dash_added
= true;
9001 else if (dumpdir_trailing_dash_added
)
9003 gcc_assert (dumpdir
[dumpdir_length
- 1] == '-');
9004 dumpdir
[dumpdir_length
- 1] = '.';
9007 if (dumpdir_trailing_dash_added
)
9009 gcc_assert (dumpdir_length
> 0);
9010 gcc_assert (dumpdir
[dumpdir_length
- 1] == '.');
9015 input_basename
= outbase
= NULL
;
9016 outbase_length
= suffixed_basename_length
= basename_length
= 0;
9018 /* Run ld to link all the compiler output files. */
9020 if (num_linker_inputs
> 0 && !seen_error () && print_subprocess_help
< 2)
9022 int tmp
= execution_count
;
9024 detect_jobserver ();
9028 #if HAVE_LTO_PLUGIN > 0
9029 #if HAVE_LTO_PLUGIN == 2
9030 const char *fno_use_linker_plugin
= "fno-use-linker-plugin";
9032 const char *fuse_linker_plugin
= "fuse-linker-plugin";
9036 /* We'll use ld if we can't find collect2. */
9037 if (! strcmp (linker_name_spec
, "collect2"))
9039 char *s
= find_a_program ("collect2");
9041 set_static_spec_shared (&linker_name_spec
, "ld");
9044 #if HAVE_LTO_PLUGIN > 0
9045 #if HAVE_LTO_PLUGIN == 2
9046 if (!switch_matches (fno_use_linker_plugin
,
9047 fno_use_linker_plugin
9048 + strlen (fno_use_linker_plugin
), 0))
9050 if (switch_matches (fuse_linker_plugin
,
9052 + strlen (fuse_linker_plugin
), 0))
9055 char *temp_spec
= find_a_file (&exec_prefixes
,
9056 LTOPLUGINSONAME
, R_OK
,
9059 fatal_error (input_location
,
9060 "%<-fuse-linker-plugin%>, but %s not found",
9062 linker_plugin_file_spec
= convert_white_space (temp_spec
);
9065 set_static_spec_shared (<o_gcc_spec
, argv0
);
9068 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
9070 putenv_from_prefixes (&exec_prefixes
, "COMPILER_PATH", false);
9071 putenv_from_prefixes (&startfile_prefixes
, LIBRARY_PATH_ENV
, true);
9073 if (print_subprocess_help
== 1)
9075 printf (_("\nLinker options\n==============\n\n"));
9076 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
9077 " to the linker.\n\n"));
9080 int value
= do_spec (link_command_spec
);
9083 linker_was_run
= (tmp
!= execution_count
);
9086 /* If options said don't run linker,
9087 complain about input files to be given to the linker. */
9089 if (! linker_was_run
&& !seen_error ())
9090 for (i
= 0; (int) i
< n_infiles
; i
++)
9091 if (explicit_link_files
[i
]
9092 && !(infiles
[i
].language
&& infiles
[i
].language
[0] == '*'))
9094 warning (0, "%s: linker input file unused because linking not done",
9096 if (access (outfiles
[i
], F_OK
) < 0)
9097 /* This is can be an indication the user specifed an errorneous
9098 separated option value, (or used the wrong prefix for an
9100 error ("%s: linker input file not found: %m", outfiles
[i
]);
9104 /* The end of "main". */
9107 driver::final_actions () const
9109 /* Delete some or all of the temporary files we made. */
9112 delete_failure_queue ();
9113 delete_temp_files ();
9115 if (print_help_list
)
9117 printf (("\nFor bug reporting instructions, please see:\n"));
9118 printf ("%s\n", bug_report_url
);
9122 /* Detect whether jobserver is active and working. If not drop
9123 --jobserver-auth from MAKEFLAGS. */
9126 driver::detect_jobserver () const
9128 jobserver_info jinfo
;
9129 if (!jinfo
.is_active
&& !jinfo
.skipped_makeflags
.empty ())
9130 xputenv (xstrdup (jinfo
.skipped_makeflags
.c_str ()));
9133 /* Determine what the exit code of the driver should be. */
9136 driver::get_exit_code () const
9138 return (signal_count
!= 0 ? 2
9139 : seen_error () ? (pass_exit_codes
? greatest_status
: 1)
9143 /* Find the proper compilation spec for the file name NAME,
9144 whose length is LENGTH. LANGUAGE is the specified language,
9145 or 0 if this file is to be passed to the linker. */
9147 static struct compiler
*
9148 lookup_compiler (const char *name
, size_t length
, const char *language
)
9150 struct compiler
*cp
;
9152 /* If this was specified by the user to be a linker input, indicate that. */
9153 if (language
!= 0 && language
[0] == '*')
9156 /* Otherwise, look for the language, if one is spec'd. */
9159 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
9160 if (cp
->suffix
[0] == '@' && !strcmp (cp
->suffix
+ 1, language
))
9162 if (name
!= NULL
&& strcmp (name
, "-") == 0
9163 && (strcmp (cp
->suffix
, "@c-header") == 0
9164 || strcmp (cp
->suffix
, "@c++-header") == 0)
9166 fatal_error (input_location
,
9167 "cannot use %<-%> as input filename for a "
9168 "precompiled header");
9173 error ("language %s not recognized", language
);
9177 /* Look for a suffix. */
9178 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
9180 if (/* The suffix `-' matches only the file name `-'. */
9181 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
9182 || (strlen (cp
->suffix
) < length
9183 /* See if the suffix matches the end of NAME. */
9184 && !strcmp (cp
->suffix
,
9185 name
+ length
- strlen (cp
->suffix
))
9190 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
9191 /* Look again, but case-insensitively this time. */
9193 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
9195 if (/* The suffix `-' matches only the file name `-'. */
9196 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
9197 || (strlen (cp
->suffix
) < length
9198 /* See if the suffix matches the end of NAME. */
9199 && ((!strcmp (cp
->suffix
,
9200 name
+ length
- strlen (cp
->suffix
))
9201 || !strpbrk (cp
->suffix
, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
9202 && !strcasecmp (cp
->suffix
,
9203 name
+ length
- strlen (cp
->suffix
)))
9209 if (cp
>= compilers
)
9211 if (cp
->spec
[0] != '@')
9212 /* A non-alias entry: return it. */
9215 /* An alias entry maps a suffix to a language.
9216 Search for the language; pass 0 for NAME and LENGTH
9217 to avoid infinite recursion if language not found. */
9218 return lookup_compiler (NULL
, 0, cp
->spec
+ 1);
9224 save_string (const char *s
, int len
)
9226 char *result
= XNEWVEC (char, len
+ 1);
9228 gcc_checking_assert (strlen (s
) >= (unsigned int) len
);
9229 memcpy (result
, s
, len
);
9236 validate_switches_from_spec (const char *spec
, bool user
)
9238 const char *p
= spec
;
9244 || (*p
== 'W' && *++p
== '{')
9245 || (*p
== '@' && *++p
== '{')))
9246 /* We have a switch spec. */
9247 p
= validate_switches (p
+ 1, user
, *p
== '{');
9251 validate_all_switches (void)
9253 struct compiler
*comp
;
9254 struct spec_list
*spec
;
9256 for (comp
= compilers
; comp
->spec
; comp
++)
9257 validate_switches_from_spec (comp
->spec
, false);
9259 /* Look through the linked list of specs read from the specs file. */
9260 for (spec
= specs
; spec
; spec
= spec
->next
)
9261 validate_switches_from_spec (*spec
->ptr_spec
, spec
->user_p
);
9263 validate_switches_from_spec (link_command_spec
, false);
9266 /* Look at the switch-name that comes after START and mark as valid
9267 all supplied switches that match it. If BRACED, handle other
9268 switches after '|' and '&', and specs after ':' until ';' or '}',
9269 going back for more switches after ';'. Without BRACED, handle
9270 only one atom. Return a pointer to whatever follows the handled
9271 items, after the closing brace if BRACED. */
9274 validate_switches (const char *start
, bool user_spec
, bool braced
)
9276 const char *p
= start
;
9280 bool suffix
= false;
9281 bool starred
= false;
9283 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
9292 if (*p
== '.' || *p
== ',')
9296 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
9297 || *p
== ',' || *p
== '.' || *p
== '@')
9302 starred
= true, p
++;
9308 /* Mark all matching switches as valid. */
9309 for (i
= 0; i
< n_switches
; i
++)
9310 if (!strncmp (switches
[i
].part1
, atom
, len
)
9311 && (starred
|| switches
[i
].part1
[len
] == '\0')
9312 && (switches
[i
].known
|| user_spec
))
9313 switches
[i
].validated
= true;
9320 if (*p
&& (p
[-1] == '|' || p
[-1] == '&'))
9323 if (*p
&& p
[-1] == ':')
9325 while (*p
&& *p
!= ';' && *p
!= '}')
9330 if (*p
== '{' || *p
== '<')
9331 p
= validate_switches (p
+1, user_spec
, *p
== '{');
9332 else if (p
[0] == 'W' && p
[1] == '{')
9333 p
= validate_switches (p
+2, user_spec
, true);
9334 else if (p
[0] == '@' && p
[1] == '{')
9335 p
= validate_switches (p
+2, user_spec
, true);
9342 if (*p
&& p
[-1] == ';')
9356 static struct mdswitchstr
*mdswitches
;
9357 static int n_mdswitches
;
9359 /* Check whether a particular argument was used. The first time we
9360 canonicalize the switches to keep only the ones we care about. */
9365 int operator () (const char *p
, int len
);
9372 const char *replace
;
9377 mswitchstr
*mswitches
;
9382 used_arg_t used_arg
;
9385 used_arg_t::operator () (const char *p
, int len
)
9391 struct mswitchstr
*matches
;
9395 /* Break multilib_matches into the component strings of string
9396 and replacement string. */
9397 for (q
= multilib_matches
; *q
!= '\0'; q
++)
9402 = (struct mswitchstr
*) alloca ((sizeof (struct mswitchstr
)) * cnt
);
9404 q
= multilib_matches
;
9413 fatal_error (input_location
, "multilib spec %qs is invalid",
9418 matches
[i
].len
= q
- matches
[i
].str
;
9420 matches
[i
].replace
= ++q
;
9421 while (*q
!= ';' && *q
!= '\0')
9424 goto invalid_matches
;
9427 matches
[i
].rep_len
= q
- matches
[i
].replace
;
9433 /* Now build a list of the replacement string for switches that we care
9434 about. Make sure we allocate at least one entry. This prevents
9435 xmalloc from calling fatal, and prevents us from re-executing this
9438 = XNEWVEC (struct mswitchstr
, n_mdswitches
+ (n_switches
? n_switches
: 1));
9439 for (i
= 0; i
< n_switches
; i
++)
9440 if ((switches
[i
].live_cond
& SWITCH_IGNORE
) == 0)
9442 int xlen
= strlen (switches
[i
].part1
);
9443 for (j
= 0; j
< cnt
; j
++)
9444 if (xlen
== matches
[j
].len
9445 && ! strncmp (switches
[i
].part1
, matches
[j
].str
, xlen
))
9447 mswitches
[n_mswitches
].str
= matches
[j
].replace
;
9448 mswitches
[n_mswitches
].len
= matches
[j
].rep_len
;
9449 mswitches
[n_mswitches
].replace
= (char *) 0;
9450 mswitches
[n_mswitches
].rep_len
= 0;
9456 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
9457 on the command line nor any options mutually incompatible with
9459 for (i
= 0; i
< n_mdswitches
; i
++)
9463 for (q
= multilib_options
; *q
!= '\0'; *q
&& q
++)
9469 while (strncmp (q
, mdswitches
[i
].str
, mdswitches
[i
].len
) != 0
9470 || strchr (" /", q
[mdswitches
[i
].len
]) == NULL
)
9472 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
9479 if (*q
!= ' ' && *q
!= '\0')
9481 while (*r
!= ' ' && *r
!= '\0')
9484 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
9487 if (used_arg (r
, q
- r
))
9492 mswitches
[n_mswitches
].str
= mdswitches
[i
].str
;
9493 mswitches
[n_mswitches
].len
= mdswitches
[i
].len
;
9494 mswitches
[n_mswitches
].replace
= (char *) 0;
9495 mswitches
[n_mswitches
].rep_len
= 0;
9508 for (i
= 0; i
< n_mswitches
; i
++)
9509 if (len
== mswitches
[i
].len
&& ! strncmp (p
, mswitches
[i
].str
, len
))
9515 void used_arg_t::finalize ()
9517 XDELETEVEC (mswitches
);
9524 default_arg (const char *p
, int len
)
9528 for (i
= 0; i
< n_mdswitches
; i
++)
9529 if (len
== mdswitches
[i
].len
&& ! strncmp (p
, mdswitches
[i
].str
, len
))
9535 /* Work out the subdirectory to use based on the options. The format of
9536 multilib_select is a list of elements. Each element is a subdirectory
9537 name followed by a list of options followed by a semicolon. The format
9538 of multilib_exclusions is the same, but without the preceding
9539 directory. First gcc will check the exclusions, if none of the options
9540 beginning with an exclamation point are present, and all of the other
9541 options are present, then we will ignore this completely. Passing
9542 that, gcc will consider each multilib_select in turn using the same
9543 rules for matching the options. If a match is found, that subdirectory
9545 A subdirectory name is optionally followed by a colon and the corresponding
9549 set_multilib_dir (void)
9552 unsigned int this_path_len
;
9553 const char *this_path
, *this_arg
;
9554 const char *start
, *end
;
9556 int ok
, ndfltok
, first
;
9559 start
= multilib_defaults
;
9560 while (*start
== ' ' || *start
== '\t')
9562 while (*start
!= '\0')
9565 while (*start
!= ' ' && *start
!= '\t' && *start
!= '\0')
9567 while (*start
== ' ' || *start
== '\t')
9575 mdswitches
= XNEWVEC (struct mdswitchstr
, n_mdswitches
);
9576 for (start
= multilib_defaults
; *start
!= '\0'; start
= end
+ 1)
9578 while (*start
== ' ' || *start
== '\t')
9584 for (end
= start
+ 1;
9585 *end
!= ' ' && *end
!= '\t' && *end
!= '\0'; end
++)
9588 obstack_grow (&multilib_obstack
, start
, end
- start
);
9589 obstack_1grow (&multilib_obstack
, 0);
9590 mdswitches
[i
].str
= XOBFINISH (&multilib_obstack
, const char *);
9591 mdswitches
[i
++].len
= end
- start
;
9598 p
= multilib_exclusions
;
9601 /* Ignore newlines. */
9608 /* Check the arguments. */
9615 fatal_error (input_location
, "multilib exclusions %qs is invalid",
9616 multilib_exclusions
);
9626 while (*p
!= ' ' && *p
!= ';')
9629 goto invalid_exclusions
;
9633 if (*this_arg
!= '!')
9641 ok
= used_arg (this_arg
, p
- this_arg
);
9656 p
= multilib_select
;
9658 /* Append multilib reuse rules if any. With those rules, we can reuse
9659 one multilib for certain different options sets. */
9660 if (strlen (multilib_reuse
) > 0)
9661 p
= concat (p
, multilib_reuse
, NULL
);
9665 /* Ignore newlines. */
9672 /* Get the initial path. */
9679 fatal_error (input_location
, "multilib select %qs %qs is invalid",
9680 multilib_select
, multilib_reuse
);
9684 this_path_len
= p
- this_path
;
9686 /* Check the arguments. */
9693 goto invalid_select
;
9702 while (*p
!= ' ' && *p
!= ';')
9705 goto invalid_select
;
9709 if (*this_arg
!= '!')
9717 /* If this is a default argument, we can just ignore it.
9718 This is true even if this_arg begins with '!'. Beginning
9719 with '!' does not mean that this argument is necessarily
9720 inappropriate for this library: it merely means that
9721 there is a more specific library which uses this
9722 argument. If this argument is a default, we need not
9723 consider that more specific library. */
9724 ok
= used_arg (this_arg
, p
- this_arg
);
9731 if (default_arg (this_arg
, p
- this_arg
))
9740 if (this_path_len
!= 1
9741 || this_path
[0] != '.')
9743 char *new_multilib_dir
= XNEWVEC (char, this_path_len
+ 1);
9746 strncpy (new_multilib_dir
, this_path
, this_path_len
);
9747 new_multilib_dir
[this_path_len
] = '\0';
9748 q
= strchr (new_multilib_dir
, ':');
9751 multilib_dir
= new_multilib_dir
;
9758 const char *q
= this_path
, *end
= this_path
+ this_path_len
;
9760 while (q
< end
&& *q
!= ':')
9764 const char *q2
= q
+ 1, *ml_end
= end
;
9765 char *new_multilib_os_dir
;
9767 while (q2
< end
&& *q2
!= ':')
9771 if (ml_end
- q
== 1)
9772 multilib_os_dir
= xstrdup (".");
9775 new_multilib_os_dir
= XNEWVEC (char, ml_end
- q
);
9776 memcpy (new_multilib_os_dir
, q
+ 1, ml_end
- q
- 1);
9777 new_multilib_os_dir
[ml_end
- q
- 1] = '\0';
9778 multilib_os_dir
= new_multilib_os_dir
;
9781 if (q2
< end
&& *q2
== ':')
9783 char *new_multiarch_dir
= XNEWVEC (char, end
- q2
);
9784 memcpy (new_multiarch_dir
, q2
+ 1, end
- q2
- 1);
9785 new_multiarch_dir
[end
- q2
- 1] = '\0';
9786 multiarch_dir
= new_multiarch_dir
;
9796 targetm_common
.compute_multilib (
9803 multilib_exclusions
,
9806 if (multilib_dir
== NULL
&& multilib_os_dir
!= NULL
9807 && strcmp (multilib_os_dir
, ".") == 0)
9809 free (CONST_CAST (char *, multilib_os_dir
));
9810 multilib_os_dir
= NULL
;
9812 else if (multilib_dir
!= NULL
&& multilib_os_dir
== NULL
)
9813 multilib_os_dir
= multilib_dir
;
9816 /* Print out the multiple library subdirectory selection
9817 information. This prints out a series of lines. Each line looks
9818 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
9819 required. Only the desired options are printed out, the negative
9820 matches. The options are print without a leading dash. There are
9821 no spaces to make it easy to use the information in the shell.
9822 Each subdirectory is printed only once. This assumes the ordering
9823 generated by the genmultilib script. Also, we leave out ones that match
9827 print_multilib_info (void)
9829 const char *p
= multilib_select
;
9830 const char *last_path
= 0, *this_path
;
9833 unsigned int last_path_len
= 0;
9838 /* Ignore newlines. */
9845 /* Get the initial path. */
9852 fatal_error (input_location
,
9853 "multilib select %qs is invalid", multilib_select
);
9859 /* When --disable-multilib was used but target defines
9860 MULTILIB_OSDIRNAMES, entries starting with .: (and not starting
9861 with .:: for multiarch configurations) are there just to find
9862 multilib_os_dir, so skip them from output. */
9863 if (this_path
[0] == '.' && this_path
[1] == ':' && this_path
[2] != ':')
9866 /* Check for matches with the multilib_exclusions. We don't bother
9867 with the '!' in either list. If any of the exclusion rules match
9868 all of its options with the select rule, we skip it. */
9870 const char *e
= multilib_exclusions
;
9871 const char *this_arg
;
9876 /* Ignore newlines. */
9883 /* Check the arguments. */
9892 fatal_error (input_location
,
9893 "multilib exclusion %qs is invalid",
9894 multilib_exclusions
);
9905 while (*e
!= ' ' && *e
!= ';')
9908 goto invalid_exclusion
;
9916 int len
= e
- this_arg
;
9919 goto invalid_select
;
9923 while (*q
!= ' ' && *q
!= ';')
9926 goto invalid_select
;
9930 if (! strncmp (arg
, this_arg
,
9931 (len
< q
- arg
) ? q
- arg
: len
)
9932 || default_arg (this_arg
, e
- this_arg
))
9962 /* If this is a duplicate, skip it. */
9963 skip
= (last_path
!= 0
9964 && (unsigned int) (p
- this_path
) == last_path_len
9965 && ! filename_ncmp (last_path
, this_path
, last_path_len
));
9967 last_path
= this_path
;
9968 last_path_len
= p
- this_path
;
9971 /* If all required arguments are default arguments, and no default
9972 arguments appear in the ! argument list, then we can skip it.
9973 We will already have printed a directory identical to this one
9974 which does not require that default argument. */
9978 bool default_arg_ok
= false;
9986 goto invalid_select
;
9997 while (*q
!= ' ' && *q
!= ';')
10000 goto invalid_select
;
10004 if (default_arg (arg
, q
- arg
))
10006 /* Stop checking if any default arguments appeared in not
10010 default_arg_ok
= false;
10014 default_arg_ok
= true;
10018 /* Stop checking if any required argument is not provided by
10019 default arguments. */
10020 default_arg_ok
= false;
10028 /* Make sure all default argument is OK for this multi-lib set. */
10029 if (default_arg_ok
)
10039 for (p1
= last_path
; p1
< p
&& *p1
!= ':'; p1
++)
10050 goto invalid_select
;
10058 use_arg
= *p
!= '!';
10063 while (*p
!= ' ' && *p
!= ';')
10066 goto invalid_select
;
10078 /* If there are extra options, print them now. */
10079 if (multilib_extra
&& *multilib_extra
)
10081 int print_at
= TRUE
;
10084 for (q
= multilib_extra
; *q
!= '\0'; q
++)
10105 /* getenv built-in spec function.
10107 Returns the value of the environment variable given by its first argument,
10108 concatenated with the second argument. If the variable is not defined, a
10109 fatal error is issued unless such undefs are internally allowed, in which
10110 case the variable name prefixed by a '/' is used as the variable value.
10112 The leading '/' allows using the result at a spot where a full path would
10113 normally be expected and when the actual value doesn't really matter since
10114 undef vars are allowed. */
10116 static const char *
10117 getenv_spec_function (int argc
, const char **argv
)
10120 const char *varname
;
10130 value
= env
.get (varname
);
10132 /* If the variable isn't defined and this is allowed, craft our expected
10133 return value. Assume variable names used in specs strings don't contain
10134 any active spec character so don't need escaping. */
10135 if (!value
&& spec_undefvar_allowed
)
10137 result
= XNEWVAR (char, strlen(varname
) + 2);
10138 sprintf (result
, "/%s", varname
);
10143 fatal_error (input_location
,
10144 "environment variable %qs not defined", varname
);
10146 /* We have to escape every character of the environment variable so
10147 they are not interpreted as active spec characters. A
10148 particularly painful case is when we are reading a variable
10149 holding a windows path complete with \ separators. */
10150 len
= strlen (value
) * 2 + strlen (argv
[1]) + 1;
10151 result
= XNEWVAR (char, len
);
10152 for (ptr
= result
; *value
; ptr
+= 2)
10158 strcpy (ptr
, argv
[1]);
10163 /* if-exists built-in spec function.
10165 Checks to see if the file specified by the absolute pathname in
10166 ARGS exists. Returns that pathname if found.
10168 The usual use for this function is to check for a library file
10169 (whose name has been expanded with %s). */
10171 static const char *
10172 if_exists_spec_function (int argc
, const char **argv
)
10174 /* Must have only one argument. */
10175 if (argc
== 1 && IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
10181 /* if-exists-else built-in spec function.
10183 This is like if-exists, but takes an additional argument which
10184 is returned if the first argument does not exist. */
10186 static const char *
10187 if_exists_else_spec_function (int argc
, const char **argv
)
10189 /* Must have exactly two arguments. */
10193 if (IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
10199 /* if-exists-then-else built-in spec function.
10201 Checks to see if the file specified by the absolute pathname in
10202 the first arg exists. Returns the second arg if so, otherwise returns
10203 the third arg if it is present. */
10205 static const char *
10206 if_exists_then_else_spec_function (int argc
, const char **argv
)
10209 /* Must have two or three arguments. */
10210 if (argc
!= 2 && argc
!= 3)
10213 if (IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
10222 /* sanitize built-in spec function.
10224 This returns non-NULL, if sanitizing address, thread or
10225 any of the undefined behavior sanitizers. */
10227 static const char *
10228 sanitize_spec_function (int argc
, const char **argv
)
10233 if (strcmp (argv
[0], "address") == 0)
10234 return (flag_sanitize
& SANITIZE_USER_ADDRESS
) ? "" : NULL
;
10235 if (strcmp (argv
[0], "hwaddress") == 0)
10236 return (flag_sanitize
& SANITIZE_USER_HWADDRESS
) ? "" : NULL
;
10237 if (strcmp (argv
[0], "kernel-address") == 0)
10238 return (flag_sanitize
& SANITIZE_KERNEL_ADDRESS
) ? "" : NULL
;
10239 if (strcmp (argv
[0], "kernel-hwaddress") == 0)
10240 return (flag_sanitize
& SANITIZE_KERNEL_HWADDRESS
) ? "" : NULL
;
10241 if (strcmp (argv
[0], "thread") == 0)
10242 return (flag_sanitize
& SANITIZE_THREAD
) ? "" : NULL
;
10243 if (strcmp (argv
[0], "undefined") == 0)
10244 return ((flag_sanitize
10245 & ~flag_sanitize_trap
10246 & (SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
)))
10248 if (strcmp (argv
[0], "leak") == 0)
10249 return ((flag_sanitize
10250 & (SANITIZE_ADDRESS
| SANITIZE_LEAK
| SANITIZE_THREAD
))
10251 == SANITIZE_LEAK
) ? "" : NULL
;
10255 /* replace-outfile built-in spec function.
10257 This looks for the first argument in the outfiles array's name and
10258 replaces it with the second argument. */
10260 static const char *
10261 replace_outfile_spec_function (int argc
, const char **argv
)
10264 /* Must have exactly two arguments. */
10268 for (i
= 0; i
< n_infiles
; i
++)
10270 if (outfiles
[i
] && !filename_cmp (outfiles
[i
], argv
[0]))
10271 outfiles
[i
] = xstrdup (argv
[1]);
10276 /* remove-outfile built-in spec function.
10278 * This looks for the first argument in the outfiles array's name and
10281 static const char *
10282 remove_outfile_spec_function (int argc
, const char **argv
)
10285 /* Must have exactly one argument. */
10289 for (i
= 0; i
< n_infiles
; i
++)
10291 if (outfiles
[i
] && !filename_cmp (outfiles
[i
], argv
[0]))
10292 outfiles
[i
] = NULL
;
10297 /* Given two version numbers, compares the two numbers.
10298 A version number must match the regular expression
10299 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
10302 compare_version_strings (const char *v1
, const char *v2
)
10307 if (regcomp (&r
, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
10308 REG_EXTENDED
| REG_NOSUB
) != 0)
10310 rresult
= regexec (&r
, v1
, 0, NULL
, 0);
10311 if (rresult
== REG_NOMATCH
)
10312 fatal_error (input_location
, "invalid version number %qs", v1
);
10313 else if (rresult
!= 0)
10315 rresult
= regexec (&r
, v2
, 0, NULL
, 0);
10316 if (rresult
== REG_NOMATCH
)
10317 fatal_error (input_location
, "invalid version number %qs", v2
);
10318 else if (rresult
!= 0)
10321 return strverscmp (v1
, v2
);
10325 /* version_compare built-in spec function.
10327 This takes an argument of the following form:
10329 <comparison-op> <arg1> [<arg2>] <switch> <result>
10331 and produces "result" if the comparison evaluates to true,
10332 and nothing if it doesn't.
10334 The supported <comparison-op> values are:
10336 >= true if switch is a later (or same) version than arg1
10338 < true if switch is an earlier version than arg1
10340 >< true if switch is arg1 or later, and earlier than arg2
10341 <> true if switch is earlier than arg1 or is arg2 or later
10343 If the switch is not present, the condition is false unless
10344 the first character of the <comparison-op> is '!'.
10347 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
10348 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
10350 static const char *
10351 version_compare_spec_function (int argc
, const char **argv
)
10355 const char *switch_value
= NULL
;
10360 fatal_error (input_location
, "too few arguments to %%:version-compare");
10361 if (argv
[0][0] == '\0')
10363 if ((argv
[0][1] == '<' || argv
[0][1] == '>') && argv
[0][0] != '!')
10365 if (argc
!= nargs
+ 3)
10366 fatal_error (input_location
, "too many arguments to %%:version-compare");
10368 switch_len
= strlen (argv
[nargs
+ 1]);
10369 for (i
= 0; i
< n_switches
; i
++)
10370 if (!strncmp (switches
[i
].part1
, argv
[nargs
+ 1], switch_len
)
10371 && check_live_switch (i
, switch_len
))
10372 switch_value
= switches
[i
].part1
+ switch_len
;
10374 if (switch_value
== NULL
)
10375 comp1
= comp2
= -1;
10378 comp1
= compare_version_strings (switch_value
, argv
[1]);
10380 comp2
= compare_version_strings (switch_value
, argv
[2]);
10382 comp2
= -1; /* This value unused. */
10385 switch (argv
[0][0] << 8 | argv
[0][1])
10387 case '>' << 8 | '=':
10388 result
= comp1
>= 0;
10390 case '!' << 8 | '<':
10391 result
= comp1
>= 0 || switch_value
== NULL
;
10394 result
= comp1
< 0;
10396 case '!' << 8 | '>':
10397 result
= comp1
< 0 || switch_value
== NULL
;
10399 case '>' << 8 | '<':
10400 result
= comp1
>= 0 && comp2
< 0;
10402 case '<' << 8 | '>':
10403 result
= comp1
< 0 || comp2
>= 0;
10407 fatal_error (input_location
,
10408 "unknown operator %qs in %%:version-compare", argv
[0]);
10413 return argv
[nargs
+ 2];
10416 /* %:include builtin spec function. This differs from %include in that it
10417 can be nested inside a spec, and thus be conditionalized. It takes
10418 one argument, the filename, and looks for it in the startfile path.
10419 The result is always NULL, i.e. an empty expansion. */
10421 static const char *
10422 include_spec_function (int argc
, const char **argv
)
10429 file
= find_a_file (&startfile_prefixes
, argv
[0], R_OK
, true);
10430 read_specs (file
? file
: argv
[0], false, false);
10435 /* %:find-file spec function. This function replaces its argument by
10436 the file found through find_file, that is the -print-file-name gcc
10438 static const char *
10439 find_file_spec_function (int argc
, const char **argv
)
10446 file
= find_file (argv
[0]);
10451 /* %:find-plugindir spec function. This function replaces its argument
10452 by the -iplugindir=<dir> option. `dir' is found through find_file, that
10453 is the -print-file-name gcc program option. */
10454 static const char *
10455 find_plugindir_spec_function (int argc
, const char **argv ATTRIBUTE_UNUSED
)
10457 const char *option
;
10462 option
= concat ("-iplugindir=", find_file ("plugin"), NULL
);
10467 /* %:print-asm-header spec function. Print a banner to say that the
10468 following output is from the assembler. */
10470 static const char *
10471 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED
,
10472 const char **argv ATTRIBUTE_UNUSED
)
10474 printf (_("Assembler options\n=================\n\n"));
10475 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
10480 /* Get a random number for -frandom-seed */
10482 static unsigned HOST_WIDE_INT
10483 get_random_number (void)
10485 unsigned HOST_WIDE_INT ret
= 0;
10488 fd
= open ("/dev/urandom", O_RDONLY
);
10491 read (fd
, &ret
, sizeof (HOST_WIDE_INT
));
10497 /* Get some more or less random data. */
10498 #ifdef HAVE_GETTIMEOFDAY
10502 gettimeofday (&tv
, NULL
);
10503 ret
= tv
.tv_sec
* 1000 + tv
.tv_usec
/ 1000;
10507 time_t now
= time (NULL
);
10509 if (now
!= (time_t)-1)
10510 ret
= (unsigned) now
;
10514 return ret
^ getpid ();
10517 /* %:compare-debug-dump-opt spec function. Save the last argument,
10518 expected to be the last -fdump-final-insns option, or generate a
10521 static const char *
10522 compare_debug_dump_opt_spec_function (int arg
,
10523 const char **argv ATTRIBUTE_UNUSED
)
10528 static char random_seed
[HOST_BITS_PER_WIDE_INT
/ 4 + 3];
10531 fatal_error (input_location
,
10532 "too many arguments to %%:compare-debug-dump-opt");
10534 do_spec_2 ("%{fdump-final-insns=*:%*}", NULL
);
10535 do_spec_1 (" ", 0, NULL
);
10537 if (argbuf
.length () > 0
10538 && strcmp (argv
[argbuf
.length () - 1], ".") != 0)
10540 if (!compare_debug
)
10543 name
= xstrdup (argv
[argbuf
.length () - 1]);
10548 if (argbuf
.length () > 0)
10549 do_spec_2 ("%B.gkd", NULL
);
10550 else if (!compare_debug
)
10553 do_spec_2 ("%{!save-temps*:%g.gkd}%{save-temps*:%B.gkd}", NULL
);
10555 do_spec_1 (" ", 0, NULL
);
10557 gcc_assert (argbuf
.length () > 0);
10559 name
= xstrdup (argbuf
.last ());
10561 char *arg
= quote_spec (xstrdup (name
));
10562 ret
= concat ("-fdump-final-insns=", arg
, NULL
);
10566 which
= compare_debug
< 0;
10567 debug_check_temp_file
[which
] = name
;
10571 unsigned HOST_WIDE_INT value
= get_random_number ();
10573 sprintf (random_seed
, HOST_WIDE_INT_PRINT_HEX
, value
);
10579 ret
= concat ("%{!frandom-seed=*:-frandom-seed=", random_seed
, "} ",
10590 /* %:compare-debug-self-opt spec function. Expands to the options
10591 that are to be passed in the second compilation of
10594 static const char *
10595 compare_debug_self_opt_spec_function (int arg
,
10596 const char **argv ATTRIBUTE_UNUSED
)
10599 fatal_error (input_location
,
10600 "too many arguments to %%:compare-debug-self-opt");
10602 if (compare_debug
>= 0)
10606 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
10607 %<fdump-final-insns=* -w -S -o %j \
10608 %{!fcompare-debug-second:-fcompare-debug-second} \
10609 ", compare_debug_opt
, NULL
);
10612 /* %:pass-through-libs spec function. Finds all -l options and input
10613 file names in the lib spec passed to it, and makes a list of them
10614 prepended with the plugin option to cause them to be passed through
10615 to the final link after all the new object files have been added. */
10618 pass_through_libs_spec_func (int argc
, const char **argv
)
10620 char *prepended
= xstrdup (" ");
10622 /* Shlemiel the painter's algorithm. Innately horrible, but at least
10623 we know that there will never be more than a handful of strings to
10624 concat, and it's only once per run, so it's not worth optimising. */
10625 for (n
= 0; n
< argc
; n
++)
10627 char *old
= prepended
;
10628 /* Anything that isn't an option is a full path to an output
10629 file; pass it through if it ends in '.a'. Among options,
10631 if (argv
[n
][0] == '-' && argv
[n
][1] == 'l')
10633 const char *lopt
= argv
[n
] + 2;
10634 /* Handle both joined and non-joined -l options. If for any
10635 reason there's a trailing -l with no joined or following
10636 arg just discard it. */
10637 if (!*lopt
&& ++n
>= argc
)
10641 prepended
= concat (prepended
, "-plugin-opt=-pass-through=-l",
10644 else if (!strcmp (".a", argv
[n
] + strlen (argv
[n
]) - 2))
10646 prepended
= concat (prepended
, "-plugin-opt=-pass-through=",
10647 argv
[n
], " ", NULL
);
10649 if (prepended
!= old
)
10656 not_actual_file_p (const char *name
)
10658 return (strcmp (name
, "-") == 0
10659 || strcmp (name
, HOST_BIT_BUCKET
) == 0);
10662 /* %:dumps spec function. Take an optional argument that overrides
10663 the default extension for -dumpbase and -dumpbase-ext.
10664 Return -dumpdir, -dumpbase and -dumpbase-ext, if needed. */
10666 dumps_spec_func (int argc
, const char **argv ATTRIBUTE_UNUSED
)
10668 const char *ext
= dumpbase_ext
;
10671 char *args
[3] = { NULL
, NULL
, NULL
};
10674 /* Do not compute a default for -dumpbase-ext when -dumpbase was
10675 given explicitly. */
10676 if (dumpbase
&& *dumpbase
&& !ext
)
10681 /* Do not override the explicitly-specified -dumpbase-ext with
10682 the specs-provided overrider. */
10686 else if (argc
!= 0)
10687 fatal_error (input_location
, "too many arguments for %%:dumps");
10691 p
= quote_spec_arg (xstrdup (dumpdir
));
10692 args
[nargs
++] = concat (" -dumpdir ", p
, NULL
);
10697 ext
= input_basename
+ basename_length
;
10699 /* Use the precomputed outbase, or compute dumpbase from
10700 input_basename, just like %b would. */
10703 if (dumpbase
&& *dumpbase
)
10705 base
= xstrdup (dumpbase
);
10706 p
= base
+ outbase_length
;
10707 gcc_checking_assert (strncmp (base
, outbase
, outbase_length
) == 0);
10708 gcc_checking_assert (strcmp (p
, ext
) == 0);
10710 else if (outbase_length
)
10712 base
= xstrndup (outbase
, outbase_length
);
10717 base
= xstrndup (input_basename
, suffixed_basename_length
);
10718 p
= base
+ basename_length
;
10721 if (compare_debug
< 0 || !p
|| strcmp (p
, ext
) != 0)
10727 if (compare_debug
< 0)
10732 p
= concat (base
, gk
, ext
, NULL
);
10738 base
= quote_spec_arg (base
);
10739 args
[nargs
++] = concat (" -dumpbase ", base
, NULL
);
10744 p
= quote_spec_arg (xstrdup (ext
));
10745 args
[nargs
++] = concat (" -dumpbase-ext ", p
, NULL
);
10749 const char *ret
= concat (args
[0], args
[1], args
[2], NULL
);
10751 free (args
[--nargs
]);
10756 /* Returns "" if ARGV[ARGC - 2] is greater than ARGV[ARGC-1].
10757 Otherwise, return NULL. */
10759 static const char *
10760 greater_than_spec_func (int argc
, const char **argv
)
10767 gcc_assert (argc
>= 2);
10769 long arg
= strtol (argv
[argc
- 2], &converted
, 10);
10770 gcc_assert (converted
!= argv
[argc
- 2]);
10772 long lim
= strtol (argv
[argc
- 1], &converted
, 10);
10773 gcc_assert (converted
!= argv
[argc
- 1]);
10781 /* Returns "" if debug_info_level is greater than ARGV[ARGC-1].
10782 Otherwise, return NULL. */
10784 static const char *
10785 debug_level_greater_than_spec_func (int argc
, const char **argv
)
10790 fatal_error (input_location
,
10791 "wrong number of arguments to %%:debug-level-gt");
10793 long arg
= strtol (argv
[0], &converted
, 10);
10794 gcc_assert (converted
!= argv
[0]);
10796 if (debug_info_level
> arg
)
10802 /* Returns "" if dwarf_version is greater than ARGV[ARGC-1].
10803 Otherwise, return NULL. */
10805 static const char *
10806 dwarf_version_greater_than_spec_func (int argc
, const char **argv
)
10811 fatal_error (input_location
,
10812 "wrong number of arguments to %%:dwarf-version-gt");
10814 long arg
= strtol (argv
[0], &converted
, 10);
10815 gcc_assert (converted
!= argv
[0]);
10817 if (dwarf_version
> arg
)
10824 path_prefix_reset (path_prefix
*prefix
)
10826 struct prefix_list
*iter
, *next
;
10827 iter
= prefix
->plist
;
10831 free (const_cast <char *> (iter
->prefix
));
10836 prefix
->max_len
= 0;
10839 /* The function takes 3 arguments: OPTION name, file name and location
10840 where we search for Fortran modules.
10841 When the FILE is found by find_file, return OPTION=path_to_file. */
10843 static const char *
10844 find_fortran_preinclude_file (int argc
, const char **argv
)
10846 char *result
= NULL
;
10850 struct path_prefix prefixes
= { 0, 0, "preinclude" };
10852 /* Search first for 'finclude' folder location for a header file
10853 installed by the compiler (similar to omp_lib.h). */
10854 add_prefix (&prefixes
, argv
[2], NULL
, 0, 0, 0);
10855 #ifdef TOOL_INCLUDE_DIR
10856 /* Then search: <prefix>/<target>/<include>/finclude */
10857 add_prefix (&prefixes
, TOOL_INCLUDE_DIR
"/finclude/",
10860 #ifdef NATIVE_SYSTEM_HEADER_DIR
10861 /* Then search: <sysroot>/usr/include/finclude/<multilib> */
10862 add_sysrooted_hdrs_prefix (&prefixes
, NATIVE_SYSTEM_HEADER_DIR
"/finclude/",
10866 const char *path
= find_a_file (&include_prefixes
, argv
[1], R_OK
, false);
10868 result
= concat (argv
[0], path
, NULL
);
10871 path
= find_a_file (&prefixes
, argv
[1], R_OK
, false);
10873 result
= concat (argv
[0], path
, NULL
);
10876 path_prefix_reset (&prefixes
);
10880 /* If any character in ORIG fits QUOTE_P (_, P), reallocate the string
10881 so as to precede every one of them with a backslash. Return the
10882 original string or the reallocated one. */
10884 static inline char *
10885 quote_string (char *orig
, bool (*quote_p
)(char, void *), void *p
)
10887 int len
, number_of_space
= 0;
10889 for (len
= 0; orig
[len
]; len
++)
10890 if (quote_p (orig
[len
], p
))
10893 if (number_of_space
)
10895 char *new_spec
= (char *) xmalloc (len
+ number_of_space
+ 1);
10897 for (j
= 0, k
= 0; j
<= len
; j
++, k
++)
10899 if (quote_p (orig
[j
], p
))
10900 new_spec
[k
++] = '\\';
10901 new_spec
[k
] = orig
[j
];
10910 /* Return true iff C is any of the characters convert_white_space
10914 whitespace_to_convert_p (char c
, void *)
10916 return (c
== ' ' || c
== '\t');
10919 /* Insert backslash before spaces in ORIG (usually a file path), to
10920 avoid being broken by spec parser.
10922 This function is needed as do_spec_1 treats white space (' ' and '\t')
10923 as the end of an argument. But in case of -plugin /usr/gcc install/xxx.so,
10924 the file name should be treated as a single argument rather than being
10925 broken into multiple. Solution is to insert '\\' before the space in a
10928 This function converts and only converts all occurrence of ' '
10929 to '\\' + ' ' and '\t' to '\\' + '\t'. For example:
10931 "a b" -> "a\\ \\ b"
10933 "a\\ b" -> "a\\\\ b"
10935 orig: input null-terminating string that was allocated by xalloc. The
10936 memory it points to might be freed in this function. Behavior undefined
10937 if ORIG wasn't xalloced or was freed already at entry.
10939 Return: ORIG if no conversion needed. Otherwise a newly allocated string
10940 that was converted from ORIG. */
10943 convert_white_space (char *orig
)
10945 return quote_string (orig
, whitespace_to_convert_p
, NULL
);
10948 /* Return true iff C matches any of the spec active characters. */
10950 quote_spec_char_p (char c
, void *)
10967 /* Like convert_white_space, but deactivate all active spec chars by
10970 static inline char *
10971 quote_spec (char *orig
)
10973 return quote_string (orig
, quote_spec_char_p
, NULL
);
10976 /* Like quote_spec, but also turn an empty string into the spec for an
10979 static inline char *
10980 quote_spec_arg (char *orig
)
10985 return xstrdup ("%\"");
10988 return quote_spec (orig
);
10991 /* Restore all state within gcc.cc to the initial state, so that the driver
10992 code can be safely re-run in-process.
10994 Many const char * variables are referenced by static specs (see
10995 INIT_STATIC_SPEC above). These variables are restored to their default
10996 values by a simple loop over the static specs.
10998 For other variables, we directly restore them all to their initial
10999 values (often implicitly 0).
11001 Free the various obstacks in this file, along with "opts_obstack"
11004 This function also restores any environment variables that were changed. */
11007 driver::finalize ()
11010 diagnostic_finish (global_dc
);
11013 at_file_supplied
= 0;
11014 print_help_list
= 0;
11016 verbose_only_flag
= 0;
11017 print_subprocess_help
= 0;
11019 report_times_to_file
= NULL
;
11020 target_system_root
= DEFAULT_TARGET_SYSTEM_ROOT
;
11021 target_system_root_changed
= 0;
11022 target_sysroot_suffix
= 0;
11023 target_sysroot_hdrs_suffix
= 0;
11024 save_temps_flag
= SAVE_TEMPS_NONE
;
11025 save_temps_overrides_dumpdir
= false;
11026 dumpdir_trailing_dash_added
= false;
11029 free (dumpbase_ext
);
11031 dumpdir
= dumpbase
= dumpbase_ext
= outbase
= NULL
;
11032 dumpdir_length
= outbase_length
= 0;
11033 spec_machine
= DEFAULT_TARGET_MACHINE
;
11034 greatest_status
= 1;
11036 obstack_free (&obstack
, NULL
);
11037 obstack_free (&opts_obstack
, NULL
); /* in opts.cc */
11038 obstack_free (&collect_obstack
, NULL
);
11040 link_command_spec
= LINK_COMMAND_SPEC
;
11042 obstack_free (&multilib_obstack
, NULL
);
11044 user_specs_head
= NULL
;
11045 user_specs_tail
= NULL
;
11047 /* Within the "compilers" vec, the fields "suffix" and "spec" were
11048 statically allocated for the default compilers, but dynamically
11049 allocated for additional compilers. Delete them for the latter. */
11050 for (int i
= n_default_compilers
; i
< n_compilers
; i
++)
11052 free (const_cast <char *> (compilers
[i
].suffix
));
11053 free (const_cast <char *> (compilers
[i
].spec
));
11055 XDELETEVEC (compilers
);
11059 linker_options
.truncate (0);
11060 assembler_options
.truncate (0);
11061 preprocessor_options
.truncate (0);
11063 path_prefix_reset (&exec_prefixes
);
11064 path_prefix_reset (&startfile_prefixes
);
11065 path_prefix_reset (&include_prefixes
);
11067 machine_suffix
= 0;
11068 just_machine_suffix
= 0;
11069 gcc_exec_prefix
= 0;
11070 gcc_libexec_prefix
= 0;
11071 set_static_spec_shared (&md_exec_prefix
, MD_EXEC_PREFIX
);
11072 set_static_spec_shared (&md_startfile_prefix
, MD_STARTFILE_PREFIX
);
11073 set_static_spec_shared (&md_startfile_prefix_1
, MD_STARTFILE_PREFIX_1
);
11075 multilib_os_dir
= 0;
11078 /* Free any specs dynamically-allocated by set_spec.
11079 These will be at the head of the list, before the
11080 statically-allocated ones. */
11083 while (specs
!= static_specs
)
11085 spec_list
*next
= specs
->next
;
11086 free (const_cast <char *> (specs
->name
));
11092 for (unsigned i
= 0; i
< ARRAY_SIZE (static_specs
); i
++)
11094 spec_list
*sl
= &static_specs
[i
];
11097 free (const_cast <char *> (*(sl
->ptr_spec
)));
11098 sl
->alloc_p
= false;
11100 *(sl
->ptr_spec
) = sl
->default_ptr
;
11103 extra_specs
= NULL
;
11106 processing_spec_function
= 0;
11114 execution_count
= 0;
11117 temp_filename
= NULL
;
11118 temp_filename_length
= 0;
11119 always_delete_queue
= NULL
;
11120 failure_delete_queue
= NULL
;
11122 XDELETEVEC (switches
);
11125 n_switches_alloc
= 0;
11128 compare_debug_second
= 0;
11129 compare_debug_opt
= NULL
;
11130 for (int i
= 0; i
< 2; i
++)
11132 switches_debug_check
[i
] = NULL
;
11133 n_switches_debug_check
[i
] = 0;
11134 n_switches_alloc_debug_check
[i
] = 0;
11135 debug_check_temp_file
[i
] = NULL
;
11138 XDELETEVEC (infiles
);
11141 n_infiles_alloc
= 0;
11143 combine_inputs
= false;
11144 added_libraries
= 0;
11145 XDELETEVEC (outfiles
);
11148 last_language_n_infiles
= 0;
11149 gcc_input_filename
= NULL
;
11150 input_file_number
= 0;
11151 input_filename_length
= 0;
11152 basename_length
= 0;
11153 suffixed_basename_length
= 0;
11154 input_basename
= NULL
;
11155 input_suffix
= NULL
;
11156 /* We don't need to purge "input_stat", just to unset "input_stat_set". */
11157 input_stat_set
= 0;
11158 input_file_compiler
= NULL
;
11160 delete_this_arg
= 0;
11161 this_is_output_file
= 0;
11162 this_is_library_file
= 0;
11163 this_is_linker_script
= 0;
11164 input_from_pipe
= 0;
11165 suffix_subst
= NULL
;
11170 used_arg
.finalize ();
11174 Targets can provide configure-time default options in
11175 OPTION_DEFAULT_SPECS. The jit needs to access these, but
11176 they are expressed in the spec language.
11178 Run just enough of the driver to be able to expand these
11179 specs, and then call the callback CB on each
11180 such option. The options strings are *without* a leading
11181 '-' character e.g. ("march=x86-64"). Finally, clean up. */
11184 driver_get_configure_time_options (void (*cb
) (const char *option
,
11190 obstack_init (&obstack
);
11191 init_opts_obstack ();
11194 for (i
= 0; i
< ARRAY_SIZE (option_default_specs
); i
++)
11195 do_option_spec (option_default_specs
[i
].name
,
11196 option_default_specs
[i
].spec
);
11198 for (i
= 0; (int) i
< n_switches
; i
++)
11200 gcc_assert (switches
[i
].part1
);
11201 (*cb
) (switches
[i
].part1
, user_data
);
11204 obstack_free (&opts_obstack
, NULL
);
11205 obstack_free (&obstack
, NULL
);