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 /* Basename of dump and aux outputs, computed from dumpbase (given or
306 derived from output name), to override input_basename in non-%w %b
308 static char *outbase
;
309 static size_t outbase_length
= 0;
311 /* The compiler version. */
313 static const char *compiler_version
;
315 /* The target version. */
317 static const char *const spec_version
= DEFAULT_TARGET_VERSION
;
319 /* The target machine. */
321 static const char *spec_machine
= DEFAULT_TARGET_MACHINE
;
322 static const char *spec_host_machine
= DEFAULT_REAL_TARGET_MACHINE
;
324 /* List of offload targets. Separated by colon. Empty string for
325 -foffload=disable. */
327 static char *offload_targets
= NULL
;
329 #if OFFLOAD_DEFAULTED
330 /* Set to true if -foffload has not been used and offload_targets
331 is set to the configured in default. */
332 static bool offload_targets_default
;
335 /* Nonzero if cross-compiling.
336 When -b is used, the value comes from the `specs' file. */
338 #ifdef CROSS_DIRECTORY_STRUCTURE
339 static const char *cross_compile
= "1";
341 static const char *cross_compile
= "0";
344 /* Greatest exit code of sub-processes that has been encountered up to
346 static int greatest_status
= 1;
348 /* This is the obstack which we use to allocate many strings. */
350 static struct obstack obstack
;
352 /* This is the obstack to build an environment variable to pass to
353 collect2 that describes all of the relevant switches of what to
354 pass the compiler in building the list of pointers to constructors
357 static struct obstack collect_obstack
;
359 /* Forward declaration for prototypes. */
363 static void init_spec (void);
364 static void store_arg (const char *, int, int);
365 static void insert_wrapper (const char *);
366 static char *load_specs (const char *);
367 static void read_specs (const char *, bool, bool);
368 static void set_spec (const char *, const char *, bool);
369 static struct compiler
*lookup_compiler (const char *, size_t, const char *);
370 static char *build_search_list (const struct path_prefix
*, const char *,
372 static void xputenv (const char *);
373 static void putenv_from_prefixes (const struct path_prefix
*, const char *,
375 static int access_check (const char *, int);
376 static char *find_a_file (const struct path_prefix
*, const char *, int, bool);
377 static char *find_a_program (const char *);
378 static void add_prefix (struct path_prefix
*, const char *, const char *,
380 static void add_sysrooted_prefix (struct path_prefix
*, const char *,
381 const char *, int, int, int);
382 static char *skip_whitespace (char *);
383 static void delete_if_ordinary (const char *);
384 static void delete_temp_files (void);
385 static void delete_failure_queue (void);
386 static void clear_failure_queue (void);
387 static int check_live_switch (int, int);
388 static const char *handle_braces (const char *);
389 static inline bool input_suffix_matches (const char *, const char *);
390 static inline bool switch_matches (const char *, const char *, int);
391 static inline void mark_matching_switches (const char *, const char *, int);
392 static inline void process_marked_switches (void);
393 static const char *process_brace_body (const char *, const char *, const char *, int, int);
394 static const struct spec_function
*lookup_spec_function (const char *);
395 static const char *eval_spec_function (const char *, const char *, const char *);
396 static const char *handle_spec_function (const char *, bool *, const char *);
397 static char *save_string (const char *, int);
398 static void set_collect_gcc_options (void);
399 static int do_spec_1 (const char *, int, const char *);
400 static int do_spec_2 (const char *, const char *);
401 static void do_option_spec (const char *, const char *);
402 static void do_self_spec (const char *);
403 static const char *find_file (const char *);
404 static int is_directory (const char *, bool);
405 static const char *validate_switches (const char *, bool, bool);
406 static void validate_all_switches (void);
407 static inline void validate_switches_from_spec (const char *, bool);
408 static void give_switch (int, int);
409 static int default_arg (const char *, int);
410 static void set_multilib_dir (void);
411 static void print_multilib_info (void);
412 static void display_help (void);
413 static void add_preprocessor_option (const char *, int);
414 static void add_assembler_option (const char *, int);
415 static void add_linker_option (const char *, int);
416 static void process_command (unsigned int, struct cl_decoded_option
*);
417 static int execute (void);
418 static void alloc_args (void);
419 static void clear_args (void);
420 static void fatal_signal (int);
421 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
422 static void init_gcc_specs (struct obstack
*, const char *, const char *,
425 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
426 static const char *convert_filename (const char *, int, int);
429 static void try_generate_repro (const char **argv
);
430 static const char *getenv_spec_function (int, const char **);
431 static const char *if_exists_spec_function (int, const char **);
432 static const char *if_exists_else_spec_function (int, const char **);
433 static const char *if_exists_then_else_spec_function (int, const char **);
434 static const char *sanitize_spec_function (int, const char **);
435 static const char *replace_outfile_spec_function (int, const char **);
436 static const char *remove_outfile_spec_function (int, const char **);
437 static const char *version_compare_spec_function (int, const char **);
438 static const char *include_spec_function (int, const char **);
439 static const char *find_file_spec_function (int, const char **);
440 static const char *find_plugindir_spec_function (int, const char **);
441 static const char *print_asm_header_spec_function (int, const char **);
442 static const char *compare_debug_dump_opt_spec_function (int, const char **);
443 static const char *compare_debug_self_opt_spec_function (int, const char **);
444 static const char *pass_through_libs_spec_func (int, const char **);
445 static const char *dumps_spec_func (int, const char **);
446 static const char *greater_than_spec_func (int, const char **);
447 static const char *debug_level_greater_than_spec_func (int, const char **);
448 static const char *dwarf_version_greater_than_spec_func (int, const char **);
449 static const char *find_fortran_preinclude_file (int, const char **);
450 static const char *join_spec_func (int, const char **);
451 static char *convert_white_space (char *);
452 static char *quote_spec (char *);
453 static char *quote_spec_arg (char *);
454 static bool not_actual_file_p (const char *);
457 /* The Specs Language
459 Specs are strings containing lines, each of which (if not blank)
460 is made up of a program name, and arguments separated by spaces.
461 The program name must be exact and start from root, since no path
462 is searched and it is unreliable to depend on the current working directory.
463 Redirection of input or output is not supported; the subprograms must
464 accept filenames saying what files to read and write.
466 In addition, the specs can contain %-sequences to substitute variable text
467 or for conditional text. Here is a table of all defined %-sequences.
468 Note that spaces are not generated automatically around the results of
469 expanding these sequences; therefore, you can concatenate them together
470 or with constant text in a single argument.
472 %% substitute one % into the program name or argument.
473 %" substitute an empty argument.
474 %i substitute the name of the input file being processed.
475 %b substitute the basename for outputs related with the input file
476 being processed. This is often a substring of the input file name,
477 up to (and not including) the last period but, unless %w is active,
478 it is affected by the directory selected by -save-temps=*, by
479 -dumpdir, and, in case of multiple compilations, even by -dumpbase
480 and -dumpbase-ext and, in case of linking, by the linker output
481 name. When %w is active, it derives the main output name only from
482 the input file base name; when it is not, it names aux/dump output
484 %B same as %b, but include the input file suffix (text after the last
487 substitute a file name that has suffix SUFFIX and is chosen
488 once per compilation, and mark the argument a la %d. To reduce
489 exposure to denial-of-service attacks, the file name is now
490 chosen in a way that is hard to predict even when previously
491 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
492 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
493 the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
494 had been pre-processed. Previously, %g was simply substituted
495 with a file name chosen once per compilation, without regard
496 to any appended suffix (which was therefore treated just like
497 ordinary text), making such attacks more likely to succeed.
499 like %g, but if -pipe is in effect, expands simply to "-".
501 like %g, but if -pipe is in effect, expands to nothing. (We have both
502 %| and %m to accommodate differences between system assemblers; see
503 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
505 like %g, but generates a new temporary file name even if %uSUFFIX
508 substitutes the last file name generated with %uSUFFIX, generating a
509 new one if there is no such last file name. In the absence of any
510 %uSUFFIX, this is just like %gSUFFIX, except they don't share
511 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
512 would involve the generation of two distinct file names, one
513 for each `%g.s' and another for each `%U.s'. Previously, %U was
514 simply substituted with a file name chosen for the previous %u,
515 without regard to any appended suffix.
517 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
518 writable, and if save-temps is off; otherwise, substitute the name
519 of a temporary file, just like %u. This temporary file is not
520 meant for communication between processes, but rather as a junk
523 substitutes .SUFFIX for the suffixes of a matched switch's args when
524 it is subsequently output with %*. SUFFIX is terminated by the next
526 %d marks the argument containing or following the %d as a
527 temporary file name, so that file will be deleted if GCC exits
528 successfully. Unlike %g, this contributes no text to the argument.
529 %w marks the argument containing or following the %w as the
530 "output file" of this compilation. This puts the argument
531 into the sequence of arguments that %o will substitute later.
532 %V indicates that this compilation produces no "output file".
534 like %{...} but marks the last argument supplied within as a file
535 to be deleted on failure.
537 like %{...} but puts the result into a FILE and substitutes @FILE
538 if an @file argument has been supplied.
539 %o substitutes the names of all the output files, with spaces
540 automatically placed around them. You should write spaces
541 around the %o as well or the results are undefined.
542 %o is for use in the specs for running the linker.
543 Input files whose names have no recognized suffix are not compiled
544 at all, but they are included among the output files, so they will
546 %O substitutes the suffix for object files. Note that this is
547 handled specially when it immediately follows %g, %u, or %U
548 (with or without a suffix argument) because of the need for
549 those to form complete file names. The handling is such that
550 %O is treated exactly as if it had already been substituted,
551 except that %g, %u, and %U do not currently support additional
552 SUFFIX characters following %O as they would following, for
554 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
555 (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
556 and -B options) and -imultilib as necessary.
557 %s current argument is the name of a library or startup file of some sort.
558 Search for that file in a standard list of directories
559 and substitute the full name found.
560 %T current argument is the name of a linker script.
561 Search for that file in the current list of directories to scan for
562 libraries. If the file is located, insert a --script option into the
563 command line followed by the full path name found. If the file is
564 not found then generate an error message.
565 Note: the current working directory is not searched.
566 %eSTR Print STR as an error message. STR is terminated by a newline.
567 Use this when inconsistent options are detected.
568 %nSTR Print STR as a notice. STR is terminated by a newline.
569 %x{OPTION} Accumulate an option for %X.
570 %X Output the accumulated linker options specified by compilations.
571 %Y Output the accumulated assembler options specified by compilations.
572 %Z Output the accumulated preprocessor options specified by compilations.
573 %a process ASM_SPEC as a spec.
574 This allows config.h to specify part of the spec for running as.
575 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
576 used here. This can be used to run a post-processor after the
577 assembler has done its job.
578 %D Dump out a -L option for each directory in startfile_prefixes.
579 If multilib_dir is set, extra entries are generated with it affixed.
580 %l process LINK_SPEC as a spec.
581 %L process LIB_SPEC as a spec.
582 %M Output multilib_os_dir.
583 %P Output a RUNPATH_OPTION for each directory in startfile_prefixes.
584 %G process LIBGCC_SPEC as a spec.
585 %R Output the concatenation of target_system_root and
586 target_sysroot_suffix.
587 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
588 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
589 %C process CPP_SPEC as a spec.
590 %1 process CC1_SPEC as a spec.
591 %2 process CC1PLUS_SPEC as a spec.
592 %* substitute the variable part of a matched option. (See below.)
593 Note that each comma in the substituted string is replaced by
594 a single space. A space is appended after the last substition
595 unless there is more text in current sequence.
596 %<S remove all occurrences of -S from the command line.
597 Note - this command is position dependent. % commands in the
598 spec string before this one will see -S, % commands in the
599 spec string after this one will not.
600 %>S Similar to "%<S", but keep it in the GCC command line.
601 %<S* remove all occurrences of all switches beginning with -S from the
604 Call the named function FUNCTION, passing it ARGS. ARGS is
605 first processed as a nested spec string, then split into an
606 argument vector in the usual fashion. The function returns
607 a string which is processed as if it had appeared literally
608 as part of the current spec.
609 %{S} substitutes the -S switch, if that switch was given to GCC.
610 If that switch was not specified, this substitutes nothing.
611 Here S is a metasyntactic variable.
612 %{S*} substitutes all the switches specified to GCC whose names start
613 with -S. This is used for -o, -I, etc; switches that take
614 arguments. GCC considers `-o foo' as being one switch whose
615 name starts with `o'. %{o*} would substitute this text,
616 including the space; thus, two arguments would be generated.
617 %{S*&T*} likewise, but preserve order of S and T options (the order
618 of S and T in the spec is not significant). Can be any number
619 of ampersand-separated variables; for each the wild card is
620 optional. Useful for CPP as %{D*&U*&A*}.
622 %{S:X} substitutes X, if the -S switch was given to GCC.
623 %{!S:X} substitutes X, if the -S switch was NOT given to GCC.
624 %{S*:X} substitutes X if one or more switches whose names start
625 with -S was given to GCC. Normally X is substituted only
626 once, no matter how many such switches appeared. However,
627 if %* appears somewhere in X, then X will be substituted
628 once for each matching switch, with the %* replaced by the
629 part of that switch that matched the '*'. A space will be
630 appended after the last substition unless there is more
631 text in current sequence.
632 %{.S:X} substitutes X, if processing a file with suffix S.
633 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
634 %{,S:X} substitutes X, if processing a file which will use spec S.
635 %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
637 %{S|T:X} substitutes X if either -S or -T was given to GCC. This may be
638 combined with '!', '.', ',', and '*' as above binding stronger
640 If %* appears in X, all of the alternatives must be starred, and
641 only the first matching alternative is substituted.
642 %{%:function(args):X}
643 Call function named FUNCTION with args ARGS. If the function
644 returns non-NULL, then X is substituted, if it returns
645 NULL, it isn't substituted.
646 %{S:X; if S was given to GCC, substitutes X;
647 T:Y; else if T was given to GCC, substitutes Y;
648 :D} else substitutes D. There can be as many clauses as you need.
649 This may be combined with '.', '!', ',', '|', and '*' as above.
651 %(Spec) processes a specification defined in a specs file as *Spec:
653 The switch matching text S in a %{S}, %{S:X}, or similar construct can use
654 a backslash to ignore the special meaning of the character following it,
655 thus allowing literal matching of a character that is otherwise specially
656 treated. For example, %{std=iso9899\:1999:X} substitutes X if the
657 -std=iso9899:1999 option is given.
659 The conditional text X in a %{S:X} or similar construct may contain
660 other nested % constructs or spaces, or even newlines. They are
661 processed as usual, as described above. Trailing white space in X is
662 ignored. White space may also appear anywhere on the left side of the
663 colon in these constructs, except between . or * and the corresponding
666 The -O, -f, -g, -m, and -W switches are handled specifically in these
667 constructs. If another value of -O or the negated form of a -f, -m, or
668 -W switch is found later in the command line, the earlier switch
669 value is ignored, except with {S*} where S is just one letter; this
670 passes all matching options.
672 The character | at the beginning of the predicate text is used to indicate
673 that a command should be piped to the following command, but only if -pipe
676 Note that it is built into GCC which switches take arguments and which
677 do not. You might think it would be useful to generalize this to
678 allow each compiler's spec to say which switches take arguments. But
679 this cannot be done in a consistent fashion. GCC cannot even decide
680 which input files have been specified without knowing which switches
681 take arguments, and it must know which input files to compile in order
682 to tell which compilers to run.
684 GCC also knows implicitly that arguments starting in `-l' are to be
685 treated as compiler output files, and passed to the linker in their
686 proper position among the other output files. */
688 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
690 /* config.h can define ASM_SPEC to provide extra args to the assembler
691 or extra switch-translations. */
696 /* config.h can define ASM_FINAL_SPEC to run a post processor after
697 the assembler has run. */
698 #ifndef ASM_FINAL_SPEC
699 #define ASM_FINAL_SPEC \
701 objcopy --extract-dwo \
702 %{c:%{o*:%*}%{!o*:%w%b%O}}%{!c:%U%O} \
704 objcopy --strip-dwo \
705 %{c:%{o*:%*}%{!o*:%w%b%O}}%{!c:%U%O} \
709 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
710 or extra switch-translations. */
715 /* Operating systems can define OS_CC1_SPEC to provide extra args to cc1 and
716 cc1plus or extra switch-translations. The OS_CC1_SPEC is appended
717 to CC1_SPEC in the initialization of cc1_spec. */
719 #define OS_CC1_SPEC ""
722 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
723 or extra switch-translations. */
728 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
729 or extra switch-translations. */
731 #define CC1PLUS_SPEC ""
734 /* config.h can define LINK_SPEC to provide extra args to the linker
735 or extra switch-translations. */
740 /* config.h can define LIB_SPEC to override the default libraries. */
742 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
745 /* When using -fsplit-stack we need to wrap pthread_create, in order
746 to initialize the stack guard. We always use wrapping, rather than
747 shared library ordering, and we keep the wrapper function in
748 libgcc. This is not yet a real spec, though it could become one;
749 it is currently just stuffed into LINK_SPEC. FIXME: This wrapping
750 only works with GNU ld and gold. */
751 #ifdef HAVE_GOLD_NON_DEFAULT_SPLIT_STACK
752 #define STACK_SPLIT_SPEC " %{fsplit-stack: -fuse-ld=gold --wrap=pthread_create}"
754 #define STACK_SPLIT_SPEC " %{fsplit-stack: --wrap=pthread_create}"
758 #define STATIC_LIBASAN_LIBS \
759 " %{static-libasan|static:%:include(libsanitizer.spec)%(link_libasan)}"
760 #ifdef LIBASAN_EARLY_SPEC
761 #define LIBASAN_SPEC STATIC_LIBASAN_LIBS
762 #elif defined(HAVE_LD_STATIC_DYNAMIC)
763 #define LIBASAN_SPEC "%{static-libasan:" LD_STATIC_OPTION \
764 "} -lasan %{static-libasan:" LD_DYNAMIC_OPTION "}" \
767 #define LIBASAN_SPEC "-lasan" STATIC_LIBASAN_LIBS
771 #ifndef LIBASAN_EARLY_SPEC
772 #define LIBASAN_EARLY_SPEC ""
775 #ifndef LIBHWASAN_SPEC
776 #define STATIC_LIBHWASAN_LIBS \
777 " %{static-libhwasan|static:%:include(libsanitizer.spec)%(link_libhwasan)}"
778 #ifdef LIBHWASAN_EARLY_SPEC
779 #define LIBHWASAN_SPEC STATIC_LIBHWASAN_LIBS
780 #elif defined(HAVE_LD_STATIC_DYNAMIC)
781 #define LIBHWASAN_SPEC "%{static-libhwasan:" LD_STATIC_OPTION \
782 "} -lhwasan %{static-libhwasan:" LD_DYNAMIC_OPTION "}" \
783 STATIC_LIBHWASAN_LIBS
785 #define LIBHWASAN_SPEC "-lhwasan" STATIC_LIBHWASAN_LIBS
789 #ifndef LIBHWASAN_EARLY_SPEC
790 #define LIBHWASAN_EARLY_SPEC ""
794 #define STATIC_LIBTSAN_LIBS \
795 " %{static-libtsan|static:%:include(libsanitizer.spec)%(link_libtsan)}"
796 #ifdef LIBTSAN_EARLY_SPEC
797 #define LIBTSAN_SPEC STATIC_LIBTSAN_LIBS
798 #elif defined(HAVE_LD_STATIC_DYNAMIC)
799 #define LIBTSAN_SPEC "%{static-libtsan:" LD_STATIC_OPTION \
800 "} -ltsan %{static-libtsan:" LD_DYNAMIC_OPTION "}" \
803 #define LIBTSAN_SPEC "-ltsan" STATIC_LIBTSAN_LIBS
807 #ifndef LIBTSAN_EARLY_SPEC
808 #define LIBTSAN_EARLY_SPEC ""
812 #define STATIC_LIBLSAN_LIBS \
813 " %{static-liblsan|static:%:include(libsanitizer.spec)%(link_liblsan)}"
814 #ifdef LIBLSAN_EARLY_SPEC
815 #define LIBLSAN_SPEC STATIC_LIBLSAN_LIBS
816 #elif defined(HAVE_LD_STATIC_DYNAMIC)
817 #define LIBLSAN_SPEC "%{static-liblsan:" LD_STATIC_OPTION \
818 "} -llsan %{static-liblsan:" LD_DYNAMIC_OPTION "}" \
821 #define LIBLSAN_SPEC "-llsan" STATIC_LIBLSAN_LIBS
825 #ifndef LIBLSAN_EARLY_SPEC
826 #define LIBLSAN_EARLY_SPEC ""
829 #ifndef LIBUBSAN_SPEC
830 #define STATIC_LIBUBSAN_LIBS \
831 " %{static-libubsan|static:%:include(libsanitizer.spec)%(link_libubsan)}"
832 #ifdef HAVE_LD_STATIC_DYNAMIC
833 #define LIBUBSAN_SPEC "%{static-libubsan:" LD_STATIC_OPTION \
834 "} -lubsan %{static-libubsan:" LD_DYNAMIC_OPTION "}" \
837 #define LIBUBSAN_SPEC "-lubsan" STATIC_LIBUBSAN_LIBS
841 /* Linker options for compressed debug sections. */
842 #if HAVE_LD_COMPRESS_DEBUG == 0
843 /* No linker support. */
844 #define LINK_COMPRESS_DEBUG_SPEC \
845 " %{gz*:%e-gz is not supported in this configuration} "
846 #elif HAVE_LD_COMPRESS_DEBUG == 1
847 /* ELF gABI style. */
848 #define LINK_COMPRESS_DEBUG_SPEC \
849 " %{gz|gz=zlib:" LD_COMPRESS_DEBUG_OPTION "=zlib}" \
850 " %{gz=none:" LD_COMPRESS_DEBUG_OPTION "=none}" \
851 " %{gz=zstd:%e-gz=zstd is not supported in this configuration} " \
852 " %{gz=zlib-gnu:}" /* Ignore silently zlib-gnu option value. */
853 #elif HAVE_LD_COMPRESS_DEBUG == 2
854 /* ELF gABI style and ZSTD. */
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:" LD_COMPRESS_DEBUG_OPTION "=zstd}" \
859 " %{gz=zlib-gnu:}" /* Ignore silently zlib-gnu option value. */
861 #error Unknown value for HAVE_LD_COMPRESS_DEBUG.
864 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
867 #if defined(REAL_LIBGCC_SPEC)
868 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
869 #elif defined(LINK_LIBGCC_SPECIAL_1)
870 /* Have gcc do the search for libgcc.a. */
871 #define LIBGCC_SPEC "libgcc.a%s"
873 #define LIBGCC_SPEC "-lgcc"
877 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
878 #ifndef STARTFILE_SPEC
879 #define STARTFILE_SPEC \
880 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
883 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
885 #define ENDFILE_SPEC ""
889 #define LINKER_NAME "collect2"
892 #ifdef HAVE_AS_DEBUG_PREFIX_MAP
893 #define ASM_MAP " %{ffile-prefix-map=*:--debug-prefix-map %*} %{fdebug-prefix-map=*:--debug-prefix-map %*}"
898 /* Assembler options for compressed debug sections. */
899 #if HAVE_LD_COMPRESS_DEBUG == 0
900 /* Reject if the linker cannot write compressed debug sections. */
901 #define ASM_COMPRESS_DEBUG_SPEC \
902 " %{gz*:%e-gz is not supported in this configuration} "
903 #else /* HAVE_LD_COMPRESS_DEBUG >= 1 */
904 #if HAVE_AS_COMPRESS_DEBUG == 0
905 /* No assembler support. Ignore silently. */
906 #define ASM_COMPRESS_DEBUG_SPEC \
908 #elif HAVE_AS_COMPRESS_DEBUG == 1
909 /* ELF gABI style. */
910 #define ASM_COMPRESS_DEBUG_SPEC \
911 " %{gz|gz=zlib:" AS_COMPRESS_DEBUG_OPTION "=zlib}" \
912 " %{gz=none:" AS_COMPRESS_DEBUG_OPTION "=none}" \
913 " %{gz=zlib-gnu:}" /* Ignore silently zlib-gnu option value. */
914 #elif HAVE_AS_COMPRESS_DEBUG == 2
915 /* ELF gABI style and ZSTD. */
916 #define ASM_COMPRESS_DEBUG_SPEC \
917 " %{gz|gz=zlib:" AS_COMPRESS_DEBUG_OPTION "=zlib}" \
918 " %{gz=none:" AS_COMPRESS_DEBUG_OPTION "=none}" \
919 " %{gz=zstd:" AS_COMPRESS_DEBUG_OPTION "=zstd}" \
920 " %{gz=zlib-gnu:}" /* Ignore silently zlib-gnu option value. */
922 #error Unknown value for HAVE_AS_COMPRESS_DEBUG.
924 #endif /* HAVE_LD_COMPRESS_DEBUG >= 1 */
926 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
927 to the assembler, when compiling assembly sources only. */
928 #ifndef ASM_DEBUG_SPEC
929 # if defined(HAVE_AS_GDWARF_5_DEBUG_FLAG) && defined(HAVE_AS_WORKING_DWARF_N_FLAG)
930 /* If --gdwarf-N is supported and as can handle even compiler generated
931 .debug_line with it, supply --gdwarf-N in ASM_DEBUG_OPTION_SPEC rather
932 than in ASM_DEBUG_SPEC, so that it applies to both .s and .c etc.
934 # define ASM_DEBUG_DWARF_OPTION ""
935 # elif defined(HAVE_AS_GDWARF_5_DEBUG_FLAG) && !defined(HAVE_LD_BROKEN_PE_DWARF5)
936 # define ASM_DEBUG_DWARF_OPTION "%{%:dwarf-version-gt(4):--gdwarf-5;" \
937 "%:dwarf-version-gt(3):--gdwarf-4;" \
938 "%:dwarf-version-gt(2):--gdwarf-3;" \
941 # define ASM_DEBUG_DWARF_OPTION "--gdwarf2"
943 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
944 # define ASM_DEBUG_SPEC "%{g*:%{%:debug-level-gt(0):" \
945 ASM_DEBUG_DWARF_OPTION "}}" ASM_MAP
948 #ifndef ASM_DEBUG_SPEC
949 # define ASM_DEBUG_SPEC ""
952 /* Define ASM_DEBUG_OPTION_SPEC to be a spec suitable for translating '-g'
953 to the assembler when compiling all sources. */
954 #ifndef ASM_DEBUG_OPTION_SPEC
955 # if defined(HAVE_AS_GDWARF_5_DEBUG_FLAG) && defined(HAVE_AS_WORKING_DWARF_N_FLAG)
956 # define ASM_DEBUG_OPTION_DWARF_OPT \
957 "%{%:dwarf-version-gt(4):--gdwarf-5 ;" \
958 "%:dwarf-version-gt(3):--gdwarf-4 ;" \
959 "%:dwarf-version-gt(2):--gdwarf-3 ;" \
961 # if defined(DWARF2_DEBUGGING_INFO)
962 # define ASM_DEBUG_OPTION_SPEC "%{g*:%{%:debug-level-gt(0):" \
963 ASM_DEBUG_OPTION_DWARF_OPT "}}"
967 #ifndef ASM_DEBUG_OPTION_SPEC
968 # define ASM_DEBUG_OPTION_SPEC ""
971 /* Here is the spec for running the linker, after compiling all files. */
973 /* This is overridable by the target in case they need to specify the
974 -lgcc and -lc order specially, yet not require them to override all
975 of LINK_COMMAND_SPEC. */
976 #ifndef LINK_GCC_C_SEQUENCE_SPEC
977 #define LINK_GCC_C_SEQUENCE_SPEC "%G %{!nolibc:%L %G}"
980 #ifndef LINK_SSP_SPEC
981 #ifdef TARGET_LIBC_PROVIDES_SSP
982 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all" \
983 "|fstack-protector-strong|fstack-protector-explicit:}"
985 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all" \
986 "|fstack-protector-strong|fstack-protector-explicit" \
987 ":-lssp_nonshared -lssp}"
991 #ifdef ENABLE_DEFAULT_PIE
992 #define PIE_SPEC "!no-pie"
993 #define NO_FPIE1_SPEC "fno-pie"
994 #define FPIE1_SPEC NO_FPIE1_SPEC ":;"
995 #define NO_FPIE2_SPEC "fno-PIE"
996 #define FPIE2_SPEC NO_FPIE2_SPEC ":;"
997 #define NO_FPIE_SPEC NO_FPIE1_SPEC "|" NO_FPIE2_SPEC
998 #define FPIE_SPEC NO_FPIE_SPEC ":;"
999 #define NO_FPIC1_SPEC "fno-pic"
1000 #define FPIC1_SPEC NO_FPIC1_SPEC ":;"
1001 #define NO_FPIC2_SPEC "fno-PIC"
1002 #define FPIC2_SPEC NO_FPIC2_SPEC ":;"
1003 #define NO_FPIC_SPEC NO_FPIC1_SPEC "|" NO_FPIC2_SPEC
1004 #define FPIC_SPEC NO_FPIC_SPEC ":;"
1005 #define NO_FPIE1_AND_FPIC1_SPEC NO_FPIE1_SPEC "|" NO_FPIC1_SPEC
1006 #define FPIE1_OR_FPIC1_SPEC NO_FPIE1_AND_FPIC1_SPEC ":;"
1007 #define NO_FPIE2_AND_FPIC2_SPEC NO_FPIE2_SPEC "|" NO_FPIC2_SPEC
1008 #define FPIE2_OR_FPIC2_SPEC NO_FPIE2_AND_FPIC2_SPEC ":;"
1009 #define NO_FPIE_AND_FPIC_SPEC NO_FPIE_SPEC "|" NO_FPIC_SPEC
1010 #define FPIE_OR_FPIC_SPEC NO_FPIE_AND_FPIC_SPEC ":;"
1012 #define PIE_SPEC "pie"
1013 #define FPIE1_SPEC "fpie"
1014 #define NO_FPIE1_SPEC FPIE1_SPEC ":;"
1015 #define FPIE2_SPEC "fPIE"
1016 #define NO_FPIE2_SPEC FPIE2_SPEC ":;"
1017 #define FPIE_SPEC FPIE1_SPEC "|" FPIE2_SPEC
1018 #define NO_FPIE_SPEC FPIE_SPEC ":;"
1019 #define FPIC1_SPEC "fpic"
1020 #define NO_FPIC1_SPEC FPIC1_SPEC ":;"
1021 #define FPIC2_SPEC "fPIC"
1022 #define NO_FPIC2_SPEC FPIC2_SPEC ":;"
1023 #define FPIC_SPEC FPIC1_SPEC "|" FPIC2_SPEC
1024 #define NO_FPIC_SPEC FPIC_SPEC ":;"
1025 #define FPIE1_OR_FPIC1_SPEC FPIE1_SPEC "|" FPIC1_SPEC
1026 #define NO_FPIE1_AND_FPIC1_SPEC FPIE1_OR_FPIC1_SPEC ":;"
1027 #define FPIE2_OR_FPIC2_SPEC FPIE2_SPEC "|" FPIC2_SPEC
1028 #define NO_FPIE2_AND_FPIC2_SPEC FPIE1_OR_FPIC2_SPEC ":;"
1029 #define FPIE_OR_FPIC_SPEC FPIE_SPEC "|" FPIC_SPEC
1030 #define NO_FPIE_AND_FPIC_SPEC FPIE_OR_FPIC_SPEC ":;"
1033 #ifndef LINK_PIE_SPEC
1036 #define LD_PIE_SPEC "-pie"
1039 #define LD_PIE_SPEC ""
1041 #define LINK_PIE_SPEC "%{static|shared|r:;" PIE_SPEC ":" LD_PIE_SPEC "} "
1044 #ifndef LINK_BUILDID_SPEC
1045 # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
1046 # define LINK_BUILDID_SPEC "%{!r:--build-id} "
1050 #ifndef LTO_PLUGIN_SPEC
1051 #define LTO_PLUGIN_SPEC ""
1054 /* Conditional to test whether the LTO plugin is used or not.
1055 FIXME: For slim LTO we will need to enable plugin unconditionally. This
1056 still cause problems with PLUGIN_LD != LD and when plugin is built but
1057 not useable. For GCC 4.6 we don't support slim LTO and thus we can enable
1058 plugin only when LTO is enabled. We still honor explicit
1059 -fuse-linker-plugin if the linker used understands -plugin. */
1061 /* The linker has some plugin support. */
1062 #if HAVE_LTO_PLUGIN > 0
1063 /* The linker used has full plugin support, use LTO plugin by default. */
1064 #if HAVE_LTO_PLUGIN == 2
1065 #define PLUGIN_COND "!fno-use-linker-plugin:%{!fno-lto"
1066 #define PLUGIN_COND_CLOSE "}"
1068 /* The linker used has limited plugin support, use LTO plugin with explicit
1069 -fuse-linker-plugin. */
1070 #define PLUGIN_COND "fuse-linker-plugin"
1071 #define PLUGIN_COND_CLOSE ""
1073 #define LINK_PLUGIN_SPEC \
1074 "%{" PLUGIN_COND": \
1075 -plugin %(linker_plugin_file) \
1076 -plugin-opt=%(lto_wrapper) \
1077 -plugin-opt=-fresolution=%u.res \
1078 " LTO_PLUGIN_SPEC "\
1079 %{flinker-output=*:-plugin-opt=-linker-output-known} \
1080 %{!nostdlib:%{!nodefaultlibs:%:pass-through-libs(%(link_gcc_c_sequence))}} \
1081 }" PLUGIN_COND_CLOSE
1083 /* The linker used doesn't support -plugin, reject -fuse-linker-plugin. */
1084 #define LINK_PLUGIN_SPEC "%{fuse-linker-plugin:\
1085 %e-fuse-linker-plugin is not supported in this configuration}"
1088 /* Linker command line options for -fsanitize= early on the command line. */
1089 #ifndef SANITIZER_EARLY_SPEC
1090 #define SANITIZER_EARLY_SPEC "\
1091 %{!nostdlib:%{!r:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_EARLY_SPEC "} \
1092 %{%:sanitize(hwaddress):" LIBHWASAN_EARLY_SPEC "} \
1093 %{%:sanitize(thread):" LIBTSAN_EARLY_SPEC "} \
1094 %{%:sanitize(leak):" LIBLSAN_EARLY_SPEC "}}}}"
1097 /* Linker command line options for -fsanitize= late on the command line. */
1098 #ifndef SANITIZER_SPEC
1099 #define SANITIZER_SPEC "\
1100 %{!nostdlib:%{!r:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_SPEC "\
1101 %{static:%ecannot specify -static with -fsanitize=address}}\
1102 %{%:sanitize(hwaddress):" LIBHWASAN_SPEC "\
1103 %{static:%ecannot specify -static with -fsanitize=hwaddress}}\
1104 %{%:sanitize(thread):" LIBTSAN_SPEC "\
1105 %{static:%ecannot specify -static with -fsanitize=thread}}\
1106 %{%:sanitize(undefined):" LIBUBSAN_SPEC "}\
1107 %{%:sanitize(leak):" LIBLSAN_SPEC "}}}}"
1110 #ifndef POST_LINK_SPEC
1111 #define POST_LINK_SPEC ""
1114 /* This is the spec to use, once the code for creating the vtable
1115 verification runtime library, libvtv.so, has been created. Currently
1116 the vtable verification runtime functions are in libstdc++, so we use
1117 the spec just below this one. */
1118 #ifndef VTABLE_VERIFICATION_SPEC
1119 #if ENABLE_VTABLE_VERIFY
1120 #define VTABLE_VERIFICATION_SPEC "\
1121 %{!nostdlib:%{!r:%{fvtable-verify=std: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}\
1122 %{fvtable-verify=preinit: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}}}"
1124 #define VTABLE_VERIFICATION_SPEC "\
1125 %{fvtable-verify=none:} \
1126 %{fvtable-verify=std: \
1127 %e-fvtable-verify=std is not supported in this configuration} \
1128 %{fvtable-verify=preinit: \
1129 %e-fvtable-verify=preinit is not supported in this configuration}"
1133 /* -u* was put back because both BSD and SysV seem to support it. */
1134 /* %{static|no-pie|static-pie:} simply prevents an error message:
1135 1. If the target machine doesn't handle -static.
1136 2. If PIE isn't enabled by default.
1137 3. If the target machine doesn't handle -static-pie.
1139 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
1140 scripts which exist in user specified directories, or in standard
1142 /* We pass any -flto flags on to the linker, which is expected
1143 to understand them. In practice, this means it had better be collect2. */
1144 /* %{e*} includes -export-dynamic; see comment in common.opt. */
1145 #ifndef LINK_COMMAND_SPEC
1146 #define LINK_COMMAND_SPEC "\
1147 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
1150 "%{flto|flto=*:%<fcompare-debug*} \
1151 %{flto} %{fno-lto} %{flto=*} %l " LINK_PIE_SPEC \
1152 "%{fuse-ld=*:-fuse-ld=%*} " LINK_COMPRESS_DEBUG_SPEC \
1153 "%X %{o*} %{e*} %{N} %{n} %{r}\
1154 %{s} %{t} %{u*} %{z} %{Z} %{!nostdlib:%{!r:%{!nostartfiles:%S}}} \
1155 %{static|no-pie|static-pie:} %@{L*} %(link_libgcc) " \
1156 VTABLE_VERIFICATION_SPEC " " SANITIZER_EARLY_SPEC " %o "" \
1157 %{fopenacc|fopenmp|%:gt(%{ftree-parallelize-loops=*:%*} 1):\
1158 %:include(libgomp.spec)%(link_gomp)}\
1159 %{fgnu-tm:%:include(libitm.spec)%(link_itm)}\
1160 " STACK_SPLIT_SPEC "\
1161 %{fprofile-arcs|fprofile-generate*|coverage:-lgcov} " SANITIZER_SPEC " \
1162 %{!nostdlib:%{!r:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}}\
1163 %{!nostdlib:%{!r:%{!nostartfiles:%E}}} %{T*} \n%(post_link) }}}}}}"
1166 #ifndef LINK_LIBGCC_SPEC
1167 /* Generate -L options for startfile prefix list. */
1168 # define LINK_LIBGCC_SPEC "%D"
1171 #ifndef STARTFILE_PREFIX_SPEC
1172 # define STARTFILE_PREFIX_SPEC ""
1175 #ifndef SYSROOT_SPEC
1176 # define SYSROOT_SPEC "--sysroot=%R"
1179 #ifndef SYSROOT_SUFFIX_SPEC
1180 # define SYSROOT_SUFFIX_SPEC ""
1183 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
1184 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
1187 #ifndef RUNPATH_OPTION
1188 # define RUNPATH_OPTION "-rpath"
1191 static const char *asm_debug
= ASM_DEBUG_SPEC
;
1192 static const char *asm_debug_option
= ASM_DEBUG_OPTION_SPEC
;
1193 static const char *cpp_spec
= CPP_SPEC
;
1194 static const char *cc1_spec
= CC1_SPEC OS_CC1_SPEC
;
1195 static const char *cc1plus_spec
= CC1PLUS_SPEC
;
1196 static const char *link_gcc_c_sequence_spec
= LINK_GCC_C_SEQUENCE_SPEC
;
1197 static const char *link_ssp_spec
= LINK_SSP_SPEC
;
1198 static const char *asm_spec
= ASM_SPEC
;
1199 static const char *asm_final_spec
= ASM_FINAL_SPEC
;
1200 static const char *link_spec
= LINK_SPEC
;
1201 static const char *lib_spec
= LIB_SPEC
;
1202 static const char *link_gomp_spec
= "";
1203 static const char *libgcc_spec
= LIBGCC_SPEC
;
1204 static const char *endfile_spec
= ENDFILE_SPEC
;
1205 static const char *startfile_spec
= STARTFILE_SPEC
;
1206 static const char *linker_name_spec
= LINKER_NAME
;
1207 static const char *linker_plugin_file_spec
= "";
1208 static const char *lto_wrapper_spec
= "";
1209 static const char *lto_gcc_spec
= "";
1210 static const char *post_link_spec
= POST_LINK_SPEC
;
1211 static const char *link_command_spec
= LINK_COMMAND_SPEC
;
1212 static const char *link_libgcc_spec
= LINK_LIBGCC_SPEC
;
1213 static const char *startfile_prefix_spec
= STARTFILE_PREFIX_SPEC
;
1214 static const char *sysroot_spec
= SYSROOT_SPEC
;
1215 static const char *sysroot_suffix_spec
= SYSROOT_SUFFIX_SPEC
;
1216 static const char *sysroot_hdrs_suffix_spec
= SYSROOT_HEADERS_SUFFIX_SPEC
;
1217 static const char *self_spec
= "";
1219 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
1220 There should be no need to override these in target dependent files,
1221 but we need to copy them to the specs file so that newer versions
1222 of the GCC driver can correctly drive older tool chains with the
1223 appropriate -B options. */
1225 /* When cpplib handles traditional preprocessing, get rid of this, and
1226 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
1227 that we default the front end language better. */
1228 static const char *trad_capable_cpp
=
1229 "cc1 -E %{traditional|traditional-cpp:-traditional-cpp}";
1231 /* We don't wrap .d files in %W{} since a missing .d file, and
1232 therefore no dependency entry, confuses make into thinking a .o
1233 file that happens to exist is up-to-date. */
1234 static const char *cpp_unique_options
=
1235 "%{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %@{I*&F*} %{P} %I\
1236 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
1237 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
1238 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
1239 %{Mmodules} %{Mno-modules}\
1240 %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
1241 %{remap} %{%:debug-level-gt(2):-dD}\
1242 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
1243 %{H} %C %{D*&U*&A*} %{i*} %Z %i\
1245 %{fdeps-format=*:%{!fdeps-file=*:-fdeps-file=%:join(%{!o:%b.ddi}%{o*:%.ddi%*})}}\
1246 %{fdeps-format=*:%{!fdeps-target=*:-fdeps-target=%:join(%{!o:%b.o}%{o*:%.o%*})}}";
1248 /* This contains cpp options which are common with cc1_options and are passed
1249 only when preprocessing only to avoid duplication. We pass the cc1 spec
1250 options to the preprocessor so that it the cc1 spec may manipulate
1251 options used to set target flags. Those special target flags settings may
1252 in turn cause preprocessor symbols to be defined specially. */
1253 static const char *cpp_options
=
1254 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
1255 %{f*} %{g*:%{%:debug-level-gt(0):%{g*}\
1256 %{!fno-working-directory:-fworking-directory}}} %{O*}\
1257 %{undef} %{save-temps*:-fpch-preprocess}";
1259 /* Pass -d* flags, possibly modifying -dumpdir, -dumpbase et al.
1261 Make it easy for a language to override the argument for the
1262 %:dumps specs function call. */
1263 #define DUMPS_OPTIONS(EXTS) \
1264 "%<dumpdir %<dumpbase %<dumpbase-ext %{d*} %:dumps(" EXTS ")"
1266 /* This contains cpp options which are not passed when the preprocessor
1267 output will be used by another program. */
1268 static const char *cpp_debug_options
= DUMPS_OPTIONS ("");
1270 /* NB: This is shared amongst all front-ends, except for Ada. */
1271 static const char *cc1_options
=
1272 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
1273 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
1274 %1 %{!Q:-quiet} %(cpp_debug_options) %{m*} %{aux-info*}\
1275 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
1276 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
1277 %{Qn:-fno-ident} %{Qy:} %{-help:--help}\
1278 %{-target-help:--target-help}\
1279 %{-version:--version}\
1280 %{-help=*:--help=%*}\
1281 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %w%b.s}}}\
1282 %{fsyntax-only:-o %j} %{-param*}\
1283 %{coverage:-fprofile-arcs -ftest-coverage}\
1284 %{fprofile-arcs|fprofile-generate*|coverage:\
1285 %{!fprofile-update=single:\
1286 %{pthread:-fprofile-update=prefer-atomic}}}";
1288 static const char *asm_options
=
1289 "%{-target-help:%:print-asm-header()} "
1291 /* If GNU AS is used, then convert -w (no warnings), -I, and -v
1292 to the assembler equivalents. */
1293 "%{v} %{w:-W} %{I*} "
1295 "%(asm_debug_option)"
1296 ASM_COMPRESS_DEBUG_SPEC
1297 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
1299 static const char *invoke_as
=
1300 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1302 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
1303 %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
1307 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
1308 %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
1312 /* Some compilers have limits on line lengths, and the multilib_select
1313 and/or multilib_matches strings can be very long, so we build them at
1315 static struct obstack multilib_obstack
;
1316 static const char *multilib_select
;
1317 static const char *multilib_matches
;
1318 static const char *multilib_defaults
;
1319 static const char *multilib_exclusions
;
1320 static const char *multilib_reuse
;
1322 /* Check whether a particular argument is a default argument. */
1324 #ifndef MULTILIB_DEFAULTS
1325 #define MULTILIB_DEFAULTS { "" }
1328 static const char *const multilib_defaults_raw
[] = MULTILIB_DEFAULTS
;
1330 #ifndef DRIVER_SELF_SPECS
1331 #define DRIVER_SELF_SPECS ""
1334 /* Linking to libgomp implies pthreads. This is particularly important
1335 for targets that use different start files and suchlike. */
1336 #ifndef GOMP_SELF_SPECS
1337 #define GOMP_SELF_SPECS \
1338 "%{fopenacc|fopenmp|%:gt(%{ftree-parallelize-loops=*:%*} 1): " \
1342 /* Likewise for -fgnu-tm. */
1343 #ifndef GTM_SELF_SPECS
1344 #define GTM_SELF_SPECS "%{fgnu-tm: -pthread}"
1347 static const char *const driver_self_specs
[] = {
1348 "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
1349 DRIVER_SELF_SPECS
, CONFIGURE_SPECS
, GOMP_SELF_SPECS
, GTM_SELF_SPECS
,
1350 /* This discards -fmultiflags at the end of self specs processing in the
1351 driver, so that it is effectively Ignored, without actually marking it as
1352 Ignored, which would get it discarded before self specs could remap it. */
1356 #ifndef OPTION_DEFAULT_SPECS
1357 #define OPTION_DEFAULT_SPECS { "", "" }
1366 static const struct default_spec
1367 option_default_specs
[] = { OPTION_DEFAULT_SPECS
};
1371 struct user_specs
*next
;
1372 const char *filename
;
1375 static struct user_specs
*user_specs_head
, *user_specs_tail
;
1378 /* Record the mapping from file suffixes for compilation specs. */
1382 const char *suffix
; /* Use this compiler for input files
1383 whose names end in this suffix. */
1385 const char *spec
; /* To use this compiler, run this spec. */
1387 const char *cpp_spec
; /* If non-NULL, substitute this spec
1388 for `%C', rather than the usual
1390 int combinable
; /* If nonzero, compiler can deal with
1391 multiple source files at once (IMA). */
1392 int needs_preprocessing
; /* If nonzero, source files need to
1393 be run through a preprocessor. */
1396 /* Pointer to a vector of `struct compiler' that gives the spec for
1397 compiling a file, based on its suffix.
1398 A file that does not end in any of these suffixes will be passed
1399 unchanged to the loader and nothing else will be done to it.
1401 An entry containing two 0s is used to terminate the vector.
1403 If multiple entries match a file, the last matching one is used. */
1405 static struct compiler
*compilers
;
1407 /* Number of entries in `compilers', not counting the null terminator. */
1409 static int n_compilers
;
1411 /* The default list of file name suffixes and their compilation specs. */
1413 static const struct compiler default_compilers
[] =
1415 /* Add lists of suffixes of known languages here. If those languages
1416 were not present when we built the driver, we will hit these copies
1417 and be given a more meaningful error than "file not used since
1418 linking is not done". */
1419 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0},
1420 {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
1421 {".mii", "#Objective-C++", 0, 0, 0},
1422 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
1423 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
1424 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
1425 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
1426 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
1427 {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
1428 {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
1429 {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
1430 {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
1431 {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
1432 {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
1433 {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
1434 {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
1435 {".r", "#Ratfor", 0, 0, 0},
1436 {".go", "#Go", 0, 1, 0},
1437 {".d", "#D", 0, 1, 0}, {".dd", "#D", 0, 1, 0}, {".di", "#D", 0, 1, 0},
1438 {".mod", "#Modula-2", 0, 0, 0}, {".m2i", "#Modula-2", 0, 0, 0},
1439 /* Next come the entries for C. */
1440 {".c", "@c", 0, 0, 1},
1442 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1443 external preprocessor if -save-temps is given. */
1444 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1447 %eGNU C no longer supports -traditional without -E}\
1448 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1449 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1450 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1452 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1453 cc1 %(cpp_unique_options) %(cc1_options)}}}\
1454 %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 1},
1456 "%{!E:%e-E or -x required when input is from standard input}\
1457 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
1458 {".h", "@c-header", 0, 0, 0},
1460 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1461 external preprocessor if -save-temps is given. */
1462 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1464 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1465 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1466 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1468 %{!fsyntax-only:%{!S:-o %g.s} \
1469 %{!fdump-ada-spec*:%{!o*:--output-pch %w%i.gch}\
1470 %W{o*:--output-pch %w%*}}%{!S:%V}}}\
1471 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1472 cc1 %(cpp_unique_options) %(cc1_options)\
1473 %{!fsyntax-only:%{!S:-o %g.s} \
1474 %{!fdump-ada-spec*:%{!o*:--output-pch %w%i.gch}\
1475 %W{o*:--output-pch %w%*}}%{!S:%V}}}}}}}}", 0, 0, 0},
1476 {".i", "@cpp-output", 0, 0, 0},
1478 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 0},
1479 {".s", "@assembler", 0, 0, 0},
1481 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 0, 0},
1482 {".sx", "@assembler-with-cpp", 0, 0, 0},
1483 {".S", "@assembler-with-cpp", 0, 0, 0},
1484 {"@assembler-with-cpp",
1485 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1486 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1487 %{E|M|MM:%(cpp_debug_options)}\
1488 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1489 as %(asm_debug) %(asm_options) %|.s %A }}}}"
1491 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1492 %{E|M|MM:%(cpp_debug_options)}\
1493 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1494 as %(asm_debug) %(asm_options) %m.s %A }}}}"
1499 /* Mark end of table. */
1503 /* Number of elements in default_compilers, not counting the terminator. */
1505 static const int n_default_compilers
= ARRAY_SIZE (default_compilers
) - 1;
1507 typedef char *char_p
; /* For DEF_VEC_P. */
1509 /* A vector of options to give to the linker.
1510 These options are accumulated by %x,
1511 and substituted into the linker command with %X. */
1512 static vec
<char_p
> linker_options
;
1514 /* A vector of options to give to the assembler.
1515 These options are accumulated by -Wa,
1516 and substituted into the assembler command with %Y. */
1517 static vec
<char_p
> assembler_options
;
1519 /* A vector of options to give to the preprocessor.
1520 These options are accumulated by -Wp,
1521 and substituted into the preprocessor command with %Z. */
1522 static vec
<char_p
> preprocessor_options
;
1525 skip_whitespace (char *p
)
1529 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1530 be considered whitespace. */
1531 if (p
[0] == '\n' && p
[1] == '\n' && p
[2] == '\n')
1533 else if (*p
== '\n' || *p
== ' ' || *p
== '\t')
1547 /* Structures to keep track of prefixes to try when looking for files. */
1551 const char *prefix
; /* String to prepend to the path. */
1552 struct prefix_list
*next
; /* Next in linked list. */
1553 int require_machine_suffix
; /* Don't use without machine_suffix. */
1554 /* 2 means try both machine_suffix and just_machine_suffix. */
1555 int priority
; /* Sort key - priority within list. */
1556 int os_multilib
; /* 1 if OS multilib scheme should be used,
1557 0 for GCC multilib scheme. */
1562 struct prefix_list
*plist
; /* List of prefixes to try */
1563 int max_len
; /* Max length of a prefix in PLIST */
1564 const char *name
; /* Name of this list (used in config stuff) */
1567 /* List of prefixes to try when looking for executables. */
1569 static struct path_prefix exec_prefixes
= { 0, 0, "exec" };
1571 /* List of prefixes to try when looking for startup (crt0) files. */
1573 static struct path_prefix startfile_prefixes
= { 0, 0, "startfile" };
1575 /* List of prefixes to try when looking for include files. */
1577 static struct path_prefix include_prefixes
= { 0, 0, "include" };
1579 /* Suffix to attach to directories searched for commands.
1580 This looks like `MACHINE/VERSION/'. */
1582 static const char *machine_suffix
= 0;
1584 /* Suffix to attach to directories searched for commands.
1585 This is just `MACHINE/'. */
1587 static const char *just_machine_suffix
= 0;
1589 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1591 static const char *gcc_exec_prefix
;
1593 /* Adjusted value of standard_libexec_prefix. */
1595 static const char *gcc_libexec_prefix
;
1597 /* Default prefixes to attach to command names. */
1599 #ifndef STANDARD_STARTFILE_PREFIX_1
1600 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1602 #ifndef STANDARD_STARTFILE_PREFIX_2
1603 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1606 #ifdef CROSS_DIRECTORY_STRUCTURE /* Don't use these prefixes for a cross compiler. */
1607 #undef MD_EXEC_PREFIX
1608 #undef MD_STARTFILE_PREFIX
1609 #undef MD_STARTFILE_PREFIX_1
1612 /* If no prefixes defined, use the null string, which will disable them. */
1613 #ifndef MD_EXEC_PREFIX
1614 #define MD_EXEC_PREFIX ""
1616 #ifndef MD_STARTFILE_PREFIX
1617 #define MD_STARTFILE_PREFIX ""
1619 #ifndef MD_STARTFILE_PREFIX_1
1620 #define MD_STARTFILE_PREFIX_1 ""
1623 /* These directories are locations set at configure-time based on the
1624 --prefix option provided to configure. Their initializers are
1625 defined in Makefile.in. These paths are not *directly* used when
1626 gcc_exec_prefix is set because, in that case, we know where the
1627 compiler has been installed, and use paths relative to that
1628 location instead. */
1629 static const char *const standard_exec_prefix
= STANDARD_EXEC_PREFIX
;
1630 static const char *const standard_libexec_prefix
= STANDARD_LIBEXEC_PREFIX
;
1631 static const char *const standard_bindir_prefix
= STANDARD_BINDIR_PREFIX
;
1632 static const char *const standard_startfile_prefix
= STANDARD_STARTFILE_PREFIX
;
1634 /* For native compilers, these are well-known paths containing
1635 components that may be provided by the system. For cross
1636 compilers, these paths are not used. */
1637 static const char *md_exec_prefix
= MD_EXEC_PREFIX
;
1638 static const char *md_startfile_prefix
= MD_STARTFILE_PREFIX
;
1639 static const char *md_startfile_prefix_1
= MD_STARTFILE_PREFIX_1
;
1640 static const char *const standard_startfile_prefix_1
1641 = STANDARD_STARTFILE_PREFIX_1
;
1642 static const char *const standard_startfile_prefix_2
1643 = STANDARD_STARTFILE_PREFIX_2
;
1645 /* A relative path to be used in finding the location of tools
1646 relative to the driver. */
1647 static const char *const tooldir_base_prefix
= TOOLDIR_BASE_PREFIX
;
1649 /* A prefix to be used when this is an accelerator compiler. */
1650 static const char *const accel_dir_suffix
= ACCEL_DIR_SUFFIX
;
1652 /* Subdirectory to use for locating libraries. Set by
1653 set_multilib_dir based on the compilation options. */
1655 static const char *multilib_dir
;
1657 /* Subdirectory to use for locating libraries in OS conventions. Set by
1658 set_multilib_dir based on the compilation options. */
1660 static const char *multilib_os_dir
;
1662 /* Subdirectory to use for locating libraries in multiarch conventions. Set by
1663 set_multilib_dir based on the compilation options. */
1665 static const char *multiarch_dir
;
1667 /* Structure to keep track of the specs that have been defined so far.
1668 These are accessed using %(specname) in a compiler or link
1673 /* The following 2 fields must be first */
1674 /* to allow EXTRA_SPECS to be initialized */
1675 const char *name
; /* name of the spec. */
1676 const char *ptr
; /* available ptr if no static pointer */
1678 /* The following fields are not initialized */
1679 /* by EXTRA_SPECS */
1680 const char **ptr_spec
; /* pointer to the spec itself. */
1681 struct spec_list
*next
; /* Next spec in linked list. */
1682 int name_len
; /* length of the name */
1683 bool user_p
; /* whether string come from file spec. */
1684 bool alloc_p
; /* whether string was allocated */
1685 const char *default_ptr
; /* The default value of *ptr_spec. */
1688 #define INIT_STATIC_SPEC(NAME,PTR) \
1689 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, false, false, \
1692 /* List of statically defined specs. */
1693 static struct spec_list static_specs
[] =
1695 INIT_STATIC_SPEC ("asm", &asm_spec
),
1696 INIT_STATIC_SPEC ("asm_debug", &asm_debug
),
1697 INIT_STATIC_SPEC ("asm_debug_option", &asm_debug_option
),
1698 INIT_STATIC_SPEC ("asm_final", &asm_final_spec
),
1699 INIT_STATIC_SPEC ("asm_options", &asm_options
),
1700 INIT_STATIC_SPEC ("invoke_as", &invoke_as
),
1701 INIT_STATIC_SPEC ("cpp", &cpp_spec
),
1702 INIT_STATIC_SPEC ("cpp_options", &cpp_options
),
1703 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options
),
1704 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options
),
1705 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp
),
1706 INIT_STATIC_SPEC ("cc1", &cc1_spec
),
1707 INIT_STATIC_SPEC ("cc1_options", &cc1_options
),
1708 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec
),
1709 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec
),
1710 INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec
),
1711 INIT_STATIC_SPEC ("endfile", &endfile_spec
),
1712 INIT_STATIC_SPEC ("link", &link_spec
),
1713 INIT_STATIC_SPEC ("lib", &lib_spec
),
1714 INIT_STATIC_SPEC ("link_gomp", &link_gomp_spec
),
1715 INIT_STATIC_SPEC ("libgcc", &libgcc_spec
),
1716 INIT_STATIC_SPEC ("startfile", &startfile_spec
),
1717 INIT_STATIC_SPEC ("cross_compile", &cross_compile
),
1718 INIT_STATIC_SPEC ("version", &compiler_version
),
1719 INIT_STATIC_SPEC ("multilib", &multilib_select
),
1720 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults
),
1721 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra
),
1722 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches
),
1723 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions
),
1724 INIT_STATIC_SPEC ("multilib_options", &multilib_options
),
1725 INIT_STATIC_SPEC ("multilib_reuse", &multilib_reuse
),
1726 INIT_STATIC_SPEC ("linker", &linker_name_spec
),
1727 INIT_STATIC_SPEC ("linker_plugin_file", &linker_plugin_file_spec
),
1728 INIT_STATIC_SPEC ("lto_wrapper", <o_wrapper_spec
),
1729 INIT_STATIC_SPEC ("lto_gcc", <o_gcc_spec
),
1730 INIT_STATIC_SPEC ("post_link", &post_link_spec
),
1731 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec
),
1732 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix
),
1733 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix
),
1734 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1
),
1735 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec
),
1736 INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec
),
1737 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec
),
1738 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec
),
1739 INIT_STATIC_SPEC ("self_spec", &self_spec
),
1742 #ifdef EXTRA_SPECS /* additional specs needed */
1743 /* Structure to keep track of just the first two args of a spec_list.
1744 That is all that the EXTRA_SPECS macro gives us. */
1747 const char *const name
;
1748 const char *const ptr
;
1751 static const struct spec_list_1 extra_specs_1
[] = { EXTRA_SPECS
};
1752 static struct spec_list
*extra_specs
= (struct spec_list
*) 0;
1755 /* List of dynamically allocates specs that have been defined so far. */
1757 static struct spec_list
*specs
= (struct spec_list
*) 0;
1759 /* List of static spec functions. */
1761 static const struct spec_function static_spec_functions
[] =
1763 { "getenv", getenv_spec_function
},
1764 { "if-exists", if_exists_spec_function
},
1765 { "if-exists-else", if_exists_else_spec_function
},
1766 { "if-exists-then-else", if_exists_then_else_spec_function
},
1767 { "sanitize", sanitize_spec_function
},
1768 { "replace-outfile", replace_outfile_spec_function
},
1769 { "remove-outfile", remove_outfile_spec_function
},
1770 { "version-compare", version_compare_spec_function
},
1771 { "include", include_spec_function
},
1772 { "find-file", find_file_spec_function
},
1773 { "find-plugindir", find_plugindir_spec_function
},
1774 { "print-asm-header", print_asm_header_spec_function
},
1775 { "compare-debug-dump-opt", compare_debug_dump_opt_spec_function
},
1776 { "compare-debug-self-opt", compare_debug_self_opt_spec_function
},
1777 { "pass-through-libs", pass_through_libs_spec_func
},
1778 { "dumps", dumps_spec_func
},
1779 { "gt", greater_than_spec_func
},
1780 { "debug-level-gt", debug_level_greater_than_spec_func
},
1781 { "dwarf-version-gt", dwarf_version_greater_than_spec_func
},
1782 { "fortran-preinclude-file", find_fortran_preinclude_file
},
1783 { "join", join_spec_func
},
1784 #ifdef EXTRA_SPEC_FUNCTIONS
1785 EXTRA_SPEC_FUNCTIONS
1790 static int processing_spec_function
;
1792 /* Add appropriate libgcc specs to OBSTACK, taking into account
1793 various permutations of -shared-libgcc, -shared, and such. */
1795 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1797 #ifndef USE_LD_AS_NEEDED
1798 #define USE_LD_AS_NEEDED 0
1802 init_gcc_specs (struct obstack
*obstack
, const char *shared_name
,
1803 const char *static_name
, const char *eh_name
)
1807 #if USE_LD_AS_NEEDED
1808 buf
= concat ("%{static|static-libgcc|static-pie:", static_name
, " ", eh_name
, "}"
1809 "%{!static:%{!static-libgcc:%{!static-pie:"
1810 "%{!shared-libgcc:",
1811 static_name
, " " LD_AS_NEEDED_OPTION
" ",
1812 shared_name
, " " LD_NO_AS_NEEDED_OPTION
1815 shared_name
, "%{!shared: ", static_name
, "}"
1818 buf
= concat ("%{static|static-libgcc:", static_name
, " ", eh_name
, "}"
1819 "%{!static:%{!static-libgcc:"
1821 "%{!shared-libgcc:", static_name
, " ", eh_name
, "}"
1822 "%{shared-libgcc:", shared_name
, " ", static_name
, "}"
1826 "%{shared-libgcc:", shared_name
, "}"
1827 "%{!shared-libgcc:", static_name
, "}"
1830 "%{shared:", shared_name
, "}"
1835 obstack_grow (obstack
, buf
, strlen (buf
));
1838 #endif /* ENABLE_SHARED_LIBGCC */
1840 /* Initialize the specs lookup routines. */
1845 struct spec_list
*next
= (struct spec_list
*) 0;
1846 struct spec_list
*sl
= (struct spec_list
*) 0;
1850 return; /* Already initialized. */
1853 fnotice (stderr
, "Using built-in specs.\n");
1856 extra_specs
= XCNEWVEC (struct spec_list
, ARRAY_SIZE (extra_specs_1
));
1858 for (i
= ARRAY_SIZE (extra_specs_1
) - 1; i
>= 0; i
--)
1860 sl
= &extra_specs
[i
];
1861 sl
->name
= extra_specs_1
[i
].name
;
1862 sl
->ptr
= extra_specs_1
[i
].ptr
;
1864 sl
->name_len
= strlen (sl
->name
);
1865 sl
->ptr_spec
= &sl
->ptr
;
1866 gcc_assert (sl
->ptr_spec
!= NULL
);
1867 sl
->default_ptr
= sl
->ptr
;
1872 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1874 sl
= &static_specs
[i
];
1879 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1880 /* ??? If neither -shared-libgcc nor --static-libgcc was
1881 seen, then we should be making an educated guess. Some proposed
1882 heuristics for ELF include:
1884 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1885 program will be doing dynamic loading, which will likely
1886 need the shared libgcc.
1888 (2) If "-ldl", then it's also a fair bet that we're doing
1891 (3) For each ET_DYN we're linking against (either through -lfoo
1892 or /some/path/foo.so), check to see whether it or one of
1893 its dependencies depends on a shared libgcc.
1897 If the runtime is fixed to look for program headers instead
1898 of calling __register_frame_info at all, for each object,
1899 use the shared libgcc if any EH symbol referenced.
1901 If crtstuff is fixed to not invoke __register_frame_info
1902 automatically, for each object, use the shared libgcc if
1903 any non-empty unwind section found.
1905 Doing any of this probably requires invoking an external program to
1906 do the actual object file scanning. */
1908 const char *p
= libgcc_spec
;
1911 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1912 when given the proper command line arguments. */
1915 if (in_sep
&& *p
== '-' && startswith (p
, "-lgcc"))
1917 init_gcc_specs (&obstack
,
1919 #ifdef USE_LIBUNWIND_EXCEPTIONS
1925 #ifdef USE_LIBUNWIND_EXCEPTIONS
1926 # ifdef HAVE_LD_STATIC_DYNAMIC
1927 " %{!static:%{!static-pie:" LD_STATIC_OPTION
"}} -lunwind"
1928 " %{!static:%{!static-pie:" LD_DYNAMIC_OPTION
"}}"
1938 else if (in_sep
&& *p
== 'l' && startswith (p
, "libgcc.a%s"))
1940 /* Ug. We don't know shared library extensions. Hope that
1941 systems that use this form don't do shared libraries. */
1942 init_gcc_specs (&obstack
,
1946 #ifdef USE_LIBUNWIND_EXCEPTIONS
1955 obstack_1grow (&obstack
, *p
);
1956 in_sep
= (*p
== ' ');
1961 obstack_1grow (&obstack
, '\0');
1962 libgcc_spec
= XOBFINISH (&obstack
, const char *);
1965 #ifdef USE_AS_TRADITIONAL_FORMAT
1966 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1968 static const char tf
[] = "--traditional-format ";
1969 obstack_grow (&obstack
, tf
, sizeof (tf
) - 1);
1970 obstack_grow0 (&obstack
, asm_spec
, strlen (asm_spec
));
1971 asm_spec
= XOBFINISH (&obstack
, const char *);
1975 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC || \
1976 defined LINKER_HASH_STYLE
1977 # ifdef LINK_BUILDID_SPEC
1978 /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. */
1979 obstack_grow (&obstack
, LINK_BUILDID_SPEC
, sizeof (LINK_BUILDID_SPEC
) - 1);
1981 # ifdef LINK_EH_SPEC
1982 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1983 obstack_grow (&obstack
, LINK_EH_SPEC
, sizeof (LINK_EH_SPEC
) - 1);
1985 # ifdef LINKER_HASH_STYLE
1986 /* Prepend --hash-style=LINKER_HASH_STYLE to whatever link_spec we had
1989 static const char hash_style
[] = "--hash-style=";
1990 obstack_grow (&obstack
, hash_style
, sizeof (hash_style
) - 1);
1991 obstack_grow (&obstack
, LINKER_HASH_STYLE
, sizeof (LINKER_HASH_STYLE
) - 1);
1992 obstack_1grow (&obstack
, ' ');
1995 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
1996 link_spec
= XOBFINISH (&obstack
, const char *);
2002 /* Update the entry for SPEC in the static_specs table to point to VALUE,
2003 ensuring that we free the previous value if necessary. Set alloc_p for the
2004 entry to ALLOC_P: this determines whether we take ownership of VALUE (i.e.
2005 whether we need to free it later on). */
2007 set_static_spec (const char **spec
, const char *value
, bool alloc_p
)
2009 struct spec_list
*sl
= NULL
;
2011 for (unsigned i
= 0; i
< ARRAY_SIZE (static_specs
); i
++)
2013 if (static_specs
[i
].ptr_spec
== spec
)
2015 sl
= static_specs
+ i
;
2024 const char *old
= *spec
;
2025 free (const_cast <char *> (old
));
2029 sl
->alloc_p
= alloc_p
;
2032 /* Update a static spec to a new string, taking ownership of that
2034 static void set_static_spec_owned (const char **spec
, const char *val
)
2036 return set_static_spec (spec
, val
, true);
2039 /* Update a static spec to point to a new value, but don't take
2040 ownership of (i.e. don't free) that string. */
2041 static void set_static_spec_shared (const char **spec
, const char *val
)
2043 return set_static_spec (spec
, val
, false);
2047 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
2048 removed; If the spec starts with a + then SPEC is added to the end of the
2052 set_spec (const char *name
, const char *spec
, bool user_p
)
2054 struct spec_list
*sl
;
2055 const char *old_spec
;
2056 int name_len
= strlen (name
);
2059 /* If this is the first call, initialize the statically allocated specs. */
2062 struct spec_list
*next
= (struct spec_list
*) 0;
2063 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
2065 sl
= &static_specs
[i
];
2072 /* See if the spec already exists. */
2073 for (sl
= specs
; sl
; sl
= sl
->next
)
2074 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, name
))
2079 /* Not found - make it. */
2080 sl
= XNEW (struct spec_list
);
2081 sl
->name
= xstrdup (name
);
2082 sl
->name_len
= name_len
;
2083 sl
->ptr_spec
= &sl
->ptr
;
2085 *(sl
->ptr_spec
) = "";
2087 sl
->default_ptr
= NULL
;
2091 old_spec
= *(sl
->ptr_spec
);
2092 *(sl
->ptr_spec
) = ((spec
[0] == '+' && ISSPACE ((unsigned char)spec
[1]))
2093 ? concat (old_spec
, spec
+ 1, NULL
)
2098 fnotice (stderr
, "Setting spec %s to '%s'\n\n", name
, *(sl
->ptr_spec
));
2101 /* Free the old spec. */
2102 if (old_spec
&& sl
->alloc_p
)
2103 free (CONST_CAST (char *, old_spec
));
2105 sl
->user_p
= user_p
;
2109 /* Accumulate a command (program name and args), and run it. */
2111 typedef const char *const_char_p
; /* For DEF_VEC_P. */
2113 /* Vector of pointers to arguments in the current line of specifications. */
2114 static vec
<const_char_p
> argbuf
;
2116 /* Likewise, but for the current @file. */
2117 static vec
<const_char_p
> at_file_argbuf
;
2119 /* Whether an @file is currently open. */
2120 static bool in_at_file
= false;
2122 /* Were the options -c, -S or -E passed. */
2123 static int have_c
= 0;
2125 /* Was the option -o passed. */
2126 static int have_o
= 0;
2128 /* Was the option -E passed. */
2129 static int have_E
= 0;
2131 /* Pointer to output file name passed in with -o. */
2132 static const char *output_file
= 0;
2134 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
2135 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
2138 static struct temp_name
{
2139 const char *suffix
; /* suffix associated with the code. */
2140 int length
; /* strlen (suffix). */
2141 int unique
; /* Indicates whether %g or %u/%U was used. */
2142 const char *filename
; /* associated filename. */
2143 int filename_length
; /* strlen (filename). */
2144 struct temp_name
*next
;
2147 /* Number of commands executed so far. */
2149 static int execution_count
;
2151 /* Number of commands that exited with a signal. */
2153 static int signal_count
;
2155 /* Allocate the argument vector. */
2161 at_file_argbuf
.create (10);
2164 /* Clear out the vector of arguments (after a command is executed). */
2169 argbuf
.truncate (0);
2170 at_file_argbuf
.truncate (0);
2173 /* Add one argument to the vector at the end.
2174 This is done when a space is seen or at the end of the line.
2175 If DELETE_ALWAYS is nonzero, the arg is a filename
2176 and the file should be deleted eventually.
2177 If DELETE_FAILURE is nonzero, the arg is a filename
2178 and the file should be deleted if this compilation fails. */
2181 store_arg (const char *arg
, int delete_always
, int delete_failure
)
2184 at_file_argbuf
.safe_push (arg
);
2186 argbuf
.safe_push (arg
);
2188 if (delete_always
|| delete_failure
)
2191 /* If the temporary file we should delete is specified as
2192 part of a joined argument extract the filename. */
2194 && (p
= strrchr (arg
, '=')))
2196 record_temp_file (arg
, delete_always
, delete_failure
);
2200 /* Open a temporary @file into which subsequent arguments will be stored. */
2206 fatal_error (input_location
, "cannot open nested response file");
2211 /* Create a temporary @file name. */
2213 static char *make_at_file (void)
2215 static int fileno
= 0;
2217 const char *base
, *ext
;
2219 if (!save_temps_flag
)
2220 return make_temp_file ("");
2223 if (!(base
&& *base
))
2225 if (!(base
&& *base
))
2228 sprintf (filename
, ".args.%d", fileno
++);
2231 if (base
== dumpdir
&& dumpdir_trailing_dash_added
)
2234 return concat (base
, ext
, NULL
);
2237 /* Close the temporary @file and add @file to the argument list. */
2240 close_at_file (void)
2243 fatal_error (input_location
, "cannot close nonexistent response file");
2247 const unsigned int n_args
= at_file_argbuf
.length ();
2251 char **argv
= XALLOCAVEC (char *, n_args
+ 1);
2252 char *temp_file
= make_at_file ();
2253 char *at_argument
= concat ("@", temp_file
, NULL
);
2254 FILE *f
= fopen (temp_file
, "w");
2258 /* Copy the strings over. */
2259 for (i
= 0; i
< n_args
; i
++)
2260 argv
[i
] = CONST_CAST (char *, at_file_argbuf
[i
]);
2263 at_file_argbuf
.truncate (0);
2266 fatal_error (input_location
, "could not open temporary response file %s",
2269 status
= writeargv (argv
, f
);
2272 fatal_error (input_location
,
2273 "could not write to temporary response file %s",
2276 status
= fclose (f
);
2279 fatal_error (input_location
, "could not close temporary response file %s",
2282 store_arg (at_argument
, 0, 0);
2284 record_temp_file (temp_file
, !save_temps_flag
, !save_temps_flag
);
2287 /* Load specs from a file name named FILENAME, replacing occurrences of
2288 various different types of line-endings, \r\n, \n\r and just \r, with
2292 load_specs (const char *filename
)
2296 struct stat statbuf
;
2303 fnotice (stderr
, "Reading specs from %s\n", filename
);
2305 /* Open and stat the file. */
2306 desc
= open (filename
, O_RDONLY
, 0);
2310 /* This leaves DESC open, but the OS will save us. */
2311 fatal_error (input_location
, "cannot read spec file %qs: %m", filename
);
2314 if (stat (filename
, &statbuf
) < 0)
2317 /* Read contents of file into BUFFER. */
2318 buffer
= XNEWVEC (char, statbuf
.st_size
+ 1);
2319 readlen
= read (desc
, buffer
, (unsigned) statbuf
.st_size
);
2322 buffer
[readlen
] = 0;
2325 specs
= XNEWVEC (char, readlen
+ 1);
2327 for (buffer_p
= buffer
; buffer_p
&& *buffer_p
; buffer_p
++)
2333 if (buffer_p
> buffer
&& *(buffer_p
- 1) == '\n') /* \n\r */
2335 else if (*(buffer_p
+ 1) == '\n') /* \r\n */
2349 /* Read compilation specs from a file named FILENAME,
2350 replacing the default ones.
2352 A suffix which starts with `*' is a definition for
2353 one of the machine-specific sub-specs. The "suffix" should be
2354 *asm, *cc1, *cpp, *link, *startfile, etc.
2355 The corresponding spec is stored in asm_spec, etc.,
2356 rather than in the `compilers' vector.
2358 Anything invalid in the file is a fatal error. */
2361 read_specs (const char *filename
, bool main_p
, bool user_p
)
2366 buffer
= load_specs (filename
);
2368 /* Scan BUFFER for specs, putting them in the vector. */
2374 char *in
, *out
, *p1
, *p2
, *p3
;
2376 /* Advance P in BUFFER to the next nonblank nocomment line. */
2377 p
= skip_whitespace (p
);
2381 /* Is this a special command that starts with '%'? */
2382 /* Don't allow this for the main specs file, since it would
2383 encourage people to overwrite it. */
2384 if (*p
== '%' && !main_p
)
2387 while (*p
&& *p
!= '\n')
2393 if (startswith (p1
, "%include")
2394 && (p1
[sizeof "%include" - 1] == ' '
2395 || p1
[sizeof "%include" - 1] == '\t'))
2399 p1
+= sizeof ("%include");
2400 while (*p1
== ' ' || *p1
== '\t')
2403 if (*p1
++ != '<' || p
[-2] != '>')
2404 fatal_error (input_location
,
2405 "specs %%include syntax malformed after "
2407 (long) (p1
- buffer
+ 1));
2410 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
2411 read_specs (new_filename
? new_filename
: p1
, false, user_p
);
2414 else if (startswith (p1
, "%include_noerr")
2415 && (p1
[sizeof "%include_noerr" - 1] == ' '
2416 || p1
[sizeof "%include_noerr" - 1] == '\t'))
2420 p1
+= sizeof "%include_noerr";
2421 while (*p1
== ' ' || *p1
== '\t')
2424 if (*p1
++ != '<' || p
[-2] != '>')
2425 fatal_error (input_location
,
2426 "specs %%include syntax malformed after "
2428 (long) (p1
- buffer
+ 1));
2431 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
2433 read_specs (new_filename
, false, user_p
);
2434 else if (verbose_flag
)
2435 fnotice (stderr
, "could not find specs file %s\n", p1
);
2438 else if (startswith (p1
, "%rename")
2439 && (p1
[sizeof "%rename" - 1] == ' '
2440 || p1
[sizeof "%rename" - 1] == '\t'))
2443 struct spec_list
*sl
;
2444 struct spec_list
*newsl
;
2446 /* Get original name. */
2447 p1
+= sizeof "%rename";
2448 while (*p1
== ' ' || *p1
== '\t')
2451 if (! ISALPHA ((unsigned char) *p1
))
2452 fatal_error (input_location
,
2453 "specs %%rename syntax malformed after "
2455 (long) (p1
- buffer
));
2458 while (*p2
&& !ISSPACE ((unsigned char) *p2
))
2461 if (*p2
!= ' ' && *p2
!= '\t')
2462 fatal_error (input_location
,
2463 "specs %%rename syntax malformed after "
2465 (long) (p2
- buffer
));
2469 while (*p2
== ' ' || *p2
== '\t')
2472 if (! ISALPHA ((unsigned char) *p2
))
2473 fatal_error (input_location
,
2474 "specs %%rename syntax malformed after "
2476 (long) (p2
- buffer
));
2478 /* Get new spec name. */
2480 while (*p3
&& !ISSPACE ((unsigned char) *p3
))
2484 fatal_error (input_location
,
2485 "specs %%rename syntax malformed after "
2487 (long) (p3
- buffer
));
2490 for (sl
= specs
; sl
; sl
= sl
->next
)
2491 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, p1
))
2495 fatal_error (input_location
,
2496 "specs %s spec was not found to be renamed", p1
);
2498 if (strcmp (p1
, p2
) == 0)
2501 for (newsl
= specs
; newsl
; newsl
= newsl
->next
)
2502 if (strcmp (newsl
->name
, p2
) == 0)
2503 fatal_error (input_location
,
2504 "%s: attempt to rename spec %qs to "
2505 "already defined spec %qs",
2510 fnotice (stderr
, "rename spec %s to %s\n", p1
, p2
);
2512 fnotice (stderr
, "spec is '%s'\n\n", *(sl
->ptr_spec
));
2516 set_spec (p2
, *(sl
->ptr_spec
), user_p
);
2518 free (CONST_CAST (char *, *(sl
->ptr_spec
)));
2520 *(sl
->ptr_spec
) = "";
2525 fatal_error (input_location
,
2526 "specs unknown %% command after %ld characters",
2527 (long) (p1
- buffer
));
2530 /* Find the colon that should end the suffix. */
2532 while (*p1
&& *p1
!= ':' && *p1
!= '\n')
2535 /* The colon shouldn't be missing. */
2537 fatal_error (input_location
,
2538 "specs file malformed after %ld characters",
2539 (long) (p1
- buffer
));
2541 /* Skip back over trailing whitespace. */
2543 while (p2
> buffer
&& (p2
[-1] == ' ' || p2
[-1] == '\t'))
2546 /* Copy the suffix to a string. */
2547 suffix
= save_string (p
, p2
- p
);
2548 /* Find the next line. */
2549 p
= skip_whitespace (p1
+ 1);
2551 fatal_error (input_location
,
2552 "specs file malformed after %ld characters",
2553 (long) (p
- buffer
));
2556 /* Find next blank line or end of string. */
2557 while (*p1
&& !(*p1
== '\n' && (p1
[1] == '\n' || p1
[1] == '\0')))
2560 /* Specs end at the blank line and do not include the newline. */
2561 spec
= save_string (p
, p1
- p
);
2564 /* Delete backslash-newline sequences from the spec. */
2569 if (in
[0] == '\\' && in
[1] == '\n')
2571 else if (in
[0] == '#')
2572 while (*in
&& *in
!= '\n')
2580 if (suffix
[0] == '*')
2582 if (! strcmp (suffix
, "*link_command"))
2583 link_command_spec
= spec
;
2586 set_spec (suffix
+ 1, spec
, user_p
);
2592 /* Add this pair to the vector. */
2594 = XRESIZEVEC (struct compiler
, compilers
, n_compilers
+ 2);
2596 compilers
[n_compilers
].suffix
= suffix
;
2597 compilers
[n_compilers
].spec
= spec
;
2599 memset (&compilers
[n_compilers
], 0, sizeof compilers
[n_compilers
]);
2603 link_command_spec
= spec
;
2606 if (link_command_spec
== 0)
2607 fatal_error (input_location
, "spec file has no spec for linking");
2609 XDELETEVEC (buffer
);
2612 /* Record the names of temporary files we tell compilers to write,
2613 and delete them at the end of the run. */
2615 /* This is the common prefix we use to make temp file names.
2616 It is chosen once for each run of this program.
2617 It is substituted into a spec by %g or %j.
2618 Thus, all temp file names contain this prefix.
2619 In practice, all temp file names start with this prefix.
2621 This prefix comes from the envvar TMPDIR if it is defined;
2622 otherwise, from the P_tmpdir macro if that is defined;
2623 otherwise, in /usr/tmp or /tmp;
2624 or finally the current directory if all else fails. */
2626 static const char *temp_filename
;
2628 /* Length of the prefix. */
2630 static int temp_filename_length
;
2632 /* Define the list of temporary files to delete. */
2637 struct temp_file
*next
;
2640 /* Queue of files to delete on success or failure of compilation. */
2641 static struct temp_file
*always_delete_queue
;
2642 /* Queue of files to delete on failure of compilation. */
2643 static struct temp_file
*failure_delete_queue
;
2645 /* Record FILENAME as a file to be deleted automatically.
2646 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2647 otherwise delete it in any case.
2648 FAIL_DELETE nonzero means delete it if a compilation step fails;
2649 otherwise delete it in any case. */
2652 record_temp_file (const char *filename
, int always_delete
, int fail_delete
)
2654 char *const name
= xstrdup (filename
);
2658 struct temp_file
*temp
;
2659 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2660 if (! filename_cmp (name
, temp
->name
))
2666 temp
= XNEW (struct temp_file
);
2667 temp
->next
= always_delete_queue
;
2669 always_delete_queue
= temp
;
2676 struct temp_file
*temp
;
2677 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2678 if (! filename_cmp (name
, temp
->name
))
2684 temp
= XNEW (struct temp_file
);
2685 temp
->next
= failure_delete_queue
;
2687 failure_delete_queue
= temp
;
2693 /* Delete all the temporary files whose names we previously recorded. */
2695 #ifndef DELETE_IF_ORDINARY
2696 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2699 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2700 if (unlink (NAME) < 0) \
2702 error ("%s: %m", (NAME)); \
2707 delete_if_ordinary (const char *name
)
2713 printf ("Delete %s? (y or n) ", name
);
2717 while ((c
= getchar ()) != '\n' && c
!= EOF
)
2720 if (i
== 'y' || i
== 'Y')
2722 DELETE_IF_ORDINARY (name
, st
, verbose_flag
);
2726 delete_temp_files (void)
2728 struct temp_file
*temp
;
2730 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2731 delete_if_ordinary (temp
->name
);
2732 always_delete_queue
= 0;
2735 /* Delete all the files to be deleted on error. */
2738 delete_failure_queue (void)
2740 struct temp_file
*temp
;
2742 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2743 delete_if_ordinary (temp
->name
);
2747 clear_failure_queue (void)
2749 failure_delete_queue
= 0;
2752 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2754 If DO_MULTI is true iterate over the paths twice, first with multilib
2755 suffix then without, otherwise iterate over the paths once without
2756 adding a multilib suffix. When DO_MULTI is true, some attempt is made
2757 to avoid visiting the same path twice, but we could do better. For
2758 instance, /usr/lib/../lib is considered different from /usr/lib.
2759 At least EXTRA_SPACE chars past the end of the path passed to
2760 CALLBACK are available for use by the callback.
2761 CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2763 Returns the value returned by CALLBACK. */
2766 for_each_path (const struct path_prefix
*paths
,
2769 void *(*callback
) (char *, void *),
2770 void *callback_info
)
2772 struct prefix_list
*pl
;
2773 const char *multi_dir
= NULL
;
2774 const char *multi_os_dir
= NULL
;
2775 const char *multiarch_suffix
= NULL
;
2776 const char *multi_suffix
;
2777 const char *just_multi_suffix
;
2780 bool skip_multi_dir
= false;
2781 bool skip_multi_os_dir
= false;
2783 multi_suffix
= machine_suffix
;
2784 just_multi_suffix
= just_machine_suffix
;
2785 if (do_multi
&& multilib_dir
&& strcmp (multilib_dir
, ".") != 0)
2787 multi_dir
= concat (multilib_dir
, dir_separator_str
, NULL
);
2788 multi_suffix
= concat (multi_suffix
, multi_dir
, NULL
);
2789 just_multi_suffix
= concat (just_multi_suffix
, multi_dir
, NULL
);
2791 if (do_multi
&& multilib_os_dir
&& strcmp (multilib_os_dir
, ".") != 0)
2792 multi_os_dir
= concat (multilib_os_dir
, dir_separator_str
, NULL
);
2794 multiarch_suffix
= concat (multiarch_dir
, dir_separator_str
, NULL
);
2798 size_t multi_dir_len
= 0;
2799 size_t multi_os_dir_len
= 0;
2800 size_t multiarch_len
= 0;
2802 size_t just_suffix_len
;
2806 multi_dir_len
= strlen (multi_dir
);
2808 multi_os_dir_len
= strlen (multi_os_dir
);
2809 if (multiarch_suffix
)
2810 multiarch_len
= strlen (multiarch_suffix
);
2811 suffix_len
= strlen (multi_suffix
);
2812 just_suffix_len
= strlen (just_multi_suffix
);
2816 len
= paths
->max_len
+ extra_space
+ 1;
2817 len
+= MAX (MAX (suffix_len
, multi_os_dir_len
), multiarch_len
);
2818 path
= XNEWVEC (char, len
);
2821 for (pl
= paths
->plist
; pl
!= 0; pl
= pl
->next
)
2823 len
= strlen (pl
->prefix
);
2824 memcpy (path
, pl
->prefix
, len
);
2826 /* Look first in MACHINE/VERSION subdirectory. */
2827 if (!skip_multi_dir
)
2829 memcpy (path
+ len
, multi_suffix
, suffix_len
+ 1);
2830 ret
= callback (path
, callback_info
);
2835 /* Some paths are tried with just the machine (ie. target)
2836 subdir. This is used for finding as, ld, etc. */
2838 && pl
->require_machine_suffix
== 2)
2840 memcpy (path
+ len
, just_multi_suffix
, just_suffix_len
+ 1);
2841 ret
= callback (path
, callback_info
);
2846 /* Now try the multiarch path. */
2848 && !pl
->require_machine_suffix
&& multiarch_dir
)
2850 memcpy (path
+ len
, multiarch_suffix
, multiarch_len
+ 1);
2851 ret
= callback (path
, callback_info
);
2856 /* Now try the base path. */
2857 if (!pl
->require_machine_suffix
2858 && !(pl
->os_multilib
? skip_multi_os_dir
: skip_multi_dir
))
2860 const char *this_multi
;
2861 size_t this_multi_len
;
2863 if (pl
->os_multilib
)
2865 this_multi
= multi_os_dir
;
2866 this_multi_len
= multi_os_dir_len
;
2870 this_multi
= multi_dir
;
2871 this_multi_len
= multi_dir_len
;
2875 memcpy (path
+ len
, this_multi
, this_multi_len
+ 1);
2879 ret
= callback (path
, callback_info
);
2887 if (multi_dir
== NULL
&& multi_os_dir
== NULL
)
2890 /* Run through the paths again, this time without multilibs.
2891 Don't repeat any we have already seen. */
2894 free (CONST_CAST (char *, multi_dir
));
2896 free (CONST_CAST (char *, multi_suffix
));
2897 multi_suffix
= machine_suffix
;
2898 free (CONST_CAST (char *, just_multi_suffix
));
2899 just_multi_suffix
= just_machine_suffix
;
2902 skip_multi_dir
= true;
2905 free (CONST_CAST (char *, multi_os_dir
));
2906 multi_os_dir
= NULL
;
2909 skip_multi_os_dir
= true;
2914 free (CONST_CAST (char *, multi_dir
));
2915 free (CONST_CAST (char *, multi_suffix
));
2916 free (CONST_CAST (char *, just_multi_suffix
));
2919 free (CONST_CAST (char *, multi_os_dir
));
2925 /* Callback for build_search_list. Adds path to obstack being built. */
2927 struct add_to_obstack_info
{
2934 add_to_obstack (char *path
, void *data
)
2936 struct add_to_obstack_info
*info
= (struct add_to_obstack_info
*) data
;
2938 if (info
->check_dir
&& !is_directory (path
, false))
2941 if (!info
->first_time
)
2942 obstack_1grow (info
->ob
, PATH_SEPARATOR
);
2944 obstack_grow (info
->ob
, path
, strlen (path
));
2946 info
->first_time
= false;
2950 /* Add or change the value of an environment variable, outputting the
2951 change to standard error if in verbose mode. */
2953 xputenv (const char *string
)
2958 /* Build a list of search directories from PATHS.
2959 PREFIX is a string to prepend to the list.
2960 If CHECK_DIR_P is true we ensure the directory exists.
2961 If DO_MULTI is true, multilib paths are output first, then
2963 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2964 It is also used by the --print-search-dirs flag. */
2967 build_search_list (const struct path_prefix
*paths
, const char *prefix
,
2968 bool check_dir
, bool do_multi
)
2970 struct add_to_obstack_info info
;
2972 info
.ob
= &collect_obstack
;
2973 info
.check_dir
= check_dir
;
2974 info
.first_time
= true;
2976 obstack_grow (&collect_obstack
, prefix
, strlen (prefix
));
2977 obstack_1grow (&collect_obstack
, '=');
2979 for_each_path (paths
, do_multi
, 0, add_to_obstack
, &info
);
2981 obstack_1grow (&collect_obstack
, '\0');
2982 return XOBFINISH (&collect_obstack
, char *);
2985 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2989 putenv_from_prefixes (const struct path_prefix
*paths
, const char *env_var
,
2992 xputenv (build_search_list (paths
, env_var
, true, do_multi
));
2995 /* Check whether NAME can be accessed in MODE. This is like access,
2996 except that it never considers directories to be executable. */
2999 access_check (const char *name
, int mode
)
3005 if (stat (name
, &st
) < 0
3006 || S_ISDIR (st
.st_mode
))
3010 return access (name
, mode
);
3013 /* Callback for find_a_file. Appends the file name to the directory
3014 path. If the resulting file exists in the right mode, return the
3015 full pathname to the file. */
3017 struct file_at_path_info
{
3026 file_at_path (char *path
, void *data
)
3028 struct file_at_path_info
*info
= (struct file_at_path_info
*) data
;
3029 size_t len
= strlen (path
);
3031 memcpy (path
+ len
, info
->name
, info
->name_len
);
3032 len
+= info
->name_len
;
3034 /* Some systems have a suffix for executable files.
3035 So try appending that first. */
3036 if (info
->suffix_len
)
3038 memcpy (path
+ len
, info
->suffix
, info
->suffix_len
+ 1);
3039 if (access_check (path
, info
->mode
) == 0)
3044 if (access_check (path
, info
->mode
) == 0)
3050 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
3051 access to check permissions. If DO_MULTI is true, search multilib
3052 paths then non-multilib paths, otherwise do not search multilib paths.
3053 Return 0 if not found, otherwise return its name, allocated with malloc. */
3056 find_a_file (const struct path_prefix
*pprefix
, const char *name
, int mode
,
3059 struct file_at_path_info info
;
3061 /* Find the filename in question (special case for absolute paths). */
3063 if (IS_ABSOLUTE_PATH (name
))
3065 if (access (name
, mode
) == 0)
3066 return xstrdup (name
);
3072 info
.suffix
= (mode
& X_OK
) != 0 ? HOST_EXECUTABLE_SUFFIX
: "";
3073 info
.name_len
= strlen (info
.name
);
3074 info
.suffix_len
= strlen (info
.suffix
);
3077 return (char*) for_each_path (pprefix
, do_multi
,
3078 info
.name_len
+ info
.suffix_len
,
3079 file_at_path
, &info
);
3082 /* Specialization of find_a_file for programs that also takes into account
3083 configure-specified default programs. */
3086 find_a_program (const char *name
)
3088 /* Do not search if default matches query. */
3090 #ifdef DEFAULT_ASSEMBLER
3091 if (! strcmp (name
, "as") && access (DEFAULT_ASSEMBLER
, X_OK
) == 0)
3092 return xstrdup (DEFAULT_ASSEMBLER
);
3095 #ifdef DEFAULT_LINKER
3096 if (! strcmp (name
, "ld") && access (DEFAULT_LINKER
, X_OK
) == 0)
3097 return xstrdup (DEFAULT_LINKER
);
3100 #ifdef DEFAULT_DSYMUTIL
3101 if (! strcmp (name
, "dsymutil") && access (DEFAULT_DSYMUTIL
, X_OK
) == 0)
3102 return xstrdup (DEFAULT_DSYMUTIL
);
3105 return find_a_file (&exec_prefixes
, name
, X_OK
, false);
3108 /* Ranking of prefixes in the sort list. -B prefixes are put before
3111 enum path_prefix_priority
3113 PREFIX_PRIORITY_B_OPT
,
3114 PREFIX_PRIORITY_LAST
3117 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
3118 order according to PRIORITY. Within each PRIORITY, new entries are
3121 If WARN is nonzero, we will warn if no file is found
3122 through this prefix. WARN should point to an int
3123 which will be set to 1 if this entry is used.
3125 COMPONENT is the value to be passed to update_path.
3127 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
3128 the complete value of machine_suffix.
3129 2 means try both machine_suffix and just_machine_suffix. */
3132 add_prefix (struct path_prefix
*pprefix
, const char *prefix
,
3133 const char *component
, /* enum prefix_priority */ int priority
,
3134 int require_machine_suffix
, int os_multilib
)
3136 struct prefix_list
*pl
, **prev
;
3139 for (prev
= &pprefix
->plist
;
3140 (*prev
) != NULL
&& (*prev
)->priority
<= priority
;
3141 prev
= &(*prev
)->next
)
3144 /* Keep track of the longest prefix. */
3146 prefix
= update_path (prefix
, component
);
3147 len
= strlen (prefix
);
3148 if (len
> pprefix
->max_len
)
3149 pprefix
->max_len
= len
;
3151 pl
= XNEW (struct prefix_list
);
3152 pl
->prefix
= prefix
;
3153 pl
->require_machine_suffix
= require_machine_suffix
;
3154 pl
->priority
= priority
;
3155 pl
->os_multilib
= os_multilib
;
3157 /* Insert after PREV. */
3162 /* Same as add_prefix, but prepending target_system_root to prefix. */
3163 /* The target_system_root prefix has been relocated by gcc_exec_prefix. */
3165 add_sysrooted_prefix (struct path_prefix
*pprefix
, const char *prefix
,
3166 const char *component
,
3167 /* enum prefix_priority */ int priority
,
3168 int require_machine_suffix
, int os_multilib
)
3170 if (!IS_ABSOLUTE_PATH (prefix
))
3171 fatal_error (input_location
, "system path %qs is not absolute", prefix
);
3173 if (target_system_root
)
3175 char *sysroot_no_trailing_dir_separator
= xstrdup (target_system_root
);
3176 size_t sysroot_len
= strlen (target_system_root
);
3179 && target_system_root
[sysroot_len
- 1] == DIR_SEPARATOR
)
3180 sysroot_no_trailing_dir_separator
[sysroot_len
- 1] = '\0';
3182 if (target_sysroot_suffix
)
3183 prefix
= concat (sysroot_no_trailing_dir_separator
,
3184 target_sysroot_suffix
, prefix
, NULL
);
3186 prefix
= concat (sysroot_no_trailing_dir_separator
, prefix
, NULL
);
3188 free (sysroot_no_trailing_dir_separator
);
3190 /* We have to override this because GCC's notion of sysroot
3191 moves along with GCC. */
3195 add_prefix (pprefix
, prefix
, component
, priority
,
3196 require_machine_suffix
, os_multilib
);
3199 /* Same as add_prefix, but prepending target_sysroot_hdrs_suffix to prefix. */
3202 add_sysrooted_hdrs_prefix (struct path_prefix
*pprefix
, const char *prefix
,
3203 const char *component
,
3204 /* enum prefix_priority */ int priority
,
3205 int require_machine_suffix
, int os_multilib
)
3207 if (!IS_ABSOLUTE_PATH (prefix
))
3208 fatal_error (input_location
, "system path %qs is not absolute", prefix
);
3210 if (target_system_root
)
3212 char *sysroot_no_trailing_dir_separator
= xstrdup (target_system_root
);
3213 size_t sysroot_len
= strlen (target_system_root
);
3216 && target_system_root
[sysroot_len
- 1] == DIR_SEPARATOR
)
3217 sysroot_no_trailing_dir_separator
[sysroot_len
- 1] = '\0';
3219 if (target_sysroot_hdrs_suffix
)
3220 prefix
= concat (sysroot_no_trailing_dir_separator
,
3221 target_sysroot_hdrs_suffix
, prefix
, NULL
);
3223 prefix
= concat (sysroot_no_trailing_dir_separator
, prefix
, NULL
);
3225 free (sysroot_no_trailing_dir_separator
);
3227 /* We have to override this because GCC's notion of sysroot
3228 moves along with GCC. */
3232 add_prefix (pprefix
, prefix
, component
, priority
,
3233 require_machine_suffix
, os_multilib
);
3237 /* Execute the command specified by the arguments on the current line of spec.
3238 When using pipes, this includes several piped-together commands
3239 with `|' between them.
3241 Return 0 if successful, -1 if failed. */
3247 int n_commands
; /* # of command. */
3249 struct pex_obj
*pex
;
3252 const char *prog
; /* program name. */
3253 const char **argv
; /* vector of args. */
3257 struct command
*commands
; /* each command buffer with above info. */
3259 gcc_assert (!processing_spec_function
);
3263 string
= find_a_program (argbuf
[0]);
3266 insert_wrapper (wrapper_string
);
3269 /* Count # of piped commands. */
3270 for (n_commands
= 1, i
= 0; argbuf
.iterate (i
, &arg
); i
++)
3271 if (strcmp (arg
, "|") == 0)
3274 /* Get storage for each command. */
3275 commands
= XALLOCAVEC (struct command
, n_commands
);
3277 /* Split argbuf into its separate piped processes,
3278 and record info about each one.
3279 Also search for the programs that are to be run. */
3281 argbuf
.safe_push (0);
3283 commands
[0].prog
= argbuf
[0]; /* first command. */
3284 commands
[0].argv
= argbuf
.address ();
3286 if (!wrapper_string
)
3288 string
= find_a_program(commands
[0].prog
);
3290 commands
[0].argv
[0] = string
;
3293 for (n_commands
= 1, i
= 0; argbuf
.iterate (i
, &arg
); i
++)
3294 if (arg
&& strcmp (arg
, "|") == 0)
3295 { /* each command. */
3296 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
3297 fatal_error (input_location
, "%<-pipe%> not supported");
3299 argbuf
[i
] = 0; /* Termination of command args. */
3300 commands
[n_commands
].prog
= argbuf
[i
+ 1];
3301 commands
[n_commands
].argv
3302 = &(argbuf
.address ())[i
+ 1];
3303 string
= find_a_program(commands
[n_commands
].prog
);
3305 commands
[n_commands
].argv
[0] = string
;
3309 /* If -v, print what we are about to do, and maybe query. */
3313 /* For help listings, put a blank line between sub-processes. */
3314 if (print_help_list
)
3315 fputc ('\n', stderr
);
3317 /* Print each piped command as a separate line. */
3318 for (i
= 0; i
< n_commands
; i
++)
3320 const char *const *j
;
3322 if (verbose_only_flag
)
3324 for (j
= commands
[i
].argv
; *j
; j
++)
3327 for (p
= *j
; *p
; ++p
)
3328 if (!ISALNUM ((unsigned char) *p
)
3329 && *p
!= '_' && *p
!= '/' && *p
!= '-' && *p
!= '.')
3333 fprintf (stderr
, " \"");
3334 for (p
= *j
; *p
; ++p
)
3336 if (*p
== '"' || *p
== '\\' || *p
== '$')
3337 fputc ('\\', stderr
);
3340 fputc ('"', stderr
);
3342 /* If it's empty, print "". */
3344 fprintf (stderr
, " \"\"");
3346 fprintf (stderr
, " %s", *j
);
3350 for (j
= commands
[i
].argv
; *j
; j
++)
3351 /* If it's empty, print "". */
3353 fprintf (stderr
, " \"\"");
3355 fprintf (stderr
, " %s", *j
);
3357 /* Print a pipe symbol after all but the last command. */
3358 if (i
+ 1 != n_commands
)
3359 fprintf (stderr
, " |");
3360 fprintf (stderr
, "\n");
3363 if (verbose_only_flag
!= 0)
3365 /* verbose_only_flag should act as if the spec was
3366 executed, so increment execution_count before
3367 returning. This prevents spurious warnings about
3368 unused linker input files, etc. */
3373 fnotice (stderr
, "\nGo ahead? (y or n) ");
3377 while (getchar () != '\n')
3380 if (i
!= 'y' && i
!= 'Y')
3385 #ifdef ENABLE_VALGRIND_CHECKING
3386 /* Run the each command through valgrind. To simplify prepending the
3387 path to valgrind and the option "-q" (for quiet operation unless
3388 something triggers), we allocate a separate argv array. */
3390 for (i
= 0; i
< n_commands
; i
++)
3396 for (argc
= 0; commands
[i
].argv
[argc
] != NULL
; argc
++)
3399 argv
= XALLOCAVEC (const char *, argc
+ 3);
3401 argv
[0] = VALGRIND_PATH
;
3403 for (j
= 2; j
< argc
+ 2; j
++)
3404 argv
[j
] = commands
[i
].argv
[j
- 2];
3407 commands
[i
].argv
= argv
;
3408 commands
[i
].prog
= argv
[0];
3412 /* Run each piped subprocess. */
3414 pex
= pex_init (PEX_USE_PIPES
| ((report_times
|| report_times_to_file
)
3415 ? PEX_RECORD_TIMES
: 0),
3416 progname
, temp_filename
);
3418 fatal_error (input_location
, "%<pex_init%> failed: %m");
3420 for (i
= 0; i
< n_commands
; i
++)
3424 const char *string
= commands
[i
].argv
[0];
3426 errmsg
= pex_run (pex
,
3427 ((i
+ 1 == n_commands
? PEX_LAST
: 0)
3428 | (string
== commands
[i
].prog
? PEX_SEARCH
: 0)),
3429 string
, CONST_CAST (char **, commands
[i
].argv
),
3434 fatal_error (input_location
,
3435 err
? G_("cannot execute %qs: %s: %m")
3436 : G_("cannot execute %qs: %s"),
3440 if (i
&& string
!= commands
[i
].prog
)
3441 free (CONST_CAST (char *, string
));
3446 /* Wait for all the subprocesses to finish. */
3450 struct pex_time
*times
= NULL
;
3453 statuses
= XALLOCAVEC (int, n_commands
);
3454 if (!pex_get_status (pex
, n_commands
, statuses
))
3455 fatal_error (input_location
, "failed to get exit status: %m");
3457 if (report_times
|| report_times_to_file
)
3459 times
= XALLOCAVEC (struct pex_time
, n_commands
);
3460 if (!pex_get_times (pex
, n_commands
, times
))
3461 fatal_error (input_location
, "failed to get process times: %m");
3466 for (i
= 0; i
< n_commands
; ++i
)
3468 int status
= statuses
[i
];
3470 if (WIFSIGNALED (status
))
3471 switch (WTERMSIG (status
))
3475 /* SIGQUIT and SIGKILL are not available on MinGW. */
3482 /* The user (or environment) did something to the
3483 inferior. Making this an ICE confuses the user into
3484 thinking there's a compiler bug. Much more likely is
3485 the user or OOM killer nuked it. */
3486 fatal_error (input_location
,
3487 "%s signal terminated program %s",
3488 strsignal (WTERMSIG (status
)),
3494 /* SIGPIPE is a special case. It happens in -pipe mode
3495 when the compiler dies before the preprocessor is
3496 done, or the assembler dies before the compiler is
3497 done. There's generally been an error already, and
3498 this is just fallout. So don't generate another
3499 error unless we would otherwise have succeeded. */
3500 if (signal_count
|| greatest_status
>= MIN_FATAL_STATUS
)
3510 /* The inferior failed to catch the signal. */
3511 internal_error_no_backtrace ("%s signal terminated program %s",
3512 strsignal (WTERMSIG (status
)),
3515 else if (WIFEXITED (status
)
3516 && WEXITSTATUS (status
) >= MIN_FATAL_STATUS
)
3518 /* For ICEs in cc1, cc1obj, cc1plus see if it is
3519 reproducible or not. */
3522 && WEXITSTATUS (status
) == ICE_EXIT_CODE
3524 && (p
= strrchr (commands
[0].argv
[0], DIR_SEPARATOR
))
3525 && startswith (p
+ 1, "cc1"))
3526 try_generate_repro (commands
[0].argv
);
3527 if (WEXITSTATUS (status
) > greatest_status
)
3528 greatest_status
= WEXITSTATUS (status
);
3532 if (report_times
|| report_times_to_file
)
3534 struct pex_time
*pt
= ×
[i
];
3537 ut
= ((double) pt
->user_seconds
3538 + (double) pt
->user_microseconds
/ 1.0e6
);
3539 st
= ((double) pt
->system_seconds
3540 + (double) pt
->system_microseconds
/ 1.0e6
);
3545 fnotice (stderr
, "# %s %.2f %.2f\n",
3546 commands
[i
].prog
, ut
, st
);
3548 if (report_times_to_file
)
3551 const char *const *j
;
3553 fprintf (report_times_to_file
, "%g %g", ut
, st
);
3555 for (j
= &commands
[i
].prog
; *j
; j
= &commands
[i
].argv
[++c
])
3558 for (p
= *j
; *p
; ++p
)
3559 if (*p
== '"' || *p
== '\\' || *p
== '$'
3565 fprintf (report_times_to_file
, " \"");
3566 for (p
= *j
; *p
; ++p
)
3568 if (*p
== '"' || *p
== '\\' || *p
== '$')
3569 fputc ('\\', report_times_to_file
);
3570 fputc (*p
, report_times_to_file
);
3572 fputc ('"', report_times_to_file
);
3575 fprintf (report_times_to_file
, " %s", *j
);
3578 fputc ('\n', report_times_to_file
);
3584 if (commands
[0].argv
[0] != commands
[0].prog
)
3585 free (CONST_CAST (char *, commands
[0].argv
[0]));
3591 static struct switchstr
*switches
;
3593 static int n_switches
;
3595 static int n_switches_alloc
;
3597 /* Set to zero if -fcompare-debug is disabled, positive if it's
3598 enabled and we're running the first compilation, negative if it's
3599 enabled and we're running the second compilation. For most of the
3600 time, it's in the range -1..1, but it can be temporarily set to 2
3601 or 3 to indicate that the -fcompare-debug flags didn't come from
3602 the command-line, but rather from the GCC_COMPARE_DEBUG environment
3603 variable, until a synthesized -fcompare-debug flag is added to the
3607 /* Set to nonzero if we've seen the -fcompare-debug-second flag. */
3608 int compare_debug_second
;
3610 /* Set to the flags that should be passed to the second compilation in
3611 a -fcompare-debug compilation. */
3612 const char *compare_debug_opt
;
3614 static struct switchstr
*switches_debug_check
[2];
3616 static int n_switches_debug_check
[2];
3618 static int n_switches_alloc_debug_check
[2];
3620 static char *debug_check_temp_file
[2];
3622 /* Language is one of three things:
3624 1) The name of a real programming language.
3625 2) NULL, indicating that no one has figured out
3627 3) '*', indicating that the file should be passed
3632 const char *language
;
3633 struct compiler
*incompiler
;
3638 /* Also a vector of input files specified. */
3640 static struct infile
*infiles
;
3644 static int n_infiles_alloc
;
3646 /* True if undefined environment variables encountered during spec processing
3647 are ok to ignore, typically when we're running for --help or --version. */
3649 static bool spec_undefvar_allowed
;
3651 /* True if multiple input files are being compiled to a single
3654 static bool combine_inputs
;
3656 /* This counts the number of libraries added by lang_specific_driver, so that
3657 we can tell if there were any user supplied any files or libraries. */
3659 static int added_libraries
;
3661 /* And a vector of corresponding output files is made up later. */
3663 const char **outfiles
;
3665 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3667 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
3668 is true if we should look for an executable suffix. DO_OBJ
3669 is true if we should look for an object suffix. */
3672 convert_filename (const char *name
, int do_exe ATTRIBUTE_UNUSED
,
3673 int do_obj ATTRIBUTE_UNUSED
)
3675 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3683 len
= strlen (name
);
3685 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3686 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
3687 if (do_obj
&& len
> 2
3688 && name
[len
- 2] == '.'
3689 && name
[len
- 1] == 'o')
3691 obstack_grow (&obstack
, name
, len
- 2);
3692 obstack_grow0 (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
3693 name
= XOBFINISH (&obstack
, const char *);
3697 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3698 /* If there is no filetype, make it the executable suffix (which includes
3699 the "."). But don't get confused if we have just "-o". */
3700 if (! do_exe
|| TARGET_EXECUTABLE_SUFFIX
[0] == 0 || not_actual_file_p (name
))
3703 for (i
= len
- 1; i
>= 0; i
--)
3704 if (IS_DIR_SEPARATOR (name
[i
]))
3707 for (i
++; i
< len
; i
++)
3711 obstack_grow (&obstack
, name
, len
);
3712 obstack_grow0 (&obstack
, TARGET_EXECUTABLE_SUFFIX
,
3713 strlen (TARGET_EXECUTABLE_SUFFIX
));
3714 name
= XOBFINISH (&obstack
, const char *);
3721 /* Display the command line switches accepted by gcc. */
3725 printf (_("Usage: %s [options] file...\n"), progname
);
3726 fputs (_("Options:\n"), stdout
);
3728 fputs (_(" -pass-exit-codes Exit with highest error code from a phase.\n"), stdout
);
3729 fputs (_(" --help Display this information.\n"), stdout
);
3730 fputs (_(" --target-help Display target specific command line options "
3731 "(including assembler and linker options).\n"), stdout
);
3732 fputs (_(" --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...].\n"), stdout
);
3733 fputs (_(" Display specific types of command line options.\n"), stdout
);
3735 fputs (_(" (Use '-v --help' to display command line options of sub-processes).\n"), stdout
);
3736 fputs (_(" --version Display compiler version information.\n"), stdout
);
3737 fputs (_(" -dumpspecs Display all of the built in spec strings.\n"), stdout
);
3738 fputs (_(" -dumpversion Display the version of the compiler.\n"), stdout
);
3739 fputs (_(" -dumpmachine Display the compiler's target processor.\n"), stdout
);
3740 fputs (_(" -foffload=<targets> Specify offloading targets.\n"), stdout
);
3741 fputs (_(" -print-search-dirs Display the directories in the compiler's search path.\n"), stdout
);
3742 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library.\n"), stdout
);
3743 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>.\n"), stdout
);
3744 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>.\n"), stdout
);
3746 -print-multiarch Display the target's normalized GNU triplet, used as\n\
3747 a component in the library path.\n"), stdout
);
3748 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc.\n"), stdout
);
3750 -print-multi-lib Display the mapping between command line options and\n\
3751 multiple library search directories.\n"), stdout
);
3752 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries.\n"), stdout
);
3753 fputs (_(" -print-sysroot Display the target libraries directory.\n"), stdout
);
3754 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers.\n"), stdout
);
3755 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler.\n"), stdout
);
3756 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor.\n"), stdout
);
3757 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker.\n"), stdout
);
3758 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler.\n"), stdout
);
3759 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor.\n"), stdout
);
3760 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker.\n"), stdout
);
3761 fputs (_(" -save-temps Do not delete intermediate files.\n"), stdout
);
3762 fputs (_(" -save-temps=<arg> Do not delete intermediate files.\n"), stdout
);
3764 -no-canonical-prefixes Do not canonicalize paths when building relative\n\
3765 prefixes to other gcc components.\n"), stdout
);
3766 fputs (_(" -pipe Use pipes rather than intermediate files.\n"), stdout
);
3767 fputs (_(" -time Time the execution of each subprocess.\n"), stdout
);
3768 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>.\n"), stdout
);
3769 fputs (_(" -std=<standard> Assume that the input sources are for <standard>.\n"), stdout
);
3771 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3772 and libraries.\n"), stdout
);
3773 fputs (_(" -B <directory> Add <directory> to the compiler's search paths.\n"), stdout
);
3774 fputs (_(" -v Display the programs invoked by the compiler.\n"), stdout
);
3775 fputs (_(" -### Like -v but options quoted and commands not executed.\n"), stdout
);
3776 fputs (_(" -E Preprocess only; do not compile, assemble or link.\n"), stdout
);
3777 fputs (_(" -S Compile only; do not assemble or link.\n"), stdout
);
3778 fputs (_(" -c Compile and assemble, but do not link.\n"), stdout
);
3779 fputs (_(" -o <file> Place the output into <file>.\n"), stdout
);
3780 fputs (_(" -pie Create a dynamically linked position independent\n\
3781 executable.\n"), stdout
);
3782 fputs (_(" -shared Create a shared library.\n"), stdout
);
3784 -x <language> Specify the language of the following input files.\n\
3785 Permissible languages include: c c++ assembler none\n\
3786 'none' means revert to the default behavior of\n\
3787 guessing the language based on the file's extension.\n\
3791 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3792 passed on to the various sub-processes invoked by %s. In order to pass\n\
3793 other options on to these processes the -W<letter> options must be used.\n\
3796 /* The rest of the options are displayed by invocations of the various
3801 add_preprocessor_option (const char *option
, int len
)
3803 preprocessor_options
.safe_push (save_string (option
, len
));
3807 add_assembler_option (const char *option
, int len
)
3809 assembler_options
.safe_push (save_string (option
, len
));
3813 add_linker_option (const char *option
, int len
)
3815 linker_options
.safe_push (save_string (option
, len
));
3818 /* Allocate space for an input file in infiles. */
3823 if (n_infiles_alloc
== 0)
3825 n_infiles_alloc
= 16;
3826 infiles
= XNEWVEC (struct infile
, n_infiles_alloc
);
3828 else if (n_infiles_alloc
== n_infiles
)
3830 n_infiles_alloc
*= 2;
3831 infiles
= XRESIZEVEC (struct infile
, infiles
, n_infiles_alloc
);
3835 /* Store an input file with the given NAME and LANGUAGE in
3839 add_infile (const char *name
, const char *language
)
3842 infiles
[n_infiles
].name
= name
;
3843 infiles
[n_infiles
++].language
= language
;
3846 /* Allocate space for a switch in switches. */
3851 if (n_switches_alloc
== 0)
3853 n_switches_alloc
= 16;
3854 switches
= XNEWVEC (struct switchstr
, n_switches_alloc
);
3856 else if (n_switches_alloc
== n_switches
)
3858 n_switches_alloc
*= 2;
3859 switches
= XRESIZEVEC (struct switchstr
, switches
, n_switches_alloc
);
3863 /* Save an option OPT with N_ARGS arguments in array ARGS, marking it
3864 as validated if VALIDATED and KNOWN if it is an internal switch. */
3867 save_switch (const char *opt
, size_t n_args
, const char *const *args
,
3868 bool validated
, bool known
)
3871 switches
[n_switches
].part1
= opt
+ 1;
3873 switches
[n_switches
].args
= 0;
3876 switches
[n_switches
].args
= XNEWVEC (const char *, n_args
+ 1);
3877 memcpy (switches
[n_switches
].args
, args
, n_args
* sizeof (const char *));
3878 switches
[n_switches
].args
[n_args
] = NULL
;
3881 switches
[n_switches
].live_cond
= 0;
3882 switches
[n_switches
].validated
= validated
;
3883 switches
[n_switches
].known
= known
;
3884 switches
[n_switches
].ordering
= 0;
3888 /* Set the SOURCE_DATE_EPOCH environment variable to the current time if it is
3892 set_source_date_epoch_envvar ()
3894 /* Array size is 21 = ceil(log_10(2^64)) + 1 to hold string representations
3895 of 64 bit integers. */
3896 char source_date_epoch
[21];
3901 if (tt
< (time_t) 0 || errno
!= 0)
3904 snprintf (source_date_epoch
, 21, "%llu", (unsigned long long) tt
);
3905 /* Using setenv instead of xputenv because we want the variable to remain
3906 after finalizing so that it's still set in the second run when using
3908 setenv ("SOURCE_DATE_EPOCH", source_date_epoch
, 0);
3911 /* Handle an option DECODED that is unknown to the option-processing
3915 driver_unknown_option_callback (const struct cl_decoded_option
*decoded
)
3917 const char *opt
= decoded
->arg
;
3918 if (opt
[1] == 'W' && opt
[2] == 'n' && opt
[3] == 'o' && opt
[4] == '-'
3919 && !(decoded
->errors
& CL_ERR_NEGATIVE
))
3921 /* Leave unknown -Wno-* options for the compiler proper, to be
3922 diagnosed only if there are warnings. */
3923 save_switch (decoded
->canonical_option
[0],
3924 decoded
->canonical_option_num_elements
- 1,
3925 &decoded
->canonical_option
[1], false, true);
3928 if (decoded
->opt_index
== OPT_SPECIAL_unknown
)
3930 /* Give it a chance to define it a spec file. */
3931 save_switch (decoded
->canonical_option
[0],
3932 decoded
->canonical_option_num_elements
- 1,
3933 &decoded
->canonical_option
[1], false, false);
3940 /* Handle an option DECODED that is not marked as CL_DRIVER.
3941 LANG_MASK will always be CL_DRIVER. */
3944 driver_wrong_lang_callback (const struct cl_decoded_option
*decoded
,
3945 unsigned int lang_mask ATTRIBUTE_UNUSED
)
3947 /* At this point, non-driver options are accepted (and expected to
3948 be passed down by specs) unless marked to be rejected by the
3949 driver. Options to be rejected by the driver but accepted by the
3950 compilers proper are treated just like completely unknown
3952 const struct cl_option
*option
= &cl_options
[decoded
->opt_index
];
3954 if (option
->cl_reject_driver
)
3955 error ("unrecognized command-line option %qs",
3956 decoded
->orig_option_with_args_text
);
3958 save_switch (decoded
->canonical_option
[0],
3959 decoded
->canonical_option_num_elements
- 1,
3960 &decoded
->canonical_option
[1], false, true);
3963 static const char *spec_lang
= 0;
3964 static int last_language_n_infiles
;
3967 /* Check that GCC is configured to support the offload target. */
3970 check_offload_target_name (const char *target
, ptrdiff_t len
)
3972 const char *n
, *c
= OFFLOAD_TARGETS
;
3975 n
= strchr (c
, ',');
3977 n
= strchr (c
, '\0');
3978 if (len
== n
- c
&& strncmp (target
, c
, n
- c
) == 0)
3980 c
= *n
? n
+ 1 : NULL
;
3984 auto_vec
<const char*> candidates
;
3985 size_t olen
= strlen (OFFLOAD_TARGETS
) + 1;
3986 char *cand
= XALLOCAVEC (char, olen
);
3987 memcpy (cand
, OFFLOAD_TARGETS
, olen
);
3988 for (c
= strtok (cand
, ","); c
; c
= strtok (NULL
, ","))
3989 candidates
.safe_push (c
);
3990 candidates
.safe_push ("default");
3991 candidates
.safe_push ("disable");
3993 char *target2
= XALLOCAVEC (char, len
+ 1);
3994 memcpy (target2
, target
, len
);
3995 target2
[len
] = '\0';
3997 error ("GCC is not configured to support %qs as %<-foffload=%> argument",
4001 const char *hint
= candidates_list_and_hint (target2
, s
, candidates
);
4003 inform (UNKNOWN_LOCATION
,
4004 "valid %<-foffload=%> arguments are: %s; "
4005 "did you mean %qs?", s
, hint
);
4007 inform (UNKNOWN_LOCATION
, "valid %<-foffload=%> arguments are: %s", s
);
4014 /* Sanity check for -foffload-options. */
4017 check_foffload_target_names (const char *arg
)
4019 const char *cur
, *next
, *end
;
4020 /* If option argument starts with '-' then no target is specified and we
4021 do not need to parse it. */
4024 end
= strchr (arg
, '=');
4027 error ("%<=%>options missing after %<-foffload-options=%>target");
4034 next
= strchr (cur
, ',');
4037 next
= (next
> end
) ? end
: next
;
4039 /* Retain non-supported targets after printing an error as those will not
4040 be processed; each enabled target only processes its triplet. */
4041 check_offload_target_name (cur
, next
- cur
);
4046 /* Parse -foffload option argument. */
4049 handle_foffload_option (const char *arg
)
4051 const char *c
, *cur
, *n
, *next
, *end
;
4054 /* If option argument starts with '-' then no target is specified and we
4055 do not need to parse it. */
4059 end
= strchr (arg
, '=');
4061 end
= strchr (arg
, '\0');
4066 next
= strchr (cur
, ',');
4069 next
= (next
> end
) ? end
: next
;
4071 target
= XNEWVEC (char, next
- cur
+ 1);
4072 memcpy (target
, cur
, next
- cur
);
4073 target
[next
- cur
] = '\0';
4075 /* Reset offloading list and continue. */
4076 if (strcmp (target
, "default") == 0)
4078 free (offload_targets
);
4079 offload_targets
= NULL
;
4083 /* If 'disable' is passed to the option, clean the list of
4084 offload targets and return, even if more targets follow.
4085 Likewise if GCC is not configured to support that offload target. */
4086 if (strcmp (target
, "disable") == 0
4087 || !check_offload_target_name (target
, next
- cur
))
4089 free (offload_targets
);
4090 offload_targets
= xstrdup ("");
4094 if (!offload_targets
)
4096 offload_targets
= target
;
4101 /* Check that the target hasn't already presented in the list. */
4102 c
= offload_targets
;
4105 n
= strchr (c
, ':');
4107 n
= strchr (c
, '\0');
4109 if (next
- cur
== n
- c
&& strncmp (c
, target
, n
- c
) == 0)
4116 /* If duplicate is not found, append the target to the list. */
4119 size_t offload_targets_len
= strlen (offload_targets
);
4121 = XRESIZEVEC (char, offload_targets
,
4122 offload_targets_len
+ 1 + next
- cur
+ 1);
4123 offload_targets
[offload_targets_len
++] = ':';
4124 memcpy (offload_targets
+ offload_targets_len
, target
, next
- cur
+ 1);
4129 XDELETEVEC (target
);
4133 /* Forward certain options to offloading compilation. */
4136 forward_offload_option (size_t opt_index
, const char *arg
, bool validated
)
4141 /* Use a '_GCC_' prefix and standard name ('-l_GCC_m' irrespective of the
4142 host's 'MATH_LIBRARY', for example), so that the 'mkoffload's can tell
4143 this has been synthesized here, and translate/drop as necessary. */
4144 /* Note that certain libraries ('-lc', '-lgcc', '-lgomp', for example)
4145 are injected by default in offloading compilation, and therefore not
4147 /* GCC libraries. */
4148 if (/* '-lgfortran' */ strcmp (arg
, "gfortran") == 0 )
4149 save_switch (concat ("-foffload-options=-l_GCC_", arg
, NULL
),
4150 0, NULL
, validated
, true);
4151 /* Other libraries. */
4154 /* The case will need special consideration where on the host
4155 '!need_math', but for offloading compilation still need
4156 '-foffload-options=-l_GCC_m'. The problem is that we don't get
4157 here anything like '-lm', because it's not synthesized in
4158 'gcc/fortran/gfortranspec.cc:lang_specific_driver', for example.
4159 Generally synthesizing '-foffload-options=-l_GCC_m' etc. in the
4160 language specific drivers is non-trivial, needs very careful
4161 review of their options handling. However, this issue is not
4162 actually relevant for the current set of supported host/offloading
4164 int need_math
= (MATH_LIBRARY
[0] != '\0');
4165 if (/* '-lm' */ (need_math
&& strcmp (arg
, MATH_LIBRARY
) == 0))
4166 save_switch ("-foffload-options=-l_GCC_m",
4167 0, NULL
, validated
, true);
4175 /* Handle a driver option; arguments and return value as for
4179 driver_handle_option (struct gcc_options
*opts
,
4180 struct gcc_options
*opts_set
,
4181 const struct cl_decoded_option
*decoded
,
4182 unsigned int lang_mask ATTRIBUTE_UNUSED
, int kind
,
4184 const struct cl_option_handlers
*handlers ATTRIBUTE_UNUSED
,
4185 diagnostic_context
*dc
,
4188 size_t opt_index
= decoded
->opt_index
;
4189 const char *arg
= decoded
->arg
;
4190 const char *compare_debug_replacement_opt
;
4191 int value
= decoded
->value
;
4192 bool validated
= false;
4193 bool do_save
= true;
4195 gcc_assert (opts
== &global_options
);
4196 gcc_assert (opts_set
== &global_options_set
);
4197 gcc_assert (kind
== DK_UNSPECIFIED
);
4198 gcc_assert (loc
== UNKNOWN_LOCATION
);
4199 gcc_assert (dc
== global_dc
);
4205 struct spec_list
*sl
;
4207 for (sl
= specs
; sl
; sl
= sl
->next
)
4208 printf ("*%s:\n%s\n\n", sl
->name
, *(sl
->ptr_spec
));
4209 if (link_command_spec
)
4210 printf ("*link_command:\n%s\n\n", link_command_spec
);
4214 case OPT_dumpversion
:
4215 printf ("%s\n", spec_version
);
4218 case OPT_dumpmachine
:
4219 printf ("%s\n", spec_machine
);
4222 case OPT_dumpfullversion
:
4223 printf ("%s\n", BASEVER
);
4229 /* CPP driver cannot obtain switch from cc1_options. */
4231 add_preprocessor_option ("--version", strlen ("--version"));
4232 add_assembler_option ("--version", strlen ("--version"));
4233 add_linker_option ("--version", strlen ("--version"));
4236 case OPT__completion_
:
4238 completion
= decoded
->arg
;
4242 print_help_list
= 1;
4244 /* CPP driver cannot obtain switch from cc1_options. */
4246 add_preprocessor_option ("--help", 6);
4247 add_assembler_option ("--help", 6);
4248 add_linker_option ("--help", 6);
4252 print_subprocess_help
= 2;
4255 case OPT__target_help
:
4256 print_subprocess_help
= 1;
4258 /* CPP driver cannot obtain switch from cc1_options. */
4260 add_preprocessor_option ("--target-help", 13);
4261 add_assembler_option ("--target-help", 13);
4262 add_linker_option ("--target-help", 13);
4265 case OPT__no_sysroot_suffix
:
4266 case OPT_pass_exit_codes
:
4267 case OPT_print_search_dirs
:
4268 case OPT_print_file_name_
:
4269 case OPT_print_prog_name_
:
4270 case OPT_print_multi_lib
:
4271 case OPT_print_multi_directory
:
4272 case OPT_print_sysroot
:
4273 case OPT_print_multi_os_directory
:
4274 case OPT_print_multiarch
:
4275 case OPT_print_sysroot_headers_suffix
:
4278 /* These options set the variables specified in common.opt
4279 automatically, and do not need to be saved for spec
4284 case OPT_print_libgcc_file_name
:
4285 print_file_name
= "libgcc.a";
4289 case OPT_fuse_ld_bfd
:
4293 case OPT_fuse_ld_gold
:
4297 case OPT_fuse_ld_mold
:
4301 case OPT_fcompare_debug_second
:
4302 compare_debug_second
= 1;
4305 case OPT_fcompare_debug
:
4309 compare_debug_replacement_opt
= "-fcompare-debug=";
4311 goto compare_debug_with_arg
;
4314 compare_debug_replacement_opt
= "-fcompare-debug=-gtoggle";
4316 goto compare_debug_with_arg
;
4323 case OPT_fcompare_debug_
:
4324 compare_debug_replacement_opt
= decoded
->canonical_option
[0];
4325 compare_debug_with_arg
:
4326 gcc_assert (decoded
->canonical_option_num_elements
== 1);
4327 gcc_assert (arg
!= NULL
);
4332 if (compare_debug
< 0)
4333 compare_debug_opt
= NULL
;
4335 compare_debug_opt
= arg
;
4336 save_switch (compare_debug_replacement_opt
, 0, NULL
, validated
, true);
4337 set_source_date_epoch_envvar ();
4340 case OPT_fdiagnostics_color_
:
4341 diagnostic_color_init (dc
, value
);
4344 case OPT_fdiagnostics_urls_
:
4345 diagnostic_urls_init (dc
, value
);
4348 case OPT_fdiagnostics_format_
:
4350 const char *basename
= (opts
->x_dump_base_name
? opts
->x_dump_base_name
4351 : opts
->x_main_input_basename
);
4352 diagnostic_output_format_init (dc
, basename
,
4353 (enum diagnostics_output_format
)value
);
4357 case OPT_fdiagnostics_text_art_charset_
:
4358 dc
->set_text_art_charset ((enum diagnostic_text_art_charset
)value
);
4364 /* Pass the rest of this option to the assembler. */
4366 /* Split the argument at commas. */
4368 for (j
= 0; arg
[j
]; j
++)
4371 add_assembler_option (arg
+ prev
, j
- prev
);
4375 /* Record the part after the last comma. */
4376 add_assembler_option (arg
+ prev
, j
- prev
);
4384 /* Pass the rest of this option to the preprocessor. */
4386 /* Split the argument at commas. */
4388 for (j
= 0; arg
[j
]; j
++)
4391 add_preprocessor_option (arg
+ prev
, j
- prev
);
4395 /* Record the part after the last comma. */
4396 add_preprocessor_option (arg
+ prev
, j
- prev
);
4404 /* Split the argument at commas. */
4406 for (j
= 0; arg
[j
]; j
++)
4409 add_infile (save_string (arg
+ prev
, j
- prev
), "*");
4412 /* Record the part after the last comma. */
4413 add_infile (arg
+ prev
, "*");
4419 add_infile (arg
, "*");
4423 case OPT_Xpreprocessor
:
4424 add_preprocessor_option (arg
, strlen (arg
));
4428 case OPT_Xassembler
:
4429 add_assembler_option (arg
, strlen (arg
));
4434 /* POSIX allows separation of -l and the lib arg; canonicalize
4435 by concatenating -l with its arg */
4436 add_infile (concat ("-l", arg
, NULL
), "*");
4438 /* Forward to offloading compilation '-l[...]' flags for standard,
4439 well-known libraries. */
4440 /* Doing this processing here means that we don't get to see libraries
4441 injected via specs, such as '-lquadmath' injected via
4442 '[build]/[target]/libgfortran/libgfortran.spec'. However, this issue
4443 is not actually relevant for the current set of host/offloading
4445 if (ENABLE_OFFLOADING
)
4446 forward_offload_option (opt_index
, arg
, validated
);
4452 /* Similarly, canonicalize -L for linkers that may not accept
4453 separate arguments. */
4454 save_switch (concat ("-L", arg
, NULL
), 0, NULL
, validated
, true);
4459 save_switch (concat ("-F", arg
, NULL
), 0, NULL
, validated
, true);
4462 case OPT_save_temps
:
4463 if (!save_temps_flag
)
4464 save_temps_flag
= SAVE_TEMPS_DUMP
;
4468 case OPT_save_temps_
:
4469 if (strcmp (arg
, "cwd") == 0)
4470 save_temps_flag
= SAVE_TEMPS_CWD
;
4471 else if (strcmp (arg
, "obj") == 0
4472 || strcmp (arg
, "object") == 0)
4473 save_temps_flag
= SAVE_TEMPS_OBJ
;
4475 fatal_error (input_location
, "%qs is an unknown %<-save-temps%> option",
4476 decoded
->orig_option_with_args_text
);
4477 save_temps_overrides_dumpdir
= true;
4482 dumpdir
= xstrdup (arg
);
4483 save_temps_overrides_dumpdir
= false;
4488 dumpbase
= xstrdup (arg
);
4491 case OPT_dumpbase_ext
:
4492 free (dumpbase_ext
);
4493 dumpbase_ext
= xstrdup (arg
);
4496 case OPT_no_canonical_prefixes
:
4497 /* Already handled as a special case, so ignored here. */
4503 /* These options set the variables specified in common.opt
4504 automatically, but do need to be saved for spec
4510 struct user_specs
*user
= XNEW (struct user_specs
);
4512 user
->next
= (struct user_specs
*) 0;
4513 user
->filename
= arg
;
4514 if (user_specs_tail
)
4515 user_specs_tail
->next
= user
;
4517 user_specs_head
= user
;
4518 user_specs_tail
= user
;
4524 target_system_root
= arg
;
4525 target_system_root_changed
= 1;
4526 /* Saving this option is useful to let self-specs decide to
4527 provide a default one. */
4533 if (report_times_to_file
)
4534 fclose (report_times_to_file
);
4535 report_times_to_file
= fopen (arg
, "a");
4541 This is similar to -v except that there is no execution
4542 of the commands and the echoed arguments are quoted. It
4543 is intended for use in shell scripts to capture the
4544 driver-generated command line. */
4545 verbose_only_flag
++;
4552 size_t len
= strlen (arg
);
4554 /* Catch the case where the user has forgotten to append a
4555 directory separator to the path. Note, they may be using
4556 -B to add an executable name prefix, eg "i386-elf-", in
4557 order to distinguish between multiple installations of
4558 GCC in the same directory. Hence we must check to see
4559 if appending a directory separator actually makes a
4560 valid directory name. */
4561 if (!IS_DIR_SEPARATOR (arg
[len
- 1])
4562 && is_directory (arg
, false))
4564 char *tmp
= XNEWVEC (char, len
+ 2);
4566 tmp
[len
] = DIR_SEPARATOR
;
4571 add_prefix (&exec_prefixes
, arg
, NULL
,
4572 PREFIX_PRIORITY_B_OPT
, 0, 0);
4573 add_prefix (&startfile_prefixes
, arg
, NULL
,
4574 PREFIX_PRIORITY_B_OPT
, 0, 0);
4575 add_prefix (&include_prefixes
, arg
, NULL
,
4576 PREFIX_PRIORITY_B_OPT
, 0, 0);
4587 if (!strcmp (spec_lang
, "none"))
4588 /* Suppress the warning if -xnone comes after the last input
4589 file, because alternate command interfaces like g++ might
4590 find it useful to place -xnone after each input file. */
4593 last_language_n_infiles
= n_infiles
;
4599 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
4600 arg
= convert_filename (arg
, ! have_c
, 0);
4603 /* On some systems, ld cannot handle "-o" without a space. So
4604 split the option from its argument. */
4605 save_switch ("-o", 1, &arg
, validated
, true);
4608 #ifdef ENABLE_DEFAULT_PIE
4610 /* -pie is turned on by default. */
4613 case OPT_static_libgcc
:
4614 case OPT_shared_libgcc
:
4615 case OPT_static_libgfortran
:
4616 case OPT_static_libquadmath
:
4617 case OPT_static_libphobos
:
4618 case OPT_static_libgm2
:
4619 case OPT_static_libstdc__
:
4620 /* These are always valid; gcc.cc itself understands the first two
4621 gfortranspec.cc understands -static-libgfortran,
4622 libgfortran.spec handles -static-libquadmath,
4623 d-spec.cc understands -static-libphobos,
4624 gm2spec.cc understands -static-libgm2,
4625 and g++spec.cc understands -static-libstdc++. */
4633 case OPT_foffload_options_
:
4634 check_foffload_target_names (arg
);
4638 handle_foffload_option (arg
);
4639 if (arg
[0] == '-' || NULL
!= strchr (arg
, '='))
4640 save_switch (concat ("-foffload-options=", arg
, NULL
),
4641 0, NULL
, validated
, true);
4646 add_infile ("--pdb=", "*");
4650 /* Various driver options need no special processing at this
4651 point, having been handled in a prescan above or being
4652 handled by specs. */
4657 save_switch (decoded
->canonical_option
[0],
4658 decoded
->canonical_option_num_elements
- 1,
4659 &decoded
->canonical_option
[1], validated
, true);
4663 /* Return true if F2 is F1 followed by a single suffix, i.e., by a
4664 period and additional characters other than a period. */
4667 adds_single_suffix_p (const char *f2
, const char *f1
)
4669 size_t len
= strlen (f1
);
4671 return (strncmp (f1
, f2
, len
) == 0
4673 && strchr (f2
+ len
+ 1, '.') == NULL
);
4676 /* Put the driver's standard set of option handlers in *HANDLERS. */
4679 set_option_handlers (struct cl_option_handlers
*handlers
)
4681 handlers
->unknown_option_callback
= driver_unknown_option_callback
;
4682 handlers
->wrong_lang_callback
= driver_wrong_lang_callback
;
4683 handlers
->num_handlers
= 3;
4684 handlers
->handlers
[0].handler
= driver_handle_option
;
4685 handlers
->handlers
[0].mask
= CL_DRIVER
;
4686 handlers
->handlers
[1].handler
= common_handle_option
;
4687 handlers
->handlers
[1].mask
= CL_COMMON
;
4688 handlers
->handlers
[2].handler
= target_handle_option
;
4689 handlers
->handlers
[2].mask
= CL_TARGET
;
4693 /* Return the index into infiles for the single non-library
4694 non-lto-wpa input file, -1 if there isn't any, or -2 if there is
4697 single_input_file_index ()
4701 for (int i
= 0; i
< n_infiles
; i
++)
4703 if (infiles
[i
].language
4704 && (infiles
[i
].language
[0] == '*'
4706 && strcmp (infiles
[i
].language
, "lto") == 0)))
4718 /* Create the vector `switches' and its contents.
4719 Store its length in `n_switches'. */
4722 process_command (unsigned int decoded_options_count
,
4723 struct cl_decoded_option
*decoded_options
)
4727 char *tooldir_prefix
, *tooldir_prefix2
;
4728 char *(*get_relative_prefix
) (const char *, const char *,
4729 const char *) = NULL
;
4730 struct cl_option_handlers handlers
;
4733 gcc_exec_prefix
= env
.get ("GCC_EXEC_PREFIX");
4737 added_libraries
= 0;
4739 /* Figure compiler version from version string. */
4741 compiler_version
= temp1
= xstrdup (version_string
);
4743 for (; *temp1
; ++temp1
)
4752 /* Handle any -no-canonical-prefixes flag early, to assign the function
4753 that builds relative prefixes. This function creates default search
4754 paths that are needed later in normal option handling. */
4756 for (j
= 1; j
< decoded_options_count
; j
++)
4758 if (decoded_options
[j
].opt_index
== OPT_no_canonical_prefixes
)
4760 get_relative_prefix
= make_relative_prefix_ignore_links
;
4764 if (! get_relative_prefix
)
4765 get_relative_prefix
= make_relative_prefix
;
4767 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
4768 see if we can create it from the pathname specified in
4769 decoded_options[0].arg. */
4771 gcc_libexec_prefix
= standard_libexec_prefix
;
4773 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
4774 if (!gcc_exec_prefix
)
4776 gcc_exec_prefix
= get_relative_prefix (decoded_options
[0].arg
,
4777 standard_bindir_prefix
,
4778 standard_exec_prefix
);
4779 gcc_libexec_prefix
= get_relative_prefix (decoded_options
[0].arg
,
4780 standard_bindir_prefix
,
4781 standard_libexec_prefix
);
4782 if (gcc_exec_prefix
)
4783 xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix
, NULL
));
4787 /* make_relative_prefix requires a program name, but
4788 GCC_EXEC_PREFIX is typically a directory name with a trailing
4789 / (which is ignored by make_relative_prefix), so append a
4791 char *tmp_prefix
= concat (gcc_exec_prefix
, "gcc", NULL
);
4792 gcc_libexec_prefix
= get_relative_prefix (tmp_prefix
,
4793 standard_exec_prefix
,
4794 standard_libexec_prefix
);
4796 /* The path is unrelocated, so fallback to the original setting. */
4797 if (!gcc_libexec_prefix
)
4798 gcc_libexec_prefix
= standard_libexec_prefix
;
4804 /* From this point onward, gcc_exec_prefix is non-null if the toolchain
4805 is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
4806 or an automatically created GCC_EXEC_PREFIX from
4807 decoded_options[0].arg. */
4809 /* Do language-specific adjustment/addition of flags. */
4810 lang_specific_driver (&decoded_options
, &decoded_options_count
,
4813 if (gcc_exec_prefix
)
4815 int len
= strlen (gcc_exec_prefix
);
4817 if (len
> (int) sizeof ("/lib/gcc/") - 1
4818 && (IS_DIR_SEPARATOR (gcc_exec_prefix
[len
-1])))
4820 temp
= gcc_exec_prefix
+ len
- sizeof ("/lib/gcc/") + 1;
4821 if (IS_DIR_SEPARATOR (*temp
)
4822 && filename_ncmp (temp
+ 1, "lib", 3) == 0
4823 && IS_DIR_SEPARATOR (temp
[4])
4824 && filename_ncmp (temp
+ 5, "gcc", 3) == 0)
4825 len
-= sizeof ("/lib/gcc/") - 1;
4828 set_std_prefix (gcc_exec_prefix
, len
);
4829 add_prefix (&exec_prefixes
, gcc_libexec_prefix
, "GCC",
4830 PREFIX_PRIORITY_LAST
, 0, 0);
4831 add_prefix (&startfile_prefixes
, gcc_exec_prefix
, "GCC",
4832 PREFIX_PRIORITY_LAST
, 0, 0);
4835 /* COMPILER_PATH and LIBRARY_PATH have values
4836 that are lists of directory names with colons. */
4838 temp
= env
.get ("COMPILER_PATH");
4841 const char *startp
, *endp
;
4842 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4844 startp
= endp
= temp
;
4847 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4849 strncpy (nstore
, startp
, endp
- startp
);
4851 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4852 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4854 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4855 nstore
[endp
- startp
+ 1] = 0;
4858 nstore
[endp
- startp
] = 0;
4859 add_prefix (&exec_prefixes
, nstore
, 0,
4860 PREFIX_PRIORITY_LAST
, 0, 0);
4861 add_prefix (&include_prefixes
, nstore
, 0,
4862 PREFIX_PRIORITY_LAST
, 0, 0);
4865 endp
= startp
= endp
+ 1;
4872 temp
= env
.get (LIBRARY_PATH_ENV
);
4873 if (temp
&& *cross_compile
== '0')
4875 const char *startp
, *endp
;
4876 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4878 startp
= endp
= temp
;
4881 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4883 strncpy (nstore
, startp
, endp
- startp
);
4885 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4886 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4888 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4889 nstore
[endp
- startp
+ 1] = 0;
4892 nstore
[endp
- startp
] = 0;
4893 add_prefix (&startfile_prefixes
, nstore
, NULL
,
4894 PREFIX_PRIORITY_LAST
, 0, 1);
4897 endp
= startp
= endp
+ 1;
4904 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
4905 temp
= env
.get ("LPATH");
4906 if (temp
&& *cross_compile
== '0')
4908 const char *startp
, *endp
;
4909 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4911 startp
= endp
= temp
;
4914 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4916 strncpy (nstore
, startp
, endp
- startp
);
4918 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4919 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4921 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4922 nstore
[endp
- startp
+ 1] = 0;
4925 nstore
[endp
- startp
] = 0;
4926 add_prefix (&startfile_prefixes
, nstore
, NULL
,
4927 PREFIX_PRIORITY_LAST
, 0, 1);
4930 endp
= startp
= endp
+ 1;
4937 /* Process the options and store input files and switches in their
4940 last_language_n_infiles
= -1;
4942 set_option_handlers (&handlers
);
4944 for (j
= 1; j
< decoded_options_count
; j
++)
4946 switch (decoded_options
[j
].opt_index
)
4958 for (j
= 1; j
< decoded_options_count
; j
++)
4960 if (decoded_options
[j
].opt_index
== OPT_SPECIAL_input_file
)
4962 const char *arg
= decoded_options
[j
].arg
;
4964 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4965 arg
= convert_filename (arg
, 0, access (arg
, F_OK
));
4967 add_infile (arg
, spec_lang
);
4972 read_cmdline_option (&global_options
, &global_options_set
,
4973 decoded_options
+ j
, UNKNOWN_LOCATION
,
4974 CL_DRIVER
, &handlers
, global_dc
);
4977 /* If the user didn't specify any, default to all configured offload
4979 if (ENABLE_OFFLOADING
&& offload_targets
== NULL
)
4981 handle_foffload_option (OFFLOAD_TARGETS
);
4982 #if OFFLOAD_DEFAULTED
4983 offload_targets_default
= true;
4987 /* Handle -gtoggle as it would later in toplev.cc:process_options to
4988 make the debug-level-gt spec function work as expected. */
4991 if (debug_info_level
== DINFO_LEVEL_NONE
)
4992 debug_info_level
= DINFO_LEVEL_NORMAL
;
4994 debug_info_level
= DINFO_LEVEL_NONE
;
4998 && strcmp (output_file
, "-") != 0
4999 && strcmp (output_file
, HOST_BIT_BUCKET
) != 0)
5002 for (i
= 0; i
< n_infiles
; i
++)
5003 if ((!infiles
[i
].language
|| infiles
[i
].language
[0] != '*')
5004 && canonical_filename_eq (infiles
[i
].name
, output_file
))
5005 fatal_error (input_location
,
5006 "input file %qs is the same as output file",
5010 if (output_file
!= NULL
&& output_file
[0] == '\0')
5011 fatal_error (input_location
, "output filename may not be empty");
5013 /* -dumpdir and -save-temps=* both specify the location of aux/dump
5014 outputs; the one that appears last prevails. When compiling
5015 multiple sources, an explicit dumpbase (minus -ext) may be
5016 combined with an explicit or implicit dumpdir, whereas when
5017 linking, a specified or implied link output name (minus
5018 extension) may be combined with a prevailing -save-temps=* or an
5019 otherwise implied dumpdir, but not override a prevailing
5020 -dumpdir. Primary outputs (e.g., linker output when linking
5021 without -o, or .i, .s or .o outputs when processing multiple
5022 inputs with -E, -S or -c, respectively) are NOT affected by these
5023 -save-temps=/-dump* options, always landing in the current
5024 directory and with the same basename as the input when an output
5025 name is not given, but when they're intermediate outputs, they
5026 are named like other aux outputs, so the options affect their
5029 Here are some examples. There are several more in the
5030 documentation of -o and -dump*, and some quite exhaustive tests
5031 in gcc.misc-tests/outputs.exp.
5033 When compiling any number of sources, no -dump* nor
5034 -save-temps=*, all outputs in cwd without prefix:
5036 # gcc -c b.c -gsplit-dwarf
5037 -> cc1 [-dumpdir ./] -dumpbase b.c -dumpbase-ext .c # b.o b.dwo
5039 # gcc -c b.c d.c -gsplit-dwarf
5040 -> cc1 [-dumpdir ./] -dumpbase b.c -dumpbase-ext .c # b.o b.dwo
5041 && cc1 [-dumpdir ./] -dumpbase d.c -dumpbase-ext .c # d.o d.dwo
5043 When compiling and linking, no -dump* nor -save-temps=*, .o
5044 outputs are temporary, aux outputs land in the dir of the output,
5045 prefixed with the basename of the linker output:
5047 # gcc b.c d.c -o ab -gsplit-dwarf
5048 -> cc1 -dumpdir ab- -dumpbase b.c -dumpbase-ext .c # ab-b.dwo
5049 && cc1 -dumpdir ab- -dumpbase d.c -dumpbase-ext .c # ab-d.dwo
5052 # gcc b.c d.c [-o a.out] -gsplit-dwarf
5053 -> cc1 -dumpdir a- -dumpbase b.c -dumpbase-ext .c # a-b.dwo
5054 && cc1 -dumpdir a- -dumpbase d.c -dumpbase-ext .c # a-d.dwo
5055 && link ... [-o a.out]
5057 When compiling and linking, a prevailing -dumpdir fully overrides
5058 the prefix of aux outputs given by the output name:
5060 # gcc -dumpdir f b.c d.c -gsplit-dwarf [-o [dir/]whatever]
5061 -> cc1 -dumpdir f -dumpbase b.c -dumpbase-ext .c # fb.dwo
5062 && cc1 -dumpdir f -dumpbase d.c -dumpbase-ext .c # fd.dwo
5063 && link ... [-o whatever]
5065 When compiling multiple inputs, an explicit -dumpbase is combined
5066 with -dumpdir, affecting aux outputs, but not the .o outputs:
5068 # gcc -dumpdir f -dumpbase g- b.c d.c -gsplit-dwarf -c
5069 -> cc1 -dumpdir fg- -dumpbase b.c -dumpbase-ext .c # b.o fg-b.dwo
5070 && cc1 -dumpdir fg- -dumpbase d.c -dumpbase-ext .c # d.o fg-d.dwo
5072 When compiling and linking with -save-temps, the .o outputs that
5073 would have been temporary become aux outputs, so they get
5074 affected by -dump* flags:
5076 # gcc -dumpdir f -dumpbase g- -save-temps b.c d.c
5077 -> cc1 -dumpdir fg- -dumpbase b.c -dumpbase-ext .c # fg-b.o
5078 && cc1 -dumpdir fg- -dumpbase d.c -dumpbase-ext .c # fg-d.o
5081 If -save-temps=* prevails over -dumpdir, however, the explicit
5082 -dumpdir is discarded, as if it wasn't there. The basename of
5083 the implicit linker output, a.out or a.exe, becomes a- as the aux
5084 output prefix for all compilations:
5086 # gcc [-dumpdir f] -save-temps=cwd b.c d.c
5087 -> cc1 -dumpdir a- -dumpbase b.c -dumpbase-ext .c # a-b.o
5088 && cc1 -dumpdir a- -dumpbase d.c -dumpbase-ext .c # a-d.o
5091 A single -dumpbase, applying to multiple inputs, overrides the
5092 linker output name, implied or explicit, as the aux output prefix:
5094 # gcc [-dumpdir f] -dumpbase g- -save-temps=cwd b.c d.c
5095 -> cc1 -dumpdir g- -dumpbase b.c -dumpbase-ext .c # g-b.o
5096 && cc1 -dumpdir g- -dumpbase d.c -dumpbase-ext .c # g-d.o
5099 # gcc [-dumpdir f] -dumpbase g- -save-temps=cwd b.c d.c -o dir/h.out
5100 -> cc1 -dumpdir g- -dumpbase b.c -dumpbase-ext .c # g-b.o
5101 && cc1 -dumpdir g- -dumpbase d.c -dumpbase-ext .c # g-d.o
5102 && link -o dir/h.out
5104 Now, if the linker output is NOT overridden as a prefix, but
5105 -save-temps=* overrides implicit or explicit -dumpdir, the
5106 effective dump dir combines the dir selected by the -save-temps=*
5107 option with the basename of the specified or implied link output:
5109 # gcc [-dumpdir f] -save-temps=cwd b.c d.c -o dir/h.out
5110 -> cc1 -dumpdir h- -dumpbase b.c -dumpbase-ext .c # h-b.o
5111 && cc1 -dumpdir h- -dumpbase d.c -dumpbase-ext .c # h-d.o
5112 && link -o dir/h.out
5114 # gcc [-dumpdir f] -save-temps=obj b.c d.c -o dir/h.out
5115 -> cc1 -dumpdir dir/h- -dumpbase b.c -dumpbase-ext .c # dir/h-b.o
5116 && cc1 -dumpdir dir/h- -dumpbase d.c -dumpbase-ext .c # dir/h-d.o
5117 && link -o dir/h.out
5119 But then again, a single -dumpbase applying to multiple inputs
5120 gets used instead of the linker output basename in the combined
5123 # gcc [-dumpdir f] -dumpbase g- -save-temps=obj b.c d.c -o dir/h.out
5124 -> cc1 -dumpdir dir/g- -dumpbase b.c -dumpbase-ext .c # dir/g-b.o
5125 && cc1 -dumpdir dir/g- -dumpbase d.c -dumpbase-ext .c # dir/g-d.o
5126 && link -o dir/h.out
5128 With a single input being compiled, the output basename does NOT
5129 affect the dumpdir prefix.
5131 # gcc -save-temps=obj b.c -gsplit-dwarf -c -o dir/b.o
5132 -> cc1 -dumpdir dir/ -dumpbase b.c -dumpbase-ext .c # dir/b.o dir/b.dwo
5134 but when compiling and linking even a single file, it does:
5136 # gcc -save-temps=obj b.c -o dir/h.out
5137 -> cc1 -dumpdir dir/h- -dumpbase b.c -dumpbase-ext .c # dir/h-b.o
5139 unless an explicit -dumpdir prevails:
5141 # gcc -save-temps[=obj] -dumpdir g- b.c -o dir/h.out
5142 -> cc1 -dumpdir g- -dumpbase b.c -dumpbase-ext .c # g-b.o
5146 bool explicit_dumpdir
= dumpdir
;
5148 if ((!save_temps_overrides_dumpdir
&& explicit_dumpdir
)
5149 || (output_file
&& not_actual_file_p (output_file
)))
5154 /* If -save-temps=obj and -o name, create the prefix to use for %b.
5155 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
5156 else if (save_temps_flag
!= SAVE_TEMPS_CWD
&& output_file
!= NULL
)
5160 temp
= lbasename (output_file
);
5161 if (temp
!= output_file
)
5162 dumpdir
= xstrndup (output_file
,
5163 strlen (output_file
) - strlen (temp
));
5171 if (save_temps_flag
)
5172 save_temps_flag
= SAVE_TEMPS_DUMP
;
5174 /* If there is any pathname component in an explicit -dumpbase, it
5175 overrides dumpdir entirely, so discard it right away. Although
5176 the presence of an explicit -dumpdir matters for the driver, it
5177 shouldn't matter for other processes, that get all that's needed
5178 from the -dumpdir and -dumpbase always passed to them. */
5179 if (dumpdir
&& dumpbase
&& lbasename (dumpbase
) != dumpbase
)
5185 /* Check that dumpbase_ext matches the end of dumpbase, drop it
5187 if (dumpbase_ext
&& dumpbase
&& *dumpbase
)
5189 int lendb
= strlen (dumpbase
);
5190 int lendbx
= strlen (dumpbase_ext
);
5192 /* -dumpbase-ext must be a suffix proper; discard it if it
5193 matches all of -dumpbase, as that would make for an empty
5196 || strcmp (dumpbase
+ lendb
- lendbx
, dumpbase_ext
) != 0)
5198 free (dumpbase_ext
);
5199 dumpbase_ext
= NULL
;
5203 /* -dumpbase with multiple sources goes into dumpdir. With a single
5204 source, it does only if linking and if dumpdir was not explicitly
5206 if (dumpbase
&& *dumpbase
5207 && (single_input_file_index () == -2
5208 || (!have_c
&& !explicit_dumpdir
)))
5213 /* We checked that they match above. */
5214 dumpbase
[strlen (dumpbase
) - strlen (dumpbase_ext
)] = '\0';
5217 prefix
= concat (dumpdir
, dumpbase
, "-", NULL
);
5219 prefix
= concat (dumpbase
, "-", NULL
);
5223 free (dumpbase_ext
);
5224 dumpbase
= dumpbase_ext
= NULL
;
5226 dumpdir_trailing_dash_added
= true;
5229 /* If dumpbase was not brought into dumpdir but we're linking, bring
5230 output_file into dumpdir unless dumpdir was explicitly specified.
5231 The test for !explicit_dumpdir is further below, because we want
5232 to use the obase computation for a ghost outbase, passed to
5233 GCC_COLLECT_OPTIONS. */
5234 else if (!have_c
&& (!explicit_dumpdir
|| (dumpbase
&& !*dumpbase
)))
5236 /* If we get here, we know dumpbase was not specified, or it was
5237 specified as an empty string. If it was anything else, it
5238 would have combined with dumpdir above, because the condition
5239 for dumpbase to be used when present is broader than the
5240 condition that gets us here. */
5241 gcc_assert (!dumpbase
|| !*dumpbase
);
5244 char *tofree
= NULL
;
5245 if (!output_file
|| not_actual_file_p (output_file
))
5249 obase
= lbasename (output_file
);
5250 size_t blen
= strlen (obase
), xlen
;
5251 /* Drop the suffix if it's dumpbase_ext, if given,
5252 otherwise .exe or the target executable suffix, or if the
5253 output was explicitly named a.out, but not otherwise. */
5255 ? (blen
> (xlen
= strlen (dumpbase_ext
))
5256 && strcmp ((temp
= (obase
+ blen
- xlen
)),
5258 : ((temp
= strrchr (obase
+ 1, '.'))
5259 && (xlen
= strlen (temp
))
5260 && (strcmp (temp
, ".exe") == 0
5261 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
5262 || strcmp (temp
, TARGET_EXECUTABLE_SUFFIX
) == 0
5264 || strcmp (obase
, "a.out") == 0)))
5266 tofree
= xstrndup (obase
, blen
- xlen
);
5271 /* We wish to save this basename to the -dumpdir passed through
5272 GCC_COLLECT_OPTIONS within maybe_run_linker, for e.g. LTO,
5273 but we do NOT wish to add it to e.g. %b, so we keep
5274 outbase_length as zero. */
5275 gcc_assert (!outbase
);
5278 /* If we're building [dir1/]foo[.exe] out of a single input
5279 [dir2/]foo.c that shares the same basename, dump to
5280 [dir2/]foo.c.* rather than duplicating the basename into
5281 [dir2/]foo-foo.c.*. */
5284 || ((idxin
= single_input_file_index ()) >= 0
5285 && adds_single_suffix_p (lbasename (infiles
[idxin
].name
),
5288 if (obase
== tofree
)
5292 outbase
= xstrdup (obase
);
5295 obase
= tofree
= NULL
;
5301 char *p
= concat (dumpdir
, obase
, "-", NULL
);
5306 dumpdir
= concat (obase
, "-", NULL
);
5308 dumpdir_trailing_dash_added
= true;
5311 obase
= tofree
= NULL
;
5314 if (!explicit_dumpdir
|| dumpbase
)
5316 /* Absent -dumpbase and present -dumpbase-ext have been applied
5317 to the linker output name, so compute fresh defaults for each
5319 free (dumpbase_ext
);
5320 dumpbase_ext
= NULL
;
5324 /* Now, if we're compiling, or if we haven't used the dumpbase
5325 above, then outbase (%B) is derived from dumpbase, if given, or
5326 from the output name, given or implied. We can't precompute
5327 implied output names, but that's ok, since they're derived from
5328 input names. Just make sure we skip this if dumpbase is the
5329 empty string: we want to use input names then, so don't set
5331 if ((dumpbase
|| have_c
)
5332 && !(dumpbase
&& !*dumpbase
))
5334 gcc_assert (!outbase
);
5338 gcc_assert (single_input_file_index () != -2);
5339 /* We do not want lbasename here; dumpbase with dirnames
5340 overrides dumpdir entirely, even if dumpdir is
5343 /* We've already checked above that the suffix matches. */
5344 outbase
= xstrndup (dumpbase
,
5345 strlen (dumpbase
) - strlen (dumpbase_ext
));
5347 outbase
= xstrdup (dumpbase
);
5349 else if (output_file
&& !not_actual_file_p (output_file
))
5351 outbase
= xstrdup (lbasename (output_file
));
5352 char *p
= strrchr (outbase
+ 1, '.');
5358 outbase_length
= strlen (outbase
);
5361 /* If there is any pathname component in an explicit -dumpbase, do
5362 not use dumpdir, but retain it to pass it on to the compiler. */
5364 dumpdir_length
= strlen (dumpdir
);
5368 /* Check that dumpbase_ext, if still present, still matches the end
5369 of dumpbase, if present, and drop it otherwise. We only retained
5370 it above when dumpbase was absent to maybe use it to drop the
5371 extension from output_name before combining it with dumpdir. We
5372 won't deal with -dumpbase-ext when -dumpbase is not explicitly
5373 given, even if just to activate backward-compatible dumpbase:
5374 dropping it on the floor is correct, expected and documented
5375 behavior. Attempting to deal with a -dumpbase-ext that might
5376 match the end of some input filename, or of the combination of
5377 the output basename with the suffix of the input filename,
5378 possible with an intermediate .gk extension for -fcompare-debug,
5379 is just calling for trouble. */
5382 if (!dumpbase
|| !*dumpbase
)
5384 free (dumpbase_ext
);
5385 dumpbase_ext
= NULL
;
5388 gcc_assert (strcmp (dumpbase
+ strlen (dumpbase
)
5389 - strlen (dumpbase_ext
), dumpbase_ext
) == 0);
5392 if (save_temps_flag
&& use_pipes
)
5394 /* -save-temps overrides -pipe, so that temp files are produced */
5395 if (save_temps_flag
)
5396 warning (0, "%<-pipe%> ignored because %<-save-temps%> specified");
5402 const char *gcd
= env
.get ("GCC_COMPARE_DEBUG");
5404 if (gcd
&& gcd
[0] == '-')
5407 compare_debug_opt
= gcd
;
5409 else if (gcd
&& *gcd
&& strcmp (gcd
, "0"))
5412 compare_debug_opt
= "-gtoggle";
5415 else if (compare_debug
< 0)
5418 gcc_assert (!compare_debug_opt
);
5421 /* Set up the search paths. We add directories that we expect to
5422 contain GNU Toolchain components before directories specified by
5423 the machine description so that we will find GNU components (like
5424 the GNU assembler) before those of the host system. */
5426 /* If we don't know where the toolchain has been installed, use the
5427 configured-in locations. */
5428 if (!gcc_exec_prefix
)
5431 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "GCC",
5432 PREFIX_PRIORITY_LAST
, 1, 0);
5433 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "BINUTILS",
5434 PREFIX_PRIORITY_LAST
, 2, 0);
5435 add_prefix (&exec_prefixes
, standard_exec_prefix
, "BINUTILS",
5436 PREFIX_PRIORITY_LAST
, 2, 0);
5438 add_prefix (&startfile_prefixes
, standard_exec_prefix
, "BINUTILS",
5439 PREFIX_PRIORITY_LAST
, 1, 0);
5442 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix
));
5443 tooldir_prefix2
= concat (tooldir_base_prefix
, spec_machine
,
5444 dir_separator_str
, NULL
);
5446 /* Look for tools relative to the location from which the driver is
5447 running, or, if that is not available, the configured prefix. */
5449 = concat (gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
5450 spec_host_machine
, dir_separator_str
, spec_version
,
5451 accel_dir_suffix
, dir_separator_str
, tooldir_prefix2
, NULL
);
5452 free (tooldir_prefix2
);
5454 add_prefix (&exec_prefixes
,
5455 concat (tooldir_prefix
, "bin", dir_separator_str
, NULL
),
5456 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 0);
5457 add_prefix (&startfile_prefixes
,
5458 concat (tooldir_prefix
, "lib", dir_separator_str
, NULL
),
5459 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 1);
5460 free (tooldir_prefix
);
5462 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
5463 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
5464 then consider it to relocate with the rest of the GCC installation
5465 if GCC_EXEC_PREFIX is set.
5466 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
5467 if (target_system_root
&& !target_system_root_changed
&& gcc_exec_prefix
)
5469 char *tmp_prefix
= get_relative_prefix (decoded_options
[0].arg
,
5470 standard_bindir_prefix
,
5471 target_system_root
);
5472 if (tmp_prefix
&& access_check (tmp_prefix
, F_OK
) == 0)
5474 target_system_root
= tmp_prefix
;
5475 target_system_root_changed
= 1;
5480 /* More prefixes are enabled in main, after we read the specs file
5481 and determine whether this is cross-compilation or not. */
5483 if (n_infiles
!= 0 && n_infiles
== last_language_n_infiles
&& spec_lang
!= 0)
5484 warning (0, "%<-x %s%> after last input file has no effect", spec_lang
);
5486 /* Synthesize -fcompare-debug flag from the GCC_COMPARE_DEBUG
5487 environment variable. */
5488 if (compare_debug
== 2 || compare_debug
== 3)
5490 const char *opt
= concat ("-fcompare-debug=", compare_debug_opt
, NULL
);
5491 save_switch (opt
, 0, NULL
, false, true);
5495 /* Ensure we only invoke each subprocess once. */
5497 && (print_subprocess_help
|| print_help_list
|| print_version
))
5499 /* Create a dummy input file, so that we can pass
5500 the help option on to the various sub-processes. */
5501 add_infile ("help-dummy", "c");
5504 /* Decide if undefined variable references are allowed in specs. */
5506 /* -v alone is safe. --version and --help alone or together are safe. Note
5507 that -v would make them unsafe, as they'd then be run for subprocesses as
5508 well, the location of which might depend on variables possibly coming
5509 from self-specs. Note also that the command name is counted in
5510 decoded_options_count. */
5512 unsigned help_version_count
= 0;
5515 help_version_count
++;
5517 if (print_help_list
)
5518 help_version_count
++;
5520 spec_undefvar_allowed
=
5521 ((verbose_flag
&& decoded_options_count
== 2)
5522 || help_version_count
== decoded_options_count
- 1);
5525 switches
[n_switches
].part1
= 0;
5527 infiles
[n_infiles
].name
= 0;
5530 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
5531 and place that in the environment. */
5534 set_collect_gcc_options (void)
5539 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
5541 obstack_grow (&collect_obstack
, "COLLECT_GCC_OPTIONS=",
5542 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
5545 for (i
= 0; (int) i
< n_switches
; i
++)
5547 const char *const *args
;
5550 obstack_grow (&collect_obstack
, " ", 1);
5554 /* Ignore elided switches. */
5555 if ((switches
[i
].live_cond
5556 & (SWITCH_IGNORE
| SWITCH_KEEP_FOR_GCC
))
5560 obstack_grow (&collect_obstack
, "'-", 2);
5561 q
= switches
[i
].part1
;
5562 while ((p
= strchr (q
, '\'')))
5564 obstack_grow (&collect_obstack
, q
, p
- q
);
5565 obstack_grow (&collect_obstack
, "'\\''", 4);
5568 obstack_grow (&collect_obstack
, q
, strlen (q
));
5569 obstack_grow (&collect_obstack
, "'", 1);
5571 for (args
= switches
[i
].args
; args
&& *args
; args
++)
5573 obstack_grow (&collect_obstack
, " '", 2);
5575 while ((p
= strchr (q
, '\'')))
5577 obstack_grow (&collect_obstack
, q
, p
- q
);
5578 obstack_grow (&collect_obstack
, "'\\''", 4);
5581 obstack_grow (&collect_obstack
, q
, strlen (q
));
5582 obstack_grow (&collect_obstack
, "'", 1);
5589 obstack_grow (&collect_obstack
, " ", 1);
5592 obstack_grow (&collect_obstack
, "'-dumpdir' '", 12);
5596 while ((p
= strchr (q
, '\'')))
5598 obstack_grow (&collect_obstack
, q
, p
- q
);
5599 obstack_grow (&collect_obstack
, "'\\''", 4);
5602 obstack_grow (&collect_obstack
, q
, strlen (q
));
5604 obstack_grow (&collect_obstack
, "'", 1);
5607 obstack_grow (&collect_obstack
, "\0", 1);
5608 xputenv (XOBFINISH (&collect_obstack
, char *));
5611 /* Process a spec string, accumulating and running commands. */
5613 /* These variables describe the input file name.
5614 input_file_number is the index on outfiles of this file,
5615 so that the output file name can be stored for later use by %o.
5616 input_basename is the start of the part of the input file
5617 sans all directory names, and basename_length is the number
5618 of characters starting there excluding the suffix .c or whatever. */
5620 static const char *gcc_input_filename
;
5621 static int input_file_number
;
5622 size_t input_filename_length
;
5623 static int basename_length
;
5624 static int suffixed_basename_length
;
5625 static const char *input_basename
;
5626 static const char *input_suffix
;
5627 #ifndef HOST_LACKS_INODE_NUMBERS
5628 static struct stat input_stat
;
5630 static int input_stat_set
;
5632 /* The compiler used to process the current input file. */
5633 static struct compiler
*input_file_compiler
;
5635 /* These are variables used within do_spec and do_spec_1. */
5637 /* Nonzero if an arg has been started and not yet terminated
5638 (with space, tab or newline). */
5639 static int arg_going
;
5641 /* Nonzero means %d or %g has been seen; the next arg to be terminated
5642 is a temporary file name. */
5643 static int delete_this_arg
;
5645 /* Nonzero means %w has been seen; the next arg to be terminated
5646 is the output file name of this compilation. */
5647 static int this_is_output_file
;
5649 /* Nonzero means %s has been seen; the next arg to be terminated
5650 is the name of a library file and we should try the standard
5651 search dirs for it. */
5652 static int this_is_library_file
;
5654 /* Nonzero means %T has been seen; the next arg to be terminated
5655 is the name of a linker script and we should try all of the
5656 standard search dirs for it. If it is found insert a --script
5657 command line switch and then substitute the full path in place,
5658 otherwise generate an error message. */
5659 static int this_is_linker_script
;
5661 /* Nonzero means that the input of this command is coming from a pipe. */
5662 static int input_from_pipe
;
5664 /* Nonnull means substitute this for any suffix when outputting a switches
5666 static const char *suffix_subst
;
5668 /* If there is an argument being accumulated, terminate it and store it. */
5671 end_going_arg (void)
5677 obstack_1grow (&obstack
, 0);
5678 string
= XOBFINISH (&obstack
, const char *);
5679 if (this_is_library_file
)
5680 string
= find_file (string
);
5681 if (this_is_linker_script
)
5683 char * full_script_path
= find_a_file (&startfile_prefixes
, string
, R_OK
, true);
5685 if (full_script_path
== NULL
)
5687 error ("unable to locate default linker script %qs in the library search paths", string
);
5688 /* Script was not found on search path. */
5691 store_arg ("--script", false, false);
5692 string
= full_script_path
;
5694 store_arg (string
, delete_this_arg
, this_is_output_file
);
5695 if (this_is_output_file
)
5696 outfiles
[input_file_number
] = string
;
5702 /* Parse the WRAPPER string which is a comma separated list of the command line
5703 and insert them into the beginning of argbuf. */
5706 insert_wrapper (const char *wrapper
)
5710 char *buf
= xstrdup (wrapper
);
5712 unsigned int old_length
= argbuf
.length ();
5720 while ((p
= strchr (p
, ',')) != NULL
);
5722 argbuf
.safe_grow (old_length
+ n
, true);
5723 memmove (argbuf
.address () + n
,
5725 old_length
* sizeof (const_char_p
));
5739 while ((p
= strchr (p
, ',')) != NULL
);
5740 gcc_assert (i
== n
);
5743 /* Process the spec SPEC and run the commands specified therein.
5744 Returns 0 if the spec is successfully processed; -1 if failed. */
5747 do_spec (const char *spec
)
5751 value
= do_spec_2 (spec
, NULL
);
5753 /* Force out any unfinished command.
5754 If -pipe, this forces out the last command if it ended in `|'. */
5757 if (argbuf
.length () > 0
5758 && !strcmp (argbuf
.last (), "|"))
5761 set_collect_gcc_options ();
5763 if (argbuf
.length () > 0)
5770 /* Process the spec SPEC, with SOFT_MATCHED_PART designating the current value
5771 of a matched * pattern which may be re-injected by way of %*. */
5774 do_spec_2 (const char *spec
, const char *soft_matched_part
)
5780 delete_this_arg
= 0;
5781 this_is_output_file
= 0;
5782 this_is_library_file
= 0;
5783 this_is_linker_script
= 0;
5784 input_from_pipe
= 0;
5785 suffix_subst
= NULL
;
5787 result
= do_spec_1 (spec
, 0, soft_matched_part
);
5794 /* Process the given spec string and add any new options to the end
5795 of the switches/n_switches array. */
5798 do_option_spec (const char *name
, const char *spec
)
5800 unsigned int i
, value_count
, value_len
;
5801 const char *p
, *q
, *value
;
5802 char *tmp_spec
, *tmp_spec_p
;
5804 if (configure_default_options
[0].name
== NULL
)
5807 for (i
= 0; i
< ARRAY_SIZE (configure_default_options
); i
++)
5808 if (strcmp (configure_default_options
[i
].name
, name
) == 0)
5810 if (i
== ARRAY_SIZE (configure_default_options
))
5813 value
= configure_default_options
[i
].value
;
5814 value_len
= strlen (value
);
5816 /* Compute the size of the final spec. */
5819 while ((p
= strstr (p
, "%(VALUE)")) != NULL
)
5825 /* Replace each %(VALUE) by the specified value. */
5826 tmp_spec
= (char *) alloca (strlen (spec
) + 1
5827 + value_count
* (value_len
- strlen ("%(VALUE)")));
5828 tmp_spec_p
= tmp_spec
;
5830 while ((p
= strstr (q
, "%(VALUE)")) != NULL
)
5832 memcpy (tmp_spec_p
, q
, p
- q
);
5833 tmp_spec_p
= tmp_spec_p
+ (p
- q
);
5834 memcpy (tmp_spec_p
, value
, value_len
);
5835 tmp_spec_p
+= value_len
;
5836 q
= p
+ strlen ("%(VALUE)");
5838 strcpy (tmp_spec_p
, q
);
5840 do_self_spec (tmp_spec
);
5843 /* Process the given spec string and add any new options to the end
5844 of the switches/n_switches array. */
5847 do_self_spec (const char *spec
)
5851 do_spec_2 (spec
, NULL
);
5852 do_spec_1 (" ", 0, NULL
);
5854 /* Mark %<S switches processed by do_self_spec to be ignored permanently.
5855 do_self_specs adds the replacements to switches array, so it shouldn't
5856 be processed afterwards. */
5857 for (i
= 0; i
< n_switches
; i
++)
5858 if ((switches
[i
].live_cond
& SWITCH_IGNORE
))
5859 switches
[i
].live_cond
|= SWITCH_IGNORE_PERMANENTLY
;
5861 if (argbuf
.length () > 0)
5863 const char **argbuf_copy
;
5864 struct cl_decoded_option
*decoded_options
;
5865 struct cl_option_handlers handlers
;
5866 unsigned int decoded_options_count
;
5869 /* Create a copy of argbuf with a dummy argv[0] entry for
5870 decode_cmdline_options_to_array. */
5871 argbuf_copy
= XNEWVEC (const char *,
5872 argbuf
.length () + 1);
5873 argbuf_copy
[0] = "";
5874 memcpy (argbuf_copy
+ 1, argbuf
.address (),
5875 argbuf
.length () * sizeof (const char *));
5877 decode_cmdline_options_to_array (argbuf
.length () + 1,
5879 CL_DRIVER
, &decoded_options
,
5880 &decoded_options_count
);
5883 set_option_handlers (&handlers
);
5885 for (j
= 1; j
< decoded_options_count
; j
++)
5887 switch (decoded_options
[j
].opt_index
)
5889 case OPT_SPECIAL_input_file
:
5890 /* Specs should only generate options, not input
5892 if (strcmp (decoded_options
[j
].arg
, "-") != 0)
5893 fatal_error (input_location
,
5894 "switch %qs does not start with %<-%>",
5895 decoded_options
[j
].arg
);
5897 fatal_error (input_location
,
5898 "spec-generated switch is just %<-%>");
5901 case OPT_fcompare_debug_second
:
5902 case OPT_fcompare_debug
:
5903 case OPT_fcompare_debug_
:
5905 /* Avoid duplicate processing of some options from
5906 compare-debug specs; just save them here. */
5907 save_switch (decoded_options
[j
].canonical_option
[0],
5908 (decoded_options
[j
].canonical_option_num_elements
5910 &decoded_options
[j
].canonical_option
[1], false, true);
5914 read_cmdline_option (&global_options
, &global_options_set
,
5915 decoded_options
+ j
, UNKNOWN_LOCATION
,
5916 CL_DRIVER
, &handlers
, global_dc
);
5921 free (decoded_options
);
5924 switches
[n_switches
].part1
= 0;
5928 /* Callback for processing %D and %I specs. */
5930 struct spec_path_info
{
5935 bool separate_options
;
5940 spec_path (char *path
, void *data
)
5942 struct spec_path_info
*info
= (struct spec_path_info
*) data
;
5946 /* The path must exist; we want to resolve it to the realpath so that this
5947 can be embedded as a runpath. */
5948 if (info
->realpaths
)
5949 path
= lrealpath (path
);
5951 /* However, if we failed to resolve it - perhaps because there was a bogus
5952 -B option on the command line, then punt on this entry. */
5956 if (info
->omit_relative
&& !IS_ABSOLUTE_PATH (path
))
5959 if (info
->append_len
!= 0)
5961 len
= strlen (path
);
5962 memcpy (path
+ len
, info
->append
, info
->append_len
+ 1);
5965 if (!is_directory (path
, true))
5968 do_spec_1 (info
->option
, 1, NULL
);
5969 if (info
->separate_options
)
5970 do_spec_1 (" ", 0, NULL
);
5972 if (info
->append_len
== 0)
5974 len
= strlen (path
);
5975 save
= path
[len
- 1];
5976 if (IS_DIR_SEPARATOR (path
[len
- 1]))
5977 path
[len
- 1] = '\0';
5980 do_spec_1 (path
, 1, NULL
);
5981 do_spec_1 (" ", 0, NULL
);
5983 /* Must not damage the original path. */
5984 if (info
->append_len
== 0)
5985 path
[len
- 1] = save
;
5990 /* True if we should compile INFILE. */
5993 compile_input_file_p (struct infile
*infile
)
5995 if ((!infile
->language
) || (infile
->language
[0] != '*'))
5996 if (infile
->incompiler
== input_file_compiler
)
6001 /* Process each member of VEC as a spec. */
6004 do_specs_vec (vec
<char_p
> vec
)
6006 for (char *opt
: vec
)
6008 do_spec_1 (opt
, 1, NULL
);
6009 /* Make each accumulated option a separate argument. */
6010 do_spec_1 (" ", 0, NULL
);
6014 /* Add options passed via -Xassembler or -Wa to COLLECT_AS_OPTIONS. */
6017 putenv_COLLECT_AS_OPTIONS (vec
<char_p
> vec
)
6019 if (vec
.is_empty ())
6022 obstack_init (&collect_obstack
);
6023 obstack_grow (&collect_obstack
, "COLLECT_AS_OPTIONS=",
6024 strlen ("COLLECT_AS_OPTIONS="));
6029 FOR_EACH_VEC_ELT (vec
, ix
, opt
)
6031 obstack_1grow (&collect_obstack
, '\'');
6032 obstack_grow (&collect_obstack
, opt
, strlen (opt
));
6033 obstack_1grow (&collect_obstack
, '\'');
6034 if (ix
< vec
.length () - 1)
6035 obstack_1grow(&collect_obstack
, ' ');
6038 obstack_1grow (&collect_obstack
, '\0');
6039 xputenv (XOBFINISH (&collect_obstack
, char *));
6042 /* Process the sub-spec SPEC as a portion of a larger spec.
6043 This is like processing a whole spec except that we do
6044 not initialize at the beginning and we do not supply a
6045 newline by default at the end.
6046 INSWITCH nonzero means don't process %-sequences in SPEC;
6047 in this case, % is treated as an ordinary character.
6048 This is used while substituting switches.
6049 INSWITCH nonzero also causes SPC not to terminate an argument.
6051 Value is zero unless a line was finished
6052 and the command on that line reported an error. */
6055 do_spec_1 (const char *spec
, int inswitch
, const char *soft_matched_part
)
6057 const char *p
= spec
;
6062 /* If it's an empty string argument to a switch, keep it as is. */
6063 if (inswitch
&& !*p
)
6067 /* If substituting a switch, treat all chars like letters.
6068 Otherwise, NL, SPC, TAB and % are special. */
6069 switch (inswitch
? 'a' : c
)
6074 if (argbuf
.length () > 0
6075 && !strcmp (argbuf
.last (), "|"))
6077 /* A `|' before the newline means use a pipe here,
6078 but only if -pipe was specified.
6079 Otherwise, execute now and don't pass the `|' as an arg. */
6082 input_from_pipe
= 1;
6089 set_collect_gcc_options ();
6091 if (argbuf
.length () > 0)
6097 /* Reinitialize for a new command, and for a new argument. */
6100 delete_this_arg
= 0;
6101 this_is_output_file
= 0;
6102 this_is_library_file
= 0;
6103 this_is_linker_script
= 0;
6104 input_from_pipe
= 0;
6111 obstack_1grow (&obstack
, c
);
6119 /* Reinitialize for a new argument. */
6120 delete_this_arg
= 0;
6121 this_is_output_file
= 0;
6122 this_is_library_file
= 0;
6123 this_is_linker_script
= 0;
6130 fatal_error (input_location
, "spec %qs invalid", spec
);
6133 /* Don't use %b in the linker command. */
6134 gcc_assert (suffixed_basename_length
);
6135 if (!this_is_output_file
&& dumpdir_length
)
6136 obstack_grow (&obstack
, dumpdir
, dumpdir_length
);
6137 if (this_is_output_file
|| !outbase_length
)
6138 obstack_grow (&obstack
, input_basename
, basename_length
);
6140 obstack_grow (&obstack
, outbase
, outbase_length
);
6141 if (compare_debug
< 0)
6142 obstack_grow (&obstack
, ".gk", 3);
6147 /* Don't use %B in the linker command. */
6148 gcc_assert (suffixed_basename_length
);
6149 if (!this_is_output_file
&& dumpdir_length
)
6150 obstack_grow (&obstack
, dumpdir
, dumpdir_length
);
6151 if (this_is_output_file
|| !outbase_length
)
6152 obstack_grow (&obstack
, input_basename
, basename_length
);
6154 obstack_grow (&obstack
, outbase
, outbase_length
);
6155 if (compare_debug
< 0)
6156 obstack_grow (&obstack
, ".gk", 3);
6157 obstack_grow (&obstack
, input_basename
+ basename_length
,
6158 suffixed_basename_length
- basename_length
);
6164 delete_this_arg
= 2;
6167 /* Dump out the directories specified with LIBRARY_PATH,
6168 followed by the absolute directories
6169 that we search for startfiles. */
6172 struct spec_path_info info
;
6175 info
.append_len
= 0;
6176 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
6177 /* Used on systems which record the specified -L dirs
6178 and use them to search for dynamic linking.
6179 Relative directories always come from -B,
6180 and it is better not to use them for searching
6181 at run time. In particular, stage1 loses. */
6182 info
.omit_relative
= true;
6184 info
.omit_relative
= false;
6186 info
.separate_options
= false;
6187 info
.realpaths
= false;
6189 for_each_path (&startfile_prefixes
, true, 0, spec_path
, &info
);
6195 struct spec_path_info info
;
6197 info
.option
= RUNPATH_OPTION
;
6198 info
.append_len
= 0;
6199 info
.omit_relative
= false;
6200 info
.separate_options
= true;
6201 /* We want to embed the actual paths that have the libraries. */
6202 info
.realpaths
= true;
6204 for_each_path (&startfile_prefixes
, true, 0, spec_path
, &info
);
6209 /* %efoo means report an error with `foo' as error message
6210 and don't execute any more commands for this file. */
6214 while (*p
!= 0 && *p
!= '\n')
6216 buf
= (char *) alloca (p
- q
+ 1);
6217 strncpy (buf
, q
, p
- q
);
6219 error ("%s", _(buf
));
6224 /* %nfoo means report a notice with `foo' on stderr. */
6228 while (*p
!= 0 && *p
!= '\n')
6230 buf
= (char *) alloca (p
- q
+ 1);
6231 strncpy (buf
, q
, p
- q
);
6233 inform (UNKNOWN_LOCATION
, "%s", _(buf
));
6243 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
6244 defined, and it is not a directory, and it is
6245 writable, use it. Otherwise, treat this like any
6246 other temporary file. */
6248 if ((!save_temps_flag
)
6249 && (stat (HOST_BIT_BUCKET
, &st
) == 0) && (!S_ISDIR (st
.st_mode
))
6250 && (access (HOST_BIT_BUCKET
, W_OK
) == 0))
6252 obstack_grow (&obstack
, HOST_BIT_BUCKET
,
6253 strlen (HOST_BIT_BUCKET
));
6254 delete_this_arg
= 0;
6259 goto create_temp_file
;
6263 obstack_1grow (&obstack
, '-');
6264 delete_this_arg
= 0;
6267 /* consume suffix */
6268 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
6270 if (p
[0] == '%' && p
[1] == 'O')
6275 goto create_temp_file
;
6279 /* consume suffix */
6280 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
6282 if (p
[0] == '%' && p
[1] == 'O')
6287 goto create_temp_file
;
6293 struct temp_name
*t
;
6295 const char *suffix
= p
;
6296 char *saved_suffix
= NULL
;
6298 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
6300 suffix_length
= p
- suffix
;
6301 if (p
[0] == '%' && p
[1] == 'O')
6304 /* We don't support extra suffix characters after %O. */
6305 if (*p
== '.' || ISALNUM ((unsigned char) *p
))
6306 fatal_error (input_location
,
6307 "spec %qs has invalid %<%%0%c%>", spec
, *p
);
6308 if (suffix_length
== 0)
6309 suffix
= TARGET_OBJECT_SUFFIX
;
6313 = XNEWVEC (char, suffix_length
6314 + strlen (TARGET_OBJECT_SUFFIX
) + 1);
6315 strncpy (saved_suffix
, suffix
, suffix_length
);
6316 strcpy (saved_suffix
+ suffix_length
,
6317 TARGET_OBJECT_SUFFIX
);
6319 suffix_length
+= strlen (TARGET_OBJECT_SUFFIX
);
6322 if (compare_debug
< 0)
6324 suffix
= concat (".gk", suffix
, NULL
);
6328 /* If -save-temps was specified, use that for the
6330 if (save_temps_flag
)
6333 bool adjusted_suffix
= false;
6335 && !outbase_length
&& !basename_length
6336 && !dumpdir_trailing_dash_added
)
6338 adjusted_suffix
= true;
6342 temp_filename_length
6343 = dumpdir_length
+ suffix_length
+ 1;
6345 temp_filename_length
+= outbase_length
;
6347 temp_filename_length
+= basename_length
;
6348 tmp
= (char *) alloca (temp_filename_length
);
6350 memcpy (tmp
, dumpdir
, dumpdir_length
);
6352 memcpy (tmp
+ dumpdir_length
, outbase
,
6354 else if (basename_length
)
6355 memcpy (tmp
+ dumpdir_length
, input_basename
,
6357 memcpy (tmp
+ temp_filename_length
- suffix_length
- 1,
6358 suffix
, suffix_length
);
6359 if (adjusted_suffix
)
6361 adjusted_suffix
= false;
6365 tmp
[temp_filename_length
- 1] = '\0';
6366 temp_filename
= tmp
;
6368 if (filename_cmp (temp_filename
, gcc_input_filename
) != 0)
6370 #ifndef HOST_LACKS_INODE_NUMBERS
6371 struct stat st_temp
;
6373 /* Note, set_input() resets input_stat_set to 0. */
6374 if (input_stat_set
== 0)
6376 input_stat_set
= stat (gcc_input_filename
,
6378 if (input_stat_set
>= 0)
6382 /* If we have the stat for the gcc_input_filename
6383 and we can do the stat for the temp_filename
6384 then the they could still refer to the same
6385 file if st_dev/st_ino's are the same. */
6386 if (input_stat_set
!= 1
6387 || stat (temp_filename
, &st_temp
) < 0
6388 || input_stat
.st_dev
!= st_temp
.st_dev
6389 || input_stat
.st_ino
!= st_temp
.st_ino
)
6391 /* Just compare canonical pathnames. */
6392 char* input_realname
= lrealpath (gcc_input_filename
);
6393 char* temp_realname
= lrealpath (temp_filename
);
6394 bool files_differ
= filename_cmp (input_realname
, temp_realname
);
6395 free (input_realname
);
6396 free (temp_realname
);
6401 = save_string (temp_filename
,
6402 temp_filename_length
- 1);
6403 obstack_grow (&obstack
, temp_filename
,
6404 temp_filename_length
);
6406 delete_this_arg
= 0;
6412 /* See if we already have an association of %g/%u/%U and
6414 for (t
= temp_names
; t
; t
= t
->next
)
6415 if (t
->length
== suffix_length
6416 && strncmp (t
->suffix
, suffix
, suffix_length
) == 0
6417 && t
->unique
== (c
== 'u' || c
== 'U' || c
== 'j'))
6420 /* Make a new association if needed. %u and %j
6422 if (t
== 0 || c
== 'u' || c
== 'j')
6426 t
= XNEW (struct temp_name
);
6427 t
->next
= temp_names
;
6430 t
->length
= suffix_length
;
6433 t
->suffix
= saved_suffix
;
6434 saved_suffix
= NULL
;
6437 t
->suffix
= save_string (suffix
, suffix_length
);
6438 t
->unique
= (c
== 'u' || c
== 'U' || c
== 'j');
6439 temp_filename
= make_temp_file (t
->suffix
);
6440 temp_filename_length
= strlen (temp_filename
);
6441 t
->filename
= temp_filename
;
6442 t
->filename_length
= temp_filename_length
;
6445 free (saved_suffix
);
6447 obstack_grow (&obstack
, t
->filename
, t
->filename_length
);
6448 delete_this_arg
= 1;
6456 /* We are going to expand `%i' into `@FILE', where FILE
6457 is a newly-created temporary filename. The filenames
6458 that would usually be expanded in place of %o will be
6459 written to the temporary file. */
6460 if (at_file_supplied
)
6463 for (i
= 0; (int) i
< n_infiles
; i
++)
6464 if (compile_input_file_p (&infiles
[i
]))
6466 store_arg (infiles
[i
].name
, 0, 0);
6467 infiles
[i
].compiled
= true;
6470 if (at_file_supplied
)
6475 obstack_grow (&obstack
, gcc_input_filename
,
6476 input_filename_length
);
6483 struct spec_path_info info
;
6487 do_spec_1 ("-imultilib", 1, NULL
);
6488 /* Make this a separate argument. */
6489 do_spec_1 (" ", 0, NULL
);
6490 do_spec_1 (multilib_dir
, 1, NULL
);
6491 do_spec_1 (" ", 0, NULL
);
6496 do_spec_1 ("-imultiarch", 1, NULL
);
6497 /* Make this a separate argument. */
6498 do_spec_1 (" ", 0, NULL
);
6499 do_spec_1 (multiarch_dir
, 1, NULL
);
6500 do_spec_1 (" ", 0, NULL
);
6503 if (gcc_exec_prefix
)
6505 do_spec_1 ("-iprefix", 1, NULL
);
6506 /* Make this a separate argument. */
6507 do_spec_1 (" ", 0, NULL
);
6508 do_spec_1 (gcc_exec_prefix
, 1, NULL
);
6509 do_spec_1 (" ", 0, NULL
);
6512 if (target_system_root_changed
||
6513 (target_system_root
&& target_sysroot_hdrs_suffix
))
6515 do_spec_1 ("-isysroot", 1, NULL
);
6516 /* Make this a separate argument. */
6517 do_spec_1 (" ", 0, NULL
);
6518 do_spec_1 (target_system_root
, 1, NULL
);
6519 if (target_sysroot_hdrs_suffix
)
6520 do_spec_1 (target_sysroot_hdrs_suffix
, 1, NULL
);
6521 do_spec_1 (" ", 0, NULL
);
6524 info
.option
= "-isystem";
6525 info
.append
= "include";
6526 info
.append_len
= strlen (info
.append
);
6527 info
.omit_relative
= false;
6528 info
.separate_options
= true;
6529 info
.realpaths
= false;
6531 for_each_path (&include_prefixes
, false, info
.append_len
,
6534 info
.append
= "include-fixed";
6535 if (*sysroot_hdrs_suffix_spec
)
6536 info
.append
= concat (info
.append
, dir_separator_str
,
6537 multilib_dir
, NULL
);
6538 else if (multiarch_dir
)
6540 /* For multiarch, search include-fixed/<multiarch-dir>
6541 before include-fixed. */
6542 info
.append
= concat (info
.append
, dir_separator_str
,
6543 multiarch_dir
, NULL
);
6544 info
.append_len
= strlen (info
.append
);
6545 for_each_path (&include_prefixes
, false, info
.append_len
,
6548 info
.append
= "include-fixed";
6550 info
.append_len
= strlen (info
.append
);
6551 for_each_path (&include_prefixes
, false, info
.append_len
,
6557 /* We are going to expand `%o' into `@FILE', where FILE
6558 is a newly-created temporary filename. The filenames
6559 that would usually be expanded in place of %o will be
6560 written to the temporary file. */
6561 if (at_file_supplied
)
6564 for (i
= 0; i
< n_infiles
+ lang_specific_extra_outfiles
; i
++)
6566 store_arg (outfiles
[i
], 0, 0);
6568 if (at_file_supplied
)
6573 obstack_grow (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
6578 this_is_library_file
= 1;
6582 this_is_linker_script
= 1;
6586 outfiles
[input_file_number
] = NULL
;
6590 this_is_output_file
= 1;
6595 unsigned int cur_index
= argbuf
.length ();
6596 /* Handle the {...} following the %W. */
6598 fatal_error (input_location
,
6599 "spec %qs has invalid %<%%W%c%>", spec
, *p
);
6600 p
= handle_braces (p
+ 1);
6604 /* If any args were output, mark the last one for deletion
6606 if (argbuf
.length () != cur_index
)
6607 record_temp_file (argbuf
.last (), 0, 1);
6612 /* Handle the {...} following the %@. */
6614 fatal_error (input_location
,
6615 "spec %qs has invalid %<%%@%c%>", spec
, *p
);
6616 if (at_file_supplied
)
6618 p
= handle_braces (p
+ 1);
6619 if (at_file_supplied
)
6625 /* %x{OPTION} records OPTION for %X to output. */
6631 /* Skip past the option value and make a copy. */
6633 fatal_error (input_location
,
6634 "spec %qs has invalid %<%%x%c%>", spec
, *p
);
6637 string
= save_string (p1
+ 1, p
- p1
- 2);
6639 /* See if we already recorded this option. */
6640 for (const char *opt
: linker_options
)
6641 if (! strcmp (string
, opt
))
6647 /* This option is new; add it. */
6648 add_linker_option (string
, strlen (string
));
6653 /* Dump out the options accumulated previously using %x. */
6655 do_specs_vec (linker_options
);
6658 /* Dump out the options accumulated previously using -Wa,. */
6660 do_specs_vec (assembler_options
);
6663 /* Dump out the options accumulated previously using -Wp,. */
6665 do_specs_vec (preprocessor_options
);
6668 /* Here are digits and numbers that just process
6669 a certain constant string as a spec. */
6672 value
= do_spec_1 (cc1_spec
, 0, NULL
);
6678 value
= do_spec_1 (cc1plus_spec
, 0, NULL
);
6684 value
= do_spec_1 (asm_spec
, 0, NULL
);
6690 value
= do_spec_1 (asm_final_spec
, 0, NULL
);
6697 const char *const spec
6698 = (input_file_compiler
->cpp_spec
6699 ? input_file_compiler
->cpp_spec
6701 value
= do_spec_1 (spec
, 0, NULL
);
6708 value
= do_spec_1 (endfile_spec
, 0, NULL
);
6714 value
= do_spec_1 (link_spec
, 0, NULL
);
6720 value
= do_spec_1 (lib_spec
, 0, NULL
);
6726 if (multilib_os_dir
== NULL
)
6727 obstack_1grow (&obstack
, '.');
6729 obstack_grow (&obstack
, multilib_os_dir
,
6730 strlen (multilib_os_dir
));
6734 value
= do_spec_1 (libgcc_spec
, 0, NULL
);
6740 /* We assume there is a directory
6741 separator at the end of this string. */
6742 if (target_system_root
)
6744 obstack_grow (&obstack
, target_system_root
,
6745 strlen (target_system_root
));
6746 if (target_sysroot_suffix
)
6747 obstack_grow (&obstack
, target_sysroot_suffix
,
6748 strlen (target_sysroot_suffix
));
6753 value
= do_spec_1 (startfile_spec
, 0, NULL
);
6758 /* Here we define characters other than letters and digits. */
6761 p
= handle_braces (p
);
6767 p
= handle_spec_function (p
, NULL
, soft_matched_part
);
6773 obstack_1grow (&obstack
, '%');
6780 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '%')
6782 suffix_subst
= save_string (p
- 1, len
+ 1);
6787 /* Henceforth ignore the option(s) matching the pattern
6793 int have_wildcard
= 0;
6798 switch_option
= SWITCH_IGNORE
| SWITCH_KEEP_FOR_GCC
;
6800 switch_option
= SWITCH_IGNORE
;
6802 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '\t')
6805 if (p
[len
-1] == '*')
6808 for (i
= 0; i
< n_switches
; i
++)
6809 if (!strncmp (switches
[i
].part1
, p
, len
- have_wildcard
)
6810 && (have_wildcard
|| switches
[i
].part1
[len
] == '\0'))
6812 switches
[i
].live_cond
|= switch_option
;
6813 /* User switch be validated from validate_all_switches.
6814 when the definition is seen from the spec file.
6815 If not defined anywhere, will be rejected. */
6816 if (switches
[i
].known
)
6817 switches
[i
].validated
= true;
6825 if (soft_matched_part
)
6827 if (soft_matched_part
[0])
6828 do_spec_1 (soft_matched_part
, 1, NULL
);
6829 /* Only insert a space after the substitution if it is at the
6830 end of the current sequence. So if:
6832 "%{foo=*:bar%*}%{foo=*:one%*two}"
6834 matches -foo=hello then it will produce:
6836 barhello onehellotwo
6838 if (*p
== 0 || *p
== '}')
6839 do_spec_1 (" ", 0, NULL
);
6842 /* Catch the case where a spec string contains something like
6843 '%{foo:%*}'. i.e. there is no * in the pattern on the left
6844 hand side of the :. */
6845 error ("spec failure: %<%%*%> has not been initialized by pattern match");
6848 /* Process a string found as the value of a spec given by name.
6849 This feature allows individual machine descriptions
6850 to add and use their own specs. */
6853 const char *name
= p
;
6854 struct spec_list
*sl
;
6857 /* The string after the S/P is the name of a spec that is to be
6859 while (*p
&& *p
!= ')')
6862 /* See if it's in the list. */
6863 for (len
= p
- name
, sl
= specs
; sl
; sl
= sl
->next
)
6864 if (sl
->name_len
== len
&& !strncmp (sl
->name
, name
, len
))
6866 name
= *(sl
->ptr_spec
);
6868 fnotice (stderr
, "Processing spec (%s), which is '%s'\n",
6876 value
= do_spec_1 (name
, 0, NULL
);
6881 /* Discard the closing paren. */
6888 /* End a previous argument, if there is one, then issue an
6896 error ("spec failure: unrecognized spec option %qc", c
);
6902 /* Backslash: treat next character as ordinary. */
6905 /* When adding more cases that previously matched default, make
6906 sure to adjust quote_spec_char_p as well. */
6910 /* Ordinary character: put it into the current argument. */
6911 obstack_1grow (&obstack
, c
);
6915 /* End of string. If we are processing a spec function, we need to
6916 end any pending argument. */
6917 if (processing_spec_function
)
6923 /* Look up a spec function. */
6925 static const struct spec_function
*
6926 lookup_spec_function (const char *name
)
6928 const struct spec_function
*sf
;
6930 for (sf
= static_spec_functions
; sf
->name
!= NULL
; sf
++)
6931 if (strcmp (sf
->name
, name
) == 0)
6937 /* Evaluate a spec function. */
6940 eval_spec_function (const char *func
, const char *args
,
6941 const char *soft_matched_part
)
6943 const struct spec_function
*sf
;
6944 const char *funcval
;
6946 /* Saved spec processing context. */
6947 vec
<const_char_p
> save_argbuf
;
6950 int save_delete_this_arg
;
6951 int save_this_is_output_file
;
6952 int save_this_is_library_file
;
6953 int save_input_from_pipe
;
6954 int save_this_is_linker_script
;
6955 const char *save_suffix_subst
;
6957 int save_growing_size
;
6958 void *save_growing_value
= NULL
;
6960 sf
= lookup_spec_function (func
);
6962 fatal_error (input_location
, "unknown spec function %qs", func
);
6964 /* Push the spec processing context. */
6965 save_argbuf
= argbuf
;
6967 save_arg_going
= arg_going
;
6968 save_delete_this_arg
= delete_this_arg
;
6969 save_this_is_output_file
= this_is_output_file
;
6970 save_this_is_library_file
= this_is_library_file
;
6971 save_this_is_linker_script
= this_is_linker_script
;
6972 save_input_from_pipe
= input_from_pipe
;
6973 save_suffix_subst
= suffix_subst
;
6975 /* If we have some object growing now, finalize it so the args and function
6976 eval proceed from a cleared context. This is needed to prevent the first
6977 constructed arg from mistakenly including the growing value. We'll push
6978 this value back on the obstack once the function evaluation is done, to
6979 restore a consistent processing context for our caller. This is fine as
6980 the address of growing objects isn't guaranteed to remain stable until
6981 they are finalized, and we expect this situation to be rare enough for
6982 the extra copy not to be an issue. */
6983 save_growing_size
= obstack_object_size (&obstack
);
6984 if (save_growing_size
> 0)
6985 save_growing_value
= obstack_finish (&obstack
);
6987 /* Create a new spec processing context, and build the function
6991 if (do_spec_2 (args
, soft_matched_part
) < 0)
6992 fatal_error (input_location
, "error in arguments to spec function %qs",
6995 /* argbuf_index is an index for the next argument to be inserted, and
6996 so contains the count of the args already inserted. */
6998 funcval
= (*sf
->func
) (argbuf
.length (),
7001 /* Pop the spec processing context. */
7003 argbuf
= save_argbuf
;
7005 arg_going
= save_arg_going
;
7006 delete_this_arg
= save_delete_this_arg
;
7007 this_is_output_file
= save_this_is_output_file
;
7008 this_is_library_file
= save_this_is_library_file
;
7009 this_is_linker_script
= save_this_is_linker_script
;
7010 input_from_pipe
= save_input_from_pipe
;
7011 suffix_subst
= save_suffix_subst
;
7013 if (save_growing_size
> 0)
7014 obstack_grow (&obstack
, save_growing_value
, save_growing_size
);
7019 /* Handle a spec function call of the form:
7023 ARGS is processed as a spec in a separate context and split into an
7024 argument vector in the normal fashion. The function returns a string
7025 containing a spec which we then process in the caller's context, or
7026 NULL if no processing is required.
7028 If RETVAL_NONNULL is not NULL, then store a bool whether function
7031 SOFT_MATCHED_PART holds the current value of a matched * pattern, which
7032 may be re-expanded with a %* as part of the function arguments. */
7035 handle_spec_function (const char *p
, bool *retval_nonnull
,
7036 const char *soft_matched_part
)
7039 const char *endp
, *funcval
;
7042 processing_spec_function
++;
7044 /* Get the function name. */
7045 for (endp
= p
; *endp
!= '\0'; endp
++)
7047 if (*endp
== '(') /* ) */
7049 /* Only allow [A-Za-z0-9], -, and _ in function names. */
7050 if (!ISALNUM (*endp
) && !(*endp
== '-' || *endp
== '_'))
7051 fatal_error (input_location
, "malformed spec function name");
7053 if (*endp
!= '(') /* ) */
7054 fatal_error (input_location
, "no arguments for spec function");
7055 func
= save_string (p
, endp
- p
);
7058 /* Get the arguments. */
7059 for (count
= 0; *endp
!= '\0'; endp
++)
7068 else if (*endp
== '(') /* ) */
7073 fatal_error (input_location
, "malformed spec function arguments");
7074 args
= save_string (p
, endp
- p
);
7077 /* p now points to just past the end of the spec function expression. */
7079 funcval
= eval_spec_function (func
, args
, soft_matched_part
);
7080 if (funcval
!= NULL
&& do_spec_1 (funcval
, 0, NULL
) < 0)
7083 *retval_nonnull
= funcval
!= NULL
;
7088 processing_spec_function
--;
7093 /* Inline subroutine of handle_braces. Returns true if the current
7094 input suffix matches the atom bracketed by ATOM and END_ATOM. */
7096 input_suffix_matches (const char *atom
, const char *end_atom
)
7098 return (input_suffix
7099 && !strncmp (input_suffix
, atom
, end_atom
- atom
)
7100 && input_suffix
[end_atom
- atom
] == '\0');
7103 /* Subroutine of handle_braces. Returns true if the current
7104 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
7106 input_spec_matches (const char *atom
, const char *end_atom
)
7108 return (input_file_compiler
7109 && input_file_compiler
->suffix
7110 && input_file_compiler
->suffix
[0] != '\0'
7111 && !strncmp (input_file_compiler
->suffix
+ 1, atom
,
7113 && input_file_compiler
->suffix
[end_atom
- atom
+ 1] == '\0');
7116 /* Subroutine of handle_braces. Returns true if a switch
7117 matching the atom bracketed by ATOM and END_ATOM appeared on the
7120 switch_matches (const char *atom
, const char *end_atom
, int starred
)
7123 int len
= end_atom
- atom
;
7124 int plen
= starred
? len
: -1;
7126 for (i
= 0; i
< n_switches
; i
++)
7127 if (!strncmp (switches
[i
].part1
, atom
, len
)
7128 && (starred
|| switches
[i
].part1
[len
] == '\0')
7129 && check_live_switch (i
, plen
))
7132 /* Check if a switch with separated form matching the atom.
7133 We check -D and -U switches. */
7134 else if (switches
[i
].args
!= 0)
7136 if ((*switches
[i
].part1
== 'D' || *switches
[i
].part1
== 'U')
7137 && *switches
[i
].part1
== atom
[0])
7139 if (!strncmp (switches
[i
].args
[0], &atom
[1], len
- 1)
7140 && (starred
|| (switches
[i
].part1
[1] == '\0'
7141 && switches
[i
].args
[0][len
- 1] == '\0'))
7142 && check_live_switch (i
, (starred
? 1 : -1)))
7150 /* Inline subroutine of handle_braces. Mark all of the switches which
7151 match ATOM (extends to END_ATOM; STARRED indicates whether there
7152 was a star after the atom) for later processing. */
7154 mark_matching_switches (const char *atom
, const char *end_atom
, int starred
)
7157 int len
= end_atom
- atom
;
7158 int plen
= starred
? len
: -1;
7160 for (i
= 0; i
< n_switches
; i
++)
7161 if (!strncmp (switches
[i
].part1
, atom
, len
)
7162 && (starred
|| switches
[i
].part1
[len
] == '\0')
7163 && check_live_switch (i
, plen
))
7164 switches
[i
].ordering
= 1;
7167 /* Inline subroutine of handle_braces. Process all the currently
7168 marked switches through give_switch, and clear the marks. */
7170 process_marked_switches (void)
7174 for (i
= 0; i
< n_switches
; i
++)
7175 if (switches
[i
].ordering
== 1)
7177 switches
[i
].ordering
= 0;
7182 /* Handle a %{ ... } construct. P points just inside the leading {.
7183 Returns a pointer one past the end of the brace block, or 0
7184 if we call do_spec_1 and that returns -1. */
7187 handle_braces (const char *p
)
7189 const char *atom
, *end_atom
;
7190 const char *d_atom
= NULL
, *d_end_atom
= NULL
;
7191 char *esc_buf
= NULL
, *d_esc_buf
= NULL
;
7193 const char *orig
= p
;
7201 bool a_must_be_last
= false;
7202 bool ordered_set
= false;
7203 bool disjunct_set
= false;
7204 bool disj_matched
= false;
7205 bool disj_starred
= true;
7206 bool n_way_choice
= false;
7207 bool n_way_matched
= false;
7209 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7216 /* Scan one "atom" (S in the description above of %{}, possibly
7217 with '!', '.', '@', ',', or '*' modifiers). */
7219 a_is_suffix
= false;
7220 a_is_starred
= false;
7221 a_is_negated
= false;
7222 a_is_spectype
= false;
7226 p
++, a_is_negated
= true;
7229 if (*p
== '%' && p
[1] == ':')
7233 p
= handle_spec_function (p
+ 2, &a_matched
, NULL
);
7238 p
++, a_is_suffix
= true;
7240 p
++, a_is_spectype
= true;
7244 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
7245 || *p
== ',' || *p
== '.' || *p
== '@' || *p
== '\\')
7251 fatal_error (input_location
,
7252 "braced spec %qs ends in escape", orig
);
7264 if (esc_buf
&& esc_buf
!= d_esc_buf
)
7267 ep
= esc_buf
= (char *) xmalloc (end_atom
- atom
- esc
+ 1);
7268 for (ap
= atom
; ap
!= end_atom
; ap
++, ep
++)
7280 p
++, a_is_starred
= 1;
7287 /* Substitute the switch(es) indicated by the current atom. */
7289 if (disjunct_set
|| n_way_choice
|| a_is_negated
|| a_is_suffix
7290 || a_is_spectype
|| atom
== end_atom
)
7293 mark_matching_switches (atom
, end_atom
, a_is_starred
);
7296 process_marked_switches ();
7300 /* Substitute some text if the current atom appears as a switch
7302 disjunct_set
= true;
7306 if (atom
&& atom
== end_atom
)
7308 if (!n_way_choice
|| disj_matched
|| *p
== '|'
7309 || a_is_negated
|| a_is_suffix
|| a_is_spectype
7313 /* An empty term may appear as the last choice of an
7314 N-way choice set; it means "otherwise". */
7315 a_must_be_last
= true;
7316 disj_matched
= !n_way_matched
;
7317 disj_starred
= false;
7321 if ((a_is_suffix
|| a_is_spectype
) && a_is_starred
)
7325 disj_starred
= false;
7327 /* Don't bother testing this atom if we already have a
7329 if (!disj_matched
&& !n_way_matched
)
7332 /* a_matched is already set by handle_spec_function. */;
7333 else if (a_is_suffix
)
7334 a_matched
= input_suffix_matches (atom
, end_atom
);
7335 else if (a_is_spectype
)
7336 a_matched
= input_spec_matches (atom
, end_atom
);
7338 a_matched
= switch_matches (atom
, end_atom
, a_is_starred
);
7340 if (a_matched
!= a_is_negated
)
7342 disj_matched
= true;
7344 d_end_atom
= end_atom
;
7345 d_esc_buf
= esc_buf
;
7352 /* Found the body, that is, the text to substitute if the
7353 current disjunction matches. */
7354 p
= process_brace_body (p
+ 1, d_atom
, d_end_atom
, disj_starred
,
7355 disj_matched
&& !n_way_matched
);
7359 /* If we have an N-way choice, reset state for the next
7363 n_way_choice
= true;
7364 n_way_matched
|= disj_matched
;
7365 disj_matched
= false;
7366 disj_starred
= true;
7367 d_atom
= d_end_atom
= NULL
;
7376 while (*p
++ != '}');
7379 if (d_esc_buf
&& d_esc_buf
!= esc_buf
)
7387 fatal_error (input_location
, "braced spec %qs is invalid at %qc", orig
, *p
);
7392 /* Subroutine of handle_braces. Scan and process a brace substitution body
7393 (X in the description of %{} syntax). P points one past the colon;
7394 ATOM and END_ATOM bracket the first atom which was found to be true
7395 (present) in the current disjunction; STARRED indicates whether all
7396 the atoms in the current disjunction were starred (for syntax validation);
7397 MATCHED indicates whether the disjunction matched or not, and therefore
7398 whether or not the body is to be processed through do_spec_1 or just
7399 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
7403 process_brace_body (const char *p
, const char *atom
, const char *end_atom
,
7404 int starred
, int matched
)
7406 const char *body
, *end_body
;
7407 unsigned int nesting_level
;
7408 bool have_subst
= false;
7410 /* Locate the closing } or ;, honoring nested braces.
7411 Trim trailing whitespace. */
7420 if (!--nesting_level
)
7423 else if (*p
== ';' && nesting_level
== 1)
7425 else if (*p
== '%' && p
[1] == '*' && nesting_level
== 1)
7427 else if (*p
== '\0')
7433 while (end_body
[-1] == ' ' || end_body
[-1] == '\t')
7436 if (have_subst
&& !starred
)
7441 /* Copy the substitution body to permanent storage and execute it.
7442 If have_subst is false, this is a simple matter of running the
7443 body through do_spec_1... */
7444 char *string
= save_string (body
, end_body
- body
);
7447 if (do_spec_1 (string
, 0, NULL
) < 0)
7455 /* ... but if have_subst is true, we have to process the
7456 body once for each matching switch, with %* set to the
7457 variant part of the switch. */
7458 unsigned int hard_match_len
= end_atom
- atom
;
7461 for (i
= 0; i
< n_switches
; i
++)
7462 if (!strncmp (switches
[i
].part1
, atom
, hard_match_len
)
7463 && check_live_switch (i
, hard_match_len
))
7465 if (do_spec_1 (string
, 0,
7466 &switches
[i
].part1
[hard_match_len
]) < 0)
7471 /* Pass any arguments this switch has. */
7473 suffix_subst
= NULL
;
7482 fatal_error (input_location
, "braced spec body %qs is invalid", body
);
7485 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
7486 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
7487 spec, or -1 if either exact match or %* is used.
7489 A -O switch is obsoleted by a later -O switch. A -f, -g, -m, or -W switch
7490 whose value does not begin with "no-" is obsoleted by the same value
7491 with the "no-", similarly for a switch with the "no-" prefix. */
7494 check_live_switch (int switchnum
, int prefix_length
)
7496 const char *name
= switches
[switchnum
].part1
;
7499 /* If we already processed this switch and determined if it was
7500 live or not, return our past determination. */
7501 if (switches
[switchnum
].live_cond
!= 0)
7502 return ((switches
[switchnum
].live_cond
& SWITCH_LIVE
) != 0
7503 && (switches
[switchnum
].live_cond
& SWITCH_FALSE
) == 0
7504 && (switches
[switchnum
].live_cond
& SWITCH_IGNORE_PERMANENTLY
)
7507 /* In the common case of {<at-most-one-letter>*}, a negating
7508 switch would always match, so ignore that case. We will just
7509 send the conflicting switches to the compiler phase. */
7510 if (prefix_length
>= 0 && prefix_length
<= 1)
7513 /* Now search for duplicate in a manner that depends on the name. */
7517 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
7518 if (switches
[i
].part1
[0] == 'O')
7520 switches
[switchnum
].validated
= true;
7521 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
7526 case 'W': case 'f': case 'm': case 'g':
7527 if (startswith (name
+ 1, "no-"))
7529 /* We have Xno-YYY, search for XYYY. */
7530 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
7531 if (switches
[i
].part1
[0] == name
[0]
7532 && ! strcmp (&switches
[i
].part1
[1], &name
[4]))
7534 /* --specs are validated with the validate_switches mechanism. */
7535 if (switches
[switchnum
].known
)
7536 switches
[switchnum
].validated
= true;
7537 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
7543 /* We have XYYY, search for Xno-YYY. */
7544 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
7545 if (switches
[i
].part1
[0] == name
[0]
7546 && switches
[i
].part1
[1] == 'n'
7547 && switches
[i
].part1
[2] == 'o'
7548 && switches
[i
].part1
[3] == '-'
7549 && !strcmp (&switches
[i
].part1
[4], &name
[1]))
7551 /* --specs are validated with the validate_switches mechanism. */
7552 if (switches
[switchnum
].known
)
7553 switches
[switchnum
].validated
= true;
7554 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
7561 /* Otherwise the switch is live. */
7562 switches
[switchnum
].live_cond
|= SWITCH_LIVE
;
7566 /* Pass a switch to the current accumulating command
7567 in the same form that we received it.
7568 SWITCHNUM identifies the switch; it is an index into
7569 the vector of switches gcc received, which is `switches'.
7570 This cannot fail since it never finishes a command line.
7572 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
7575 give_switch (int switchnum
, int omit_first_word
)
7577 if ((switches
[switchnum
].live_cond
& SWITCH_IGNORE
) != 0)
7580 if (!omit_first_word
)
7582 do_spec_1 ("-", 0, NULL
);
7583 do_spec_1 (switches
[switchnum
].part1
, 1, NULL
);
7586 if (switches
[switchnum
].args
!= 0)
7589 for (p
= switches
[switchnum
].args
; *p
; p
++)
7591 const char *arg
= *p
;
7593 do_spec_1 (" ", 0, NULL
);
7596 unsigned length
= strlen (arg
);
7599 while (length
-- && !IS_DIR_SEPARATOR (arg
[length
]))
7600 if (arg
[length
] == '.')
7602 (CONST_CAST (char *, arg
))[length
] = 0;
7606 do_spec_1 (arg
, 1, NULL
);
7608 (CONST_CAST (char *, arg
))[length
] = '.';
7609 do_spec_1 (suffix_subst
, 1, NULL
);
7612 do_spec_1 (arg
, 1, NULL
);
7616 do_spec_1 (" ", 0, NULL
);
7617 switches
[switchnum
].validated
= true;
7620 /* Print GCC configuration (e.g. version, thread model, target,
7621 configuration_arguments) to a given FILE. */
7624 print_configuration (FILE *file
)
7629 fnotice (file
, "Target: %s\n", spec_machine
);
7630 fnotice (file
, "Configured with: %s\n", configuration_arguments
);
7632 #ifdef THREAD_MODEL_SPEC
7633 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
7634 but there's no point in doing all this processing just to get
7635 thread_model back. */
7636 obstack_init (&obstack
);
7637 do_spec_1 (THREAD_MODEL_SPEC
, 0, thread_model
);
7638 obstack_1grow (&obstack
, '\0');
7639 thrmod
= XOBFINISH (&obstack
, const char *);
7641 thrmod
= thread_model
;
7644 fnotice (file
, "Thread model: %s\n", thrmod
);
7645 fnotice (file
, "Supported LTO compression algorithms: zlib");
7647 fnotice (file
, " zstd");
7649 fnotice (file
, "\n");
7651 /* compiler_version is truncated at the first space when initialized
7652 from version string, so truncate version_string at the first space
7653 before comparing. */
7654 for (n
= 0; version_string
[n
]; n
++)
7655 if (version_string
[n
] == ' ')
7658 if (! strncmp (version_string
, compiler_version
, n
)
7659 && compiler_version
[n
] == 0)
7660 fnotice (file
, "gcc version %s %s\n", version_string
,
7663 fnotice (file
, "gcc driver version %s %sexecuting gcc version %s\n",
7664 version_string
, pkgversion_string
, compiler_version
);
7668 #define RETRY_ICE_ATTEMPTS 3
7670 /* Returns true if FILE1 and FILE2 contain equivalent data, 0 otherwise. */
7673 files_equal_p (char *file1
, char *file2
)
7675 struct stat st1
, st2
;
7678 const int bufsize
= 8192;
7679 char *buf
= XNEWVEC (char, bufsize
);
7681 fd1
= open (file1
, O_RDONLY
);
7682 fd2
= open (file2
, O_RDONLY
);
7684 if (fd1
< 0 || fd2
< 0)
7687 if (fstat (fd1
, &st1
) < 0 || fstat (fd2
, &st2
) < 0)
7690 if (st1
.st_size
!= st2
.st_size
)
7693 for (n
= st1
.st_size
; n
; n
-= len
)
7696 if ((int) len
> bufsize
/ 2)
7699 if (read (fd1
, buf
, len
) != (int) len
7700 || read (fd2
, buf
+ bufsize
/ 2, len
) != (int) len
)
7705 if (memcmp (buf
, buf
+ bufsize
/ 2, len
) != 0)
7722 /* Check that compiler's output doesn't differ across runs.
7723 TEMP_STDOUT_FILES and TEMP_STDERR_FILES are arrays of files, containing
7724 stdout and stderr for each compiler run. Return true if all of
7725 TEMP_STDOUT_FILES and TEMP_STDERR_FILES are equivalent. */
7728 check_repro (char **temp_stdout_files
, char **temp_stderr_files
)
7731 for (i
= 0; i
< RETRY_ICE_ATTEMPTS
- 2; ++i
)
7733 if (!files_equal_p (temp_stdout_files
[i
], temp_stdout_files
[i
+ 1])
7734 || !files_equal_p (temp_stderr_files
[i
], temp_stderr_files
[i
+ 1]))
7736 fnotice (stderr
, "The bug is not reproducible, so it is"
7737 " likely a hardware or OS problem.\n");
7741 return i
== RETRY_ICE_ATTEMPTS
- 2;
7744 enum attempt_status
{
7745 ATTEMPT_STATUS_FAIL_TO_RUN
,
7746 ATTEMPT_STATUS_SUCCESS
,
7751 /* Run compiler with arguments NEW_ARGV to reproduce the ICE, storing stdout
7752 to OUT_TEMP and stderr to ERR_TEMP. If APPEND is TRUE, append to OUT_TEMP
7753 and ERR_TEMP instead of truncating. If EMIT_SYSTEM_INFO is TRUE, also write
7754 GCC configuration into to ERR_TEMP. Return ATTEMPT_STATUS_FAIL_TO_RUN if
7755 compiler failed to run, ATTEMPT_STATUS_ICE if compiled ICE-ed and
7756 ATTEMPT_STATUS_SUCCESS otherwise. */
7758 static enum attempt_status
7759 run_attempt (const char **new_argv
, const char *out_temp
,
7760 const char *err_temp
, int emit_system_info
, int append
)
7763 if (emit_system_info
)
7765 FILE *file_out
= fopen (err_temp
, "a");
7766 print_configuration (file_out
);
7767 fputs ("\n", file_out
);
7773 struct pex_obj
*pex
;
7775 int pex_flags
= PEX_USE_PIPES
| PEX_LAST
;
7776 enum attempt_status status
= ATTEMPT_STATUS_FAIL_TO_RUN
;
7779 pex_flags
|= PEX_STDOUT_APPEND
| PEX_STDERR_APPEND
;
7781 pex
= pex_init (PEX_USE_PIPES
, new_argv
[0], NULL
);
7783 fatal_error (input_location
, "%<pex_init%> failed: %m");
7785 errmsg
= pex_run (pex
, pex_flags
, new_argv
[0],
7786 CONST_CAST2 (char *const *, const char **, &new_argv
[1]),
7787 out_temp
, err_temp
, &err
);
7791 fatal_error (input_location
,
7792 err
? G_ ("cannot execute %qs: %s: %m")
7793 : G_ ("cannot execute %qs: %s"),
7794 new_argv
[0], errmsg
);
7797 if (!pex_get_status (pex
, 1, &exit_status
))
7800 switch (WEXITSTATUS (exit_status
))
7803 status
= ATTEMPT_STATUS_ICE
;
7806 case SUCCESS_EXIT_CODE
:
7807 status
= ATTEMPT_STATUS_SUCCESS
;
7819 /* This routine reads lines from IN file, adds C++ style comments
7820 at the begining of each line and writes result into OUT. */
7823 insert_comments (const char *file_in
, const char *file_out
)
7825 FILE *in
= fopen (file_in
, "rb");
7826 FILE *out
= fopen (file_out
, "wb");
7829 bool add_comment
= true;
7830 while (fgets (line
, sizeof (line
), in
))
7835 add_comment
= strchr (line
, '\n') != NULL
;
7842 /* This routine adds preprocessed source code into the given ERR_FILE.
7843 To do this, it adds "-E" to NEW_ARGV and execute RUN_ATTEMPT routine to
7844 add information in report file. RUN_ATTEMPT should return
7845 ATTEMPT_STATUS_SUCCESS, in other case we cannot generate the report. */
7848 do_report_bug (const char **new_argv
, const int nargs
,
7849 char **out_file
, char **err_file
)
7852 int fd
= open (*out_file
, O_RDWR
| O_APPEND
);
7855 write (fd
, "\n//", 3);
7856 for (i
= 0; i
< nargs
; i
++)
7859 write (fd
, new_argv
[i
], strlen (new_argv
[i
]));
7861 write (fd
, "\n\n", 2);
7863 new_argv
[nargs
] = "-E";
7864 new_argv
[nargs
+ 1] = NULL
;
7866 status
= run_attempt (new_argv
, *out_file
, *err_file
, 0, 1);
7868 if (status
== ATTEMPT_STATUS_SUCCESS
)
7870 fnotice (stderr
, "Preprocessed source stored into %s file,"
7871 " please attach this to your bugreport.\n", *out_file
);
7872 /* Make sure it is not deleted. */
7878 /* Try to reproduce ICE. If bug is reproducible, generate report .err file
7879 containing GCC configuration, backtrace, compiler's command line options
7880 and preprocessed source code. */
7883 try_generate_repro (const char **argv
)
7885 int i
, nargs
, out_arg
= -1, quiet
= 0, attempt
;
7886 const char **new_argv
;
7887 char *temp_files
[RETRY_ICE_ATTEMPTS
* 2];
7888 char **temp_stdout_files
= &temp_files
[0];
7889 char **temp_stderr_files
= &temp_files
[RETRY_ICE_ATTEMPTS
];
7891 if (gcc_input_filename
== NULL
|| ! strcmp (gcc_input_filename
, "-"))
7894 for (nargs
= 0; argv
[nargs
] != NULL
; ++nargs
)
7895 /* Only retry compiler ICEs, not preprocessor ones. */
7896 if (! strcmp (argv
[nargs
], "-E"))
7898 else if (argv
[nargs
][0] == '-' && argv
[nargs
][1] == 'o')
7905 /* If the compiler is going to output any time information,
7906 it might varry between invocations. */
7907 else if (! strcmp (argv
[nargs
], "-quiet"))
7909 else if (! strcmp (argv
[nargs
], "-ftime-report"))
7912 if (out_arg
== -1 || !quiet
)
7915 memset (temp_files
, '\0', sizeof (temp_files
));
7916 new_argv
= XALLOCAVEC (const char *, nargs
+ 4);
7917 memcpy (new_argv
, argv
, (nargs
+ 1) * sizeof (const char *));
7918 new_argv
[nargs
++] = "-frandom-seed=0";
7919 new_argv
[nargs
++] = "-fdump-noaddr";
7920 new_argv
[nargs
] = NULL
;
7921 if (new_argv
[out_arg
][2] == '\0')
7922 new_argv
[out_arg
+ 1] = "-";
7924 new_argv
[out_arg
] = "-o-";
7927 for (attempt
= 0; attempt
< RETRY_ICE_ATTEMPTS
; ++attempt
)
7929 int emit_system_info
= 0;
7931 temp_stdout_files
[attempt
] = make_temp_file (".out");
7932 temp_stderr_files
[attempt
] = make_temp_file (".err");
7934 if (attempt
== RETRY_ICE_ATTEMPTS
- 1)
7937 emit_system_info
= 1;
7940 status
= run_attempt (new_argv
, temp_stdout_files
[attempt
],
7941 temp_stderr_files
[attempt
], emit_system_info
,
7944 if (status
!= ATTEMPT_STATUS_ICE
)
7946 fnotice (stderr
, "The bug is not reproducible, so it is"
7947 " likely a hardware or OS problem.\n");
7952 if (!check_repro (temp_stdout_files
, temp_stderr_files
))
7956 /* Insert commented out backtrace into report file. */
7957 char **stderr_commented
= &temp_stdout_files
[RETRY_ICE_ATTEMPTS
- 1];
7958 insert_comments (temp_stderr_files
[RETRY_ICE_ATTEMPTS
- 1],
7961 /* In final attempt we append compiler options and preprocesssed code to last
7962 generated .out file with configuration and backtrace. */
7963 char **err
= &temp_stderr_files
[RETRY_ICE_ATTEMPTS
- 1];
7964 do_report_bug (new_argv
, nargs
, stderr_commented
, err
);
7968 for (i
= 0; i
< RETRY_ICE_ATTEMPTS
* 2; i
++)
7971 unlink (temp_stdout_files
[i
]);
7972 free (temp_stdout_files
[i
]);
7976 /* Search for a file named NAME trying various prefixes including the
7977 user's -B prefix and some standard ones.
7978 Return the absolute file name found. If nothing is found, return NAME. */
7981 find_file (const char *name
)
7983 char *newname
= find_a_file (&startfile_prefixes
, name
, R_OK
, true);
7984 return newname
? newname
: name
;
7987 /* Determine whether a directory exists. If LINKER, return 0 for
7988 certain fixed names not needed by the linker. */
7991 is_directory (const char *path1
, bool linker
)
7998 /* Ensure the string ends with "/.". The resulting path will be a
7999 directory even if the given path is a symbolic link. */
8000 len1
= strlen (path1
);
8001 path
= (char *) alloca (3 + len1
);
8002 memcpy (path
, path1
, len1
);
8004 if (!IS_DIR_SEPARATOR (cp
[-1]))
8005 *cp
++ = DIR_SEPARATOR
;
8009 /* Exclude directories that the linker is known to search. */
8011 && IS_DIR_SEPARATOR (path
[0])
8013 && filename_ncmp (path
+ 1, "lib", 3) == 0)
8015 && filename_ncmp (path
+ 1, "usr", 3) == 0
8016 && IS_DIR_SEPARATOR (path
[4])
8017 && filename_ncmp (path
+ 5, "lib", 3) == 0)))
8020 return (stat (path
, &st
) >= 0 && S_ISDIR (st
.st_mode
));
8023 /* Set up the various global variables to indicate that we're processing
8024 the input file named FILENAME. */
8027 set_input (const char *filename
)
8031 gcc_input_filename
= filename
;
8032 input_filename_length
= strlen (gcc_input_filename
);
8033 input_basename
= lbasename (gcc_input_filename
);
8035 /* Find a suffix starting with the last period,
8036 and set basename_length to exclude that suffix. */
8037 basename_length
= strlen (input_basename
);
8038 suffixed_basename_length
= basename_length
;
8039 p
= input_basename
+ basename_length
;
8040 while (p
!= input_basename
&& *p
!= '.')
8042 if (*p
== '.' && p
!= input_basename
)
8044 basename_length
= p
- input_basename
;
8045 input_suffix
= p
+ 1;
8050 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
8051 we will need to do a stat on the gcc_input_filename. The
8052 INPUT_STAT_SET signals that the stat is needed. */
8056 /* On fatal signals, delete all the temporary files. */
8059 fatal_signal (int signum
)
8061 signal (signum
, SIG_DFL
);
8062 delete_failure_queue ();
8063 delete_temp_files ();
8064 /* Get the same signal again, this time not handled,
8065 so its normal effect occurs. */
8066 kill (getpid (), signum
);
8069 /* Compare the contents of the two files named CMPFILE[0] and
8070 CMPFILE[1]. Return zero if they're identical, nonzero
8074 compare_files (char *cmpfile
[])
8077 FILE *temp
[2] = { NULL
, NULL
};
8083 void *map
[2] = { NULL
, NULL
};
8085 for (i
= 0; i
< 2; i
++)
8089 if (stat (cmpfile
[i
], &st
) < 0 || !S_ISREG (st
.st_mode
))
8091 error ("%s: could not determine length of compare-debug file %s",
8092 gcc_input_filename
, cmpfile
[i
]);
8097 length
[i
] = st
.st_size
;
8100 if (!ret
&& length
[0] != length
[1])
8102 error ("%s: %<-fcompare-debug%> failure (length)", gcc_input_filename
);
8107 for (i
= 0; i
< 2; i
++)
8109 int fd
= open (cmpfile
[i
], O_RDONLY
);
8112 error ("%s: could not open compare-debug file %s",
8113 gcc_input_filename
, cmpfile
[i
]);
8118 map
[i
] = mmap (NULL
, length
[i
], PROT_READ
, MAP_PRIVATE
, fd
, 0);
8121 if (map
[i
] == (void *) MAP_FAILED
)
8130 if (memcmp (map
[0], map
[1], length
[0]) != 0)
8132 error ("%s: %<-fcompare-debug%> failure", gcc_input_filename
);
8137 for (i
= 0; i
< 2; i
++)
8139 munmap ((caddr_t
) map
[i
], length
[i
]);
8148 for (i
= 0; i
< 2; i
++)
8150 temp
[i
] = fopen (cmpfile
[i
], "r");
8153 error ("%s: could not open compare-debug file %s",
8154 gcc_input_filename
, cmpfile
[i
]);
8160 if (!ret
&& temp
[0] && temp
[1])
8164 c0
= fgetc (temp
[0]);
8165 c1
= fgetc (temp
[1]);
8169 error ("%s: %<-fcompare-debug%> failure",
8170 gcc_input_filename
);
8179 for (i
= 1; i
>= 0; i
--)
8188 driver::driver (bool can_finalize
, bool debug
) :
8189 explicit_link_files (NULL
),
8190 decoded_options (NULL
)
8192 env
.init (can_finalize
, debug
);
8197 XDELETEVEC (explicit_link_files
);
8198 XDELETEVEC (decoded_options
);
8201 /* driver::main is implemented as a series of driver:: method calls. */
8204 driver::main (int argc
, char **argv
)
8208 set_progname (argv
[0]);
8209 expand_at_files (&argc
, &argv
);
8210 decode_argv (argc
, const_cast <const char **> (argv
));
8211 global_initializations ();
8212 build_multilib_strings ();
8214 putenv_COLLECT_AS_OPTIONS (assembler_options
);
8215 putenv_COLLECT_GCC (argv
[0]);
8216 maybe_putenv_COLLECT_LTO_WRAPPER ();
8217 maybe_putenv_OFFLOAD_TARGETS ();
8218 handle_unrecognized_options ();
8222 m_option_proposer
.suggest_completion (completion
);
8226 if (!maybe_print_and_exit ())
8229 early_exit
= prepare_infiles ();
8231 return get_exit_code ();
8233 do_spec_on_infiles ();
8234 maybe_run_linker (argv
[0]);
8236 return get_exit_code ();
8239 /* Locate the final component of argv[0] after any leading path, and set
8240 the program name accordingly. */
8243 driver::set_progname (const char *argv0
) const
8245 const char *p
= argv0
+ strlen (argv0
);
8246 while (p
!= argv0
&& !IS_DIR_SEPARATOR (p
[-1]))
8250 xmalloc_set_program_name (progname
);
8253 /* Expand any @ files within the command-line args,
8254 setting at_file_supplied if any were expanded. */
8257 driver::expand_at_files (int *argc
, char ***argv
) const
8259 char **old_argv
= *argv
;
8261 expandargv (argc
, argv
);
8263 /* Determine if any expansions were made. */
8264 if (*argv
!= old_argv
)
8265 at_file_supplied
= true;
8268 /* Decode the command-line arguments from argc/argv into the
8269 decoded_options array. */
8272 driver::decode_argv (int argc
, const char **argv
)
8274 init_opts_obstack ();
8275 init_options_struct (&global_options
, &global_options_set
);
8277 decode_cmdline_options_to_array (argc
, argv
,
8279 &decoded_options
, &decoded_options_count
);
8282 /* Perform various initializations and setup. */
8285 driver::global_initializations ()
8287 /* Unlock the stdio streams. */
8288 unlock_std_streams ();
8290 gcc_init_libintl ();
8292 diagnostic_initialize (global_dc
, 0);
8293 diagnostic_color_init (global_dc
);
8294 diagnostic_urls_init (global_dc
);
8295 global_dc
->set_urlifier (make_gcc_urlifier ());
8297 #ifdef GCC_DRIVER_HOST_INITIALIZATION
8298 /* Perform host dependent initialization when needed. */
8299 GCC_DRIVER_HOST_INITIALIZATION
;
8302 if (atexit (delete_temp_files
) != 0)
8303 fatal_error (input_location
, "atexit failed");
8305 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
8306 signal (SIGINT
, fatal_signal
);
8308 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
8309 signal (SIGHUP
, fatal_signal
);
8311 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
8312 signal (SIGTERM
, fatal_signal
);
8314 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
8315 signal (SIGPIPE
, fatal_signal
);
8318 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
8319 receive the signal. A different setting is inheritable */
8320 signal (SIGCHLD
, SIG_DFL
);
8323 /* Parsing and gimplification sometimes need quite large stack.
8324 Increase stack size limits if possible. */
8325 stack_limit_increase (64 * 1024 * 1024);
8327 /* Allocate the argument vector. */
8330 obstack_init (&obstack
);
8333 /* Build multilib_select, et. al from the separate lines that make up each
8334 multilib selection. */
8337 driver::build_multilib_strings () const
8341 const char *const *q
= multilib_raw
;
8344 obstack_init (&multilib_obstack
);
8345 while ((p
= *q
++) != (char *) 0)
8346 obstack_grow (&multilib_obstack
, p
, strlen (p
));
8348 obstack_1grow (&multilib_obstack
, 0);
8349 multilib_select
= XOBFINISH (&multilib_obstack
, const char *);
8351 q
= multilib_matches_raw
;
8352 while ((p
= *q
++) != (char *) 0)
8353 obstack_grow (&multilib_obstack
, p
, strlen (p
));
8355 obstack_1grow (&multilib_obstack
, 0);
8356 multilib_matches
= XOBFINISH (&multilib_obstack
, const char *);
8358 q
= multilib_exclusions_raw
;
8359 while ((p
= *q
++) != (char *) 0)
8360 obstack_grow (&multilib_obstack
, p
, strlen (p
));
8362 obstack_1grow (&multilib_obstack
, 0);
8363 multilib_exclusions
= XOBFINISH (&multilib_obstack
, const char *);
8365 q
= multilib_reuse_raw
;
8366 while ((p
= *q
++) != (char *) 0)
8367 obstack_grow (&multilib_obstack
, p
, strlen (p
));
8369 obstack_1grow (&multilib_obstack
, 0);
8370 multilib_reuse
= XOBFINISH (&multilib_obstack
, const char *);
8373 for (size_t i
= 0; i
< ARRAY_SIZE (multilib_defaults_raw
); i
++)
8376 obstack_1grow (&multilib_obstack
, ' ');
8377 obstack_grow (&multilib_obstack
,
8378 multilib_defaults_raw
[i
],
8379 strlen (multilib_defaults_raw
[i
]));
8383 obstack_1grow (&multilib_obstack
, 0);
8384 multilib_defaults
= XOBFINISH (&multilib_obstack
, const char *);
8388 /* Set up the spec-handling machinery. */
8391 driver::set_up_specs () const
8393 const char *spec_machine_suffix
;
8397 #ifdef INIT_ENVIRONMENT
8398 /* Set up any other necessary machine specific environment variables. */
8399 xputenv (INIT_ENVIRONMENT
);
8402 /* Make a table of what switches there are (switches, n_switches).
8403 Make a table of specified input files (infiles, n_infiles).
8404 Decode switches that are handled locally. */
8406 process_command (decoded_options_count
, decoded_options
);
8408 /* Initialize the vector of specs to just the default.
8409 This means one element containing 0s, as a terminator. */
8411 compilers
= XNEWVAR (struct compiler
, sizeof default_compilers
);
8412 memcpy (compilers
, default_compilers
, sizeof default_compilers
);
8413 n_compilers
= n_default_compilers
;
8415 /* Read specs from a file if there is one. */
8417 machine_suffix
= concat (spec_host_machine
, dir_separator_str
, spec_version
,
8418 accel_dir_suffix
, dir_separator_str
, NULL
);
8419 just_machine_suffix
= concat (spec_machine
, dir_separator_str
, NULL
);
8421 specs_file
= find_a_file (&startfile_prefixes
, "specs", R_OK
, true);
8422 /* Read the specs file unless it is a default one. */
8423 if (specs_file
!= 0 && strcmp (specs_file
, "specs"))
8424 read_specs (specs_file
, true, false);
8428 #ifdef ACCEL_COMPILER
8429 spec_machine_suffix
= machine_suffix
;
8431 spec_machine_suffix
= just_machine_suffix
;
8434 /* We need to check standard_exec_prefix/spec_machine_suffix/specs
8435 for any override of as, ld and libraries. */
8436 specs_file
= (char *) alloca (strlen (standard_exec_prefix
)
8437 + strlen (spec_machine_suffix
) + sizeof ("specs"));
8438 strcpy (specs_file
, standard_exec_prefix
);
8439 strcat (specs_file
, spec_machine_suffix
);
8440 strcat (specs_file
, "specs");
8441 if (access (specs_file
, R_OK
) == 0)
8442 read_specs (specs_file
, true, false);
8444 /* Process any configure-time defaults specified for the command line
8445 options, via OPTION_DEFAULT_SPECS. */
8446 for (i
= 0; i
< ARRAY_SIZE (option_default_specs
); i
++)
8447 do_option_spec (option_default_specs
[i
].name
,
8448 option_default_specs
[i
].spec
);
8450 /* Process DRIVER_SELF_SPECS, adding any new options to the end
8451 of the command line. */
8453 for (i
= 0; i
< ARRAY_SIZE (driver_self_specs
); i
++)
8454 do_self_spec (driver_self_specs
[i
]);
8456 /* If not cross-compiling, look for executables in the standard
8458 if (*cross_compile
== '0')
8460 if (*md_exec_prefix
)
8462 add_prefix (&exec_prefixes
, md_exec_prefix
, "GCC",
8463 PREFIX_PRIORITY_LAST
, 0, 0);
8467 /* Process sysroot_suffix_spec. */
8468 if (*sysroot_suffix_spec
!= 0
8469 && !no_sysroot_suffix
8470 && do_spec_2 (sysroot_suffix_spec
, NULL
) == 0)
8472 if (argbuf
.length () > 1)
8473 error ("spec failure: more than one argument to "
8474 "%<SYSROOT_SUFFIX_SPEC%>");
8475 else if (argbuf
.length () == 1)
8476 target_sysroot_suffix
= xstrdup (argbuf
.last ());
8479 #ifdef HAVE_LD_SYSROOT
8480 /* Pass the --sysroot option to the linker, if it supports that. If
8481 there is a sysroot_suffix_spec, it has already been processed by
8482 this point, so target_system_root really is the system root we
8484 if (target_system_root
)
8486 obstack_grow (&obstack
, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
8487 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
8488 set_spec ("link", XOBFINISH (&obstack
, const char *), false);
8492 /* Process sysroot_hdrs_suffix_spec. */
8493 if (*sysroot_hdrs_suffix_spec
!= 0
8494 && !no_sysroot_suffix
8495 && do_spec_2 (sysroot_hdrs_suffix_spec
, NULL
) == 0)
8497 if (argbuf
.length () > 1)
8498 error ("spec failure: more than one argument "
8499 "to %<SYSROOT_HEADERS_SUFFIX_SPEC%>");
8500 else if (argbuf
.length () == 1)
8501 target_sysroot_hdrs_suffix
= xstrdup (argbuf
.last ());
8504 /* Look for startfiles in the standard places. */
8505 if (*startfile_prefix_spec
!= 0
8506 && do_spec_2 (startfile_prefix_spec
, NULL
) == 0
8507 && do_spec_1 (" ", 0, NULL
) == 0)
8509 for (const char *arg
: argbuf
)
8510 add_sysrooted_prefix (&startfile_prefixes
, arg
, "BINUTILS",
8511 PREFIX_PRIORITY_LAST
, 0, 1);
8513 /* We should eventually get rid of all these and stick to
8514 startfile_prefix_spec exclusively. */
8515 else if (*cross_compile
== '0' || target_system_root
)
8517 if (*md_startfile_prefix
)
8518 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix
,
8519 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
8521 if (*md_startfile_prefix_1
)
8522 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix_1
,
8523 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
8525 /* If standard_startfile_prefix is relative, base it on
8526 standard_exec_prefix. This lets us move the installed tree
8527 as a unit. If GCC_EXEC_PREFIX is defined, base
8528 standard_startfile_prefix on that as well.
8530 If the prefix is relative, only search it for native compilers;
8531 otherwise we will search a directory containing host libraries. */
8532 if (IS_ABSOLUTE_PATH (standard_startfile_prefix
))
8533 add_sysrooted_prefix (&startfile_prefixes
,
8534 standard_startfile_prefix
, "BINUTILS",
8535 PREFIX_PRIORITY_LAST
, 0, 1);
8536 else if (*cross_compile
== '0')
8538 add_prefix (&startfile_prefixes
,
8539 concat (gcc_exec_prefix
8540 ? gcc_exec_prefix
: standard_exec_prefix
,
8542 standard_startfile_prefix
, NULL
),
8543 NULL
, PREFIX_PRIORITY_LAST
, 0, 1);
8546 /* Sysrooted prefixes are relocated because target_system_root is
8547 also relocated by gcc_exec_prefix. */
8548 if (*standard_startfile_prefix_1
)
8549 add_sysrooted_prefix (&startfile_prefixes
,
8550 standard_startfile_prefix_1
, "BINUTILS",
8551 PREFIX_PRIORITY_LAST
, 0, 1);
8552 if (*standard_startfile_prefix_2
)
8553 add_sysrooted_prefix (&startfile_prefixes
,
8554 standard_startfile_prefix_2
, "BINUTILS",
8555 PREFIX_PRIORITY_LAST
, 0, 1);
8558 /* Process any user specified specs in the order given on the command
8560 for (struct user_specs
*uptr
= user_specs_head
; uptr
; uptr
= uptr
->next
)
8562 char *filename
= find_a_file (&startfile_prefixes
, uptr
->filename
,
8564 read_specs (filename
? filename
: uptr
->filename
, false, true);
8567 /* Process any user self specs. */
8569 struct spec_list
*sl
;
8570 for (sl
= specs
; sl
; sl
= sl
->next
)
8571 if (sl
->name_len
== sizeof "self_spec" - 1
8572 && !strcmp (sl
->name
, "self_spec"))
8573 do_self_spec (*sl
->ptr_spec
);
8578 enum save_temps save
;
8580 if (!compare_debug_second
)
8582 n_switches_debug_check
[1] = n_switches
;
8583 n_switches_alloc_debug_check
[1] = n_switches_alloc
;
8584 switches_debug_check
[1] = XDUPVEC (struct switchstr
, switches
,
8587 do_self_spec ("%:compare-debug-self-opt()");
8588 n_switches_debug_check
[0] = n_switches
;
8589 n_switches_alloc_debug_check
[0] = n_switches_alloc
;
8590 switches_debug_check
[0] = switches
;
8592 n_switches
= n_switches_debug_check
[1];
8593 n_switches_alloc
= n_switches_alloc_debug_check
[1];
8594 switches
= switches_debug_check
[1];
8597 /* Avoid crash when computing %j in this early. */
8598 save
= save_temps_flag
;
8599 save_temps_flag
= SAVE_TEMPS_NONE
;
8601 compare_debug
= -compare_debug
;
8602 do_self_spec ("%:compare-debug-self-opt()");
8604 save_temps_flag
= save
;
8606 if (!compare_debug_second
)
8608 n_switches_debug_check
[1] = n_switches
;
8609 n_switches_alloc_debug_check
[1] = n_switches_alloc
;
8610 switches_debug_check
[1] = switches
;
8611 compare_debug
= -compare_debug
;
8612 n_switches
= n_switches_debug_check
[0];
8613 n_switches_alloc
= n_switches_debug_check
[0];
8614 switches
= switches_debug_check
[0];
8619 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
8620 if (gcc_exec_prefix
)
8621 gcc_exec_prefix
= concat (gcc_exec_prefix
, spec_host_machine
,
8622 dir_separator_str
, spec_version
,
8623 accel_dir_suffix
, dir_separator_str
, NULL
);
8625 /* Now we have the specs.
8626 Set the `valid' bits for switches that match anything in any spec. */
8628 validate_all_switches ();
8630 /* Now that we have the switches and the specs, set
8631 the subdirectory based on the options. */
8632 set_multilib_dir ();
8635 /* Set up to remember the pathname of gcc and any options
8636 needed for collect. We use argv[0] instead of progname because
8637 we need the complete pathname. */
8640 driver::putenv_COLLECT_GCC (const char *argv0
) const
8642 obstack_init (&collect_obstack
);
8643 obstack_grow (&collect_obstack
, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
8644 obstack_grow (&collect_obstack
, argv0
, strlen (argv0
) + 1);
8645 xputenv (XOBFINISH (&collect_obstack
, char *));
8648 /* Set up to remember the pathname of the lto wrapper. */
8651 driver::maybe_putenv_COLLECT_LTO_WRAPPER () const
8653 char *lto_wrapper_file
;
8656 lto_wrapper_file
= NULL
;
8658 lto_wrapper_file
= find_a_program ("lto-wrapper");
8659 if (lto_wrapper_file
)
8661 lto_wrapper_file
= convert_white_space (lto_wrapper_file
);
8662 set_static_spec_owned (<o_wrapper_spec
, lto_wrapper_file
);
8663 obstack_init (&collect_obstack
);
8664 obstack_grow (&collect_obstack
, "COLLECT_LTO_WRAPPER=",
8665 sizeof ("COLLECT_LTO_WRAPPER=") - 1);
8666 obstack_grow (&collect_obstack
, lto_wrapper_spec
,
8667 strlen (lto_wrapper_spec
) + 1);
8668 xputenv (XOBFINISH (&collect_obstack
, char *));
8673 /* Set up to remember the names of offload targets. */
8676 driver::maybe_putenv_OFFLOAD_TARGETS () const
8678 if (offload_targets
&& offload_targets
[0] != '\0')
8680 obstack_grow (&collect_obstack
, "OFFLOAD_TARGET_NAMES=",
8681 sizeof ("OFFLOAD_TARGET_NAMES=") - 1);
8682 obstack_grow (&collect_obstack
, offload_targets
,
8683 strlen (offload_targets
) + 1);
8684 xputenv (XOBFINISH (&collect_obstack
, char *));
8685 #if OFFLOAD_DEFAULTED
8686 if (offload_targets_default
)
8687 xputenv ("OFFLOAD_TARGET_DEFAULT=1");
8691 free (offload_targets
);
8692 offload_targets
= NULL
;
8695 /* Reject switches that no pass was interested in. */
8698 driver::handle_unrecognized_options ()
8700 for (size_t i
= 0; (int) i
< n_switches
; i
++)
8701 if (! switches
[i
].validated
)
8703 const char *hint
= m_option_proposer
.suggest_option (switches
[i
].part1
);
8705 error ("unrecognized command-line option %<-%s%>;"
8706 " did you mean %<-%s%>?",
8707 switches
[i
].part1
, hint
);
8709 error ("unrecognized command-line option %<-%s%>",
8714 /* Handle the various -print-* options, returning 0 if the driver
8715 should exit, or nonzero if the driver should continue. */
8718 driver::maybe_print_and_exit () const
8720 if (print_search_dirs
)
8722 printf (_("install: %s%s\n"),
8723 gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
8724 gcc_exec_prefix
? "" : machine_suffix
);
8725 printf (_("programs: %s\n"),
8726 build_search_list (&exec_prefixes
, "", false, false));
8727 printf (_("libraries: %s\n"),
8728 build_search_list (&startfile_prefixes
, "", false, true));
8732 if (print_file_name
)
8734 printf ("%s\n", find_file (print_file_name
));
8738 if (print_prog_name
)
8740 if (use_ld
!= NULL
&& ! strcmp (print_prog_name
, "ld"))
8742 /* Append USE_LD to the default linker. */
8743 #ifdef DEFAULT_LINKER
8745 # ifdef HAVE_HOST_EXECUTABLE_SUFFIX
8746 int len
= (sizeof (DEFAULT_LINKER
)
8747 - sizeof (HOST_EXECUTABLE_SUFFIX
));
8751 char *default_linker
= xstrdup (DEFAULT_LINKER
);
8752 /* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains
8753 HOST_EXECUTABLE_SUFFIX. */
8754 if (! strcmp (&default_linker
[len
], HOST_EXECUTABLE_SUFFIX
))
8756 default_linker
[len
] = '\0';
8757 ld
= concat (default_linker
, use_ld
,
8758 HOST_EXECUTABLE_SUFFIX
, NULL
);
8763 ld
= concat (DEFAULT_LINKER
, use_ld
, NULL
);
8764 if (access (ld
, X_OK
) == 0)
8766 printf ("%s\n", ld
);
8770 print_prog_name
= concat (print_prog_name
, use_ld
, NULL
);
8772 char *newname
= find_a_program (print_prog_name
);
8773 printf ("%s\n", (newname
? newname
: print_prog_name
));
8777 if (print_multi_lib
)
8779 print_multilib_info ();
8783 if (print_multi_directory
)
8785 if (multilib_dir
== NULL
)
8788 printf ("%s\n", multilib_dir
);
8792 if (print_multiarch
)
8794 if (multiarch_dir
== NULL
)
8797 printf ("%s\n", multiarch_dir
);
8803 if (target_system_root
)
8805 if (target_sysroot_suffix
)
8806 printf ("%s%s\n", target_system_root
, target_sysroot_suffix
);
8808 printf ("%s\n", target_system_root
);
8813 if (print_multi_os_directory
)
8815 if (multilib_os_dir
== NULL
)
8818 printf ("%s\n", multilib_os_dir
);
8822 if (print_sysroot_headers_suffix
)
8824 if (*sysroot_hdrs_suffix_spec
)
8826 printf("%s\n", (target_sysroot_hdrs_suffix
8827 ? target_sysroot_hdrs_suffix
8832 /* The error status indicates that only one set of fixed
8833 headers should be built. */
8834 fatal_error (input_location
,
8835 "not configured with sysroot headers suffix");
8838 if (print_help_list
)
8844 printf (_("\nFor bug reporting instructions, please see:\n"));
8845 printf ("%s.\n", bug_report_url
);
8850 /* We do not exit here. Instead we have created a fake input file
8851 called 'help-dummy' which needs to be compiled, and we pass this
8852 on the various sub-processes, along with the --help switch.
8853 Ensure their output appears after ours. */
8854 fputc ('\n', stdout
);
8860 printf (_("%s %s%s\n"), progname
, pkgversion_string
,
8862 printf ("Copyright %s 2023 Free Software Foundation, Inc.\n",
8864 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
8865 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
8870 /* We do not exit here. We use the same mechanism of --help to print
8871 the version of the sub-processes. */
8872 fputc ('\n', stdout
);
8878 print_configuration (stderr
);
8886 /* Figure out what to do with each input file.
8887 Return true if we need to exit early from "main", false otherwise. */
8890 driver::prepare_infiles ()
8893 int lang_n_infiles
= 0;
8895 if (n_infiles
== added_libraries
)
8896 fatal_error (input_location
, "no input files");
8899 /* Early exit needed from main. */
8902 /* Make a place to record the compiler output file names
8903 that correspond to the input files. */
8906 i
+= lang_specific_extra_outfiles
;
8907 outfiles
= XCNEWVEC (const char *, i
);
8909 /* Record which files were specified explicitly as link input. */
8911 explicit_link_files
= XCNEWVEC (char, n_infiles
);
8913 combine_inputs
= have_o
|| flag_wpa
;
8915 for (i
= 0; (int) i
< n_infiles
; i
++)
8917 const char *name
= infiles
[i
].name
;
8918 struct compiler
*compiler
= lookup_compiler (name
,
8920 infiles
[i
].language
);
8922 if (compiler
&& !(compiler
->combinable
))
8923 combine_inputs
= false;
8925 if (lang_n_infiles
> 0 && compiler
!= input_file_compiler
8926 && infiles
[i
].language
&& infiles
[i
].language
[0] != '*')
8927 infiles
[i
].incompiler
= compiler
;
8931 input_file_compiler
= compiler
;
8932 infiles
[i
].incompiler
= compiler
;
8936 /* Since there is no compiler for this input file, assume it is a
8938 explicit_link_files
[i
] = 1;
8939 infiles
[i
].incompiler
= NULL
;
8941 infiles
[i
].compiled
= false;
8942 infiles
[i
].preprocessed
= false;
8945 if (!combine_inputs
&& have_c
&& have_o
&& lang_n_infiles
> 1)
8946 fatal_error (input_location
,
8947 "cannot specify %<-o%> with %<-c%>, %<-S%> or %<-E%> "
8948 "with multiple files");
8950 /* No early exit needed from main; we can continue. */
8954 /* Run the spec machinery on each input file. */
8957 driver::do_spec_on_infiles () const
8961 for (i
= 0; (int) i
< n_infiles
; i
++)
8963 int this_file_error
= 0;
8965 /* Tell do_spec what to substitute for %i. */
8967 input_file_number
= i
;
8968 set_input (infiles
[i
].name
);
8970 if (infiles
[i
].compiled
)
8973 /* Use the same thing in %o, unless cp->spec says otherwise. */
8975 outfiles
[i
] = gcc_input_filename
;
8977 /* Figure out which compiler from the file's suffix. */
8980 = lookup_compiler (infiles
[i
].name
, input_filename_length
,
8981 infiles
[i
].language
);
8983 if (input_file_compiler
)
8985 /* Ok, we found an applicable compiler. Run its spec. */
8987 if (input_file_compiler
->spec
[0] == '#')
8989 error ("%s: %s compiler not installed on this system",
8990 gcc_input_filename
, &input_file_compiler
->spec
[1]);
8991 this_file_error
= 1;
8999 free (debug_check_temp_file
[0]);
9000 debug_check_temp_file
[0] = NULL
;
9002 free (debug_check_temp_file
[1]);
9003 debug_check_temp_file
[1] = NULL
;
9006 value
= do_spec (input_file_compiler
->spec
);
9007 infiles
[i
].compiled
= true;
9009 this_file_error
= 1;
9010 else if (compare_debug
&& debug_check_temp_file
[0])
9013 inform (UNKNOWN_LOCATION
,
9014 "recompiling with %<-fcompare-debug%>");
9016 compare_debug
= -compare_debug
;
9017 n_switches
= n_switches_debug_check
[1];
9018 n_switches_alloc
= n_switches_alloc_debug_check
[1];
9019 switches
= switches_debug_check
[1];
9021 value
= do_spec (input_file_compiler
->spec
);
9023 compare_debug
= -compare_debug
;
9024 n_switches
= n_switches_debug_check
[0];
9025 n_switches_alloc
= n_switches_alloc_debug_check
[0];
9026 switches
= switches_debug_check
[0];
9030 error ("during %<-fcompare-debug%> recompilation");
9031 this_file_error
= 1;
9034 gcc_assert (debug_check_temp_file
[1]
9035 && filename_cmp (debug_check_temp_file
[0],
9036 debug_check_temp_file
[1]));
9039 inform (UNKNOWN_LOCATION
, "comparing final insns dumps");
9041 if (compare_files (debug_check_temp_file
))
9042 this_file_error
= 1;
9047 free (debug_check_temp_file
[0]);
9048 debug_check_temp_file
[0] = NULL
;
9050 free (debug_check_temp_file
[1]);
9051 debug_check_temp_file
[1] = NULL
;
9056 /* If this file's name does not contain a recognized suffix,
9057 record it as explicit linker input. */
9060 explicit_link_files
[i
] = 1;
9062 /* Clear the delete-on-failure queue, deleting the files in it
9063 if this compilation failed. */
9065 if (this_file_error
)
9067 delete_failure_queue ();
9070 /* If this compilation succeeded, don't delete those files later. */
9071 clear_failure_queue ();
9074 /* Reset the input file name to the first compile/object file name, for use
9075 with %b in LINK_SPEC. We use the first input file that we can find
9076 a compiler to compile it instead of using infiles.language since for
9077 languages other than C we use aliases that we then lookup later. */
9082 for (i
= 0; i
< n_infiles
; i
++)
9083 if (infiles
[i
].incompiler
9084 || (infiles
[i
].language
&& infiles
[i
].language
[0] != '*'))
9086 set_input (infiles
[i
].name
);
9093 /* Make sure INPUT_FILE_NUMBER points to first available open
9095 input_file_number
= n_infiles
;
9096 if (lang_specific_pre_link ())
9101 /* If we have to run the linker, do it now. */
9104 driver::maybe_run_linker (const char *argv0
) const
9107 int linker_was_run
= 0;
9108 int num_linker_inputs
;
9110 /* Determine if there are any linker input files. */
9111 num_linker_inputs
= 0;
9112 for (i
= 0; (int) i
< n_infiles
; i
++)
9113 if (explicit_link_files
[i
] || outfiles
[i
] != NULL
)
9114 num_linker_inputs
++;
9116 /* Arrange for temporary file names created during linking to take
9117 on names related with the linker output rather than with the
9118 inputs when appropriate. */
9119 if (outbase
&& *outbase
)
9123 char *tofree
= dumpdir
;
9124 gcc_checking_assert (strlen (dumpdir
) == dumpdir_length
);
9125 dumpdir
= concat (dumpdir
, outbase
, ".", NULL
);
9129 dumpdir
= concat (outbase
, ".", NULL
);
9130 dumpdir_length
+= strlen (outbase
) + 1;
9131 dumpdir_trailing_dash_added
= true;
9133 else if (dumpdir_trailing_dash_added
)
9135 gcc_assert (dumpdir
[dumpdir_length
- 1] == '-');
9136 dumpdir
[dumpdir_length
- 1] = '.';
9139 if (dumpdir_trailing_dash_added
)
9141 gcc_assert (dumpdir_length
> 0);
9142 gcc_assert (dumpdir
[dumpdir_length
- 1] == '.');
9147 input_basename
= outbase
= NULL
;
9148 outbase_length
= suffixed_basename_length
= basename_length
= 0;
9150 /* Run ld to link all the compiler output files. */
9152 if (num_linker_inputs
> 0 && !seen_error () && print_subprocess_help
< 2)
9154 int tmp
= execution_count
;
9156 detect_jobserver ();
9160 #if HAVE_LTO_PLUGIN > 0
9161 #if HAVE_LTO_PLUGIN == 2
9162 const char *fno_use_linker_plugin
= "fno-use-linker-plugin";
9164 const char *fuse_linker_plugin
= "fuse-linker-plugin";
9168 /* We'll use ld if we can't find collect2. */
9169 if (! strcmp (linker_name_spec
, "collect2"))
9171 char *s
= find_a_program ("collect2");
9173 set_static_spec_shared (&linker_name_spec
, "ld");
9176 #if HAVE_LTO_PLUGIN > 0
9177 #if HAVE_LTO_PLUGIN == 2
9178 if (!switch_matches (fno_use_linker_plugin
,
9179 fno_use_linker_plugin
9180 + strlen (fno_use_linker_plugin
), 0))
9182 if (switch_matches (fuse_linker_plugin
,
9184 + strlen (fuse_linker_plugin
), 0))
9187 char *temp_spec
= find_a_file (&exec_prefixes
,
9188 LTOPLUGINSONAME
, R_OK
,
9191 fatal_error (input_location
,
9192 "%<-fuse-linker-plugin%>, but %s not found",
9194 linker_plugin_file_spec
= convert_white_space (temp_spec
);
9197 set_static_spec_shared (<o_gcc_spec
, argv0
);
9200 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
9202 putenv_from_prefixes (&exec_prefixes
, "COMPILER_PATH", false);
9203 putenv_from_prefixes (&startfile_prefixes
, LIBRARY_PATH_ENV
, true);
9205 if (print_subprocess_help
== 1)
9207 printf (_("\nLinker options\n==============\n\n"));
9208 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
9209 " to the linker.\n\n"));
9212 int value
= do_spec (link_command_spec
);
9215 linker_was_run
= (tmp
!= execution_count
);
9218 /* If options said don't run linker,
9219 complain about input files to be given to the linker. */
9221 if (! linker_was_run
&& !seen_error ())
9222 for (i
= 0; (int) i
< n_infiles
; i
++)
9223 if (explicit_link_files
[i
]
9224 && !(infiles
[i
].language
&& infiles
[i
].language
[0] == '*'))
9226 warning (0, "%s: linker input file unused because linking not done",
9228 if (access (outfiles
[i
], F_OK
) < 0)
9229 /* This is can be an indication the user specifed an errorneous
9230 separated option value, (or used the wrong prefix for an
9232 error ("%s: linker input file not found: %m", outfiles
[i
]);
9236 /* The end of "main". */
9239 driver::final_actions () const
9241 /* Delete some or all of the temporary files we made. */
9244 delete_failure_queue ();
9245 delete_temp_files ();
9247 if (print_help_list
)
9249 printf (("\nFor bug reporting instructions, please see:\n"));
9250 printf ("%s\n", bug_report_url
);
9254 /* Detect whether jobserver is active and working. If not drop
9255 --jobserver-auth from MAKEFLAGS. */
9258 driver::detect_jobserver () const
9260 jobserver_info jinfo
;
9261 if (!jinfo
.is_active
&& !jinfo
.skipped_makeflags
.empty ())
9262 xputenv (xstrdup (jinfo
.skipped_makeflags
.c_str ()));
9265 /* Determine what the exit code of the driver should be. */
9268 driver::get_exit_code () const
9270 return (signal_count
!= 0 ? 2
9271 : seen_error () ? (pass_exit_codes
? greatest_status
: 1)
9275 /* Find the proper compilation spec for the file name NAME,
9276 whose length is LENGTH. LANGUAGE is the specified language,
9277 or 0 if this file is to be passed to the linker. */
9279 static struct compiler
*
9280 lookup_compiler (const char *name
, size_t length
, const char *language
)
9282 struct compiler
*cp
;
9284 /* If this was specified by the user to be a linker input, indicate that. */
9285 if (language
!= 0 && language
[0] == '*')
9288 /* Otherwise, look for the language, if one is spec'd. */
9291 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
9292 if (cp
->suffix
[0] == '@' && !strcmp (cp
->suffix
+ 1, language
))
9294 if (name
!= NULL
&& strcmp (name
, "-") == 0
9295 && (strcmp (cp
->suffix
, "@c-header") == 0
9296 || strcmp (cp
->suffix
, "@c++-header") == 0)
9298 fatal_error (input_location
,
9299 "cannot use %<-%> as input filename for a "
9300 "precompiled header");
9305 error ("language %s not recognized", language
);
9309 /* Look for a suffix. */
9310 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
9312 if (/* The suffix `-' matches only the file name `-'. */
9313 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
9314 || (strlen (cp
->suffix
) < length
9315 /* See if the suffix matches the end of NAME. */
9316 && !strcmp (cp
->suffix
,
9317 name
+ length
- strlen (cp
->suffix
))
9322 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
9323 /* Look again, but case-insensitively this time. */
9325 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
9327 if (/* The suffix `-' matches only the file name `-'. */
9328 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
9329 || (strlen (cp
->suffix
) < length
9330 /* See if the suffix matches the end of NAME. */
9331 && ((!strcmp (cp
->suffix
,
9332 name
+ length
- strlen (cp
->suffix
))
9333 || !strpbrk (cp
->suffix
, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
9334 && !strcasecmp (cp
->suffix
,
9335 name
+ length
- strlen (cp
->suffix
)))
9341 if (cp
>= compilers
)
9343 if (cp
->spec
[0] != '@')
9344 /* A non-alias entry: return it. */
9347 /* An alias entry maps a suffix to a language.
9348 Search for the language; pass 0 for NAME and LENGTH
9349 to avoid infinite recursion if language not found. */
9350 return lookup_compiler (NULL
, 0, cp
->spec
+ 1);
9356 save_string (const char *s
, int len
)
9358 char *result
= XNEWVEC (char, len
+ 1);
9360 gcc_checking_assert (strlen (s
) >= (unsigned int) len
);
9361 memcpy (result
, s
, len
);
9368 validate_switches_from_spec (const char *spec
, bool user
)
9370 const char *p
= spec
;
9376 || (*p
== 'W' && *++p
== '{')
9377 || (*p
== '@' && *++p
== '{')))
9378 /* We have a switch spec. */
9379 p
= validate_switches (p
+ 1, user
, *p
== '{');
9383 validate_all_switches (void)
9385 struct compiler
*comp
;
9386 struct spec_list
*spec
;
9388 for (comp
= compilers
; comp
->spec
; comp
++)
9389 validate_switches_from_spec (comp
->spec
, false);
9391 /* Look through the linked list of specs read from the specs file. */
9392 for (spec
= specs
; spec
; spec
= spec
->next
)
9393 validate_switches_from_spec (*spec
->ptr_spec
, spec
->user_p
);
9395 validate_switches_from_spec (link_command_spec
, false);
9398 /* Look at the switch-name that comes after START and mark as valid
9399 all supplied switches that match it. If BRACED, handle other
9400 switches after '|' and '&', and specs after ':' until ';' or '}',
9401 going back for more switches after ';'. Without BRACED, handle
9402 only one atom. Return a pointer to whatever follows the handled
9403 items, after the closing brace if BRACED. */
9406 validate_switches (const char *start
, bool user_spec
, bool braced
)
9408 const char *p
= start
;
9415 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
9427 if (*p
== '.' || *p
== ',')
9431 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
9432 || *p
== ',' || *p
== '.' || *p
== '@')
9437 starred
= true, p
++;
9443 /* Mark all matching switches as valid. */
9444 for (i
= 0; i
< n_switches
; i
++)
9445 if (!strncmp (switches
[i
].part1
, atom
, len
)
9446 && (starred
|| switches
[i
].part1
[len
] == '\0')
9447 && (switches
[i
].known
|| user_spec
))
9448 switches
[i
].validated
= true;
9455 if (*p
&& (p
[-1] == '|' || p
[-1] == '&'))
9458 if (*p
&& p
[-1] == ':')
9460 while (*p
&& *p
!= ';' && *p
!= '}')
9465 if (*p
== '{' || *p
== '<')
9466 p
= validate_switches (p
+1, user_spec
, *p
== '{');
9467 else if (p
[0] == 'W' && p
[1] == '{')
9468 p
= validate_switches (p
+2, user_spec
, true);
9469 else if (p
[0] == '@' && p
[1] == '{')
9470 p
= validate_switches (p
+2, user_spec
, true);
9477 if (*p
&& p
[-1] == ';')
9491 static struct mdswitchstr
*mdswitches
;
9492 static int n_mdswitches
;
9494 /* Check whether a particular argument was used. The first time we
9495 canonicalize the switches to keep only the ones we care about. */
9500 int operator () (const char *p
, int len
);
9507 const char *replace
;
9512 mswitchstr
*mswitches
;
9517 used_arg_t used_arg
;
9520 used_arg_t::operator () (const char *p
, int len
)
9526 struct mswitchstr
*matches
;
9530 /* Break multilib_matches into the component strings of string
9531 and replacement string. */
9532 for (q
= multilib_matches
; *q
!= '\0'; q
++)
9537 = (struct mswitchstr
*) alloca ((sizeof (struct mswitchstr
)) * cnt
);
9539 q
= multilib_matches
;
9548 fatal_error (input_location
, "multilib spec %qs is invalid",
9553 matches
[i
].len
= q
- matches
[i
].str
;
9555 matches
[i
].replace
= ++q
;
9556 while (*q
!= ';' && *q
!= '\0')
9559 goto invalid_matches
;
9562 matches
[i
].rep_len
= q
- matches
[i
].replace
;
9568 /* Now build a list of the replacement string for switches that we care
9569 about. Make sure we allocate at least one entry. This prevents
9570 xmalloc from calling fatal, and prevents us from re-executing this
9573 = XNEWVEC (struct mswitchstr
, n_mdswitches
+ (n_switches
? n_switches
: 1));
9574 for (i
= 0; i
< n_switches
; i
++)
9575 if ((switches
[i
].live_cond
& SWITCH_IGNORE
) == 0)
9577 int xlen
= strlen (switches
[i
].part1
);
9578 for (j
= 0; j
< cnt
; j
++)
9579 if (xlen
== matches
[j
].len
9580 && ! strncmp (switches
[i
].part1
, matches
[j
].str
, xlen
))
9582 mswitches
[n_mswitches
].str
= matches
[j
].replace
;
9583 mswitches
[n_mswitches
].len
= matches
[j
].rep_len
;
9584 mswitches
[n_mswitches
].replace
= (char *) 0;
9585 mswitches
[n_mswitches
].rep_len
= 0;
9591 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
9592 on the command line nor any options mutually incompatible with
9594 for (i
= 0; i
< n_mdswitches
; i
++)
9598 for (q
= multilib_options
; *q
!= '\0'; *q
&& q
++)
9604 while (strncmp (q
, mdswitches
[i
].str
, mdswitches
[i
].len
) != 0
9605 || strchr (" /", q
[mdswitches
[i
].len
]) == NULL
)
9607 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
9614 if (*q
!= ' ' && *q
!= '\0')
9616 while (*r
!= ' ' && *r
!= '\0')
9619 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
9622 if (used_arg (r
, q
- r
))
9627 mswitches
[n_mswitches
].str
= mdswitches
[i
].str
;
9628 mswitches
[n_mswitches
].len
= mdswitches
[i
].len
;
9629 mswitches
[n_mswitches
].replace
= (char *) 0;
9630 mswitches
[n_mswitches
].rep_len
= 0;
9643 for (i
= 0; i
< n_mswitches
; i
++)
9644 if (len
== mswitches
[i
].len
&& ! strncmp (p
, mswitches
[i
].str
, len
))
9650 void used_arg_t::finalize ()
9652 XDELETEVEC (mswitches
);
9659 default_arg (const char *p
, int len
)
9663 for (i
= 0; i
< n_mdswitches
; i
++)
9664 if (len
== mdswitches
[i
].len
&& ! strncmp (p
, mdswitches
[i
].str
, len
))
9670 /* Work out the subdirectory to use based on the options. The format of
9671 multilib_select is a list of elements. Each element is a subdirectory
9672 name followed by a list of options followed by a semicolon. The format
9673 of multilib_exclusions is the same, but without the preceding
9674 directory. First gcc will check the exclusions, if none of the options
9675 beginning with an exclamation point are present, and all of the other
9676 options are present, then we will ignore this completely. Passing
9677 that, gcc will consider each multilib_select in turn using the same
9678 rules for matching the options. If a match is found, that subdirectory
9680 A subdirectory name is optionally followed by a colon and the corresponding
9684 set_multilib_dir (void)
9687 unsigned int this_path_len
;
9688 const char *this_path
, *this_arg
;
9689 const char *start
, *end
;
9691 int ok
, ndfltok
, first
;
9694 start
= multilib_defaults
;
9695 while (*start
== ' ' || *start
== '\t')
9697 while (*start
!= '\0')
9700 while (*start
!= ' ' && *start
!= '\t' && *start
!= '\0')
9702 while (*start
== ' ' || *start
== '\t')
9710 mdswitches
= XNEWVEC (struct mdswitchstr
, n_mdswitches
);
9711 for (start
= multilib_defaults
; *start
!= '\0'; start
= end
+ 1)
9713 while (*start
== ' ' || *start
== '\t')
9719 for (end
= start
+ 1;
9720 *end
!= ' ' && *end
!= '\t' && *end
!= '\0'; end
++)
9723 obstack_grow (&multilib_obstack
, start
, end
- start
);
9724 obstack_1grow (&multilib_obstack
, 0);
9725 mdswitches
[i
].str
= XOBFINISH (&multilib_obstack
, const char *);
9726 mdswitches
[i
++].len
= end
- start
;
9733 p
= multilib_exclusions
;
9736 /* Ignore newlines. */
9743 /* Check the arguments. */
9750 fatal_error (input_location
, "multilib exclusions %qs is invalid",
9751 multilib_exclusions
);
9761 while (*p
!= ' ' && *p
!= ';')
9764 goto invalid_exclusions
;
9768 if (*this_arg
!= '!')
9776 ok
= used_arg (this_arg
, p
- this_arg
);
9791 p
= multilib_select
;
9793 /* Append multilib reuse rules if any. With those rules, we can reuse
9794 one multilib for certain different options sets. */
9795 if (strlen (multilib_reuse
) > 0)
9796 p
= concat (p
, multilib_reuse
, NULL
);
9800 /* Ignore newlines. */
9807 /* Get the initial path. */
9814 fatal_error (input_location
, "multilib select %qs %qs is invalid",
9815 multilib_select
, multilib_reuse
);
9819 this_path_len
= p
- this_path
;
9821 /* Check the arguments. */
9828 goto invalid_select
;
9837 while (*p
!= ' ' && *p
!= ';')
9840 goto invalid_select
;
9844 if (*this_arg
!= '!')
9852 /* If this is a default argument, we can just ignore it.
9853 This is true even if this_arg begins with '!'. Beginning
9854 with '!' does not mean that this argument is necessarily
9855 inappropriate for this library: it merely means that
9856 there is a more specific library which uses this
9857 argument. If this argument is a default, we need not
9858 consider that more specific library. */
9859 ok
= used_arg (this_arg
, p
- this_arg
);
9866 if (default_arg (this_arg
, p
- this_arg
))
9875 if (this_path_len
!= 1
9876 || this_path
[0] != '.')
9878 char *new_multilib_dir
= XNEWVEC (char, this_path_len
+ 1);
9881 strncpy (new_multilib_dir
, this_path
, this_path_len
);
9882 new_multilib_dir
[this_path_len
] = '\0';
9883 q
= strchr (new_multilib_dir
, ':');
9886 multilib_dir
= new_multilib_dir
;
9893 const char *q
= this_path
, *end
= this_path
+ this_path_len
;
9895 while (q
< end
&& *q
!= ':')
9899 const char *q2
= q
+ 1, *ml_end
= end
;
9900 char *new_multilib_os_dir
;
9902 while (q2
< end
&& *q2
!= ':')
9906 if (ml_end
- q
== 1)
9907 multilib_os_dir
= xstrdup (".");
9910 new_multilib_os_dir
= XNEWVEC (char, ml_end
- q
);
9911 memcpy (new_multilib_os_dir
, q
+ 1, ml_end
- q
- 1);
9912 new_multilib_os_dir
[ml_end
- q
- 1] = '\0';
9913 multilib_os_dir
= new_multilib_os_dir
;
9916 if (q2
< end
&& *q2
== ':')
9918 char *new_multiarch_dir
= XNEWVEC (char, end
- q2
);
9919 memcpy (new_multiarch_dir
, q2
+ 1, end
- q2
- 1);
9920 new_multiarch_dir
[end
- q2
- 1] = '\0';
9921 multiarch_dir
= new_multiarch_dir
;
9931 targetm_common
.compute_multilib (
9938 multilib_exclusions
,
9941 if (multilib_dir
== NULL
&& multilib_os_dir
!= NULL
9942 && strcmp (multilib_os_dir
, ".") == 0)
9944 free (CONST_CAST (char *, multilib_os_dir
));
9945 multilib_os_dir
= NULL
;
9947 else if (multilib_dir
!= NULL
&& multilib_os_dir
== NULL
)
9948 multilib_os_dir
= multilib_dir
;
9951 /* Print out the multiple library subdirectory selection
9952 information. This prints out a series of lines. Each line looks
9953 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
9954 required. Only the desired options are printed out, the negative
9955 matches. The options are print without a leading dash. There are
9956 no spaces to make it easy to use the information in the shell.
9957 Each subdirectory is printed only once. This assumes the ordering
9958 generated by the genmultilib script. Also, we leave out ones that match
9962 print_multilib_info (void)
9964 const char *p
= multilib_select
;
9965 const char *last_path
= 0, *this_path
;
9968 unsigned int last_path_len
= 0;
9973 /* Ignore newlines. */
9980 /* Get the initial path. */
9987 fatal_error (input_location
,
9988 "multilib select %qs is invalid", multilib_select
);
9994 /* When --disable-multilib was used but target defines
9995 MULTILIB_OSDIRNAMES, entries starting with .: (and not starting
9996 with .:: for multiarch configurations) are there just to find
9997 multilib_os_dir, so skip them from output. */
9998 if (this_path
[0] == '.' && this_path
[1] == ':' && this_path
[2] != ':')
10001 /* Check for matches with the multilib_exclusions. We don't bother
10002 with the '!' in either list. If any of the exclusion rules match
10003 all of its options with the select rule, we skip it. */
10005 const char *e
= multilib_exclusions
;
10006 const char *this_arg
;
10011 /* Ignore newlines. */
10018 /* Check the arguments. */
10027 fatal_error (input_location
,
10028 "multilib exclusion %qs is invalid",
10029 multilib_exclusions
);
10040 while (*e
!= ' ' && *e
!= ';')
10043 goto invalid_exclusion
;
10051 int len
= e
- this_arg
;
10054 goto invalid_select
;
10058 while (*q
!= ' ' && *q
!= ';')
10061 goto invalid_select
;
10065 if (! strncmp (arg
, this_arg
,
10066 (len
< q
- arg
) ? q
- arg
: len
)
10067 || default_arg (this_arg
, e
- this_arg
))
10097 /* If this is a duplicate, skip it. */
10098 skip
= (last_path
!= 0
10099 && (unsigned int) (p
- this_path
) == last_path_len
10100 && ! filename_ncmp (last_path
, this_path
, last_path_len
));
10102 last_path
= this_path
;
10103 last_path_len
= p
- this_path
;
10106 /* If all required arguments are default arguments, and no default
10107 arguments appear in the ! argument list, then we can skip it.
10108 We will already have printed a directory identical to this one
10109 which does not require that default argument. */
10113 bool default_arg_ok
= false;
10121 goto invalid_select
;
10132 while (*q
!= ' ' && *q
!= ';')
10135 goto invalid_select
;
10139 if (default_arg (arg
, q
- arg
))
10141 /* Stop checking if any default arguments appeared in not
10145 default_arg_ok
= false;
10149 default_arg_ok
= true;
10153 /* Stop checking if any required argument is not provided by
10154 default arguments. */
10155 default_arg_ok
= false;
10163 /* Make sure all default argument is OK for this multi-lib set. */
10164 if (default_arg_ok
)
10174 for (p1
= last_path
; p1
< p
&& *p1
!= ':'; p1
++)
10185 goto invalid_select
;
10193 use_arg
= *p
!= '!';
10198 while (*p
!= ' ' && *p
!= ';')
10201 goto invalid_select
;
10213 /* If there are extra options, print them now. */
10214 if (multilib_extra
&& *multilib_extra
)
10216 int print_at
= true;
10219 for (q
= multilib_extra
; *q
!= '\0'; q
++)
10240 /* getenv built-in spec function.
10242 Returns the value of the environment variable given by its first argument,
10243 concatenated with the second argument. If the variable is not defined, a
10244 fatal error is issued unless such undefs are internally allowed, in which
10245 case the variable name prefixed by a '/' is used as the variable value.
10247 The leading '/' allows using the result at a spot where a full path would
10248 normally be expected and when the actual value doesn't really matter since
10249 undef vars are allowed. */
10251 static const char *
10252 getenv_spec_function (int argc
, const char **argv
)
10255 const char *varname
;
10265 value
= env
.get (varname
);
10267 /* If the variable isn't defined and this is allowed, craft our expected
10268 return value. Assume variable names used in specs strings don't contain
10269 any active spec character so don't need escaping. */
10270 if (!value
&& spec_undefvar_allowed
)
10272 result
= XNEWVAR (char, strlen(varname
) + 2);
10273 sprintf (result
, "/%s", varname
);
10278 fatal_error (input_location
,
10279 "environment variable %qs not defined", varname
);
10281 /* We have to escape every character of the environment variable so
10282 they are not interpreted as active spec characters. A
10283 particularly painful case is when we are reading a variable
10284 holding a windows path complete with \ separators. */
10285 len
= strlen (value
) * 2 + strlen (argv
[1]) + 1;
10286 result
= XNEWVAR (char, len
);
10287 for (ptr
= result
; *value
; ptr
+= 2)
10293 strcpy (ptr
, argv
[1]);
10298 /* if-exists built-in spec function.
10300 Checks to see if the file specified by the absolute pathname in
10301 ARGS exists. Returns that pathname if found.
10303 The usual use for this function is to check for a library file
10304 (whose name has been expanded with %s). */
10306 static const char *
10307 if_exists_spec_function (int argc
, const char **argv
)
10309 /* Must have only one argument. */
10310 if (argc
== 1 && IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
10316 /* if-exists-else built-in spec function.
10318 This is like if-exists, but takes an additional argument which
10319 is returned if the first argument does not exist. */
10321 static const char *
10322 if_exists_else_spec_function (int argc
, const char **argv
)
10324 /* Must have exactly two arguments. */
10328 if (IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
10334 /* if-exists-then-else built-in spec function.
10336 Checks to see if the file specified by the absolute pathname in
10337 the first arg exists. Returns the second arg if so, otherwise returns
10338 the third arg if it is present. */
10340 static const char *
10341 if_exists_then_else_spec_function (int argc
, const char **argv
)
10344 /* Must have two or three arguments. */
10345 if (argc
!= 2 && argc
!= 3)
10348 if (IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
10357 /* sanitize built-in spec function.
10359 This returns non-NULL, if sanitizing address, thread or
10360 any of the undefined behavior sanitizers. */
10362 static const char *
10363 sanitize_spec_function (int argc
, const char **argv
)
10368 if (strcmp (argv
[0], "address") == 0)
10369 return (flag_sanitize
& SANITIZE_USER_ADDRESS
) ? "" : NULL
;
10370 if (strcmp (argv
[0], "hwaddress") == 0)
10371 return (flag_sanitize
& SANITIZE_USER_HWADDRESS
) ? "" : NULL
;
10372 if (strcmp (argv
[0], "kernel-address") == 0)
10373 return (flag_sanitize
& SANITIZE_KERNEL_ADDRESS
) ? "" : NULL
;
10374 if (strcmp (argv
[0], "kernel-hwaddress") == 0)
10375 return (flag_sanitize
& SANITIZE_KERNEL_HWADDRESS
) ? "" : NULL
;
10376 if (strcmp (argv
[0], "thread") == 0)
10377 return (flag_sanitize
& SANITIZE_THREAD
) ? "" : NULL
;
10378 if (strcmp (argv
[0], "undefined") == 0)
10379 return ((flag_sanitize
10380 & ~flag_sanitize_trap
10381 & (SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
)))
10383 if (strcmp (argv
[0], "leak") == 0)
10384 return ((flag_sanitize
10385 & (SANITIZE_ADDRESS
| SANITIZE_LEAK
| SANITIZE_THREAD
))
10386 == SANITIZE_LEAK
) ? "" : NULL
;
10390 /* replace-outfile built-in spec function.
10392 This looks for the first argument in the outfiles array's name and
10393 replaces it with the second argument. */
10395 static const char *
10396 replace_outfile_spec_function (int argc
, const char **argv
)
10399 /* Must have exactly two arguments. */
10403 for (i
= 0; i
< n_infiles
; i
++)
10405 if (outfiles
[i
] && !filename_cmp (outfiles
[i
], argv
[0]))
10406 outfiles
[i
] = xstrdup (argv
[1]);
10411 /* remove-outfile built-in spec function.
10413 * This looks for the first argument in the outfiles array's name and
10416 static const char *
10417 remove_outfile_spec_function (int argc
, const char **argv
)
10420 /* Must have exactly one argument. */
10424 for (i
= 0; i
< n_infiles
; i
++)
10426 if (outfiles
[i
] && !filename_cmp (outfiles
[i
], argv
[0]))
10427 outfiles
[i
] = NULL
;
10432 /* Given two version numbers, compares the two numbers.
10433 A version number must match the regular expression
10434 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
10437 compare_version_strings (const char *v1
, const char *v2
)
10442 if (regcomp (&r
, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
10443 REG_EXTENDED
| REG_NOSUB
) != 0)
10445 rresult
= regexec (&r
, v1
, 0, NULL
, 0);
10446 if (rresult
== REG_NOMATCH
)
10447 fatal_error (input_location
, "invalid version number %qs", v1
);
10448 else if (rresult
!= 0)
10450 rresult
= regexec (&r
, v2
, 0, NULL
, 0);
10451 if (rresult
== REG_NOMATCH
)
10452 fatal_error (input_location
, "invalid version number %qs", v2
);
10453 else if (rresult
!= 0)
10456 return strverscmp (v1
, v2
);
10460 /* version_compare built-in spec function.
10462 This takes an argument of the following form:
10464 <comparison-op> <arg1> [<arg2>] <switch> <result>
10466 and produces "result" if the comparison evaluates to true,
10467 and nothing if it doesn't.
10469 The supported <comparison-op> values are:
10471 >= true if switch is a later (or same) version than arg1
10473 < true if switch is an earlier version than arg1
10475 >< true if switch is arg1 or later, and earlier than arg2
10476 <> true if switch is earlier than arg1 or is arg2 or later
10478 If the switch is not present, the condition is false unless
10479 the first character of the <comparison-op> is '!'.
10482 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
10483 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
10485 static const char *
10486 version_compare_spec_function (int argc
, const char **argv
)
10490 const char *switch_value
= NULL
;
10495 fatal_error (input_location
, "too few arguments to %%:version-compare");
10496 if (argv
[0][0] == '\0')
10498 if ((argv
[0][1] == '<' || argv
[0][1] == '>') && argv
[0][0] != '!')
10500 if (argc
!= nargs
+ 3)
10501 fatal_error (input_location
, "too many arguments to %%:version-compare");
10503 switch_len
= strlen (argv
[nargs
+ 1]);
10504 for (i
= 0; i
< n_switches
; i
++)
10505 if (!strncmp (switches
[i
].part1
, argv
[nargs
+ 1], switch_len
)
10506 && check_live_switch (i
, switch_len
))
10507 switch_value
= switches
[i
].part1
+ switch_len
;
10509 if (switch_value
== NULL
)
10510 comp1
= comp2
= -1;
10513 comp1
= compare_version_strings (switch_value
, argv
[1]);
10515 comp2
= compare_version_strings (switch_value
, argv
[2]);
10517 comp2
= -1; /* This value unused. */
10520 switch (argv
[0][0] << 8 | argv
[0][1])
10522 case '>' << 8 | '=':
10523 result
= comp1
>= 0;
10525 case '!' << 8 | '<':
10526 result
= comp1
>= 0 || switch_value
== NULL
;
10529 result
= comp1
< 0;
10531 case '!' << 8 | '>':
10532 result
= comp1
< 0 || switch_value
== NULL
;
10534 case '>' << 8 | '<':
10535 result
= comp1
>= 0 && comp2
< 0;
10537 case '<' << 8 | '>':
10538 result
= comp1
< 0 || comp2
>= 0;
10542 fatal_error (input_location
,
10543 "unknown operator %qs in %%:version-compare", argv
[0]);
10548 return argv
[nargs
+ 2];
10551 /* %:include builtin spec function. This differs from %include in that it
10552 can be nested inside a spec, and thus be conditionalized. It takes
10553 one argument, the filename, and looks for it in the startfile path.
10554 The result is always NULL, i.e. an empty expansion. */
10556 static const char *
10557 include_spec_function (int argc
, const char **argv
)
10564 file
= find_a_file (&startfile_prefixes
, argv
[0], R_OK
, true);
10565 read_specs (file
? file
: argv
[0], false, false);
10570 /* %:find-file spec function. This function replaces its argument by
10571 the file found through find_file, that is the -print-file-name gcc
10573 static const char *
10574 find_file_spec_function (int argc
, const char **argv
)
10581 file
= find_file (argv
[0]);
10586 /* %:find-plugindir spec function. This function replaces its argument
10587 by the -iplugindir=<dir> option. `dir' is found through find_file, that
10588 is the -print-file-name gcc program option. */
10589 static const char *
10590 find_plugindir_spec_function (int argc
, const char **argv ATTRIBUTE_UNUSED
)
10592 const char *option
;
10597 option
= concat ("-iplugindir=", find_file ("plugin"), NULL
);
10602 /* %:print-asm-header spec function. Print a banner to say that the
10603 following output is from the assembler. */
10605 static const char *
10606 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED
,
10607 const char **argv ATTRIBUTE_UNUSED
)
10609 printf (_("Assembler options\n=================\n\n"));
10610 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
10615 /* Get a random number for -frandom-seed */
10617 static unsigned HOST_WIDE_INT
10618 get_random_number (void)
10620 unsigned HOST_WIDE_INT ret
= 0;
10623 fd
= open ("/dev/urandom", O_RDONLY
);
10626 read (fd
, &ret
, sizeof (HOST_WIDE_INT
));
10632 /* Get some more or less random data. */
10633 #ifdef HAVE_GETTIMEOFDAY
10637 gettimeofday (&tv
, NULL
);
10638 ret
= tv
.tv_sec
* 1000 + tv
.tv_usec
/ 1000;
10642 time_t now
= time (NULL
);
10644 if (now
!= (time_t)-1)
10645 ret
= (unsigned) now
;
10649 return ret
^ getpid ();
10652 /* %:compare-debug-dump-opt spec function. Save the last argument,
10653 expected to be the last -fdump-final-insns option, or generate a
10656 static const char *
10657 compare_debug_dump_opt_spec_function (int arg
,
10658 const char **argv ATTRIBUTE_UNUSED
)
10663 static char random_seed
[HOST_BITS_PER_WIDE_INT
/ 4 + 3];
10666 fatal_error (input_location
,
10667 "too many arguments to %%:compare-debug-dump-opt");
10669 do_spec_2 ("%{fdump-final-insns=*:%*}", NULL
);
10670 do_spec_1 (" ", 0, NULL
);
10672 if (argbuf
.length () > 0
10673 && strcmp (argv
[argbuf
.length () - 1], ".") != 0)
10675 if (!compare_debug
)
10678 name
= xstrdup (argv
[argbuf
.length () - 1]);
10683 if (argbuf
.length () > 0)
10684 do_spec_2 ("%B.gkd", NULL
);
10685 else if (!compare_debug
)
10688 do_spec_2 ("%{!save-temps*:%g.gkd}%{save-temps*:%B.gkd}", NULL
);
10690 do_spec_1 (" ", 0, NULL
);
10692 gcc_assert (argbuf
.length () > 0);
10694 name
= xstrdup (argbuf
.last ());
10696 char *arg
= quote_spec (xstrdup (name
));
10697 ret
= concat ("-fdump-final-insns=", arg
, NULL
);
10701 which
= compare_debug
< 0;
10702 debug_check_temp_file
[which
] = name
;
10706 unsigned HOST_WIDE_INT value
= get_random_number ();
10708 sprintf (random_seed
, HOST_WIDE_INT_PRINT_HEX
, value
);
10714 ret
= concat ("%{!frandom-seed=*:-frandom-seed=", random_seed
, "} ",
10725 /* %:compare-debug-self-opt spec function. Expands to the options
10726 that are to be passed in the second compilation of
10729 static const char *
10730 compare_debug_self_opt_spec_function (int arg
,
10731 const char **argv ATTRIBUTE_UNUSED
)
10734 fatal_error (input_location
,
10735 "too many arguments to %%:compare-debug-self-opt");
10737 if (compare_debug
>= 0)
10741 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
10742 %<fdump-final-insns=* -w -S -o %j \
10743 %{!fcompare-debug-second:-fcompare-debug-second} \
10744 ", compare_debug_opt
, NULL
);
10747 /* %:pass-through-libs spec function. Finds all -l options and input
10748 file names in the lib spec passed to it, and makes a list of them
10749 prepended with the plugin option to cause them to be passed through
10750 to the final link after all the new object files have been added. */
10753 pass_through_libs_spec_func (int argc
, const char **argv
)
10755 char *prepended
= xstrdup (" ");
10757 /* Shlemiel the painter's algorithm. Innately horrible, but at least
10758 we know that there will never be more than a handful of strings to
10759 concat, and it's only once per run, so it's not worth optimising. */
10760 for (n
= 0; n
< argc
; n
++)
10762 char *old
= prepended
;
10763 /* Anything that isn't an option is a full path to an output
10764 file; pass it through if it ends in '.a'. Among options,
10766 if (argv
[n
][0] == '-' && argv
[n
][1] == 'l')
10768 const char *lopt
= argv
[n
] + 2;
10769 /* Handle both joined and non-joined -l options. If for any
10770 reason there's a trailing -l with no joined or following
10771 arg just discard it. */
10772 if (!*lopt
&& ++n
>= argc
)
10776 prepended
= concat (prepended
, "-plugin-opt=-pass-through=-l",
10779 else if (!strcmp (".a", argv
[n
] + strlen (argv
[n
]) - 2))
10781 prepended
= concat (prepended
, "-plugin-opt=-pass-through=",
10782 argv
[n
], " ", NULL
);
10784 if (prepended
!= old
)
10791 not_actual_file_p (const char *name
)
10793 return (strcmp (name
, "-") == 0
10794 || strcmp (name
, HOST_BIT_BUCKET
) == 0);
10797 /* %:dumps spec function. Take an optional argument that overrides
10798 the default extension for -dumpbase and -dumpbase-ext.
10799 Return -dumpdir, -dumpbase and -dumpbase-ext, if needed. */
10801 dumps_spec_func (int argc
, const char **argv ATTRIBUTE_UNUSED
)
10803 const char *ext
= dumpbase_ext
;
10806 char *args
[3] = { NULL
, NULL
, NULL
};
10809 /* Do not compute a default for -dumpbase-ext when -dumpbase was
10810 given explicitly. */
10811 if (dumpbase
&& *dumpbase
&& !ext
)
10816 /* Do not override the explicitly-specified -dumpbase-ext with
10817 the specs-provided overrider. */
10821 else if (argc
!= 0)
10822 fatal_error (input_location
, "too many arguments for %%:dumps");
10826 p
= quote_spec_arg (xstrdup (dumpdir
));
10827 args
[nargs
++] = concat (" -dumpdir ", p
, NULL
);
10832 ext
= input_basename
+ basename_length
;
10834 /* Use the precomputed outbase, or compute dumpbase from
10835 input_basename, just like %b would. */
10838 if (dumpbase
&& *dumpbase
)
10840 base
= xstrdup (dumpbase
);
10841 p
= base
+ outbase_length
;
10842 gcc_checking_assert (strncmp (base
, outbase
, outbase_length
) == 0);
10843 gcc_checking_assert (strcmp (p
, ext
) == 0);
10845 else if (outbase_length
)
10847 base
= xstrndup (outbase
, outbase_length
);
10852 base
= xstrndup (input_basename
, suffixed_basename_length
);
10853 p
= base
+ basename_length
;
10856 if (compare_debug
< 0 || !p
|| strcmp (p
, ext
) != 0)
10862 if (compare_debug
< 0)
10867 p
= concat (base
, gk
, ext
, NULL
);
10873 base
= quote_spec_arg (base
);
10874 args
[nargs
++] = concat (" -dumpbase ", base
, NULL
);
10879 p
= quote_spec_arg (xstrdup (ext
));
10880 args
[nargs
++] = concat (" -dumpbase-ext ", p
, NULL
);
10884 const char *ret
= concat (args
[0], args
[1], args
[2], NULL
);
10886 free (args
[--nargs
]);
10891 /* Returns "" if ARGV[ARGC - 2] is greater than ARGV[ARGC-1].
10892 Otherwise, return NULL. */
10894 static const char *
10895 greater_than_spec_func (int argc
, const char **argv
)
10902 gcc_assert (argc
>= 2);
10904 long arg
= strtol (argv
[argc
- 2], &converted
, 10);
10905 gcc_assert (converted
!= argv
[argc
- 2]);
10907 long lim
= strtol (argv
[argc
- 1], &converted
, 10);
10908 gcc_assert (converted
!= argv
[argc
- 1]);
10916 /* Returns "" if debug_info_level is greater than ARGV[ARGC-1].
10917 Otherwise, return NULL. */
10919 static const char *
10920 debug_level_greater_than_spec_func (int argc
, const char **argv
)
10925 fatal_error (input_location
,
10926 "wrong number of arguments to %%:debug-level-gt");
10928 long arg
= strtol (argv
[0], &converted
, 10);
10929 gcc_assert (converted
!= argv
[0]);
10931 if (debug_info_level
> arg
)
10937 /* Returns "" if dwarf_version is greater than ARGV[ARGC-1].
10938 Otherwise, return NULL. */
10940 static const char *
10941 dwarf_version_greater_than_spec_func (int argc
, const char **argv
)
10946 fatal_error (input_location
,
10947 "wrong number of arguments to %%:dwarf-version-gt");
10949 long arg
= strtol (argv
[0], &converted
, 10);
10950 gcc_assert (converted
!= argv
[0]);
10952 if (dwarf_version
> arg
)
10959 path_prefix_reset (path_prefix
*prefix
)
10961 struct prefix_list
*iter
, *next
;
10962 iter
= prefix
->plist
;
10966 free (const_cast <char *> (iter
->prefix
));
10971 prefix
->max_len
= 0;
10974 /* The function takes 3 arguments: OPTION name, file name and location
10975 where we search for Fortran modules.
10976 When the FILE is found by find_file, return OPTION=path_to_file. */
10978 static const char *
10979 find_fortran_preinclude_file (int argc
, const char **argv
)
10981 char *result
= NULL
;
10985 struct path_prefix prefixes
= { 0, 0, "preinclude" };
10987 /* Search first for 'finclude' folder location for a header file
10988 installed by the compiler (similar to omp_lib.h). */
10989 add_prefix (&prefixes
, argv
[2], NULL
, 0, 0, 0);
10990 #ifdef TOOL_INCLUDE_DIR
10991 /* Then search: <prefix>/<target>/<include>/finclude */
10992 add_prefix (&prefixes
, TOOL_INCLUDE_DIR
"/finclude/",
10995 #ifdef NATIVE_SYSTEM_HEADER_DIR
10996 /* Then search: <sysroot>/usr/include/finclude/<multilib> */
10997 add_sysrooted_hdrs_prefix (&prefixes
, NATIVE_SYSTEM_HEADER_DIR
"/finclude/",
11001 const char *path
= find_a_file (&include_prefixes
, argv
[1], R_OK
, false);
11003 result
= concat (argv
[0], path
, NULL
);
11006 path
= find_a_file (&prefixes
, argv
[1], R_OK
, false);
11008 result
= concat (argv
[0], path
, NULL
);
11011 path_prefix_reset (&prefixes
);
11015 /* The function takes any number of arguments and joins them together.
11017 This seems to be necessary to build "-fjoined=foo.b" from "-fseparate foo.a"
11018 with a %{fseparate*:-fjoined=%.b$*} rule without adding undesired spaces:
11019 when doing $* replacement we first replace $* with the rest of the switch
11020 (in this case ""), and then add any arguments as arguments after the result,
11021 resulting in "-fjoined= foo.b". Using this function with e.g.
11022 %{fseparate*:-fjoined=%:join(%.b$*)} gets multiple words as separate argv
11023 elements instead of separated by spaces, and we paste them together. */
11025 static const char *
11026 join_spec_func (int argc
, const char **argv
)
11030 for (int i
= 0; i
< argc
; ++i
)
11031 obstack_grow (&obstack
, argv
[i
], strlen (argv
[i
]));
11032 obstack_1grow (&obstack
, '\0');
11033 return XOBFINISH (&obstack
, const char *);
11036 /* If any character in ORIG fits QUOTE_P (_, P), reallocate the string
11037 so as to precede every one of them with a backslash. Return the
11038 original string or the reallocated one. */
11040 static inline char *
11041 quote_string (char *orig
, bool (*quote_p
)(char, void *), void *p
)
11043 int len
, number_of_space
= 0;
11045 for (len
= 0; orig
[len
]; len
++)
11046 if (quote_p (orig
[len
], p
))
11049 if (number_of_space
)
11051 char *new_spec
= (char *) xmalloc (len
+ number_of_space
+ 1);
11053 for (j
= 0, k
= 0; j
<= len
; j
++, k
++)
11055 if (quote_p (orig
[j
], p
))
11056 new_spec
[k
++] = '\\';
11057 new_spec
[k
] = orig
[j
];
11066 /* Return true iff C is any of the characters convert_white_space
11070 whitespace_to_convert_p (char c
, void *)
11072 return (c
== ' ' || c
== '\t');
11075 /* Insert backslash before spaces in ORIG (usually a file path), to
11076 avoid being broken by spec parser.
11078 This function is needed as do_spec_1 treats white space (' ' and '\t')
11079 as the end of an argument. But in case of -plugin /usr/gcc install/xxx.so,
11080 the file name should be treated as a single argument rather than being
11081 broken into multiple. Solution is to insert '\\' before the space in a
11084 This function converts and only converts all occurrence of ' '
11085 to '\\' + ' ' and '\t' to '\\' + '\t'. For example:
11087 "a b" -> "a\\ \\ b"
11089 "a\\ b" -> "a\\\\ b"
11091 orig: input null-terminating string that was allocated by xalloc. The
11092 memory it points to might be freed in this function. Behavior undefined
11093 if ORIG wasn't xalloced or was freed already at entry.
11095 Return: ORIG if no conversion needed. Otherwise a newly allocated string
11096 that was converted from ORIG. */
11099 convert_white_space (char *orig
)
11101 return quote_string (orig
, whitespace_to_convert_p
, NULL
);
11104 /* Return true iff C matches any of the spec active characters. */
11106 quote_spec_char_p (char c
, void *)
11123 /* Like convert_white_space, but deactivate all active spec chars by
11126 static inline char *
11127 quote_spec (char *orig
)
11129 return quote_string (orig
, quote_spec_char_p
, NULL
);
11132 /* Like quote_spec, but also turn an empty string into the spec for an
11135 static inline char *
11136 quote_spec_arg (char *orig
)
11141 return xstrdup ("%\"");
11144 return quote_spec (orig
);
11147 /* Restore all state within gcc.cc to the initial state, so that the driver
11148 code can be safely re-run in-process.
11150 Many const char * variables are referenced by static specs (see
11151 INIT_STATIC_SPEC above). These variables are restored to their default
11152 values by a simple loop over the static specs.
11154 For other variables, we directly restore them all to their initial
11155 values (often implicitly 0).
11157 Free the various obstacks in this file, along with "opts_obstack"
11160 This function also restores any environment variables that were changed. */
11163 driver::finalize ()
11166 diagnostic_finish (global_dc
);
11169 at_file_supplied
= 0;
11170 print_help_list
= 0;
11172 verbose_only_flag
= 0;
11173 print_subprocess_help
= 0;
11175 report_times_to_file
= NULL
;
11176 target_system_root
= DEFAULT_TARGET_SYSTEM_ROOT
;
11177 target_system_root_changed
= 0;
11178 target_sysroot_suffix
= 0;
11179 target_sysroot_hdrs_suffix
= 0;
11180 save_temps_flag
= SAVE_TEMPS_NONE
;
11181 save_temps_overrides_dumpdir
= false;
11182 dumpdir_trailing_dash_added
= false;
11185 free (dumpbase_ext
);
11187 dumpdir
= dumpbase
= dumpbase_ext
= outbase
= NULL
;
11188 dumpdir_length
= outbase_length
= 0;
11189 spec_machine
= DEFAULT_TARGET_MACHINE
;
11190 greatest_status
= 1;
11192 obstack_free (&obstack
, NULL
);
11193 obstack_free (&opts_obstack
, NULL
); /* in opts.cc */
11194 obstack_free (&collect_obstack
, NULL
);
11196 link_command_spec
= LINK_COMMAND_SPEC
;
11198 obstack_free (&multilib_obstack
, NULL
);
11200 user_specs_head
= NULL
;
11201 user_specs_tail
= NULL
;
11203 /* Within the "compilers" vec, the fields "suffix" and "spec" were
11204 statically allocated for the default compilers, but dynamically
11205 allocated for additional compilers. Delete them for the latter. */
11206 for (int i
= n_default_compilers
; i
< n_compilers
; i
++)
11208 free (const_cast <char *> (compilers
[i
].suffix
));
11209 free (const_cast <char *> (compilers
[i
].spec
));
11211 XDELETEVEC (compilers
);
11215 linker_options
.truncate (0);
11216 assembler_options
.truncate (0);
11217 preprocessor_options
.truncate (0);
11219 path_prefix_reset (&exec_prefixes
);
11220 path_prefix_reset (&startfile_prefixes
);
11221 path_prefix_reset (&include_prefixes
);
11223 machine_suffix
= 0;
11224 just_machine_suffix
= 0;
11225 gcc_exec_prefix
= 0;
11226 gcc_libexec_prefix
= 0;
11227 set_static_spec_shared (&md_exec_prefix
, MD_EXEC_PREFIX
);
11228 set_static_spec_shared (&md_startfile_prefix
, MD_STARTFILE_PREFIX
);
11229 set_static_spec_shared (&md_startfile_prefix_1
, MD_STARTFILE_PREFIX_1
);
11231 multilib_os_dir
= 0;
11234 /* Free any specs dynamically-allocated by set_spec.
11235 These will be at the head of the list, before the
11236 statically-allocated ones. */
11239 while (specs
!= static_specs
)
11241 spec_list
*next
= specs
->next
;
11242 free (const_cast <char *> (specs
->name
));
11248 for (unsigned i
= 0; i
< ARRAY_SIZE (static_specs
); i
++)
11250 spec_list
*sl
= &static_specs
[i
];
11253 free (const_cast <char *> (*(sl
->ptr_spec
)));
11254 sl
->alloc_p
= false;
11256 *(sl
->ptr_spec
) = sl
->default_ptr
;
11259 extra_specs
= NULL
;
11262 processing_spec_function
= 0;
11270 execution_count
= 0;
11273 temp_filename
= NULL
;
11274 temp_filename_length
= 0;
11275 always_delete_queue
= NULL
;
11276 failure_delete_queue
= NULL
;
11278 XDELETEVEC (switches
);
11281 n_switches_alloc
= 0;
11284 compare_debug_second
= 0;
11285 compare_debug_opt
= NULL
;
11286 for (int i
= 0; i
< 2; i
++)
11288 switches_debug_check
[i
] = NULL
;
11289 n_switches_debug_check
[i
] = 0;
11290 n_switches_alloc_debug_check
[i
] = 0;
11291 debug_check_temp_file
[i
] = NULL
;
11294 XDELETEVEC (infiles
);
11297 n_infiles_alloc
= 0;
11299 combine_inputs
= false;
11300 added_libraries
= 0;
11301 XDELETEVEC (outfiles
);
11304 last_language_n_infiles
= 0;
11305 gcc_input_filename
= NULL
;
11306 input_file_number
= 0;
11307 input_filename_length
= 0;
11308 basename_length
= 0;
11309 suffixed_basename_length
= 0;
11310 input_basename
= NULL
;
11311 input_suffix
= NULL
;
11312 /* We don't need to purge "input_stat", just to unset "input_stat_set". */
11313 input_stat_set
= 0;
11314 input_file_compiler
= NULL
;
11316 delete_this_arg
= 0;
11317 this_is_output_file
= 0;
11318 this_is_library_file
= 0;
11319 this_is_linker_script
= 0;
11320 input_from_pipe
= 0;
11321 suffix_subst
= NULL
;
11326 used_arg
.finalize ();
11330 Targets can provide configure-time default options in
11331 OPTION_DEFAULT_SPECS. The jit needs to access these, but
11332 they are expressed in the spec language.
11334 Run just enough of the driver to be able to expand these
11335 specs, and then call the callback CB on each
11336 such option. The options strings are *without* a leading
11337 '-' character e.g. ("march=x86-64"). Finally, clean up. */
11340 driver_get_configure_time_options (void (*cb
) (const char *option
,
11346 obstack_init (&obstack
);
11347 init_opts_obstack ();
11350 for (i
= 0; i
< ARRAY_SIZE (option_default_specs
); i
++)
11351 do_option_spec (option_default_specs
[i
].name
,
11352 option_default_specs
[i
].spec
);
11354 for (i
= 0; (int) i
< n_switches
; i
++)
11356 gcc_assert (switches
[i
].part1
);
11357 (*cb
) (switches
[i
].part1
, user_data
);
11360 obstack_free (&opts_obstack
, NULL
);
11361 obstack_free (&obstack
, NULL
);