1 /* Compiler driver program that can handle many languages.
2 Copyright (C) 1987-2023 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"
49 #include "gcc-urlifier.h"
52 #define MATH_LIBRARY "m"
56 /* Manage the manipulation of env vars.
58 We poison "getenv" and "putenv", so that all enviroment-handling is
59 done through this class. Note that poisoning happens in the
60 preprocessor at the identifier level, and doesn't distinguish between
64 Hence we need to use "get" for the accessor method, not "getenv". */
69 void init (bool can_restore
, bool debug
);
70 const char *get (const char *name
);
71 void xput (const char *string
);
86 /* The singleton instance of class env_manager. */
88 static env_manager env
;
90 /* Initializer for class env_manager.
92 We can't do this as a constructor since we have a statically
93 allocated instance ("env" above). */
96 env_manager::init (bool can_restore
, bool debug
)
98 m_can_restore
= can_restore
;
102 /* Get the value of NAME within the environment. Essentially
103 a wrapper for ::getenv, but adding logging, and the possibility
104 of caching results. */
107 env_manager::get (const char *name
)
109 const char *result
= ::getenv (name
);
111 fprintf (stderr
, "env_manager::getenv (%s) -> %s\n", name
, result
);
115 /* Put the given KEY=VALUE entry STRING into the environment.
116 If the env_manager was initialized with CAN_RESTORE set, then
117 also record the old value of KEY within the environment, so that it
118 can be later restored. */
121 env_manager::xput (const char *string
)
124 fprintf (stderr
, "env_manager::xput (%s)\n", string
);
126 fnotice (stderr
, "%s\n", string
);
130 char *equals
= strchr (const_cast <char *> (string
), '=');
134 kv
.m_key
= xstrndup (string
, equals
- string
);
135 const char *cur_value
= ::getenv (kv
.m_key
);
137 fprintf (stderr
, "saving old value: %s\n",cur_value
);
138 kv
.m_value
= cur_value
? xstrdup (cur_value
) : NULL
;
139 m_keys
.safe_push (kv
);
142 ::putenv (CONST_CAST (char *, string
));
145 /* Undo any xputenv changes made since last restore.
146 Can only be called if the env_manager was initialized with
147 CAN_RESTORE enabled. */
150 env_manager::restore ()
155 gcc_assert (m_can_restore
);
157 FOR_EACH_VEC_ELT_REVERSE (m_keys
, i
, item
)
160 printf ("restoring saved key: %s value: %s\n", item
->m_key
, item
->m_value
);
162 ::setenv (item
->m_key
, item
->m_value
, 1);
164 ::unsetenv (item
->m_key
);
166 free (item
->m_value
);
172 /* Forbid other uses of getenv and putenv. */
173 #if (GCC_VERSION >= 3000)
174 #pragma GCC poison getenv putenv
179 /* By default there is no special suffix for target executables. */
180 #ifdef TARGET_EXECUTABLE_SUFFIX
181 #define HAVE_TARGET_EXECUTABLE_SUFFIX
183 #define TARGET_EXECUTABLE_SUFFIX ""
186 /* By default there is no special suffix for host executables. */
187 #ifdef HOST_EXECUTABLE_SUFFIX
188 #define HAVE_HOST_EXECUTABLE_SUFFIX
190 #define HOST_EXECUTABLE_SUFFIX ""
193 /* By default, the suffix for target object files is ".o". */
194 #ifdef TARGET_OBJECT_SUFFIX
195 #define HAVE_TARGET_OBJECT_SUFFIX
197 #define TARGET_OBJECT_SUFFIX ".o"
200 static const char dir_separator_str
[] = { DIR_SEPARATOR
, 0 };
202 /* Most every one is fine with LIBRARY_PATH. For some, it conflicts. */
203 #ifndef LIBRARY_PATH_ENV
204 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
207 /* If a stage of compilation returns an exit status >= 1,
208 compilation of that file ceases. */
210 #define MIN_FATAL_STATUS 1
212 /* Flag set by cppspec.cc to 1. */
215 /* Flag set to nonzero if an @file argument has been supplied to gcc. */
216 static bool at_file_supplied
;
218 /* Definition of string containing the arguments given to configure. */
219 #include "configargs.h"
221 /* Flag saying to print the command line options understood by gcc and its
224 static int print_help_list
;
226 /* Flag saying to print the version of gcc and its sub-processes. */
228 static int print_version
;
230 /* Flag that stores string prefix for which we provide bash completion. */
232 static const char *completion
= NULL
;
234 /* Flag indicating whether we should ONLY print the command and
235 arguments (like verbose_flag) without executing the command.
236 Displayed arguments are quoted so that the generated command
237 line is suitable for execution. This is intended for use in
238 shell scripts to capture the driver-generated command line. */
239 static int verbose_only_flag
;
241 /* Flag indicating how to print command line options of sub-processes. */
243 static int print_subprocess_help
;
245 /* Linker suffix passed to -fuse-ld=... */
246 static const char *use_ld
;
248 /* Whether we should report subprocess execution times to a file. */
250 FILE *report_times_to_file
= NULL
;
252 /* Nonzero means place this string before uses of /, so that include
253 and library files can be found in an alternate location. */
255 #ifdef TARGET_SYSTEM_ROOT
256 #define DEFAULT_TARGET_SYSTEM_ROOT (TARGET_SYSTEM_ROOT)
258 #define DEFAULT_TARGET_SYSTEM_ROOT (0)
260 static const char *target_system_root
= DEFAULT_TARGET_SYSTEM_ROOT
;
262 /* Nonzero means pass the updated target_system_root to the compiler. */
264 static int target_system_root_changed
;
266 /* Nonzero means append this string to target_system_root. */
268 static const char *target_sysroot_suffix
= 0;
270 /* Nonzero means append this string to target_system_root for headers. */
272 static const char *target_sysroot_hdrs_suffix
= 0;
274 /* Nonzero means write "temp" files in source directory
275 and use the source file's name in them, and don't delete them. */
277 static enum save_temps
{
278 SAVE_TEMPS_NONE
, /* no -save-temps */
279 SAVE_TEMPS_CWD
, /* -save-temps in current directory */
280 SAVE_TEMPS_DUMP
, /* -save-temps in dumpdir */
281 SAVE_TEMPS_OBJ
/* -save-temps in object directory */
284 /* Set this iff the dumppfx implied by a -save-temps=* option is to
285 override a -dumpdir option, if any. */
286 static bool save_temps_overrides_dumpdir
= false;
288 /* -dumpdir, -dumpbase and -dumpbase-ext flags passed in, possibly
289 rearranged as they are to be passed down, e.g., dumpbase and
290 dumpbase_ext may be cleared if integrated with dumpdir or
292 static char *dumpdir
, *dumpbase
, *dumpbase_ext
;
294 /* Usually the length of the string in dumpdir. However, during
295 linking, it may be shortened to omit a driver-added trailing dash,
296 by then replaced with a trailing period, that is still to be passed
297 to sub-processes in -dumpdir, but not to be generally used in spec
298 filename expansions. See maybe_run_linker. */
299 static size_t dumpdir_length
= 0;
301 /* Set if the last character in dumpdir is (or was) a dash that the
302 driver added to dumpdir after dumpbase or linker output name. */
303 static bool dumpdir_trailing_dash_added
= false;
305 /* True if -r, -shared, -pie, or -no-pie were specified on the command
307 static bool any_link_options_p
;
309 /* True if -static was specified on the command line. */
310 static bool static_p
;
312 /* Basename of dump and aux outputs, computed from dumpbase (given or
313 derived from output name), to override input_basename in non-%w %b
315 static char *outbase
;
316 static size_t outbase_length
= 0;
318 /* The compiler version. */
320 static const char *compiler_version
;
322 /* The target version. */
324 static const char *const spec_version
= DEFAULT_TARGET_VERSION
;
326 /* The target machine. */
328 static const char *spec_machine
= DEFAULT_TARGET_MACHINE
;
329 static const char *spec_host_machine
= DEFAULT_REAL_TARGET_MACHINE
;
331 /* List of offload targets. Separated by colon. Empty string for
332 -foffload=disable. */
334 static char *offload_targets
= NULL
;
336 #if OFFLOAD_DEFAULTED
337 /* Set to true if -foffload has not been used and offload_targets
338 is set to the configured in default. */
339 static bool offload_targets_default
;
342 /* Nonzero if cross-compiling.
343 When -b is used, the value comes from the `specs' file. */
345 #ifdef CROSS_DIRECTORY_STRUCTURE
346 static const char *cross_compile
= "1";
348 static const char *cross_compile
= "0";
351 /* Greatest exit code of sub-processes that has been encountered up to
353 static int greatest_status
= 1;
355 /* This is the obstack which we use to allocate many strings. */
357 static struct obstack obstack
;
359 /* This is the obstack to build an environment variable to pass to
360 collect2 that describes all of the relevant switches of what to
361 pass the compiler in building the list of pointers to constructors
364 static struct obstack collect_obstack
;
366 /* Forward declaration for prototypes. */
370 static void init_spec (void);
371 static void store_arg (const char *, int, int);
372 static void insert_wrapper (const char *);
373 static char *load_specs (const char *);
374 static void read_specs (const char *, bool, bool);
375 static void set_spec (const char *, const char *, bool);
376 static struct compiler
*lookup_compiler (const char *, size_t, const char *);
377 static char *build_search_list (const struct path_prefix
*, const char *,
379 static void xputenv (const char *);
380 static void putenv_from_prefixes (const struct path_prefix
*, const char *,
382 static int access_check (const char *, int);
383 static char *find_a_file (const struct path_prefix
*, const char *, int, bool);
384 static char *find_a_program (const char *);
385 static void add_prefix (struct path_prefix
*, const char *, const char *,
387 static void add_sysrooted_prefix (struct path_prefix
*, const char *,
388 const char *, int, int, int);
389 static char *skip_whitespace (char *);
390 static void delete_if_ordinary (const char *);
391 static void delete_temp_files (void);
392 static void delete_failure_queue (void);
393 static void clear_failure_queue (void);
394 static int check_live_switch (int, int);
395 static const char *handle_braces (const char *);
396 static inline bool input_suffix_matches (const char *, const char *);
397 static inline bool switch_matches (const char *, const char *, int);
398 static inline void mark_matching_switches (const char *, const char *, int);
399 static inline void process_marked_switches (void);
400 static const char *process_brace_body (const char *, const char *, const char *, int, int);
401 static const struct spec_function
*lookup_spec_function (const char *);
402 static const char *eval_spec_function (const char *, const char *, const char *);
403 static const char *handle_spec_function (const char *, bool *, const char *);
404 static char *save_string (const char *, int);
405 static void set_collect_gcc_options (void);
406 static int do_spec_1 (const char *, int, const char *);
407 static int do_spec_2 (const char *, const char *);
408 static void do_option_spec (const char *, const char *);
409 static void do_self_spec (const char *);
410 static const char *find_file (const char *);
411 static int is_directory (const char *, bool);
412 static const char *validate_switches (const char *, bool, bool);
413 static void validate_all_switches (void);
414 static inline void validate_switches_from_spec (const char *, bool);
415 static void give_switch (int, int);
416 static int default_arg (const char *, int);
417 static void set_multilib_dir (void);
418 static void print_multilib_info (void);
419 static void display_help (void);
420 static void add_preprocessor_option (const char *, int);
421 static void add_assembler_option (const char *, int);
422 static void add_linker_option (const char *, int);
423 static void process_command (unsigned int, struct cl_decoded_option
*);
424 static int execute (void);
425 static void alloc_args (void);
426 static void clear_args (void);
427 static void fatal_signal (int);
428 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
429 static void init_gcc_specs (struct obstack
*, const char *, const char *,
432 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
433 static const char *convert_filename (const char *, int, int);
436 static void try_generate_repro (const char **argv
);
437 static const char *getenv_spec_function (int, const char **);
438 static const char *if_exists_spec_function (int, const char **);
439 static const char *if_exists_else_spec_function (int, const char **);
440 static const char *if_exists_then_else_spec_function (int, const char **);
441 static const char *sanitize_spec_function (int, const char **);
442 static const char *replace_outfile_spec_function (int, const char **);
443 static const char *remove_outfile_spec_function (int, const char **);
444 static const char *version_compare_spec_function (int, const char **);
445 static const char *include_spec_function (int, const char **);
446 static const char *find_file_spec_function (int, const char **);
447 static const char *find_plugindir_spec_function (int, const char **);
448 static const char *print_asm_header_spec_function (int, const char **);
449 static const char *compare_debug_dump_opt_spec_function (int, const char **);
450 static const char *compare_debug_self_opt_spec_function (int, const char **);
451 static const char *pass_through_libs_spec_func (int, const char **);
452 static const char *dumps_spec_func (int, const char **);
453 static const char *greater_than_spec_func (int, const char **);
454 static const char *debug_level_greater_than_spec_func (int, const char **);
455 static const char *dwarf_version_greater_than_spec_func (int, const char **);
456 static const char *find_fortran_preinclude_file (int, const char **);
457 static const char *join_spec_func (int, const char **);
458 static char *convert_white_space (char *);
459 static char *quote_spec (char *);
460 static char *quote_spec_arg (char *);
461 static bool not_actual_file_p (const char *);
464 /* The Specs Language
466 Specs are strings containing lines, each of which (if not blank)
467 is made up of a program name, and arguments separated by spaces.
468 The program name must be exact and start from root, since no path
469 is searched and it is unreliable to depend on the current working directory.
470 Redirection of input or output is not supported; the subprograms must
471 accept filenames saying what files to read and write.
473 In addition, the specs can contain %-sequences to substitute variable text
474 or for conditional text. Here is a table of all defined %-sequences.
475 Note that spaces are not generated automatically around the results of
476 expanding these sequences; therefore, you can concatenate them together
477 or with constant text in a single argument.
479 %% substitute one % into the program name or argument.
480 %" substitute an empty argument.
481 %i substitute the name of the input file being processed.
482 %b substitute the basename for outputs related with the input file
483 being processed. This is often a substring of the input file name,
484 up to (and not including) the last period but, unless %w is active,
485 it is affected by the directory selected by -save-temps=*, by
486 -dumpdir, and, in case of multiple compilations, even by -dumpbase
487 and -dumpbase-ext and, in case of linking, by the linker output
488 name. When %w is active, it derives the main output name only from
489 the input file base name; when it is not, it names aux/dump output
491 %B same as %b, but include the input file suffix (text after the last
494 substitute a file name that has suffix SUFFIX and is chosen
495 once per compilation, and mark the argument a la %d. To reduce
496 exposure to denial-of-service attacks, the file name is now
497 chosen in a way that is hard to predict even when previously
498 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
499 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
500 the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
501 had been pre-processed. Previously, %g was simply substituted
502 with a file name chosen once per compilation, without regard
503 to any appended suffix (which was therefore treated just like
504 ordinary text), making such attacks more likely to succeed.
506 like %g, but if -pipe is in effect, expands simply to "-".
508 like %g, but if -pipe is in effect, expands to nothing. (We have both
509 %| and %m to accommodate differences between system assemblers; see
510 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
512 like %g, but generates a new temporary file name even if %uSUFFIX
515 substitutes the last file name generated with %uSUFFIX, generating a
516 new one if there is no such last file name. In the absence of any
517 %uSUFFIX, this is just like %gSUFFIX, except they don't share
518 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
519 would involve the generation of two distinct file names, one
520 for each `%g.s' and another for each `%U.s'. Previously, %U was
521 simply substituted with a file name chosen for the previous %u,
522 without regard to any appended suffix.
524 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
525 writable, and if save-temps is off; otherwise, substitute the name
526 of a temporary file, just like %u. This temporary file is not
527 meant for communication between processes, but rather as a junk
530 substitutes .SUFFIX for the suffixes of a matched switch's args when
531 it is subsequently output with %*. SUFFIX is terminated by the next
533 %d marks the argument containing or following the %d as a
534 temporary file name, so that file will be deleted if GCC exits
535 successfully. Unlike %g, this contributes no text to the argument.
536 %w marks the argument containing or following the %w as the
537 "output file" of this compilation. This puts the argument
538 into the sequence of arguments that %o will substitute later.
539 %V indicates that this compilation produces no "output file".
541 like %{...} but marks the last argument supplied within as a file
542 to be deleted on failure.
544 like %{...} but puts the result into a FILE and substitutes @FILE
545 if an @file argument has been supplied.
546 %o substitutes the names of all the output files, with spaces
547 automatically placed around them. You should write spaces
548 around the %o as well or the results are undefined.
549 %o is for use in the specs for running the linker.
550 Input files whose names have no recognized suffix are not compiled
551 at all, but they are included among the output files, so they will
553 %O substitutes the suffix for object files. Note that this is
554 handled specially when it immediately follows %g, %u, or %U
555 (with or without a suffix argument) because of the need for
556 those to form complete file names. The handling is such that
557 %O is treated exactly as if it had already been substituted,
558 except that %g, %u, and %U do not currently support additional
559 SUFFIX characters following %O as they would following, for
561 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
562 (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
563 and -B options) and -imultilib as necessary.
564 %s current argument is the name of a library or startup file of some sort.
565 Search for that file in a standard list of directories
566 and substitute the full name found.
567 %T current argument is the name of a linker script.
568 Search for that file in the current list of directories to scan for
569 libraries. If the file is located, insert a --script option into the
570 command line followed by the full path name found. If the file is
571 not found then generate an error message.
572 Note: the current working directory is not searched.
573 %eSTR Print STR as an error message. STR is terminated by a newline.
574 Use this when inconsistent options are detected.
575 %nSTR Print STR as a notice. STR is terminated by a newline.
576 %x{OPTION} Accumulate an option for %X.
577 %X Output the accumulated linker options specified by compilations.
578 %Y Output the accumulated assembler options specified by compilations.
579 %Z Output the accumulated preprocessor options specified by compilations.
580 %a process ASM_SPEC as a spec.
581 This allows config.h to specify part of the spec for running as.
582 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
583 used here. This can be used to run a post-processor after the
584 assembler has done its job.
585 %D Dump out a -L option for each directory in startfile_prefixes.
586 If multilib_dir is set, extra entries are generated with it affixed.
587 %l process LINK_SPEC as a spec.
588 %L process LIB_SPEC as a spec.
589 %M Output multilib_os_dir.
590 %P Output a RUNPATH_OPTION for each directory in startfile_prefixes.
591 %G process LIBGCC_SPEC as a spec.
592 %R Output the concatenation of target_system_root and
593 target_sysroot_suffix.
594 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
595 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
596 %C process CPP_SPEC as a spec.
597 %1 process CC1_SPEC as a spec.
598 %2 process CC1PLUS_SPEC as a spec.
599 %* substitute the variable part of a matched option. (See below.)
600 Note that each comma in the substituted string is replaced by
601 a single space. A space is appended after the last substition
602 unless there is more text in current sequence.
603 %<S remove all occurrences of -S from the command line.
604 Note - this command is position dependent. % commands in the
605 spec string before this one will see -S, % commands in the
606 spec string after this one will not.
607 %>S Similar to "%<S", but keep it in the GCC command line.
608 %<S* remove all occurrences of all switches beginning with -S from the
611 Call the named function FUNCTION, passing it ARGS. ARGS is
612 first processed as a nested spec string, then split into an
613 argument vector in the usual fashion. The function returns
614 a string which is processed as if it had appeared literally
615 as part of the current spec.
616 %{S} substitutes the -S switch, if that switch was given to GCC.
617 If that switch was not specified, this substitutes nothing.
618 Here S is a metasyntactic variable.
619 %{S*} substitutes all the switches specified to GCC whose names start
620 with -S. This is used for -o, -I, etc; switches that take
621 arguments. GCC considers `-o foo' as being one switch whose
622 name starts with `o'. %{o*} would substitute this text,
623 including the space; thus, two arguments would be generated.
624 %{S*&T*} likewise, but preserve order of S and T options (the order
625 of S and T in the spec is not significant). Can be any number
626 of ampersand-separated variables; for each the wild card is
627 optional. Useful for CPP as %{D*&U*&A*}.
629 %{S:X} substitutes X, if the -S switch was given to GCC.
630 %{!S:X} substitutes X, if the -S switch was NOT given to GCC.
631 %{S*:X} substitutes X if one or more switches whose names start
632 with -S was given to GCC. Normally X is substituted only
633 once, no matter how many such switches appeared. However,
634 if %* appears somewhere in X, then X will be substituted
635 once for each matching switch, with the %* replaced by the
636 part of that switch that matched the '*'. A space will be
637 appended after the last substition unless there is more
638 text in current sequence.
639 %{.S:X} substitutes X, if processing a file with suffix S.
640 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
641 %{,S:X} substitutes X, if processing a file which will use spec S.
642 %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
644 %{S|T:X} substitutes X if either -S or -T was given to GCC. This may be
645 combined with '!', '.', ',', and '*' as above binding stronger
647 If %* appears in X, all of the alternatives must be starred, and
648 only the first matching alternative is substituted.
649 %{%:function(args):X}
650 Call function named FUNCTION with args ARGS. If the function
651 returns non-NULL, then X is substituted, if it returns
652 NULL, it isn't substituted.
653 %{S:X; if S was given to GCC, substitutes X;
654 T:Y; else if T was given to GCC, substitutes Y;
655 :D} else substitutes D. There can be as many clauses as you need.
656 This may be combined with '.', '!', ',', '|', and '*' as above.
658 %(Spec) processes a specification defined in a specs file as *Spec:
660 The switch matching text S in a %{S}, %{S:X}, or similar construct can use
661 a backslash to ignore the special meaning of the character following it,
662 thus allowing literal matching of a character that is otherwise specially
663 treated. For example, %{std=iso9899\:1999:X} substitutes X if the
664 -std=iso9899:1999 option is given.
666 The conditional text X in a %{S:X} or similar construct may contain
667 other nested % constructs or spaces, or even newlines. They are
668 processed as usual, as described above. Trailing white space in X is
669 ignored. White space may also appear anywhere on the left side of the
670 colon in these constructs, except between . or * and the corresponding
673 The -O, -f, -g, -m, and -W switches are handled specifically in these
674 constructs. If another value of -O or the negated form of a -f, -m, or
675 -W switch is found later in the command line, the earlier switch
676 value is ignored, except with {S*} where S is just one letter; this
677 passes all matching options.
679 The character | at the beginning of the predicate text is used to indicate
680 that a command should be piped to the following command, but only if -pipe
683 Note that it is built into GCC which switches take arguments and which
684 do not. You might think it would be useful to generalize this to
685 allow each compiler's spec to say which switches take arguments. But
686 this cannot be done in a consistent fashion. GCC cannot even decide
687 which input files have been specified without knowing which switches
688 take arguments, and it must know which input files to compile in order
689 to tell which compilers to run.
691 GCC also knows implicitly that arguments starting in `-l' are to be
692 treated as compiler output files, and passed to the linker in their
693 proper position among the other output files. */
695 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
697 /* config.h can define ASM_SPEC to provide extra args to the assembler
698 or extra switch-translations. */
703 /* config.h can define ASM_FINAL_SPEC to run a post processor after
704 the assembler has run. */
705 #ifndef ASM_FINAL_SPEC
706 #define ASM_FINAL_SPEC \
708 objcopy --extract-dwo \
709 %{c:%{o*:%*}%{!o*:%w%b%O}}%{!c:%U%O} \
711 objcopy --strip-dwo \
712 %{c:%{o*:%*}%{!o*:%w%b%O}}%{!c:%U%O} \
716 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
717 or extra switch-translations. */
722 /* Operating systems can define OS_CC1_SPEC to provide extra args to cc1 and
723 cc1plus or extra switch-translations. The OS_CC1_SPEC is appended
724 to CC1_SPEC in the initialization of cc1_spec. */
726 #define OS_CC1_SPEC ""
729 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
730 or extra switch-translations. */
735 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
736 or extra switch-translations. */
738 #define CC1PLUS_SPEC ""
741 /* config.h can define LINK_SPEC to provide extra args to the linker
742 or extra switch-translations. */
747 /* config.h can define LIB_SPEC to override the default libraries. */
749 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
752 /* When using -fsplit-stack we need to wrap pthread_create, in order
753 to initialize the stack guard. We always use wrapping, rather than
754 shared library ordering, and we keep the wrapper function in
755 libgcc. This is not yet a real spec, though it could become one;
756 it is currently just stuffed into LINK_SPEC. FIXME: This wrapping
757 only works with GNU ld and gold. */
758 #ifdef HAVE_GOLD_NON_DEFAULT_SPLIT_STACK
759 #define STACK_SPLIT_SPEC " %{fsplit-stack: -fuse-ld=gold --wrap=pthread_create}"
761 #define STACK_SPLIT_SPEC " %{fsplit-stack: --wrap=pthread_create}"
765 #define STATIC_LIBASAN_LIBS \
766 " %{static-libasan|static:%:include(libsanitizer.spec)%(link_libasan)}"
767 #ifdef LIBASAN_EARLY_SPEC
768 #define LIBASAN_SPEC STATIC_LIBASAN_LIBS
769 #elif defined(HAVE_LD_STATIC_DYNAMIC)
770 #define LIBASAN_SPEC "%{static-libasan:" LD_STATIC_OPTION \
771 "} -lasan %{static-libasan:" LD_DYNAMIC_OPTION "}" \
774 #define LIBASAN_SPEC "-lasan" STATIC_LIBASAN_LIBS
778 #ifndef LIBASAN_EARLY_SPEC
779 #define LIBASAN_EARLY_SPEC ""
782 #ifndef LIBHWASAN_SPEC
783 #define STATIC_LIBHWASAN_LIBS \
784 " %{static-libhwasan|static:%:include(libsanitizer.spec)%(link_libhwasan)}"
785 #ifdef LIBHWASAN_EARLY_SPEC
786 #define LIBHWASAN_SPEC STATIC_LIBHWASAN_LIBS
787 #elif defined(HAVE_LD_STATIC_DYNAMIC)
788 #define LIBHWASAN_SPEC "%{static-libhwasan:" LD_STATIC_OPTION \
789 "} -lhwasan %{static-libhwasan:" LD_DYNAMIC_OPTION "}" \
790 STATIC_LIBHWASAN_LIBS
792 #define LIBHWASAN_SPEC "-lhwasan" STATIC_LIBHWASAN_LIBS
796 #ifndef LIBHWASAN_EARLY_SPEC
797 #define LIBHWASAN_EARLY_SPEC ""
801 #define STATIC_LIBTSAN_LIBS \
802 " %{static-libtsan|static:%:include(libsanitizer.spec)%(link_libtsan)}"
803 #ifdef LIBTSAN_EARLY_SPEC
804 #define LIBTSAN_SPEC STATIC_LIBTSAN_LIBS
805 #elif defined(HAVE_LD_STATIC_DYNAMIC)
806 #define LIBTSAN_SPEC "%{static-libtsan:" LD_STATIC_OPTION \
807 "} -ltsan %{static-libtsan:" LD_DYNAMIC_OPTION "}" \
810 #define LIBTSAN_SPEC "-ltsan" STATIC_LIBTSAN_LIBS
814 #ifndef LIBTSAN_EARLY_SPEC
815 #define LIBTSAN_EARLY_SPEC ""
819 #define STATIC_LIBLSAN_LIBS \
820 " %{static-liblsan|static:%:include(libsanitizer.spec)%(link_liblsan)}"
821 #ifdef LIBLSAN_EARLY_SPEC
822 #define LIBLSAN_SPEC STATIC_LIBLSAN_LIBS
823 #elif defined(HAVE_LD_STATIC_DYNAMIC)
824 #define LIBLSAN_SPEC "%{static-liblsan:" LD_STATIC_OPTION \
825 "} -llsan %{static-liblsan:" LD_DYNAMIC_OPTION "}" \
828 #define LIBLSAN_SPEC "-llsan" STATIC_LIBLSAN_LIBS
832 #ifndef LIBLSAN_EARLY_SPEC
833 #define LIBLSAN_EARLY_SPEC ""
836 #ifndef LIBUBSAN_SPEC
837 #define STATIC_LIBUBSAN_LIBS \
838 " %{static-libubsan|static:%:include(libsanitizer.spec)%(link_libubsan)}"
839 #ifdef HAVE_LD_STATIC_DYNAMIC
840 #define LIBUBSAN_SPEC "%{static-libubsan:" LD_STATIC_OPTION \
841 "} -lubsan %{static-libubsan:" LD_DYNAMIC_OPTION "}" \
844 #define LIBUBSAN_SPEC "-lubsan" STATIC_LIBUBSAN_LIBS
848 /* Linker options for compressed debug sections. */
849 #if HAVE_LD_COMPRESS_DEBUG == 0
850 /* No linker support. */
851 #define LINK_COMPRESS_DEBUG_SPEC \
852 " %{gz*:%e-gz is not supported in this configuration} "
853 #elif HAVE_LD_COMPRESS_DEBUG == 1
854 /* ELF gABI style. */
855 #define LINK_COMPRESS_DEBUG_SPEC \
856 " %{gz|gz=zlib:" LD_COMPRESS_DEBUG_OPTION "=zlib}" \
857 " %{gz=none:" LD_COMPRESS_DEBUG_OPTION "=none}" \
858 " %{gz=zstd:%e-gz=zstd is not supported in this configuration} " \
859 " %{gz=zlib-gnu:}" /* Ignore silently zlib-gnu option value. */
860 #elif HAVE_LD_COMPRESS_DEBUG == 2
861 /* ELF gABI style and ZSTD. */
862 #define LINK_COMPRESS_DEBUG_SPEC \
863 " %{gz|gz=zlib:" LD_COMPRESS_DEBUG_OPTION "=zlib}" \
864 " %{gz=none:" LD_COMPRESS_DEBUG_OPTION "=none}" \
865 " %{gz=zstd:" LD_COMPRESS_DEBUG_OPTION "=zstd}" \
866 " %{gz=zlib-gnu:}" /* Ignore silently zlib-gnu option value. */
868 #error Unknown value for HAVE_LD_COMPRESS_DEBUG.
871 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
874 #if defined(REAL_LIBGCC_SPEC)
875 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
876 #elif defined(LINK_LIBGCC_SPECIAL_1)
877 /* Have gcc do the search for libgcc.a. */
878 #define LIBGCC_SPEC "libgcc.a%s"
880 #define LIBGCC_SPEC "-lgcc"
884 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
885 #ifndef STARTFILE_SPEC
886 #define STARTFILE_SPEC \
887 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
890 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
892 #define ENDFILE_SPEC ""
896 #define LINKER_NAME "collect2"
899 #ifdef HAVE_AS_DEBUG_PREFIX_MAP
900 #define ASM_MAP " %{ffile-prefix-map=*:--debug-prefix-map %*} %{fdebug-prefix-map=*:--debug-prefix-map %*}"
905 /* Assembler options for compressed debug sections. */
906 #if HAVE_LD_COMPRESS_DEBUG == 0
907 /* Reject if the linker cannot write compressed debug sections. */
908 #define ASM_COMPRESS_DEBUG_SPEC \
909 " %{gz*:%e-gz is not supported in this configuration} "
910 #else /* HAVE_LD_COMPRESS_DEBUG >= 1 */
911 #if HAVE_AS_COMPRESS_DEBUG == 0
912 /* No assembler support. Ignore silently. */
913 #define ASM_COMPRESS_DEBUG_SPEC \
915 #elif HAVE_AS_COMPRESS_DEBUG == 1
916 /* ELF gABI style. */
917 #define ASM_COMPRESS_DEBUG_SPEC \
918 " %{gz|gz=zlib:" AS_COMPRESS_DEBUG_OPTION "=zlib}" \
919 " %{gz=none:" AS_COMPRESS_DEBUG_OPTION "=none}" \
920 " %{gz=zlib-gnu:}" /* Ignore silently zlib-gnu option value. */
921 #elif HAVE_AS_COMPRESS_DEBUG == 2
922 /* ELF gABI style and ZSTD. */
923 #define ASM_COMPRESS_DEBUG_SPEC \
924 " %{gz|gz=zlib:" AS_COMPRESS_DEBUG_OPTION "=zlib}" \
925 " %{gz=none:" AS_COMPRESS_DEBUG_OPTION "=none}" \
926 " %{gz=zstd:" AS_COMPRESS_DEBUG_OPTION "=zstd}" \
927 " %{gz=zlib-gnu:}" /* Ignore silently zlib-gnu option value. */
929 #error Unknown value for HAVE_AS_COMPRESS_DEBUG.
931 #endif /* HAVE_LD_COMPRESS_DEBUG >= 1 */
933 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
934 to the assembler, when compiling assembly sources only. */
935 #ifndef ASM_DEBUG_SPEC
936 # if defined(HAVE_AS_GDWARF_5_DEBUG_FLAG) && defined(HAVE_AS_WORKING_DWARF_N_FLAG)
937 /* If --gdwarf-N is supported and as can handle even compiler generated
938 .debug_line with it, supply --gdwarf-N in ASM_DEBUG_OPTION_SPEC rather
939 than in ASM_DEBUG_SPEC, so that it applies to both .s and .c etc.
941 # define ASM_DEBUG_DWARF_OPTION ""
942 # elif defined(HAVE_AS_GDWARF_5_DEBUG_FLAG) && !defined(HAVE_LD_BROKEN_PE_DWARF5)
943 # define ASM_DEBUG_DWARF_OPTION "%{%:dwarf-version-gt(4):--gdwarf-5;" \
944 "%:dwarf-version-gt(3):--gdwarf-4;" \
945 "%:dwarf-version-gt(2):--gdwarf-3;" \
948 # define ASM_DEBUG_DWARF_OPTION "--gdwarf2"
950 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
951 # define ASM_DEBUG_SPEC "%{g*:%{%:debug-level-gt(0):" \
952 ASM_DEBUG_DWARF_OPTION "}}" ASM_MAP
955 #ifndef ASM_DEBUG_SPEC
956 # define ASM_DEBUG_SPEC ""
959 /* Define ASM_DEBUG_OPTION_SPEC to be a spec suitable for translating '-g'
960 to the assembler when compiling all sources. */
961 #ifndef ASM_DEBUG_OPTION_SPEC
962 # if defined(HAVE_AS_GDWARF_5_DEBUG_FLAG) && defined(HAVE_AS_WORKING_DWARF_N_FLAG)
963 # define ASM_DEBUG_OPTION_DWARF_OPT \
964 "%{%:dwarf-version-gt(4):--gdwarf-5 ;" \
965 "%:dwarf-version-gt(3):--gdwarf-4 ;" \
966 "%:dwarf-version-gt(2):--gdwarf-3 ;" \
968 # if defined(DWARF2_DEBUGGING_INFO)
969 # define ASM_DEBUG_OPTION_SPEC "%{g*:%{%:debug-level-gt(0):" \
970 ASM_DEBUG_OPTION_DWARF_OPT "}}"
974 #ifndef ASM_DEBUG_OPTION_SPEC
975 # define ASM_DEBUG_OPTION_SPEC ""
978 /* Here is the spec for running the linker, after compiling all files. */
980 /* This is overridable by the target in case they need to specify the
981 -lgcc and -lc order specially, yet not require them to override all
982 of LINK_COMMAND_SPEC. */
983 #ifndef LINK_GCC_C_SEQUENCE_SPEC
984 #define LINK_GCC_C_SEQUENCE_SPEC "%G %{!nolibc:%L %G}"
987 #ifndef LINK_SSP_SPEC
988 #ifdef TARGET_LIBC_PROVIDES_SSP
989 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all" \
990 "|fstack-protector-strong|fstack-protector-explicit:}"
992 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all" \
993 "|fstack-protector-strong|fstack-protector-explicit" \
994 ":-lssp_nonshared -lssp}"
998 #ifdef ENABLE_DEFAULT_PIE
999 #define PIE_SPEC "!no-pie"
1000 #define NO_FPIE1_SPEC "fno-pie"
1001 #define FPIE1_SPEC NO_FPIE1_SPEC ":;"
1002 #define NO_FPIE2_SPEC "fno-PIE"
1003 #define FPIE2_SPEC NO_FPIE2_SPEC ":;"
1004 #define NO_FPIE_SPEC NO_FPIE1_SPEC "|" NO_FPIE2_SPEC
1005 #define FPIE_SPEC NO_FPIE_SPEC ":;"
1006 #define NO_FPIC1_SPEC "fno-pic"
1007 #define FPIC1_SPEC NO_FPIC1_SPEC ":;"
1008 #define NO_FPIC2_SPEC "fno-PIC"
1009 #define FPIC2_SPEC NO_FPIC2_SPEC ":;"
1010 #define NO_FPIC_SPEC NO_FPIC1_SPEC "|" NO_FPIC2_SPEC
1011 #define FPIC_SPEC NO_FPIC_SPEC ":;"
1012 #define NO_FPIE1_AND_FPIC1_SPEC NO_FPIE1_SPEC "|" NO_FPIC1_SPEC
1013 #define FPIE1_OR_FPIC1_SPEC NO_FPIE1_AND_FPIC1_SPEC ":;"
1014 #define NO_FPIE2_AND_FPIC2_SPEC NO_FPIE2_SPEC "|" NO_FPIC2_SPEC
1015 #define FPIE2_OR_FPIC2_SPEC NO_FPIE2_AND_FPIC2_SPEC ":;"
1016 #define NO_FPIE_AND_FPIC_SPEC NO_FPIE_SPEC "|" NO_FPIC_SPEC
1017 #define FPIE_OR_FPIC_SPEC NO_FPIE_AND_FPIC_SPEC ":;"
1019 #define PIE_SPEC "pie"
1020 #define FPIE1_SPEC "fpie"
1021 #define NO_FPIE1_SPEC FPIE1_SPEC ":;"
1022 #define FPIE2_SPEC "fPIE"
1023 #define NO_FPIE2_SPEC FPIE2_SPEC ":;"
1024 #define FPIE_SPEC FPIE1_SPEC "|" FPIE2_SPEC
1025 #define NO_FPIE_SPEC FPIE_SPEC ":;"
1026 #define FPIC1_SPEC "fpic"
1027 #define NO_FPIC1_SPEC FPIC1_SPEC ":;"
1028 #define FPIC2_SPEC "fPIC"
1029 #define NO_FPIC2_SPEC FPIC2_SPEC ":;"
1030 #define FPIC_SPEC FPIC1_SPEC "|" FPIC2_SPEC
1031 #define NO_FPIC_SPEC FPIC_SPEC ":;"
1032 #define FPIE1_OR_FPIC1_SPEC FPIE1_SPEC "|" FPIC1_SPEC
1033 #define NO_FPIE1_AND_FPIC1_SPEC FPIE1_OR_FPIC1_SPEC ":;"
1034 #define FPIE2_OR_FPIC2_SPEC FPIE2_SPEC "|" FPIC2_SPEC
1035 #define NO_FPIE2_AND_FPIC2_SPEC FPIE1_OR_FPIC2_SPEC ":;"
1036 #define FPIE_OR_FPIC_SPEC FPIE_SPEC "|" FPIC_SPEC
1037 #define NO_FPIE_AND_FPIC_SPEC FPIE_OR_FPIC_SPEC ":;"
1040 #ifndef LINK_PIE_SPEC
1043 #define LD_PIE_SPEC "-pie"
1046 #define LD_PIE_SPEC ""
1048 #define LINK_PIE_SPEC "%{static|shared|r:;" PIE_SPEC ":" LD_PIE_SPEC "} "
1051 #ifndef LINK_BUILDID_SPEC
1052 # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
1053 # define LINK_BUILDID_SPEC "%{!r:--build-id} "
1057 #ifndef LTO_PLUGIN_SPEC
1058 #define LTO_PLUGIN_SPEC ""
1061 /* Conditional to test whether the LTO plugin is used or not.
1062 FIXME: For slim LTO we will need to enable plugin unconditionally. This
1063 still cause problems with PLUGIN_LD != LD and when plugin is built but
1064 not useable. For GCC 4.6 we don't support slim LTO and thus we can enable
1065 plugin only when LTO is enabled. We still honor explicit
1066 -fuse-linker-plugin if the linker used understands -plugin. */
1068 /* The linker has some plugin support. */
1069 #if HAVE_LTO_PLUGIN > 0
1070 /* The linker used has full plugin support, use LTO plugin by default. */
1071 #if HAVE_LTO_PLUGIN == 2
1072 #define PLUGIN_COND "!fno-use-linker-plugin:%{!fno-lto"
1073 #define PLUGIN_COND_CLOSE "}"
1075 /* The linker used has limited plugin support, use LTO plugin with explicit
1076 -fuse-linker-plugin. */
1077 #define PLUGIN_COND "fuse-linker-plugin"
1078 #define PLUGIN_COND_CLOSE ""
1080 #define LINK_PLUGIN_SPEC \
1081 "%{" PLUGIN_COND": \
1082 -plugin %(linker_plugin_file) \
1083 -plugin-opt=%(lto_wrapper) \
1084 -plugin-opt=-fresolution=%u.res \
1085 " LTO_PLUGIN_SPEC "\
1086 %{flinker-output=*:-plugin-opt=-linker-output-known} \
1087 %{!nostdlib:%{!nodefaultlibs:%:pass-through-libs(%(link_gcc_c_sequence))}} \
1088 }" PLUGIN_COND_CLOSE
1090 /* The linker used doesn't support -plugin, reject -fuse-linker-plugin. */
1091 #define LINK_PLUGIN_SPEC "%{fuse-linker-plugin:\
1092 %e-fuse-linker-plugin is not supported in this configuration}"
1095 /* Linker command line options for -fsanitize= early on the command line. */
1096 #ifndef SANITIZER_EARLY_SPEC
1097 #define SANITIZER_EARLY_SPEC "\
1098 %{!nostdlib:%{!r:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_EARLY_SPEC "} \
1099 %{%:sanitize(hwaddress):" LIBHWASAN_EARLY_SPEC "} \
1100 %{%:sanitize(thread):" LIBTSAN_EARLY_SPEC "} \
1101 %{%:sanitize(leak):" LIBLSAN_EARLY_SPEC "}}}}"
1104 /* Linker command line options for -fsanitize= late on the command line. */
1105 #ifndef SANITIZER_SPEC
1106 #define SANITIZER_SPEC "\
1107 %{!nostdlib:%{!r:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_SPEC "\
1108 %{static:%ecannot specify -static with -fsanitize=address}}\
1109 %{%:sanitize(hwaddress):" LIBHWASAN_SPEC "\
1110 %{static:%ecannot specify -static with -fsanitize=hwaddress}}\
1111 %{%:sanitize(thread):" LIBTSAN_SPEC "\
1112 %{static:%ecannot specify -static with -fsanitize=thread}}\
1113 %{%:sanitize(undefined):" LIBUBSAN_SPEC "}\
1114 %{%:sanitize(leak):" LIBLSAN_SPEC "}}}}"
1117 #ifndef POST_LINK_SPEC
1118 #define POST_LINK_SPEC ""
1121 /* This is the spec to use, once the code for creating the vtable
1122 verification runtime library, libvtv.so, has been created. Currently
1123 the vtable verification runtime functions are in libstdc++, so we use
1124 the spec just below this one. */
1125 #ifndef VTABLE_VERIFICATION_SPEC
1126 #if ENABLE_VTABLE_VERIFY
1127 #define VTABLE_VERIFICATION_SPEC "\
1128 %{!nostdlib:%{!r:%{fvtable-verify=std: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}\
1129 %{fvtable-verify=preinit: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}}}"
1131 #define VTABLE_VERIFICATION_SPEC "\
1132 %{fvtable-verify=none:} \
1133 %{fvtable-verify=std: \
1134 %e-fvtable-verify=std is not supported in this configuration} \
1135 %{fvtable-verify=preinit: \
1136 %e-fvtable-verify=preinit is not supported in this configuration}"
1140 /* -u* was put back because both BSD and SysV seem to support it. */
1141 /* %{static|no-pie|static-pie:} simply prevents an error message:
1142 1. If the target machine doesn't handle -static.
1143 2. If PIE isn't enabled by default.
1144 3. If the target machine doesn't handle -static-pie.
1146 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
1147 scripts which exist in user specified directories, or in standard
1149 /* We pass any -flto flags on to the linker, which is expected
1150 to understand them. In practice, this means it had better be collect2. */
1151 /* %{e*} includes -export-dynamic; see comment in common.opt. */
1152 #ifndef LINK_COMMAND_SPEC
1153 #define LINK_COMMAND_SPEC "\
1154 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
1157 "%{flto|flto=*:%<fcompare-debug*} \
1158 %{flto} %{fno-lto} %{flto=*} %l " LINK_PIE_SPEC \
1159 "%{fuse-ld=*:-fuse-ld=%*} " LINK_COMPRESS_DEBUG_SPEC \
1160 "%X %{o*} %{e*} %{N} %{n} %{r}\
1161 %{s} %{t} %{u*} %{z} %{Z} %{!nostdlib:%{!r:%{!nostartfiles:%S}}} \
1162 %{static|no-pie|static-pie:} %@{L*} %(link_libgcc) " \
1163 VTABLE_VERIFICATION_SPEC " " SANITIZER_EARLY_SPEC " %o "" \
1164 %{fopenacc|fopenmp|%:gt(%{ftree-parallelize-loops=*:%*} 1):\
1165 %:include(libgomp.spec)%(link_gomp)}\
1166 %{fgnu-tm:%:include(libitm.spec)%(link_itm)}\
1167 " STACK_SPLIT_SPEC "\
1168 %{fprofile-arcs|fprofile-generate*|coverage:-lgcov} " SANITIZER_SPEC " \
1169 %{!nostdlib:%{!r:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}}\
1170 %{!nostdlib:%{!r:%{!nostartfiles:%E}}} %{T*} \n%(post_link) }}}}}}"
1173 #ifndef LINK_LIBGCC_SPEC
1174 /* Generate -L options for startfile prefix list. */
1175 # define LINK_LIBGCC_SPEC "%D"
1178 #ifndef STARTFILE_PREFIX_SPEC
1179 # define STARTFILE_PREFIX_SPEC ""
1182 #ifndef SYSROOT_SPEC
1183 # define SYSROOT_SPEC "--sysroot=%R"
1186 #ifndef SYSROOT_SUFFIX_SPEC
1187 # define SYSROOT_SUFFIX_SPEC ""
1190 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
1191 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
1194 #ifndef RUNPATH_OPTION
1195 # define RUNPATH_OPTION "-rpath"
1198 static const char *asm_debug
= ASM_DEBUG_SPEC
;
1199 static const char *asm_debug_option
= ASM_DEBUG_OPTION_SPEC
;
1200 static const char *cpp_spec
= CPP_SPEC
;
1201 static const char *cc1_spec
= CC1_SPEC OS_CC1_SPEC
;
1202 static const char *cc1plus_spec
= CC1PLUS_SPEC
;
1203 static const char *link_gcc_c_sequence_spec
= LINK_GCC_C_SEQUENCE_SPEC
;
1204 static const char *link_ssp_spec
= LINK_SSP_SPEC
;
1205 static const char *asm_spec
= ASM_SPEC
;
1206 static const char *asm_final_spec
= ASM_FINAL_SPEC
;
1207 static const char *link_spec
= LINK_SPEC
;
1208 static const char *lib_spec
= LIB_SPEC
;
1209 static const char *link_gomp_spec
= "";
1210 static const char *libgcc_spec
= LIBGCC_SPEC
;
1211 static const char *endfile_spec
= ENDFILE_SPEC
;
1212 static const char *startfile_spec
= STARTFILE_SPEC
;
1213 static const char *linker_name_spec
= LINKER_NAME
;
1214 static const char *linker_plugin_file_spec
= "";
1215 static const char *lto_wrapper_spec
= "";
1216 static const char *lto_gcc_spec
= "";
1217 static const char *post_link_spec
= POST_LINK_SPEC
;
1218 static const char *link_command_spec
= LINK_COMMAND_SPEC
;
1219 static const char *link_libgcc_spec
= LINK_LIBGCC_SPEC
;
1220 static const char *startfile_prefix_spec
= STARTFILE_PREFIX_SPEC
;
1221 static const char *sysroot_spec
= SYSROOT_SPEC
;
1222 static const char *sysroot_suffix_spec
= SYSROOT_SUFFIX_SPEC
;
1223 static const char *sysroot_hdrs_suffix_spec
= SYSROOT_HEADERS_SUFFIX_SPEC
;
1224 static const char *self_spec
= "";
1226 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
1227 There should be no need to override these in target dependent files,
1228 but we need to copy them to the specs file so that newer versions
1229 of the GCC driver can correctly drive older tool chains with the
1230 appropriate -B options. */
1232 /* When cpplib handles traditional preprocessing, get rid of this, and
1233 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
1234 that we default the front end language better. */
1235 static const char *trad_capable_cpp
=
1236 "cc1 -E %{traditional|traditional-cpp:-traditional-cpp}";
1238 /* We don't wrap .d files in %W{} since a missing .d file, and
1239 therefore no dependency entry, confuses make into thinking a .o
1240 file that happens to exist is up-to-date. */
1241 static const char *cpp_unique_options
=
1242 "%{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %@{I*&F*} %{P} %I\
1243 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
1244 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
1245 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
1246 %{Mmodules} %{Mno-modules}\
1247 %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
1248 %{remap} %{%:debug-level-gt(2):-dD}\
1249 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
1250 %{H} %C %{D*&U*&A*} %{i*} %Z %i\
1252 %{fdeps-format=*:%{!fdeps-file=*:-fdeps-file=%:join(%{!o:%b.ddi}%{o*:%.ddi%*})}}\
1253 %{fdeps-format=*:%{!fdeps-target=*:-fdeps-target=%:join(%{!o:%b.o}%{o*:%.o%*})}}";
1255 /* This contains cpp options which are common with cc1_options and are passed
1256 only when preprocessing only to avoid duplication. We pass the cc1 spec
1257 options to the preprocessor so that it the cc1 spec may manipulate
1258 options used to set target flags. Those special target flags settings may
1259 in turn cause preprocessor symbols to be defined specially. */
1260 static const char *cpp_options
=
1261 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
1262 %{f*} %{g*:%{%:debug-level-gt(0):%{g*}\
1263 %{!fno-working-directory:-fworking-directory}}} %{O*}\
1264 %{undef} %{save-temps*:-fpch-preprocess}";
1266 /* Pass -d* flags, possibly modifying -dumpdir, -dumpbase et al.
1268 Make it easy for a language to override the argument for the
1269 %:dumps specs function call. */
1270 #define DUMPS_OPTIONS(EXTS) \
1271 "%<dumpdir %<dumpbase %<dumpbase-ext %{d*} %:dumps(" EXTS ")"
1273 /* This contains cpp options which are not passed when the preprocessor
1274 output will be used by another program. */
1275 static const char *cpp_debug_options
= DUMPS_OPTIONS ("");
1277 /* NB: This is shared amongst all front-ends, except for Ada. */
1278 static const char *cc1_options
=
1279 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
1280 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
1281 %1 %{!Q:-quiet} %(cpp_debug_options) %{m*} %{aux-info*}\
1282 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
1283 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
1284 %{Qn:-fno-ident} %{Qy:} %{-help:--help}\
1285 %{-target-help:--target-help}\
1286 %{-version:--version}\
1287 %{-help=*:--help=%*}\
1288 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %w%b.s}}}\
1289 %{fsyntax-only:-o %j} %{-param*}\
1290 %{coverage:-fprofile-arcs -ftest-coverage}\
1291 %{fprofile-arcs|fprofile-generate*|coverage:\
1292 %{!fprofile-update=single:\
1293 %{pthread:-fprofile-update=prefer-atomic}}}";
1295 static const char *asm_options
=
1296 "%{-target-help:%:print-asm-header()} "
1298 /* If GNU AS is used, then convert -w (no warnings), -I, and -v
1299 to the assembler equivalents. */
1300 "%{v} %{w:-W} %{I*} "
1302 "%(asm_debug_option)"
1303 ASM_COMPRESS_DEBUG_SPEC
1304 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
1306 static const char *invoke_as
=
1307 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1309 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
1310 %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
1314 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
1315 %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
1319 /* Some compilers have limits on line lengths, and the multilib_select
1320 and/or multilib_matches strings can be very long, so we build them at
1322 static struct obstack multilib_obstack
;
1323 static const char *multilib_select
;
1324 static const char *multilib_matches
;
1325 static const char *multilib_defaults
;
1326 static const char *multilib_exclusions
;
1327 static const char *multilib_reuse
;
1329 /* Check whether a particular argument is a default argument. */
1331 #ifndef MULTILIB_DEFAULTS
1332 #define MULTILIB_DEFAULTS { "" }
1335 static const char *const multilib_defaults_raw
[] = MULTILIB_DEFAULTS
;
1337 #ifndef DRIVER_SELF_SPECS
1338 #define DRIVER_SELF_SPECS ""
1341 /* Linking to libgomp implies pthreads. This is particularly important
1342 for targets that use different start files and suchlike. */
1343 #ifndef GOMP_SELF_SPECS
1344 #define GOMP_SELF_SPECS \
1345 "%{fopenacc|fopenmp|%:gt(%{ftree-parallelize-loops=*:%*} 1): " \
1349 /* Likewise for -fgnu-tm. */
1350 #ifndef GTM_SELF_SPECS
1351 #define GTM_SELF_SPECS "%{fgnu-tm: -pthread}"
1354 static const char *const driver_self_specs
[] = {
1355 "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
1356 DRIVER_SELF_SPECS
, CONFIGURE_SPECS
, GOMP_SELF_SPECS
, GTM_SELF_SPECS
,
1357 /* This discards -fmultiflags at the end of self specs processing in the
1358 driver, so that it is effectively Ignored, without actually marking it as
1359 Ignored, which would get it discarded before self specs could remap it. */
1363 #ifndef OPTION_DEFAULT_SPECS
1364 #define OPTION_DEFAULT_SPECS { "", "" }
1373 static const struct default_spec
1374 option_default_specs
[] = { OPTION_DEFAULT_SPECS
};
1378 struct user_specs
*next
;
1379 const char *filename
;
1382 static struct user_specs
*user_specs_head
, *user_specs_tail
;
1385 /* Record the mapping from file suffixes for compilation specs. */
1389 const char *suffix
; /* Use this compiler for input files
1390 whose names end in this suffix. */
1392 const char *spec
; /* To use this compiler, run this spec. */
1394 const char *cpp_spec
; /* If non-NULL, substitute this spec
1395 for `%C', rather than the usual
1397 int combinable
; /* If nonzero, compiler can deal with
1398 multiple source files at once (IMA). */
1399 int needs_preprocessing
; /* If nonzero, source files need to
1400 be run through a preprocessor. */
1403 /* Pointer to a vector of `struct compiler' that gives the spec for
1404 compiling a file, based on its suffix.
1405 A file that does not end in any of these suffixes will be passed
1406 unchanged to the loader and nothing else will be done to it.
1408 An entry containing two 0s is used to terminate the vector.
1410 If multiple entries match a file, the last matching one is used. */
1412 static struct compiler
*compilers
;
1414 /* Number of entries in `compilers', not counting the null terminator. */
1416 static int n_compilers
;
1418 /* The default list of file name suffixes and their compilation specs. */
1420 static const struct compiler default_compilers
[] =
1422 /* Add lists of suffixes of known languages here. If those languages
1423 were not present when we built the driver, we will hit these copies
1424 and be given a more meaningful error than "file not used since
1425 linking is not done". */
1426 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0},
1427 {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
1428 {".mii", "#Objective-C++", 0, 0, 0},
1429 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
1430 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
1431 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
1432 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
1433 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
1434 {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
1435 {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
1436 {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
1437 {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
1438 {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
1439 {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
1440 {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
1441 {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
1442 {".r", "#Ratfor", 0, 0, 0},
1443 {".go", "#Go", 0, 1, 0},
1444 {".d", "#D", 0, 1, 0}, {".dd", "#D", 0, 1, 0}, {".di", "#D", 0, 1, 0},
1445 {".mod", "#Modula-2", 0, 0, 0}, {".m2i", "#Modula-2", 0, 0, 0},
1446 /* Next come the entries for C. */
1447 {".c", "@c", 0, 0, 1},
1449 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1450 external preprocessor if -save-temps is given. */
1451 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1454 %eGNU C no longer supports -traditional without -E}\
1455 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1456 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1457 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1459 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1460 cc1 %(cpp_unique_options) %(cc1_options)}}}\
1461 %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 1},
1463 "%{!E:%e-E or -x required when input is from standard input}\
1464 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
1465 {".h", "@c-header", 0, 0, 0},
1467 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1468 external preprocessor if -save-temps is given. */
1469 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1471 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1472 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1473 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1475 %{!fsyntax-only:%{!S:-o %g.s} \
1476 %{!fdump-ada-spec*:%{!o*:--output-pch %w%i.gch}\
1477 %W{o*:--output-pch %w%*}}%{!S:%V}}}\
1478 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1479 cc1 %(cpp_unique_options) %(cc1_options)\
1480 %{!fsyntax-only:%{!S:-o %g.s} \
1481 %{!fdump-ada-spec*:%{!o*:--output-pch %w%i.gch}\
1482 %W{o*:--output-pch %w%*}}%{!S:%V}}}}}}}}", 0, 0, 0},
1483 {".i", "@cpp-output", 0, 0, 0},
1485 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 0},
1486 {".s", "@assembler", 0, 0, 0},
1488 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 0, 0},
1489 {".sx", "@assembler-with-cpp", 0, 0, 0},
1490 {".S", "@assembler-with-cpp", 0, 0, 0},
1491 {"@assembler-with-cpp",
1492 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1493 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1494 %{E|M|MM:%(cpp_debug_options)}\
1495 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1496 as %(asm_debug) %(asm_options) %|.s %A }}}}"
1498 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1499 %{E|M|MM:%(cpp_debug_options)}\
1500 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1501 as %(asm_debug) %(asm_options) %m.s %A }}}}"
1506 /* Mark end of table. */
1510 /* Number of elements in default_compilers, not counting the terminator. */
1512 static const int n_default_compilers
= ARRAY_SIZE (default_compilers
) - 1;
1514 typedef char *char_p
; /* For DEF_VEC_P. */
1516 /* A vector of options to give to the linker.
1517 These options are accumulated by %x,
1518 and substituted into the linker command with %X. */
1519 static vec
<char_p
> linker_options
;
1521 /* A vector of options to give to the assembler.
1522 These options are accumulated by -Wa,
1523 and substituted into the assembler command with %Y. */
1524 static vec
<char_p
> assembler_options
;
1526 /* A vector of options to give to the preprocessor.
1527 These options are accumulated by -Wp,
1528 and substituted into the preprocessor command with %Z. */
1529 static vec
<char_p
> preprocessor_options
;
1532 skip_whitespace (char *p
)
1536 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1537 be considered whitespace. */
1538 if (p
[0] == '\n' && p
[1] == '\n' && p
[2] == '\n')
1540 else if (*p
== '\n' || *p
== ' ' || *p
== '\t')
1554 /* Structures to keep track of prefixes to try when looking for files. */
1558 const char *prefix
; /* String to prepend to the path. */
1559 struct prefix_list
*next
; /* Next in linked list. */
1560 int require_machine_suffix
; /* Don't use without machine_suffix. */
1561 /* 2 means try both machine_suffix and just_machine_suffix. */
1562 int priority
; /* Sort key - priority within list. */
1563 int os_multilib
; /* 1 if OS multilib scheme should be used,
1564 0 for GCC multilib scheme. */
1569 struct prefix_list
*plist
; /* List of prefixes to try */
1570 int max_len
; /* Max length of a prefix in PLIST */
1571 const char *name
; /* Name of this list (used in config stuff) */
1574 /* List of prefixes to try when looking for executables. */
1576 static struct path_prefix exec_prefixes
= { 0, 0, "exec" };
1578 /* List of prefixes to try when looking for startup (crt0) files. */
1580 static struct path_prefix startfile_prefixes
= { 0, 0, "startfile" };
1582 /* List of prefixes to try when looking for include files. */
1584 static struct path_prefix include_prefixes
= { 0, 0, "include" };
1586 /* Suffix to attach to directories searched for commands.
1587 This looks like `MACHINE/VERSION/'. */
1589 static const char *machine_suffix
= 0;
1591 /* Suffix to attach to directories searched for commands.
1592 This is just `MACHINE/'. */
1594 static const char *just_machine_suffix
= 0;
1596 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1598 static const char *gcc_exec_prefix
;
1600 /* Adjusted value of standard_libexec_prefix. */
1602 static const char *gcc_libexec_prefix
;
1604 /* Default prefixes to attach to command names. */
1606 #ifndef STANDARD_STARTFILE_PREFIX_1
1607 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1609 #ifndef STANDARD_STARTFILE_PREFIX_2
1610 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1613 #ifdef CROSS_DIRECTORY_STRUCTURE /* Don't use these prefixes for a cross compiler. */
1614 #undef MD_EXEC_PREFIX
1615 #undef MD_STARTFILE_PREFIX
1616 #undef MD_STARTFILE_PREFIX_1
1619 /* If no prefixes defined, use the null string, which will disable them. */
1620 #ifndef MD_EXEC_PREFIX
1621 #define MD_EXEC_PREFIX ""
1623 #ifndef MD_STARTFILE_PREFIX
1624 #define MD_STARTFILE_PREFIX ""
1626 #ifndef MD_STARTFILE_PREFIX_1
1627 #define MD_STARTFILE_PREFIX_1 ""
1630 /* These directories are locations set at configure-time based on the
1631 --prefix option provided to configure. Their initializers are
1632 defined in Makefile.in. These paths are not *directly* used when
1633 gcc_exec_prefix is set because, in that case, we know where the
1634 compiler has been installed, and use paths relative to that
1635 location instead. */
1636 static const char *const standard_exec_prefix
= STANDARD_EXEC_PREFIX
;
1637 static const char *const standard_libexec_prefix
= STANDARD_LIBEXEC_PREFIX
;
1638 static const char *const standard_bindir_prefix
= STANDARD_BINDIR_PREFIX
;
1639 static const char *const standard_startfile_prefix
= STANDARD_STARTFILE_PREFIX
;
1641 /* For native compilers, these are well-known paths containing
1642 components that may be provided by the system. For cross
1643 compilers, these paths are not used. */
1644 static const char *md_exec_prefix
= MD_EXEC_PREFIX
;
1645 static const char *md_startfile_prefix
= MD_STARTFILE_PREFIX
;
1646 static const char *md_startfile_prefix_1
= MD_STARTFILE_PREFIX_1
;
1647 static const char *const standard_startfile_prefix_1
1648 = STANDARD_STARTFILE_PREFIX_1
;
1649 static const char *const standard_startfile_prefix_2
1650 = STANDARD_STARTFILE_PREFIX_2
;
1652 /* A relative path to be used in finding the location of tools
1653 relative to the driver. */
1654 static const char *const tooldir_base_prefix
= TOOLDIR_BASE_PREFIX
;
1656 /* A prefix to be used when this is an accelerator compiler. */
1657 static const char *const accel_dir_suffix
= ACCEL_DIR_SUFFIX
;
1659 /* Subdirectory to use for locating libraries. Set by
1660 set_multilib_dir based on the compilation options. */
1662 static const char *multilib_dir
;
1664 /* Subdirectory to use for locating libraries in OS conventions. Set by
1665 set_multilib_dir based on the compilation options. */
1667 static const char *multilib_os_dir
;
1669 /* Subdirectory to use for locating libraries in multiarch conventions. Set by
1670 set_multilib_dir based on the compilation options. */
1672 static const char *multiarch_dir
;
1674 /* Structure to keep track of the specs that have been defined so far.
1675 These are accessed using %(specname) in a compiler or link
1680 /* The following 2 fields must be first */
1681 /* to allow EXTRA_SPECS to be initialized */
1682 const char *name
; /* name of the spec. */
1683 const char *ptr
; /* available ptr if no static pointer */
1685 /* The following fields are not initialized */
1686 /* by EXTRA_SPECS */
1687 const char **ptr_spec
; /* pointer to the spec itself. */
1688 struct spec_list
*next
; /* Next spec in linked list. */
1689 int name_len
; /* length of the name */
1690 bool user_p
; /* whether string come from file spec. */
1691 bool alloc_p
; /* whether string was allocated */
1692 const char *default_ptr
; /* The default value of *ptr_spec. */
1695 #define INIT_STATIC_SPEC(NAME,PTR) \
1696 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, false, false, \
1699 /* List of statically defined specs. */
1700 static struct spec_list static_specs
[] =
1702 INIT_STATIC_SPEC ("asm", &asm_spec
),
1703 INIT_STATIC_SPEC ("asm_debug", &asm_debug
),
1704 INIT_STATIC_SPEC ("asm_debug_option", &asm_debug_option
),
1705 INIT_STATIC_SPEC ("asm_final", &asm_final_spec
),
1706 INIT_STATIC_SPEC ("asm_options", &asm_options
),
1707 INIT_STATIC_SPEC ("invoke_as", &invoke_as
),
1708 INIT_STATIC_SPEC ("cpp", &cpp_spec
),
1709 INIT_STATIC_SPEC ("cpp_options", &cpp_options
),
1710 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options
),
1711 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options
),
1712 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp
),
1713 INIT_STATIC_SPEC ("cc1", &cc1_spec
),
1714 INIT_STATIC_SPEC ("cc1_options", &cc1_options
),
1715 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec
),
1716 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec
),
1717 INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec
),
1718 INIT_STATIC_SPEC ("endfile", &endfile_spec
),
1719 INIT_STATIC_SPEC ("link", &link_spec
),
1720 INIT_STATIC_SPEC ("lib", &lib_spec
),
1721 INIT_STATIC_SPEC ("link_gomp", &link_gomp_spec
),
1722 INIT_STATIC_SPEC ("libgcc", &libgcc_spec
),
1723 INIT_STATIC_SPEC ("startfile", &startfile_spec
),
1724 INIT_STATIC_SPEC ("cross_compile", &cross_compile
),
1725 INIT_STATIC_SPEC ("version", &compiler_version
),
1726 INIT_STATIC_SPEC ("multilib", &multilib_select
),
1727 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults
),
1728 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra
),
1729 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches
),
1730 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions
),
1731 INIT_STATIC_SPEC ("multilib_options", &multilib_options
),
1732 INIT_STATIC_SPEC ("multilib_reuse", &multilib_reuse
),
1733 INIT_STATIC_SPEC ("linker", &linker_name_spec
),
1734 INIT_STATIC_SPEC ("linker_plugin_file", &linker_plugin_file_spec
),
1735 INIT_STATIC_SPEC ("lto_wrapper", <o_wrapper_spec
),
1736 INIT_STATIC_SPEC ("lto_gcc", <o_gcc_spec
),
1737 INIT_STATIC_SPEC ("post_link", &post_link_spec
),
1738 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec
),
1739 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix
),
1740 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix
),
1741 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1
),
1742 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec
),
1743 INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec
),
1744 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec
),
1745 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec
),
1746 INIT_STATIC_SPEC ("self_spec", &self_spec
),
1749 #ifdef EXTRA_SPECS /* additional specs needed */
1750 /* Structure to keep track of just the first two args of a spec_list.
1751 That is all that the EXTRA_SPECS macro gives us. */
1754 const char *const name
;
1755 const char *const ptr
;
1758 static const struct spec_list_1 extra_specs_1
[] = { EXTRA_SPECS
};
1759 static struct spec_list
*extra_specs
= (struct spec_list
*) 0;
1762 /* List of dynamically allocates specs that have been defined so far. */
1764 static struct spec_list
*specs
= (struct spec_list
*) 0;
1766 /* List of static spec functions. */
1768 static const struct spec_function static_spec_functions
[] =
1770 { "getenv", getenv_spec_function
},
1771 { "if-exists", if_exists_spec_function
},
1772 { "if-exists-else", if_exists_else_spec_function
},
1773 { "if-exists-then-else", if_exists_then_else_spec_function
},
1774 { "sanitize", sanitize_spec_function
},
1775 { "replace-outfile", replace_outfile_spec_function
},
1776 { "remove-outfile", remove_outfile_spec_function
},
1777 { "version-compare", version_compare_spec_function
},
1778 { "include", include_spec_function
},
1779 { "find-file", find_file_spec_function
},
1780 { "find-plugindir", find_plugindir_spec_function
},
1781 { "print-asm-header", print_asm_header_spec_function
},
1782 { "compare-debug-dump-opt", compare_debug_dump_opt_spec_function
},
1783 { "compare-debug-self-opt", compare_debug_self_opt_spec_function
},
1784 { "pass-through-libs", pass_through_libs_spec_func
},
1785 { "dumps", dumps_spec_func
},
1786 { "gt", greater_than_spec_func
},
1787 { "debug-level-gt", debug_level_greater_than_spec_func
},
1788 { "dwarf-version-gt", dwarf_version_greater_than_spec_func
},
1789 { "fortran-preinclude-file", find_fortran_preinclude_file
},
1790 { "join", join_spec_func
},
1791 #ifdef EXTRA_SPEC_FUNCTIONS
1792 EXTRA_SPEC_FUNCTIONS
1797 static int processing_spec_function
;
1799 /* Add appropriate libgcc specs to OBSTACK, taking into account
1800 various permutations of -shared-libgcc, -shared, and such. */
1802 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1804 #ifndef USE_LD_AS_NEEDED
1805 #define USE_LD_AS_NEEDED 0
1809 init_gcc_specs (struct obstack
*obstack
, const char *shared_name
,
1810 const char *static_name
, const char *eh_name
)
1814 #if USE_LD_AS_NEEDED
1815 buf
= concat ("%{static|static-libgcc|static-pie:", static_name
, " ", eh_name
, "}"
1816 "%{!static:%{!static-libgcc:%{!static-pie:"
1817 "%{!shared-libgcc:",
1818 static_name
, " " LD_AS_NEEDED_OPTION
" ",
1819 shared_name
, " " LD_NO_AS_NEEDED_OPTION
1822 shared_name
, "%{!shared: ", static_name
, "}"
1825 buf
= concat ("%{static|static-libgcc:", static_name
, " ", eh_name
, "}"
1826 "%{!static:%{!static-libgcc:"
1828 "%{!shared-libgcc:", static_name
, " ", eh_name
, "}"
1829 "%{shared-libgcc:", shared_name
, " ", static_name
, "}"
1833 "%{shared-libgcc:", shared_name
, "}"
1834 "%{!shared-libgcc:", static_name
, "}"
1837 "%{shared:", shared_name
, "}"
1842 obstack_grow (obstack
, buf
, strlen (buf
));
1845 #endif /* ENABLE_SHARED_LIBGCC */
1847 /* Initialize the specs lookup routines. */
1852 struct spec_list
*next
= (struct spec_list
*) 0;
1853 struct spec_list
*sl
= (struct spec_list
*) 0;
1857 return; /* Already initialized. */
1860 fnotice (stderr
, "Using built-in specs.\n");
1863 extra_specs
= XCNEWVEC (struct spec_list
, ARRAY_SIZE (extra_specs_1
));
1865 for (i
= ARRAY_SIZE (extra_specs_1
) - 1; i
>= 0; i
--)
1867 sl
= &extra_specs
[i
];
1868 sl
->name
= extra_specs_1
[i
].name
;
1869 sl
->ptr
= extra_specs_1
[i
].ptr
;
1871 sl
->name_len
= strlen (sl
->name
);
1872 sl
->ptr_spec
= &sl
->ptr
;
1873 gcc_assert (sl
->ptr_spec
!= NULL
);
1874 sl
->default_ptr
= sl
->ptr
;
1879 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1881 sl
= &static_specs
[i
];
1886 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1887 /* ??? If neither -shared-libgcc nor --static-libgcc was
1888 seen, then we should be making an educated guess. Some proposed
1889 heuristics for ELF include:
1891 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1892 program will be doing dynamic loading, which will likely
1893 need the shared libgcc.
1895 (2) If "-ldl", then it's also a fair bet that we're doing
1898 (3) For each ET_DYN we're linking against (either through -lfoo
1899 or /some/path/foo.so), check to see whether it or one of
1900 its dependencies depends on a shared libgcc.
1904 If the runtime is fixed to look for program headers instead
1905 of calling __register_frame_info at all, for each object,
1906 use the shared libgcc if any EH symbol referenced.
1908 If crtstuff is fixed to not invoke __register_frame_info
1909 automatically, for each object, use the shared libgcc if
1910 any non-empty unwind section found.
1912 Doing any of this probably requires invoking an external program to
1913 do the actual object file scanning. */
1915 const char *p
= libgcc_spec
;
1918 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1919 when given the proper command line arguments. */
1922 if (in_sep
&& *p
== '-' && startswith (p
, "-lgcc"))
1924 init_gcc_specs (&obstack
,
1926 #ifdef USE_LIBUNWIND_EXCEPTIONS
1932 #ifdef USE_LIBUNWIND_EXCEPTIONS
1933 # ifdef HAVE_LD_STATIC_DYNAMIC
1934 " %{!static:%{!static-pie:" LD_STATIC_OPTION
"}} -lunwind"
1935 " %{!static:%{!static-pie:" LD_DYNAMIC_OPTION
"}}"
1945 else if (in_sep
&& *p
== 'l' && startswith (p
, "libgcc.a%s"))
1947 /* Ug. We don't know shared library extensions. Hope that
1948 systems that use this form don't do shared libraries. */
1949 init_gcc_specs (&obstack
,
1953 #ifdef USE_LIBUNWIND_EXCEPTIONS
1962 obstack_1grow (&obstack
, *p
);
1963 in_sep
= (*p
== ' ');
1968 obstack_1grow (&obstack
, '\0');
1969 libgcc_spec
= XOBFINISH (&obstack
, const char *);
1972 #ifdef USE_AS_TRADITIONAL_FORMAT
1973 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1975 static const char tf
[] = "--traditional-format ";
1976 obstack_grow (&obstack
, tf
, sizeof (tf
) - 1);
1977 obstack_grow0 (&obstack
, asm_spec
, strlen (asm_spec
));
1978 asm_spec
= XOBFINISH (&obstack
, const char *);
1982 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC || \
1983 defined LINKER_HASH_STYLE
1984 # ifdef LINK_BUILDID_SPEC
1985 /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. */
1986 obstack_grow (&obstack
, LINK_BUILDID_SPEC
, sizeof (LINK_BUILDID_SPEC
) - 1);
1988 # ifdef LINK_EH_SPEC
1989 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1990 obstack_grow (&obstack
, LINK_EH_SPEC
, sizeof (LINK_EH_SPEC
) - 1);
1992 # ifdef LINKER_HASH_STYLE
1993 /* Prepend --hash-style=LINKER_HASH_STYLE to whatever link_spec we had
1996 static const char hash_style
[] = "--hash-style=";
1997 obstack_grow (&obstack
, hash_style
, sizeof (hash_style
) - 1);
1998 obstack_grow (&obstack
, LINKER_HASH_STYLE
, sizeof (LINKER_HASH_STYLE
) - 1);
1999 obstack_1grow (&obstack
, ' ');
2002 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
2003 link_spec
= XOBFINISH (&obstack
, const char *);
2009 /* Update the entry for SPEC in the static_specs table to point to VALUE,
2010 ensuring that we free the previous value if necessary. Set alloc_p for the
2011 entry to ALLOC_P: this determines whether we take ownership of VALUE (i.e.
2012 whether we need to free it later on). */
2014 set_static_spec (const char **spec
, const char *value
, bool alloc_p
)
2016 struct spec_list
*sl
= NULL
;
2018 for (unsigned i
= 0; i
< ARRAY_SIZE (static_specs
); i
++)
2020 if (static_specs
[i
].ptr_spec
== spec
)
2022 sl
= static_specs
+ i
;
2031 const char *old
= *spec
;
2032 free (const_cast <char *> (old
));
2036 sl
->alloc_p
= alloc_p
;
2039 /* Update a static spec to a new string, taking ownership of that
2041 static void set_static_spec_owned (const char **spec
, const char *val
)
2043 return set_static_spec (spec
, val
, true);
2046 /* Update a static spec to point to a new value, but don't take
2047 ownership of (i.e. don't free) that string. */
2048 static void set_static_spec_shared (const char **spec
, const char *val
)
2050 return set_static_spec (spec
, val
, false);
2054 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
2055 removed; If the spec starts with a + then SPEC is added to the end of the
2059 set_spec (const char *name
, const char *spec
, bool user_p
)
2061 struct spec_list
*sl
;
2062 const char *old_spec
;
2063 int name_len
= strlen (name
);
2066 /* If this is the first call, initialize the statically allocated specs. */
2069 struct spec_list
*next
= (struct spec_list
*) 0;
2070 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
2072 sl
= &static_specs
[i
];
2079 /* See if the spec already exists. */
2080 for (sl
= specs
; sl
; sl
= sl
->next
)
2081 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, name
))
2086 /* Not found - make it. */
2087 sl
= XNEW (struct spec_list
);
2088 sl
->name
= xstrdup (name
);
2089 sl
->name_len
= name_len
;
2090 sl
->ptr_spec
= &sl
->ptr
;
2092 *(sl
->ptr_spec
) = "";
2094 sl
->default_ptr
= NULL
;
2098 old_spec
= *(sl
->ptr_spec
);
2099 *(sl
->ptr_spec
) = ((spec
[0] == '+' && ISSPACE ((unsigned char)spec
[1]))
2100 ? concat (old_spec
, spec
+ 1, NULL
)
2105 fnotice (stderr
, "Setting spec %s to '%s'\n\n", name
, *(sl
->ptr_spec
));
2108 /* Free the old spec. */
2109 if (old_spec
&& sl
->alloc_p
)
2110 free (CONST_CAST (char *, old_spec
));
2112 sl
->user_p
= user_p
;
2116 /* Accumulate a command (program name and args), and run it. */
2118 typedef const char *const_char_p
; /* For DEF_VEC_P. */
2120 /* Vector of pointers to arguments in the current line of specifications. */
2121 static vec
<const_char_p
> argbuf
;
2123 /* Likewise, but for the current @file. */
2124 static vec
<const_char_p
> at_file_argbuf
;
2126 /* Whether an @file is currently open. */
2127 static bool in_at_file
= false;
2129 /* Were the options -c, -S or -E passed. */
2130 static int have_c
= 0;
2132 /* Was the option -o passed. */
2133 static int have_o
= 0;
2135 /* Was the option -E passed. */
2136 static int have_E
= 0;
2138 /* Pointer to output file name passed in with -o. */
2139 static const char *output_file
= 0;
2141 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
2142 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
2145 static struct temp_name
{
2146 const char *suffix
; /* suffix associated with the code. */
2147 int length
; /* strlen (suffix). */
2148 int unique
; /* Indicates whether %g or %u/%U was used. */
2149 const char *filename
; /* associated filename. */
2150 int filename_length
; /* strlen (filename). */
2151 struct temp_name
*next
;
2154 /* Number of commands executed so far. */
2156 static int execution_count
;
2158 /* Number of commands that exited with a signal. */
2160 static int signal_count
;
2162 /* Allocate the argument vector. */
2168 at_file_argbuf
.create (10);
2171 /* Clear out the vector of arguments (after a command is executed). */
2176 argbuf
.truncate (0);
2177 at_file_argbuf
.truncate (0);
2180 /* Add one argument to the vector at the end.
2181 This is done when a space is seen or at the end of the line.
2182 If DELETE_ALWAYS is nonzero, the arg is a filename
2183 and the file should be deleted eventually.
2184 If DELETE_FAILURE is nonzero, the arg is a filename
2185 and the file should be deleted if this compilation fails. */
2188 store_arg (const char *arg
, int delete_always
, int delete_failure
)
2191 at_file_argbuf
.safe_push (arg
);
2193 argbuf
.safe_push (arg
);
2195 if (delete_always
|| delete_failure
)
2198 /* If the temporary file we should delete is specified as
2199 part of a joined argument extract the filename. */
2201 && (p
= strrchr (arg
, '=')))
2203 record_temp_file (arg
, delete_always
, delete_failure
);
2207 /* Open a temporary @file into which subsequent arguments will be stored. */
2213 fatal_error (input_location
, "cannot open nested response file");
2218 /* Create a temporary @file name. */
2220 static char *make_at_file (void)
2222 static int fileno
= 0;
2224 const char *base
, *ext
;
2226 if (!save_temps_flag
)
2227 return make_temp_file ("");
2230 if (!(base
&& *base
))
2232 if (!(base
&& *base
))
2235 sprintf (filename
, ".args.%d", fileno
++);
2238 if (base
== dumpdir
&& dumpdir_trailing_dash_added
)
2241 return concat (base
, ext
, NULL
);
2244 /* Close the temporary @file and add @file to the argument list. */
2247 close_at_file (void)
2250 fatal_error (input_location
, "cannot close nonexistent response file");
2254 const unsigned int n_args
= at_file_argbuf
.length ();
2258 char **argv
= XALLOCAVEC (char *, n_args
+ 1);
2259 char *temp_file
= make_at_file ();
2260 char *at_argument
= concat ("@", temp_file
, NULL
);
2261 FILE *f
= fopen (temp_file
, "w");
2265 /* Copy the strings over. */
2266 for (i
= 0; i
< n_args
; i
++)
2267 argv
[i
] = CONST_CAST (char *, at_file_argbuf
[i
]);
2270 at_file_argbuf
.truncate (0);
2273 fatal_error (input_location
, "could not open temporary response file %s",
2276 status
= writeargv (argv
, f
);
2279 fatal_error (input_location
,
2280 "could not write to temporary response file %s",
2283 status
= fclose (f
);
2286 fatal_error (input_location
, "could not close temporary response file %s",
2289 store_arg (at_argument
, 0, 0);
2291 record_temp_file (temp_file
, !save_temps_flag
, !save_temps_flag
);
2294 /* Load specs from a file name named FILENAME, replacing occurrences of
2295 various different types of line-endings, \r\n, \n\r and just \r, with
2299 load_specs (const char *filename
)
2303 struct stat statbuf
;
2310 fnotice (stderr
, "Reading specs from %s\n", filename
);
2312 /* Open and stat the file. */
2313 desc
= open (filename
, O_RDONLY
, 0);
2317 /* This leaves DESC open, but the OS will save us. */
2318 fatal_error (input_location
, "cannot read spec file %qs: %m", filename
);
2321 if (stat (filename
, &statbuf
) < 0)
2324 /* Read contents of file into BUFFER. */
2325 buffer
= XNEWVEC (char, statbuf
.st_size
+ 1);
2326 readlen
= read (desc
, buffer
, (unsigned) statbuf
.st_size
);
2329 buffer
[readlen
] = 0;
2332 specs
= XNEWVEC (char, readlen
+ 1);
2334 for (buffer_p
= buffer
; buffer_p
&& *buffer_p
; buffer_p
++)
2340 if (buffer_p
> buffer
&& *(buffer_p
- 1) == '\n') /* \n\r */
2342 else if (*(buffer_p
+ 1) == '\n') /* \r\n */
2356 /* Read compilation specs from a file named FILENAME,
2357 replacing the default ones.
2359 A suffix which starts with `*' is a definition for
2360 one of the machine-specific sub-specs. The "suffix" should be
2361 *asm, *cc1, *cpp, *link, *startfile, etc.
2362 The corresponding spec is stored in asm_spec, etc.,
2363 rather than in the `compilers' vector.
2365 Anything invalid in the file is a fatal error. */
2368 read_specs (const char *filename
, bool main_p
, bool user_p
)
2373 buffer
= load_specs (filename
);
2375 /* Scan BUFFER for specs, putting them in the vector. */
2381 char *in
, *out
, *p1
, *p2
, *p3
;
2383 /* Advance P in BUFFER to the next nonblank nocomment line. */
2384 p
= skip_whitespace (p
);
2388 /* Is this a special command that starts with '%'? */
2389 /* Don't allow this for the main specs file, since it would
2390 encourage people to overwrite it. */
2391 if (*p
== '%' && !main_p
)
2394 while (*p
&& *p
!= '\n')
2400 if (startswith (p1
, "%include")
2401 && (p1
[sizeof "%include" - 1] == ' '
2402 || p1
[sizeof "%include" - 1] == '\t'))
2406 p1
+= sizeof ("%include");
2407 while (*p1
== ' ' || *p1
== '\t')
2410 if (*p1
++ != '<' || p
[-2] != '>')
2411 fatal_error (input_location
,
2412 "specs %%include syntax malformed after "
2414 (long) (p1
- buffer
+ 1));
2417 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
2418 read_specs (new_filename
? new_filename
: p1
, false, user_p
);
2421 else if (startswith (p1
, "%include_noerr")
2422 && (p1
[sizeof "%include_noerr" - 1] == ' '
2423 || p1
[sizeof "%include_noerr" - 1] == '\t'))
2427 p1
+= sizeof "%include_noerr";
2428 while (*p1
== ' ' || *p1
== '\t')
2431 if (*p1
++ != '<' || p
[-2] != '>')
2432 fatal_error (input_location
,
2433 "specs %%include syntax malformed after "
2435 (long) (p1
- buffer
+ 1));
2438 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
2440 read_specs (new_filename
, false, user_p
);
2441 else if (verbose_flag
)
2442 fnotice (stderr
, "could not find specs file %s\n", p1
);
2445 else if (startswith (p1
, "%rename")
2446 && (p1
[sizeof "%rename" - 1] == ' '
2447 || p1
[sizeof "%rename" - 1] == '\t'))
2450 struct spec_list
*sl
;
2451 struct spec_list
*newsl
;
2453 /* Get original name. */
2454 p1
+= sizeof "%rename";
2455 while (*p1
== ' ' || *p1
== '\t')
2458 if (! ISALPHA ((unsigned char) *p1
))
2459 fatal_error (input_location
,
2460 "specs %%rename syntax malformed after "
2462 (long) (p1
- buffer
));
2465 while (*p2
&& !ISSPACE ((unsigned char) *p2
))
2468 if (*p2
!= ' ' && *p2
!= '\t')
2469 fatal_error (input_location
,
2470 "specs %%rename syntax malformed after "
2472 (long) (p2
- buffer
));
2476 while (*p2
== ' ' || *p2
== '\t')
2479 if (! ISALPHA ((unsigned char) *p2
))
2480 fatal_error (input_location
,
2481 "specs %%rename syntax malformed after "
2483 (long) (p2
- buffer
));
2485 /* Get new spec name. */
2487 while (*p3
&& !ISSPACE ((unsigned char) *p3
))
2491 fatal_error (input_location
,
2492 "specs %%rename syntax malformed after "
2494 (long) (p3
- buffer
));
2497 for (sl
= specs
; sl
; sl
= sl
->next
)
2498 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, p1
))
2502 fatal_error (input_location
,
2503 "specs %s spec was not found to be renamed", p1
);
2505 if (strcmp (p1
, p2
) == 0)
2508 for (newsl
= specs
; newsl
; newsl
= newsl
->next
)
2509 if (strcmp (newsl
->name
, p2
) == 0)
2510 fatal_error (input_location
,
2511 "%s: attempt to rename spec %qs to "
2512 "already defined spec %qs",
2517 fnotice (stderr
, "rename spec %s to %s\n", p1
, p2
);
2519 fnotice (stderr
, "spec is '%s'\n\n", *(sl
->ptr_spec
));
2523 set_spec (p2
, *(sl
->ptr_spec
), user_p
);
2525 free (CONST_CAST (char *, *(sl
->ptr_spec
)));
2527 *(sl
->ptr_spec
) = "";
2532 fatal_error (input_location
,
2533 "specs unknown %% command after %ld characters",
2534 (long) (p1
- buffer
));
2537 /* Find the colon that should end the suffix. */
2539 while (*p1
&& *p1
!= ':' && *p1
!= '\n')
2542 /* The colon shouldn't be missing. */
2544 fatal_error (input_location
,
2545 "specs file malformed after %ld characters",
2546 (long) (p1
- buffer
));
2548 /* Skip back over trailing whitespace. */
2550 while (p2
> buffer
&& (p2
[-1] == ' ' || p2
[-1] == '\t'))
2553 /* Copy the suffix to a string. */
2554 suffix
= save_string (p
, p2
- p
);
2555 /* Find the next line. */
2556 p
= skip_whitespace (p1
+ 1);
2558 fatal_error (input_location
,
2559 "specs file malformed after %ld characters",
2560 (long) (p
- buffer
));
2563 /* Find next blank line or end of string. */
2564 while (*p1
&& !(*p1
== '\n' && (p1
[1] == '\n' || p1
[1] == '\0')))
2567 /* Specs end at the blank line and do not include the newline. */
2568 spec
= save_string (p
, p1
- p
);
2571 /* Delete backslash-newline sequences from the spec. */
2576 if (in
[0] == '\\' && in
[1] == '\n')
2578 else if (in
[0] == '#')
2579 while (*in
&& *in
!= '\n')
2587 if (suffix
[0] == '*')
2589 if (! strcmp (suffix
, "*link_command"))
2590 link_command_spec
= spec
;
2593 set_spec (suffix
+ 1, spec
, user_p
);
2599 /* Add this pair to the vector. */
2601 = XRESIZEVEC (struct compiler
, compilers
, n_compilers
+ 2);
2603 compilers
[n_compilers
].suffix
= suffix
;
2604 compilers
[n_compilers
].spec
= spec
;
2606 memset (&compilers
[n_compilers
], 0, sizeof compilers
[n_compilers
]);
2610 link_command_spec
= spec
;
2613 if (link_command_spec
== 0)
2614 fatal_error (input_location
, "spec file has no spec for linking");
2616 XDELETEVEC (buffer
);
2619 /* Record the names of temporary files we tell compilers to write,
2620 and delete them at the end of the run. */
2622 /* This is the common prefix we use to make temp file names.
2623 It is chosen once for each run of this program.
2624 It is substituted into a spec by %g or %j.
2625 Thus, all temp file names contain this prefix.
2626 In practice, all temp file names start with this prefix.
2628 This prefix comes from the envvar TMPDIR if it is defined;
2629 otherwise, from the P_tmpdir macro if that is defined;
2630 otherwise, in /usr/tmp or /tmp;
2631 or finally the current directory if all else fails. */
2633 static const char *temp_filename
;
2635 /* Length of the prefix. */
2637 static int temp_filename_length
;
2639 /* Define the list of temporary files to delete. */
2644 struct temp_file
*next
;
2647 /* Queue of files to delete on success or failure of compilation. */
2648 static struct temp_file
*always_delete_queue
;
2649 /* Queue of files to delete on failure of compilation. */
2650 static struct temp_file
*failure_delete_queue
;
2652 /* Record FILENAME as a file to be deleted automatically.
2653 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2654 otherwise delete it in any case.
2655 FAIL_DELETE nonzero means delete it if a compilation step fails;
2656 otherwise delete it in any case. */
2659 record_temp_file (const char *filename
, int always_delete
, int fail_delete
)
2661 char *const name
= xstrdup (filename
);
2665 struct temp_file
*temp
;
2666 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2667 if (! filename_cmp (name
, temp
->name
))
2673 temp
= XNEW (struct temp_file
);
2674 temp
->next
= always_delete_queue
;
2676 always_delete_queue
= temp
;
2683 struct temp_file
*temp
;
2684 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2685 if (! filename_cmp (name
, temp
->name
))
2691 temp
= XNEW (struct temp_file
);
2692 temp
->next
= failure_delete_queue
;
2694 failure_delete_queue
= temp
;
2700 /* Delete all the temporary files whose names we previously recorded. */
2702 #ifndef DELETE_IF_ORDINARY
2703 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2706 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2707 if (unlink (NAME) < 0) \
2709 error ("%s: %m", (NAME)); \
2714 delete_if_ordinary (const char *name
)
2720 printf ("Delete %s? (y or n) ", name
);
2724 while ((c
= getchar ()) != '\n' && c
!= EOF
)
2727 if (i
== 'y' || i
== 'Y')
2729 DELETE_IF_ORDINARY (name
, st
, verbose_flag
);
2733 delete_temp_files (void)
2735 struct temp_file
*temp
;
2737 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2738 delete_if_ordinary (temp
->name
);
2739 always_delete_queue
= 0;
2742 /* Delete all the files to be deleted on error. */
2745 delete_failure_queue (void)
2747 struct temp_file
*temp
;
2749 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2750 delete_if_ordinary (temp
->name
);
2754 clear_failure_queue (void)
2756 failure_delete_queue
= 0;
2759 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2761 If DO_MULTI is true iterate over the paths twice, first with multilib
2762 suffix then without, otherwise iterate over the paths once without
2763 adding a multilib suffix. When DO_MULTI is true, some attempt is made
2764 to avoid visiting the same path twice, but we could do better. For
2765 instance, /usr/lib/../lib is considered different from /usr/lib.
2766 At least EXTRA_SPACE chars past the end of the path passed to
2767 CALLBACK are available for use by the callback.
2768 CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2770 Returns the value returned by CALLBACK. */
2773 for_each_path (const struct path_prefix
*paths
,
2776 void *(*callback
) (char *, void *),
2777 void *callback_info
)
2779 struct prefix_list
*pl
;
2780 const char *multi_dir
= NULL
;
2781 const char *multi_os_dir
= NULL
;
2782 const char *multiarch_suffix
= NULL
;
2783 const char *multi_suffix
;
2784 const char *just_multi_suffix
;
2787 bool skip_multi_dir
= false;
2788 bool skip_multi_os_dir
= false;
2790 multi_suffix
= machine_suffix
;
2791 just_multi_suffix
= just_machine_suffix
;
2792 if (do_multi
&& multilib_dir
&& strcmp (multilib_dir
, ".") != 0)
2794 multi_dir
= concat (multilib_dir
, dir_separator_str
, NULL
);
2795 multi_suffix
= concat (multi_suffix
, multi_dir
, NULL
);
2796 just_multi_suffix
= concat (just_multi_suffix
, multi_dir
, NULL
);
2798 if (do_multi
&& multilib_os_dir
&& strcmp (multilib_os_dir
, ".") != 0)
2799 multi_os_dir
= concat (multilib_os_dir
, dir_separator_str
, NULL
);
2801 multiarch_suffix
= concat (multiarch_dir
, dir_separator_str
, NULL
);
2805 size_t multi_dir_len
= 0;
2806 size_t multi_os_dir_len
= 0;
2807 size_t multiarch_len
= 0;
2809 size_t just_suffix_len
;
2813 multi_dir_len
= strlen (multi_dir
);
2815 multi_os_dir_len
= strlen (multi_os_dir
);
2816 if (multiarch_suffix
)
2817 multiarch_len
= strlen (multiarch_suffix
);
2818 suffix_len
= strlen (multi_suffix
);
2819 just_suffix_len
= strlen (just_multi_suffix
);
2823 len
= paths
->max_len
+ extra_space
+ 1;
2824 len
+= MAX (MAX (suffix_len
, multi_os_dir_len
), multiarch_len
);
2825 path
= XNEWVEC (char, len
);
2828 for (pl
= paths
->plist
; pl
!= 0; pl
= pl
->next
)
2830 len
= strlen (pl
->prefix
);
2831 memcpy (path
, pl
->prefix
, len
);
2833 /* Look first in MACHINE/VERSION subdirectory. */
2834 if (!skip_multi_dir
)
2836 memcpy (path
+ len
, multi_suffix
, suffix_len
+ 1);
2837 ret
= callback (path
, callback_info
);
2842 /* Some paths are tried with just the machine (ie. target)
2843 subdir. This is used for finding as, ld, etc. */
2845 && pl
->require_machine_suffix
== 2)
2847 memcpy (path
+ len
, just_multi_suffix
, just_suffix_len
+ 1);
2848 ret
= callback (path
, callback_info
);
2853 /* Now try the multiarch path. */
2855 && !pl
->require_machine_suffix
&& multiarch_dir
)
2857 memcpy (path
+ len
, multiarch_suffix
, multiarch_len
+ 1);
2858 ret
= callback (path
, callback_info
);
2863 /* Now try the base path. */
2864 if (!pl
->require_machine_suffix
2865 && !(pl
->os_multilib
? skip_multi_os_dir
: skip_multi_dir
))
2867 const char *this_multi
;
2868 size_t this_multi_len
;
2870 if (pl
->os_multilib
)
2872 this_multi
= multi_os_dir
;
2873 this_multi_len
= multi_os_dir_len
;
2877 this_multi
= multi_dir
;
2878 this_multi_len
= multi_dir_len
;
2882 memcpy (path
+ len
, this_multi
, this_multi_len
+ 1);
2886 ret
= callback (path
, callback_info
);
2894 if (multi_dir
== NULL
&& multi_os_dir
== NULL
)
2897 /* Run through the paths again, this time without multilibs.
2898 Don't repeat any we have already seen. */
2901 free (CONST_CAST (char *, multi_dir
));
2903 free (CONST_CAST (char *, multi_suffix
));
2904 multi_suffix
= machine_suffix
;
2905 free (CONST_CAST (char *, just_multi_suffix
));
2906 just_multi_suffix
= just_machine_suffix
;
2909 skip_multi_dir
= true;
2912 free (CONST_CAST (char *, multi_os_dir
));
2913 multi_os_dir
= NULL
;
2916 skip_multi_os_dir
= true;
2921 free (CONST_CAST (char *, multi_dir
));
2922 free (CONST_CAST (char *, multi_suffix
));
2923 free (CONST_CAST (char *, just_multi_suffix
));
2926 free (CONST_CAST (char *, multi_os_dir
));
2932 /* Callback for build_search_list. Adds path to obstack being built. */
2934 struct add_to_obstack_info
{
2941 add_to_obstack (char *path
, void *data
)
2943 struct add_to_obstack_info
*info
= (struct add_to_obstack_info
*) data
;
2945 if (info
->check_dir
&& !is_directory (path
, false))
2948 if (!info
->first_time
)
2949 obstack_1grow (info
->ob
, PATH_SEPARATOR
);
2951 obstack_grow (info
->ob
, path
, strlen (path
));
2953 info
->first_time
= false;
2957 /* Add or change the value of an environment variable, outputting the
2958 change to standard error if in verbose mode. */
2960 xputenv (const char *string
)
2965 /* Build a list of search directories from PATHS.
2966 PREFIX is a string to prepend to the list.
2967 If CHECK_DIR_P is true we ensure the directory exists.
2968 If DO_MULTI is true, multilib paths are output first, then
2970 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2971 It is also used by the --print-search-dirs flag. */
2974 build_search_list (const struct path_prefix
*paths
, const char *prefix
,
2975 bool check_dir
, bool do_multi
)
2977 struct add_to_obstack_info info
;
2979 info
.ob
= &collect_obstack
;
2980 info
.check_dir
= check_dir
;
2981 info
.first_time
= true;
2983 obstack_grow (&collect_obstack
, prefix
, strlen (prefix
));
2984 obstack_1grow (&collect_obstack
, '=');
2986 for_each_path (paths
, do_multi
, 0, add_to_obstack
, &info
);
2988 obstack_1grow (&collect_obstack
, '\0');
2989 return XOBFINISH (&collect_obstack
, char *);
2992 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2996 putenv_from_prefixes (const struct path_prefix
*paths
, const char *env_var
,
2999 xputenv (build_search_list (paths
, env_var
, true, do_multi
));
3002 /* Check whether NAME can be accessed in MODE. This is like access,
3003 except that it never considers directories to be executable. */
3006 access_check (const char *name
, int mode
)
3012 if (stat (name
, &st
) < 0
3013 || S_ISDIR (st
.st_mode
))
3017 return access (name
, mode
);
3020 /* Callback for find_a_file. Appends the file name to the directory
3021 path. If the resulting file exists in the right mode, return the
3022 full pathname to the file. */
3024 struct file_at_path_info
{
3033 file_at_path (char *path
, void *data
)
3035 struct file_at_path_info
*info
= (struct file_at_path_info
*) data
;
3036 size_t len
= strlen (path
);
3038 memcpy (path
+ len
, info
->name
, info
->name_len
);
3039 len
+= info
->name_len
;
3041 /* Some systems have a suffix for executable files.
3042 So try appending that first. */
3043 if (info
->suffix_len
)
3045 memcpy (path
+ len
, info
->suffix
, info
->suffix_len
+ 1);
3046 if (access_check (path
, info
->mode
) == 0)
3051 if (access_check (path
, info
->mode
) == 0)
3057 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
3058 access to check permissions. If DO_MULTI is true, search multilib
3059 paths then non-multilib paths, otherwise do not search multilib paths.
3060 Return 0 if not found, otherwise return its name, allocated with malloc. */
3063 find_a_file (const struct path_prefix
*pprefix
, const char *name
, int mode
,
3066 struct file_at_path_info info
;
3068 /* Find the filename in question (special case for absolute paths). */
3070 if (IS_ABSOLUTE_PATH (name
))
3072 if (access (name
, mode
) == 0)
3073 return xstrdup (name
);
3079 info
.suffix
= (mode
& X_OK
) != 0 ? HOST_EXECUTABLE_SUFFIX
: "";
3080 info
.name_len
= strlen (info
.name
);
3081 info
.suffix_len
= strlen (info
.suffix
);
3084 return (char*) for_each_path (pprefix
, do_multi
,
3085 info
.name_len
+ info
.suffix_len
,
3086 file_at_path
, &info
);
3089 /* Specialization of find_a_file for programs that also takes into account
3090 configure-specified default programs. */
3093 find_a_program (const char *name
)
3095 /* Do not search if default matches query. */
3097 #ifdef DEFAULT_ASSEMBLER
3098 if (! strcmp (name
, "as") && access (DEFAULT_ASSEMBLER
, X_OK
) == 0)
3099 return xstrdup (DEFAULT_ASSEMBLER
);
3102 #ifdef DEFAULT_LINKER
3103 if (! strcmp (name
, "ld") && access (DEFAULT_LINKER
, X_OK
) == 0)
3104 return xstrdup (DEFAULT_LINKER
);
3107 #ifdef DEFAULT_DSYMUTIL
3108 if (! strcmp (name
, "dsymutil") && access (DEFAULT_DSYMUTIL
, X_OK
) == 0)
3109 return xstrdup (DEFAULT_DSYMUTIL
);
3112 return find_a_file (&exec_prefixes
, name
, X_OK
, false);
3115 /* Ranking of prefixes in the sort list. -B prefixes are put before
3118 enum path_prefix_priority
3120 PREFIX_PRIORITY_B_OPT
,
3121 PREFIX_PRIORITY_LAST
3124 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
3125 order according to PRIORITY. Within each PRIORITY, new entries are
3128 If WARN is nonzero, we will warn if no file is found
3129 through this prefix. WARN should point to an int
3130 which will be set to 1 if this entry is used.
3132 COMPONENT is the value to be passed to update_path.
3134 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
3135 the complete value of machine_suffix.
3136 2 means try both machine_suffix and just_machine_suffix. */
3139 add_prefix (struct path_prefix
*pprefix
, const char *prefix
,
3140 const char *component
, /* enum prefix_priority */ int priority
,
3141 int require_machine_suffix
, int os_multilib
)
3143 struct prefix_list
*pl
, **prev
;
3146 for (prev
= &pprefix
->plist
;
3147 (*prev
) != NULL
&& (*prev
)->priority
<= priority
;
3148 prev
= &(*prev
)->next
)
3151 /* Keep track of the longest prefix. */
3153 prefix
= update_path (prefix
, component
);
3154 len
= strlen (prefix
);
3155 if (len
> pprefix
->max_len
)
3156 pprefix
->max_len
= len
;
3158 pl
= XNEW (struct prefix_list
);
3159 pl
->prefix
= prefix
;
3160 pl
->require_machine_suffix
= require_machine_suffix
;
3161 pl
->priority
= priority
;
3162 pl
->os_multilib
= os_multilib
;
3164 /* Insert after PREV. */
3169 /* Same as add_prefix, but prepending target_system_root to prefix. */
3170 /* The target_system_root prefix has been relocated by gcc_exec_prefix. */
3172 add_sysrooted_prefix (struct path_prefix
*pprefix
, const char *prefix
,
3173 const char *component
,
3174 /* enum prefix_priority */ int priority
,
3175 int require_machine_suffix
, int os_multilib
)
3177 if (!IS_ABSOLUTE_PATH (prefix
))
3178 fatal_error (input_location
, "system path %qs is not absolute", prefix
);
3180 if (target_system_root
)
3182 char *sysroot_no_trailing_dir_separator
= xstrdup (target_system_root
);
3183 size_t sysroot_len
= strlen (target_system_root
);
3186 && target_system_root
[sysroot_len
- 1] == DIR_SEPARATOR
)
3187 sysroot_no_trailing_dir_separator
[sysroot_len
- 1] = '\0';
3189 if (target_sysroot_suffix
)
3190 prefix
= concat (sysroot_no_trailing_dir_separator
,
3191 target_sysroot_suffix
, prefix
, NULL
);
3193 prefix
= concat (sysroot_no_trailing_dir_separator
, prefix
, NULL
);
3195 free (sysroot_no_trailing_dir_separator
);
3197 /* We have to override this because GCC's notion of sysroot
3198 moves along with GCC. */
3202 add_prefix (pprefix
, prefix
, component
, priority
,
3203 require_machine_suffix
, os_multilib
);
3206 /* Same as add_prefix, but prepending target_sysroot_hdrs_suffix to prefix. */
3209 add_sysrooted_hdrs_prefix (struct path_prefix
*pprefix
, const char *prefix
,
3210 const char *component
,
3211 /* enum prefix_priority */ int priority
,
3212 int require_machine_suffix
, int os_multilib
)
3214 if (!IS_ABSOLUTE_PATH (prefix
))
3215 fatal_error (input_location
, "system path %qs is not absolute", prefix
);
3217 if (target_system_root
)
3219 char *sysroot_no_trailing_dir_separator
= xstrdup (target_system_root
);
3220 size_t sysroot_len
= strlen (target_system_root
);
3223 && target_system_root
[sysroot_len
- 1] == DIR_SEPARATOR
)
3224 sysroot_no_trailing_dir_separator
[sysroot_len
- 1] = '\0';
3226 if (target_sysroot_hdrs_suffix
)
3227 prefix
= concat (sysroot_no_trailing_dir_separator
,
3228 target_sysroot_hdrs_suffix
, prefix
, NULL
);
3230 prefix
= concat (sysroot_no_trailing_dir_separator
, prefix
, NULL
);
3232 free (sysroot_no_trailing_dir_separator
);
3234 /* We have to override this because GCC's notion of sysroot
3235 moves along with GCC. */
3239 add_prefix (pprefix
, prefix
, component
, priority
,
3240 require_machine_suffix
, os_multilib
);
3244 /* Execute the command specified by the arguments on the current line of spec.
3245 When using pipes, this includes several piped-together commands
3246 with `|' between them.
3248 Return 0 if successful, -1 if failed. */
3254 int n_commands
; /* # of command. */
3256 struct pex_obj
*pex
;
3259 const char *prog
; /* program name. */
3260 const char **argv
; /* vector of args. */
3264 struct command
*commands
; /* each command buffer with above info. */
3266 gcc_assert (!processing_spec_function
);
3270 string
= find_a_program (argbuf
[0]);
3273 insert_wrapper (wrapper_string
);
3276 /* Count # of piped commands. */
3277 for (n_commands
= 1, i
= 0; argbuf
.iterate (i
, &arg
); i
++)
3278 if (strcmp (arg
, "|") == 0)
3281 /* Get storage for each command. */
3282 commands
= XALLOCAVEC (struct command
, n_commands
);
3284 /* Split argbuf into its separate piped processes,
3285 and record info about each one.
3286 Also search for the programs that are to be run. */
3288 argbuf
.safe_push (0);
3290 commands
[0].prog
= argbuf
[0]; /* first command. */
3291 commands
[0].argv
= argbuf
.address ();
3293 if (!wrapper_string
)
3295 string
= find_a_program(commands
[0].prog
);
3297 commands
[0].argv
[0] = string
;
3300 for (n_commands
= 1, i
= 0; argbuf
.iterate (i
, &arg
); i
++)
3301 if (arg
&& strcmp (arg
, "|") == 0)
3302 { /* each command. */
3303 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
3304 fatal_error (input_location
, "%<-pipe%> not supported");
3306 argbuf
[i
] = 0; /* Termination of command args. */
3307 commands
[n_commands
].prog
= argbuf
[i
+ 1];
3308 commands
[n_commands
].argv
3309 = &(argbuf
.address ())[i
+ 1];
3310 string
= find_a_program(commands
[n_commands
].prog
);
3312 commands
[n_commands
].argv
[0] = string
;
3316 /* If -v, print what we are about to do, and maybe query. */
3320 /* For help listings, put a blank line between sub-processes. */
3321 if (print_help_list
)
3322 fputc ('\n', stderr
);
3324 /* Print each piped command as a separate line. */
3325 for (i
= 0; i
< n_commands
; i
++)
3327 const char *const *j
;
3329 if (verbose_only_flag
)
3331 for (j
= commands
[i
].argv
; *j
; j
++)
3334 for (p
= *j
; *p
; ++p
)
3335 if (!ISALNUM ((unsigned char) *p
)
3336 && *p
!= '_' && *p
!= '/' && *p
!= '-' && *p
!= '.')
3340 fprintf (stderr
, " \"");
3341 for (p
= *j
; *p
; ++p
)
3343 if (*p
== '"' || *p
== '\\' || *p
== '$')
3344 fputc ('\\', stderr
);
3347 fputc ('"', stderr
);
3349 /* If it's empty, print "". */
3351 fprintf (stderr
, " \"\"");
3353 fprintf (stderr
, " %s", *j
);
3357 for (j
= commands
[i
].argv
; *j
; j
++)
3358 /* If it's empty, print "". */
3360 fprintf (stderr
, " \"\"");
3362 fprintf (stderr
, " %s", *j
);
3364 /* Print a pipe symbol after all but the last command. */
3365 if (i
+ 1 != n_commands
)
3366 fprintf (stderr
, " |");
3367 fprintf (stderr
, "\n");
3370 if (verbose_only_flag
!= 0)
3372 /* verbose_only_flag should act as if the spec was
3373 executed, so increment execution_count before
3374 returning. This prevents spurious warnings about
3375 unused linker input files, etc. */
3380 fnotice (stderr
, "\nGo ahead? (y or n) ");
3384 while (getchar () != '\n')
3387 if (i
!= 'y' && i
!= 'Y')
3392 #ifdef ENABLE_VALGRIND_CHECKING
3393 /* Run the each command through valgrind. To simplify prepending the
3394 path to valgrind and the option "-q" (for quiet operation unless
3395 something triggers), we allocate a separate argv array. */
3397 for (i
= 0; i
< n_commands
; i
++)
3403 for (argc
= 0; commands
[i
].argv
[argc
] != NULL
; argc
++)
3406 argv
= XALLOCAVEC (const char *, argc
+ 3);
3408 argv
[0] = VALGRIND_PATH
;
3410 for (j
= 2; j
< argc
+ 2; j
++)
3411 argv
[j
] = commands
[i
].argv
[j
- 2];
3414 commands
[i
].argv
= argv
;
3415 commands
[i
].prog
= argv
[0];
3419 /* Run each piped subprocess. */
3421 pex
= pex_init (PEX_USE_PIPES
| ((report_times
|| report_times_to_file
)
3422 ? PEX_RECORD_TIMES
: 0),
3423 progname
, temp_filename
);
3425 fatal_error (input_location
, "%<pex_init%> failed: %m");
3427 for (i
= 0; i
< n_commands
; i
++)
3431 const char *string
= commands
[i
].argv
[0];
3433 errmsg
= pex_run (pex
,
3434 ((i
+ 1 == n_commands
? PEX_LAST
: 0)
3435 | (string
== commands
[i
].prog
? PEX_SEARCH
: 0)),
3436 string
, CONST_CAST (char **, commands
[i
].argv
),
3441 fatal_error (input_location
,
3442 err
? G_("cannot execute %qs: %s: %m")
3443 : G_("cannot execute %qs: %s"),
3447 if (i
&& string
!= commands
[i
].prog
)
3448 free (CONST_CAST (char *, string
));
3453 /* Wait for all the subprocesses to finish. */
3457 struct pex_time
*times
= NULL
;
3460 statuses
= XALLOCAVEC (int, n_commands
);
3461 if (!pex_get_status (pex
, n_commands
, statuses
))
3462 fatal_error (input_location
, "failed to get exit status: %m");
3464 if (report_times
|| report_times_to_file
)
3466 times
= XALLOCAVEC (struct pex_time
, n_commands
);
3467 if (!pex_get_times (pex
, n_commands
, times
))
3468 fatal_error (input_location
, "failed to get process times: %m");
3473 for (i
= 0; i
< n_commands
; ++i
)
3475 int status
= statuses
[i
];
3477 if (WIFSIGNALED (status
))
3478 switch (WTERMSIG (status
))
3482 /* SIGQUIT and SIGKILL are not available on MinGW. */
3489 /* The user (or environment) did something to the
3490 inferior. Making this an ICE confuses the user into
3491 thinking there's a compiler bug. Much more likely is
3492 the user or OOM killer nuked it. */
3493 fatal_error (input_location
,
3494 "%s signal terminated program %s",
3495 strsignal (WTERMSIG (status
)),
3501 /* SIGPIPE is a special case. It happens in -pipe mode
3502 when the compiler dies before the preprocessor is
3503 done, or the assembler dies before the compiler is
3504 done. There's generally been an error already, and
3505 this is just fallout. So don't generate another
3506 error unless we would otherwise have succeeded. */
3507 if (signal_count
|| greatest_status
>= MIN_FATAL_STATUS
)
3517 /* The inferior failed to catch the signal. */
3518 internal_error_no_backtrace ("%s signal terminated program %s",
3519 strsignal (WTERMSIG (status
)),
3522 else if (WIFEXITED (status
)
3523 && WEXITSTATUS (status
) >= MIN_FATAL_STATUS
)
3525 /* For ICEs in cc1, cc1obj, cc1plus see if it is
3526 reproducible or not. */
3529 && WEXITSTATUS (status
) == ICE_EXIT_CODE
3531 && (p
= strrchr (commands
[0].argv
[0], DIR_SEPARATOR
))
3532 && startswith (p
+ 1, "cc1"))
3533 try_generate_repro (commands
[0].argv
);
3534 if (WEXITSTATUS (status
) > greatest_status
)
3535 greatest_status
= WEXITSTATUS (status
);
3539 if (report_times
|| report_times_to_file
)
3541 struct pex_time
*pt
= ×
[i
];
3544 ut
= ((double) pt
->user_seconds
3545 + (double) pt
->user_microseconds
/ 1.0e6
);
3546 st
= ((double) pt
->system_seconds
3547 + (double) pt
->system_microseconds
/ 1.0e6
);
3552 fnotice (stderr
, "# %s %.2f %.2f\n",
3553 commands
[i
].prog
, ut
, st
);
3555 if (report_times_to_file
)
3558 const char *const *j
;
3560 fprintf (report_times_to_file
, "%g %g", ut
, st
);
3562 for (j
= &commands
[i
].prog
; *j
; j
= &commands
[i
].argv
[++c
])
3565 for (p
= *j
; *p
; ++p
)
3566 if (*p
== '"' || *p
== '\\' || *p
== '$'
3572 fprintf (report_times_to_file
, " \"");
3573 for (p
= *j
; *p
; ++p
)
3575 if (*p
== '"' || *p
== '\\' || *p
== '$')
3576 fputc ('\\', report_times_to_file
);
3577 fputc (*p
, report_times_to_file
);
3579 fputc ('"', report_times_to_file
);
3582 fprintf (report_times_to_file
, " %s", *j
);
3585 fputc ('\n', report_times_to_file
);
3591 if (commands
[0].argv
[0] != commands
[0].prog
)
3592 free (CONST_CAST (char *, commands
[0].argv
[0]));
3598 static struct switchstr
*switches
;
3600 static int n_switches
;
3602 static int n_switches_alloc
;
3604 /* Set to zero if -fcompare-debug is disabled, positive if it's
3605 enabled and we're running the first compilation, negative if it's
3606 enabled and we're running the second compilation. For most of the
3607 time, it's in the range -1..1, but it can be temporarily set to 2
3608 or 3 to indicate that the -fcompare-debug flags didn't come from
3609 the command-line, but rather from the GCC_COMPARE_DEBUG environment
3610 variable, until a synthesized -fcompare-debug flag is added to the
3614 /* Set to nonzero if we've seen the -fcompare-debug-second flag. */
3615 int compare_debug_second
;
3617 /* Set to the flags that should be passed to the second compilation in
3618 a -fcompare-debug compilation. */
3619 const char *compare_debug_opt
;
3621 static struct switchstr
*switches_debug_check
[2];
3623 static int n_switches_debug_check
[2];
3625 static int n_switches_alloc_debug_check
[2];
3627 static char *debug_check_temp_file
[2];
3629 /* Language is one of three things:
3631 1) The name of a real programming language.
3632 2) NULL, indicating that no one has figured out
3634 3) '*', indicating that the file should be passed
3639 const char *language
;
3640 struct compiler
*incompiler
;
3645 /* Also a vector of input files specified. */
3647 static struct infile
*infiles
;
3651 static int n_infiles_alloc
;
3653 /* True if undefined environment variables encountered during spec processing
3654 are ok to ignore, typically when we're running for --help or --version. */
3656 static bool spec_undefvar_allowed
;
3658 /* True if multiple input files are being compiled to a single
3661 static bool combine_inputs
;
3663 /* This counts the number of libraries added by lang_specific_driver, so that
3664 we can tell if there were any user supplied any files or libraries. */
3666 static int added_libraries
;
3668 /* And a vector of corresponding output files is made up later. */
3670 const char **outfiles
;
3672 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3674 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
3675 is true if we should look for an executable suffix. DO_OBJ
3676 is true if we should look for an object suffix. */
3679 convert_filename (const char *name
, int do_exe ATTRIBUTE_UNUSED
,
3680 int do_obj ATTRIBUTE_UNUSED
)
3682 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3690 len
= strlen (name
);
3692 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3693 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
3694 if (do_obj
&& len
> 2
3695 && name
[len
- 2] == '.'
3696 && name
[len
- 1] == 'o')
3698 obstack_grow (&obstack
, name
, len
- 2);
3699 obstack_grow0 (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
3700 name
= XOBFINISH (&obstack
, const char *);
3704 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3705 /* If there is no filetype, make it the executable suffix (which includes
3706 the "."). But don't get confused if we have just "-o". */
3707 if (! do_exe
|| TARGET_EXECUTABLE_SUFFIX
[0] == 0 || not_actual_file_p (name
))
3710 for (i
= len
- 1; i
>= 0; i
--)
3711 if (IS_DIR_SEPARATOR (name
[i
]))
3714 for (i
++; i
< len
; i
++)
3718 obstack_grow (&obstack
, name
, len
);
3719 obstack_grow0 (&obstack
, TARGET_EXECUTABLE_SUFFIX
,
3720 strlen (TARGET_EXECUTABLE_SUFFIX
));
3721 name
= XOBFINISH (&obstack
, const char *);
3728 /* Display the command line switches accepted by gcc. */
3732 printf (_("Usage: %s [options] file...\n"), progname
);
3733 fputs (_("Options:\n"), stdout
);
3735 fputs (_(" -pass-exit-codes Exit with highest error code from a phase.\n"), stdout
);
3736 fputs (_(" --help Display this information.\n"), stdout
);
3737 fputs (_(" --target-help Display target specific command line options "
3738 "(including assembler and linker options).\n"), stdout
);
3739 fputs (_(" --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...].\n"), stdout
);
3740 fputs (_(" Display specific types of command line options.\n"), stdout
);
3742 fputs (_(" (Use '-v --help' to display command line options of sub-processes).\n"), stdout
);
3743 fputs (_(" --version Display compiler version information.\n"), stdout
);
3744 fputs (_(" -dumpspecs Display all of the built in spec strings.\n"), stdout
);
3745 fputs (_(" -dumpversion Display the version of the compiler.\n"), stdout
);
3746 fputs (_(" -dumpmachine Display the compiler's target processor.\n"), stdout
);
3747 fputs (_(" -foffload=<targets> Specify offloading targets.\n"), stdout
);
3748 fputs (_(" -print-search-dirs Display the directories in the compiler's search path.\n"), stdout
);
3749 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library.\n"), stdout
);
3750 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>.\n"), stdout
);
3751 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>.\n"), stdout
);
3753 -print-multiarch Display the target's normalized GNU triplet, used as\n\
3754 a component in the library path.\n"), stdout
);
3755 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc.\n"), stdout
);
3757 -print-multi-lib Display the mapping between command line options and\n\
3758 multiple library search directories.\n"), stdout
);
3759 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries.\n"), stdout
);
3760 fputs (_(" -print-sysroot Display the target libraries directory.\n"), stdout
);
3761 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers.\n"), stdout
);
3762 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler.\n"), stdout
);
3763 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor.\n"), stdout
);
3764 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker.\n"), stdout
);
3765 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler.\n"), stdout
);
3766 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor.\n"), stdout
);
3767 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker.\n"), stdout
);
3768 fputs (_(" -save-temps Do not delete intermediate files.\n"), stdout
);
3769 fputs (_(" -save-temps=<arg> Do not delete intermediate files.\n"), stdout
);
3771 -no-canonical-prefixes Do not canonicalize paths when building relative\n\
3772 prefixes to other gcc components.\n"), stdout
);
3773 fputs (_(" -pipe Use pipes rather than intermediate files.\n"), stdout
);
3774 fputs (_(" -time Time the execution of each subprocess.\n"), stdout
);
3775 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>.\n"), stdout
);
3776 fputs (_(" -std=<standard> Assume that the input sources are for <standard>.\n"), stdout
);
3778 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3779 and libraries.\n"), stdout
);
3780 fputs (_(" -B <directory> Add <directory> to the compiler's search paths.\n"), stdout
);
3781 fputs (_(" -v Display the programs invoked by the compiler.\n"), stdout
);
3782 fputs (_(" -### Like -v but options quoted and commands not executed.\n"), stdout
);
3783 fputs (_(" -E Preprocess only; do not compile, assemble or link.\n"), stdout
);
3784 fputs (_(" -S Compile only; do not assemble or link.\n"), stdout
);
3785 fputs (_(" -c Compile and assemble, but do not link.\n"), stdout
);
3786 fputs (_(" -o <file> Place the output into <file>.\n"), stdout
);
3787 fputs (_(" -pie Create a dynamically linked position independent\n\
3788 executable.\n"), stdout
);
3789 fputs (_(" -shared Create a shared library.\n"), stdout
);
3791 -x <language> Specify the language of the following input files.\n\
3792 Permissible languages include: c c++ assembler none\n\
3793 'none' means revert to the default behavior of\n\
3794 guessing the language based on the file's extension.\n\
3798 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3799 passed on to the various sub-processes invoked by %s. In order to pass\n\
3800 other options on to these processes the -W<letter> options must be used.\n\
3803 /* The rest of the options are displayed by invocations of the various
3808 add_preprocessor_option (const char *option
, int len
)
3810 preprocessor_options
.safe_push (save_string (option
, len
));
3814 add_assembler_option (const char *option
, int len
)
3816 assembler_options
.safe_push (save_string (option
, len
));
3820 add_linker_option (const char *option
, int len
)
3822 linker_options
.safe_push (save_string (option
, len
));
3825 /* Allocate space for an input file in infiles. */
3830 if (n_infiles_alloc
== 0)
3832 n_infiles_alloc
= 16;
3833 infiles
= XNEWVEC (struct infile
, n_infiles_alloc
);
3835 else if (n_infiles_alloc
== n_infiles
)
3837 n_infiles_alloc
*= 2;
3838 infiles
= XRESIZEVEC (struct infile
, infiles
, n_infiles_alloc
);
3842 /* Store an input file with the given NAME and LANGUAGE in
3846 add_infile (const char *name
, const char *language
)
3849 infiles
[n_infiles
].name
= name
;
3850 infiles
[n_infiles
++].language
= language
;
3853 /* Allocate space for a switch in switches. */
3858 if (n_switches_alloc
== 0)
3860 n_switches_alloc
= 16;
3861 switches
= XNEWVEC (struct switchstr
, n_switches_alloc
);
3863 else if (n_switches_alloc
== n_switches
)
3865 n_switches_alloc
*= 2;
3866 switches
= XRESIZEVEC (struct switchstr
, switches
, n_switches_alloc
);
3870 /* Save an option OPT with N_ARGS arguments in array ARGS, marking it
3871 as validated if VALIDATED and KNOWN if it is an internal switch. */
3874 save_switch (const char *opt
, size_t n_args
, const char *const *args
,
3875 bool validated
, bool known
)
3878 switches
[n_switches
].part1
= opt
+ 1;
3880 switches
[n_switches
].args
= 0;
3883 switches
[n_switches
].args
= XNEWVEC (const char *, n_args
+ 1);
3884 memcpy (switches
[n_switches
].args
, args
, n_args
* sizeof (const char *));
3885 switches
[n_switches
].args
[n_args
] = NULL
;
3888 switches
[n_switches
].live_cond
= 0;
3889 switches
[n_switches
].validated
= validated
;
3890 switches
[n_switches
].known
= known
;
3891 switches
[n_switches
].ordering
= 0;
3895 /* Set the SOURCE_DATE_EPOCH environment variable to the current time if it is
3899 set_source_date_epoch_envvar ()
3901 /* Array size is 21 = ceil(log_10(2^64)) + 1 to hold string representations
3902 of 64 bit integers. */
3903 char source_date_epoch
[21];
3908 if (tt
< (time_t) 0 || errno
!= 0)
3911 snprintf (source_date_epoch
, 21, "%llu", (unsigned long long) tt
);
3912 /* Using setenv instead of xputenv because we want the variable to remain
3913 after finalizing so that it's still set in the second run when using
3915 setenv ("SOURCE_DATE_EPOCH", source_date_epoch
, 0);
3918 /* Handle an option DECODED that is unknown to the option-processing
3922 driver_unknown_option_callback (const struct cl_decoded_option
*decoded
)
3924 const char *opt
= decoded
->arg
;
3925 if (opt
[1] == 'W' && opt
[2] == 'n' && opt
[3] == 'o' && opt
[4] == '-'
3926 && !(decoded
->errors
& CL_ERR_NEGATIVE
))
3928 /* Leave unknown -Wno-* options for the compiler proper, to be
3929 diagnosed only if there are warnings. */
3930 save_switch (decoded
->canonical_option
[0],
3931 decoded
->canonical_option_num_elements
- 1,
3932 &decoded
->canonical_option
[1], false, true);
3935 if (decoded
->opt_index
== OPT_SPECIAL_unknown
)
3937 /* Give it a chance to define it a spec file. */
3938 save_switch (decoded
->canonical_option
[0],
3939 decoded
->canonical_option_num_elements
- 1,
3940 &decoded
->canonical_option
[1], false, false);
3947 /* Handle an option DECODED that is not marked as CL_DRIVER.
3948 LANG_MASK will always be CL_DRIVER. */
3951 driver_wrong_lang_callback (const struct cl_decoded_option
*decoded
,
3952 unsigned int lang_mask ATTRIBUTE_UNUSED
)
3954 /* At this point, non-driver options are accepted (and expected to
3955 be passed down by specs) unless marked to be rejected by the
3956 driver. Options to be rejected by the driver but accepted by the
3957 compilers proper are treated just like completely unknown
3959 const struct cl_option
*option
= &cl_options
[decoded
->opt_index
];
3961 if (option
->cl_reject_driver
)
3962 error ("unrecognized command-line option %qs",
3963 decoded
->orig_option_with_args_text
);
3965 save_switch (decoded
->canonical_option
[0],
3966 decoded
->canonical_option_num_elements
- 1,
3967 &decoded
->canonical_option
[1], false, true);
3970 static const char *spec_lang
= 0;
3971 static int last_language_n_infiles
;
3974 /* Check that GCC is configured to support the offload target. */
3977 check_offload_target_name (const char *target
, ptrdiff_t len
)
3979 const char *n
, *c
= OFFLOAD_TARGETS
;
3982 n
= strchr (c
, ',');
3984 n
= strchr (c
, '\0');
3985 if (len
== n
- c
&& strncmp (target
, c
, n
- c
) == 0)
3987 c
= *n
? n
+ 1 : NULL
;
3991 auto_vec
<const char*> candidates
;
3992 size_t olen
= strlen (OFFLOAD_TARGETS
) + 1;
3993 char *cand
= XALLOCAVEC (char, olen
);
3994 memcpy (cand
, OFFLOAD_TARGETS
, olen
);
3995 for (c
= strtok (cand
, ","); c
; c
= strtok (NULL
, ","))
3996 candidates
.safe_push (c
);
3997 candidates
.safe_push ("default");
3998 candidates
.safe_push ("disable");
4000 char *target2
= XALLOCAVEC (char, len
+ 1);
4001 memcpy (target2
, target
, len
);
4002 target2
[len
] = '\0';
4004 error ("GCC is not configured to support %qs as %<-foffload=%> argument",
4008 const char *hint
= candidates_list_and_hint (target2
, s
, candidates
);
4010 inform (UNKNOWN_LOCATION
,
4011 "valid %<-foffload=%> arguments are: %s; "
4012 "did you mean %qs?", s
, hint
);
4014 inform (UNKNOWN_LOCATION
, "valid %<-foffload=%> arguments are: %s", s
);
4021 /* Sanity check for -foffload-options. */
4024 check_foffload_target_names (const char *arg
)
4026 const char *cur
, *next
, *end
;
4027 /* If option argument starts with '-' then no target is specified and we
4028 do not need to parse it. */
4031 end
= strchr (arg
, '=');
4034 error ("%<=%>options missing after %<-foffload-options=%>target");
4041 next
= strchr (cur
, ',');
4044 next
= (next
> end
) ? end
: next
;
4046 /* Retain non-supported targets after printing an error as those will not
4047 be processed; each enabled target only processes its triplet. */
4048 check_offload_target_name (cur
, next
- cur
);
4053 /* Parse -foffload option argument. */
4056 handle_foffload_option (const char *arg
)
4058 const char *c
, *cur
, *n
, *next
, *end
;
4061 /* If option argument starts with '-' then no target is specified and we
4062 do not need to parse it. */
4066 end
= strchr (arg
, '=');
4068 end
= strchr (arg
, '\0');
4073 next
= strchr (cur
, ',');
4076 next
= (next
> end
) ? end
: next
;
4078 target
= XNEWVEC (char, next
- cur
+ 1);
4079 memcpy (target
, cur
, next
- cur
);
4080 target
[next
- cur
] = '\0';
4082 /* Reset offloading list and continue. */
4083 if (strcmp (target
, "default") == 0)
4085 free (offload_targets
);
4086 offload_targets
= NULL
;
4090 /* If 'disable' is passed to the option, clean the list of
4091 offload targets and return, even if more targets follow.
4092 Likewise if GCC is not configured to support that offload target. */
4093 if (strcmp (target
, "disable") == 0
4094 || !check_offload_target_name (target
, next
- cur
))
4096 free (offload_targets
);
4097 offload_targets
= xstrdup ("");
4101 if (!offload_targets
)
4103 offload_targets
= target
;
4108 /* Check that the target hasn't already presented in the list. */
4109 c
= offload_targets
;
4112 n
= strchr (c
, ':');
4114 n
= strchr (c
, '\0');
4116 if (next
- cur
== n
- c
&& strncmp (c
, target
, n
- c
) == 0)
4123 /* If duplicate is not found, append the target to the list. */
4126 size_t offload_targets_len
= strlen (offload_targets
);
4128 = XRESIZEVEC (char, offload_targets
,
4129 offload_targets_len
+ 1 + next
- cur
+ 1);
4130 offload_targets
[offload_targets_len
++] = ':';
4131 memcpy (offload_targets
+ offload_targets_len
, target
, next
- cur
+ 1);
4136 XDELETEVEC (target
);
4140 /* Forward certain options to offloading compilation. */
4143 forward_offload_option (size_t opt_index
, const char *arg
, bool validated
)
4148 /* Use a '_GCC_' prefix and standard name ('-l_GCC_m' irrespective of the
4149 host's 'MATH_LIBRARY', for example), so that the 'mkoffload's can tell
4150 this has been synthesized here, and translate/drop as necessary. */
4151 /* Note that certain libraries ('-lc', '-lgcc', '-lgomp', for example)
4152 are injected by default in offloading compilation, and therefore not
4154 /* GCC libraries. */
4155 if (/* '-lgfortran' */ strcmp (arg
, "gfortran") == 0 )
4156 save_switch (concat ("-foffload-options=-l_GCC_", arg
, NULL
),
4157 0, NULL
, validated
, true);
4158 /* Other libraries. */
4161 /* The case will need special consideration where on the host
4162 '!need_math', but for offloading compilation still need
4163 '-foffload-options=-l_GCC_m'. The problem is that we don't get
4164 here anything like '-lm', because it's not synthesized in
4165 'gcc/fortran/gfortranspec.cc:lang_specific_driver', for example.
4166 Generally synthesizing '-foffload-options=-l_GCC_m' etc. in the
4167 language specific drivers is non-trivial, needs very careful
4168 review of their options handling. However, this issue is not
4169 actually relevant for the current set of supported host/offloading
4171 int need_math
= (MATH_LIBRARY
[0] != '\0');
4172 if (/* '-lm' */ (need_math
&& strcmp (arg
, MATH_LIBRARY
) == 0))
4173 save_switch ("-foffload-options=-l_GCC_m",
4174 0, NULL
, validated
, true);
4182 /* Handle a driver option; arguments and return value as for
4186 driver_handle_option (struct gcc_options
*opts
,
4187 struct gcc_options
*opts_set
,
4188 const struct cl_decoded_option
*decoded
,
4189 unsigned int lang_mask ATTRIBUTE_UNUSED
, int kind
,
4191 const struct cl_option_handlers
*handlers ATTRIBUTE_UNUSED
,
4192 diagnostic_context
*dc
,
4195 size_t opt_index
= decoded
->opt_index
;
4196 const char *arg
= decoded
->arg
;
4197 const char *compare_debug_replacement_opt
;
4198 int value
= decoded
->value
;
4199 bool validated
= false;
4200 bool do_save
= true;
4202 gcc_assert (opts
== &global_options
);
4203 gcc_assert (opts_set
== &global_options_set
);
4204 gcc_assert (kind
== DK_UNSPECIFIED
);
4205 gcc_assert (loc
== UNKNOWN_LOCATION
);
4206 gcc_assert (dc
== global_dc
);
4212 struct spec_list
*sl
;
4214 for (sl
= specs
; sl
; sl
= sl
->next
)
4215 printf ("*%s:\n%s\n\n", sl
->name
, *(sl
->ptr_spec
));
4216 if (link_command_spec
)
4217 printf ("*link_command:\n%s\n\n", link_command_spec
);
4221 case OPT_dumpversion
:
4222 printf ("%s\n", spec_version
);
4225 case OPT_dumpmachine
:
4226 printf ("%s\n", spec_machine
);
4229 case OPT_dumpfullversion
:
4230 printf ("%s\n", BASEVER
);
4236 /* CPP driver cannot obtain switch from cc1_options. */
4238 add_preprocessor_option ("--version", strlen ("--version"));
4239 add_assembler_option ("--version", strlen ("--version"));
4240 add_linker_option ("--version", strlen ("--version"));
4243 case OPT__completion_
:
4245 completion
= decoded
->arg
;
4249 print_help_list
= 1;
4251 /* CPP driver cannot obtain switch from cc1_options. */
4253 add_preprocessor_option ("--help", 6);
4254 add_assembler_option ("--help", 6);
4255 add_linker_option ("--help", 6);
4259 print_subprocess_help
= 2;
4262 case OPT__target_help
:
4263 print_subprocess_help
= 1;
4265 /* CPP driver cannot obtain switch from cc1_options. */
4267 add_preprocessor_option ("--target-help", 13);
4268 add_assembler_option ("--target-help", 13);
4269 add_linker_option ("--target-help", 13);
4272 case OPT__no_sysroot_suffix
:
4273 case OPT_pass_exit_codes
:
4274 case OPT_print_search_dirs
:
4275 case OPT_print_file_name_
:
4276 case OPT_print_prog_name_
:
4277 case OPT_print_multi_lib
:
4278 case OPT_print_multi_directory
:
4279 case OPT_print_sysroot
:
4280 case OPT_print_multi_os_directory
:
4281 case OPT_print_multiarch
:
4282 case OPT_print_sysroot_headers_suffix
:
4285 /* These options set the variables specified in common.opt
4286 automatically, and do not need to be saved for spec
4291 case OPT_print_libgcc_file_name
:
4292 print_file_name
= "libgcc.a";
4296 case OPT_fuse_ld_bfd
:
4300 case OPT_fuse_ld_gold
:
4304 case OPT_fuse_ld_mold
:
4308 case OPT_fcompare_debug_second
:
4309 compare_debug_second
= 1;
4312 case OPT_fcompare_debug
:
4316 compare_debug_replacement_opt
= "-fcompare-debug=";
4318 goto compare_debug_with_arg
;
4321 compare_debug_replacement_opt
= "-fcompare-debug=-gtoggle";
4323 goto compare_debug_with_arg
;
4330 case OPT_fcompare_debug_
:
4331 compare_debug_replacement_opt
= decoded
->canonical_option
[0];
4332 compare_debug_with_arg
:
4333 gcc_assert (decoded
->canonical_option_num_elements
== 1);
4334 gcc_assert (arg
!= NULL
);
4339 if (compare_debug
< 0)
4340 compare_debug_opt
= NULL
;
4342 compare_debug_opt
= arg
;
4343 save_switch (compare_debug_replacement_opt
, 0, NULL
, validated
, true);
4344 set_source_date_epoch_envvar ();
4347 case OPT_fdiagnostics_color_
:
4348 diagnostic_color_init (dc
, value
);
4351 case OPT_fdiagnostics_urls_
:
4352 diagnostic_urls_init (dc
, value
);
4355 case OPT_fdiagnostics_format_
:
4357 const char *basename
= (opts
->x_dump_base_name
? opts
->x_dump_base_name
4358 : opts
->x_main_input_basename
);
4359 diagnostic_output_format_init (dc
, basename
,
4360 (enum diagnostics_output_format
)value
);
4364 case OPT_fdiagnostics_text_art_charset_
:
4365 dc
->set_text_art_charset ((enum diagnostic_text_art_charset
)value
);
4371 /* Pass the rest of this option to the assembler. */
4373 /* Split the argument at commas. */
4375 for (j
= 0; arg
[j
]; j
++)
4378 add_assembler_option (arg
+ prev
, j
- prev
);
4382 /* Record the part after the last comma. */
4383 add_assembler_option (arg
+ prev
, j
- prev
);
4391 /* Pass the rest of this option to the preprocessor. */
4393 /* Split the argument at commas. */
4395 for (j
= 0; arg
[j
]; j
++)
4398 add_preprocessor_option (arg
+ prev
, j
- prev
);
4402 /* Record the part after the last comma. */
4403 add_preprocessor_option (arg
+ prev
, j
- prev
);
4411 /* Split the argument at commas. */
4413 for (j
= 0; arg
[j
]; j
++)
4416 add_infile (save_string (arg
+ prev
, j
- prev
), "*");
4419 /* Record the part after the last comma. */
4420 add_infile (arg
+ prev
, "*");
4426 add_infile (arg
, "*");
4430 case OPT_Xpreprocessor
:
4431 add_preprocessor_option (arg
, strlen (arg
));
4435 case OPT_Xassembler
:
4436 add_assembler_option (arg
, strlen (arg
));
4441 /* POSIX allows separation of -l and the lib arg; canonicalize
4442 by concatenating -l with its arg */
4443 add_infile (concat ("-l", arg
, NULL
), "*");
4445 /* Forward to offloading compilation '-l[...]' flags for standard,
4446 well-known libraries. */
4447 /* Doing this processing here means that we don't get to see libraries
4448 injected via specs, such as '-lquadmath' injected via
4449 '[build]/[target]/libgfortran/libgfortran.spec'. However, this issue
4450 is not actually relevant for the current set of host/offloading
4452 if (ENABLE_OFFLOADING
)
4453 forward_offload_option (opt_index
, arg
, validated
);
4459 /* Similarly, canonicalize -L for linkers that may not accept
4460 separate arguments. */
4461 save_switch (concat ("-L", arg
, NULL
), 0, NULL
, validated
, true);
4466 save_switch (concat ("-F", arg
, NULL
), 0, NULL
, validated
, true);
4469 case OPT_save_temps
:
4470 if (!save_temps_flag
)
4471 save_temps_flag
= SAVE_TEMPS_DUMP
;
4475 case OPT_save_temps_
:
4476 if (strcmp (arg
, "cwd") == 0)
4477 save_temps_flag
= SAVE_TEMPS_CWD
;
4478 else if (strcmp (arg
, "obj") == 0
4479 || strcmp (arg
, "object") == 0)
4480 save_temps_flag
= SAVE_TEMPS_OBJ
;
4482 fatal_error (input_location
, "%qs is an unknown %<-save-temps%> option",
4483 decoded
->orig_option_with_args_text
);
4484 save_temps_overrides_dumpdir
= true;
4489 dumpdir
= xstrdup (arg
);
4490 save_temps_overrides_dumpdir
= false;
4495 dumpbase
= xstrdup (arg
);
4498 case OPT_dumpbase_ext
:
4499 free (dumpbase_ext
);
4500 dumpbase_ext
= xstrdup (arg
);
4503 case OPT_no_canonical_prefixes
:
4504 /* Already handled as a special case, so ignored here. */
4510 /* These options set the variables specified in common.opt
4511 automatically, but do need to be saved for spec
4517 struct user_specs
*user
= XNEW (struct user_specs
);
4519 user
->next
= (struct user_specs
*) 0;
4520 user
->filename
= arg
;
4521 if (user_specs_tail
)
4522 user_specs_tail
->next
= user
;
4524 user_specs_head
= user
;
4525 user_specs_tail
= user
;
4531 target_system_root
= arg
;
4532 target_system_root_changed
= 1;
4533 /* Saving this option is useful to let self-specs decide to
4534 provide a default one. */
4540 if (report_times_to_file
)
4541 fclose (report_times_to_file
);
4542 report_times_to_file
= fopen (arg
, "a");
4548 This is similar to -v except that there is no execution
4549 of the commands and the echoed arguments are quoted. It
4550 is intended for use in shell scripts to capture the
4551 driver-generated command line. */
4552 verbose_only_flag
++;
4559 size_t len
= strlen (arg
);
4561 /* Catch the case where the user has forgotten to append a
4562 directory separator to the path. Note, they may be using
4563 -B to add an executable name prefix, eg "i386-elf-", in
4564 order to distinguish between multiple installations of
4565 GCC in the same directory. Hence we must check to see
4566 if appending a directory separator actually makes a
4567 valid directory name. */
4568 if (!IS_DIR_SEPARATOR (arg
[len
- 1])
4569 && is_directory (arg
, false))
4571 char *tmp
= XNEWVEC (char, len
+ 2);
4573 tmp
[len
] = DIR_SEPARATOR
;
4578 add_prefix (&exec_prefixes
, arg
, NULL
,
4579 PREFIX_PRIORITY_B_OPT
, 0, 0);
4580 add_prefix (&startfile_prefixes
, arg
, NULL
,
4581 PREFIX_PRIORITY_B_OPT
, 0, 0);
4582 add_prefix (&include_prefixes
, arg
, NULL
,
4583 PREFIX_PRIORITY_B_OPT
, 0, 0);
4594 if (!strcmp (spec_lang
, "none"))
4595 /* Suppress the warning if -xnone comes after the last input
4596 file, because alternate command interfaces like g++ might
4597 find it useful to place -xnone after each input file. */
4600 last_language_n_infiles
= n_infiles
;
4606 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
4607 arg
= convert_filename (arg
, ! have_c
, 0);
4610 /* On some systems, ld cannot handle "-o" without a space. So
4611 split the option from its argument. */
4612 save_switch ("-o", 1, &arg
, validated
, true);
4616 #ifdef ENABLE_DEFAULT_PIE
4617 /* -pie is turned on by default. */
4623 any_link_options_p
= true;
4630 case OPT_static_libgcc
:
4631 case OPT_shared_libgcc
:
4632 case OPT_static_libgfortran
:
4633 case OPT_static_libquadmath
:
4634 case OPT_static_libphobos
:
4635 case OPT_static_libgm2
:
4636 case OPT_static_libstdc__
:
4637 /* These are always valid; gcc.cc itself understands the first two
4638 gfortranspec.cc understands -static-libgfortran,
4639 libgfortran.spec handles -static-libquadmath,
4640 d-spec.cc understands -static-libphobos,
4641 gm2spec.cc understands -static-libgm2,
4642 and g++spec.cc understands -static-libstdc++. */
4650 case OPT_foffload_options_
:
4651 check_foffload_target_names (arg
);
4655 handle_foffload_option (arg
);
4656 if (arg
[0] == '-' || NULL
!= strchr (arg
, '='))
4657 save_switch (concat ("-foffload-options=", arg
, NULL
),
4658 0, NULL
, validated
, true);
4663 add_infile ("--pdb=", "*");
4667 /* Various driver options need no special processing at this
4668 point, having been handled in a prescan above or being
4669 handled by specs. */
4674 save_switch (decoded
->canonical_option
[0],
4675 decoded
->canonical_option_num_elements
- 1,
4676 &decoded
->canonical_option
[1], validated
, true);
4680 /* Return true if F2 is F1 followed by a single suffix, i.e., by a
4681 period and additional characters other than a period. */
4684 adds_single_suffix_p (const char *f2
, const char *f1
)
4686 size_t len
= strlen (f1
);
4688 return (strncmp (f1
, f2
, len
) == 0
4690 && strchr (f2
+ len
+ 1, '.') == NULL
);
4693 /* Put the driver's standard set of option handlers in *HANDLERS. */
4696 set_option_handlers (struct cl_option_handlers
*handlers
)
4698 handlers
->unknown_option_callback
= driver_unknown_option_callback
;
4699 handlers
->wrong_lang_callback
= driver_wrong_lang_callback
;
4700 handlers
->num_handlers
= 3;
4701 handlers
->handlers
[0].handler
= driver_handle_option
;
4702 handlers
->handlers
[0].mask
= CL_DRIVER
;
4703 handlers
->handlers
[1].handler
= common_handle_option
;
4704 handlers
->handlers
[1].mask
= CL_COMMON
;
4705 handlers
->handlers
[2].handler
= target_handle_option
;
4706 handlers
->handlers
[2].mask
= CL_TARGET
;
4710 /* Return the index into infiles for the single non-library
4711 non-lto-wpa input file, -1 if there isn't any, or -2 if there is
4714 single_input_file_index ()
4718 for (int i
= 0; i
< n_infiles
; i
++)
4720 if (infiles
[i
].language
4721 && (infiles
[i
].language
[0] == '*'
4723 && strcmp (infiles
[i
].language
, "lto") == 0)))
4735 /* Create the vector `switches' and its contents.
4736 Store its length in `n_switches'. */
4739 process_command (unsigned int decoded_options_count
,
4740 struct cl_decoded_option
*decoded_options
)
4744 char *tooldir_prefix
, *tooldir_prefix2
;
4745 char *(*get_relative_prefix
) (const char *, const char *,
4746 const char *) = NULL
;
4747 struct cl_option_handlers handlers
;
4750 gcc_exec_prefix
= env
.get ("GCC_EXEC_PREFIX");
4754 added_libraries
= 0;
4756 /* Figure compiler version from version string. */
4758 compiler_version
= temp1
= xstrdup (version_string
);
4760 for (; *temp1
; ++temp1
)
4769 /* Handle any -no-canonical-prefixes flag early, to assign the function
4770 that builds relative prefixes. This function creates default search
4771 paths that are needed later in normal option handling. */
4773 for (j
= 1; j
< decoded_options_count
; j
++)
4775 if (decoded_options
[j
].opt_index
== OPT_no_canonical_prefixes
)
4777 get_relative_prefix
= make_relative_prefix_ignore_links
;
4781 if (! get_relative_prefix
)
4782 get_relative_prefix
= make_relative_prefix
;
4784 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
4785 see if we can create it from the pathname specified in
4786 decoded_options[0].arg. */
4788 gcc_libexec_prefix
= standard_libexec_prefix
;
4790 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
4791 if (!gcc_exec_prefix
)
4793 gcc_exec_prefix
= get_relative_prefix (decoded_options
[0].arg
,
4794 standard_bindir_prefix
,
4795 standard_exec_prefix
);
4796 gcc_libexec_prefix
= get_relative_prefix (decoded_options
[0].arg
,
4797 standard_bindir_prefix
,
4798 standard_libexec_prefix
);
4799 if (gcc_exec_prefix
)
4800 xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix
, NULL
));
4804 /* make_relative_prefix requires a program name, but
4805 GCC_EXEC_PREFIX is typically a directory name with a trailing
4806 / (which is ignored by make_relative_prefix), so append a
4808 char *tmp_prefix
= concat (gcc_exec_prefix
, "gcc", NULL
);
4809 gcc_libexec_prefix
= get_relative_prefix (tmp_prefix
,
4810 standard_exec_prefix
,
4811 standard_libexec_prefix
);
4813 /* The path is unrelocated, so fallback to the original setting. */
4814 if (!gcc_libexec_prefix
)
4815 gcc_libexec_prefix
= standard_libexec_prefix
;
4821 /* From this point onward, gcc_exec_prefix is non-null if the toolchain
4822 is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
4823 or an automatically created GCC_EXEC_PREFIX from
4824 decoded_options[0].arg. */
4826 /* Do language-specific adjustment/addition of flags. */
4827 lang_specific_driver (&decoded_options
, &decoded_options_count
,
4830 if (gcc_exec_prefix
)
4832 int len
= strlen (gcc_exec_prefix
);
4834 if (len
> (int) sizeof ("/lib/gcc/") - 1
4835 && (IS_DIR_SEPARATOR (gcc_exec_prefix
[len
-1])))
4837 temp
= gcc_exec_prefix
+ len
- sizeof ("/lib/gcc/") + 1;
4838 if (IS_DIR_SEPARATOR (*temp
)
4839 && filename_ncmp (temp
+ 1, "lib", 3) == 0
4840 && IS_DIR_SEPARATOR (temp
[4])
4841 && filename_ncmp (temp
+ 5, "gcc", 3) == 0)
4842 len
-= sizeof ("/lib/gcc/") - 1;
4845 set_std_prefix (gcc_exec_prefix
, len
);
4846 add_prefix (&exec_prefixes
, gcc_libexec_prefix
, "GCC",
4847 PREFIX_PRIORITY_LAST
, 0, 0);
4848 add_prefix (&startfile_prefixes
, gcc_exec_prefix
, "GCC",
4849 PREFIX_PRIORITY_LAST
, 0, 0);
4852 /* COMPILER_PATH and LIBRARY_PATH have values
4853 that are lists of directory names with colons. */
4855 temp
= env
.get ("COMPILER_PATH");
4858 const char *startp
, *endp
;
4859 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4861 startp
= endp
= temp
;
4864 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4866 strncpy (nstore
, startp
, endp
- startp
);
4868 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4869 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4871 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4872 nstore
[endp
- startp
+ 1] = 0;
4875 nstore
[endp
- startp
] = 0;
4876 add_prefix (&exec_prefixes
, nstore
, 0,
4877 PREFIX_PRIORITY_LAST
, 0, 0);
4878 add_prefix (&include_prefixes
, nstore
, 0,
4879 PREFIX_PRIORITY_LAST
, 0, 0);
4882 endp
= startp
= endp
+ 1;
4889 temp
= env
.get (LIBRARY_PATH_ENV
);
4890 if (temp
&& *cross_compile
== '0')
4892 const char *startp
, *endp
;
4893 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4895 startp
= endp
= temp
;
4898 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4900 strncpy (nstore
, startp
, endp
- startp
);
4902 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4903 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4905 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4906 nstore
[endp
- startp
+ 1] = 0;
4909 nstore
[endp
- startp
] = 0;
4910 add_prefix (&startfile_prefixes
, nstore
, NULL
,
4911 PREFIX_PRIORITY_LAST
, 0, 1);
4914 endp
= startp
= endp
+ 1;
4921 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
4922 temp
= env
.get ("LPATH");
4923 if (temp
&& *cross_compile
== '0')
4925 const char *startp
, *endp
;
4926 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4928 startp
= endp
= temp
;
4931 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4933 strncpy (nstore
, startp
, endp
- startp
);
4935 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4936 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4938 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4939 nstore
[endp
- startp
+ 1] = 0;
4942 nstore
[endp
- startp
] = 0;
4943 add_prefix (&startfile_prefixes
, nstore
, NULL
,
4944 PREFIX_PRIORITY_LAST
, 0, 1);
4947 endp
= startp
= endp
+ 1;
4954 /* Process the options and store input files and switches in their
4957 last_language_n_infiles
= -1;
4959 set_option_handlers (&handlers
);
4961 for (j
= 1; j
< decoded_options_count
; j
++)
4963 switch (decoded_options
[j
].opt_index
)
4975 for (j
= 1; j
< decoded_options_count
; j
++)
4977 if (decoded_options
[j
].opt_index
== OPT_SPECIAL_input_file
)
4979 const char *arg
= decoded_options
[j
].arg
;
4981 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4982 arg
= convert_filename (arg
, 0, access (arg
, F_OK
));
4984 add_infile (arg
, spec_lang
);
4989 read_cmdline_option (&global_options
, &global_options_set
,
4990 decoded_options
+ j
, UNKNOWN_LOCATION
,
4991 CL_DRIVER
, &handlers
, global_dc
);
4994 /* If the user didn't specify any, default to all configured offload
4996 if (ENABLE_OFFLOADING
&& offload_targets
== NULL
)
4998 handle_foffload_option (OFFLOAD_TARGETS
);
4999 #if OFFLOAD_DEFAULTED
5000 offload_targets_default
= true;
5004 /* TODO: check if -static -pie works and maybe use it. */
5007 if (!any_link_options_p
&& !static_p
)
5010 save_switch (LD_PIE_SPEC
, 0, NULL
, /*validated=*/true, /*known=*/false);
5012 /* These are passed straight down to collect2 so we have to break
5014 if (HAVE_LD_NOW_SUPPORT
)
5016 add_infile ("-z", "*");
5017 add_infile ("now", "*");
5019 if (HAVE_LD_RELRO_SUPPORT
)
5021 add_infile ("-z", "*");
5022 add_infile ("relro", "*");
5025 /* We can't use OPT_Whardened yet. Sigh. */
5026 else if (warn_hardened
)
5027 warning_at (UNKNOWN_LOCATION
, 0,
5028 "linker hardening options not enabled by %<-fhardened%> "
5029 "because other link options were specified on the command "
5033 /* Handle -gtoggle as it would later in toplev.cc:process_options to
5034 make the debug-level-gt spec function work as expected. */
5037 if (debug_info_level
== DINFO_LEVEL_NONE
)
5038 debug_info_level
= DINFO_LEVEL_NORMAL
;
5040 debug_info_level
= DINFO_LEVEL_NONE
;
5044 && strcmp (output_file
, "-") != 0
5045 && strcmp (output_file
, HOST_BIT_BUCKET
) != 0)
5048 for (i
= 0; i
< n_infiles
; i
++)
5049 if ((!infiles
[i
].language
|| infiles
[i
].language
[0] != '*')
5050 && canonical_filename_eq (infiles
[i
].name
, output_file
))
5051 fatal_error (input_location
,
5052 "input file %qs is the same as output file",
5056 if (output_file
!= NULL
&& output_file
[0] == '\0')
5057 fatal_error (input_location
, "output filename may not be empty");
5059 /* -dumpdir and -save-temps=* both specify the location of aux/dump
5060 outputs; the one that appears last prevails. When compiling
5061 multiple sources, an explicit dumpbase (minus -ext) may be
5062 combined with an explicit or implicit dumpdir, whereas when
5063 linking, a specified or implied link output name (minus
5064 extension) may be combined with a prevailing -save-temps=* or an
5065 otherwise implied dumpdir, but not override a prevailing
5066 -dumpdir. Primary outputs (e.g., linker output when linking
5067 without -o, or .i, .s or .o outputs when processing multiple
5068 inputs with -E, -S or -c, respectively) are NOT affected by these
5069 -save-temps=/-dump* options, always landing in the current
5070 directory and with the same basename as the input when an output
5071 name is not given, but when they're intermediate outputs, they
5072 are named like other aux outputs, so the options affect their
5075 Here are some examples. There are several more in the
5076 documentation of -o and -dump*, and some quite exhaustive tests
5077 in gcc.misc-tests/outputs.exp.
5079 When compiling any number of sources, no -dump* nor
5080 -save-temps=*, all outputs in cwd without prefix:
5082 # gcc -c b.c -gsplit-dwarf
5083 -> cc1 [-dumpdir ./] -dumpbase b.c -dumpbase-ext .c # b.o b.dwo
5085 # gcc -c b.c d.c -gsplit-dwarf
5086 -> cc1 [-dumpdir ./] -dumpbase b.c -dumpbase-ext .c # b.o b.dwo
5087 && cc1 [-dumpdir ./] -dumpbase d.c -dumpbase-ext .c # d.o d.dwo
5089 When compiling and linking, no -dump* nor -save-temps=*, .o
5090 outputs are temporary, aux outputs land in the dir of the output,
5091 prefixed with the basename of the linker output:
5093 # gcc b.c d.c -o ab -gsplit-dwarf
5094 -> cc1 -dumpdir ab- -dumpbase b.c -dumpbase-ext .c # ab-b.dwo
5095 && cc1 -dumpdir ab- -dumpbase d.c -dumpbase-ext .c # ab-d.dwo
5098 # gcc b.c d.c [-o a.out] -gsplit-dwarf
5099 -> cc1 -dumpdir a- -dumpbase b.c -dumpbase-ext .c # a-b.dwo
5100 && cc1 -dumpdir a- -dumpbase d.c -dumpbase-ext .c # a-d.dwo
5101 && link ... [-o a.out]
5103 When compiling and linking, a prevailing -dumpdir fully overrides
5104 the prefix of aux outputs given by the output name:
5106 # gcc -dumpdir f b.c d.c -gsplit-dwarf [-o [dir/]whatever]
5107 -> cc1 -dumpdir f -dumpbase b.c -dumpbase-ext .c # fb.dwo
5108 && cc1 -dumpdir f -dumpbase d.c -dumpbase-ext .c # fd.dwo
5109 && link ... [-o whatever]
5111 When compiling multiple inputs, an explicit -dumpbase is combined
5112 with -dumpdir, affecting aux outputs, but not the .o outputs:
5114 # gcc -dumpdir f -dumpbase g- b.c d.c -gsplit-dwarf -c
5115 -> cc1 -dumpdir fg- -dumpbase b.c -dumpbase-ext .c # b.o fg-b.dwo
5116 && cc1 -dumpdir fg- -dumpbase d.c -dumpbase-ext .c # d.o fg-d.dwo
5118 When compiling and linking with -save-temps, the .o outputs that
5119 would have been temporary become aux outputs, so they get
5120 affected by -dump* flags:
5122 # gcc -dumpdir f -dumpbase g- -save-temps b.c d.c
5123 -> cc1 -dumpdir fg- -dumpbase b.c -dumpbase-ext .c # fg-b.o
5124 && cc1 -dumpdir fg- -dumpbase d.c -dumpbase-ext .c # fg-d.o
5127 If -save-temps=* prevails over -dumpdir, however, the explicit
5128 -dumpdir is discarded, as if it wasn't there. The basename of
5129 the implicit linker output, a.out or a.exe, becomes a- as the aux
5130 output prefix for all compilations:
5132 # gcc [-dumpdir f] -save-temps=cwd b.c d.c
5133 -> cc1 -dumpdir a- -dumpbase b.c -dumpbase-ext .c # a-b.o
5134 && cc1 -dumpdir a- -dumpbase d.c -dumpbase-ext .c # a-d.o
5137 A single -dumpbase, applying to multiple inputs, overrides the
5138 linker output name, implied or explicit, as the aux output prefix:
5140 # gcc [-dumpdir f] -dumpbase g- -save-temps=cwd b.c d.c
5141 -> cc1 -dumpdir g- -dumpbase b.c -dumpbase-ext .c # g-b.o
5142 && cc1 -dumpdir g- -dumpbase d.c -dumpbase-ext .c # g-d.o
5145 # gcc [-dumpdir f] -dumpbase g- -save-temps=cwd b.c d.c -o dir/h.out
5146 -> cc1 -dumpdir g- -dumpbase b.c -dumpbase-ext .c # g-b.o
5147 && cc1 -dumpdir g- -dumpbase d.c -dumpbase-ext .c # g-d.o
5148 && link -o dir/h.out
5150 Now, if the linker output is NOT overridden as a prefix, but
5151 -save-temps=* overrides implicit or explicit -dumpdir, the
5152 effective dump dir combines the dir selected by the -save-temps=*
5153 option with the basename of the specified or implied link output:
5155 # gcc [-dumpdir f] -save-temps=cwd b.c d.c -o dir/h.out
5156 -> cc1 -dumpdir h- -dumpbase b.c -dumpbase-ext .c # h-b.o
5157 && cc1 -dumpdir h- -dumpbase d.c -dumpbase-ext .c # h-d.o
5158 && link -o dir/h.out
5160 # gcc [-dumpdir f] -save-temps=obj b.c d.c -o dir/h.out
5161 -> cc1 -dumpdir dir/h- -dumpbase b.c -dumpbase-ext .c # dir/h-b.o
5162 && cc1 -dumpdir dir/h- -dumpbase d.c -dumpbase-ext .c # dir/h-d.o
5163 && link -o dir/h.out
5165 But then again, a single -dumpbase applying to multiple inputs
5166 gets used instead of the linker output basename in the combined
5169 # gcc [-dumpdir f] -dumpbase g- -save-temps=obj b.c d.c -o dir/h.out
5170 -> cc1 -dumpdir dir/g- -dumpbase b.c -dumpbase-ext .c # dir/g-b.o
5171 && cc1 -dumpdir dir/g- -dumpbase d.c -dumpbase-ext .c # dir/g-d.o
5172 && link -o dir/h.out
5174 With a single input being compiled, the output basename does NOT
5175 affect the dumpdir prefix.
5177 # gcc -save-temps=obj b.c -gsplit-dwarf -c -o dir/b.o
5178 -> cc1 -dumpdir dir/ -dumpbase b.c -dumpbase-ext .c # dir/b.o dir/b.dwo
5180 but when compiling and linking even a single file, it does:
5182 # gcc -save-temps=obj b.c -o dir/h.out
5183 -> cc1 -dumpdir dir/h- -dumpbase b.c -dumpbase-ext .c # dir/h-b.o
5185 unless an explicit -dumpdir prevails:
5187 # gcc -save-temps[=obj] -dumpdir g- b.c -o dir/h.out
5188 -> cc1 -dumpdir g- -dumpbase b.c -dumpbase-ext .c # g-b.o
5192 bool explicit_dumpdir
= dumpdir
;
5194 if ((!save_temps_overrides_dumpdir
&& explicit_dumpdir
)
5195 || (output_file
&& not_actual_file_p (output_file
)))
5200 /* If -save-temps=obj and -o name, create the prefix to use for %b.
5201 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
5202 else if (save_temps_flag
!= SAVE_TEMPS_CWD
&& output_file
!= NULL
)
5206 temp
= lbasename (output_file
);
5207 if (temp
!= output_file
)
5208 dumpdir
= xstrndup (output_file
,
5209 strlen (output_file
) - strlen (temp
));
5217 if (save_temps_flag
)
5218 save_temps_flag
= SAVE_TEMPS_DUMP
;
5220 /* If there is any pathname component in an explicit -dumpbase, it
5221 overrides dumpdir entirely, so discard it right away. Although
5222 the presence of an explicit -dumpdir matters for the driver, it
5223 shouldn't matter for other processes, that get all that's needed
5224 from the -dumpdir and -dumpbase always passed to them. */
5225 if (dumpdir
&& dumpbase
&& lbasename (dumpbase
) != dumpbase
)
5231 /* Check that dumpbase_ext matches the end of dumpbase, drop it
5233 if (dumpbase_ext
&& dumpbase
&& *dumpbase
)
5235 int lendb
= strlen (dumpbase
);
5236 int lendbx
= strlen (dumpbase_ext
);
5238 /* -dumpbase-ext must be a suffix proper; discard it if it
5239 matches all of -dumpbase, as that would make for an empty
5242 || strcmp (dumpbase
+ lendb
- lendbx
, dumpbase_ext
) != 0)
5244 free (dumpbase_ext
);
5245 dumpbase_ext
= NULL
;
5249 /* -dumpbase with multiple sources goes into dumpdir. With a single
5250 source, it does only if linking and if dumpdir was not explicitly
5252 if (dumpbase
&& *dumpbase
5253 && (single_input_file_index () == -2
5254 || (!have_c
&& !explicit_dumpdir
)))
5259 /* We checked that they match above. */
5260 dumpbase
[strlen (dumpbase
) - strlen (dumpbase_ext
)] = '\0';
5263 prefix
= concat (dumpdir
, dumpbase
, "-", NULL
);
5265 prefix
= concat (dumpbase
, "-", NULL
);
5269 free (dumpbase_ext
);
5270 dumpbase
= dumpbase_ext
= NULL
;
5272 dumpdir_trailing_dash_added
= true;
5275 /* If dumpbase was not brought into dumpdir but we're linking, bring
5276 output_file into dumpdir unless dumpdir was explicitly specified.
5277 The test for !explicit_dumpdir is further below, because we want
5278 to use the obase computation for a ghost outbase, passed to
5279 GCC_COLLECT_OPTIONS. */
5280 else if (!have_c
&& (!explicit_dumpdir
|| (dumpbase
&& !*dumpbase
)))
5282 /* If we get here, we know dumpbase was not specified, or it was
5283 specified as an empty string. If it was anything else, it
5284 would have combined with dumpdir above, because the condition
5285 for dumpbase to be used when present is broader than the
5286 condition that gets us here. */
5287 gcc_assert (!dumpbase
|| !*dumpbase
);
5290 char *tofree
= NULL
;
5291 if (!output_file
|| not_actual_file_p (output_file
))
5295 obase
= lbasename (output_file
);
5296 size_t blen
= strlen (obase
), xlen
;
5297 /* Drop the suffix if it's dumpbase_ext, if given,
5298 otherwise .exe or the target executable suffix, or if the
5299 output was explicitly named a.out, but not otherwise. */
5301 ? (blen
> (xlen
= strlen (dumpbase_ext
))
5302 && strcmp ((temp
= (obase
+ blen
- xlen
)),
5304 : ((temp
= strrchr (obase
+ 1, '.'))
5305 && (xlen
= strlen (temp
))
5306 && (strcmp (temp
, ".exe") == 0
5307 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
5308 || strcmp (temp
, TARGET_EXECUTABLE_SUFFIX
) == 0
5310 || strcmp (obase
, "a.out") == 0)))
5312 tofree
= xstrndup (obase
, blen
- xlen
);
5317 /* We wish to save this basename to the -dumpdir passed through
5318 GCC_COLLECT_OPTIONS within maybe_run_linker, for e.g. LTO,
5319 but we do NOT wish to add it to e.g. %b, so we keep
5320 outbase_length as zero. */
5321 gcc_assert (!outbase
);
5324 /* If we're building [dir1/]foo[.exe] out of a single input
5325 [dir2/]foo.c that shares the same basename, dump to
5326 [dir2/]foo.c.* rather than duplicating the basename into
5327 [dir2/]foo-foo.c.*. */
5330 || ((idxin
= single_input_file_index ()) >= 0
5331 && adds_single_suffix_p (lbasename (infiles
[idxin
].name
),
5334 if (obase
== tofree
)
5338 outbase
= xstrdup (obase
);
5341 obase
= tofree
= NULL
;
5347 char *p
= concat (dumpdir
, obase
, "-", NULL
);
5352 dumpdir
= concat (obase
, "-", NULL
);
5354 dumpdir_trailing_dash_added
= true;
5357 obase
= tofree
= NULL
;
5360 if (!explicit_dumpdir
|| dumpbase
)
5362 /* Absent -dumpbase and present -dumpbase-ext have been applied
5363 to the linker output name, so compute fresh defaults for each
5365 free (dumpbase_ext
);
5366 dumpbase_ext
= NULL
;
5370 /* Now, if we're compiling, or if we haven't used the dumpbase
5371 above, then outbase (%B) is derived from dumpbase, if given, or
5372 from the output name, given or implied. We can't precompute
5373 implied output names, but that's ok, since they're derived from
5374 input names. Just make sure we skip this if dumpbase is the
5375 empty string: we want to use input names then, so don't set
5377 if ((dumpbase
|| have_c
)
5378 && !(dumpbase
&& !*dumpbase
))
5380 gcc_assert (!outbase
);
5384 gcc_assert (single_input_file_index () != -2);
5385 /* We do not want lbasename here; dumpbase with dirnames
5386 overrides dumpdir entirely, even if dumpdir is
5389 /* We've already checked above that the suffix matches. */
5390 outbase
= xstrndup (dumpbase
,
5391 strlen (dumpbase
) - strlen (dumpbase_ext
));
5393 outbase
= xstrdup (dumpbase
);
5395 else if (output_file
&& !not_actual_file_p (output_file
))
5397 outbase
= xstrdup (lbasename (output_file
));
5398 char *p
= strrchr (outbase
+ 1, '.');
5404 outbase_length
= strlen (outbase
);
5407 /* If there is any pathname component in an explicit -dumpbase, do
5408 not use dumpdir, but retain it to pass it on to the compiler. */
5410 dumpdir_length
= strlen (dumpdir
);
5414 /* Check that dumpbase_ext, if still present, still matches the end
5415 of dumpbase, if present, and drop it otherwise. We only retained
5416 it above when dumpbase was absent to maybe use it to drop the
5417 extension from output_name before combining it with dumpdir. We
5418 won't deal with -dumpbase-ext when -dumpbase is not explicitly
5419 given, even if just to activate backward-compatible dumpbase:
5420 dropping it on the floor is correct, expected and documented
5421 behavior. Attempting to deal with a -dumpbase-ext that might
5422 match the end of some input filename, or of the combination of
5423 the output basename with the suffix of the input filename,
5424 possible with an intermediate .gk extension for -fcompare-debug,
5425 is just calling for trouble. */
5428 if (!dumpbase
|| !*dumpbase
)
5430 free (dumpbase_ext
);
5431 dumpbase_ext
= NULL
;
5434 gcc_assert (strcmp (dumpbase
+ strlen (dumpbase
)
5435 - strlen (dumpbase_ext
), dumpbase_ext
) == 0);
5438 if (save_temps_flag
&& use_pipes
)
5440 /* -save-temps overrides -pipe, so that temp files are produced */
5441 if (save_temps_flag
)
5442 warning (0, "%<-pipe%> ignored because %<-save-temps%> specified");
5448 const char *gcd
= env
.get ("GCC_COMPARE_DEBUG");
5450 if (gcd
&& gcd
[0] == '-')
5453 compare_debug_opt
= gcd
;
5455 else if (gcd
&& *gcd
&& strcmp (gcd
, "0"))
5458 compare_debug_opt
= "-gtoggle";
5461 else if (compare_debug
< 0)
5464 gcc_assert (!compare_debug_opt
);
5467 /* Set up the search paths. We add directories that we expect to
5468 contain GNU Toolchain components before directories specified by
5469 the machine description so that we will find GNU components (like
5470 the GNU assembler) before those of the host system. */
5472 /* If we don't know where the toolchain has been installed, use the
5473 configured-in locations. */
5474 if (!gcc_exec_prefix
)
5477 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "GCC",
5478 PREFIX_PRIORITY_LAST
, 1, 0);
5479 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "BINUTILS",
5480 PREFIX_PRIORITY_LAST
, 2, 0);
5481 add_prefix (&exec_prefixes
, standard_exec_prefix
, "BINUTILS",
5482 PREFIX_PRIORITY_LAST
, 2, 0);
5484 add_prefix (&startfile_prefixes
, standard_exec_prefix
, "BINUTILS",
5485 PREFIX_PRIORITY_LAST
, 1, 0);
5488 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix
));
5489 tooldir_prefix2
= concat (tooldir_base_prefix
, spec_machine
,
5490 dir_separator_str
, NULL
);
5492 /* Look for tools relative to the location from which the driver is
5493 running, or, if that is not available, the configured prefix. */
5495 = concat (gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
5496 spec_host_machine
, dir_separator_str
, spec_version
,
5497 accel_dir_suffix
, dir_separator_str
, tooldir_prefix2
, NULL
);
5498 free (tooldir_prefix2
);
5500 add_prefix (&exec_prefixes
,
5501 concat (tooldir_prefix
, "bin", dir_separator_str
, NULL
),
5502 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 0);
5503 add_prefix (&startfile_prefixes
,
5504 concat (tooldir_prefix
, "lib", dir_separator_str
, NULL
),
5505 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 1);
5506 free (tooldir_prefix
);
5508 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
5509 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
5510 then consider it to relocate with the rest of the GCC installation
5511 if GCC_EXEC_PREFIX is set.
5512 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
5513 if (target_system_root
&& !target_system_root_changed
&& gcc_exec_prefix
)
5515 char *tmp_prefix
= get_relative_prefix (decoded_options
[0].arg
,
5516 standard_bindir_prefix
,
5517 target_system_root
);
5518 if (tmp_prefix
&& access_check (tmp_prefix
, F_OK
) == 0)
5520 target_system_root
= tmp_prefix
;
5521 target_system_root_changed
= 1;
5526 /* More prefixes are enabled in main, after we read the specs file
5527 and determine whether this is cross-compilation or not. */
5529 if (n_infiles
!= 0 && n_infiles
== last_language_n_infiles
&& spec_lang
!= 0)
5530 warning (0, "%<-x %s%> after last input file has no effect", spec_lang
);
5532 /* Synthesize -fcompare-debug flag from the GCC_COMPARE_DEBUG
5533 environment variable. */
5534 if (compare_debug
== 2 || compare_debug
== 3)
5536 const char *opt
= concat ("-fcompare-debug=", compare_debug_opt
, NULL
);
5537 save_switch (opt
, 0, NULL
, false, true);
5541 /* Ensure we only invoke each subprocess once. */
5543 && (print_subprocess_help
|| print_help_list
|| print_version
))
5545 /* Create a dummy input file, so that we can pass
5546 the help option on to the various sub-processes. */
5547 add_infile ("help-dummy", "c");
5550 /* Decide if undefined variable references are allowed in specs. */
5552 /* -v alone is safe. --version and --help alone or together are safe. Note
5553 that -v would make them unsafe, as they'd then be run for subprocesses as
5554 well, the location of which might depend on variables possibly coming
5555 from self-specs. Note also that the command name is counted in
5556 decoded_options_count. */
5558 unsigned help_version_count
= 0;
5561 help_version_count
++;
5563 if (print_help_list
)
5564 help_version_count
++;
5566 spec_undefvar_allowed
=
5567 ((verbose_flag
&& decoded_options_count
== 2)
5568 || help_version_count
== decoded_options_count
- 1);
5571 switches
[n_switches
].part1
= 0;
5573 infiles
[n_infiles
].name
= 0;
5576 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
5577 and place that in the environment. */
5580 set_collect_gcc_options (void)
5585 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
5587 obstack_grow (&collect_obstack
, "COLLECT_GCC_OPTIONS=",
5588 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
5591 for (i
= 0; (int) i
< n_switches
; i
++)
5593 const char *const *args
;
5596 obstack_grow (&collect_obstack
, " ", 1);
5600 /* Ignore elided switches. */
5601 if ((switches
[i
].live_cond
5602 & (SWITCH_IGNORE
| SWITCH_KEEP_FOR_GCC
))
5606 obstack_grow (&collect_obstack
, "'-", 2);
5607 q
= switches
[i
].part1
;
5608 while ((p
= strchr (q
, '\'')))
5610 obstack_grow (&collect_obstack
, q
, p
- q
);
5611 obstack_grow (&collect_obstack
, "'\\''", 4);
5614 obstack_grow (&collect_obstack
, q
, strlen (q
));
5615 obstack_grow (&collect_obstack
, "'", 1);
5617 for (args
= switches
[i
].args
; args
&& *args
; args
++)
5619 obstack_grow (&collect_obstack
, " '", 2);
5621 while ((p
= strchr (q
, '\'')))
5623 obstack_grow (&collect_obstack
, q
, p
- q
);
5624 obstack_grow (&collect_obstack
, "'\\''", 4);
5627 obstack_grow (&collect_obstack
, q
, strlen (q
));
5628 obstack_grow (&collect_obstack
, "'", 1);
5635 obstack_grow (&collect_obstack
, " ", 1);
5638 obstack_grow (&collect_obstack
, "'-dumpdir' '", 12);
5642 while ((p
= strchr (q
, '\'')))
5644 obstack_grow (&collect_obstack
, q
, p
- q
);
5645 obstack_grow (&collect_obstack
, "'\\''", 4);
5648 obstack_grow (&collect_obstack
, q
, strlen (q
));
5650 obstack_grow (&collect_obstack
, "'", 1);
5653 obstack_grow (&collect_obstack
, "\0", 1);
5654 xputenv (XOBFINISH (&collect_obstack
, char *));
5657 /* Process a spec string, accumulating and running commands. */
5659 /* These variables describe the input file name.
5660 input_file_number is the index on outfiles of this file,
5661 so that the output file name can be stored for later use by %o.
5662 input_basename is the start of the part of the input file
5663 sans all directory names, and basename_length is the number
5664 of characters starting there excluding the suffix .c or whatever. */
5666 static const char *gcc_input_filename
;
5667 static int input_file_number
;
5668 size_t input_filename_length
;
5669 static int basename_length
;
5670 static int suffixed_basename_length
;
5671 static const char *input_basename
;
5672 static const char *input_suffix
;
5673 #ifndef HOST_LACKS_INODE_NUMBERS
5674 static struct stat input_stat
;
5676 static int input_stat_set
;
5678 /* The compiler used to process the current input file. */
5679 static struct compiler
*input_file_compiler
;
5681 /* These are variables used within do_spec and do_spec_1. */
5683 /* Nonzero if an arg has been started and not yet terminated
5684 (with space, tab or newline). */
5685 static int arg_going
;
5687 /* Nonzero means %d or %g has been seen; the next arg to be terminated
5688 is a temporary file name. */
5689 static int delete_this_arg
;
5691 /* Nonzero means %w has been seen; the next arg to be terminated
5692 is the output file name of this compilation. */
5693 static int this_is_output_file
;
5695 /* Nonzero means %s has been seen; the next arg to be terminated
5696 is the name of a library file and we should try the standard
5697 search dirs for it. */
5698 static int this_is_library_file
;
5700 /* Nonzero means %T has been seen; the next arg to be terminated
5701 is the name of a linker script and we should try all of the
5702 standard search dirs for it. If it is found insert a --script
5703 command line switch and then substitute the full path in place,
5704 otherwise generate an error message. */
5705 static int this_is_linker_script
;
5707 /* Nonzero means that the input of this command is coming from a pipe. */
5708 static int input_from_pipe
;
5710 /* Nonnull means substitute this for any suffix when outputting a switches
5712 static const char *suffix_subst
;
5714 /* If there is an argument being accumulated, terminate it and store it. */
5717 end_going_arg (void)
5723 obstack_1grow (&obstack
, 0);
5724 string
= XOBFINISH (&obstack
, const char *);
5725 if (this_is_library_file
)
5726 string
= find_file (string
);
5727 if (this_is_linker_script
)
5729 char * full_script_path
= find_a_file (&startfile_prefixes
, string
, R_OK
, true);
5731 if (full_script_path
== NULL
)
5733 error ("unable to locate default linker script %qs in the library search paths", string
);
5734 /* Script was not found on search path. */
5737 store_arg ("--script", false, false);
5738 string
= full_script_path
;
5740 store_arg (string
, delete_this_arg
, this_is_output_file
);
5741 if (this_is_output_file
)
5742 outfiles
[input_file_number
] = string
;
5748 /* Parse the WRAPPER string which is a comma separated list of the command line
5749 and insert them into the beginning of argbuf. */
5752 insert_wrapper (const char *wrapper
)
5756 char *buf
= xstrdup (wrapper
);
5758 unsigned int old_length
= argbuf
.length ();
5766 while ((p
= strchr (p
, ',')) != NULL
);
5768 argbuf
.safe_grow (old_length
+ n
, true);
5769 memmove (argbuf
.address () + n
,
5771 old_length
* sizeof (const_char_p
));
5785 while ((p
= strchr (p
, ',')) != NULL
);
5786 gcc_assert (i
== n
);
5789 /* Process the spec SPEC and run the commands specified therein.
5790 Returns 0 if the spec is successfully processed; -1 if failed. */
5793 do_spec (const char *spec
)
5797 value
= do_spec_2 (spec
, NULL
);
5799 /* Force out any unfinished command.
5800 If -pipe, this forces out the last command if it ended in `|'. */
5803 if (argbuf
.length () > 0
5804 && !strcmp (argbuf
.last (), "|"))
5807 set_collect_gcc_options ();
5809 if (argbuf
.length () > 0)
5816 /* Process the spec SPEC, with SOFT_MATCHED_PART designating the current value
5817 of a matched * pattern which may be re-injected by way of %*. */
5820 do_spec_2 (const char *spec
, const char *soft_matched_part
)
5826 delete_this_arg
= 0;
5827 this_is_output_file
= 0;
5828 this_is_library_file
= 0;
5829 this_is_linker_script
= 0;
5830 input_from_pipe
= 0;
5831 suffix_subst
= NULL
;
5833 result
= do_spec_1 (spec
, 0, soft_matched_part
);
5840 /* Process the given spec string and add any new options to the end
5841 of the switches/n_switches array. */
5844 do_option_spec (const char *name
, const char *spec
)
5846 unsigned int i
, value_count
, value_len
;
5847 const char *p
, *q
, *value
;
5848 char *tmp_spec
, *tmp_spec_p
;
5850 if (configure_default_options
[0].name
== NULL
)
5853 for (i
= 0; i
< ARRAY_SIZE (configure_default_options
); i
++)
5854 if (strcmp (configure_default_options
[i
].name
, name
) == 0)
5856 if (i
== ARRAY_SIZE (configure_default_options
))
5859 value
= configure_default_options
[i
].value
;
5860 value_len
= strlen (value
);
5862 /* Compute the size of the final spec. */
5865 while ((p
= strstr (p
, "%(VALUE)")) != NULL
)
5871 /* Replace each %(VALUE) by the specified value. */
5872 tmp_spec
= (char *) alloca (strlen (spec
) + 1
5873 + value_count
* (value_len
- strlen ("%(VALUE)")));
5874 tmp_spec_p
= tmp_spec
;
5876 while ((p
= strstr (q
, "%(VALUE)")) != NULL
)
5878 memcpy (tmp_spec_p
, q
, p
- q
);
5879 tmp_spec_p
= tmp_spec_p
+ (p
- q
);
5880 memcpy (tmp_spec_p
, value
, value_len
);
5881 tmp_spec_p
+= value_len
;
5882 q
= p
+ strlen ("%(VALUE)");
5884 strcpy (tmp_spec_p
, q
);
5886 do_self_spec (tmp_spec
);
5889 /* Process the given spec string and add any new options to the end
5890 of the switches/n_switches array. */
5893 do_self_spec (const char *spec
)
5897 do_spec_2 (spec
, NULL
);
5898 do_spec_1 (" ", 0, NULL
);
5900 /* Mark %<S switches processed by do_self_spec to be ignored permanently.
5901 do_self_specs adds the replacements to switches array, so it shouldn't
5902 be processed afterwards. */
5903 for (i
= 0; i
< n_switches
; i
++)
5904 if ((switches
[i
].live_cond
& SWITCH_IGNORE
))
5905 switches
[i
].live_cond
|= SWITCH_IGNORE_PERMANENTLY
;
5907 if (argbuf
.length () > 0)
5909 const char **argbuf_copy
;
5910 struct cl_decoded_option
*decoded_options
;
5911 struct cl_option_handlers handlers
;
5912 unsigned int decoded_options_count
;
5915 /* Create a copy of argbuf with a dummy argv[0] entry for
5916 decode_cmdline_options_to_array. */
5917 argbuf_copy
= XNEWVEC (const char *,
5918 argbuf
.length () + 1);
5919 argbuf_copy
[0] = "";
5920 memcpy (argbuf_copy
+ 1, argbuf
.address (),
5921 argbuf
.length () * sizeof (const char *));
5923 decode_cmdline_options_to_array (argbuf
.length () + 1,
5925 CL_DRIVER
, &decoded_options
,
5926 &decoded_options_count
);
5929 set_option_handlers (&handlers
);
5931 for (j
= 1; j
< decoded_options_count
; j
++)
5933 switch (decoded_options
[j
].opt_index
)
5935 case OPT_SPECIAL_input_file
:
5936 /* Specs should only generate options, not input
5938 if (strcmp (decoded_options
[j
].arg
, "-") != 0)
5939 fatal_error (input_location
,
5940 "switch %qs does not start with %<-%>",
5941 decoded_options
[j
].arg
);
5943 fatal_error (input_location
,
5944 "spec-generated switch is just %<-%>");
5947 case OPT_fcompare_debug_second
:
5948 case OPT_fcompare_debug
:
5949 case OPT_fcompare_debug_
:
5951 /* Avoid duplicate processing of some options from
5952 compare-debug specs; just save them here. */
5953 save_switch (decoded_options
[j
].canonical_option
[0],
5954 (decoded_options
[j
].canonical_option_num_elements
5956 &decoded_options
[j
].canonical_option
[1], false, true);
5960 read_cmdline_option (&global_options
, &global_options_set
,
5961 decoded_options
+ j
, UNKNOWN_LOCATION
,
5962 CL_DRIVER
, &handlers
, global_dc
);
5967 free (decoded_options
);
5970 switches
[n_switches
].part1
= 0;
5974 /* Callback for processing %D and %I specs. */
5976 struct spec_path_info
{
5981 bool separate_options
;
5986 spec_path (char *path
, void *data
)
5988 struct spec_path_info
*info
= (struct spec_path_info
*) data
;
5992 /* The path must exist; we want to resolve it to the realpath so that this
5993 can be embedded as a runpath. */
5994 if (info
->realpaths
)
5995 path
= lrealpath (path
);
5997 /* However, if we failed to resolve it - perhaps because there was a bogus
5998 -B option on the command line, then punt on this entry. */
6002 if (info
->omit_relative
&& !IS_ABSOLUTE_PATH (path
))
6005 if (info
->append_len
!= 0)
6007 len
= strlen (path
);
6008 memcpy (path
+ len
, info
->append
, info
->append_len
+ 1);
6011 if (!is_directory (path
, true))
6014 do_spec_1 (info
->option
, 1, NULL
);
6015 if (info
->separate_options
)
6016 do_spec_1 (" ", 0, NULL
);
6018 if (info
->append_len
== 0)
6020 len
= strlen (path
);
6021 save
= path
[len
- 1];
6022 if (IS_DIR_SEPARATOR (path
[len
- 1]))
6023 path
[len
- 1] = '\0';
6026 do_spec_1 (path
, 1, NULL
);
6027 do_spec_1 (" ", 0, NULL
);
6029 /* Must not damage the original path. */
6030 if (info
->append_len
== 0)
6031 path
[len
- 1] = save
;
6036 /* True if we should compile INFILE. */
6039 compile_input_file_p (struct infile
*infile
)
6041 if ((!infile
->language
) || (infile
->language
[0] != '*'))
6042 if (infile
->incompiler
== input_file_compiler
)
6047 /* Process each member of VEC as a spec. */
6050 do_specs_vec (vec
<char_p
> vec
)
6052 for (char *opt
: vec
)
6054 do_spec_1 (opt
, 1, NULL
);
6055 /* Make each accumulated option a separate argument. */
6056 do_spec_1 (" ", 0, NULL
);
6060 /* Add options passed via -Xassembler or -Wa to COLLECT_AS_OPTIONS. */
6063 putenv_COLLECT_AS_OPTIONS (vec
<char_p
> vec
)
6065 if (vec
.is_empty ())
6068 obstack_init (&collect_obstack
);
6069 obstack_grow (&collect_obstack
, "COLLECT_AS_OPTIONS=",
6070 strlen ("COLLECT_AS_OPTIONS="));
6075 FOR_EACH_VEC_ELT (vec
, ix
, opt
)
6077 obstack_1grow (&collect_obstack
, '\'');
6078 obstack_grow (&collect_obstack
, opt
, strlen (opt
));
6079 obstack_1grow (&collect_obstack
, '\'');
6080 if (ix
< vec
.length () - 1)
6081 obstack_1grow(&collect_obstack
, ' ');
6084 obstack_1grow (&collect_obstack
, '\0');
6085 xputenv (XOBFINISH (&collect_obstack
, char *));
6088 /* Process the sub-spec SPEC as a portion of a larger spec.
6089 This is like processing a whole spec except that we do
6090 not initialize at the beginning and we do not supply a
6091 newline by default at the end.
6092 INSWITCH nonzero means don't process %-sequences in SPEC;
6093 in this case, % is treated as an ordinary character.
6094 This is used while substituting switches.
6095 INSWITCH nonzero also causes SPC not to terminate an argument.
6097 Value is zero unless a line was finished
6098 and the command on that line reported an error. */
6101 do_spec_1 (const char *spec
, int inswitch
, const char *soft_matched_part
)
6103 const char *p
= spec
;
6108 /* If it's an empty string argument to a switch, keep it as is. */
6109 if (inswitch
&& !*p
)
6113 /* If substituting a switch, treat all chars like letters.
6114 Otherwise, NL, SPC, TAB and % are special. */
6115 switch (inswitch
? 'a' : c
)
6120 if (argbuf
.length () > 0
6121 && !strcmp (argbuf
.last (), "|"))
6123 /* A `|' before the newline means use a pipe here,
6124 but only if -pipe was specified.
6125 Otherwise, execute now and don't pass the `|' as an arg. */
6128 input_from_pipe
= 1;
6135 set_collect_gcc_options ();
6137 if (argbuf
.length () > 0)
6143 /* Reinitialize for a new command, and for a new argument. */
6146 delete_this_arg
= 0;
6147 this_is_output_file
= 0;
6148 this_is_library_file
= 0;
6149 this_is_linker_script
= 0;
6150 input_from_pipe
= 0;
6157 obstack_1grow (&obstack
, c
);
6165 /* Reinitialize for a new argument. */
6166 delete_this_arg
= 0;
6167 this_is_output_file
= 0;
6168 this_is_library_file
= 0;
6169 this_is_linker_script
= 0;
6176 fatal_error (input_location
, "spec %qs invalid", spec
);
6179 /* Don't use %b in the linker command. */
6180 gcc_assert (suffixed_basename_length
);
6181 if (!this_is_output_file
&& dumpdir_length
)
6182 obstack_grow (&obstack
, dumpdir
, dumpdir_length
);
6183 if (this_is_output_file
|| !outbase_length
)
6184 obstack_grow (&obstack
, input_basename
, basename_length
);
6186 obstack_grow (&obstack
, outbase
, outbase_length
);
6187 if (compare_debug
< 0)
6188 obstack_grow (&obstack
, ".gk", 3);
6193 /* Don't use %B in the linker command. */
6194 gcc_assert (suffixed_basename_length
);
6195 if (!this_is_output_file
&& dumpdir_length
)
6196 obstack_grow (&obstack
, dumpdir
, dumpdir_length
);
6197 if (this_is_output_file
|| !outbase_length
)
6198 obstack_grow (&obstack
, input_basename
, basename_length
);
6200 obstack_grow (&obstack
, outbase
, outbase_length
);
6201 if (compare_debug
< 0)
6202 obstack_grow (&obstack
, ".gk", 3);
6203 obstack_grow (&obstack
, input_basename
+ basename_length
,
6204 suffixed_basename_length
- basename_length
);
6210 delete_this_arg
= 2;
6213 /* Dump out the directories specified with LIBRARY_PATH,
6214 followed by the absolute directories
6215 that we search for startfiles. */
6218 struct spec_path_info info
;
6221 info
.append_len
= 0;
6222 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
6223 /* Used on systems which record the specified -L dirs
6224 and use them to search for dynamic linking.
6225 Relative directories always come from -B,
6226 and it is better not to use them for searching
6227 at run time. In particular, stage1 loses. */
6228 info
.omit_relative
= true;
6230 info
.omit_relative
= false;
6232 info
.separate_options
= false;
6233 info
.realpaths
= false;
6235 for_each_path (&startfile_prefixes
, true, 0, spec_path
, &info
);
6241 struct spec_path_info info
;
6243 info
.option
= RUNPATH_OPTION
;
6244 info
.append_len
= 0;
6245 info
.omit_relative
= false;
6246 info
.separate_options
= true;
6247 /* We want to embed the actual paths that have the libraries. */
6248 info
.realpaths
= true;
6250 for_each_path (&startfile_prefixes
, true, 0, spec_path
, &info
);
6255 /* %efoo means report an error with `foo' as error message
6256 and don't execute any more commands for this file. */
6260 while (*p
!= 0 && *p
!= '\n')
6262 buf
= (char *) alloca (p
- q
+ 1);
6263 strncpy (buf
, q
, p
- q
);
6265 error ("%s", _(buf
));
6270 /* %nfoo means report a notice with `foo' on stderr. */
6274 while (*p
!= 0 && *p
!= '\n')
6276 buf
= (char *) alloca (p
- q
+ 1);
6277 strncpy (buf
, q
, p
- q
);
6279 inform (UNKNOWN_LOCATION
, "%s", _(buf
));
6289 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
6290 defined, and it is not a directory, and it is
6291 writable, use it. Otherwise, treat this like any
6292 other temporary file. */
6294 if ((!save_temps_flag
)
6295 && (stat (HOST_BIT_BUCKET
, &st
) == 0) && (!S_ISDIR (st
.st_mode
))
6296 && (access (HOST_BIT_BUCKET
, W_OK
) == 0))
6298 obstack_grow (&obstack
, HOST_BIT_BUCKET
,
6299 strlen (HOST_BIT_BUCKET
));
6300 delete_this_arg
= 0;
6305 goto create_temp_file
;
6309 obstack_1grow (&obstack
, '-');
6310 delete_this_arg
= 0;
6313 /* consume suffix */
6314 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
6316 if (p
[0] == '%' && p
[1] == 'O')
6321 goto create_temp_file
;
6325 /* consume suffix */
6326 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
6328 if (p
[0] == '%' && p
[1] == 'O')
6333 goto create_temp_file
;
6339 struct temp_name
*t
;
6341 const char *suffix
= p
;
6342 char *saved_suffix
= NULL
;
6344 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
6346 suffix_length
= p
- suffix
;
6347 if (p
[0] == '%' && p
[1] == 'O')
6350 /* We don't support extra suffix characters after %O. */
6351 if (*p
== '.' || ISALNUM ((unsigned char) *p
))
6352 fatal_error (input_location
,
6353 "spec %qs has invalid %<%%0%c%>", spec
, *p
);
6354 if (suffix_length
== 0)
6355 suffix
= TARGET_OBJECT_SUFFIX
;
6359 = XNEWVEC (char, suffix_length
6360 + strlen (TARGET_OBJECT_SUFFIX
) + 1);
6361 strncpy (saved_suffix
, suffix
, suffix_length
);
6362 strcpy (saved_suffix
+ suffix_length
,
6363 TARGET_OBJECT_SUFFIX
);
6365 suffix_length
+= strlen (TARGET_OBJECT_SUFFIX
);
6368 if (compare_debug
< 0)
6370 suffix
= concat (".gk", suffix
, NULL
);
6374 /* If -save-temps was specified, use that for the
6376 if (save_temps_flag
)
6379 bool adjusted_suffix
= false;
6381 && !outbase_length
&& !basename_length
6382 && !dumpdir_trailing_dash_added
)
6384 adjusted_suffix
= true;
6388 temp_filename_length
6389 = dumpdir_length
+ suffix_length
+ 1;
6391 temp_filename_length
+= outbase_length
;
6393 temp_filename_length
+= basename_length
;
6394 tmp
= (char *) alloca (temp_filename_length
);
6396 memcpy (tmp
, dumpdir
, dumpdir_length
);
6398 memcpy (tmp
+ dumpdir_length
, outbase
,
6400 else if (basename_length
)
6401 memcpy (tmp
+ dumpdir_length
, input_basename
,
6403 memcpy (tmp
+ temp_filename_length
- suffix_length
- 1,
6404 suffix
, suffix_length
);
6405 if (adjusted_suffix
)
6407 adjusted_suffix
= false;
6411 tmp
[temp_filename_length
- 1] = '\0';
6412 temp_filename
= tmp
;
6414 if (filename_cmp (temp_filename
, gcc_input_filename
) != 0)
6416 #ifndef HOST_LACKS_INODE_NUMBERS
6417 struct stat st_temp
;
6419 /* Note, set_input() resets input_stat_set to 0. */
6420 if (input_stat_set
== 0)
6422 input_stat_set
= stat (gcc_input_filename
,
6424 if (input_stat_set
>= 0)
6428 /* If we have the stat for the gcc_input_filename
6429 and we can do the stat for the temp_filename
6430 then the they could still refer to the same
6431 file if st_dev/st_ino's are the same. */
6432 if (input_stat_set
!= 1
6433 || stat (temp_filename
, &st_temp
) < 0
6434 || input_stat
.st_dev
!= st_temp
.st_dev
6435 || input_stat
.st_ino
!= st_temp
.st_ino
)
6437 /* Just compare canonical pathnames. */
6438 char* input_realname
= lrealpath (gcc_input_filename
);
6439 char* temp_realname
= lrealpath (temp_filename
);
6440 bool files_differ
= filename_cmp (input_realname
, temp_realname
);
6441 free (input_realname
);
6442 free (temp_realname
);
6447 = save_string (temp_filename
,
6448 temp_filename_length
- 1);
6449 obstack_grow (&obstack
, temp_filename
,
6450 temp_filename_length
);
6452 delete_this_arg
= 0;
6458 /* See if we already have an association of %g/%u/%U and
6460 for (t
= temp_names
; t
; t
= t
->next
)
6461 if (t
->length
== suffix_length
6462 && strncmp (t
->suffix
, suffix
, suffix_length
) == 0
6463 && t
->unique
== (c
== 'u' || c
== 'U' || c
== 'j'))
6466 /* Make a new association if needed. %u and %j
6468 if (t
== 0 || c
== 'u' || c
== 'j')
6472 t
= XNEW (struct temp_name
);
6473 t
->next
= temp_names
;
6476 t
->length
= suffix_length
;
6479 t
->suffix
= saved_suffix
;
6480 saved_suffix
= NULL
;
6483 t
->suffix
= save_string (suffix
, suffix_length
);
6484 t
->unique
= (c
== 'u' || c
== 'U' || c
== 'j');
6485 temp_filename
= make_temp_file (t
->suffix
);
6486 temp_filename_length
= strlen (temp_filename
);
6487 t
->filename
= temp_filename
;
6488 t
->filename_length
= temp_filename_length
;
6491 free (saved_suffix
);
6493 obstack_grow (&obstack
, t
->filename
, t
->filename_length
);
6494 delete_this_arg
= 1;
6502 /* We are going to expand `%i' into `@FILE', where FILE
6503 is a newly-created temporary filename. The filenames
6504 that would usually be expanded in place of %o will be
6505 written to the temporary file. */
6506 if (at_file_supplied
)
6509 for (i
= 0; (int) i
< n_infiles
; i
++)
6510 if (compile_input_file_p (&infiles
[i
]))
6512 store_arg (infiles
[i
].name
, 0, 0);
6513 infiles
[i
].compiled
= true;
6516 if (at_file_supplied
)
6521 obstack_grow (&obstack
, gcc_input_filename
,
6522 input_filename_length
);
6529 struct spec_path_info info
;
6533 do_spec_1 ("-imultilib", 1, NULL
);
6534 /* Make this a separate argument. */
6535 do_spec_1 (" ", 0, NULL
);
6536 do_spec_1 (multilib_dir
, 1, NULL
);
6537 do_spec_1 (" ", 0, NULL
);
6542 do_spec_1 ("-imultiarch", 1, NULL
);
6543 /* Make this a separate argument. */
6544 do_spec_1 (" ", 0, NULL
);
6545 do_spec_1 (multiarch_dir
, 1, NULL
);
6546 do_spec_1 (" ", 0, NULL
);
6549 if (gcc_exec_prefix
)
6551 do_spec_1 ("-iprefix", 1, NULL
);
6552 /* Make this a separate argument. */
6553 do_spec_1 (" ", 0, NULL
);
6554 do_spec_1 (gcc_exec_prefix
, 1, NULL
);
6555 do_spec_1 (" ", 0, NULL
);
6558 if (target_system_root_changed
||
6559 (target_system_root
&& target_sysroot_hdrs_suffix
))
6561 do_spec_1 ("-isysroot", 1, NULL
);
6562 /* Make this a separate argument. */
6563 do_spec_1 (" ", 0, NULL
);
6564 do_spec_1 (target_system_root
, 1, NULL
);
6565 if (target_sysroot_hdrs_suffix
)
6566 do_spec_1 (target_sysroot_hdrs_suffix
, 1, NULL
);
6567 do_spec_1 (" ", 0, NULL
);
6570 info
.option
= "-isystem";
6571 info
.append
= "include";
6572 info
.append_len
= strlen (info
.append
);
6573 info
.omit_relative
= false;
6574 info
.separate_options
= true;
6575 info
.realpaths
= false;
6577 for_each_path (&include_prefixes
, false, info
.append_len
,
6580 info
.append
= "include-fixed";
6581 if (*sysroot_hdrs_suffix_spec
)
6582 info
.append
= concat (info
.append
, dir_separator_str
,
6583 multilib_dir
, NULL
);
6584 else if (multiarch_dir
)
6586 /* For multiarch, search include-fixed/<multiarch-dir>
6587 before include-fixed. */
6588 info
.append
= concat (info
.append
, dir_separator_str
,
6589 multiarch_dir
, NULL
);
6590 info
.append_len
= strlen (info
.append
);
6591 for_each_path (&include_prefixes
, false, info
.append_len
,
6594 info
.append
= "include-fixed";
6596 info
.append_len
= strlen (info
.append
);
6597 for_each_path (&include_prefixes
, false, info
.append_len
,
6603 /* We are going to expand `%o' into `@FILE', where FILE
6604 is a newly-created temporary filename. The filenames
6605 that would usually be expanded in place of %o will be
6606 written to the temporary file. */
6607 if (at_file_supplied
)
6610 for (i
= 0; i
< n_infiles
+ lang_specific_extra_outfiles
; i
++)
6612 store_arg (outfiles
[i
], 0, 0);
6614 if (at_file_supplied
)
6619 obstack_grow (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
6624 this_is_library_file
= 1;
6628 this_is_linker_script
= 1;
6632 outfiles
[input_file_number
] = NULL
;
6636 this_is_output_file
= 1;
6641 unsigned int cur_index
= argbuf
.length ();
6642 /* Handle the {...} following the %W. */
6644 fatal_error (input_location
,
6645 "spec %qs has invalid %<%%W%c%>", spec
, *p
);
6646 p
= handle_braces (p
+ 1);
6650 /* If any args were output, mark the last one for deletion
6652 if (argbuf
.length () != cur_index
)
6653 record_temp_file (argbuf
.last (), 0, 1);
6658 /* Handle the {...} following the %@. */
6660 fatal_error (input_location
,
6661 "spec %qs has invalid %<%%@%c%>", spec
, *p
);
6662 if (at_file_supplied
)
6664 p
= handle_braces (p
+ 1);
6665 if (at_file_supplied
)
6671 /* %x{OPTION} records OPTION for %X to output. */
6677 /* Skip past the option value and make a copy. */
6679 fatal_error (input_location
,
6680 "spec %qs has invalid %<%%x%c%>", spec
, *p
);
6683 string
= save_string (p1
+ 1, p
- p1
- 2);
6685 /* See if we already recorded this option. */
6686 for (const char *opt
: linker_options
)
6687 if (! strcmp (string
, opt
))
6693 /* This option is new; add it. */
6694 add_linker_option (string
, strlen (string
));
6699 /* Dump out the options accumulated previously using %x. */
6701 do_specs_vec (linker_options
);
6704 /* Dump out the options accumulated previously using -Wa,. */
6706 do_specs_vec (assembler_options
);
6709 /* Dump out the options accumulated previously using -Wp,. */
6711 do_specs_vec (preprocessor_options
);
6714 /* Here are digits and numbers that just process
6715 a certain constant string as a spec. */
6718 value
= do_spec_1 (cc1_spec
, 0, NULL
);
6724 value
= do_spec_1 (cc1plus_spec
, 0, NULL
);
6730 value
= do_spec_1 (asm_spec
, 0, NULL
);
6736 value
= do_spec_1 (asm_final_spec
, 0, NULL
);
6743 const char *const spec
6744 = (input_file_compiler
->cpp_spec
6745 ? input_file_compiler
->cpp_spec
6747 value
= do_spec_1 (spec
, 0, NULL
);
6754 value
= do_spec_1 (endfile_spec
, 0, NULL
);
6760 value
= do_spec_1 (link_spec
, 0, NULL
);
6766 value
= do_spec_1 (lib_spec
, 0, NULL
);
6772 if (multilib_os_dir
== NULL
)
6773 obstack_1grow (&obstack
, '.');
6775 obstack_grow (&obstack
, multilib_os_dir
,
6776 strlen (multilib_os_dir
));
6780 value
= do_spec_1 (libgcc_spec
, 0, NULL
);
6786 /* We assume there is a directory
6787 separator at the end of this string. */
6788 if (target_system_root
)
6790 obstack_grow (&obstack
, target_system_root
,
6791 strlen (target_system_root
));
6792 if (target_sysroot_suffix
)
6793 obstack_grow (&obstack
, target_sysroot_suffix
,
6794 strlen (target_sysroot_suffix
));
6799 value
= do_spec_1 (startfile_spec
, 0, NULL
);
6804 /* Here we define characters other than letters and digits. */
6807 p
= handle_braces (p
);
6813 p
= handle_spec_function (p
, NULL
, soft_matched_part
);
6819 obstack_1grow (&obstack
, '%');
6826 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '%')
6828 suffix_subst
= save_string (p
- 1, len
+ 1);
6833 /* Henceforth ignore the option(s) matching the pattern
6839 int have_wildcard
= 0;
6844 switch_option
= SWITCH_IGNORE
| SWITCH_KEEP_FOR_GCC
;
6846 switch_option
= SWITCH_IGNORE
;
6848 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '\t')
6851 if (p
[len
-1] == '*')
6854 for (i
= 0; i
< n_switches
; i
++)
6855 if (!strncmp (switches
[i
].part1
, p
, len
- have_wildcard
)
6856 && (have_wildcard
|| switches
[i
].part1
[len
] == '\0'))
6858 switches
[i
].live_cond
|= switch_option
;
6859 /* User switch be validated from validate_all_switches.
6860 when the definition is seen from the spec file.
6861 If not defined anywhere, will be rejected. */
6862 if (switches
[i
].known
)
6863 switches
[i
].validated
= true;
6871 if (soft_matched_part
)
6873 if (soft_matched_part
[0])
6874 do_spec_1 (soft_matched_part
, 1, NULL
);
6875 /* Only insert a space after the substitution if it is at the
6876 end of the current sequence. So if:
6878 "%{foo=*:bar%*}%{foo=*:one%*two}"
6880 matches -foo=hello then it will produce:
6882 barhello onehellotwo
6884 if (*p
== 0 || *p
== '}')
6885 do_spec_1 (" ", 0, NULL
);
6888 /* Catch the case where a spec string contains something like
6889 '%{foo:%*}'. i.e. there is no * in the pattern on the left
6890 hand side of the :. */
6891 error ("spec failure: %<%%*%> has not been initialized by pattern match");
6894 /* Process a string found as the value of a spec given by name.
6895 This feature allows individual machine descriptions
6896 to add and use their own specs. */
6899 const char *name
= p
;
6900 struct spec_list
*sl
;
6903 /* The string after the S/P is the name of a spec that is to be
6905 while (*p
&& *p
!= ')')
6908 /* See if it's in the list. */
6909 for (len
= p
- name
, sl
= specs
; sl
; sl
= sl
->next
)
6910 if (sl
->name_len
== len
&& !strncmp (sl
->name
, name
, len
))
6912 name
= *(sl
->ptr_spec
);
6914 fnotice (stderr
, "Processing spec (%s), which is '%s'\n",
6922 value
= do_spec_1 (name
, 0, NULL
);
6927 /* Discard the closing paren. */
6934 /* End a previous argument, if there is one, then issue an
6942 error ("spec failure: unrecognized spec option %qc", c
);
6948 /* Backslash: treat next character as ordinary. */
6951 /* When adding more cases that previously matched default, make
6952 sure to adjust quote_spec_char_p as well. */
6956 /* Ordinary character: put it into the current argument. */
6957 obstack_1grow (&obstack
, c
);
6961 /* End of string. If we are processing a spec function, we need to
6962 end any pending argument. */
6963 if (processing_spec_function
)
6969 /* Look up a spec function. */
6971 static const struct spec_function
*
6972 lookup_spec_function (const char *name
)
6974 const struct spec_function
*sf
;
6976 for (sf
= static_spec_functions
; sf
->name
!= NULL
; sf
++)
6977 if (strcmp (sf
->name
, name
) == 0)
6983 /* Evaluate a spec function. */
6986 eval_spec_function (const char *func
, const char *args
,
6987 const char *soft_matched_part
)
6989 const struct spec_function
*sf
;
6990 const char *funcval
;
6992 /* Saved spec processing context. */
6993 vec
<const_char_p
> save_argbuf
;
6996 int save_delete_this_arg
;
6997 int save_this_is_output_file
;
6998 int save_this_is_library_file
;
6999 int save_input_from_pipe
;
7000 int save_this_is_linker_script
;
7001 const char *save_suffix_subst
;
7003 int save_growing_size
;
7004 void *save_growing_value
= NULL
;
7006 sf
= lookup_spec_function (func
);
7008 fatal_error (input_location
, "unknown spec function %qs", func
);
7010 /* Push the spec processing context. */
7011 save_argbuf
= argbuf
;
7013 save_arg_going
= arg_going
;
7014 save_delete_this_arg
= delete_this_arg
;
7015 save_this_is_output_file
= this_is_output_file
;
7016 save_this_is_library_file
= this_is_library_file
;
7017 save_this_is_linker_script
= this_is_linker_script
;
7018 save_input_from_pipe
= input_from_pipe
;
7019 save_suffix_subst
= suffix_subst
;
7021 /* If we have some object growing now, finalize it so the args and function
7022 eval proceed from a cleared context. This is needed to prevent the first
7023 constructed arg from mistakenly including the growing value. We'll push
7024 this value back on the obstack once the function evaluation is done, to
7025 restore a consistent processing context for our caller. This is fine as
7026 the address of growing objects isn't guaranteed to remain stable until
7027 they are finalized, and we expect this situation to be rare enough for
7028 the extra copy not to be an issue. */
7029 save_growing_size
= obstack_object_size (&obstack
);
7030 if (save_growing_size
> 0)
7031 save_growing_value
= obstack_finish (&obstack
);
7033 /* Create a new spec processing context, and build the function
7037 if (do_spec_2 (args
, soft_matched_part
) < 0)
7038 fatal_error (input_location
, "error in arguments to spec function %qs",
7041 /* argbuf_index is an index for the next argument to be inserted, and
7042 so contains the count of the args already inserted. */
7044 funcval
= (*sf
->func
) (argbuf
.length (),
7047 /* Pop the spec processing context. */
7049 argbuf
= save_argbuf
;
7051 arg_going
= save_arg_going
;
7052 delete_this_arg
= save_delete_this_arg
;
7053 this_is_output_file
= save_this_is_output_file
;
7054 this_is_library_file
= save_this_is_library_file
;
7055 this_is_linker_script
= save_this_is_linker_script
;
7056 input_from_pipe
= save_input_from_pipe
;
7057 suffix_subst
= save_suffix_subst
;
7059 if (save_growing_size
> 0)
7060 obstack_grow (&obstack
, save_growing_value
, save_growing_size
);
7065 /* Handle a spec function call of the form:
7069 ARGS is processed as a spec in a separate context and split into an
7070 argument vector in the normal fashion. The function returns a string
7071 containing a spec which we then process in the caller's context, or
7072 NULL if no processing is required.
7074 If RETVAL_NONNULL is not NULL, then store a bool whether function
7077 SOFT_MATCHED_PART holds the current value of a matched * pattern, which
7078 may be re-expanded with a %* as part of the function arguments. */
7081 handle_spec_function (const char *p
, bool *retval_nonnull
,
7082 const char *soft_matched_part
)
7085 const char *endp
, *funcval
;
7088 processing_spec_function
++;
7090 /* Get the function name. */
7091 for (endp
= p
; *endp
!= '\0'; endp
++)
7093 if (*endp
== '(') /* ) */
7095 /* Only allow [A-Za-z0-9], -, and _ in function names. */
7096 if (!ISALNUM (*endp
) && !(*endp
== '-' || *endp
== '_'))
7097 fatal_error (input_location
, "malformed spec function name");
7099 if (*endp
!= '(') /* ) */
7100 fatal_error (input_location
, "no arguments for spec function");
7101 func
= save_string (p
, endp
- p
);
7104 /* Get the arguments. */
7105 for (count
= 0; *endp
!= '\0'; endp
++)
7114 else if (*endp
== '(') /* ) */
7119 fatal_error (input_location
, "malformed spec function arguments");
7120 args
= save_string (p
, endp
- p
);
7123 /* p now points to just past the end of the spec function expression. */
7125 funcval
= eval_spec_function (func
, args
, soft_matched_part
);
7126 if (funcval
!= NULL
&& do_spec_1 (funcval
, 0, NULL
) < 0)
7129 *retval_nonnull
= funcval
!= NULL
;
7134 processing_spec_function
--;
7139 /* Inline subroutine of handle_braces. Returns true if the current
7140 input suffix matches the atom bracketed by ATOM and END_ATOM. */
7142 input_suffix_matches (const char *atom
, const char *end_atom
)
7144 return (input_suffix
7145 && !strncmp (input_suffix
, atom
, end_atom
- atom
)
7146 && input_suffix
[end_atom
- atom
] == '\0');
7149 /* Subroutine of handle_braces. Returns true if the current
7150 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
7152 input_spec_matches (const char *atom
, const char *end_atom
)
7154 return (input_file_compiler
7155 && input_file_compiler
->suffix
7156 && input_file_compiler
->suffix
[0] != '\0'
7157 && !strncmp (input_file_compiler
->suffix
+ 1, atom
,
7159 && input_file_compiler
->suffix
[end_atom
- atom
+ 1] == '\0');
7162 /* Subroutine of handle_braces. Returns true if a switch
7163 matching the atom bracketed by ATOM and END_ATOM appeared on the
7166 switch_matches (const char *atom
, const char *end_atom
, int starred
)
7169 int len
= end_atom
- atom
;
7170 int plen
= starred
? len
: -1;
7172 for (i
= 0; i
< n_switches
; i
++)
7173 if (!strncmp (switches
[i
].part1
, atom
, len
)
7174 && (starred
|| switches
[i
].part1
[len
] == '\0')
7175 && check_live_switch (i
, plen
))
7178 /* Check if a switch with separated form matching the atom.
7179 We check -D and -U switches. */
7180 else if (switches
[i
].args
!= 0)
7182 if ((*switches
[i
].part1
== 'D' || *switches
[i
].part1
== 'U')
7183 && *switches
[i
].part1
== atom
[0])
7185 if (!strncmp (switches
[i
].args
[0], &atom
[1], len
- 1)
7186 && (starred
|| (switches
[i
].part1
[1] == '\0'
7187 && switches
[i
].args
[0][len
- 1] == '\0'))
7188 && check_live_switch (i
, (starred
? 1 : -1)))
7196 /* Inline subroutine of handle_braces. Mark all of the switches which
7197 match ATOM (extends to END_ATOM; STARRED indicates whether there
7198 was a star after the atom) for later processing. */
7200 mark_matching_switches (const char *atom
, const char *end_atom
, int starred
)
7203 int len
= end_atom
- atom
;
7204 int plen
= starred
? len
: -1;
7206 for (i
= 0; i
< n_switches
; i
++)
7207 if (!strncmp (switches
[i
].part1
, atom
, len
)
7208 && (starred
|| switches
[i
].part1
[len
] == '\0')
7209 && check_live_switch (i
, plen
))
7210 switches
[i
].ordering
= 1;
7213 /* Inline subroutine of handle_braces. Process all the currently
7214 marked switches through give_switch, and clear the marks. */
7216 process_marked_switches (void)
7220 for (i
= 0; i
< n_switches
; i
++)
7221 if (switches
[i
].ordering
== 1)
7223 switches
[i
].ordering
= 0;
7228 /* Handle a %{ ... } construct. P points just inside the leading {.
7229 Returns a pointer one past the end of the brace block, or 0
7230 if we call do_spec_1 and that returns -1. */
7233 handle_braces (const char *p
)
7235 const char *atom
, *end_atom
;
7236 const char *d_atom
= NULL
, *d_end_atom
= NULL
;
7237 char *esc_buf
= NULL
, *d_esc_buf
= NULL
;
7239 const char *orig
= p
;
7247 bool a_must_be_last
= false;
7248 bool ordered_set
= false;
7249 bool disjunct_set
= false;
7250 bool disj_matched
= false;
7251 bool disj_starred
= true;
7252 bool n_way_choice
= false;
7253 bool n_way_matched
= false;
7255 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7262 /* Scan one "atom" (S in the description above of %{}, possibly
7263 with '!', '.', '@', ',', or '*' modifiers). */
7265 a_is_suffix
= false;
7266 a_is_starred
= false;
7267 a_is_negated
= false;
7268 a_is_spectype
= false;
7272 p
++, a_is_negated
= true;
7275 if (*p
== '%' && p
[1] == ':')
7279 p
= handle_spec_function (p
+ 2, &a_matched
, NULL
);
7284 p
++, a_is_suffix
= true;
7286 p
++, a_is_spectype
= true;
7290 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
7291 || *p
== ',' || *p
== '.' || *p
== '@' || *p
== '\\')
7297 fatal_error (input_location
,
7298 "braced spec %qs ends in escape", orig
);
7310 if (esc_buf
&& esc_buf
!= d_esc_buf
)
7313 ep
= esc_buf
= (char *) xmalloc (end_atom
- atom
- esc
+ 1);
7314 for (ap
= atom
; ap
!= end_atom
; ap
++, ep
++)
7326 p
++, a_is_starred
= 1;
7333 /* Substitute the switch(es) indicated by the current atom. */
7335 if (disjunct_set
|| n_way_choice
|| a_is_negated
|| a_is_suffix
7336 || a_is_spectype
|| atom
== end_atom
)
7339 mark_matching_switches (atom
, end_atom
, a_is_starred
);
7342 process_marked_switches ();
7346 /* Substitute some text if the current atom appears as a switch
7348 disjunct_set
= true;
7352 if (atom
&& atom
== end_atom
)
7354 if (!n_way_choice
|| disj_matched
|| *p
== '|'
7355 || a_is_negated
|| a_is_suffix
|| a_is_spectype
7359 /* An empty term may appear as the last choice of an
7360 N-way choice set; it means "otherwise". */
7361 a_must_be_last
= true;
7362 disj_matched
= !n_way_matched
;
7363 disj_starred
= false;
7367 if ((a_is_suffix
|| a_is_spectype
) && a_is_starred
)
7371 disj_starred
= false;
7373 /* Don't bother testing this atom if we already have a
7375 if (!disj_matched
&& !n_way_matched
)
7378 /* a_matched is already set by handle_spec_function. */;
7379 else if (a_is_suffix
)
7380 a_matched
= input_suffix_matches (atom
, end_atom
);
7381 else if (a_is_spectype
)
7382 a_matched
= input_spec_matches (atom
, end_atom
);
7384 a_matched
= switch_matches (atom
, end_atom
, a_is_starred
);
7386 if (a_matched
!= a_is_negated
)
7388 disj_matched
= true;
7390 d_end_atom
= end_atom
;
7391 d_esc_buf
= esc_buf
;
7398 /* Found the body, that is, the text to substitute if the
7399 current disjunction matches. */
7400 p
= process_brace_body (p
+ 1, d_atom
, d_end_atom
, disj_starred
,
7401 disj_matched
&& !n_way_matched
);
7405 /* If we have an N-way choice, reset state for the next
7409 n_way_choice
= true;
7410 n_way_matched
|= disj_matched
;
7411 disj_matched
= false;
7412 disj_starred
= true;
7413 d_atom
= d_end_atom
= NULL
;
7422 while (*p
++ != '}');
7425 if (d_esc_buf
&& d_esc_buf
!= esc_buf
)
7433 fatal_error (input_location
, "braced spec %qs is invalid at %qc", orig
, *p
);
7438 /* Subroutine of handle_braces. Scan and process a brace substitution body
7439 (X in the description of %{} syntax). P points one past the colon;
7440 ATOM and END_ATOM bracket the first atom which was found to be true
7441 (present) in the current disjunction; STARRED indicates whether all
7442 the atoms in the current disjunction were starred (for syntax validation);
7443 MATCHED indicates whether the disjunction matched or not, and therefore
7444 whether or not the body is to be processed through do_spec_1 or just
7445 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
7449 process_brace_body (const char *p
, const char *atom
, const char *end_atom
,
7450 int starred
, int matched
)
7452 const char *body
, *end_body
;
7453 unsigned int nesting_level
;
7454 bool have_subst
= false;
7456 /* Locate the closing } or ;, honoring nested braces.
7457 Trim trailing whitespace. */
7466 if (!--nesting_level
)
7469 else if (*p
== ';' && nesting_level
== 1)
7471 else if (*p
== '%' && p
[1] == '*' && nesting_level
== 1)
7473 else if (*p
== '\0')
7479 while (end_body
[-1] == ' ' || end_body
[-1] == '\t')
7482 if (have_subst
&& !starred
)
7487 /* Copy the substitution body to permanent storage and execute it.
7488 If have_subst is false, this is a simple matter of running the
7489 body through do_spec_1... */
7490 char *string
= save_string (body
, end_body
- body
);
7493 if (do_spec_1 (string
, 0, NULL
) < 0)
7501 /* ... but if have_subst is true, we have to process the
7502 body once for each matching switch, with %* set to the
7503 variant part of the switch. */
7504 unsigned int hard_match_len
= end_atom
- atom
;
7507 for (i
= 0; i
< n_switches
; i
++)
7508 if (!strncmp (switches
[i
].part1
, atom
, hard_match_len
)
7509 && check_live_switch (i
, hard_match_len
))
7511 if (do_spec_1 (string
, 0,
7512 &switches
[i
].part1
[hard_match_len
]) < 0)
7517 /* Pass any arguments this switch has. */
7519 suffix_subst
= NULL
;
7528 fatal_error (input_location
, "braced spec body %qs is invalid", body
);
7531 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
7532 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
7533 spec, or -1 if either exact match or %* is used.
7535 A -O switch is obsoleted by a later -O switch. A -f, -g, -m, or -W switch
7536 whose value does not begin with "no-" is obsoleted by the same value
7537 with the "no-", similarly for a switch with the "no-" prefix. */
7540 check_live_switch (int switchnum
, int prefix_length
)
7542 const char *name
= switches
[switchnum
].part1
;
7545 /* If we already processed this switch and determined if it was
7546 live or not, return our past determination. */
7547 if (switches
[switchnum
].live_cond
!= 0)
7548 return ((switches
[switchnum
].live_cond
& SWITCH_LIVE
) != 0
7549 && (switches
[switchnum
].live_cond
& SWITCH_FALSE
) == 0
7550 && (switches
[switchnum
].live_cond
& SWITCH_IGNORE_PERMANENTLY
)
7553 /* In the common case of {<at-most-one-letter>*}, a negating
7554 switch would always match, so ignore that case. We will just
7555 send the conflicting switches to the compiler phase. */
7556 if (prefix_length
>= 0 && prefix_length
<= 1)
7559 /* Now search for duplicate in a manner that depends on the name. */
7563 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
7564 if (switches
[i
].part1
[0] == 'O')
7566 switches
[switchnum
].validated
= true;
7567 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
7572 case 'W': case 'f': case 'm': case 'g':
7573 if (startswith (name
+ 1, "no-"))
7575 /* We have Xno-YYY, search for XYYY. */
7576 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
7577 if (switches
[i
].part1
[0] == name
[0]
7578 && ! strcmp (&switches
[i
].part1
[1], &name
[4]))
7580 /* --specs are validated with the validate_switches mechanism. */
7581 if (switches
[switchnum
].known
)
7582 switches
[switchnum
].validated
= true;
7583 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
7589 /* We have XYYY, search for Xno-YYY. */
7590 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
7591 if (switches
[i
].part1
[0] == name
[0]
7592 && switches
[i
].part1
[1] == 'n'
7593 && switches
[i
].part1
[2] == 'o'
7594 && switches
[i
].part1
[3] == '-'
7595 && !strcmp (&switches
[i
].part1
[4], &name
[1]))
7597 /* --specs are validated with the validate_switches mechanism. */
7598 if (switches
[switchnum
].known
)
7599 switches
[switchnum
].validated
= true;
7600 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
7607 /* Otherwise the switch is live. */
7608 switches
[switchnum
].live_cond
|= SWITCH_LIVE
;
7612 /* Pass a switch to the current accumulating command
7613 in the same form that we received it.
7614 SWITCHNUM identifies the switch; it is an index into
7615 the vector of switches gcc received, which is `switches'.
7616 This cannot fail since it never finishes a command line.
7618 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
7621 give_switch (int switchnum
, int omit_first_word
)
7623 if ((switches
[switchnum
].live_cond
& SWITCH_IGNORE
) != 0)
7626 if (!omit_first_word
)
7628 do_spec_1 ("-", 0, NULL
);
7629 do_spec_1 (switches
[switchnum
].part1
, 1, NULL
);
7632 if (switches
[switchnum
].args
!= 0)
7635 for (p
= switches
[switchnum
].args
; *p
; p
++)
7637 const char *arg
= *p
;
7639 do_spec_1 (" ", 0, NULL
);
7642 unsigned length
= strlen (arg
);
7645 while (length
-- && !IS_DIR_SEPARATOR (arg
[length
]))
7646 if (arg
[length
] == '.')
7648 (CONST_CAST (char *, arg
))[length
] = 0;
7652 do_spec_1 (arg
, 1, NULL
);
7654 (CONST_CAST (char *, arg
))[length
] = '.';
7655 do_spec_1 (suffix_subst
, 1, NULL
);
7658 do_spec_1 (arg
, 1, NULL
);
7662 do_spec_1 (" ", 0, NULL
);
7663 switches
[switchnum
].validated
= true;
7666 /* Print GCC configuration (e.g. version, thread model, target,
7667 configuration_arguments) to a given FILE. */
7670 print_configuration (FILE *file
)
7675 fnotice (file
, "Target: %s\n", spec_machine
);
7676 fnotice (file
, "Configured with: %s\n", configuration_arguments
);
7678 #ifdef THREAD_MODEL_SPEC
7679 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
7680 but there's no point in doing all this processing just to get
7681 thread_model back. */
7682 obstack_init (&obstack
);
7683 do_spec_1 (THREAD_MODEL_SPEC
, 0, thread_model
);
7684 obstack_1grow (&obstack
, '\0');
7685 thrmod
= XOBFINISH (&obstack
, const char *);
7687 thrmod
= thread_model
;
7690 fnotice (file
, "Thread model: %s\n", thrmod
);
7691 fnotice (file
, "Supported LTO compression algorithms: zlib");
7693 fnotice (file
, " zstd");
7695 fnotice (file
, "\n");
7697 /* compiler_version is truncated at the first space when initialized
7698 from version string, so truncate version_string at the first space
7699 before comparing. */
7700 for (n
= 0; version_string
[n
]; n
++)
7701 if (version_string
[n
] == ' ')
7704 if (! strncmp (version_string
, compiler_version
, n
)
7705 && compiler_version
[n
] == 0)
7706 fnotice (file
, "gcc version %s %s\n", version_string
,
7709 fnotice (file
, "gcc driver version %s %sexecuting gcc version %s\n",
7710 version_string
, pkgversion_string
, compiler_version
);
7714 #define RETRY_ICE_ATTEMPTS 3
7716 /* Returns true if FILE1 and FILE2 contain equivalent data, 0 otherwise. */
7719 files_equal_p (char *file1
, char *file2
)
7721 struct stat st1
, st2
;
7724 const int bufsize
= 8192;
7725 char *buf
= XNEWVEC (char, bufsize
);
7727 fd1
= open (file1
, O_RDONLY
);
7728 fd2
= open (file2
, O_RDONLY
);
7730 if (fd1
< 0 || fd2
< 0)
7733 if (fstat (fd1
, &st1
) < 0 || fstat (fd2
, &st2
) < 0)
7736 if (st1
.st_size
!= st2
.st_size
)
7739 for (n
= st1
.st_size
; n
; n
-= len
)
7742 if ((int) len
> bufsize
/ 2)
7745 if (read (fd1
, buf
, len
) != (int) len
7746 || read (fd2
, buf
+ bufsize
/ 2, len
) != (int) len
)
7751 if (memcmp (buf
, buf
+ bufsize
/ 2, len
) != 0)
7768 /* Check that compiler's output doesn't differ across runs.
7769 TEMP_STDOUT_FILES and TEMP_STDERR_FILES are arrays of files, containing
7770 stdout and stderr for each compiler run. Return true if all of
7771 TEMP_STDOUT_FILES and TEMP_STDERR_FILES are equivalent. */
7774 check_repro (char **temp_stdout_files
, char **temp_stderr_files
)
7777 for (i
= 0; i
< RETRY_ICE_ATTEMPTS
- 2; ++i
)
7779 if (!files_equal_p (temp_stdout_files
[i
], temp_stdout_files
[i
+ 1])
7780 || !files_equal_p (temp_stderr_files
[i
], temp_stderr_files
[i
+ 1]))
7782 fnotice (stderr
, "The bug is not reproducible, so it is"
7783 " likely a hardware or OS problem.\n");
7787 return i
== RETRY_ICE_ATTEMPTS
- 2;
7790 enum attempt_status
{
7791 ATTEMPT_STATUS_FAIL_TO_RUN
,
7792 ATTEMPT_STATUS_SUCCESS
,
7797 /* Run compiler with arguments NEW_ARGV to reproduce the ICE, storing stdout
7798 to OUT_TEMP and stderr to ERR_TEMP. If APPEND is TRUE, append to OUT_TEMP
7799 and ERR_TEMP instead of truncating. If EMIT_SYSTEM_INFO is TRUE, also write
7800 GCC configuration into to ERR_TEMP. Return ATTEMPT_STATUS_FAIL_TO_RUN if
7801 compiler failed to run, ATTEMPT_STATUS_ICE if compiled ICE-ed and
7802 ATTEMPT_STATUS_SUCCESS otherwise. */
7804 static enum attempt_status
7805 run_attempt (const char **new_argv
, const char *out_temp
,
7806 const char *err_temp
, int emit_system_info
, int append
)
7809 if (emit_system_info
)
7811 FILE *file_out
= fopen (err_temp
, "a");
7812 print_configuration (file_out
);
7813 fputs ("\n", file_out
);
7819 struct pex_obj
*pex
;
7821 int pex_flags
= PEX_USE_PIPES
| PEX_LAST
;
7822 enum attempt_status status
= ATTEMPT_STATUS_FAIL_TO_RUN
;
7825 pex_flags
|= PEX_STDOUT_APPEND
| PEX_STDERR_APPEND
;
7827 pex
= pex_init (PEX_USE_PIPES
, new_argv
[0], NULL
);
7829 fatal_error (input_location
, "%<pex_init%> failed: %m");
7831 errmsg
= pex_run (pex
, pex_flags
, new_argv
[0],
7832 CONST_CAST2 (char *const *, const char **, &new_argv
[1]),
7833 out_temp
, err_temp
, &err
);
7837 fatal_error (input_location
,
7838 err
? G_ ("cannot execute %qs: %s: %m")
7839 : G_ ("cannot execute %qs: %s"),
7840 new_argv
[0], errmsg
);
7843 if (!pex_get_status (pex
, 1, &exit_status
))
7846 switch (WEXITSTATUS (exit_status
))
7849 status
= ATTEMPT_STATUS_ICE
;
7852 case SUCCESS_EXIT_CODE
:
7853 status
= ATTEMPT_STATUS_SUCCESS
;
7865 /* This routine reads lines from IN file, adds C++ style comments
7866 at the begining of each line and writes result into OUT. */
7869 insert_comments (const char *file_in
, const char *file_out
)
7871 FILE *in
= fopen (file_in
, "rb");
7872 FILE *out
= fopen (file_out
, "wb");
7875 bool add_comment
= true;
7876 while (fgets (line
, sizeof (line
), in
))
7881 add_comment
= strchr (line
, '\n') != NULL
;
7888 /* This routine adds preprocessed source code into the given ERR_FILE.
7889 To do this, it adds "-E" to NEW_ARGV and execute RUN_ATTEMPT routine to
7890 add information in report file. RUN_ATTEMPT should return
7891 ATTEMPT_STATUS_SUCCESS, in other case we cannot generate the report. */
7894 do_report_bug (const char **new_argv
, const int nargs
,
7895 char **out_file
, char **err_file
)
7898 int fd
= open (*out_file
, O_RDWR
| O_APPEND
);
7901 write (fd
, "\n//", 3);
7902 for (i
= 0; i
< nargs
; i
++)
7905 write (fd
, new_argv
[i
], strlen (new_argv
[i
]));
7907 write (fd
, "\n\n", 2);
7909 new_argv
[nargs
] = "-E";
7910 new_argv
[nargs
+ 1] = NULL
;
7912 status
= run_attempt (new_argv
, *out_file
, *err_file
, 0, 1);
7914 if (status
== ATTEMPT_STATUS_SUCCESS
)
7916 fnotice (stderr
, "Preprocessed source stored into %s file,"
7917 " please attach this to your bugreport.\n", *out_file
);
7918 /* Make sure it is not deleted. */
7924 /* Try to reproduce ICE. If bug is reproducible, generate report .err file
7925 containing GCC configuration, backtrace, compiler's command line options
7926 and preprocessed source code. */
7929 try_generate_repro (const char **argv
)
7931 int i
, nargs
, out_arg
= -1, quiet
= 0, attempt
;
7932 const char **new_argv
;
7933 char *temp_files
[RETRY_ICE_ATTEMPTS
* 2];
7934 char **temp_stdout_files
= &temp_files
[0];
7935 char **temp_stderr_files
= &temp_files
[RETRY_ICE_ATTEMPTS
];
7937 if (gcc_input_filename
== NULL
|| ! strcmp (gcc_input_filename
, "-"))
7940 for (nargs
= 0; argv
[nargs
] != NULL
; ++nargs
)
7941 /* Only retry compiler ICEs, not preprocessor ones. */
7942 if (! strcmp (argv
[nargs
], "-E"))
7944 else if (argv
[nargs
][0] == '-' && argv
[nargs
][1] == 'o')
7951 /* If the compiler is going to output any time information,
7952 it might varry between invocations. */
7953 else if (! strcmp (argv
[nargs
], "-quiet"))
7955 else if (! strcmp (argv
[nargs
], "-ftime-report"))
7958 if (out_arg
== -1 || !quiet
)
7961 memset (temp_files
, '\0', sizeof (temp_files
));
7962 new_argv
= XALLOCAVEC (const char *, nargs
+ 4);
7963 memcpy (new_argv
, argv
, (nargs
+ 1) * sizeof (const char *));
7964 new_argv
[nargs
++] = "-frandom-seed=0";
7965 new_argv
[nargs
++] = "-fdump-noaddr";
7966 new_argv
[nargs
] = NULL
;
7967 if (new_argv
[out_arg
][2] == '\0')
7968 new_argv
[out_arg
+ 1] = "-";
7970 new_argv
[out_arg
] = "-o-";
7973 for (attempt
= 0; attempt
< RETRY_ICE_ATTEMPTS
; ++attempt
)
7975 int emit_system_info
= 0;
7977 temp_stdout_files
[attempt
] = make_temp_file (".out");
7978 temp_stderr_files
[attempt
] = make_temp_file (".err");
7980 if (attempt
== RETRY_ICE_ATTEMPTS
- 1)
7983 emit_system_info
= 1;
7986 status
= run_attempt (new_argv
, temp_stdout_files
[attempt
],
7987 temp_stderr_files
[attempt
], emit_system_info
,
7990 if (status
!= ATTEMPT_STATUS_ICE
)
7992 fnotice (stderr
, "The bug is not reproducible, so it is"
7993 " likely a hardware or OS problem.\n");
7998 if (!check_repro (temp_stdout_files
, temp_stderr_files
))
8002 /* Insert commented out backtrace into report file. */
8003 char **stderr_commented
= &temp_stdout_files
[RETRY_ICE_ATTEMPTS
- 1];
8004 insert_comments (temp_stderr_files
[RETRY_ICE_ATTEMPTS
- 1],
8007 /* In final attempt we append compiler options and preprocesssed code to last
8008 generated .out file with configuration and backtrace. */
8009 char **err
= &temp_stderr_files
[RETRY_ICE_ATTEMPTS
- 1];
8010 do_report_bug (new_argv
, nargs
, stderr_commented
, err
);
8014 for (i
= 0; i
< RETRY_ICE_ATTEMPTS
* 2; i
++)
8017 unlink (temp_stdout_files
[i
]);
8018 free (temp_stdout_files
[i
]);
8022 /* Search for a file named NAME trying various prefixes including the
8023 user's -B prefix and some standard ones.
8024 Return the absolute file name found. If nothing is found, return NAME. */
8027 find_file (const char *name
)
8029 char *newname
= find_a_file (&startfile_prefixes
, name
, R_OK
, true);
8030 return newname
? newname
: name
;
8033 /* Determine whether a directory exists. If LINKER, return 0 for
8034 certain fixed names not needed by the linker. */
8037 is_directory (const char *path1
, bool linker
)
8044 /* Ensure the string ends with "/.". The resulting path will be a
8045 directory even if the given path is a symbolic link. */
8046 len1
= strlen (path1
);
8047 path
= (char *) alloca (3 + len1
);
8048 memcpy (path
, path1
, len1
);
8050 if (!IS_DIR_SEPARATOR (cp
[-1]))
8051 *cp
++ = DIR_SEPARATOR
;
8055 /* Exclude directories that the linker is known to search. */
8057 && IS_DIR_SEPARATOR (path
[0])
8059 && filename_ncmp (path
+ 1, "lib", 3) == 0)
8061 && filename_ncmp (path
+ 1, "usr", 3) == 0
8062 && IS_DIR_SEPARATOR (path
[4])
8063 && filename_ncmp (path
+ 5, "lib", 3) == 0)))
8066 return (stat (path
, &st
) >= 0 && S_ISDIR (st
.st_mode
));
8069 /* Set up the various global variables to indicate that we're processing
8070 the input file named FILENAME. */
8073 set_input (const char *filename
)
8077 gcc_input_filename
= filename
;
8078 input_filename_length
= strlen (gcc_input_filename
);
8079 input_basename
= lbasename (gcc_input_filename
);
8081 /* Find a suffix starting with the last period,
8082 and set basename_length to exclude that suffix. */
8083 basename_length
= strlen (input_basename
);
8084 suffixed_basename_length
= basename_length
;
8085 p
= input_basename
+ basename_length
;
8086 while (p
!= input_basename
&& *p
!= '.')
8088 if (*p
== '.' && p
!= input_basename
)
8090 basename_length
= p
- input_basename
;
8091 input_suffix
= p
+ 1;
8096 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
8097 we will need to do a stat on the gcc_input_filename. The
8098 INPUT_STAT_SET signals that the stat is needed. */
8102 /* On fatal signals, delete all the temporary files. */
8105 fatal_signal (int signum
)
8107 signal (signum
, SIG_DFL
);
8108 delete_failure_queue ();
8109 delete_temp_files ();
8110 /* Get the same signal again, this time not handled,
8111 so its normal effect occurs. */
8112 kill (getpid (), signum
);
8115 /* Compare the contents of the two files named CMPFILE[0] and
8116 CMPFILE[1]. Return zero if they're identical, nonzero
8120 compare_files (char *cmpfile
[])
8123 FILE *temp
[2] = { NULL
, NULL
};
8129 void *map
[2] = { NULL
, NULL
};
8131 for (i
= 0; i
< 2; i
++)
8135 if (stat (cmpfile
[i
], &st
) < 0 || !S_ISREG (st
.st_mode
))
8137 error ("%s: could not determine length of compare-debug file %s",
8138 gcc_input_filename
, cmpfile
[i
]);
8143 length
[i
] = st
.st_size
;
8146 if (!ret
&& length
[0] != length
[1])
8148 error ("%s: %<-fcompare-debug%> failure (length)", gcc_input_filename
);
8153 for (i
= 0; i
< 2; i
++)
8155 int fd
= open (cmpfile
[i
], O_RDONLY
);
8158 error ("%s: could not open compare-debug file %s",
8159 gcc_input_filename
, cmpfile
[i
]);
8164 map
[i
] = mmap (NULL
, length
[i
], PROT_READ
, MAP_PRIVATE
, fd
, 0);
8167 if (map
[i
] == (void *) MAP_FAILED
)
8176 if (memcmp (map
[0], map
[1], length
[0]) != 0)
8178 error ("%s: %<-fcompare-debug%> failure", gcc_input_filename
);
8183 for (i
= 0; i
< 2; i
++)
8185 munmap ((caddr_t
) map
[i
], length
[i
]);
8194 for (i
= 0; i
< 2; i
++)
8196 temp
[i
] = fopen (cmpfile
[i
], "r");
8199 error ("%s: could not open compare-debug file %s",
8200 gcc_input_filename
, cmpfile
[i
]);
8206 if (!ret
&& temp
[0] && temp
[1])
8210 c0
= fgetc (temp
[0]);
8211 c1
= fgetc (temp
[1]);
8215 error ("%s: %<-fcompare-debug%> failure",
8216 gcc_input_filename
);
8225 for (i
= 1; i
>= 0; i
--)
8234 driver::driver (bool can_finalize
, bool debug
) :
8235 explicit_link_files (NULL
),
8236 decoded_options (NULL
)
8238 env
.init (can_finalize
, debug
);
8243 XDELETEVEC (explicit_link_files
);
8244 XDELETEVEC (decoded_options
);
8247 /* driver::main is implemented as a series of driver:: method calls. */
8250 driver::main (int argc
, char **argv
)
8254 set_progname (argv
[0]);
8255 expand_at_files (&argc
, &argv
);
8256 decode_argv (argc
, const_cast <const char **> (argv
));
8257 global_initializations ();
8258 build_multilib_strings ();
8260 putenv_COLLECT_AS_OPTIONS (assembler_options
);
8261 putenv_COLLECT_GCC (argv
[0]);
8262 maybe_putenv_COLLECT_LTO_WRAPPER ();
8263 maybe_putenv_OFFLOAD_TARGETS ();
8264 handle_unrecognized_options ();
8268 m_option_proposer
.suggest_completion (completion
);
8272 if (!maybe_print_and_exit ())
8275 early_exit
= prepare_infiles ();
8277 return get_exit_code ();
8279 do_spec_on_infiles ();
8280 maybe_run_linker (argv
[0]);
8282 return get_exit_code ();
8285 /* Locate the final component of argv[0] after any leading path, and set
8286 the program name accordingly. */
8289 driver::set_progname (const char *argv0
) const
8291 const char *p
= argv0
+ strlen (argv0
);
8292 while (p
!= argv0
&& !IS_DIR_SEPARATOR (p
[-1]))
8296 xmalloc_set_program_name (progname
);
8299 /* Expand any @ files within the command-line args,
8300 setting at_file_supplied if any were expanded. */
8303 driver::expand_at_files (int *argc
, char ***argv
) const
8305 char **old_argv
= *argv
;
8307 expandargv (argc
, argv
);
8309 /* Determine if any expansions were made. */
8310 if (*argv
!= old_argv
)
8311 at_file_supplied
= true;
8314 /* Decode the command-line arguments from argc/argv into the
8315 decoded_options array. */
8318 driver::decode_argv (int argc
, const char **argv
)
8320 init_opts_obstack ();
8321 init_options_struct (&global_options
, &global_options_set
);
8323 decode_cmdline_options_to_array (argc
, argv
,
8325 &decoded_options
, &decoded_options_count
);
8328 /* Perform various initializations and setup. */
8331 driver::global_initializations ()
8333 /* Unlock the stdio streams. */
8334 unlock_std_streams ();
8336 gcc_init_libintl ();
8338 diagnostic_initialize (global_dc
, 0);
8339 diagnostic_color_init (global_dc
);
8340 diagnostic_urls_init (global_dc
);
8341 global_dc
->set_urlifier (make_gcc_urlifier ());
8343 #ifdef GCC_DRIVER_HOST_INITIALIZATION
8344 /* Perform host dependent initialization when needed. */
8345 GCC_DRIVER_HOST_INITIALIZATION
;
8348 if (atexit (delete_temp_files
) != 0)
8349 fatal_error (input_location
, "atexit failed");
8351 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
8352 signal (SIGINT
, fatal_signal
);
8354 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
8355 signal (SIGHUP
, fatal_signal
);
8357 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
8358 signal (SIGTERM
, fatal_signal
);
8360 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
8361 signal (SIGPIPE
, fatal_signal
);
8364 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
8365 receive the signal. A different setting is inheritable */
8366 signal (SIGCHLD
, SIG_DFL
);
8369 /* Parsing and gimplification sometimes need quite large stack.
8370 Increase stack size limits if possible. */
8371 stack_limit_increase (64 * 1024 * 1024);
8373 /* Allocate the argument vector. */
8376 obstack_init (&obstack
);
8379 /* Build multilib_select, et. al from the separate lines that make up each
8380 multilib selection. */
8383 driver::build_multilib_strings () const
8387 const char *const *q
= multilib_raw
;
8390 obstack_init (&multilib_obstack
);
8391 while ((p
= *q
++) != (char *) 0)
8392 obstack_grow (&multilib_obstack
, p
, strlen (p
));
8394 obstack_1grow (&multilib_obstack
, 0);
8395 multilib_select
= XOBFINISH (&multilib_obstack
, const char *);
8397 q
= multilib_matches_raw
;
8398 while ((p
= *q
++) != (char *) 0)
8399 obstack_grow (&multilib_obstack
, p
, strlen (p
));
8401 obstack_1grow (&multilib_obstack
, 0);
8402 multilib_matches
= XOBFINISH (&multilib_obstack
, const char *);
8404 q
= multilib_exclusions_raw
;
8405 while ((p
= *q
++) != (char *) 0)
8406 obstack_grow (&multilib_obstack
, p
, strlen (p
));
8408 obstack_1grow (&multilib_obstack
, 0);
8409 multilib_exclusions
= XOBFINISH (&multilib_obstack
, const char *);
8411 q
= multilib_reuse_raw
;
8412 while ((p
= *q
++) != (char *) 0)
8413 obstack_grow (&multilib_obstack
, p
, strlen (p
));
8415 obstack_1grow (&multilib_obstack
, 0);
8416 multilib_reuse
= XOBFINISH (&multilib_obstack
, const char *);
8419 for (size_t i
= 0; i
< ARRAY_SIZE (multilib_defaults_raw
); i
++)
8422 obstack_1grow (&multilib_obstack
, ' ');
8423 obstack_grow (&multilib_obstack
,
8424 multilib_defaults_raw
[i
],
8425 strlen (multilib_defaults_raw
[i
]));
8429 obstack_1grow (&multilib_obstack
, 0);
8430 multilib_defaults
= XOBFINISH (&multilib_obstack
, const char *);
8434 /* Set up the spec-handling machinery. */
8437 driver::set_up_specs () const
8439 const char *spec_machine_suffix
;
8443 #ifdef INIT_ENVIRONMENT
8444 /* Set up any other necessary machine specific environment variables. */
8445 xputenv (INIT_ENVIRONMENT
);
8448 /* Make a table of what switches there are (switches, n_switches).
8449 Make a table of specified input files (infiles, n_infiles).
8450 Decode switches that are handled locally. */
8452 process_command (decoded_options_count
, decoded_options
);
8454 /* Initialize the vector of specs to just the default.
8455 This means one element containing 0s, as a terminator. */
8457 compilers
= XNEWVAR (struct compiler
, sizeof default_compilers
);
8458 memcpy (compilers
, default_compilers
, sizeof default_compilers
);
8459 n_compilers
= n_default_compilers
;
8461 /* Read specs from a file if there is one. */
8463 machine_suffix
= concat (spec_host_machine
, dir_separator_str
, spec_version
,
8464 accel_dir_suffix
, dir_separator_str
, NULL
);
8465 just_machine_suffix
= concat (spec_machine
, dir_separator_str
, NULL
);
8467 specs_file
= find_a_file (&startfile_prefixes
, "specs", R_OK
, true);
8468 /* Read the specs file unless it is a default one. */
8469 if (specs_file
!= 0 && strcmp (specs_file
, "specs"))
8470 read_specs (specs_file
, true, false);
8474 #ifdef ACCEL_COMPILER
8475 spec_machine_suffix
= machine_suffix
;
8477 spec_machine_suffix
= just_machine_suffix
;
8480 /* We need to check standard_exec_prefix/spec_machine_suffix/specs
8481 for any override of as, ld and libraries. */
8482 specs_file
= (char *) alloca (strlen (standard_exec_prefix
)
8483 + strlen (spec_machine_suffix
) + sizeof ("specs"));
8484 strcpy (specs_file
, standard_exec_prefix
);
8485 strcat (specs_file
, spec_machine_suffix
);
8486 strcat (specs_file
, "specs");
8487 if (access (specs_file
, R_OK
) == 0)
8488 read_specs (specs_file
, true, false);
8490 /* Process any configure-time defaults specified for the command line
8491 options, via OPTION_DEFAULT_SPECS. */
8492 for (i
= 0; i
< ARRAY_SIZE (option_default_specs
); i
++)
8493 do_option_spec (option_default_specs
[i
].name
,
8494 option_default_specs
[i
].spec
);
8496 /* Process DRIVER_SELF_SPECS, adding any new options to the end
8497 of the command line. */
8499 for (i
= 0; i
< ARRAY_SIZE (driver_self_specs
); i
++)
8500 do_self_spec (driver_self_specs
[i
]);
8502 /* If not cross-compiling, look for executables in the standard
8504 if (*cross_compile
== '0')
8506 if (*md_exec_prefix
)
8508 add_prefix (&exec_prefixes
, md_exec_prefix
, "GCC",
8509 PREFIX_PRIORITY_LAST
, 0, 0);
8513 /* Process sysroot_suffix_spec. */
8514 if (*sysroot_suffix_spec
!= 0
8515 && !no_sysroot_suffix
8516 && do_spec_2 (sysroot_suffix_spec
, NULL
) == 0)
8518 if (argbuf
.length () > 1)
8519 error ("spec failure: more than one argument to "
8520 "%<SYSROOT_SUFFIX_SPEC%>");
8521 else if (argbuf
.length () == 1)
8522 target_sysroot_suffix
= xstrdup (argbuf
.last ());
8525 #ifdef HAVE_LD_SYSROOT
8526 /* Pass the --sysroot option to the linker, if it supports that. If
8527 there is a sysroot_suffix_spec, it has already been processed by
8528 this point, so target_system_root really is the system root we
8530 if (target_system_root
)
8532 obstack_grow (&obstack
, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
8533 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
8534 set_spec ("link", XOBFINISH (&obstack
, const char *), false);
8538 /* Process sysroot_hdrs_suffix_spec. */
8539 if (*sysroot_hdrs_suffix_spec
!= 0
8540 && !no_sysroot_suffix
8541 && do_spec_2 (sysroot_hdrs_suffix_spec
, NULL
) == 0)
8543 if (argbuf
.length () > 1)
8544 error ("spec failure: more than one argument "
8545 "to %<SYSROOT_HEADERS_SUFFIX_SPEC%>");
8546 else if (argbuf
.length () == 1)
8547 target_sysroot_hdrs_suffix
= xstrdup (argbuf
.last ());
8550 /* Look for startfiles in the standard places. */
8551 if (*startfile_prefix_spec
!= 0
8552 && do_spec_2 (startfile_prefix_spec
, NULL
) == 0
8553 && do_spec_1 (" ", 0, NULL
) == 0)
8555 for (const char *arg
: argbuf
)
8556 add_sysrooted_prefix (&startfile_prefixes
, arg
, "BINUTILS",
8557 PREFIX_PRIORITY_LAST
, 0, 1);
8559 /* We should eventually get rid of all these and stick to
8560 startfile_prefix_spec exclusively. */
8561 else if (*cross_compile
== '0' || target_system_root
)
8563 if (*md_startfile_prefix
)
8564 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix
,
8565 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
8567 if (*md_startfile_prefix_1
)
8568 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix_1
,
8569 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
8571 /* If standard_startfile_prefix is relative, base it on
8572 standard_exec_prefix. This lets us move the installed tree
8573 as a unit. If GCC_EXEC_PREFIX is defined, base
8574 standard_startfile_prefix on that as well.
8576 If the prefix is relative, only search it for native compilers;
8577 otherwise we will search a directory containing host libraries. */
8578 if (IS_ABSOLUTE_PATH (standard_startfile_prefix
))
8579 add_sysrooted_prefix (&startfile_prefixes
,
8580 standard_startfile_prefix
, "BINUTILS",
8581 PREFIX_PRIORITY_LAST
, 0, 1);
8582 else if (*cross_compile
== '0')
8584 add_prefix (&startfile_prefixes
,
8585 concat (gcc_exec_prefix
8586 ? gcc_exec_prefix
: standard_exec_prefix
,
8588 standard_startfile_prefix
, NULL
),
8589 NULL
, PREFIX_PRIORITY_LAST
, 0, 1);
8592 /* Sysrooted prefixes are relocated because target_system_root is
8593 also relocated by gcc_exec_prefix. */
8594 if (*standard_startfile_prefix_1
)
8595 add_sysrooted_prefix (&startfile_prefixes
,
8596 standard_startfile_prefix_1
, "BINUTILS",
8597 PREFIX_PRIORITY_LAST
, 0, 1);
8598 if (*standard_startfile_prefix_2
)
8599 add_sysrooted_prefix (&startfile_prefixes
,
8600 standard_startfile_prefix_2
, "BINUTILS",
8601 PREFIX_PRIORITY_LAST
, 0, 1);
8604 /* Process any user specified specs in the order given on the command
8606 for (struct user_specs
*uptr
= user_specs_head
; uptr
; uptr
= uptr
->next
)
8608 char *filename
= find_a_file (&startfile_prefixes
, uptr
->filename
,
8610 read_specs (filename
? filename
: uptr
->filename
, false, true);
8613 /* Process any user self specs. */
8615 struct spec_list
*sl
;
8616 for (sl
= specs
; sl
; sl
= sl
->next
)
8617 if (sl
->name_len
== sizeof "self_spec" - 1
8618 && !strcmp (sl
->name
, "self_spec"))
8619 do_self_spec (*sl
->ptr_spec
);
8624 enum save_temps save
;
8626 if (!compare_debug_second
)
8628 n_switches_debug_check
[1] = n_switches
;
8629 n_switches_alloc_debug_check
[1] = n_switches_alloc
;
8630 switches_debug_check
[1] = XDUPVEC (struct switchstr
, switches
,
8633 do_self_spec ("%:compare-debug-self-opt()");
8634 n_switches_debug_check
[0] = n_switches
;
8635 n_switches_alloc_debug_check
[0] = n_switches_alloc
;
8636 switches_debug_check
[0] = switches
;
8638 n_switches
= n_switches_debug_check
[1];
8639 n_switches_alloc
= n_switches_alloc_debug_check
[1];
8640 switches
= switches_debug_check
[1];
8643 /* Avoid crash when computing %j in this early. */
8644 save
= save_temps_flag
;
8645 save_temps_flag
= SAVE_TEMPS_NONE
;
8647 compare_debug
= -compare_debug
;
8648 do_self_spec ("%:compare-debug-self-opt()");
8650 save_temps_flag
= save
;
8652 if (!compare_debug_second
)
8654 n_switches_debug_check
[1] = n_switches
;
8655 n_switches_alloc_debug_check
[1] = n_switches_alloc
;
8656 switches_debug_check
[1] = switches
;
8657 compare_debug
= -compare_debug
;
8658 n_switches
= n_switches_debug_check
[0];
8659 n_switches_alloc
= n_switches_debug_check
[0];
8660 switches
= switches_debug_check
[0];
8665 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
8666 if (gcc_exec_prefix
)
8667 gcc_exec_prefix
= concat (gcc_exec_prefix
, spec_host_machine
,
8668 dir_separator_str
, spec_version
,
8669 accel_dir_suffix
, dir_separator_str
, NULL
);
8671 /* Now we have the specs.
8672 Set the `valid' bits for switches that match anything in any spec. */
8674 validate_all_switches ();
8676 /* Now that we have the switches and the specs, set
8677 the subdirectory based on the options. */
8678 set_multilib_dir ();
8681 /* Set up to remember the pathname of gcc and any options
8682 needed for collect. We use argv[0] instead of progname because
8683 we need the complete pathname. */
8686 driver::putenv_COLLECT_GCC (const char *argv0
) const
8688 obstack_init (&collect_obstack
);
8689 obstack_grow (&collect_obstack
, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
8690 obstack_grow (&collect_obstack
, argv0
, strlen (argv0
) + 1);
8691 xputenv (XOBFINISH (&collect_obstack
, char *));
8694 /* Set up to remember the pathname of the lto wrapper. */
8697 driver::maybe_putenv_COLLECT_LTO_WRAPPER () const
8699 char *lto_wrapper_file
;
8702 lto_wrapper_file
= NULL
;
8704 lto_wrapper_file
= find_a_program ("lto-wrapper");
8705 if (lto_wrapper_file
)
8707 lto_wrapper_file
= convert_white_space (lto_wrapper_file
);
8708 set_static_spec_owned (<o_wrapper_spec
, lto_wrapper_file
);
8709 obstack_init (&collect_obstack
);
8710 obstack_grow (&collect_obstack
, "COLLECT_LTO_WRAPPER=",
8711 sizeof ("COLLECT_LTO_WRAPPER=") - 1);
8712 obstack_grow (&collect_obstack
, lto_wrapper_spec
,
8713 strlen (lto_wrapper_spec
) + 1);
8714 xputenv (XOBFINISH (&collect_obstack
, char *));
8719 /* Set up to remember the names of offload targets. */
8722 driver::maybe_putenv_OFFLOAD_TARGETS () const
8724 if (offload_targets
&& offload_targets
[0] != '\0')
8726 obstack_grow (&collect_obstack
, "OFFLOAD_TARGET_NAMES=",
8727 sizeof ("OFFLOAD_TARGET_NAMES=") - 1);
8728 obstack_grow (&collect_obstack
, offload_targets
,
8729 strlen (offload_targets
) + 1);
8730 xputenv (XOBFINISH (&collect_obstack
, char *));
8731 #if OFFLOAD_DEFAULTED
8732 if (offload_targets_default
)
8733 xputenv ("OFFLOAD_TARGET_DEFAULT=1");
8737 free (offload_targets
);
8738 offload_targets
= NULL
;
8741 /* Reject switches that no pass was interested in. */
8744 driver::handle_unrecognized_options ()
8746 for (size_t i
= 0; (int) i
< n_switches
; i
++)
8747 if (! switches
[i
].validated
)
8749 const char *hint
= m_option_proposer
.suggest_option (switches
[i
].part1
);
8751 error ("unrecognized command-line option %<-%s%>;"
8752 " did you mean %<-%s%>?",
8753 switches
[i
].part1
, hint
);
8755 error ("unrecognized command-line option %<-%s%>",
8760 /* Handle the various -print-* options, returning 0 if the driver
8761 should exit, or nonzero if the driver should continue. */
8764 driver::maybe_print_and_exit () const
8766 if (print_search_dirs
)
8768 printf (_("install: %s%s\n"),
8769 gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
8770 gcc_exec_prefix
? "" : machine_suffix
);
8771 printf (_("programs: %s\n"),
8772 build_search_list (&exec_prefixes
, "", false, false));
8773 printf (_("libraries: %s\n"),
8774 build_search_list (&startfile_prefixes
, "", false, true));
8778 if (print_file_name
)
8780 printf ("%s\n", find_file (print_file_name
));
8784 if (print_prog_name
)
8786 if (use_ld
!= NULL
&& ! strcmp (print_prog_name
, "ld"))
8788 /* Append USE_LD to the default linker. */
8789 #ifdef DEFAULT_LINKER
8791 # ifdef HAVE_HOST_EXECUTABLE_SUFFIX
8792 int len
= (sizeof (DEFAULT_LINKER
)
8793 - sizeof (HOST_EXECUTABLE_SUFFIX
));
8797 char *default_linker
= xstrdup (DEFAULT_LINKER
);
8798 /* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains
8799 HOST_EXECUTABLE_SUFFIX. */
8800 if (! strcmp (&default_linker
[len
], HOST_EXECUTABLE_SUFFIX
))
8802 default_linker
[len
] = '\0';
8803 ld
= concat (default_linker
, use_ld
,
8804 HOST_EXECUTABLE_SUFFIX
, NULL
);
8809 ld
= concat (DEFAULT_LINKER
, use_ld
, NULL
);
8810 if (access (ld
, X_OK
) == 0)
8812 printf ("%s\n", ld
);
8816 print_prog_name
= concat (print_prog_name
, use_ld
, NULL
);
8818 char *newname
= find_a_program (print_prog_name
);
8819 printf ("%s\n", (newname
? newname
: print_prog_name
));
8823 if (print_multi_lib
)
8825 print_multilib_info ();
8829 if (print_multi_directory
)
8831 if (multilib_dir
== NULL
)
8834 printf ("%s\n", multilib_dir
);
8838 if (print_multiarch
)
8840 if (multiarch_dir
== NULL
)
8843 printf ("%s\n", multiarch_dir
);
8849 if (target_system_root
)
8851 if (target_sysroot_suffix
)
8852 printf ("%s%s\n", target_system_root
, target_sysroot_suffix
);
8854 printf ("%s\n", target_system_root
);
8859 if (print_multi_os_directory
)
8861 if (multilib_os_dir
== NULL
)
8864 printf ("%s\n", multilib_os_dir
);
8868 if (print_sysroot_headers_suffix
)
8870 if (*sysroot_hdrs_suffix_spec
)
8872 printf("%s\n", (target_sysroot_hdrs_suffix
8873 ? target_sysroot_hdrs_suffix
8878 /* The error status indicates that only one set of fixed
8879 headers should be built. */
8880 fatal_error (input_location
,
8881 "not configured with sysroot headers suffix");
8884 if (print_help_list
)
8890 printf (_("\nFor bug reporting instructions, please see:\n"));
8891 printf ("%s.\n", bug_report_url
);
8896 /* We do not exit here. Instead we have created a fake input file
8897 called 'help-dummy' which needs to be compiled, and we pass this
8898 on the various sub-processes, along with the --help switch.
8899 Ensure their output appears after ours. */
8900 fputc ('\n', stdout
);
8906 printf (_("%s %s%s\n"), progname
, pkgversion_string
,
8908 printf ("Copyright %s 2023 Free Software Foundation, Inc.\n",
8910 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
8911 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
8916 /* We do not exit here. We use the same mechanism of --help to print
8917 the version of the sub-processes. */
8918 fputc ('\n', stdout
);
8924 print_configuration (stderr
);
8932 /* Figure out what to do with each input file.
8933 Return true if we need to exit early from "main", false otherwise. */
8936 driver::prepare_infiles ()
8939 int lang_n_infiles
= 0;
8941 if (n_infiles
== added_libraries
)
8942 fatal_error (input_location
, "no input files");
8945 /* Early exit needed from main. */
8948 /* Make a place to record the compiler output file names
8949 that correspond to the input files. */
8952 i
+= lang_specific_extra_outfiles
;
8953 outfiles
= XCNEWVEC (const char *, i
);
8955 /* Record which files were specified explicitly as link input. */
8957 explicit_link_files
= XCNEWVEC (char, n_infiles
);
8959 combine_inputs
= have_o
|| flag_wpa
;
8961 for (i
= 0; (int) i
< n_infiles
; i
++)
8963 const char *name
= infiles
[i
].name
;
8964 struct compiler
*compiler
= lookup_compiler (name
,
8966 infiles
[i
].language
);
8968 if (compiler
&& !(compiler
->combinable
))
8969 combine_inputs
= false;
8971 if (lang_n_infiles
> 0 && compiler
!= input_file_compiler
8972 && infiles
[i
].language
&& infiles
[i
].language
[0] != '*')
8973 infiles
[i
].incompiler
= compiler
;
8977 input_file_compiler
= compiler
;
8978 infiles
[i
].incompiler
= compiler
;
8982 /* Since there is no compiler for this input file, assume it is a
8984 explicit_link_files
[i
] = 1;
8985 infiles
[i
].incompiler
= NULL
;
8987 infiles
[i
].compiled
= false;
8988 infiles
[i
].preprocessed
= false;
8991 if (!combine_inputs
&& have_c
&& have_o
&& lang_n_infiles
> 1)
8992 fatal_error (input_location
,
8993 "cannot specify %<-o%> with %<-c%>, %<-S%> or %<-E%> "
8994 "with multiple files");
8996 /* No early exit needed from main; we can continue. */
9000 /* Run the spec machinery on each input file. */
9003 driver::do_spec_on_infiles () const
9007 for (i
= 0; (int) i
< n_infiles
; i
++)
9009 int this_file_error
= 0;
9011 /* Tell do_spec what to substitute for %i. */
9013 input_file_number
= i
;
9014 set_input (infiles
[i
].name
);
9016 if (infiles
[i
].compiled
)
9019 /* Use the same thing in %o, unless cp->spec says otherwise. */
9021 outfiles
[i
] = gcc_input_filename
;
9023 /* Figure out which compiler from the file's suffix. */
9026 = lookup_compiler (infiles
[i
].name
, input_filename_length
,
9027 infiles
[i
].language
);
9029 if (input_file_compiler
)
9031 /* Ok, we found an applicable compiler. Run its spec. */
9033 if (input_file_compiler
->spec
[0] == '#')
9035 error ("%s: %s compiler not installed on this system",
9036 gcc_input_filename
, &input_file_compiler
->spec
[1]);
9037 this_file_error
= 1;
9045 free (debug_check_temp_file
[0]);
9046 debug_check_temp_file
[0] = NULL
;
9048 free (debug_check_temp_file
[1]);
9049 debug_check_temp_file
[1] = NULL
;
9052 value
= do_spec (input_file_compiler
->spec
);
9053 infiles
[i
].compiled
= true;
9055 this_file_error
= 1;
9056 else if (compare_debug
&& debug_check_temp_file
[0])
9059 inform (UNKNOWN_LOCATION
,
9060 "recompiling with %<-fcompare-debug%>");
9062 compare_debug
= -compare_debug
;
9063 n_switches
= n_switches_debug_check
[1];
9064 n_switches_alloc
= n_switches_alloc_debug_check
[1];
9065 switches
= switches_debug_check
[1];
9067 value
= do_spec (input_file_compiler
->spec
);
9069 compare_debug
= -compare_debug
;
9070 n_switches
= n_switches_debug_check
[0];
9071 n_switches_alloc
= n_switches_alloc_debug_check
[0];
9072 switches
= switches_debug_check
[0];
9076 error ("during %<-fcompare-debug%> recompilation");
9077 this_file_error
= 1;
9080 gcc_assert (debug_check_temp_file
[1]
9081 && filename_cmp (debug_check_temp_file
[0],
9082 debug_check_temp_file
[1]));
9085 inform (UNKNOWN_LOCATION
, "comparing final insns dumps");
9087 if (compare_files (debug_check_temp_file
))
9088 this_file_error
= 1;
9093 free (debug_check_temp_file
[0]);
9094 debug_check_temp_file
[0] = NULL
;
9096 free (debug_check_temp_file
[1]);
9097 debug_check_temp_file
[1] = NULL
;
9102 /* If this file's name does not contain a recognized suffix,
9103 record it as explicit linker input. */
9106 explicit_link_files
[i
] = 1;
9108 /* Clear the delete-on-failure queue, deleting the files in it
9109 if this compilation failed. */
9111 if (this_file_error
)
9113 delete_failure_queue ();
9116 /* If this compilation succeeded, don't delete those files later. */
9117 clear_failure_queue ();
9120 /* Reset the input file name to the first compile/object file name, for use
9121 with %b in LINK_SPEC. We use the first input file that we can find
9122 a compiler to compile it instead of using infiles.language since for
9123 languages other than C we use aliases that we then lookup later. */
9128 for (i
= 0; i
< n_infiles
; i
++)
9129 if (infiles
[i
].incompiler
9130 || (infiles
[i
].language
&& infiles
[i
].language
[0] != '*'))
9132 set_input (infiles
[i
].name
);
9139 /* Make sure INPUT_FILE_NUMBER points to first available open
9141 input_file_number
= n_infiles
;
9142 if (lang_specific_pre_link ())
9147 /* If we have to run the linker, do it now. */
9150 driver::maybe_run_linker (const char *argv0
) const
9153 int linker_was_run
= 0;
9154 int num_linker_inputs
;
9156 /* Determine if there are any linker input files. */
9157 num_linker_inputs
= 0;
9158 for (i
= 0; (int) i
< n_infiles
; i
++)
9159 if (explicit_link_files
[i
] || outfiles
[i
] != NULL
)
9160 num_linker_inputs
++;
9162 /* Arrange for temporary file names created during linking to take
9163 on names related with the linker output rather than with the
9164 inputs when appropriate. */
9165 if (outbase
&& *outbase
)
9169 char *tofree
= dumpdir
;
9170 gcc_checking_assert (strlen (dumpdir
) == dumpdir_length
);
9171 dumpdir
= concat (dumpdir
, outbase
, ".", NULL
);
9175 dumpdir
= concat (outbase
, ".", NULL
);
9176 dumpdir_length
+= strlen (outbase
) + 1;
9177 dumpdir_trailing_dash_added
= true;
9179 else if (dumpdir_trailing_dash_added
)
9181 gcc_assert (dumpdir
[dumpdir_length
- 1] == '-');
9182 dumpdir
[dumpdir_length
- 1] = '.';
9185 if (dumpdir_trailing_dash_added
)
9187 gcc_assert (dumpdir_length
> 0);
9188 gcc_assert (dumpdir
[dumpdir_length
- 1] == '.');
9193 input_basename
= outbase
= NULL
;
9194 outbase_length
= suffixed_basename_length
= basename_length
= 0;
9196 /* Run ld to link all the compiler output files. */
9198 if (num_linker_inputs
> 0 && !seen_error () && print_subprocess_help
< 2)
9200 int tmp
= execution_count
;
9202 detect_jobserver ();
9206 #if HAVE_LTO_PLUGIN > 0
9207 #if HAVE_LTO_PLUGIN == 2
9208 const char *fno_use_linker_plugin
= "fno-use-linker-plugin";
9210 const char *fuse_linker_plugin
= "fuse-linker-plugin";
9214 /* We'll use ld if we can't find collect2. */
9215 if (! strcmp (linker_name_spec
, "collect2"))
9217 char *s
= find_a_program ("collect2");
9219 set_static_spec_shared (&linker_name_spec
, "ld");
9222 #if HAVE_LTO_PLUGIN > 0
9223 #if HAVE_LTO_PLUGIN == 2
9224 if (!switch_matches (fno_use_linker_plugin
,
9225 fno_use_linker_plugin
9226 + strlen (fno_use_linker_plugin
), 0))
9228 if (switch_matches (fuse_linker_plugin
,
9230 + strlen (fuse_linker_plugin
), 0))
9233 char *temp_spec
= find_a_file (&exec_prefixes
,
9234 LTOPLUGINSONAME
, R_OK
,
9237 fatal_error (input_location
,
9238 "%<-fuse-linker-plugin%>, but %s not found",
9240 linker_plugin_file_spec
= convert_white_space (temp_spec
);
9243 set_static_spec_shared (<o_gcc_spec
, argv0
);
9246 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
9248 putenv_from_prefixes (&exec_prefixes
, "COMPILER_PATH", false);
9249 putenv_from_prefixes (&startfile_prefixes
, LIBRARY_PATH_ENV
, true);
9251 if (print_subprocess_help
== 1)
9253 printf (_("\nLinker options\n==============\n\n"));
9254 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
9255 " to the linker.\n\n"));
9258 int value
= do_spec (link_command_spec
);
9261 linker_was_run
= (tmp
!= execution_count
);
9264 /* If options said don't run linker,
9265 complain about input files to be given to the linker. */
9267 if (! linker_was_run
&& !seen_error ())
9268 for (i
= 0; (int) i
< n_infiles
; i
++)
9269 if (explicit_link_files
[i
]
9270 && !(infiles
[i
].language
&& infiles
[i
].language
[0] == '*'))
9272 warning (0, "%s: linker input file unused because linking not done",
9274 if (access (outfiles
[i
], F_OK
) < 0)
9275 /* This is can be an indication the user specifed an errorneous
9276 separated option value, (or used the wrong prefix for an
9278 error ("%s: linker input file not found: %m", outfiles
[i
]);
9282 /* The end of "main". */
9285 driver::final_actions () const
9287 /* Delete some or all of the temporary files we made. */
9290 delete_failure_queue ();
9291 delete_temp_files ();
9293 if (print_help_list
)
9295 printf (("\nFor bug reporting instructions, please see:\n"));
9296 printf ("%s\n", bug_report_url
);
9300 /* Detect whether jobserver is active and working. If not drop
9301 --jobserver-auth from MAKEFLAGS. */
9304 driver::detect_jobserver () const
9306 jobserver_info jinfo
;
9307 if (!jinfo
.is_active
&& !jinfo
.skipped_makeflags
.empty ())
9308 xputenv (xstrdup (jinfo
.skipped_makeflags
.c_str ()));
9311 /* Determine what the exit code of the driver should be. */
9314 driver::get_exit_code () const
9316 return (signal_count
!= 0 ? 2
9317 : seen_error () ? (pass_exit_codes
? greatest_status
: 1)
9321 /* Find the proper compilation spec for the file name NAME,
9322 whose length is LENGTH. LANGUAGE is the specified language,
9323 or 0 if this file is to be passed to the linker. */
9325 static struct compiler
*
9326 lookup_compiler (const char *name
, size_t length
, const char *language
)
9328 struct compiler
*cp
;
9330 /* If this was specified by the user to be a linker input, indicate that. */
9331 if (language
!= 0 && language
[0] == '*')
9334 /* Otherwise, look for the language, if one is spec'd. */
9337 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
9338 if (cp
->suffix
[0] == '@' && !strcmp (cp
->suffix
+ 1, language
))
9340 if (name
!= NULL
&& strcmp (name
, "-") == 0
9341 && (strcmp (cp
->suffix
, "@c-header") == 0
9342 || strcmp (cp
->suffix
, "@c++-header") == 0)
9344 fatal_error (input_location
,
9345 "cannot use %<-%> as input filename for a "
9346 "precompiled header");
9351 error ("language %s not recognized", language
);
9355 /* Look for a suffix. */
9356 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
9358 if (/* The suffix `-' matches only the file name `-'. */
9359 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
9360 || (strlen (cp
->suffix
) < length
9361 /* See if the suffix matches the end of NAME. */
9362 && !strcmp (cp
->suffix
,
9363 name
+ length
- strlen (cp
->suffix
))
9368 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
9369 /* Look again, but case-insensitively this time. */
9371 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
9373 if (/* The suffix `-' matches only the file name `-'. */
9374 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
9375 || (strlen (cp
->suffix
) < length
9376 /* See if the suffix matches the end of NAME. */
9377 && ((!strcmp (cp
->suffix
,
9378 name
+ length
- strlen (cp
->suffix
))
9379 || !strpbrk (cp
->suffix
, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
9380 && !strcasecmp (cp
->suffix
,
9381 name
+ length
- strlen (cp
->suffix
)))
9387 if (cp
>= compilers
)
9389 if (cp
->spec
[0] != '@')
9390 /* A non-alias entry: return it. */
9393 /* An alias entry maps a suffix to a language.
9394 Search for the language; pass 0 for NAME and LENGTH
9395 to avoid infinite recursion if language not found. */
9396 return lookup_compiler (NULL
, 0, cp
->spec
+ 1);
9402 save_string (const char *s
, int len
)
9404 char *result
= XNEWVEC (char, len
+ 1);
9406 gcc_checking_assert (strlen (s
) >= (unsigned int) len
);
9407 memcpy (result
, s
, len
);
9414 validate_switches_from_spec (const char *spec
, bool user
)
9416 const char *p
= spec
;
9422 || (*p
== 'W' && *++p
== '{')
9423 || (*p
== '@' && *++p
== '{')))
9424 /* We have a switch spec. */
9425 p
= validate_switches (p
+ 1, user
, *p
== '{');
9429 validate_all_switches (void)
9431 struct compiler
*comp
;
9432 struct spec_list
*spec
;
9434 for (comp
= compilers
; comp
->spec
; comp
++)
9435 validate_switches_from_spec (comp
->spec
, false);
9437 /* Look through the linked list of specs read from the specs file. */
9438 for (spec
= specs
; spec
; spec
= spec
->next
)
9439 validate_switches_from_spec (*spec
->ptr_spec
, spec
->user_p
);
9441 validate_switches_from_spec (link_command_spec
, false);
9444 /* Look at the switch-name that comes after START and mark as valid
9445 all supplied switches that match it. If BRACED, handle other
9446 switches after '|' and '&', and specs after ':' until ';' or '}',
9447 going back for more switches after ';'. Without BRACED, handle
9448 only one atom. Return a pointer to whatever follows the handled
9449 items, after the closing brace if BRACED. */
9452 validate_switches (const char *start
, bool user_spec
, bool braced
)
9454 const char *p
= start
;
9461 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
9473 if (*p
== '.' || *p
== ',')
9477 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
9478 || *p
== ',' || *p
== '.' || *p
== '@')
9483 starred
= true, p
++;
9489 /* Mark all matching switches as valid. */
9490 for (i
= 0; i
< n_switches
; i
++)
9491 if (!strncmp (switches
[i
].part1
, atom
, len
)
9492 && (starred
|| switches
[i
].part1
[len
] == '\0')
9493 && (switches
[i
].known
|| user_spec
))
9494 switches
[i
].validated
= true;
9501 if (*p
&& (p
[-1] == '|' || p
[-1] == '&'))
9504 if (*p
&& p
[-1] == ':')
9506 while (*p
&& *p
!= ';' && *p
!= '}')
9511 if (*p
== '{' || *p
== '<')
9512 p
= validate_switches (p
+1, user_spec
, *p
== '{');
9513 else if (p
[0] == 'W' && p
[1] == '{')
9514 p
= validate_switches (p
+2, user_spec
, true);
9515 else if (p
[0] == '@' && p
[1] == '{')
9516 p
= validate_switches (p
+2, user_spec
, true);
9523 if (*p
&& p
[-1] == ';')
9537 static struct mdswitchstr
*mdswitches
;
9538 static int n_mdswitches
;
9540 /* Check whether a particular argument was used. The first time we
9541 canonicalize the switches to keep only the ones we care about. */
9546 int operator () (const char *p
, int len
);
9553 const char *replace
;
9558 mswitchstr
*mswitches
;
9563 used_arg_t used_arg
;
9566 used_arg_t::operator () (const char *p
, int len
)
9572 struct mswitchstr
*matches
;
9576 /* Break multilib_matches into the component strings of string
9577 and replacement string. */
9578 for (q
= multilib_matches
; *q
!= '\0'; q
++)
9583 = (struct mswitchstr
*) alloca ((sizeof (struct mswitchstr
)) * cnt
);
9585 q
= multilib_matches
;
9594 fatal_error (input_location
, "multilib spec %qs is invalid",
9599 matches
[i
].len
= q
- matches
[i
].str
;
9601 matches
[i
].replace
= ++q
;
9602 while (*q
!= ';' && *q
!= '\0')
9605 goto invalid_matches
;
9608 matches
[i
].rep_len
= q
- matches
[i
].replace
;
9614 /* Now build a list of the replacement string for switches that we care
9615 about. Make sure we allocate at least one entry. This prevents
9616 xmalloc from calling fatal, and prevents us from re-executing this
9619 = XNEWVEC (struct mswitchstr
, n_mdswitches
+ (n_switches
? n_switches
: 1));
9620 for (i
= 0; i
< n_switches
; i
++)
9621 if ((switches
[i
].live_cond
& SWITCH_IGNORE
) == 0)
9623 int xlen
= strlen (switches
[i
].part1
);
9624 for (j
= 0; j
< cnt
; j
++)
9625 if (xlen
== matches
[j
].len
9626 && ! strncmp (switches
[i
].part1
, matches
[j
].str
, xlen
))
9628 mswitches
[n_mswitches
].str
= matches
[j
].replace
;
9629 mswitches
[n_mswitches
].len
= matches
[j
].rep_len
;
9630 mswitches
[n_mswitches
].replace
= (char *) 0;
9631 mswitches
[n_mswitches
].rep_len
= 0;
9637 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
9638 on the command line nor any options mutually incompatible with
9640 for (i
= 0; i
< n_mdswitches
; i
++)
9644 for (q
= multilib_options
; *q
!= '\0'; *q
&& q
++)
9650 while (strncmp (q
, mdswitches
[i
].str
, mdswitches
[i
].len
) != 0
9651 || strchr (" /", q
[mdswitches
[i
].len
]) == NULL
)
9653 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
9660 if (*q
!= ' ' && *q
!= '\0')
9662 while (*r
!= ' ' && *r
!= '\0')
9665 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
9668 if (used_arg (r
, q
- r
))
9673 mswitches
[n_mswitches
].str
= mdswitches
[i
].str
;
9674 mswitches
[n_mswitches
].len
= mdswitches
[i
].len
;
9675 mswitches
[n_mswitches
].replace
= (char *) 0;
9676 mswitches
[n_mswitches
].rep_len
= 0;
9689 for (i
= 0; i
< n_mswitches
; i
++)
9690 if (len
== mswitches
[i
].len
&& ! strncmp (p
, mswitches
[i
].str
, len
))
9696 void used_arg_t::finalize ()
9698 XDELETEVEC (mswitches
);
9705 default_arg (const char *p
, int len
)
9709 for (i
= 0; i
< n_mdswitches
; i
++)
9710 if (len
== mdswitches
[i
].len
&& ! strncmp (p
, mdswitches
[i
].str
, len
))
9716 /* Work out the subdirectory to use based on the options. The format of
9717 multilib_select is a list of elements. Each element is a subdirectory
9718 name followed by a list of options followed by a semicolon. The format
9719 of multilib_exclusions is the same, but without the preceding
9720 directory. First gcc will check the exclusions, if none of the options
9721 beginning with an exclamation point are present, and all of the other
9722 options are present, then we will ignore this completely. Passing
9723 that, gcc will consider each multilib_select in turn using the same
9724 rules for matching the options. If a match is found, that subdirectory
9726 A subdirectory name is optionally followed by a colon and the corresponding
9730 set_multilib_dir (void)
9733 unsigned int this_path_len
;
9734 const char *this_path
, *this_arg
;
9735 const char *start
, *end
;
9737 int ok
, ndfltok
, first
;
9740 start
= multilib_defaults
;
9741 while (*start
== ' ' || *start
== '\t')
9743 while (*start
!= '\0')
9746 while (*start
!= ' ' && *start
!= '\t' && *start
!= '\0')
9748 while (*start
== ' ' || *start
== '\t')
9756 mdswitches
= XNEWVEC (struct mdswitchstr
, n_mdswitches
);
9757 for (start
= multilib_defaults
; *start
!= '\0'; start
= end
+ 1)
9759 while (*start
== ' ' || *start
== '\t')
9765 for (end
= start
+ 1;
9766 *end
!= ' ' && *end
!= '\t' && *end
!= '\0'; end
++)
9769 obstack_grow (&multilib_obstack
, start
, end
- start
);
9770 obstack_1grow (&multilib_obstack
, 0);
9771 mdswitches
[i
].str
= XOBFINISH (&multilib_obstack
, const char *);
9772 mdswitches
[i
++].len
= end
- start
;
9779 p
= multilib_exclusions
;
9782 /* Ignore newlines. */
9789 /* Check the arguments. */
9796 fatal_error (input_location
, "multilib exclusions %qs is invalid",
9797 multilib_exclusions
);
9807 while (*p
!= ' ' && *p
!= ';')
9810 goto invalid_exclusions
;
9814 if (*this_arg
!= '!')
9822 ok
= used_arg (this_arg
, p
- this_arg
);
9837 p
= multilib_select
;
9839 /* Append multilib reuse rules if any. With those rules, we can reuse
9840 one multilib for certain different options sets. */
9841 if (strlen (multilib_reuse
) > 0)
9842 p
= concat (p
, multilib_reuse
, NULL
);
9846 /* Ignore newlines. */
9853 /* Get the initial path. */
9860 fatal_error (input_location
, "multilib select %qs %qs is invalid",
9861 multilib_select
, multilib_reuse
);
9865 this_path_len
= p
- this_path
;
9867 /* Check the arguments. */
9874 goto invalid_select
;
9883 while (*p
!= ' ' && *p
!= ';')
9886 goto invalid_select
;
9890 if (*this_arg
!= '!')
9898 /* If this is a default argument, we can just ignore it.
9899 This is true even if this_arg begins with '!'. Beginning
9900 with '!' does not mean that this argument is necessarily
9901 inappropriate for this library: it merely means that
9902 there is a more specific library which uses this
9903 argument. If this argument is a default, we need not
9904 consider that more specific library. */
9905 ok
= used_arg (this_arg
, p
- this_arg
);
9912 if (default_arg (this_arg
, p
- this_arg
))
9921 if (this_path_len
!= 1
9922 || this_path
[0] != '.')
9924 char *new_multilib_dir
= XNEWVEC (char, this_path_len
+ 1);
9927 strncpy (new_multilib_dir
, this_path
, this_path_len
);
9928 new_multilib_dir
[this_path_len
] = '\0';
9929 q
= strchr (new_multilib_dir
, ':');
9932 multilib_dir
= new_multilib_dir
;
9939 const char *q
= this_path
, *end
= this_path
+ this_path_len
;
9941 while (q
< end
&& *q
!= ':')
9945 const char *q2
= q
+ 1, *ml_end
= end
;
9946 char *new_multilib_os_dir
;
9948 while (q2
< end
&& *q2
!= ':')
9952 if (ml_end
- q
== 1)
9953 multilib_os_dir
= xstrdup (".");
9956 new_multilib_os_dir
= XNEWVEC (char, ml_end
- q
);
9957 memcpy (new_multilib_os_dir
, q
+ 1, ml_end
- q
- 1);
9958 new_multilib_os_dir
[ml_end
- q
- 1] = '\0';
9959 multilib_os_dir
= new_multilib_os_dir
;
9962 if (q2
< end
&& *q2
== ':')
9964 char *new_multiarch_dir
= XNEWVEC (char, end
- q2
);
9965 memcpy (new_multiarch_dir
, q2
+ 1, end
- q2
- 1);
9966 new_multiarch_dir
[end
- q2
- 1] = '\0';
9967 multiarch_dir
= new_multiarch_dir
;
9977 targetm_common
.compute_multilib (
9984 multilib_exclusions
,
9987 if (multilib_dir
== NULL
&& multilib_os_dir
!= NULL
9988 && strcmp (multilib_os_dir
, ".") == 0)
9990 free (CONST_CAST (char *, multilib_os_dir
));
9991 multilib_os_dir
= NULL
;
9993 else if (multilib_dir
!= NULL
&& multilib_os_dir
== NULL
)
9994 multilib_os_dir
= multilib_dir
;
9997 /* Print out the multiple library subdirectory selection
9998 information. This prints out a series of lines. Each line looks
9999 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
10000 required. Only the desired options are printed out, the negative
10001 matches. The options are print without a leading dash. There are
10002 no spaces to make it easy to use the information in the shell.
10003 Each subdirectory is printed only once. This assumes the ordering
10004 generated by the genmultilib script. Also, we leave out ones that match
10008 print_multilib_info (void)
10010 const char *p
= multilib_select
;
10011 const char *last_path
= 0, *this_path
;
10014 unsigned int last_path_len
= 0;
10019 /* Ignore newlines. */
10026 /* Get the initial path. */
10033 fatal_error (input_location
,
10034 "multilib select %qs is invalid", multilib_select
);
10040 /* When --disable-multilib was used but target defines
10041 MULTILIB_OSDIRNAMES, entries starting with .: (and not starting
10042 with .:: for multiarch configurations) are there just to find
10043 multilib_os_dir, so skip them from output. */
10044 if (this_path
[0] == '.' && this_path
[1] == ':' && this_path
[2] != ':')
10047 /* Check for matches with the multilib_exclusions. We don't bother
10048 with the '!' in either list. If any of the exclusion rules match
10049 all of its options with the select rule, we skip it. */
10051 const char *e
= multilib_exclusions
;
10052 const char *this_arg
;
10057 /* Ignore newlines. */
10064 /* Check the arguments. */
10073 fatal_error (input_location
,
10074 "multilib exclusion %qs is invalid",
10075 multilib_exclusions
);
10086 while (*e
!= ' ' && *e
!= ';')
10089 goto invalid_exclusion
;
10097 int len
= e
- this_arg
;
10100 goto invalid_select
;
10104 while (*q
!= ' ' && *q
!= ';')
10107 goto invalid_select
;
10111 if (! strncmp (arg
, this_arg
,
10112 (len
< q
- arg
) ? q
- arg
: len
)
10113 || default_arg (this_arg
, e
- this_arg
))
10143 /* If this is a duplicate, skip it. */
10144 skip
= (last_path
!= 0
10145 && (unsigned int) (p
- this_path
) == last_path_len
10146 && ! filename_ncmp (last_path
, this_path
, last_path_len
));
10148 last_path
= this_path
;
10149 last_path_len
= p
- this_path
;
10152 /* If all required arguments are default arguments, and no default
10153 arguments appear in the ! argument list, then we can skip it.
10154 We will already have printed a directory identical to this one
10155 which does not require that default argument. */
10159 bool default_arg_ok
= false;
10167 goto invalid_select
;
10178 while (*q
!= ' ' && *q
!= ';')
10181 goto invalid_select
;
10185 if (default_arg (arg
, q
- arg
))
10187 /* Stop checking if any default arguments appeared in not
10191 default_arg_ok
= false;
10195 default_arg_ok
= true;
10199 /* Stop checking if any required argument is not provided by
10200 default arguments. */
10201 default_arg_ok
= false;
10209 /* Make sure all default argument is OK for this multi-lib set. */
10210 if (default_arg_ok
)
10220 for (p1
= last_path
; p1
< p
&& *p1
!= ':'; p1
++)
10231 goto invalid_select
;
10239 use_arg
= *p
!= '!';
10244 while (*p
!= ' ' && *p
!= ';')
10247 goto invalid_select
;
10259 /* If there are extra options, print them now. */
10260 if (multilib_extra
&& *multilib_extra
)
10262 int print_at
= true;
10265 for (q
= multilib_extra
; *q
!= '\0'; q
++)
10286 /* getenv built-in spec function.
10288 Returns the value of the environment variable given by its first argument,
10289 concatenated with the second argument. If the variable is not defined, a
10290 fatal error is issued unless such undefs are internally allowed, in which
10291 case the variable name prefixed by a '/' is used as the variable value.
10293 The leading '/' allows using the result at a spot where a full path would
10294 normally be expected and when the actual value doesn't really matter since
10295 undef vars are allowed. */
10297 static const char *
10298 getenv_spec_function (int argc
, const char **argv
)
10301 const char *varname
;
10311 value
= env
.get (varname
);
10313 /* If the variable isn't defined and this is allowed, craft our expected
10314 return value. Assume variable names used in specs strings don't contain
10315 any active spec character so don't need escaping. */
10316 if (!value
&& spec_undefvar_allowed
)
10318 result
= XNEWVAR (char, strlen(varname
) + 2);
10319 sprintf (result
, "/%s", varname
);
10324 fatal_error (input_location
,
10325 "environment variable %qs not defined", varname
);
10327 /* We have to escape every character of the environment variable so
10328 they are not interpreted as active spec characters. A
10329 particularly painful case is when we are reading a variable
10330 holding a windows path complete with \ separators. */
10331 len
= strlen (value
) * 2 + strlen (argv
[1]) + 1;
10332 result
= XNEWVAR (char, len
);
10333 for (ptr
= result
; *value
; ptr
+= 2)
10339 strcpy (ptr
, argv
[1]);
10344 /* if-exists built-in spec function.
10346 Checks to see if the file specified by the absolute pathname in
10347 ARGS exists. Returns that pathname if found.
10349 The usual use for this function is to check for a library file
10350 (whose name has been expanded with %s). */
10352 static const char *
10353 if_exists_spec_function (int argc
, const char **argv
)
10355 /* Must have only one argument. */
10356 if (argc
== 1 && IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
10362 /* if-exists-else built-in spec function.
10364 This is like if-exists, but takes an additional argument which
10365 is returned if the first argument does not exist. */
10367 static const char *
10368 if_exists_else_spec_function (int argc
, const char **argv
)
10370 /* Must have exactly two arguments. */
10374 if (IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
10380 /* if-exists-then-else built-in spec function.
10382 Checks to see if the file specified by the absolute pathname in
10383 the first arg exists. Returns the second arg if so, otherwise returns
10384 the third arg if it is present. */
10386 static const char *
10387 if_exists_then_else_spec_function (int argc
, const char **argv
)
10390 /* Must have two or three arguments. */
10391 if (argc
!= 2 && argc
!= 3)
10394 if (IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
10403 /* sanitize built-in spec function.
10405 This returns non-NULL, if sanitizing address, thread or
10406 any of the undefined behavior sanitizers. */
10408 static const char *
10409 sanitize_spec_function (int argc
, const char **argv
)
10414 if (strcmp (argv
[0], "address") == 0)
10415 return (flag_sanitize
& SANITIZE_USER_ADDRESS
) ? "" : NULL
;
10416 if (strcmp (argv
[0], "hwaddress") == 0)
10417 return (flag_sanitize
& SANITIZE_USER_HWADDRESS
) ? "" : NULL
;
10418 if (strcmp (argv
[0], "kernel-address") == 0)
10419 return (flag_sanitize
& SANITIZE_KERNEL_ADDRESS
) ? "" : NULL
;
10420 if (strcmp (argv
[0], "kernel-hwaddress") == 0)
10421 return (flag_sanitize
& SANITIZE_KERNEL_HWADDRESS
) ? "" : NULL
;
10422 if (strcmp (argv
[0], "thread") == 0)
10423 return (flag_sanitize
& SANITIZE_THREAD
) ? "" : NULL
;
10424 if (strcmp (argv
[0], "undefined") == 0)
10425 return ((flag_sanitize
10426 & ~flag_sanitize_trap
10427 & (SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
)))
10429 if (strcmp (argv
[0], "leak") == 0)
10430 return ((flag_sanitize
10431 & (SANITIZE_ADDRESS
| SANITIZE_LEAK
| SANITIZE_THREAD
))
10432 == SANITIZE_LEAK
) ? "" : NULL
;
10436 /* replace-outfile built-in spec function.
10438 This looks for the first argument in the outfiles array's name and
10439 replaces it with the second argument. */
10441 static const char *
10442 replace_outfile_spec_function (int argc
, const char **argv
)
10445 /* Must have exactly two arguments. */
10449 for (i
= 0; i
< n_infiles
; i
++)
10451 if (outfiles
[i
] && !filename_cmp (outfiles
[i
], argv
[0]))
10452 outfiles
[i
] = xstrdup (argv
[1]);
10457 /* remove-outfile built-in spec function.
10459 * This looks for the first argument in the outfiles array's name and
10462 static const char *
10463 remove_outfile_spec_function (int argc
, const char **argv
)
10466 /* Must have exactly one argument. */
10470 for (i
= 0; i
< n_infiles
; i
++)
10472 if (outfiles
[i
] && !filename_cmp (outfiles
[i
], argv
[0]))
10473 outfiles
[i
] = NULL
;
10478 /* Given two version numbers, compares the two numbers.
10479 A version number must match the regular expression
10480 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
10483 compare_version_strings (const char *v1
, const char *v2
)
10488 if (regcomp (&r
, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
10489 REG_EXTENDED
| REG_NOSUB
) != 0)
10491 rresult
= regexec (&r
, v1
, 0, NULL
, 0);
10492 if (rresult
== REG_NOMATCH
)
10493 fatal_error (input_location
, "invalid version number %qs", v1
);
10494 else if (rresult
!= 0)
10496 rresult
= regexec (&r
, v2
, 0, NULL
, 0);
10497 if (rresult
== REG_NOMATCH
)
10498 fatal_error (input_location
, "invalid version number %qs", v2
);
10499 else if (rresult
!= 0)
10502 return strverscmp (v1
, v2
);
10506 /* version_compare built-in spec function.
10508 This takes an argument of the following form:
10510 <comparison-op> <arg1> [<arg2>] <switch> <result>
10512 and produces "result" if the comparison evaluates to true,
10513 and nothing if it doesn't.
10515 The supported <comparison-op> values are:
10517 >= true if switch is a later (or same) version than arg1
10519 < true if switch is an earlier version than arg1
10521 >< true if switch is arg1 or later, and earlier than arg2
10522 <> true if switch is earlier than arg1 or is arg2 or later
10524 If the switch is not present, the condition is false unless
10525 the first character of the <comparison-op> is '!'.
10528 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
10529 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
10531 static const char *
10532 version_compare_spec_function (int argc
, const char **argv
)
10536 const char *switch_value
= NULL
;
10541 fatal_error (input_location
, "too few arguments to %%:version-compare");
10542 if (argv
[0][0] == '\0')
10544 if ((argv
[0][1] == '<' || argv
[0][1] == '>') && argv
[0][0] != '!')
10546 if (argc
!= nargs
+ 3)
10547 fatal_error (input_location
, "too many arguments to %%:version-compare");
10549 switch_len
= strlen (argv
[nargs
+ 1]);
10550 for (i
= 0; i
< n_switches
; i
++)
10551 if (!strncmp (switches
[i
].part1
, argv
[nargs
+ 1], switch_len
)
10552 && check_live_switch (i
, switch_len
))
10553 switch_value
= switches
[i
].part1
+ switch_len
;
10555 if (switch_value
== NULL
)
10556 comp1
= comp2
= -1;
10559 comp1
= compare_version_strings (switch_value
, argv
[1]);
10561 comp2
= compare_version_strings (switch_value
, argv
[2]);
10563 comp2
= -1; /* This value unused. */
10566 switch (argv
[0][0] << 8 | argv
[0][1])
10568 case '>' << 8 | '=':
10569 result
= comp1
>= 0;
10571 case '!' << 8 | '<':
10572 result
= comp1
>= 0 || switch_value
== NULL
;
10575 result
= comp1
< 0;
10577 case '!' << 8 | '>':
10578 result
= comp1
< 0 || switch_value
== NULL
;
10580 case '>' << 8 | '<':
10581 result
= comp1
>= 0 && comp2
< 0;
10583 case '<' << 8 | '>':
10584 result
= comp1
< 0 || comp2
>= 0;
10588 fatal_error (input_location
,
10589 "unknown operator %qs in %%:version-compare", argv
[0]);
10594 return argv
[nargs
+ 2];
10597 /* %:include builtin spec function. This differs from %include in that it
10598 can be nested inside a spec, and thus be conditionalized. It takes
10599 one argument, the filename, and looks for it in the startfile path.
10600 The result is always NULL, i.e. an empty expansion. */
10602 static const char *
10603 include_spec_function (int argc
, const char **argv
)
10610 file
= find_a_file (&startfile_prefixes
, argv
[0], R_OK
, true);
10611 read_specs (file
? file
: argv
[0], false, false);
10616 /* %:find-file spec function. This function replaces its argument by
10617 the file found through find_file, that is the -print-file-name gcc
10619 static const char *
10620 find_file_spec_function (int argc
, const char **argv
)
10627 file
= find_file (argv
[0]);
10632 /* %:find-plugindir spec function. This function replaces its argument
10633 by the -iplugindir=<dir> option. `dir' is found through find_file, that
10634 is the -print-file-name gcc program option. */
10635 static const char *
10636 find_plugindir_spec_function (int argc
, const char **argv ATTRIBUTE_UNUSED
)
10638 const char *option
;
10643 option
= concat ("-iplugindir=", find_file ("plugin"), NULL
);
10648 /* %:print-asm-header spec function. Print a banner to say that the
10649 following output is from the assembler. */
10651 static const char *
10652 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED
,
10653 const char **argv ATTRIBUTE_UNUSED
)
10655 printf (_("Assembler options\n=================\n\n"));
10656 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
10661 /* Get a random number for -frandom-seed */
10663 static unsigned HOST_WIDE_INT
10664 get_random_number (void)
10666 unsigned HOST_WIDE_INT ret
= 0;
10669 fd
= open ("/dev/urandom", O_RDONLY
);
10672 read (fd
, &ret
, sizeof (HOST_WIDE_INT
));
10678 /* Get some more or less random data. */
10679 #ifdef HAVE_GETTIMEOFDAY
10683 gettimeofday (&tv
, NULL
);
10684 ret
= tv
.tv_sec
* 1000 + tv
.tv_usec
/ 1000;
10688 time_t now
= time (NULL
);
10690 if (now
!= (time_t)-1)
10691 ret
= (unsigned) now
;
10695 return ret
^ getpid ();
10698 /* %:compare-debug-dump-opt spec function. Save the last argument,
10699 expected to be the last -fdump-final-insns option, or generate a
10702 static const char *
10703 compare_debug_dump_opt_spec_function (int arg
,
10704 const char **argv ATTRIBUTE_UNUSED
)
10709 static char random_seed
[HOST_BITS_PER_WIDE_INT
/ 4 + 3];
10712 fatal_error (input_location
,
10713 "too many arguments to %%:compare-debug-dump-opt");
10715 do_spec_2 ("%{fdump-final-insns=*:%*}", NULL
);
10716 do_spec_1 (" ", 0, NULL
);
10718 if (argbuf
.length () > 0
10719 && strcmp (argv
[argbuf
.length () - 1], ".") != 0)
10721 if (!compare_debug
)
10724 name
= xstrdup (argv
[argbuf
.length () - 1]);
10729 if (argbuf
.length () > 0)
10730 do_spec_2 ("%B.gkd", NULL
);
10731 else if (!compare_debug
)
10734 do_spec_2 ("%{!save-temps*:%g.gkd}%{save-temps*:%B.gkd}", NULL
);
10736 do_spec_1 (" ", 0, NULL
);
10738 gcc_assert (argbuf
.length () > 0);
10740 name
= xstrdup (argbuf
.last ());
10742 char *arg
= quote_spec (xstrdup (name
));
10743 ret
= concat ("-fdump-final-insns=", arg
, NULL
);
10747 which
= compare_debug
< 0;
10748 debug_check_temp_file
[which
] = name
;
10752 unsigned HOST_WIDE_INT value
= get_random_number ();
10754 sprintf (random_seed
, HOST_WIDE_INT_PRINT_HEX
, value
);
10760 ret
= concat ("%{!frandom-seed=*:-frandom-seed=", random_seed
, "} ",
10771 /* %:compare-debug-self-opt spec function. Expands to the options
10772 that are to be passed in the second compilation of
10775 static const char *
10776 compare_debug_self_opt_spec_function (int arg
,
10777 const char **argv ATTRIBUTE_UNUSED
)
10780 fatal_error (input_location
,
10781 "too many arguments to %%:compare-debug-self-opt");
10783 if (compare_debug
>= 0)
10787 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
10788 %<fdump-final-insns=* -w -S -o %j \
10789 %{!fcompare-debug-second:-fcompare-debug-second} \
10790 ", compare_debug_opt
, NULL
);
10793 /* %:pass-through-libs spec function. Finds all -l options and input
10794 file names in the lib spec passed to it, and makes a list of them
10795 prepended with the plugin option to cause them to be passed through
10796 to the final link after all the new object files have been added. */
10799 pass_through_libs_spec_func (int argc
, const char **argv
)
10801 char *prepended
= xstrdup (" ");
10803 /* Shlemiel the painter's algorithm. Innately horrible, but at least
10804 we know that there will never be more than a handful of strings to
10805 concat, and it's only once per run, so it's not worth optimising. */
10806 for (n
= 0; n
< argc
; n
++)
10808 char *old
= prepended
;
10809 /* Anything that isn't an option is a full path to an output
10810 file; pass it through if it ends in '.a'. Among options,
10812 if (argv
[n
][0] == '-' && argv
[n
][1] == 'l')
10814 const char *lopt
= argv
[n
] + 2;
10815 /* Handle both joined and non-joined -l options. If for any
10816 reason there's a trailing -l with no joined or following
10817 arg just discard it. */
10818 if (!*lopt
&& ++n
>= argc
)
10822 prepended
= concat (prepended
, "-plugin-opt=-pass-through=-l",
10825 else if (!strcmp (".a", argv
[n
] + strlen (argv
[n
]) - 2))
10827 prepended
= concat (prepended
, "-plugin-opt=-pass-through=",
10828 argv
[n
], " ", NULL
);
10830 if (prepended
!= old
)
10837 not_actual_file_p (const char *name
)
10839 return (strcmp (name
, "-") == 0
10840 || strcmp (name
, HOST_BIT_BUCKET
) == 0);
10843 /* %:dumps spec function. Take an optional argument that overrides
10844 the default extension for -dumpbase and -dumpbase-ext.
10845 Return -dumpdir, -dumpbase and -dumpbase-ext, if needed. */
10847 dumps_spec_func (int argc
, const char **argv ATTRIBUTE_UNUSED
)
10849 const char *ext
= dumpbase_ext
;
10852 char *args
[3] = { NULL
, NULL
, NULL
};
10855 /* Do not compute a default for -dumpbase-ext when -dumpbase was
10856 given explicitly. */
10857 if (dumpbase
&& *dumpbase
&& !ext
)
10862 /* Do not override the explicitly-specified -dumpbase-ext with
10863 the specs-provided overrider. */
10867 else if (argc
!= 0)
10868 fatal_error (input_location
, "too many arguments for %%:dumps");
10872 p
= quote_spec_arg (xstrdup (dumpdir
));
10873 args
[nargs
++] = concat (" -dumpdir ", p
, NULL
);
10878 ext
= input_basename
+ basename_length
;
10880 /* Use the precomputed outbase, or compute dumpbase from
10881 input_basename, just like %b would. */
10884 if (dumpbase
&& *dumpbase
)
10886 base
= xstrdup (dumpbase
);
10887 p
= base
+ outbase_length
;
10888 gcc_checking_assert (strncmp (base
, outbase
, outbase_length
) == 0);
10889 gcc_checking_assert (strcmp (p
, ext
) == 0);
10891 else if (outbase_length
)
10893 base
= xstrndup (outbase
, outbase_length
);
10898 base
= xstrndup (input_basename
, suffixed_basename_length
);
10899 p
= base
+ basename_length
;
10902 if (compare_debug
< 0 || !p
|| strcmp (p
, ext
) != 0)
10908 if (compare_debug
< 0)
10913 p
= concat (base
, gk
, ext
, NULL
);
10919 base
= quote_spec_arg (base
);
10920 args
[nargs
++] = concat (" -dumpbase ", base
, NULL
);
10925 p
= quote_spec_arg (xstrdup (ext
));
10926 args
[nargs
++] = concat (" -dumpbase-ext ", p
, NULL
);
10930 const char *ret
= concat (args
[0], args
[1], args
[2], NULL
);
10932 free (args
[--nargs
]);
10937 /* Returns "" if ARGV[ARGC - 2] is greater than ARGV[ARGC-1].
10938 Otherwise, return NULL. */
10940 static const char *
10941 greater_than_spec_func (int argc
, const char **argv
)
10948 gcc_assert (argc
>= 2);
10950 long arg
= strtol (argv
[argc
- 2], &converted
, 10);
10951 gcc_assert (converted
!= argv
[argc
- 2]);
10953 long lim
= strtol (argv
[argc
- 1], &converted
, 10);
10954 gcc_assert (converted
!= argv
[argc
- 1]);
10962 /* Returns "" if debug_info_level is greater than ARGV[ARGC-1].
10963 Otherwise, return NULL. */
10965 static const char *
10966 debug_level_greater_than_spec_func (int argc
, const char **argv
)
10971 fatal_error (input_location
,
10972 "wrong number of arguments to %%:debug-level-gt");
10974 long arg
= strtol (argv
[0], &converted
, 10);
10975 gcc_assert (converted
!= argv
[0]);
10977 if (debug_info_level
> arg
)
10983 /* Returns "" if dwarf_version is greater than ARGV[ARGC-1].
10984 Otherwise, return NULL. */
10986 static const char *
10987 dwarf_version_greater_than_spec_func (int argc
, const char **argv
)
10992 fatal_error (input_location
,
10993 "wrong number of arguments to %%:dwarf-version-gt");
10995 long arg
= strtol (argv
[0], &converted
, 10);
10996 gcc_assert (converted
!= argv
[0]);
10998 if (dwarf_version
> arg
)
11005 path_prefix_reset (path_prefix
*prefix
)
11007 struct prefix_list
*iter
, *next
;
11008 iter
= prefix
->plist
;
11012 free (const_cast <char *> (iter
->prefix
));
11017 prefix
->max_len
= 0;
11020 /* The function takes 3 arguments: OPTION name, file name and location
11021 where we search for Fortran modules.
11022 When the FILE is found by find_file, return OPTION=path_to_file. */
11024 static const char *
11025 find_fortran_preinclude_file (int argc
, const char **argv
)
11027 char *result
= NULL
;
11031 struct path_prefix prefixes
= { 0, 0, "preinclude" };
11033 /* Search first for 'finclude' folder location for a header file
11034 installed by the compiler (similar to omp_lib.h). */
11035 add_prefix (&prefixes
, argv
[2], NULL
, 0, 0, 0);
11036 #ifdef TOOL_INCLUDE_DIR
11037 /* Then search: <prefix>/<target>/<include>/finclude */
11038 add_prefix (&prefixes
, TOOL_INCLUDE_DIR
"/finclude/",
11041 #ifdef NATIVE_SYSTEM_HEADER_DIR
11042 /* Then search: <sysroot>/usr/include/finclude/<multilib> */
11043 add_sysrooted_hdrs_prefix (&prefixes
, NATIVE_SYSTEM_HEADER_DIR
"/finclude/",
11047 const char *path
= find_a_file (&include_prefixes
, argv
[1], R_OK
, false);
11049 result
= concat (argv
[0], path
, NULL
);
11052 path
= find_a_file (&prefixes
, argv
[1], R_OK
, false);
11054 result
= concat (argv
[0], path
, NULL
);
11057 path_prefix_reset (&prefixes
);
11061 /* The function takes any number of arguments and joins them together.
11063 This seems to be necessary to build "-fjoined=foo.b" from "-fseparate foo.a"
11064 with a %{fseparate*:-fjoined=%.b$*} rule without adding undesired spaces:
11065 when doing $* replacement we first replace $* with the rest of the switch
11066 (in this case ""), and then add any arguments as arguments after the result,
11067 resulting in "-fjoined= foo.b". Using this function with e.g.
11068 %{fseparate*:-fjoined=%:join(%.b$*)} gets multiple words as separate argv
11069 elements instead of separated by spaces, and we paste them together. */
11071 static const char *
11072 join_spec_func (int argc
, const char **argv
)
11076 for (int i
= 0; i
< argc
; ++i
)
11077 obstack_grow (&obstack
, argv
[i
], strlen (argv
[i
]));
11078 obstack_1grow (&obstack
, '\0');
11079 return XOBFINISH (&obstack
, const char *);
11082 /* If any character in ORIG fits QUOTE_P (_, P), reallocate the string
11083 so as to precede every one of them with a backslash. Return the
11084 original string or the reallocated one. */
11086 static inline char *
11087 quote_string (char *orig
, bool (*quote_p
)(char, void *), void *p
)
11089 int len
, number_of_space
= 0;
11091 for (len
= 0; orig
[len
]; len
++)
11092 if (quote_p (orig
[len
], p
))
11095 if (number_of_space
)
11097 char *new_spec
= (char *) xmalloc (len
+ number_of_space
+ 1);
11099 for (j
= 0, k
= 0; j
<= len
; j
++, k
++)
11101 if (quote_p (orig
[j
], p
))
11102 new_spec
[k
++] = '\\';
11103 new_spec
[k
] = orig
[j
];
11112 /* Return true iff C is any of the characters convert_white_space
11116 whitespace_to_convert_p (char c
, void *)
11118 return (c
== ' ' || c
== '\t');
11121 /* Insert backslash before spaces in ORIG (usually a file path), to
11122 avoid being broken by spec parser.
11124 This function is needed as do_spec_1 treats white space (' ' and '\t')
11125 as the end of an argument. But in case of -plugin /usr/gcc install/xxx.so,
11126 the file name should be treated as a single argument rather than being
11127 broken into multiple. Solution is to insert '\\' before the space in a
11130 This function converts and only converts all occurrence of ' '
11131 to '\\' + ' ' and '\t' to '\\' + '\t'. For example:
11133 "a b" -> "a\\ \\ b"
11135 "a\\ b" -> "a\\\\ b"
11137 orig: input null-terminating string that was allocated by xalloc. The
11138 memory it points to might be freed in this function. Behavior undefined
11139 if ORIG wasn't xalloced or was freed already at entry.
11141 Return: ORIG if no conversion needed. Otherwise a newly allocated string
11142 that was converted from ORIG. */
11145 convert_white_space (char *orig
)
11147 return quote_string (orig
, whitespace_to_convert_p
, NULL
);
11150 /* Return true iff C matches any of the spec active characters. */
11152 quote_spec_char_p (char c
, void *)
11169 /* Like convert_white_space, but deactivate all active spec chars by
11172 static inline char *
11173 quote_spec (char *orig
)
11175 return quote_string (orig
, quote_spec_char_p
, NULL
);
11178 /* Like quote_spec, but also turn an empty string into the spec for an
11181 static inline char *
11182 quote_spec_arg (char *orig
)
11187 return xstrdup ("%\"");
11190 return quote_spec (orig
);
11193 /* Restore all state within gcc.cc to the initial state, so that the driver
11194 code can be safely re-run in-process.
11196 Many const char * variables are referenced by static specs (see
11197 INIT_STATIC_SPEC above). These variables are restored to their default
11198 values by a simple loop over the static specs.
11200 For other variables, we directly restore them all to their initial
11201 values (often implicitly 0).
11203 Free the various obstacks in this file, along with "opts_obstack"
11206 This function also restores any environment variables that were changed. */
11209 driver::finalize ()
11212 diagnostic_finish (global_dc
);
11215 at_file_supplied
= 0;
11216 print_help_list
= 0;
11218 verbose_only_flag
= 0;
11219 print_subprocess_help
= 0;
11221 report_times_to_file
= NULL
;
11222 target_system_root
= DEFAULT_TARGET_SYSTEM_ROOT
;
11223 target_system_root_changed
= 0;
11224 target_sysroot_suffix
= 0;
11225 target_sysroot_hdrs_suffix
= 0;
11226 save_temps_flag
= SAVE_TEMPS_NONE
;
11227 save_temps_overrides_dumpdir
= false;
11228 dumpdir_trailing_dash_added
= false;
11231 free (dumpbase_ext
);
11233 dumpdir
= dumpbase
= dumpbase_ext
= outbase
= NULL
;
11234 dumpdir_length
= outbase_length
= 0;
11235 spec_machine
= DEFAULT_TARGET_MACHINE
;
11236 greatest_status
= 1;
11238 obstack_free (&obstack
, NULL
);
11239 obstack_free (&opts_obstack
, NULL
); /* in opts.cc */
11240 obstack_free (&collect_obstack
, NULL
);
11242 link_command_spec
= LINK_COMMAND_SPEC
;
11244 obstack_free (&multilib_obstack
, NULL
);
11246 user_specs_head
= NULL
;
11247 user_specs_tail
= NULL
;
11249 /* Within the "compilers" vec, the fields "suffix" and "spec" were
11250 statically allocated for the default compilers, but dynamically
11251 allocated for additional compilers. Delete them for the latter. */
11252 for (int i
= n_default_compilers
; i
< n_compilers
; i
++)
11254 free (const_cast <char *> (compilers
[i
].suffix
));
11255 free (const_cast <char *> (compilers
[i
].spec
));
11257 XDELETEVEC (compilers
);
11261 linker_options
.truncate (0);
11262 assembler_options
.truncate (0);
11263 preprocessor_options
.truncate (0);
11265 path_prefix_reset (&exec_prefixes
);
11266 path_prefix_reset (&startfile_prefixes
);
11267 path_prefix_reset (&include_prefixes
);
11269 machine_suffix
= 0;
11270 just_machine_suffix
= 0;
11271 gcc_exec_prefix
= 0;
11272 gcc_libexec_prefix
= 0;
11273 set_static_spec_shared (&md_exec_prefix
, MD_EXEC_PREFIX
);
11274 set_static_spec_shared (&md_startfile_prefix
, MD_STARTFILE_PREFIX
);
11275 set_static_spec_shared (&md_startfile_prefix_1
, MD_STARTFILE_PREFIX_1
);
11277 multilib_os_dir
= 0;
11280 /* Free any specs dynamically-allocated by set_spec.
11281 These will be at the head of the list, before the
11282 statically-allocated ones. */
11285 while (specs
!= static_specs
)
11287 spec_list
*next
= specs
->next
;
11288 free (const_cast <char *> (specs
->name
));
11294 for (unsigned i
= 0; i
< ARRAY_SIZE (static_specs
); i
++)
11296 spec_list
*sl
= &static_specs
[i
];
11299 free (const_cast <char *> (*(sl
->ptr_spec
)));
11300 sl
->alloc_p
= false;
11302 *(sl
->ptr_spec
) = sl
->default_ptr
;
11305 extra_specs
= NULL
;
11308 processing_spec_function
= 0;
11316 execution_count
= 0;
11319 temp_filename
= NULL
;
11320 temp_filename_length
= 0;
11321 always_delete_queue
= NULL
;
11322 failure_delete_queue
= NULL
;
11324 XDELETEVEC (switches
);
11327 n_switches_alloc
= 0;
11330 compare_debug_second
= 0;
11331 compare_debug_opt
= NULL
;
11332 for (int i
= 0; i
< 2; i
++)
11334 switches_debug_check
[i
] = NULL
;
11335 n_switches_debug_check
[i
] = 0;
11336 n_switches_alloc_debug_check
[i
] = 0;
11337 debug_check_temp_file
[i
] = NULL
;
11340 XDELETEVEC (infiles
);
11343 n_infiles_alloc
= 0;
11345 combine_inputs
= false;
11346 added_libraries
= 0;
11347 XDELETEVEC (outfiles
);
11350 last_language_n_infiles
= 0;
11351 gcc_input_filename
= NULL
;
11352 input_file_number
= 0;
11353 input_filename_length
= 0;
11354 basename_length
= 0;
11355 suffixed_basename_length
= 0;
11356 input_basename
= NULL
;
11357 input_suffix
= NULL
;
11358 /* We don't need to purge "input_stat", just to unset "input_stat_set". */
11359 input_stat_set
= 0;
11360 input_file_compiler
= NULL
;
11362 delete_this_arg
= 0;
11363 this_is_output_file
= 0;
11364 this_is_library_file
= 0;
11365 this_is_linker_script
= 0;
11366 input_from_pipe
= 0;
11367 suffix_subst
= NULL
;
11372 used_arg
.finalize ();
11376 Targets can provide configure-time default options in
11377 OPTION_DEFAULT_SPECS. The jit needs to access these, but
11378 they are expressed in the spec language.
11380 Run just enough of the driver to be able to expand these
11381 specs, and then call the callback CB on each
11382 such option. The options strings are *without* a leading
11383 '-' character e.g. ("march=x86-64"). Finally, clean up. */
11386 driver_get_configure_time_options (void (*cb
) (const char *option
,
11392 obstack_init (&obstack
);
11393 init_opts_obstack ();
11396 for (i
= 0; i
< ARRAY_SIZE (option_default_specs
); i
++)
11397 do_option_spec (option_default_specs
[i
].name
,
11398 option_default_specs
[i
].spec
);
11400 for (i
= 0; (int) i
< n_switches
; i
++)
11402 gcc_assert (switches
[i
].part1
);
11403 (*cb
) (switches
[i
].part1
, user_data
);
11406 obstack_free (&opts_obstack
, NULL
);
11407 obstack_free (&obstack
, NULL
);