1 /* Compiler driver program that can handle many languages.
2 Copyright (C) 1987-2022 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 /* This program is the user interface to the C compiler and possibly to
21 other compilers. It is used because compilation is a complicated procedure
22 which involves running several programs and passing temporary files between
23 them, forwarding the users switches to those programs selectively,
24 and deleting the temporary files at the end.
26 CC recognizes how to compile each input file by suffixes in the file names.
27 Once it knows which kind of compilation to perform, the procedure for
28 compilation is specified by a string called a "spec". */
32 #include "coretypes.h"
33 #include "multilib.h" /* before tm.h */
39 #include "opt-suggestions.h"
41 #include "diagnostic.h"
44 #include "filenames.h"
45 #include "spellcheck.h"
49 /* Manage the manipulation of env vars.
51 We poison "getenv" and "putenv", so that all enviroment-handling is
52 done through this class. Note that poisoning happens in the
53 preprocessor at the identifier level, and doesn't distinguish between
57 Hence we need to use "get" for the accessor method, not "getenv". */
62 void init (bool can_restore
, bool debug
);
63 const char *get (const char *name
);
64 void xput (const char *string
);
79 /* The singleton instance of class env_manager. */
81 static env_manager env
;
83 /* Initializer for class env_manager.
85 We can't do this as a constructor since we have a statically
86 allocated instance ("env" above). */
89 env_manager::init (bool can_restore
, bool debug
)
91 m_can_restore
= can_restore
;
95 /* Get the value of NAME within the environment. Essentially
96 a wrapper for ::getenv, but adding logging, and the possibility
97 of caching results. */
100 env_manager::get (const char *name
)
102 const char *result
= ::getenv (name
);
104 fprintf (stderr
, "env_manager::getenv (%s) -> %s\n", name
, result
);
108 /* Put the given KEY=VALUE entry STRING into the environment.
109 If the env_manager was initialized with CAN_RESTORE set, then
110 also record the old value of KEY within the environment, so that it
111 can be later restored. */
114 env_manager::xput (const char *string
)
117 fprintf (stderr
, "env_manager::xput (%s)\n", string
);
119 fnotice (stderr
, "%s\n", string
);
123 char *equals
= strchr (const_cast <char *> (string
), '=');
127 kv
.m_key
= xstrndup (string
, equals
- string
);
128 const char *cur_value
= ::getenv (kv
.m_key
);
130 fprintf (stderr
, "saving old value: %s\n",cur_value
);
131 kv
.m_value
= cur_value
? xstrdup (cur_value
) : NULL
;
132 m_keys
.safe_push (kv
);
135 ::putenv (CONST_CAST (char *, string
));
138 /* Undo any xputenv changes made since last restore.
139 Can only be called if the env_manager was initialized with
140 CAN_RESTORE enabled. */
143 env_manager::restore ()
148 gcc_assert (m_can_restore
);
150 FOR_EACH_VEC_ELT_REVERSE (m_keys
, i
, item
)
153 printf ("restoring saved key: %s value: %s\n", item
->m_key
, item
->m_value
);
155 ::setenv (item
->m_key
, item
->m_value
, 1);
157 ::unsetenv (item
->m_key
);
159 free (item
->m_value
);
165 /* Forbid other uses of getenv and putenv. */
166 #if (GCC_VERSION >= 3000)
167 #pragma GCC poison getenv putenv
172 /* By default there is no special suffix for target executables. */
173 #ifdef TARGET_EXECUTABLE_SUFFIX
174 #define HAVE_TARGET_EXECUTABLE_SUFFIX
176 #define TARGET_EXECUTABLE_SUFFIX ""
179 /* By default there is no special suffix for host executables. */
180 #ifdef HOST_EXECUTABLE_SUFFIX
181 #define HAVE_HOST_EXECUTABLE_SUFFIX
183 #define HOST_EXECUTABLE_SUFFIX ""
186 /* By default, the suffix for target object files is ".o". */
187 #ifdef TARGET_OBJECT_SUFFIX
188 #define HAVE_TARGET_OBJECT_SUFFIX
190 #define TARGET_OBJECT_SUFFIX ".o"
193 static const char dir_separator_str
[] = { DIR_SEPARATOR
, 0 };
195 /* Most every one is fine with LIBRARY_PATH. For some, it conflicts. */
196 #ifndef LIBRARY_PATH_ENV
197 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
200 /* If a stage of compilation returns an exit status >= 1,
201 compilation of that file ceases. */
203 #define MIN_FATAL_STATUS 1
205 /* Flag set by cppspec.cc to 1. */
208 /* Flag set to nonzero if an @file argument has been supplied to gcc. */
209 static bool at_file_supplied
;
211 /* Definition of string containing the arguments given to configure. */
212 #include "configargs.h"
214 /* Flag saying to print the command line options understood by gcc and its
217 static int print_help_list
;
219 /* Flag saying to print the version of gcc and its sub-processes. */
221 static int print_version
;
223 /* Flag that stores string prefix for which we provide bash completion. */
225 static const char *completion
= NULL
;
227 /* Flag indicating whether we should ONLY print the command and
228 arguments (like verbose_flag) without executing the command.
229 Displayed arguments are quoted so that the generated command
230 line is suitable for execution. This is intended for use in
231 shell scripts to capture the driver-generated command line. */
232 static int verbose_only_flag
;
234 /* Flag indicating how to print command line options of sub-processes. */
236 static int print_subprocess_help
;
238 /* Linker suffix passed to -fuse-ld=... */
239 static const char *use_ld
;
241 /* Whether we should report subprocess execution times to a file. */
243 FILE *report_times_to_file
= NULL
;
245 /* Nonzero means place this string before uses of /, so that include
246 and library files can be found in an alternate location. */
248 #ifdef TARGET_SYSTEM_ROOT
249 #define DEFAULT_TARGET_SYSTEM_ROOT (TARGET_SYSTEM_ROOT)
251 #define DEFAULT_TARGET_SYSTEM_ROOT (0)
253 static const char *target_system_root
= DEFAULT_TARGET_SYSTEM_ROOT
;
255 /* Nonzero means pass the updated target_system_root to the compiler. */
257 static int target_system_root_changed
;
259 /* Nonzero means append this string to target_system_root. */
261 static const char *target_sysroot_suffix
= 0;
263 /* Nonzero means append this string to target_system_root for headers. */
265 static const char *target_sysroot_hdrs_suffix
= 0;
267 /* Nonzero means write "temp" files in source directory
268 and use the source file's name in them, and don't delete them. */
270 static enum save_temps
{
271 SAVE_TEMPS_NONE
, /* no -save-temps */
272 SAVE_TEMPS_CWD
, /* -save-temps in current directory */
273 SAVE_TEMPS_DUMP
, /* -save-temps in dumpdir */
274 SAVE_TEMPS_OBJ
/* -save-temps in object directory */
277 /* Set this iff the dumppfx implied by a -save-temps=* option is to
278 override a -dumpdir option, if any. */
279 static bool save_temps_overrides_dumpdir
= false;
281 /* -dumpdir, -dumpbase and -dumpbase-ext flags passed in, possibly
282 rearranged as they are to be passed down, e.g., dumpbase and
283 dumpbase_ext may be cleared if integrated with dumpdir or
285 static char *dumpdir
, *dumpbase
, *dumpbase_ext
;
287 /* Usually the length of the string in dumpdir. However, during
288 linking, it may be shortened to omit a driver-added trailing dash,
289 by then replaced with a trailing period, that is still to be passed
290 to sub-processes in -dumpdir, but not to be generally used in spec
291 filename expansions. See maybe_run_linker. */
292 static size_t dumpdir_length
= 0;
294 /* Set if the last character in dumpdir is (or was) a dash that the
295 driver added to dumpdir after dumpbase or linker output name. */
296 static bool dumpdir_trailing_dash_added
= false;
298 /* Basename of dump and aux outputs, computed from dumpbase (given or
299 derived from output name), to override input_basename in non-%w %b
301 static char *outbase
;
302 static size_t outbase_length
= 0;
304 /* The compiler version. */
306 static const char *compiler_version
;
308 /* The target version. */
310 static const char *const spec_version
= DEFAULT_TARGET_VERSION
;
312 /* The target machine. */
314 static const char *spec_machine
= DEFAULT_TARGET_MACHINE
;
315 static const char *spec_host_machine
= DEFAULT_REAL_TARGET_MACHINE
;
317 /* List of offload targets. Separated by colon. Empty string for
318 -foffload=disable. */
320 static char *offload_targets
= NULL
;
322 #if OFFLOAD_DEFAULTED
323 /* Set to true if -foffload has not been used and offload_targets
324 is set to the configured in default. */
325 static bool offload_targets_default
;
328 /* Nonzero if cross-compiling.
329 When -b is used, the value comes from the `specs' file. */
331 #ifdef CROSS_DIRECTORY_STRUCTURE
332 static const char *cross_compile
= "1";
334 static const char *cross_compile
= "0";
337 /* Greatest exit code of sub-processes that has been encountered up to
339 static int greatest_status
= 1;
341 /* This is the obstack which we use to allocate many strings. */
343 static struct obstack obstack
;
345 /* This is the obstack to build an environment variable to pass to
346 collect2 that describes all of the relevant switches of what to
347 pass the compiler in building the list of pointers to constructors
350 static struct obstack collect_obstack
;
352 /* Forward declaration for prototypes. */
356 static void init_spec (void);
357 static void store_arg (const char *, int, int);
358 static void insert_wrapper (const char *);
359 static char *load_specs (const char *);
360 static void read_specs (const char *, bool, bool);
361 static void set_spec (const char *, const char *, bool);
362 static struct compiler
*lookup_compiler (const char *, size_t, const char *);
363 static char *build_search_list (const struct path_prefix
*, const char *,
365 static void xputenv (const char *);
366 static void putenv_from_prefixes (const struct path_prefix
*, const char *,
368 static int access_check (const char *, int);
369 static char *find_a_file (const struct path_prefix
*, const char *, int, bool);
370 static char *find_a_program (const char *);
371 static void add_prefix (struct path_prefix
*, const char *, const char *,
373 static void add_sysrooted_prefix (struct path_prefix
*, const char *,
374 const char *, int, int, int);
375 static char *skip_whitespace (char *);
376 static void delete_if_ordinary (const char *);
377 static void delete_temp_files (void);
378 static void delete_failure_queue (void);
379 static void clear_failure_queue (void);
380 static int check_live_switch (int, int);
381 static const char *handle_braces (const char *);
382 static inline bool input_suffix_matches (const char *, const char *);
383 static inline bool switch_matches (const char *, const char *, int);
384 static inline void mark_matching_switches (const char *, const char *, int);
385 static inline void process_marked_switches (void);
386 static const char *process_brace_body (const char *, const char *, const char *, int, int);
387 static const struct spec_function
*lookup_spec_function (const char *);
388 static const char *eval_spec_function (const char *, const char *, const char *);
389 static const char *handle_spec_function (const char *, bool *, const char *);
390 static char *save_string (const char *, int);
391 static void set_collect_gcc_options (void);
392 static int do_spec_1 (const char *, int, const char *);
393 static int do_spec_2 (const char *, const char *);
394 static void do_option_spec (const char *, const char *);
395 static void do_self_spec (const char *);
396 static const char *find_file (const char *);
397 static int is_directory (const char *, bool);
398 static const char *validate_switches (const char *, bool, bool);
399 static void validate_all_switches (void);
400 static inline void validate_switches_from_spec (const char *, bool);
401 static void give_switch (int, int);
402 static int default_arg (const char *, int);
403 static void set_multilib_dir (void);
404 static void print_multilib_info (void);
405 static void display_help (void);
406 static void add_preprocessor_option (const char *, int);
407 static void add_assembler_option (const char *, int);
408 static void add_linker_option (const char *, int);
409 static void process_command (unsigned int, struct cl_decoded_option
*);
410 static int execute (void);
411 static void alloc_args (void);
412 static void clear_args (void);
413 static void fatal_signal (int);
414 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
415 static void init_gcc_specs (struct obstack
*, const char *, const char *,
418 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
419 static const char *convert_filename (const char *, int, int);
422 static void try_generate_repro (const char **argv
);
423 static const char *getenv_spec_function (int, const char **);
424 static const char *if_exists_spec_function (int, const char **);
425 static const char *if_exists_else_spec_function (int, const char **);
426 static const char *if_exists_then_else_spec_function (int, const char **);
427 static const char *sanitize_spec_function (int, const char **);
428 static const char *replace_outfile_spec_function (int, const char **);
429 static const char *remove_outfile_spec_function (int, const char **);
430 static const char *version_compare_spec_function (int, const char **);
431 static const char *include_spec_function (int, const char **);
432 static const char *find_file_spec_function (int, const char **);
433 static const char *find_plugindir_spec_function (int, const char **);
434 static const char *print_asm_header_spec_function (int, const char **);
435 static const char *compare_debug_dump_opt_spec_function (int, const char **);
436 static const char *compare_debug_self_opt_spec_function (int, const char **);
437 static const char *pass_through_libs_spec_func (int, const char **);
438 static const char *dumps_spec_func (int, const char **);
439 static const char *greater_than_spec_func (int, const char **);
440 static const char *debug_level_greater_than_spec_func (int, const char **);
441 static const char *dwarf_version_greater_than_spec_func (int, const char **);
442 static const char *find_fortran_preinclude_file (int, const char **);
443 static char *convert_white_space (char *);
444 static char *quote_spec (char *);
445 static char *quote_spec_arg (char *);
446 static bool not_actual_file_p (const char *);
449 /* The Specs Language
451 Specs are strings containing lines, each of which (if not blank)
452 is made up of a program name, and arguments separated by spaces.
453 The program name must be exact and start from root, since no path
454 is searched and it is unreliable to depend on the current working directory.
455 Redirection of input or output is not supported; the subprograms must
456 accept filenames saying what files to read and write.
458 In addition, the specs can contain %-sequences to substitute variable text
459 or for conditional text. Here is a table of all defined %-sequences.
460 Note that spaces are not generated automatically around the results of
461 expanding these sequences; therefore, you can concatenate them together
462 or with constant text in a single argument.
464 %% substitute one % into the program name or argument.
465 %" substitute an empty argument.
466 %i substitute the name of the input file being processed.
467 %b substitute the basename for outputs related with the input file
468 being processed. This is often a substring of the input file name,
469 up to (and not including) the last period but, unless %w is active,
470 it is affected by the directory selected by -save-temps=*, by
471 -dumpdir, and, in case of multiple compilations, even by -dumpbase
472 and -dumpbase-ext and, in case of linking, by the linker output
473 name. When %w is active, it derives the main output name only from
474 the input file base name; when it is not, it names aux/dump output
476 %B same as %b, but include the input file suffix (text after the last
479 substitute a file name that has suffix SUFFIX and is chosen
480 once per compilation, and mark the argument a la %d. To reduce
481 exposure to denial-of-service attacks, the file name is now
482 chosen in a way that is hard to predict even when previously
483 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
484 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
485 the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
486 had been pre-processed. Previously, %g was simply substituted
487 with a file name chosen once per compilation, without regard
488 to any appended suffix (which was therefore treated just like
489 ordinary text), making such attacks more likely to succeed.
491 like %g, but if -pipe is in effect, expands simply to "-".
493 like %g, but if -pipe is in effect, expands to nothing. (We have both
494 %| and %m to accommodate differences between system assemblers; see
495 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
497 like %g, but generates a new temporary file name even if %uSUFFIX
500 substitutes the last file name generated with %uSUFFIX, generating a
501 new one if there is no such last file name. In the absence of any
502 %uSUFFIX, this is just like %gSUFFIX, except they don't share
503 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
504 would involve the generation of two distinct file names, one
505 for each `%g.s' and another for each `%U.s'. Previously, %U was
506 simply substituted with a file name chosen for the previous %u,
507 without regard to any appended suffix.
509 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
510 writable, and if save-temps is off; otherwise, substitute the name
511 of a temporary file, just like %u. This temporary file is not
512 meant for communication between processes, but rather as a junk
515 substitutes .SUFFIX for the suffixes of a matched switch's args when
516 it is subsequently output with %*. SUFFIX is terminated by the next
518 %d marks the argument containing or following the %d as a
519 temporary file name, so that file will be deleted if GCC exits
520 successfully. Unlike %g, this contributes no text to the argument.
521 %w marks the argument containing or following the %w as the
522 "output file" of this compilation. This puts the argument
523 into the sequence of arguments that %o will substitute later.
524 %V indicates that this compilation produces no "output file".
526 like %{...} but marks the last argument supplied within as a file
527 to be deleted on failure.
529 like %{...} but puts the result into a FILE and substitutes @FILE
530 if an @file argument has been supplied.
531 %o substitutes the names of all the output files, with spaces
532 automatically placed around them. You should write spaces
533 around the %o as well or the results are undefined.
534 %o is for use in the specs for running the linker.
535 Input files whose names have no recognized suffix are not compiled
536 at all, but they are included among the output files, so they will
538 %O substitutes the suffix for object files. Note that this is
539 handled specially when it immediately follows %g, %u, or %U
540 (with or without a suffix argument) because of the need for
541 those to form complete file names. The handling is such that
542 %O is treated exactly as if it had already been substituted,
543 except that %g, %u, and %U do not currently support additional
544 SUFFIX characters following %O as they would following, for
546 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
547 (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
548 and -B options) and -imultilib as necessary.
549 %s current argument is the name of a library or startup file of some sort.
550 Search for that file in a standard list of directories
551 and substitute the full name found.
552 %T current argument is the name of a linker script.
553 Search for that file in the current list of directories to scan for
554 libraries. If the file is located, insert a --script option into the
555 command line followed by the full path name found. If the file is
556 not found then generate an error message.
557 Note: the current working directory is not searched.
558 %eSTR Print STR as an error message. STR is terminated by a newline.
559 Use this when inconsistent options are detected.
560 %nSTR Print STR as a notice. STR is terminated by a newline.
561 %x{OPTION} Accumulate an option for %X.
562 %X Output the accumulated linker options specified by compilations.
563 %Y Output the accumulated assembler options specified by compilations.
564 %Z Output the accumulated preprocessor options specified by compilations.
565 %a process ASM_SPEC as a spec.
566 This allows config.h to specify part of the spec for running as.
567 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
568 used here. This can be used to run a post-processor after the
569 assembler has done its job.
570 %D Dump out a -L option for each directory in startfile_prefixes.
571 If multilib_dir is set, extra entries are generated with it affixed.
572 %l process LINK_SPEC as a spec.
573 %L process LIB_SPEC as a spec.
574 %M Output multilib_os_dir.
575 %G process LIBGCC_SPEC as a spec.
576 %R Output the concatenation of target_system_root and
577 target_sysroot_suffix.
578 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
579 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
580 %C process CPP_SPEC as a spec.
581 %1 process CC1_SPEC as a spec.
582 %2 process CC1PLUS_SPEC as a spec.
583 %* substitute the variable part of a matched option. (See below.)
584 Note that each comma in the substituted string is replaced by
585 a single space. A space is appended after the last substition
586 unless there is more text in current sequence.
587 %<S remove all occurrences of -S from the command line.
588 Note - this command is position dependent. % commands in the
589 spec string before this one will see -S, % commands in the
590 spec string after this one will not.
591 %>S Similar to "%<S", but keep it in the GCC command line.
592 %<S* remove all occurrences of all switches beginning with -S from the
595 Call the named function FUNCTION, passing it ARGS. ARGS is
596 first processed as a nested spec string, then split into an
597 argument vector in the usual fashion. The function returns
598 a string which is processed as if it had appeared literally
599 as part of the current spec.
600 %{S} substitutes the -S switch, if that switch was given to GCC.
601 If that switch was not specified, this substitutes nothing.
602 Here S is a metasyntactic variable.
603 %{S*} substitutes all the switches specified to GCC whose names start
604 with -S. This is used for -o, -I, etc; switches that take
605 arguments. GCC considers `-o foo' as being one switch whose
606 name starts with `o'. %{o*} would substitute this text,
607 including the space; thus, two arguments would be generated.
608 %{S*&T*} likewise, but preserve order of S and T options (the order
609 of S and T in the spec is not significant). Can be any number
610 of ampersand-separated variables; for each the wild card is
611 optional. Useful for CPP as %{D*&U*&A*}.
613 %{S:X} substitutes X, if the -S switch was given to GCC.
614 %{!S:X} substitutes X, if the -S switch was NOT given to GCC.
615 %{S*:X} substitutes X if one or more switches whose names start
616 with -S was given to GCC. Normally X is substituted only
617 once, no matter how many such switches appeared. However,
618 if %* appears somewhere in X, then X will be substituted
619 once for each matching switch, with the %* replaced by the
620 part of that switch that matched the '*'. A space will be
621 appended after the last substition unless there is more
622 text in current sequence.
623 %{.S:X} substitutes X, if processing a file with suffix S.
624 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
625 %{,S:X} substitutes X, if processing a file which will use spec S.
626 %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
628 %{S|T:X} substitutes X if either -S or -T was given to GCC. This may be
629 combined with '!', '.', ',', and '*' as above binding stronger
631 If %* appears in X, all of the alternatives must be starred, and
632 only the first matching alternative is substituted.
633 %{%:function(args):X}
634 Call function named FUNCTION with args ARGS. If the function
635 returns non-NULL, then X is substituted, if it returns
636 NULL, it isn't substituted.
637 %{S:X; if S was given to GCC, substitutes X;
638 T:Y; else if T was given to GCC, substitutes Y;
639 :D} else substitutes D. There can be as many clauses as you need.
640 This may be combined with '.', '!', ',', '|', and '*' as above.
642 %(Spec) processes a specification defined in a specs file as *Spec:
644 The switch matching text S in a %{S}, %{S:X}, or similar construct can use
645 a backslash to ignore the special meaning of the character following it,
646 thus allowing literal matching of a character that is otherwise specially
647 treated. For example, %{std=iso9899\:1999:X} substitutes X if the
648 -std=iso9899:1999 option is given.
650 The conditional text X in a %{S:X} or similar construct may contain
651 other nested % constructs or spaces, or even newlines. They are
652 processed as usual, as described above. Trailing white space in X is
653 ignored. White space may also appear anywhere on the left side of the
654 colon in these constructs, except between . or * and the corresponding
657 The -O, -f, -g, -m, and -W switches are handled specifically in these
658 constructs. If another value of -O or the negated form of a -f, -m, or
659 -W switch is found later in the command line, the earlier switch
660 value is ignored, except with {S*} where S is just one letter; this
661 passes all matching options.
663 The character | at the beginning of the predicate text is used to indicate
664 that a command should be piped to the following command, but only if -pipe
667 Note that it is built into GCC which switches take arguments and which
668 do not. You might think it would be useful to generalize this to
669 allow each compiler's spec to say which switches take arguments. But
670 this cannot be done in a consistent fashion. GCC cannot even decide
671 which input files have been specified without knowing which switches
672 take arguments, and it must know which input files to compile in order
673 to tell which compilers to run.
675 GCC also knows implicitly that arguments starting in `-l' are to be
676 treated as compiler output files, and passed to the linker in their
677 proper position among the other output files. */
679 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
681 /* config.h can define ASM_SPEC to provide extra args to the assembler
682 or extra switch-translations. */
687 /* config.h can define ASM_FINAL_SPEC to run a post processor after
688 the assembler has run. */
689 #ifndef ASM_FINAL_SPEC
690 #define ASM_FINAL_SPEC \
692 objcopy --extract-dwo \
693 %{c:%{o*:%*}%{!o*:%w%b%O}}%{!c:%U%O} \
695 objcopy --strip-dwo \
696 %{c:%{o*:%*}%{!o*:%w%b%O}}%{!c:%U%O} \
700 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
701 or extra switch-translations. */
706 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
707 or extra switch-translations. */
712 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
713 or extra switch-translations. */
715 #define CC1PLUS_SPEC ""
718 /* config.h can define LINK_SPEC to provide extra args to the linker
719 or extra switch-translations. */
724 /* config.h can define LIB_SPEC to override the default libraries. */
726 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
729 /* When using -fsplit-stack we need to wrap pthread_create, in order
730 to initialize the stack guard. We always use wrapping, rather than
731 shared library ordering, and we keep the wrapper function in
732 libgcc. This is not yet a real spec, though it could become one;
733 it is currently just stuffed into LINK_SPEC. FIXME: This wrapping
734 only works with GNU ld and gold. */
735 #ifdef HAVE_GOLD_NON_DEFAULT_SPLIT_STACK
736 #define STACK_SPLIT_SPEC " %{fsplit-stack: -fuse-ld=gold --wrap=pthread_create}"
738 #define STACK_SPLIT_SPEC " %{fsplit-stack: --wrap=pthread_create}"
742 #define STATIC_LIBASAN_LIBS \
743 " %{static-libasan|static:%:include(libsanitizer.spec)%(link_libasan)}"
744 #ifdef LIBASAN_EARLY_SPEC
745 #define LIBASAN_SPEC STATIC_LIBASAN_LIBS
746 #elif defined(HAVE_LD_STATIC_DYNAMIC)
747 #define LIBASAN_SPEC "%{static-libasan:" LD_STATIC_OPTION \
748 "} -lasan %{static-libasan:" LD_DYNAMIC_OPTION "}" \
751 #define LIBASAN_SPEC "-lasan" STATIC_LIBASAN_LIBS
755 #ifndef LIBASAN_EARLY_SPEC
756 #define LIBASAN_EARLY_SPEC ""
759 #ifndef LIBHWASAN_SPEC
760 #define STATIC_LIBHWASAN_LIBS \
761 " %{static-libhwasan|static:%:include(libsanitizer.spec)%(link_libhwasan)}"
762 #ifdef LIBHWASAN_EARLY_SPEC
763 #define LIBHWASAN_SPEC STATIC_LIBHWASAN_LIBS
764 #elif defined(HAVE_LD_STATIC_DYNAMIC)
765 #define LIBHWASAN_SPEC "%{static-libhwasan:" LD_STATIC_OPTION \
766 "} -lhwasan %{static-libhwasan:" LD_DYNAMIC_OPTION "}" \
767 STATIC_LIBHWASAN_LIBS
769 #define LIBHWASAN_SPEC "-lhwasan" STATIC_LIBHWASAN_LIBS
773 #ifndef LIBHWASAN_EARLY_SPEC
774 #define LIBHWASAN_EARLY_SPEC ""
778 #define STATIC_LIBTSAN_LIBS \
779 " %{static-libtsan|static:%:include(libsanitizer.spec)%(link_libtsan)}"
780 #ifdef LIBTSAN_EARLY_SPEC
781 #define LIBTSAN_SPEC STATIC_LIBTSAN_LIBS
782 #elif defined(HAVE_LD_STATIC_DYNAMIC)
783 #define LIBTSAN_SPEC "%{static-libtsan:" LD_STATIC_OPTION \
784 "} -ltsan %{static-libtsan:" LD_DYNAMIC_OPTION "}" \
787 #define LIBTSAN_SPEC "-ltsan" STATIC_LIBTSAN_LIBS
791 #ifndef LIBTSAN_EARLY_SPEC
792 #define LIBTSAN_EARLY_SPEC ""
796 #define STATIC_LIBLSAN_LIBS \
797 " %{static-liblsan|static:%:include(libsanitizer.spec)%(link_liblsan)}"
798 #ifdef LIBLSAN_EARLY_SPEC
799 #define LIBLSAN_SPEC STATIC_LIBLSAN_LIBS
800 #elif defined(HAVE_LD_STATIC_DYNAMIC)
801 #define LIBLSAN_SPEC "%{static-liblsan:" LD_STATIC_OPTION \
802 "} -llsan %{static-liblsan:" LD_DYNAMIC_OPTION "}" \
805 #define LIBLSAN_SPEC "-llsan" STATIC_LIBLSAN_LIBS
809 #ifndef LIBLSAN_EARLY_SPEC
810 #define LIBLSAN_EARLY_SPEC ""
813 #ifndef LIBUBSAN_SPEC
814 #define STATIC_LIBUBSAN_LIBS \
815 " %{static-libubsan|static:%:include(libsanitizer.spec)%(link_libubsan)}"
816 #ifdef HAVE_LD_STATIC_DYNAMIC
817 #define LIBUBSAN_SPEC "%{static-libubsan:" LD_STATIC_OPTION \
818 "} -lubsan %{static-libubsan:" LD_DYNAMIC_OPTION "}" \
821 #define LIBUBSAN_SPEC "-lubsan" STATIC_LIBUBSAN_LIBS
825 /* Linker options for compressed debug sections. */
826 #if HAVE_LD_COMPRESS_DEBUG == 0
827 /* No linker support. */
828 #define LINK_COMPRESS_DEBUG_SPEC \
829 " %{gz*:%e-gz is not supported in this configuration} "
830 #elif HAVE_LD_COMPRESS_DEBUG == 1
831 /* GNU style on input, GNU ld options. Reject, not useful. */
832 #define LINK_COMPRESS_DEBUG_SPEC \
833 " %{gz*:%e-gz is not supported in this configuration} "
834 #elif HAVE_LD_COMPRESS_DEBUG == 2
835 /* GNU style, GNU gold options. */
836 #define LINK_COMPRESS_DEBUG_SPEC \
837 " %{gz|gz=zlib-gnu:" LD_COMPRESS_DEBUG_OPTION "=zlib}" \
838 " %{gz=none:" LD_COMPRESS_DEBUG_OPTION "=none}" \
839 " %{gz=zlib:%e-gz=zlib is not supported in this configuration} "
840 #elif HAVE_LD_COMPRESS_DEBUG == 3
841 /* ELF gABI style. */
842 #define LINK_COMPRESS_DEBUG_SPEC \
843 " %{gz|gz=zlib:" LD_COMPRESS_DEBUG_OPTION "=zlib}" \
844 " %{gz=none:" LD_COMPRESS_DEBUG_OPTION "=none}" \
845 " %{gz=zlib-gnu:" LD_COMPRESS_DEBUG_OPTION "=zlib-gnu} "
847 #error Unknown value for HAVE_LD_COMPRESS_DEBUG.
850 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
853 #if defined(REAL_LIBGCC_SPEC)
854 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
855 #elif defined(LINK_LIBGCC_SPECIAL_1)
856 /* Have gcc do the search for libgcc.a. */
857 #define LIBGCC_SPEC "libgcc.a%s"
859 #define LIBGCC_SPEC "-lgcc"
863 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
864 #ifndef STARTFILE_SPEC
865 #define STARTFILE_SPEC \
866 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
869 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
871 #define ENDFILE_SPEC ""
875 #define LINKER_NAME "collect2"
878 #ifdef HAVE_AS_DEBUG_PREFIX_MAP
879 #define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
884 /* Assembler options for compressed debug sections. */
885 #if HAVE_LD_COMPRESS_DEBUG < 2
886 /* Reject if the linker cannot write compressed debug sections. */
887 #define ASM_COMPRESS_DEBUG_SPEC \
888 " %{gz*:%e-gz is not supported in this configuration} "
889 #else /* HAVE_LD_COMPRESS_DEBUG >= 2 */
890 #if HAVE_AS_COMPRESS_DEBUG == 0
891 /* No assembler support. Ignore silently. */
892 #define ASM_COMPRESS_DEBUG_SPEC \
894 #elif HAVE_AS_COMPRESS_DEBUG == 1
895 /* GNU style, GNU as options. */
896 #define ASM_COMPRESS_DEBUG_SPEC \
897 " %{gz|gz=zlib-gnu:" AS_COMPRESS_DEBUG_OPTION "}" \
898 " %{gz=none:" AS_NO_COMPRESS_DEBUG_OPTION "}" \
899 " %{gz=zlib:%e-gz=zlib is not supported in this configuration} "
900 #elif HAVE_AS_COMPRESS_DEBUG == 2
901 /* ELF gABI style. */
902 #define ASM_COMPRESS_DEBUG_SPEC \
903 " %{gz|gz=zlib:" AS_COMPRESS_DEBUG_OPTION "=zlib}" \
904 " %{gz=none:" AS_COMPRESS_DEBUG_OPTION "=none}" \
905 " %{gz=zlib-gnu:" AS_COMPRESS_DEBUG_OPTION "=zlib-gnu} "
907 #error Unknown value for HAVE_AS_COMPRESS_DEBUG.
909 #endif /* HAVE_LD_COMPRESS_DEBUG >= 2 */
911 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
912 to the assembler, when compiling assembly sources only. */
913 #ifndef ASM_DEBUG_SPEC
914 # if defined(HAVE_AS_GDWARF_5_DEBUG_FLAG) && defined(HAVE_AS_WORKING_DWARF_N_FLAG)
915 /* If --gdwarf-N is supported and as can handle even compiler generated
916 .debug_line with it, supply --gdwarf-N in ASM_DEBUG_OPTION_SPEC rather
917 than in ASM_DEBUG_SPEC, so that it applies to both .s and .c etc.
919 # define ASM_DEBUG_DWARF_OPTION ""
920 # elif defined(HAVE_AS_GDWARF_5_DEBUG_FLAG) && !defined(HAVE_LD_BROKEN_PE_DWARF5)
921 # define ASM_DEBUG_DWARF_OPTION "%{%:dwarf-version-gt(4):--gdwarf-5;" \
922 "%:dwarf-version-gt(3):--gdwarf-4;" \
923 "%:dwarf-version-gt(2):--gdwarf-3;" \
926 # define ASM_DEBUG_DWARF_OPTION "--gdwarf2"
928 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
929 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
930 # define ASM_DEBUG_SPEC \
931 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
932 ? "%{%:debug-level-gt(0):" \
933 "%{gdwarf*:" ASM_DEBUG_DWARF_OPTION "};" \
934 ":%{g*:--gstabs}}" ASM_MAP \
935 : "%{%:debug-level-gt(0):" \
936 "%{gstabs*:--gstabs;" \
937 ":%{g*:" ASM_DEBUG_DWARF_OPTION "}}}" ASM_MAP)
939 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
940 # define ASM_DEBUG_SPEC "%{g*:%{%:debug-level-gt(0):--gstabs}}" ASM_MAP
942 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
943 # define ASM_DEBUG_SPEC "%{g*:%{%:debug-level-gt(0):" \
944 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(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO)
962 # define ASM_DEBUG_OPTION_SPEC \
963 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
964 ? "%{%:debug-level-gt(0):" \
965 "%{gdwarf*:" ASM_DEBUG_OPTION_DWARF_OPT "}}" \
966 : "%{%:debug-level-gt(0):" \
967 "%{!gstabs*:%{g*:" ASM_DEBUG_OPTION_DWARF_OPT "}}}")
968 # elif defined(DWARF2_DEBUGGING_INFO)
969 # define ASM_DEBUG_OPTION_SPEC "%{g*:%{%:debug-level-gt(0):" \
970 ASM_DEBUG_OPTION_DWARF_OPT "}}"
974 #ifndef ASM_DEBUG_OPTION_SPEC
975 # define ASM_DEBUG_OPTION_SPEC ""
978 /* Here is the spec for running the linker, after compiling all files. */
980 /* This is overridable by the target in case they need to specify the
981 -lgcc and -lc order specially, yet not require them to override all
982 of LINK_COMMAND_SPEC. */
983 #ifndef LINK_GCC_C_SEQUENCE_SPEC
984 #define LINK_GCC_C_SEQUENCE_SPEC "%G %{!nolibc:%L %G}"
987 #ifndef LINK_SSP_SPEC
988 #ifdef TARGET_LIBC_PROVIDES_SSP
989 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all" \
990 "|fstack-protector-strong|fstack-protector-explicit:}"
992 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all" \
993 "|fstack-protector-strong|fstack-protector-explicit" \
994 ":-lssp_nonshared -lssp}"
998 #ifdef ENABLE_DEFAULT_PIE
999 #define PIE_SPEC "!no-pie"
1000 #define NO_FPIE1_SPEC "fno-pie"
1001 #define FPIE1_SPEC NO_FPIE1_SPEC ":;"
1002 #define NO_FPIE2_SPEC "fno-PIE"
1003 #define FPIE2_SPEC NO_FPIE2_SPEC ":;"
1004 #define NO_FPIE_SPEC NO_FPIE1_SPEC "|" NO_FPIE2_SPEC
1005 #define FPIE_SPEC NO_FPIE_SPEC ":;"
1006 #define NO_FPIC1_SPEC "fno-pic"
1007 #define FPIC1_SPEC NO_FPIC1_SPEC ":;"
1008 #define NO_FPIC2_SPEC "fno-PIC"
1009 #define FPIC2_SPEC NO_FPIC2_SPEC ":;"
1010 #define NO_FPIC_SPEC NO_FPIC1_SPEC "|" NO_FPIC2_SPEC
1011 #define FPIC_SPEC NO_FPIC_SPEC ":;"
1012 #define NO_FPIE1_AND_FPIC1_SPEC NO_FPIE1_SPEC "|" NO_FPIC1_SPEC
1013 #define FPIE1_OR_FPIC1_SPEC NO_FPIE1_AND_FPIC1_SPEC ":;"
1014 #define NO_FPIE2_AND_FPIC2_SPEC NO_FPIE2_SPEC "|" NO_FPIC2_SPEC
1015 #define FPIE2_OR_FPIC2_SPEC NO_FPIE2_AND_FPIC2_SPEC ":;"
1016 #define NO_FPIE_AND_FPIC_SPEC NO_FPIE_SPEC "|" NO_FPIC_SPEC
1017 #define FPIE_OR_FPIC_SPEC NO_FPIE_AND_FPIC_SPEC ":;"
1019 #define PIE_SPEC "pie"
1020 #define FPIE1_SPEC "fpie"
1021 #define NO_FPIE1_SPEC FPIE1_SPEC ":;"
1022 #define FPIE2_SPEC "fPIE"
1023 #define NO_FPIE2_SPEC FPIE2_SPEC ":;"
1024 #define FPIE_SPEC FPIE1_SPEC "|" FPIE2_SPEC
1025 #define NO_FPIE_SPEC FPIE_SPEC ":;"
1026 #define FPIC1_SPEC "fpic"
1027 #define NO_FPIC1_SPEC FPIC1_SPEC ":;"
1028 #define FPIC2_SPEC "fPIC"
1029 #define NO_FPIC2_SPEC FPIC2_SPEC ":;"
1030 #define FPIC_SPEC FPIC1_SPEC "|" FPIC2_SPEC
1031 #define NO_FPIC_SPEC FPIC_SPEC ":;"
1032 #define FPIE1_OR_FPIC1_SPEC FPIE1_SPEC "|" FPIC1_SPEC
1033 #define NO_FPIE1_AND_FPIC1_SPEC FPIE1_OR_FPIC1_SPEC ":;"
1034 #define FPIE2_OR_FPIC2_SPEC FPIE2_SPEC "|" FPIC2_SPEC
1035 #define NO_FPIE2_AND_FPIC2_SPEC FPIE1_OR_FPIC2_SPEC ":;"
1036 #define FPIE_OR_FPIC_SPEC FPIE_SPEC "|" FPIC_SPEC
1037 #define NO_FPIE_AND_FPIC_SPEC FPIE_OR_FPIC_SPEC ":;"
1040 #ifndef LINK_PIE_SPEC
1043 #define LD_PIE_SPEC "-pie"
1046 #define LD_PIE_SPEC ""
1048 #define LINK_PIE_SPEC "%{static|shared|r:;" PIE_SPEC ":" LD_PIE_SPEC "} "
1051 #ifndef LINK_BUILDID_SPEC
1052 # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
1053 # define LINK_BUILDID_SPEC "%{!r:--build-id} "
1057 #ifndef LTO_PLUGIN_SPEC
1058 #define LTO_PLUGIN_SPEC ""
1061 /* Conditional to test whether the LTO plugin is used or not.
1062 FIXME: For slim LTO we will need to enable plugin unconditionally. This
1063 still cause problems with PLUGIN_LD != LD and when plugin is built but
1064 not useable. For GCC 4.6 we don't support slim LTO and thus we can enable
1065 plugin only when LTO is enabled. We still honor explicit
1066 -fuse-linker-plugin if the linker used understands -plugin. */
1068 /* The linker has some plugin support. */
1069 #if HAVE_LTO_PLUGIN > 0
1070 /* The linker used has full plugin support, use LTO plugin by default. */
1071 #if HAVE_LTO_PLUGIN == 2
1072 #define PLUGIN_COND "!fno-use-linker-plugin:%{!fno-lto"
1073 #define PLUGIN_COND_CLOSE "}"
1075 /* The linker used has limited plugin support, use LTO plugin with explicit
1076 -fuse-linker-plugin. */
1077 #define PLUGIN_COND "fuse-linker-plugin"
1078 #define PLUGIN_COND_CLOSE ""
1080 #define LINK_PLUGIN_SPEC \
1081 "%{" PLUGIN_COND": \
1082 -plugin %(linker_plugin_file) \
1083 -plugin-opt=%(lto_wrapper) \
1084 -plugin-opt=-fresolution=%u.res \
1085 " LTO_PLUGIN_SPEC "\
1086 %{flinker-output=*:-plugin-opt=-linker-output-known} \
1087 %{!nostdlib:%{!nodefaultlibs:%:pass-through-libs(%(link_gcc_c_sequence))}} \
1088 }" PLUGIN_COND_CLOSE
1090 /* The linker used doesn't support -plugin, reject -fuse-linker-plugin. */
1091 #define LINK_PLUGIN_SPEC "%{fuse-linker-plugin:\
1092 %e-fuse-linker-plugin is not supported in this configuration}"
1095 /* Linker command line options for -fsanitize= early on the command line. */
1096 #ifndef SANITIZER_EARLY_SPEC
1097 #define SANITIZER_EARLY_SPEC "\
1098 %{!nostdlib:%{!r:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_EARLY_SPEC "} \
1099 %{%:sanitize(hwaddress):" LIBHWASAN_EARLY_SPEC "} \
1100 %{%:sanitize(thread):" LIBTSAN_EARLY_SPEC "} \
1101 %{%:sanitize(leak):" LIBLSAN_EARLY_SPEC "}}}}"
1104 /* Linker command line options for -fsanitize= late on the command line. */
1105 #ifndef SANITIZER_SPEC
1106 #define SANITIZER_SPEC "\
1107 %{!nostdlib:%{!r:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_SPEC "\
1108 %{static:%ecannot specify -static with -fsanitize=address}}\
1109 %{%:sanitize(hwaddress):" LIBHWASAN_SPEC "\
1110 %{static:%ecannot specify -static with -fsanitize=hwaddress}}\
1111 %{%:sanitize(thread):" LIBTSAN_SPEC "\
1112 %{static:%ecannot specify -static with -fsanitize=thread}}\
1113 %{%:sanitize(undefined):" LIBUBSAN_SPEC "}\
1114 %{%:sanitize(leak):" LIBLSAN_SPEC "}}}}"
1117 #ifndef POST_LINK_SPEC
1118 #define POST_LINK_SPEC ""
1121 /* This is the spec to use, once the code for creating the vtable
1122 verification runtime library, libvtv.so, has been created. Currently
1123 the vtable verification runtime functions are in libstdc++, so we use
1124 the spec just below this one. */
1125 #ifndef VTABLE_VERIFICATION_SPEC
1126 #if ENABLE_VTABLE_VERIFY
1127 #define VTABLE_VERIFICATION_SPEC "\
1128 %{!nostdlib:%{!r:%{fvtable-verify=std: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}\
1129 %{fvtable-verify=preinit: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}}}"
1131 #define VTABLE_VERIFICATION_SPEC "\
1132 %{fvtable-verify=none:} \
1133 %{fvtable-verify=std: \
1134 %e-fvtable-verify=std is not supported in this configuration} \
1135 %{fvtable-verify=preinit: \
1136 %e-fvtable-verify=preinit is not supported in this configuration}"
1140 /* -u* was put back because both BSD and SysV seem to support it. */
1141 /* %{static|no-pie|static-pie:} simply prevents an error message:
1142 1. If the target machine doesn't handle -static.
1143 2. If PIE isn't enabled by default.
1144 3. If the target machine doesn't handle -static-pie.
1146 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
1147 scripts which exist in user specified directories, or in standard
1149 /* We pass any -flto flags on to the linker, which is expected
1150 to understand them. In practice, this means it had better be collect2. */
1151 /* %{e*} includes -export-dynamic; see comment in common.opt. */
1152 #ifndef LINK_COMMAND_SPEC
1153 #define LINK_COMMAND_SPEC "\
1154 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
1157 "%{flto|flto=*:%<fcompare-debug*} \
1158 %{flto} %{fno-lto} %{flto=*} %l " LINK_PIE_SPEC \
1159 "%{fuse-ld=*:-fuse-ld=%*} " LINK_COMPRESS_DEBUG_SPEC \
1160 "%X %{o*} %{e*} %{N} %{n} %{r}\
1161 %{s} %{t} %{u*} %{z} %{Z} %{!nostdlib:%{!r:%{!nostartfiles:%S}}} \
1162 %{static|no-pie|static-pie:} %@{L*} %(mfwrap) %(link_libgcc) " \
1163 VTABLE_VERIFICATION_SPEC " " SANITIZER_EARLY_SPEC " %o "" \
1164 %{fopenacc|fopenmp|%:gt(%{ftree-parallelize-loops=*:%*} 1):\
1165 %:include(libgomp.spec)%(link_gomp)}\
1166 %{fgnu-tm:%:include(libitm.spec)%(link_itm)}\
1167 %(mflib) " STACK_SPLIT_SPEC "\
1168 %{fprofile-arcs|fprofile-generate*|coverage:-lgcov} " SANITIZER_SPEC " \
1169 %{!nostdlib:%{!r:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}}\
1170 %{!nostdlib:%{!r:%{!nostartfiles:%E}}} %{T*} \n%(post_link) }}}}}}"
1173 #ifndef LINK_LIBGCC_SPEC
1174 /* Generate -L options for startfile prefix list. */
1175 # define LINK_LIBGCC_SPEC "%D"
1178 #ifndef STARTFILE_PREFIX_SPEC
1179 # define STARTFILE_PREFIX_SPEC ""
1182 #ifndef SYSROOT_SPEC
1183 # define SYSROOT_SPEC "--sysroot=%R"
1186 #ifndef SYSROOT_SUFFIX_SPEC
1187 # define SYSROOT_SUFFIX_SPEC ""
1190 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
1191 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
1194 static const char *asm_debug
= ASM_DEBUG_SPEC
;
1195 static const char *asm_debug_option
= ASM_DEBUG_OPTION_SPEC
;
1196 static const char *cpp_spec
= CPP_SPEC
;
1197 static const char *cc1_spec
= CC1_SPEC
;
1198 static const char *cc1plus_spec
= CC1PLUS_SPEC
;
1199 static const char *link_gcc_c_sequence_spec
= LINK_GCC_C_SEQUENCE_SPEC
;
1200 static const char *link_ssp_spec
= LINK_SSP_SPEC
;
1201 static const char *asm_spec
= ASM_SPEC
;
1202 static const char *asm_final_spec
= ASM_FINAL_SPEC
;
1203 static const char *link_spec
= LINK_SPEC
;
1204 static const char *lib_spec
= LIB_SPEC
;
1205 static const char *link_gomp_spec
= "";
1206 static const char *libgcc_spec
= LIBGCC_SPEC
;
1207 static const char *endfile_spec
= ENDFILE_SPEC
;
1208 static const char *startfile_spec
= STARTFILE_SPEC
;
1209 static const char *linker_name_spec
= LINKER_NAME
;
1210 static const char *linker_plugin_file_spec
= "";
1211 static const char *lto_wrapper_spec
= "";
1212 static const char *lto_gcc_spec
= "";
1213 static const char *post_link_spec
= POST_LINK_SPEC
;
1214 static const char *link_command_spec
= LINK_COMMAND_SPEC
;
1215 static const char *link_libgcc_spec
= LINK_LIBGCC_SPEC
;
1216 static const char *startfile_prefix_spec
= STARTFILE_PREFIX_SPEC
;
1217 static const char *sysroot_spec
= SYSROOT_SPEC
;
1218 static const char *sysroot_suffix_spec
= SYSROOT_SUFFIX_SPEC
;
1219 static const char *sysroot_hdrs_suffix_spec
= SYSROOT_HEADERS_SUFFIX_SPEC
;
1220 static const char *self_spec
= "";
1222 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
1223 There should be no need to override these in target dependent files,
1224 but we need to copy them to the specs file so that newer versions
1225 of the GCC driver can correctly drive older tool chains with the
1226 appropriate -B options. */
1228 /* When cpplib handles traditional preprocessing, get rid of this, and
1229 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
1230 that we default the front end language better. */
1231 static const char *trad_capable_cpp
=
1232 "cc1 -E %{traditional|traditional-cpp:-traditional-cpp}";
1234 /* We don't wrap .d files in %W{} since a missing .d file, and
1235 therefore no dependency entry, confuses make into thinking a .o
1236 file that happens to exist is up-to-date. */
1237 static const char *cpp_unique_options
=
1238 "%{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %@{I*&F*} %{P} %I\
1239 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
1240 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
1241 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
1242 %{Mmodules} %{Mno-modules}\
1243 %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
1244 %{remap} %{%:debug-level-gt(2):-dD}\
1245 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
1246 %{H} %C %{D*&U*&A*} %{i*} %Z %i\
1249 /* This contains cpp options which are common with cc1_options and are passed
1250 only when preprocessing only to avoid duplication. We pass the cc1 spec
1251 options to the preprocessor so that it the cc1 spec may manipulate
1252 options used to set target flags. Those special target flags settings may
1253 in turn cause preprocessor symbols to be defined specially. */
1254 static const char *cpp_options
=
1255 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
1256 %{f*} %{g*:%{%:debug-level-gt(0):%{g*}\
1257 %{!fno-working-directory:-fworking-directory}}} %{O*}\
1258 %{undef} %{save-temps*:-fpch-preprocess}";
1260 /* Pass -d* flags, possibly modifying -dumpdir, -dumpbase et al.
1262 Make it easy for a language to override the argument for the
1263 %:dumps specs function call. */
1264 #define DUMPS_OPTIONS(EXTS) \
1265 "%<dumpdir %<dumpbase %<dumpbase-ext %{d*} %:dumps(" EXTS ")"
1267 /* This contains cpp options which are not passed when the preprocessor
1268 output will be used by another program. */
1269 static const char *cpp_debug_options
= DUMPS_OPTIONS ("");
1271 /* NB: This is shared amongst all front-ends, except for Ada. */
1272 static const char *cc1_options
=
1273 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
1274 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
1275 %1 %{!Q:-quiet} %(cpp_debug_options) %{m*} %{aux-info*}\
1276 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
1277 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
1278 %{Qn:-fno-ident} %{Qy:} %{-help:--help}\
1279 %{-target-help:--target-help}\
1280 %{-version:--version}\
1281 %{-help=*:--help=%*}\
1282 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %w%b.s}}}\
1283 %{fsyntax-only:-o %j} %{-param*}\
1284 %{coverage:-fprofile-arcs -ftest-coverage}\
1285 %{fprofile-arcs|fprofile-generate*|coverage:\
1286 %{!fprofile-update=single:\
1287 %{pthread:-fprofile-update=prefer-atomic}}}";
1289 static const char *asm_options
=
1290 "%{-target-help:%:print-asm-header()} "
1292 /* If GNU AS is used, then convert -w (no warnings), -I, and -v
1293 to the assembler equivalents. */
1294 "%{v} %{w:-W} %{I*} "
1296 "%(asm_debug_option)"
1297 ASM_COMPRESS_DEBUG_SPEC
1298 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
1300 static const char *invoke_as
=
1301 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1303 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
1304 %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
1308 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
1309 %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
1313 /* Some compilers have limits on line lengths, and the multilib_select
1314 and/or multilib_matches strings can be very long, so we build them at
1316 static struct obstack multilib_obstack
;
1317 static const char *multilib_select
;
1318 static const char *multilib_matches
;
1319 static const char *multilib_defaults
;
1320 static const char *multilib_exclusions
;
1321 static const char *multilib_reuse
;
1323 /* Check whether a particular argument is a default argument. */
1325 #ifndef MULTILIB_DEFAULTS
1326 #define MULTILIB_DEFAULTS { "" }
1329 static const char *const multilib_defaults_raw
[] = MULTILIB_DEFAULTS
;
1331 #ifndef DRIVER_SELF_SPECS
1332 #define DRIVER_SELF_SPECS ""
1335 /* Linking to libgomp implies pthreads. This is particularly important
1336 for targets that use different start files and suchlike. */
1337 #ifndef GOMP_SELF_SPECS
1338 #define GOMP_SELF_SPECS \
1339 "%{fopenacc|fopenmp|%:gt(%{ftree-parallelize-loops=*:%*} 1): " \
1343 /* Likewise for -fgnu-tm. */
1344 #ifndef GTM_SELF_SPECS
1345 #define GTM_SELF_SPECS "%{fgnu-tm: -pthread}"
1348 static const char *const driver_self_specs
[] = {
1349 "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
1350 DRIVER_SELF_SPECS
, CONFIGURE_SPECS
, GOMP_SELF_SPECS
, GTM_SELF_SPECS
1353 #ifndef OPTION_DEFAULT_SPECS
1354 #define OPTION_DEFAULT_SPECS { "", "" }
1363 static const struct default_spec
1364 option_default_specs
[] = { OPTION_DEFAULT_SPECS
};
1368 struct user_specs
*next
;
1369 const char *filename
;
1372 static struct user_specs
*user_specs_head
, *user_specs_tail
;
1375 /* Record the mapping from file suffixes for compilation specs. */
1379 const char *suffix
; /* Use this compiler for input files
1380 whose names end in this suffix. */
1382 const char *spec
; /* To use this compiler, run this spec. */
1384 const char *cpp_spec
; /* If non-NULL, substitute this spec
1385 for `%C', rather than the usual
1387 int combinable
; /* If nonzero, compiler can deal with
1388 multiple source files at once (IMA). */
1389 int needs_preprocessing
; /* If nonzero, source files need to
1390 be run through a preprocessor. */
1393 /* Pointer to a vector of `struct compiler' that gives the spec for
1394 compiling a file, based on its suffix.
1395 A file that does not end in any of these suffixes will be passed
1396 unchanged to the loader and nothing else will be done to it.
1398 An entry containing two 0s is used to terminate the vector.
1400 If multiple entries match a file, the last matching one is used. */
1402 static struct compiler
*compilers
;
1404 /* Number of entries in `compilers', not counting the null terminator. */
1406 static int n_compilers
;
1408 /* The default list of file name suffixes and their compilation specs. */
1410 static const struct compiler default_compilers
[] =
1412 /* Add lists of suffixes of known languages here. If those languages
1413 were not present when we built the driver, we will hit these copies
1414 and be given a more meaningful error than "file not used since
1415 linking is not done". */
1416 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0},
1417 {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
1418 {".mii", "#Objective-C++", 0, 0, 0},
1419 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
1420 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
1421 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
1422 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
1423 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
1424 {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
1425 {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
1426 {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
1427 {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
1428 {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
1429 {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
1430 {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
1431 {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
1432 {".r", "#Ratfor", 0, 0, 0},
1433 {".go", "#Go", 0, 1, 0},
1434 {".d", "#D", 0, 1, 0}, {".dd", "#D", 0, 1, 0}, {".di", "#D", 0, 1, 0},
1435 /* Next come the entries for C. */
1436 {".c", "@c", 0, 0, 1},
1438 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1439 external preprocessor if -save-temps is given. */
1440 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1443 %eGNU C no longer supports -traditional without -E}\
1444 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1445 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1446 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1448 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1449 cc1 %(cpp_unique_options) %(cc1_options)}}}\
1450 %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 1},
1452 "%{!E:%e-E or -x required when input is from standard input}\
1453 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
1454 {".h", "@c-header", 0, 0, 0},
1456 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1457 external preprocessor if -save-temps is given. */
1458 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1460 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1461 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1462 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1464 %{!fsyntax-only:%{!S:-o %g.s} \
1465 %{!fdump-ada-spec*:%{!o*:--output-pch %i.gch}\
1466 %W{o*:--output-pch %*}}%V}}\
1467 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1468 cc1 %(cpp_unique_options) %(cc1_options)\
1469 %{!fsyntax-only:%{!S:-o %g.s} \
1470 %{!fdump-ada-spec*:%{!o*:--output-pch %i.gch}\
1471 %W{o*:--output-pch %*}}%V}}}}}}}", 0, 0, 0},
1472 {".i", "@cpp-output", 0, 0, 0},
1474 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 0},
1475 {".s", "@assembler", 0, 0, 0},
1477 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 0, 0},
1478 {".sx", "@assembler-with-cpp", 0, 0, 0},
1479 {".S", "@assembler-with-cpp", 0, 0, 0},
1480 {"@assembler-with-cpp",
1481 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1482 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1483 %{E|M|MM:%(cpp_debug_options)}\
1484 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1485 as %(asm_debug) %(asm_options) %|.s %A }}}}"
1487 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1488 %{E|M|MM:%(cpp_debug_options)}\
1489 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1490 as %(asm_debug) %(asm_options) %m.s %A }}}}"
1495 /* Mark end of table. */
1499 /* Number of elements in default_compilers, not counting the terminator. */
1501 static const int n_default_compilers
= ARRAY_SIZE (default_compilers
) - 1;
1503 typedef char *char_p
; /* For DEF_VEC_P. */
1505 /* A vector of options to give to the linker.
1506 These options are accumulated by %x,
1507 and substituted into the linker command with %X. */
1508 static vec
<char_p
> linker_options
;
1510 /* A vector of options to give to the assembler.
1511 These options are accumulated by -Wa,
1512 and substituted into the assembler command with %Y. */
1513 static vec
<char_p
> assembler_options
;
1515 /* A vector of options to give to the preprocessor.
1516 These options are accumulated by -Wp,
1517 and substituted into the preprocessor command with %Z. */
1518 static vec
<char_p
> preprocessor_options
;
1521 skip_whitespace (char *p
)
1525 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1526 be considered whitespace. */
1527 if (p
[0] == '\n' && p
[1] == '\n' && p
[2] == '\n')
1529 else if (*p
== '\n' || *p
== ' ' || *p
== '\t')
1543 /* Structures to keep track of prefixes to try when looking for files. */
1547 const char *prefix
; /* String to prepend to the path. */
1548 struct prefix_list
*next
; /* Next in linked list. */
1549 int require_machine_suffix
; /* Don't use without machine_suffix. */
1550 /* 2 means try both machine_suffix and just_machine_suffix. */
1551 int priority
; /* Sort key - priority within list. */
1552 int os_multilib
; /* 1 if OS multilib scheme should be used,
1553 0 for GCC multilib scheme. */
1558 struct prefix_list
*plist
; /* List of prefixes to try */
1559 int max_len
; /* Max length of a prefix in PLIST */
1560 const char *name
; /* Name of this list (used in config stuff) */
1563 /* List of prefixes to try when looking for executables. */
1565 static struct path_prefix exec_prefixes
= { 0, 0, "exec" };
1567 /* List of prefixes to try when looking for startup (crt0) files. */
1569 static struct path_prefix startfile_prefixes
= { 0, 0, "startfile" };
1571 /* List of prefixes to try when looking for include files. */
1573 static struct path_prefix include_prefixes
= { 0, 0, "include" };
1575 /* Suffix to attach to directories searched for commands.
1576 This looks like `MACHINE/VERSION/'. */
1578 static const char *machine_suffix
= 0;
1580 /* Suffix to attach to directories searched for commands.
1581 This is just `MACHINE/'. */
1583 static const char *just_machine_suffix
= 0;
1585 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1587 static const char *gcc_exec_prefix
;
1589 /* Adjusted value of standard_libexec_prefix. */
1591 static const char *gcc_libexec_prefix
;
1593 /* Default prefixes to attach to command names. */
1595 #ifndef STANDARD_STARTFILE_PREFIX_1
1596 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1598 #ifndef STANDARD_STARTFILE_PREFIX_2
1599 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1602 #ifdef CROSS_DIRECTORY_STRUCTURE /* Don't use these prefixes for a cross compiler. */
1603 #undef MD_EXEC_PREFIX
1604 #undef MD_STARTFILE_PREFIX
1605 #undef MD_STARTFILE_PREFIX_1
1608 /* If no prefixes defined, use the null string, which will disable them. */
1609 #ifndef MD_EXEC_PREFIX
1610 #define MD_EXEC_PREFIX ""
1612 #ifndef MD_STARTFILE_PREFIX
1613 #define MD_STARTFILE_PREFIX ""
1615 #ifndef MD_STARTFILE_PREFIX_1
1616 #define MD_STARTFILE_PREFIX_1 ""
1619 /* These directories are locations set at configure-time based on the
1620 --prefix option provided to configure. Their initializers are
1621 defined in Makefile.in. These paths are not *directly* used when
1622 gcc_exec_prefix is set because, in that case, we know where the
1623 compiler has been installed, and use paths relative to that
1624 location instead. */
1625 static const char *const standard_exec_prefix
= STANDARD_EXEC_PREFIX
;
1626 static const char *const standard_libexec_prefix
= STANDARD_LIBEXEC_PREFIX
;
1627 static const char *const standard_bindir_prefix
= STANDARD_BINDIR_PREFIX
;
1628 static const char *const standard_startfile_prefix
= STANDARD_STARTFILE_PREFIX
;
1630 /* For native compilers, these are well-known paths containing
1631 components that may be provided by the system. For cross
1632 compilers, these paths are not used. */
1633 static const char *md_exec_prefix
= MD_EXEC_PREFIX
;
1634 static const char *md_startfile_prefix
= MD_STARTFILE_PREFIX
;
1635 static const char *md_startfile_prefix_1
= MD_STARTFILE_PREFIX_1
;
1636 static const char *const standard_startfile_prefix_1
1637 = STANDARD_STARTFILE_PREFIX_1
;
1638 static const char *const standard_startfile_prefix_2
1639 = STANDARD_STARTFILE_PREFIX_2
;
1641 /* A relative path to be used in finding the location of tools
1642 relative to the driver. */
1643 static const char *const tooldir_base_prefix
= TOOLDIR_BASE_PREFIX
;
1645 /* A prefix to be used when this is an accelerator compiler. */
1646 static const char *const accel_dir_suffix
= ACCEL_DIR_SUFFIX
;
1648 /* Subdirectory to use for locating libraries. Set by
1649 set_multilib_dir based on the compilation options. */
1651 static const char *multilib_dir
;
1653 /* Subdirectory to use for locating libraries in OS conventions. Set by
1654 set_multilib_dir based on the compilation options. */
1656 static const char *multilib_os_dir
;
1658 /* Subdirectory to use for locating libraries in multiarch conventions. Set by
1659 set_multilib_dir based on the compilation options. */
1661 static const char *multiarch_dir
;
1663 /* Structure to keep track of the specs that have been defined so far.
1664 These are accessed using %(specname) in a compiler or link
1669 /* The following 2 fields must be first */
1670 /* to allow EXTRA_SPECS to be initialized */
1671 const char *name
; /* name of the spec. */
1672 const char *ptr
; /* available ptr if no static pointer */
1674 /* The following fields are not initialized */
1675 /* by EXTRA_SPECS */
1676 const char **ptr_spec
; /* pointer to the spec itself. */
1677 struct spec_list
*next
; /* Next spec in linked list. */
1678 int name_len
; /* length of the name */
1679 bool user_p
; /* whether string come from file spec. */
1680 bool alloc_p
; /* whether string was allocated */
1681 const char *default_ptr
; /* The default value of *ptr_spec. */
1684 #define INIT_STATIC_SPEC(NAME,PTR) \
1685 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, false, false, \
1688 /* List of statically defined specs. */
1689 static struct spec_list static_specs
[] =
1691 INIT_STATIC_SPEC ("asm", &asm_spec
),
1692 INIT_STATIC_SPEC ("asm_debug", &asm_debug
),
1693 INIT_STATIC_SPEC ("asm_debug_option", &asm_debug_option
),
1694 INIT_STATIC_SPEC ("asm_final", &asm_final_spec
),
1695 INIT_STATIC_SPEC ("asm_options", &asm_options
),
1696 INIT_STATIC_SPEC ("invoke_as", &invoke_as
),
1697 INIT_STATIC_SPEC ("cpp", &cpp_spec
),
1698 INIT_STATIC_SPEC ("cpp_options", &cpp_options
),
1699 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options
),
1700 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options
),
1701 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp
),
1702 INIT_STATIC_SPEC ("cc1", &cc1_spec
),
1703 INIT_STATIC_SPEC ("cc1_options", &cc1_options
),
1704 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec
),
1705 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec
),
1706 INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec
),
1707 INIT_STATIC_SPEC ("endfile", &endfile_spec
),
1708 INIT_STATIC_SPEC ("link", &link_spec
),
1709 INIT_STATIC_SPEC ("lib", &lib_spec
),
1710 INIT_STATIC_SPEC ("link_gomp", &link_gomp_spec
),
1711 INIT_STATIC_SPEC ("libgcc", &libgcc_spec
),
1712 INIT_STATIC_SPEC ("startfile", &startfile_spec
),
1713 INIT_STATIC_SPEC ("cross_compile", &cross_compile
),
1714 INIT_STATIC_SPEC ("version", &compiler_version
),
1715 INIT_STATIC_SPEC ("multilib", &multilib_select
),
1716 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults
),
1717 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra
),
1718 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches
),
1719 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions
),
1720 INIT_STATIC_SPEC ("multilib_options", &multilib_options
),
1721 INIT_STATIC_SPEC ("multilib_reuse", &multilib_reuse
),
1722 INIT_STATIC_SPEC ("linker", &linker_name_spec
),
1723 INIT_STATIC_SPEC ("linker_plugin_file", &linker_plugin_file_spec
),
1724 INIT_STATIC_SPEC ("lto_wrapper", <o_wrapper_spec
),
1725 INIT_STATIC_SPEC ("lto_gcc", <o_gcc_spec
),
1726 INIT_STATIC_SPEC ("post_link", &post_link_spec
),
1727 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec
),
1728 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix
),
1729 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix
),
1730 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1
),
1731 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec
),
1732 INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec
),
1733 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec
),
1734 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec
),
1735 INIT_STATIC_SPEC ("self_spec", &self_spec
),
1738 #ifdef EXTRA_SPECS /* additional specs needed */
1739 /* Structure to keep track of just the first two args of a spec_list.
1740 That is all that the EXTRA_SPECS macro gives us. */
1743 const char *const name
;
1744 const char *const ptr
;
1747 static const struct spec_list_1 extra_specs_1
[] = { EXTRA_SPECS
};
1748 static struct spec_list
*extra_specs
= (struct spec_list
*) 0;
1751 /* List of dynamically allocates specs that have been defined so far. */
1753 static struct spec_list
*specs
= (struct spec_list
*) 0;
1755 /* List of static spec functions. */
1757 static const struct spec_function static_spec_functions
[] =
1759 { "getenv", getenv_spec_function
},
1760 { "if-exists", if_exists_spec_function
},
1761 { "if-exists-else", if_exists_else_spec_function
},
1762 { "if-exists-then-else", if_exists_then_else_spec_function
},
1763 { "sanitize", sanitize_spec_function
},
1764 { "replace-outfile", replace_outfile_spec_function
},
1765 { "remove-outfile", remove_outfile_spec_function
},
1766 { "version-compare", version_compare_spec_function
},
1767 { "include", include_spec_function
},
1768 { "find-file", find_file_spec_function
},
1769 { "find-plugindir", find_plugindir_spec_function
},
1770 { "print-asm-header", print_asm_header_spec_function
},
1771 { "compare-debug-dump-opt", compare_debug_dump_opt_spec_function
},
1772 { "compare-debug-self-opt", compare_debug_self_opt_spec_function
},
1773 { "pass-through-libs", pass_through_libs_spec_func
},
1774 { "dumps", dumps_spec_func
},
1775 { "gt", greater_than_spec_func
},
1776 { "debug-level-gt", debug_level_greater_than_spec_func
},
1777 { "dwarf-version-gt", dwarf_version_greater_than_spec_func
},
1778 { "fortran-preinclude-file", find_fortran_preinclude_file
},
1779 #ifdef EXTRA_SPEC_FUNCTIONS
1780 EXTRA_SPEC_FUNCTIONS
1785 static int processing_spec_function
;
1787 /* Add appropriate libgcc specs to OBSTACK, taking into account
1788 various permutations of -shared-libgcc, -shared, and such. */
1790 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1792 #ifndef USE_LD_AS_NEEDED
1793 #define USE_LD_AS_NEEDED 0
1797 init_gcc_specs (struct obstack
*obstack
, const char *shared_name
,
1798 const char *static_name
, const char *eh_name
)
1802 #if USE_LD_AS_NEEDED
1803 buf
= concat ("%{static|static-libgcc|static-pie:", static_name
, " ", eh_name
, "}"
1804 "%{!static:%{!static-libgcc:%{!static-pie:"
1805 "%{!shared-libgcc:",
1806 static_name
, " " LD_AS_NEEDED_OPTION
" ",
1807 shared_name
, " " LD_NO_AS_NEEDED_OPTION
1810 shared_name
, "%{!shared: ", static_name
, "}"
1813 buf
= concat ("%{static|static-libgcc:", static_name
, " ", eh_name
, "}"
1814 "%{!static:%{!static-libgcc:"
1816 "%{!shared-libgcc:", static_name
, " ", eh_name
, "}"
1817 "%{shared-libgcc:", shared_name
, " ", static_name
, "}"
1821 "%{shared-libgcc:", shared_name
, "}"
1822 "%{!shared-libgcc:", static_name
, "}"
1825 "%{shared:", shared_name
, "}"
1830 obstack_grow (obstack
, buf
, strlen (buf
));
1833 #endif /* ENABLE_SHARED_LIBGCC */
1835 /* Initialize the specs lookup routines. */
1840 struct spec_list
*next
= (struct spec_list
*) 0;
1841 struct spec_list
*sl
= (struct spec_list
*) 0;
1845 return; /* Already initialized. */
1848 fnotice (stderr
, "Using built-in specs.\n");
1851 extra_specs
= XCNEWVEC (struct spec_list
, ARRAY_SIZE (extra_specs_1
));
1853 for (i
= ARRAY_SIZE (extra_specs_1
) - 1; i
>= 0; i
--)
1855 sl
= &extra_specs
[i
];
1856 sl
->name
= extra_specs_1
[i
].name
;
1857 sl
->ptr
= extra_specs_1
[i
].ptr
;
1859 sl
->name_len
= strlen (sl
->name
);
1860 sl
->ptr_spec
= &sl
->ptr
;
1861 gcc_assert (sl
->ptr_spec
!= NULL
);
1862 sl
->default_ptr
= sl
->ptr
;
1867 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1869 sl
= &static_specs
[i
];
1874 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1875 /* ??? If neither -shared-libgcc nor --static-libgcc was
1876 seen, then we should be making an educated guess. Some proposed
1877 heuristics for ELF include:
1879 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1880 program will be doing dynamic loading, which will likely
1881 need the shared libgcc.
1883 (2) If "-ldl", then it's also a fair bet that we're doing
1886 (3) For each ET_DYN we're linking against (either through -lfoo
1887 or /some/path/foo.so), check to see whether it or one of
1888 its dependencies depends on a shared libgcc.
1892 If the runtime is fixed to look for program headers instead
1893 of calling __register_frame_info at all, for each object,
1894 use the shared libgcc if any EH symbol referenced.
1896 If crtstuff is fixed to not invoke __register_frame_info
1897 automatically, for each object, use the shared libgcc if
1898 any non-empty unwind section found.
1900 Doing any of this probably requires invoking an external program to
1901 do the actual object file scanning. */
1903 const char *p
= libgcc_spec
;
1906 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1907 when given the proper command line arguments. */
1910 if (in_sep
&& *p
== '-' && startswith (p
, "-lgcc"))
1912 init_gcc_specs (&obstack
,
1914 #ifdef USE_LIBUNWIND_EXCEPTIONS
1920 #ifdef USE_LIBUNWIND_EXCEPTIONS
1921 # ifdef HAVE_LD_STATIC_DYNAMIC
1922 " %{!static:%{!static-pie:" LD_STATIC_OPTION
"}} -lunwind"
1923 " %{!static:%{!static-pie:" LD_DYNAMIC_OPTION
"}}"
1933 else if (in_sep
&& *p
== 'l' && startswith (p
, "libgcc.a%s"))
1935 /* Ug. We don't know shared library extensions. Hope that
1936 systems that use this form don't do shared libraries. */
1937 init_gcc_specs (&obstack
,
1941 #ifdef USE_LIBUNWIND_EXCEPTIONS
1950 obstack_1grow (&obstack
, *p
);
1951 in_sep
= (*p
== ' ');
1956 obstack_1grow (&obstack
, '\0');
1957 libgcc_spec
= XOBFINISH (&obstack
, const char *);
1960 #ifdef USE_AS_TRADITIONAL_FORMAT
1961 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1963 static const char tf
[] = "--traditional-format ";
1964 obstack_grow (&obstack
, tf
, sizeof (tf
) - 1);
1965 obstack_grow0 (&obstack
, asm_spec
, strlen (asm_spec
));
1966 asm_spec
= XOBFINISH (&obstack
, const char *);
1970 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC || \
1971 defined LINKER_HASH_STYLE
1972 # ifdef LINK_BUILDID_SPEC
1973 /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. */
1974 obstack_grow (&obstack
, LINK_BUILDID_SPEC
, sizeof (LINK_BUILDID_SPEC
) - 1);
1976 # ifdef LINK_EH_SPEC
1977 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1978 obstack_grow (&obstack
, LINK_EH_SPEC
, sizeof (LINK_EH_SPEC
) - 1);
1980 # ifdef LINKER_HASH_STYLE
1981 /* Prepend --hash-style=LINKER_HASH_STYLE to whatever link_spec we had
1984 static const char hash_style
[] = "--hash-style=";
1985 obstack_grow (&obstack
, hash_style
, sizeof (hash_style
) - 1);
1986 obstack_grow (&obstack
, LINKER_HASH_STYLE
, sizeof (LINKER_HASH_STYLE
) - 1);
1987 obstack_1grow (&obstack
, ' ');
1990 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
1991 link_spec
= XOBFINISH (&obstack
, const char *);
1997 /* Update the entry for SPEC in the static_specs table to point to VALUE,
1998 ensuring that we free the previous value if necessary. Set alloc_p for the
1999 entry to ALLOC_P: this determines whether we take ownership of VALUE (i.e.
2000 whether we need to free it later on). */
2002 set_static_spec (const char **spec
, const char *value
, bool alloc_p
)
2004 struct spec_list
*sl
= NULL
;
2006 for (unsigned i
= 0; i
< ARRAY_SIZE (static_specs
); i
++)
2008 if (static_specs
[i
].ptr_spec
== spec
)
2010 sl
= static_specs
+ i
;
2019 const char *old
= *spec
;
2020 free (const_cast <char *> (old
));
2024 sl
->alloc_p
= alloc_p
;
2027 /* Update a static spec to a new string, taking ownership of that
2029 static void set_static_spec_owned (const char **spec
, const char *val
)
2031 return set_static_spec (spec
, val
, true);
2034 /* Update a static spec to point to a new value, but don't take
2035 ownership of (i.e. don't free) that string. */
2036 static void set_static_spec_shared (const char **spec
, const char *val
)
2038 return set_static_spec (spec
, val
, false);
2042 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
2043 removed; If the spec starts with a + then SPEC is added to the end of the
2047 set_spec (const char *name
, const char *spec
, bool user_p
)
2049 struct spec_list
*sl
;
2050 const char *old_spec
;
2051 int name_len
= strlen (name
);
2054 /* If this is the first call, initialize the statically allocated specs. */
2057 struct spec_list
*next
= (struct spec_list
*) 0;
2058 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
2060 sl
= &static_specs
[i
];
2067 /* See if the spec already exists. */
2068 for (sl
= specs
; sl
; sl
= sl
->next
)
2069 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, name
))
2074 /* Not found - make it. */
2075 sl
= XNEW (struct spec_list
);
2076 sl
->name
= xstrdup (name
);
2077 sl
->name_len
= name_len
;
2078 sl
->ptr_spec
= &sl
->ptr
;
2080 *(sl
->ptr_spec
) = "";
2082 sl
->default_ptr
= NULL
;
2086 old_spec
= *(sl
->ptr_spec
);
2087 *(sl
->ptr_spec
) = ((spec
[0] == '+' && ISSPACE ((unsigned char)spec
[1]))
2088 ? concat (old_spec
, spec
+ 1, NULL
)
2093 fnotice (stderr
, "Setting spec %s to '%s'\n\n", name
, *(sl
->ptr_spec
));
2096 /* Free the old spec. */
2097 if (old_spec
&& sl
->alloc_p
)
2098 free (CONST_CAST (char *, old_spec
));
2100 sl
->user_p
= user_p
;
2104 /* Accumulate a command (program name and args), and run it. */
2106 typedef const char *const_char_p
; /* For DEF_VEC_P. */
2108 /* Vector of pointers to arguments in the current line of specifications. */
2109 static vec
<const_char_p
> argbuf
;
2111 /* Likewise, but for the current @file. */
2112 static vec
<const_char_p
> at_file_argbuf
;
2114 /* Whether an @file is currently open. */
2115 static bool in_at_file
= false;
2117 /* Were the options -c, -S or -E passed. */
2118 static int have_c
= 0;
2120 /* Was the option -o passed. */
2121 static int have_o
= 0;
2123 /* Was the option -E passed. */
2124 static int have_E
= 0;
2126 /* Pointer to output file name passed in with -o. */
2127 static const char *output_file
= 0;
2129 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
2130 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
2133 static struct temp_name
{
2134 const char *suffix
; /* suffix associated with the code. */
2135 int length
; /* strlen (suffix). */
2136 int unique
; /* Indicates whether %g or %u/%U was used. */
2137 const char *filename
; /* associated filename. */
2138 int filename_length
; /* strlen (filename). */
2139 struct temp_name
*next
;
2142 /* Number of commands executed so far. */
2144 static int execution_count
;
2146 /* Number of commands that exited with a signal. */
2148 static int signal_count
;
2150 /* Allocate the argument vector. */
2156 at_file_argbuf
.create (10);
2159 /* Clear out the vector of arguments (after a command is executed). */
2164 argbuf
.truncate (0);
2165 at_file_argbuf
.truncate (0);
2168 /* Add one argument to the vector at the end.
2169 This is done when a space is seen or at the end of the line.
2170 If DELETE_ALWAYS is nonzero, the arg is a filename
2171 and the file should be deleted eventually.
2172 If DELETE_FAILURE is nonzero, the arg is a filename
2173 and the file should be deleted if this compilation fails. */
2176 store_arg (const char *arg
, int delete_always
, int delete_failure
)
2179 at_file_argbuf
.safe_push (arg
);
2181 argbuf
.safe_push (arg
);
2183 if (delete_always
|| delete_failure
)
2186 /* If the temporary file we should delete is specified as
2187 part of a joined argument extract the filename. */
2189 && (p
= strrchr (arg
, '=')))
2191 record_temp_file (arg
, delete_always
, delete_failure
);
2195 /* Open a temporary @file into which subsequent arguments will be stored. */
2201 fatal_error (input_location
, "cannot open nested response file");
2206 /* Create a temporary @file name. */
2208 static char *make_at_file (void)
2210 static int fileno
= 0;
2212 const char *base
, *ext
;
2214 if (!save_temps_flag
)
2215 return make_temp_file ("");
2218 if (!(base
&& *base
))
2220 if (!(base
&& *base
))
2223 sprintf (filename
, ".args.%d", fileno
++);
2226 if (base
== dumpdir
&& dumpdir_trailing_dash_added
)
2229 return concat (base
, ext
, NULL
);
2232 /* Close the temporary @file and add @file to the argument list. */
2235 close_at_file (void)
2238 fatal_error (input_location
, "cannot close nonexistent response file");
2242 const unsigned int n_args
= at_file_argbuf
.length ();
2246 char **argv
= XALLOCAVEC (char *, n_args
+ 1);
2247 char *temp_file
= make_at_file ();
2248 char *at_argument
= concat ("@", temp_file
, NULL
);
2249 FILE *f
= fopen (temp_file
, "w");
2253 /* Copy the strings over. */
2254 for (i
= 0; i
< n_args
; i
++)
2255 argv
[i
] = CONST_CAST (char *, at_file_argbuf
[i
]);
2258 at_file_argbuf
.truncate (0);
2261 fatal_error (input_location
, "could not open temporary response file %s",
2264 status
= writeargv (argv
, f
);
2267 fatal_error (input_location
,
2268 "could not write to temporary response file %s",
2271 status
= fclose (f
);
2274 fatal_error (input_location
, "could not close temporary response file %s",
2277 store_arg (at_argument
, 0, 0);
2279 record_temp_file (temp_file
, !save_temps_flag
, !save_temps_flag
);
2282 /* Load specs from a file name named FILENAME, replacing occurrences of
2283 various different types of line-endings, \r\n, \n\r and just \r, with
2287 load_specs (const char *filename
)
2291 struct stat statbuf
;
2298 fnotice (stderr
, "Reading specs from %s\n", filename
);
2300 /* Open and stat the file. */
2301 desc
= open (filename
, O_RDONLY
, 0);
2305 /* This leaves DESC open, but the OS will save us. */
2306 fatal_error (input_location
, "cannot read spec file %qs: %m", filename
);
2309 if (stat (filename
, &statbuf
) < 0)
2312 /* Read contents of file into BUFFER. */
2313 buffer
= XNEWVEC (char, statbuf
.st_size
+ 1);
2314 readlen
= read (desc
, buffer
, (unsigned) statbuf
.st_size
);
2317 buffer
[readlen
] = 0;
2320 specs
= XNEWVEC (char, readlen
+ 1);
2322 for (buffer_p
= buffer
; buffer_p
&& *buffer_p
; buffer_p
++)
2328 if (buffer_p
> buffer
&& *(buffer_p
- 1) == '\n') /* \n\r */
2330 else if (*(buffer_p
+ 1) == '\n') /* \r\n */
2344 /* Read compilation specs from a file named FILENAME,
2345 replacing the default ones.
2347 A suffix which starts with `*' is a definition for
2348 one of the machine-specific sub-specs. The "suffix" should be
2349 *asm, *cc1, *cpp, *link, *startfile, etc.
2350 The corresponding spec is stored in asm_spec, etc.,
2351 rather than in the `compilers' vector.
2353 Anything invalid in the file is a fatal error. */
2356 read_specs (const char *filename
, bool main_p
, bool user_p
)
2361 buffer
= load_specs (filename
);
2363 /* Scan BUFFER for specs, putting them in the vector. */
2369 char *in
, *out
, *p1
, *p2
, *p3
;
2371 /* Advance P in BUFFER to the next nonblank nocomment line. */
2372 p
= skip_whitespace (p
);
2376 /* Is this a special command that starts with '%'? */
2377 /* Don't allow this for the main specs file, since it would
2378 encourage people to overwrite it. */
2379 if (*p
== '%' && !main_p
)
2382 while (*p
&& *p
!= '\n')
2388 if (startswith (p1
, "%include")
2389 && (p1
[sizeof "%include" - 1] == ' '
2390 || p1
[sizeof "%include" - 1] == '\t'))
2394 p1
+= sizeof ("%include");
2395 while (*p1
== ' ' || *p1
== '\t')
2398 if (*p1
++ != '<' || p
[-2] != '>')
2399 fatal_error (input_location
,
2400 "specs %%include syntax malformed after "
2402 (long) (p1
- buffer
+ 1));
2405 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
2406 read_specs (new_filename
? new_filename
: p1
, false, user_p
);
2409 else if (startswith (p1
, "%include_noerr")
2410 && (p1
[sizeof "%include_noerr" - 1] == ' '
2411 || p1
[sizeof "%include_noerr" - 1] == '\t'))
2415 p1
+= sizeof "%include_noerr";
2416 while (*p1
== ' ' || *p1
== '\t')
2419 if (*p1
++ != '<' || p
[-2] != '>')
2420 fatal_error (input_location
,
2421 "specs %%include syntax malformed after "
2423 (long) (p1
- buffer
+ 1));
2426 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
2428 read_specs (new_filename
, false, user_p
);
2429 else if (verbose_flag
)
2430 fnotice (stderr
, "could not find specs file %s\n", p1
);
2433 else if (startswith (p1
, "%rename")
2434 && (p1
[sizeof "%rename" - 1] == ' '
2435 || p1
[sizeof "%rename" - 1] == '\t'))
2438 struct spec_list
*sl
;
2439 struct spec_list
*newsl
;
2441 /* Get original name. */
2442 p1
+= sizeof "%rename";
2443 while (*p1
== ' ' || *p1
== '\t')
2446 if (! ISALPHA ((unsigned char) *p1
))
2447 fatal_error (input_location
,
2448 "specs %%rename syntax malformed after "
2450 (long) (p1
- buffer
));
2453 while (*p2
&& !ISSPACE ((unsigned char) *p2
))
2456 if (*p2
!= ' ' && *p2
!= '\t')
2457 fatal_error (input_location
,
2458 "specs %%rename syntax malformed after "
2460 (long) (p2
- buffer
));
2464 while (*p2
== ' ' || *p2
== '\t')
2467 if (! ISALPHA ((unsigned char) *p2
))
2468 fatal_error (input_location
,
2469 "specs %%rename syntax malformed after "
2471 (long) (p2
- buffer
));
2473 /* Get new spec name. */
2475 while (*p3
&& !ISSPACE ((unsigned char) *p3
))
2479 fatal_error (input_location
,
2480 "specs %%rename syntax malformed after "
2482 (long) (p3
- buffer
));
2485 for (sl
= specs
; sl
; sl
= sl
->next
)
2486 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, p1
))
2490 fatal_error (input_location
,
2491 "specs %s spec was not found to be renamed", p1
);
2493 if (strcmp (p1
, p2
) == 0)
2496 for (newsl
= specs
; newsl
; newsl
= newsl
->next
)
2497 if (strcmp (newsl
->name
, p2
) == 0)
2498 fatal_error (input_location
,
2499 "%s: attempt to rename spec %qs to "
2500 "already defined spec %qs",
2505 fnotice (stderr
, "rename spec %s to %s\n", p1
, p2
);
2507 fnotice (stderr
, "spec is '%s'\n\n", *(sl
->ptr_spec
));
2511 set_spec (p2
, *(sl
->ptr_spec
), user_p
);
2513 free (CONST_CAST (char *, *(sl
->ptr_spec
)));
2515 *(sl
->ptr_spec
) = "";
2520 fatal_error (input_location
,
2521 "specs unknown %% command after %ld characters",
2522 (long) (p1
- buffer
));
2525 /* Find the colon that should end the suffix. */
2527 while (*p1
&& *p1
!= ':' && *p1
!= '\n')
2530 /* The colon shouldn't be missing. */
2532 fatal_error (input_location
,
2533 "specs file malformed after %ld characters",
2534 (long) (p1
- buffer
));
2536 /* Skip back over trailing whitespace. */
2538 while (p2
> buffer
&& (p2
[-1] == ' ' || p2
[-1] == '\t'))
2541 /* Copy the suffix to a string. */
2542 suffix
= save_string (p
, p2
- p
);
2543 /* Find the next line. */
2544 p
= skip_whitespace (p1
+ 1);
2546 fatal_error (input_location
,
2547 "specs file malformed after %ld characters",
2548 (long) (p
- buffer
));
2551 /* Find next blank line or end of string. */
2552 while (*p1
&& !(*p1
== '\n' && (p1
[1] == '\n' || p1
[1] == '\0')))
2555 /* Specs end at the blank line and do not include the newline. */
2556 spec
= save_string (p
, p1
- p
);
2559 /* Delete backslash-newline sequences from the spec. */
2564 if (in
[0] == '\\' && in
[1] == '\n')
2566 else if (in
[0] == '#')
2567 while (*in
&& *in
!= '\n')
2575 if (suffix
[0] == '*')
2577 if (! strcmp (suffix
, "*link_command"))
2578 link_command_spec
= spec
;
2581 set_spec (suffix
+ 1, spec
, user_p
);
2587 /* Add this pair to the vector. */
2589 = XRESIZEVEC (struct compiler
, compilers
, n_compilers
+ 2);
2591 compilers
[n_compilers
].suffix
= suffix
;
2592 compilers
[n_compilers
].spec
= spec
;
2594 memset (&compilers
[n_compilers
], 0, sizeof compilers
[n_compilers
]);
2598 link_command_spec
= spec
;
2601 if (link_command_spec
== 0)
2602 fatal_error (input_location
, "spec file has no spec for linking");
2604 XDELETEVEC (buffer
);
2607 /* Record the names of temporary files we tell compilers to write,
2608 and delete them at the end of the run. */
2610 /* This is the common prefix we use to make temp file names.
2611 It is chosen once for each run of this program.
2612 It is substituted into a spec by %g or %j.
2613 Thus, all temp file names contain this prefix.
2614 In practice, all temp file names start with this prefix.
2616 This prefix comes from the envvar TMPDIR if it is defined;
2617 otherwise, from the P_tmpdir macro if that is defined;
2618 otherwise, in /usr/tmp or /tmp;
2619 or finally the current directory if all else fails. */
2621 static const char *temp_filename
;
2623 /* Length of the prefix. */
2625 static int temp_filename_length
;
2627 /* Define the list of temporary files to delete. */
2632 struct temp_file
*next
;
2635 /* Queue of files to delete on success or failure of compilation. */
2636 static struct temp_file
*always_delete_queue
;
2637 /* Queue of files to delete on failure of compilation. */
2638 static struct temp_file
*failure_delete_queue
;
2640 /* Record FILENAME as a file to be deleted automatically.
2641 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2642 otherwise delete it in any case.
2643 FAIL_DELETE nonzero means delete it if a compilation step fails;
2644 otherwise delete it in any case. */
2647 record_temp_file (const char *filename
, int always_delete
, int fail_delete
)
2649 char *const name
= xstrdup (filename
);
2653 struct temp_file
*temp
;
2654 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2655 if (! filename_cmp (name
, temp
->name
))
2661 temp
= XNEW (struct temp_file
);
2662 temp
->next
= always_delete_queue
;
2664 always_delete_queue
= temp
;
2671 struct temp_file
*temp
;
2672 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2673 if (! filename_cmp (name
, temp
->name
))
2679 temp
= XNEW (struct temp_file
);
2680 temp
->next
= failure_delete_queue
;
2682 failure_delete_queue
= temp
;
2688 /* Delete all the temporary files whose names we previously recorded. */
2690 #ifndef DELETE_IF_ORDINARY
2691 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2694 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2695 if (unlink (NAME) < 0) \
2697 error ("%s: %m", (NAME)); \
2702 delete_if_ordinary (const char *name
)
2708 printf ("Delete %s? (y or n) ", name
);
2712 while ((c
= getchar ()) != '\n' && c
!= EOF
)
2715 if (i
== 'y' || i
== 'Y')
2717 DELETE_IF_ORDINARY (name
, st
, verbose_flag
);
2721 delete_temp_files (void)
2723 struct temp_file
*temp
;
2725 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2726 delete_if_ordinary (temp
->name
);
2727 always_delete_queue
= 0;
2730 /* Delete all the files to be deleted on error. */
2733 delete_failure_queue (void)
2735 struct temp_file
*temp
;
2737 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2738 delete_if_ordinary (temp
->name
);
2742 clear_failure_queue (void)
2744 failure_delete_queue
= 0;
2747 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2749 If DO_MULTI is true iterate over the paths twice, first with multilib
2750 suffix then without, otherwise iterate over the paths once without
2751 adding a multilib suffix. When DO_MULTI is true, some attempt is made
2752 to avoid visiting the same path twice, but we could do better. For
2753 instance, /usr/lib/../lib is considered different from /usr/lib.
2754 At least EXTRA_SPACE chars past the end of the path passed to
2755 CALLBACK are available for use by the callback.
2756 CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2758 Returns the value returned by CALLBACK. */
2761 for_each_path (const struct path_prefix
*paths
,
2764 void *(*callback
) (char *, void *),
2765 void *callback_info
)
2767 struct prefix_list
*pl
;
2768 const char *multi_dir
= NULL
;
2769 const char *multi_os_dir
= NULL
;
2770 const char *multiarch_suffix
= NULL
;
2771 const char *multi_suffix
;
2772 const char *just_multi_suffix
;
2775 bool skip_multi_dir
= false;
2776 bool skip_multi_os_dir
= false;
2778 multi_suffix
= machine_suffix
;
2779 just_multi_suffix
= just_machine_suffix
;
2780 if (do_multi
&& multilib_dir
&& strcmp (multilib_dir
, ".") != 0)
2782 multi_dir
= concat (multilib_dir
, dir_separator_str
, NULL
);
2783 multi_suffix
= concat (multi_suffix
, multi_dir
, NULL
);
2784 just_multi_suffix
= concat (just_multi_suffix
, multi_dir
, NULL
);
2786 if (do_multi
&& multilib_os_dir
&& strcmp (multilib_os_dir
, ".") != 0)
2787 multi_os_dir
= concat (multilib_os_dir
, dir_separator_str
, NULL
);
2789 multiarch_suffix
= concat (multiarch_dir
, dir_separator_str
, NULL
);
2793 size_t multi_dir_len
= 0;
2794 size_t multi_os_dir_len
= 0;
2795 size_t multiarch_len
= 0;
2797 size_t just_suffix_len
;
2801 multi_dir_len
= strlen (multi_dir
);
2803 multi_os_dir_len
= strlen (multi_os_dir
);
2804 if (multiarch_suffix
)
2805 multiarch_len
= strlen (multiarch_suffix
);
2806 suffix_len
= strlen (multi_suffix
);
2807 just_suffix_len
= strlen (just_multi_suffix
);
2811 len
= paths
->max_len
+ extra_space
+ 1;
2812 len
+= MAX (MAX (suffix_len
, multi_os_dir_len
), multiarch_len
);
2813 path
= XNEWVEC (char, len
);
2816 for (pl
= paths
->plist
; pl
!= 0; pl
= pl
->next
)
2818 len
= strlen (pl
->prefix
);
2819 memcpy (path
, pl
->prefix
, len
);
2821 /* Look first in MACHINE/VERSION subdirectory. */
2822 if (!skip_multi_dir
)
2824 memcpy (path
+ len
, multi_suffix
, suffix_len
+ 1);
2825 ret
= callback (path
, callback_info
);
2830 /* Some paths are tried with just the machine (ie. target)
2831 subdir. This is used for finding as, ld, etc. */
2833 && pl
->require_machine_suffix
== 2)
2835 memcpy (path
+ len
, just_multi_suffix
, just_suffix_len
+ 1);
2836 ret
= callback (path
, callback_info
);
2841 /* Now try the multiarch path. */
2843 && !pl
->require_machine_suffix
&& multiarch_dir
)
2845 memcpy (path
+ len
, multiarch_suffix
, multiarch_len
+ 1);
2846 ret
= callback (path
, callback_info
);
2851 /* Now try the base path. */
2852 if (!pl
->require_machine_suffix
2853 && !(pl
->os_multilib
? skip_multi_os_dir
: skip_multi_dir
))
2855 const char *this_multi
;
2856 size_t this_multi_len
;
2858 if (pl
->os_multilib
)
2860 this_multi
= multi_os_dir
;
2861 this_multi_len
= multi_os_dir_len
;
2865 this_multi
= multi_dir
;
2866 this_multi_len
= multi_dir_len
;
2870 memcpy (path
+ len
, this_multi
, this_multi_len
+ 1);
2874 ret
= callback (path
, callback_info
);
2882 if (multi_dir
== NULL
&& multi_os_dir
== NULL
)
2885 /* Run through the paths again, this time without multilibs.
2886 Don't repeat any we have already seen. */
2889 free (CONST_CAST (char *, multi_dir
));
2891 free (CONST_CAST (char *, multi_suffix
));
2892 multi_suffix
= machine_suffix
;
2893 free (CONST_CAST (char *, just_multi_suffix
));
2894 just_multi_suffix
= just_machine_suffix
;
2897 skip_multi_dir
= true;
2900 free (CONST_CAST (char *, multi_os_dir
));
2901 multi_os_dir
= NULL
;
2904 skip_multi_os_dir
= true;
2909 free (CONST_CAST (char *, multi_dir
));
2910 free (CONST_CAST (char *, multi_suffix
));
2911 free (CONST_CAST (char *, just_multi_suffix
));
2914 free (CONST_CAST (char *, multi_os_dir
));
2920 /* Callback for build_search_list. Adds path to obstack being built. */
2922 struct add_to_obstack_info
{
2929 add_to_obstack (char *path
, void *data
)
2931 struct add_to_obstack_info
*info
= (struct add_to_obstack_info
*) data
;
2933 if (info
->check_dir
&& !is_directory (path
, false))
2936 if (!info
->first_time
)
2937 obstack_1grow (info
->ob
, PATH_SEPARATOR
);
2939 obstack_grow (info
->ob
, path
, strlen (path
));
2941 info
->first_time
= false;
2945 /* Add or change the value of an environment variable, outputting the
2946 change to standard error if in verbose mode. */
2948 xputenv (const char *string
)
2953 /* Build a list of search directories from PATHS.
2954 PREFIX is a string to prepend to the list.
2955 If CHECK_DIR_P is true we ensure the directory exists.
2956 If DO_MULTI is true, multilib paths are output first, then
2958 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2959 It is also used by the --print-search-dirs flag. */
2962 build_search_list (const struct path_prefix
*paths
, const char *prefix
,
2963 bool check_dir
, bool do_multi
)
2965 struct add_to_obstack_info info
;
2967 info
.ob
= &collect_obstack
;
2968 info
.check_dir
= check_dir
;
2969 info
.first_time
= true;
2971 obstack_grow (&collect_obstack
, prefix
, strlen (prefix
));
2972 obstack_1grow (&collect_obstack
, '=');
2974 for_each_path (paths
, do_multi
, 0, add_to_obstack
, &info
);
2976 obstack_1grow (&collect_obstack
, '\0');
2977 return XOBFINISH (&collect_obstack
, char *);
2980 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2984 putenv_from_prefixes (const struct path_prefix
*paths
, const char *env_var
,
2987 xputenv (build_search_list (paths
, env_var
, true, do_multi
));
2990 /* Check whether NAME can be accessed in MODE. This is like access,
2991 except that it never considers directories to be executable. */
2994 access_check (const char *name
, int mode
)
3000 if (stat (name
, &st
) < 0
3001 || S_ISDIR (st
.st_mode
))
3005 return access (name
, mode
);
3008 /* Callback for find_a_file. Appends the file name to the directory
3009 path. If the resulting file exists in the right mode, return the
3010 full pathname to the file. */
3012 struct file_at_path_info
{
3021 file_at_path (char *path
, void *data
)
3023 struct file_at_path_info
*info
= (struct file_at_path_info
*) data
;
3024 size_t len
= strlen (path
);
3026 memcpy (path
+ len
, info
->name
, info
->name_len
);
3027 len
+= info
->name_len
;
3029 /* Some systems have a suffix for executable files.
3030 So try appending that first. */
3031 if (info
->suffix_len
)
3033 memcpy (path
+ len
, info
->suffix
, info
->suffix_len
+ 1);
3034 if (access_check (path
, info
->mode
) == 0)
3039 if (access_check (path
, info
->mode
) == 0)
3045 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
3046 access to check permissions. If DO_MULTI is true, search multilib
3047 paths then non-multilib paths, otherwise do not search multilib paths.
3048 Return 0 if not found, otherwise return its name, allocated with malloc. */
3051 find_a_file (const struct path_prefix
*pprefix
, const char *name
, int mode
,
3054 struct file_at_path_info info
;
3056 /* Find the filename in question (special case for absolute paths). */
3058 if (IS_ABSOLUTE_PATH (name
))
3060 if (access (name
, mode
) == 0)
3061 return xstrdup (name
);
3067 info
.suffix
= (mode
& X_OK
) != 0 ? HOST_EXECUTABLE_SUFFIX
: "";
3068 info
.name_len
= strlen (info
.name
);
3069 info
.suffix_len
= strlen (info
.suffix
);
3072 return (char*) for_each_path (pprefix
, do_multi
,
3073 info
.name_len
+ info
.suffix_len
,
3074 file_at_path
, &info
);
3077 /* Specialization of find_a_file for programs that also takes into account
3078 configure-specified default programs. */
3081 find_a_program (const char *name
)
3083 /* Do not search if default matches query. */
3085 #ifdef DEFAULT_ASSEMBLER
3086 if (! strcmp (name
, "as") && access (DEFAULT_ASSEMBLER
, X_OK
) == 0)
3087 return xstrdup (DEFAULT_ASSEMBLER
);
3090 #ifdef DEFAULT_LINKER
3091 if (! strcmp (name
, "ld") && access (DEFAULT_LINKER
, X_OK
) == 0)
3092 return xstrdup (DEFAULT_LINKER
);
3095 #ifdef DEFAULT_DSYMUTIL
3096 if (! strcmp (name
, "dsymutil") && access (DEFAULT_DSYMUTIL
, X_OK
) == 0)
3097 return xstrdup (DEFAULT_DSYMUTIL
);
3100 return find_a_file (&exec_prefixes
, name
, X_OK
, false);
3103 /* Ranking of prefixes in the sort list. -B prefixes are put before
3106 enum path_prefix_priority
3108 PREFIX_PRIORITY_B_OPT
,
3109 PREFIX_PRIORITY_LAST
3112 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
3113 order according to PRIORITY. Within each PRIORITY, new entries are
3116 If WARN is nonzero, we will warn if no file is found
3117 through this prefix. WARN should point to an int
3118 which will be set to 1 if this entry is used.
3120 COMPONENT is the value to be passed to update_path.
3122 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
3123 the complete value of machine_suffix.
3124 2 means try both machine_suffix and just_machine_suffix. */
3127 add_prefix (struct path_prefix
*pprefix
, const char *prefix
,
3128 const char *component
, /* enum prefix_priority */ int priority
,
3129 int require_machine_suffix
, int os_multilib
)
3131 struct prefix_list
*pl
, **prev
;
3134 for (prev
= &pprefix
->plist
;
3135 (*prev
) != NULL
&& (*prev
)->priority
<= priority
;
3136 prev
= &(*prev
)->next
)
3139 /* Keep track of the longest prefix. */
3141 prefix
= update_path (prefix
, component
);
3142 len
= strlen (prefix
);
3143 if (len
> pprefix
->max_len
)
3144 pprefix
->max_len
= len
;
3146 pl
= XNEW (struct prefix_list
);
3147 pl
->prefix
= prefix
;
3148 pl
->require_machine_suffix
= require_machine_suffix
;
3149 pl
->priority
= priority
;
3150 pl
->os_multilib
= os_multilib
;
3152 /* Insert after PREV. */
3157 /* Same as add_prefix, but prepending target_system_root to prefix. */
3158 /* The target_system_root prefix has been relocated by gcc_exec_prefix. */
3160 add_sysrooted_prefix (struct path_prefix
*pprefix
, const char *prefix
,
3161 const char *component
,
3162 /* enum prefix_priority */ int priority
,
3163 int require_machine_suffix
, int os_multilib
)
3165 if (!IS_ABSOLUTE_PATH (prefix
))
3166 fatal_error (input_location
, "system path %qs is not absolute", prefix
);
3168 if (target_system_root
)
3170 char *sysroot_no_trailing_dir_separator
= xstrdup (target_system_root
);
3171 size_t sysroot_len
= strlen (target_system_root
);
3174 && target_system_root
[sysroot_len
- 1] == DIR_SEPARATOR
)
3175 sysroot_no_trailing_dir_separator
[sysroot_len
- 1] = '\0';
3177 if (target_sysroot_suffix
)
3178 prefix
= concat (sysroot_no_trailing_dir_separator
,
3179 target_sysroot_suffix
, prefix
, NULL
);
3181 prefix
= concat (sysroot_no_trailing_dir_separator
, prefix
, NULL
);
3183 free (sysroot_no_trailing_dir_separator
);
3185 /* We have to override this because GCC's notion of sysroot
3186 moves along with GCC. */
3190 add_prefix (pprefix
, prefix
, component
, priority
,
3191 require_machine_suffix
, os_multilib
);
3194 /* Same as add_prefix, but prepending target_sysroot_hdrs_suffix to prefix. */
3197 add_sysrooted_hdrs_prefix (struct path_prefix
*pprefix
, const char *prefix
,
3198 const char *component
,
3199 /* enum prefix_priority */ int priority
,
3200 int require_machine_suffix
, int os_multilib
)
3202 if (!IS_ABSOLUTE_PATH (prefix
))
3203 fatal_error (input_location
, "system path %qs is not absolute", prefix
);
3205 if (target_system_root
)
3207 char *sysroot_no_trailing_dir_separator
= xstrdup (target_system_root
);
3208 size_t sysroot_len
= strlen (target_system_root
);
3211 && target_system_root
[sysroot_len
- 1] == DIR_SEPARATOR
)
3212 sysroot_no_trailing_dir_separator
[sysroot_len
- 1] = '\0';
3214 if (target_sysroot_hdrs_suffix
)
3215 prefix
= concat (sysroot_no_trailing_dir_separator
,
3216 target_sysroot_hdrs_suffix
, prefix
, NULL
);
3218 prefix
= concat (sysroot_no_trailing_dir_separator
, prefix
, NULL
);
3220 free (sysroot_no_trailing_dir_separator
);
3222 /* We have to override this because GCC's notion of sysroot
3223 moves along with GCC. */
3227 add_prefix (pprefix
, prefix
, component
, priority
,
3228 require_machine_suffix
, os_multilib
);
3232 /* Execute the command specified by the arguments on the current line of spec.
3233 When using pipes, this includes several piped-together commands
3234 with `|' between them.
3236 Return 0 if successful, -1 if failed. */
3242 int n_commands
; /* # of command. */
3244 struct pex_obj
*pex
;
3247 const char *prog
; /* program name. */
3248 const char **argv
; /* vector of args. */
3252 struct command
*commands
; /* each command buffer with above info. */
3254 gcc_assert (!processing_spec_function
);
3258 string
= find_a_program (argbuf
[0]);
3261 insert_wrapper (wrapper_string
);
3264 /* Count # of piped commands. */
3265 for (n_commands
= 1, i
= 0; argbuf
.iterate (i
, &arg
); i
++)
3266 if (strcmp (arg
, "|") == 0)
3269 /* Get storage for each command. */
3270 commands
= XALLOCAVEC (struct command
, n_commands
);
3272 /* Split argbuf into its separate piped processes,
3273 and record info about each one.
3274 Also search for the programs that are to be run. */
3276 argbuf
.safe_push (0);
3278 commands
[0].prog
= argbuf
[0]; /* first command. */
3279 commands
[0].argv
= argbuf
.address ();
3281 if (!wrapper_string
)
3283 string
= find_a_program(commands
[0].prog
);
3285 commands
[0].argv
[0] = string
;
3288 for (n_commands
= 1, i
= 0; argbuf
.iterate (i
, &arg
); i
++)
3289 if (arg
&& strcmp (arg
, "|") == 0)
3290 { /* each command. */
3291 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
3292 fatal_error (input_location
, "%<-pipe%> not supported");
3294 argbuf
[i
] = 0; /* Termination of command args. */
3295 commands
[n_commands
].prog
= argbuf
[i
+ 1];
3296 commands
[n_commands
].argv
3297 = &(argbuf
.address ())[i
+ 1];
3298 string
= find_a_program(commands
[n_commands
].prog
);
3300 commands
[n_commands
].argv
[0] = string
;
3304 /* If -v, print what we are about to do, and maybe query. */
3308 /* For help listings, put a blank line between sub-processes. */
3309 if (print_help_list
)
3310 fputc ('\n', stderr
);
3312 /* Print each piped command as a separate line. */
3313 for (i
= 0; i
< n_commands
; i
++)
3315 const char *const *j
;
3317 if (verbose_only_flag
)
3319 for (j
= commands
[i
].argv
; *j
; j
++)
3322 for (p
= *j
; *p
; ++p
)
3323 if (!ISALNUM ((unsigned char) *p
)
3324 && *p
!= '_' && *p
!= '/' && *p
!= '-' && *p
!= '.')
3328 fprintf (stderr
, " \"");
3329 for (p
= *j
; *p
; ++p
)
3331 if (*p
== '"' || *p
== '\\' || *p
== '$')
3332 fputc ('\\', stderr
);
3335 fputc ('"', stderr
);
3337 /* If it's empty, print "". */
3339 fprintf (stderr
, " \"\"");
3341 fprintf (stderr
, " %s", *j
);
3345 for (j
= commands
[i
].argv
; *j
; j
++)
3346 /* If it's empty, print "". */
3348 fprintf (stderr
, " \"\"");
3350 fprintf (stderr
, " %s", *j
);
3352 /* Print a pipe symbol after all but the last command. */
3353 if (i
+ 1 != n_commands
)
3354 fprintf (stderr
, " |");
3355 fprintf (stderr
, "\n");
3358 if (verbose_only_flag
!= 0)
3360 /* verbose_only_flag should act as if the spec was
3361 executed, so increment execution_count before
3362 returning. This prevents spurious warnings about
3363 unused linker input files, etc. */
3368 fnotice (stderr
, "\nGo ahead? (y or n) ");
3372 while (getchar () != '\n')
3375 if (i
!= 'y' && i
!= 'Y')
3380 #ifdef ENABLE_VALGRIND_CHECKING
3381 /* Run the each command through valgrind. To simplify prepending the
3382 path to valgrind and the option "-q" (for quiet operation unless
3383 something triggers), we allocate a separate argv array. */
3385 for (i
= 0; i
< n_commands
; i
++)
3391 for (argc
= 0; commands
[i
].argv
[argc
] != NULL
; argc
++)
3394 argv
= XALLOCAVEC (const char *, argc
+ 3);
3396 argv
[0] = VALGRIND_PATH
;
3398 for (j
= 2; j
< argc
+ 2; j
++)
3399 argv
[j
] = commands
[i
].argv
[j
- 2];
3402 commands
[i
].argv
= argv
;
3403 commands
[i
].prog
= argv
[0];
3407 /* Run each piped subprocess. */
3409 pex
= pex_init (PEX_USE_PIPES
| ((report_times
|| report_times_to_file
)
3410 ? PEX_RECORD_TIMES
: 0),
3411 progname
, temp_filename
);
3413 fatal_error (input_location
, "%<pex_init%> failed: %m");
3415 for (i
= 0; i
< n_commands
; i
++)
3419 const char *string
= commands
[i
].argv
[0];
3421 errmsg
= pex_run (pex
,
3422 ((i
+ 1 == n_commands
? PEX_LAST
: 0)
3423 | (string
== commands
[i
].prog
? PEX_SEARCH
: 0)),
3424 string
, CONST_CAST (char **, commands
[i
].argv
),
3429 fatal_error (input_location
,
3430 err
? G_("cannot execute %qs: %s: %m")
3431 : G_("cannot execute %qs: %s"),
3435 if (i
&& string
!= commands
[i
].prog
)
3436 free (CONST_CAST (char *, string
));
3441 /* Wait for all the subprocesses to finish. */
3445 struct pex_time
*times
= NULL
;
3448 statuses
= XALLOCAVEC (int, n_commands
);
3449 if (!pex_get_status (pex
, n_commands
, statuses
))
3450 fatal_error (input_location
, "failed to get exit status: %m");
3452 if (report_times
|| report_times_to_file
)
3454 times
= XALLOCAVEC (struct pex_time
, n_commands
);
3455 if (!pex_get_times (pex
, n_commands
, times
))
3456 fatal_error (input_location
, "failed to get process times: %m");
3461 for (i
= 0; i
< n_commands
; ++i
)
3463 int status
= statuses
[i
];
3465 if (WIFSIGNALED (status
))
3466 switch (WTERMSIG (status
))
3470 /* SIGQUIT and SIGKILL are not available on MinGW. */
3477 /* The user (or environment) did something to the
3478 inferior. Making this an ICE confuses the user into
3479 thinking there's a compiler bug. Much more likely is
3480 the user or OOM killer nuked it. */
3481 fatal_error (input_location
,
3482 "%s signal terminated program %s",
3483 strsignal (WTERMSIG (status
)),
3489 /* SIGPIPE is a special case. It happens in -pipe mode
3490 when the compiler dies before the preprocessor is
3491 done, or the assembler dies before the compiler is
3492 done. There's generally been an error already, and
3493 this is just fallout. So don't generate another
3494 error unless we would otherwise have succeeded. */
3495 if (signal_count
|| greatest_status
>= MIN_FATAL_STATUS
)
3505 /* The inferior failed to catch the signal. */
3506 internal_error_no_backtrace ("%s signal terminated program %s",
3507 strsignal (WTERMSIG (status
)),
3510 else if (WIFEXITED (status
)
3511 && WEXITSTATUS (status
) >= MIN_FATAL_STATUS
)
3513 /* For ICEs in cc1, cc1obj, cc1plus see if it is
3514 reproducible or not. */
3517 && WEXITSTATUS (status
) == ICE_EXIT_CODE
3519 && (p
= strrchr (commands
[0].argv
[0], DIR_SEPARATOR
))
3520 && startswith (p
+ 1, "cc1"))
3521 try_generate_repro (commands
[0].argv
);
3522 if (WEXITSTATUS (status
) > greatest_status
)
3523 greatest_status
= WEXITSTATUS (status
);
3527 if (report_times
|| report_times_to_file
)
3529 struct pex_time
*pt
= ×
[i
];
3532 ut
= ((double) pt
->user_seconds
3533 + (double) pt
->user_microseconds
/ 1.0e6
);
3534 st
= ((double) pt
->system_seconds
3535 + (double) pt
->system_microseconds
/ 1.0e6
);
3540 fnotice (stderr
, "# %s %.2f %.2f\n",
3541 commands
[i
].prog
, ut
, st
);
3543 if (report_times_to_file
)
3546 const char *const *j
;
3548 fprintf (report_times_to_file
, "%g %g", ut
, st
);
3550 for (j
= &commands
[i
].prog
; *j
; j
= &commands
[i
].argv
[++c
])
3553 for (p
= *j
; *p
; ++p
)
3554 if (*p
== '"' || *p
== '\\' || *p
== '$'
3560 fprintf (report_times_to_file
, " \"");
3561 for (p
= *j
; *p
; ++p
)
3563 if (*p
== '"' || *p
== '\\' || *p
== '$')
3564 fputc ('\\', report_times_to_file
);
3565 fputc (*p
, report_times_to_file
);
3567 fputc ('"', report_times_to_file
);
3570 fprintf (report_times_to_file
, " %s", *j
);
3573 fputc ('\n', report_times_to_file
);
3579 if (commands
[0].argv
[0] != commands
[0].prog
)
3580 free (CONST_CAST (char *, commands
[0].argv
[0]));
3586 /* Find all the switches given to us
3587 and make a vector describing them.
3588 The elements of the vector are strings, one per switch given.
3589 If a switch uses following arguments, then the `part1' field
3590 is the switch itself and the `args' field
3591 is a null-terminated vector containing the following arguments.
3592 Bits in the `live_cond' field are:
3593 SWITCH_LIVE to indicate this switch is true in a conditional spec.
3594 SWITCH_FALSE to indicate this switch is overridden by a later switch.
3595 SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
3596 SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored.
3597 SWITCH_KEEP_FOR_GCC to indicate that this switch, otherwise ignored,
3598 should be included in COLLECT_GCC_OPTIONS.
3599 in all do_spec calls afterwards. Used for %<S from self specs.
3600 The `known' field describes whether this is an internal switch.
3601 The `validated' field describes whether any spec has looked at this switch;
3602 if it remains false at the end of the run, the switch must be meaningless.
3603 The `ordering' field is used to temporarily mark switches that have to be
3604 kept in a specific order. */
3606 #define SWITCH_LIVE (1 << 0)
3607 #define SWITCH_FALSE (1 << 1)
3608 #define SWITCH_IGNORE (1 << 2)
3609 #define SWITCH_IGNORE_PERMANENTLY (1 << 3)
3610 #define SWITCH_KEEP_FOR_GCC (1 << 4)
3616 unsigned int live_cond
;
3622 static struct switchstr
*switches
;
3624 static int n_switches
;
3626 static int n_switches_alloc
;
3628 /* Set to zero if -fcompare-debug is disabled, positive if it's
3629 enabled and we're running the first compilation, negative if it's
3630 enabled and we're running the second compilation. For most of the
3631 time, it's in the range -1..1, but it can be temporarily set to 2
3632 or 3 to indicate that the -fcompare-debug flags didn't come from
3633 the command-line, but rather from the GCC_COMPARE_DEBUG environment
3634 variable, until a synthesized -fcompare-debug flag is added to the
3638 /* Set to nonzero if we've seen the -fcompare-debug-second flag. */
3639 int compare_debug_second
;
3641 /* Set to the flags that should be passed to the second compilation in
3642 a -fcompare-debug compilation. */
3643 const char *compare_debug_opt
;
3645 static struct switchstr
*switches_debug_check
[2];
3647 static int n_switches_debug_check
[2];
3649 static int n_switches_alloc_debug_check
[2];
3651 static char *debug_check_temp_file
[2];
3653 /* Language is one of three things:
3655 1) The name of a real programming language.
3656 2) NULL, indicating that no one has figured out
3658 3) '*', indicating that the file should be passed
3663 const char *language
;
3664 struct compiler
*incompiler
;
3669 /* Also a vector of input files specified. */
3671 static struct infile
*infiles
;
3675 static int n_infiles_alloc
;
3677 /* True if undefined environment variables encountered during spec processing
3678 are ok to ignore, typically when we're running for --help or --version. */
3680 static bool spec_undefvar_allowed
;
3682 /* True if multiple input files are being compiled to a single
3685 static bool combine_inputs
;
3687 /* This counts the number of libraries added by lang_specific_driver, so that
3688 we can tell if there were any user supplied any files or libraries. */
3690 static int added_libraries
;
3692 /* And a vector of corresponding output files is made up later. */
3694 const char **outfiles
;
3696 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3698 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
3699 is true if we should look for an executable suffix. DO_OBJ
3700 is true if we should look for an object suffix. */
3703 convert_filename (const char *name
, int do_exe ATTRIBUTE_UNUSED
,
3704 int do_obj ATTRIBUTE_UNUSED
)
3706 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3714 len
= strlen (name
);
3716 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3717 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
3718 if (do_obj
&& len
> 2
3719 && name
[len
- 2] == '.'
3720 && name
[len
- 1] == 'o')
3722 obstack_grow (&obstack
, name
, len
- 2);
3723 obstack_grow0 (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
3724 name
= XOBFINISH (&obstack
, const char *);
3728 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3729 /* If there is no filetype, make it the executable suffix (which includes
3730 the "."). But don't get confused if we have just "-o". */
3731 if (! do_exe
|| TARGET_EXECUTABLE_SUFFIX
[0] == 0 || not_actual_file_p (name
))
3734 for (i
= len
- 1; i
>= 0; i
--)
3735 if (IS_DIR_SEPARATOR (name
[i
]))
3738 for (i
++; i
< len
; i
++)
3742 obstack_grow (&obstack
, name
, len
);
3743 obstack_grow0 (&obstack
, TARGET_EXECUTABLE_SUFFIX
,
3744 strlen (TARGET_EXECUTABLE_SUFFIX
));
3745 name
= XOBFINISH (&obstack
, const char *);
3752 /* Display the command line switches accepted by gcc. */
3756 printf (_("Usage: %s [options] file...\n"), progname
);
3757 fputs (_("Options:\n"), stdout
);
3759 fputs (_(" -pass-exit-codes Exit with highest error code from a phase.\n"), stdout
);
3760 fputs (_(" --help Display this information.\n"), stdout
);
3761 fputs (_(" --target-help Display target specific command line options "
3762 "(including assembler and linker options).\n"), stdout
);
3763 fputs (_(" --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...].\n"), stdout
);
3764 fputs (_(" Display specific types of command line options.\n"), stdout
);
3766 fputs (_(" (Use '-v --help' to display command line options of sub-processes).\n"), stdout
);
3767 fputs (_(" --version Display compiler version information.\n"), stdout
);
3768 fputs (_(" -dumpspecs Display all of the built in spec strings.\n"), stdout
);
3769 fputs (_(" -dumpversion Display the version of the compiler.\n"), stdout
);
3770 fputs (_(" -dumpmachine Display the compiler's target processor.\n"), stdout
);
3771 fputs (_(" -foffload=<targets> Specify offloading targets.\n"), stdout
);
3772 fputs (_(" -print-search-dirs Display the directories in the compiler's search path.\n"), stdout
);
3773 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library.\n"), stdout
);
3774 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>.\n"), stdout
);
3775 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>.\n"), stdout
);
3777 -print-multiarch Display the target's normalized GNU triplet, used as\n\
3778 a component in the library path.\n"), stdout
);
3779 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc.\n"), stdout
);
3781 -print-multi-lib Display the mapping between command line options and\n\
3782 multiple library search directories.\n"), stdout
);
3783 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries.\n"), stdout
);
3784 fputs (_(" -print-sysroot Display the target libraries directory.\n"), stdout
);
3785 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers.\n"), stdout
);
3786 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler.\n"), stdout
);
3787 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor.\n"), stdout
);
3788 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker.\n"), stdout
);
3789 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler.\n"), stdout
);
3790 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor.\n"), stdout
);
3791 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker.\n"), stdout
);
3792 fputs (_(" -save-temps Do not delete intermediate files.\n"), stdout
);
3793 fputs (_(" -save-temps=<arg> Do not delete intermediate files.\n"), stdout
);
3795 -no-canonical-prefixes Do not canonicalize paths when building relative\n\
3796 prefixes to other gcc components.\n"), stdout
);
3797 fputs (_(" -pipe Use pipes rather than intermediate files.\n"), stdout
);
3798 fputs (_(" -time Time the execution of each subprocess.\n"), stdout
);
3799 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>.\n"), stdout
);
3800 fputs (_(" -std=<standard> Assume that the input sources are for <standard>.\n"), stdout
);
3802 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3803 and libraries.\n"), stdout
);
3804 fputs (_(" -B <directory> Add <directory> to the compiler's search paths.\n"), stdout
);
3805 fputs (_(" -v Display the programs invoked by the compiler.\n"), stdout
);
3806 fputs (_(" -### Like -v but options quoted and commands not executed.\n"), stdout
);
3807 fputs (_(" -E Preprocess only; do not compile, assemble or link.\n"), stdout
);
3808 fputs (_(" -S Compile only; do not assemble or link.\n"), stdout
);
3809 fputs (_(" -c Compile and assemble, but do not link.\n"), stdout
);
3810 fputs (_(" -o <file> Place the output into <file>.\n"), stdout
);
3811 fputs (_(" -pie Create a dynamically linked position independent\n\
3812 executable.\n"), stdout
);
3813 fputs (_(" -shared Create a shared library.\n"), stdout
);
3815 -x <language> Specify the language of the following input files.\n\
3816 Permissible languages include: c c++ assembler none\n\
3817 'none' means revert to the default behavior of\n\
3818 guessing the language based on the file's extension.\n\
3822 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3823 passed on to the various sub-processes invoked by %s. In order to pass\n\
3824 other options on to these processes the -W<letter> options must be used.\n\
3827 /* The rest of the options are displayed by invocations of the various
3832 add_preprocessor_option (const char *option
, int len
)
3834 preprocessor_options
.safe_push (save_string (option
, len
));
3838 add_assembler_option (const char *option
, int len
)
3840 assembler_options
.safe_push (save_string (option
, len
));
3844 add_linker_option (const char *option
, int len
)
3846 linker_options
.safe_push (save_string (option
, len
));
3849 /* Allocate space for an input file in infiles. */
3854 if (n_infiles_alloc
== 0)
3856 n_infiles_alloc
= 16;
3857 infiles
= XNEWVEC (struct infile
, n_infiles_alloc
);
3859 else if (n_infiles_alloc
== n_infiles
)
3861 n_infiles_alloc
*= 2;
3862 infiles
= XRESIZEVEC (struct infile
, infiles
, n_infiles_alloc
);
3866 /* Store an input file with the given NAME and LANGUAGE in
3870 add_infile (const char *name
, const char *language
)
3873 infiles
[n_infiles
].name
= name
;
3874 infiles
[n_infiles
++].language
= language
;
3877 /* Allocate space for a switch in switches. */
3882 if (n_switches_alloc
== 0)
3884 n_switches_alloc
= 16;
3885 switches
= XNEWVEC (struct switchstr
, n_switches_alloc
);
3887 else if (n_switches_alloc
== n_switches
)
3889 n_switches_alloc
*= 2;
3890 switches
= XRESIZEVEC (struct switchstr
, switches
, n_switches_alloc
);
3894 /* Save an option OPT with N_ARGS arguments in array ARGS, marking it
3895 as validated if VALIDATED and KNOWN if it is an internal switch. */
3898 save_switch (const char *opt
, size_t n_args
, const char *const *args
,
3899 bool validated
, bool known
)
3902 switches
[n_switches
].part1
= opt
+ 1;
3904 switches
[n_switches
].args
= 0;
3907 switches
[n_switches
].args
= XNEWVEC (const char *, n_args
+ 1);
3908 memcpy (switches
[n_switches
].args
, args
, n_args
* sizeof (const char *));
3909 switches
[n_switches
].args
[n_args
] = NULL
;
3912 switches
[n_switches
].live_cond
= 0;
3913 switches
[n_switches
].validated
= validated
;
3914 switches
[n_switches
].known
= known
;
3915 switches
[n_switches
].ordering
= 0;
3919 /* Set the SOURCE_DATE_EPOCH environment variable to the current time if it is
3923 set_source_date_epoch_envvar ()
3925 /* Array size is 21 = ceil(log_10(2^64)) + 1 to hold string representations
3926 of 64 bit integers. */
3927 char source_date_epoch
[21];
3932 if (tt
< (time_t) 0 || errno
!= 0)
3935 snprintf (source_date_epoch
, 21, "%llu", (unsigned long long) tt
);
3936 /* Using setenv instead of xputenv because we want the variable to remain
3937 after finalizing so that it's still set in the second run when using
3939 setenv ("SOURCE_DATE_EPOCH", source_date_epoch
, 0);
3942 /* Handle an option DECODED that is unknown to the option-processing
3946 driver_unknown_option_callback (const struct cl_decoded_option
*decoded
)
3948 const char *opt
= decoded
->arg
;
3949 if (opt
[1] == 'W' && opt
[2] == 'n' && opt
[3] == 'o' && opt
[4] == '-'
3950 && !(decoded
->errors
& CL_ERR_NEGATIVE
))
3952 /* Leave unknown -Wno-* options for the compiler proper, to be
3953 diagnosed only if there are warnings. */
3954 save_switch (decoded
->canonical_option
[0],
3955 decoded
->canonical_option_num_elements
- 1,
3956 &decoded
->canonical_option
[1], false, true);
3959 if (decoded
->opt_index
== OPT_SPECIAL_unknown
)
3961 /* Give it a chance to define it a spec file. */
3962 save_switch (decoded
->canonical_option
[0],
3963 decoded
->canonical_option_num_elements
- 1,
3964 &decoded
->canonical_option
[1], false, false);
3971 /* Handle an option DECODED that is not marked as CL_DRIVER.
3972 LANG_MASK will always be CL_DRIVER. */
3975 driver_wrong_lang_callback (const struct cl_decoded_option
*decoded
,
3976 unsigned int lang_mask ATTRIBUTE_UNUSED
)
3978 /* At this point, non-driver options are accepted (and expected to
3979 be passed down by specs) unless marked to be rejected by the
3980 driver. Options to be rejected by the driver but accepted by the
3981 compilers proper are treated just like completely unknown
3983 const struct cl_option
*option
= &cl_options
[decoded
->opt_index
];
3985 if (option
->cl_reject_driver
)
3986 error ("unrecognized command-line option %qs",
3987 decoded
->orig_option_with_args_text
);
3989 save_switch (decoded
->canonical_option
[0],
3990 decoded
->canonical_option_num_elements
- 1,
3991 &decoded
->canonical_option
[1], false, true);
3994 static const char *spec_lang
= 0;
3995 static int last_language_n_infiles
;
3998 /* Check that GCC is configured to support the offload target. */
4001 check_offload_target_name (const char *target
, ptrdiff_t len
)
4003 const char *n
, *c
= OFFLOAD_TARGETS
;
4006 n
= strchr (c
, ',');
4008 n
= strchr (c
, '\0');
4009 if (len
== n
- c
&& strncmp (target
, c
, n
- c
) == 0)
4011 c
= *n
? n
+ 1 : NULL
;
4015 auto_vec
<const char*> candidates
;
4016 size_t olen
= strlen (OFFLOAD_TARGETS
) + 1;
4017 char *cand
= XALLOCAVEC (char, olen
);
4018 memcpy (cand
, OFFLOAD_TARGETS
, olen
);
4019 for (c
= strtok (cand
, ","); c
; c
= strtok (NULL
, ","))
4020 candidates
.safe_push (c
);
4021 candidates
.safe_push ("default");
4022 candidates
.safe_push ("disable");
4024 char *target2
= XALLOCAVEC (char, len
+ 1);
4025 memcpy (target2
, target
, len
);
4026 target2
[len
] = '\0';
4028 error ("GCC is not configured to support %qs as %<-foffload=%> argument",
4032 const char *hint
= candidates_list_and_hint (target2
, s
, candidates
);
4034 inform (UNKNOWN_LOCATION
,
4035 "valid %<-foffload=%> arguments are: %s; "
4036 "did you mean %qs?", s
, hint
);
4038 inform (UNKNOWN_LOCATION
, "valid %<-foffload=%> arguments are: %s", s
);
4045 /* Sanity check for -foffload-options. */
4048 check_foffload_target_names (const char *arg
)
4050 const char *cur
, *next
, *end
;
4051 /* If option argument starts with '-' then no target is specified and we
4052 do not need to parse it. */
4055 end
= strchr (arg
, '=');
4058 error ("%<=%>options missing after %<-foffload-options=%>target");
4065 next
= strchr (cur
, ',');
4068 next
= (next
> end
) ? end
: next
;
4070 /* Retain non-supported targets after printing an error as those will not
4071 be processed; each enabled target only processes its triplet. */
4072 check_offload_target_name (cur
, next
- cur
);
4077 /* Parse -foffload option argument. */
4080 handle_foffload_option (const char *arg
)
4082 const char *c
, *cur
, *n
, *next
, *end
;
4085 /* If option argument starts with '-' then no target is specified and we
4086 do not need to parse it. */
4090 end
= strchr (arg
, '=');
4092 end
= strchr (arg
, '\0');
4097 next
= strchr (cur
, ',');
4100 next
= (next
> end
) ? end
: next
;
4102 target
= XNEWVEC (char, next
- cur
+ 1);
4103 memcpy (target
, cur
, next
- cur
);
4104 target
[next
- cur
] = '\0';
4106 /* Reset offloading list and continue. */
4107 if (strcmp (target
, "default") == 0)
4109 free (offload_targets
);
4110 offload_targets
= NULL
;
4114 /* If 'disable' is passed to the option, clean the list of
4115 offload targets and return, even if more targets follow.
4116 Likewise if GCC is not configured to support that offload target. */
4117 if (strcmp (target
, "disable") == 0
4118 || !check_offload_target_name (target
, next
- cur
))
4120 free (offload_targets
);
4121 offload_targets
= xstrdup ("");
4125 if (!offload_targets
)
4127 offload_targets
= target
;
4132 /* Check that the target hasn't already presented in the list. */
4133 c
= offload_targets
;
4136 n
= strchr (c
, ':');
4138 n
= strchr (c
, '\0');
4140 if (next
- cur
== n
- c
&& strncmp (c
, target
, n
- c
) == 0)
4147 /* If duplicate is not found, append the target to the list. */
4150 size_t offload_targets_len
= strlen (offload_targets
);
4152 = XRESIZEVEC (char, offload_targets
,
4153 offload_targets_len
+ 1 + next
- cur
+ 1);
4154 offload_targets
[offload_targets_len
++] = ':';
4155 memcpy (offload_targets
+ offload_targets_len
, target
, next
- cur
+ 1);
4160 XDELETEVEC (target
);
4164 /* Handle a driver option; arguments and return value as for
4168 driver_handle_option (struct gcc_options
*opts
,
4169 struct gcc_options
*opts_set
,
4170 const struct cl_decoded_option
*decoded
,
4171 unsigned int lang_mask ATTRIBUTE_UNUSED
, int kind
,
4173 const struct cl_option_handlers
*handlers ATTRIBUTE_UNUSED
,
4174 diagnostic_context
*dc
,
4177 size_t opt_index
= decoded
->opt_index
;
4178 const char *arg
= decoded
->arg
;
4179 const char *compare_debug_replacement_opt
;
4180 int value
= decoded
->value
;
4181 bool validated
= false;
4182 bool do_save
= true;
4184 gcc_assert (opts
== &global_options
);
4185 gcc_assert (opts_set
== &global_options_set
);
4186 gcc_assert (kind
== DK_UNSPECIFIED
);
4187 gcc_assert (loc
== UNKNOWN_LOCATION
);
4188 gcc_assert (dc
== global_dc
);
4194 struct spec_list
*sl
;
4196 for (sl
= specs
; sl
; sl
= sl
->next
)
4197 printf ("*%s:\n%s\n\n", sl
->name
, *(sl
->ptr_spec
));
4198 if (link_command_spec
)
4199 printf ("*link_command:\n%s\n\n", link_command_spec
);
4203 case OPT_dumpversion
:
4204 printf ("%s\n", spec_version
);
4207 case OPT_dumpmachine
:
4208 printf ("%s\n", spec_machine
);
4211 case OPT_dumpfullversion
:
4212 printf ("%s\n", BASEVER
);
4218 /* CPP driver cannot obtain switch from cc1_options. */
4220 add_preprocessor_option ("--version", strlen ("--version"));
4221 add_assembler_option ("--version", strlen ("--version"));
4222 add_linker_option ("--version", strlen ("--version"));
4225 case OPT__completion_
:
4227 completion
= decoded
->arg
;
4231 print_help_list
= 1;
4233 /* CPP driver cannot obtain switch from cc1_options. */
4235 add_preprocessor_option ("--help", 6);
4236 add_assembler_option ("--help", 6);
4237 add_linker_option ("--help", 6);
4241 print_subprocess_help
= 2;
4244 case OPT__target_help
:
4245 print_subprocess_help
= 1;
4247 /* CPP driver cannot obtain switch from cc1_options. */
4249 add_preprocessor_option ("--target-help", 13);
4250 add_assembler_option ("--target-help", 13);
4251 add_linker_option ("--target-help", 13);
4254 case OPT__no_sysroot_suffix
:
4255 case OPT_pass_exit_codes
:
4256 case OPT_print_search_dirs
:
4257 case OPT_print_file_name_
:
4258 case OPT_print_prog_name_
:
4259 case OPT_print_multi_lib
:
4260 case OPT_print_multi_directory
:
4261 case OPT_print_sysroot
:
4262 case OPT_print_multi_os_directory
:
4263 case OPT_print_multiarch
:
4264 case OPT_print_sysroot_headers_suffix
:
4267 /* These options set the variables specified in common.opt
4268 automatically, and do not need to be saved for spec
4273 case OPT_print_libgcc_file_name
:
4274 print_file_name
= "libgcc.a";
4278 case OPT_fuse_ld_bfd
:
4282 case OPT_fuse_ld_gold
:
4286 case OPT_fuse_ld_mold
:
4290 case OPT_fcompare_debug_second
:
4291 compare_debug_second
= 1;
4294 case OPT_fcompare_debug
:
4298 compare_debug_replacement_opt
= "-fcompare-debug=";
4300 goto compare_debug_with_arg
;
4303 compare_debug_replacement_opt
= "-fcompare-debug=-gtoggle";
4305 goto compare_debug_with_arg
;
4312 case OPT_fcompare_debug_
:
4313 compare_debug_replacement_opt
= decoded
->canonical_option
[0];
4314 compare_debug_with_arg
:
4315 gcc_assert (decoded
->canonical_option_num_elements
== 1);
4316 gcc_assert (arg
!= NULL
);
4321 if (compare_debug
< 0)
4322 compare_debug_opt
= NULL
;
4324 compare_debug_opt
= arg
;
4325 save_switch (compare_debug_replacement_opt
, 0, NULL
, validated
, true);
4326 set_source_date_epoch_envvar ();
4329 case OPT_fdiagnostics_color_
:
4330 diagnostic_color_init (dc
, value
);
4333 case OPT_fdiagnostics_urls_
:
4334 diagnostic_urls_init (dc
, value
);
4337 case OPT_fdiagnostics_format_
:
4338 diagnostic_output_format_init (dc
, opts
->x_dump_base_name
,
4339 (enum diagnostics_output_format
)value
);
4345 /* Pass the rest of this option to the assembler. */
4347 /* Split the argument at commas. */
4349 for (j
= 0; arg
[j
]; j
++)
4352 add_assembler_option (arg
+ prev
, j
- prev
);
4356 /* Record the part after the last comma. */
4357 add_assembler_option (arg
+ prev
, j
- prev
);
4365 /* Pass the rest of this option to the preprocessor. */
4367 /* Split the argument at commas. */
4369 for (j
= 0; arg
[j
]; j
++)
4372 add_preprocessor_option (arg
+ prev
, j
- prev
);
4376 /* Record the part after the last comma. */
4377 add_preprocessor_option (arg
+ prev
, j
- prev
);
4385 /* Split the argument at commas. */
4387 for (j
= 0; arg
[j
]; j
++)
4390 add_infile (save_string (arg
+ prev
, j
- prev
), "*");
4393 /* Record the part after the last comma. */
4394 add_infile (arg
+ prev
, "*");
4400 add_infile (arg
, "*");
4404 case OPT_Xpreprocessor
:
4405 add_preprocessor_option (arg
, strlen (arg
));
4409 case OPT_Xassembler
:
4410 add_assembler_option (arg
, strlen (arg
));
4415 /* POSIX allows separation of -l and the lib arg; canonicalize
4416 by concatenating -l with its arg */
4417 add_infile (concat ("-l", arg
, NULL
), "*");
4422 /* Similarly, canonicalize -L for linkers that may not accept
4423 separate arguments. */
4424 save_switch (concat ("-L", arg
, NULL
), 0, NULL
, validated
, true);
4429 save_switch (concat ("-F", arg
, NULL
), 0, NULL
, validated
, true);
4432 case OPT_save_temps
:
4433 if (!save_temps_flag
)
4434 save_temps_flag
= SAVE_TEMPS_DUMP
;
4438 case OPT_save_temps_
:
4439 if (strcmp (arg
, "cwd") == 0)
4440 save_temps_flag
= SAVE_TEMPS_CWD
;
4441 else if (strcmp (arg
, "obj") == 0
4442 || strcmp (arg
, "object") == 0)
4443 save_temps_flag
= SAVE_TEMPS_OBJ
;
4445 fatal_error (input_location
, "%qs is an unknown %<-save-temps%> option",
4446 decoded
->orig_option_with_args_text
);
4447 save_temps_overrides_dumpdir
= true;
4452 dumpdir
= xstrdup (arg
);
4453 save_temps_overrides_dumpdir
= false;
4458 dumpbase
= xstrdup (arg
);
4461 case OPT_dumpbase_ext
:
4462 free (dumpbase_ext
);
4463 dumpbase_ext
= xstrdup (arg
);
4466 case OPT_no_canonical_prefixes
:
4467 /* Already handled as a special case, so ignored here. */
4473 /* These options set the variables specified in common.opt
4474 automatically, but do need to be saved for spec
4480 struct user_specs
*user
= XNEW (struct user_specs
);
4482 user
->next
= (struct user_specs
*) 0;
4483 user
->filename
= arg
;
4484 if (user_specs_tail
)
4485 user_specs_tail
->next
= user
;
4487 user_specs_head
= user
;
4488 user_specs_tail
= user
;
4494 target_system_root
= arg
;
4495 target_system_root_changed
= 1;
4496 /* Saving this option is useful to let self-specs decide to
4497 provide a default one. */
4503 if (report_times_to_file
)
4504 fclose (report_times_to_file
);
4505 report_times_to_file
= fopen (arg
, "a");
4511 This is similar to -v except that there is no execution
4512 of the commands and the echoed arguments are quoted. It
4513 is intended for use in shell scripts to capture the
4514 driver-generated command line. */
4515 verbose_only_flag
++;
4522 size_t len
= strlen (arg
);
4524 /* Catch the case where the user has forgotten to append a
4525 directory separator to the path. Note, they may be using
4526 -B to add an executable name prefix, eg "i386-elf-", in
4527 order to distinguish between multiple installations of
4528 GCC in the same directory. Hence we must check to see
4529 if appending a directory separator actually makes a
4530 valid directory name. */
4531 if (!IS_DIR_SEPARATOR (arg
[len
- 1])
4532 && is_directory (arg
, false))
4534 char *tmp
= XNEWVEC (char, len
+ 2);
4536 tmp
[len
] = DIR_SEPARATOR
;
4541 add_prefix (&exec_prefixes
, arg
, NULL
,
4542 PREFIX_PRIORITY_B_OPT
, 0, 0);
4543 add_prefix (&startfile_prefixes
, arg
, NULL
,
4544 PREFIX_PRIORITY_B_OPT
, 0, 0);
4545 add_prefix (&include_prefixes
, arg
, NULL
,
4546 PREFIX_PRIORITY_B_OPT
, 0, 0);
4557 if (!strcmp (spec_lang
, "none"))
4558 /* Suppress the warning if -xnone comes after the last input
4559 file, because alternate command interfaces like g++ might
4560 find it useful to place -xnone after each input file. */
4563 last_language_n_infiles
= n_infiles
;
4569 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
4570 arg
= convert_filename (arg
, ! have_c
, 0);
4573 /* On some systems, ld cannot handle "-o" without a space. So
4574 split the option from its argument. */
4575 save_switch ("-o", 1, &arg
, validated
, true);
4578 #ifdef ENABLE_DEFAULT_PIE
4580 /* -pie is turned on by default. */
4583 case OPT_static_libgcc
:
4584 case OPT_shared_libgcc
:
4585 case OPT_static_libgfortran
:
4586 case OPT_static_libphobos
:
4587 case OPT_static_libstdc__
:
4588 /* These are always valid, since gcc.cc itself understands the
4589 first two, gfortranspec.cc understands -static-libgfortran,
4590 d-spec.cc understands -static-libphobos, and g++spec.cc
4591 understands -static-libstdc++ */
4599 case OPT_foffload_options_
:
4600 check_foffload_target_names (arg
);
4604 handle_foffload_option (arg
);
4605 if (arg
[0] == '-' || NULL
!= strchr (arg
, '='))
4606 save_switch (concat ("-foffload-options=", arg
, NULL
),
4607 0, NULL
, validated
, true);
4612 /* Various driver options need no special processing at this
4613 point, having been handled in a prescan above or being
4614 handled by specs. */
4619 save_switch (decoded
->canonical_option
[0],
4620 decoded
->canonical_option_num_elements
- 1,
4621 &decoded
->canonical_option
[1], validated
, true);
4625 /* Return true if F2 is F1 followed by a single suffix, i.e., by a
4626 period and additional characters other than a period. */
4629 adds_single_suffix_p (const char *f2
, const char *f1
)
4631 size_t len
= strlen (f1
);
4633 return (strncmp (f1
, f2
, len
) == 0
4635 && strchr (f2
+ len
+ 1, '.') == NULL
);
4638 /* Put the driver's standard set of option handlers in *HANDLERS. */
4641 set_option_handlers (struct cl_option_handlers
*handlers
)
4643 handlers
->unknown_option_callback
= driver_unknown_option_callback
;
4644 handlers
->wrong_lang_callback
= driver_wrong_lang_callback
;
4645 handlers
->num_handlers
= 3;
4646 handlers
->handlers
[0].handler
= driver_handle_option
;
4647 handlers
->handlers
[0].mask
= CL_DRIVER
;
4648 handlers
->handlers
[1].handler
= common_handle_option
;
4649 handlers
->handlers
[1].mask
= CL_COMMON
;
4650 handlers
->handlers
[2].handler
= target_handle_option
;
4651 handlers
->handlers
[2].mask
= CL_TARGET
;
4655 /* Return the index into infiles for the single non-library
4656 non-lto-wpa input file, -1 if there isn't any, or -2 if there is
4659 single_input_file_index ()
4663 for (int i
= 0; i
< n_infiles
; i
++)
4665 if (infiles
[i
].language
4666 && (infiles
[i
].language
[0] == '*'
4668 && strcmp (infiles
[i
].language
, "lto") == 0)))
4680 /* Create the vector `switches' and its contents.
4681 Store its length in `n_switches'. */
4684 process_command (unsigned int decoded_options_count
,
4685 struct cl_decoded_option
*decoded_options
)
4689 char *tooldir_prefix
, *tooldir_prefix2
;
4690 char *(*get_relative_prefix
) (const char *, const char *,
4691 const char *) = NULL
;
4692 struct cl_option_handlers handlers
;
4695 gcc_exec_prefix
= env
.get ("GCC_EXEC_PREFIX");
4699 added_libraries
= 0;
4701 /* Figure compiler version from version string. */
4703 compiler_version
= temp1
= xstrdup (version_string
);
4705 for (; *temp1
; ++temp1
)
4714 /* Handle any -no-canonical-prefixes flag early, to assign the function
4715 that builds relative prefixes. This function creates default search
4716 paths that are needed later in normal option handling. */
4718 for (j
= 1; j
< decoded_options_count
; j
++)
4720 if (decoded_options
[j
].opt_index
== OPT_no_canonical_prefixes
)
4722 get_relative_prefix
= make_relative_prefix_ignore_links
;
4726 if (! get_relative_prefix
)
4727 get_relative_prefix
= make_relative_prefix
;
4729 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
4730 see if we can create it from the pathname specified in
4731 decoded_options[0].arg. */
4733 gcc_libexec_prefix
= standard_libexec_prefix
;
4735 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
4736 if (!gcc_exec_prefix
)
4738 gcc_exec_prefix
= get_relative_prefix (decoded_options
[0].arg
,
4739 standard_bindir_prefix
,
4740 standard_exec_prefix
);
4741 gcc_libexec_prefix
= get_relative_prefix (decoded_options
[0].arg
,
4742 standard_bindir_prefix
,
4743 standard_libexec_prefix
);
4744 if (gcc_exec_prefix
)
4745 xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix
, NULL
));
4749 /* make_relative_prefix requires a program name, but
4750 GCC_EXEC_PREFIX is typically a directory name with a trailing
4751 / (which is ignored by make_relative_prefix), so append a
4753 char *tmp_prefix
= concat (gcc_exec_prefix
, "gcc", NULL
);
4754 gcc_libexec_prefix
= get_relative_prefix (tmp_prefix
,
4755 standard_exec_prefix
,
4756 standard_libexec_prefix
);
4758 /* The path is unrelocated, so fallback to the original setting. */
4759 if (!gcc_libexec_prefix
)
4760 gcc_libexec_prefix
= standard_libexec_prefix
;
4766 /* From this point onward, gcc_exec_prefix is non-null if the toolchain
4767 is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
4768 or an automatically created GCC_EXEC_PREFIX from
4769 decoded_options[0].arg. */
4771 /* Do language-specific adjustment/addition of flags. */
4772 lang_specific_driver (&decoded_options
, &decoded_options_count
,
4775 if (gcc_exec_prefix
)
4777 int len
= strlen (gcc_exec_prefix
);
4779 if (len
> (int) sizeof ("/lib/gcc/") - 1
4780 && (IS_DIR_SEPARATOR (gcc_exec_prefix
[len
-1])))
4782 temp
= gcc_exec_prefix
+ len
- sizeof ("/lib/gcc/") + 1;
4783 if (IS_DIR_SEPARATOR (*temp
)
4784 && filename_ncmp (temp
+ 1, "lib", 3) == 0
4785 && IS_DIR_SEPARATOR (temp
[4])
4786 && filename_ncmp (temp
+ 5, "gcc", 3) == 0)
4787 len
-= sizeof ("/lib/gcc/") - 1;
4790 set_std_prefix (gcc_exec_prefix
, len
);
4791 add_prefix (&exec_prefixes
, gcc_libexec_prefix
, "GCC",
4792 PREFIX_PRIORITY_LAST
, 0, 0);
4793 add_prefix (&startfile_prefixes
, gcc_exec_prefix
, "GCC",
4794 PREFIX_PRIORITY_LAST
, 0, 0);
4797 /* COMPILER_PATH and LIBRARY_PATH have values
4798 that are lists of directory names with colons. */
4800 temp
= env
.get ("COMPILER_PATH");
4803 const char *startp
, *endp
;
4804 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4806 startp
= endp
= temp
;
4809 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4811 strncpy (nstore
, startp
, endp
- startp
);
4813 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4814 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4816 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4817 nstore
[endp
- startp
+ 1] = 0;
4820 nstore
[endp
- startp
] = 0;
4821 add_prefix (&exec_prefixes
, nstore
, 0,
4822 PREFIX_PRIORITY_LAST
, 0, 0);
4823 add_prefix (&include_prefixes
, nstore
, 0,
4824 PREFIX_PRIORITY_LAST
, 0, 0);
4827 endp
= startp
= endp
+ 1;
4834 temp
= env
.get (LIBRARY_PATH_ENV
);
4835 if (temp
&& *cross_compile
== '0')
4837 const char *startp
, *endp
;
4838 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4840 startp
= endp
= temp
;
4843 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4845 strncpy (nstore
, startp
, endp
- startp
);
4847 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4848 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4850 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4851 nstore
[endp
- startp
+ 1] = 0;
4854 nstore
[endp
- startp
] = 0;
4855 add_prefix (&startfile_prefixes
, nstore
, NULL
,
4856 PREFIX_PRIORITY_LAST
, 0, 1);
4859 endp
= startp
= endp
+ 1;
4866 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
4867 temp
= env
.get ("LPATH");
4868 if (temp
&& *cross_compile
== '0')
4870 const char *startp
, *endp
;
4871 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4873 startp
= endp
= temp
;
4876 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4878 strncpy (nstore
, startp
, endp
- startp
);
4880 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4881 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4883 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4884 nstore
[endp
- startp
+ 1] = 0;
4887 nstore
[endp
- startp
] = 0;
4888 add_prefix (&startfile_prefixes
, nstore
, NULL
,
4889 PREFIX_PRIORITY_LAST
, 0, 1);
4892 endp
= startp
= endp
+ 1;
4899 /* Process the options and store input files and switches in their
4902 last_language_n_infiles
= -1;
4904 set_option_handlers (&handlers
);
4906 for (j
= 1; j
< decoded_options_count
; j
++)
4908 switch (decoded_options
[j
].opt_index
)
4920 for (j
= 1; j
< decoded_options_count
; j
++)
4922 if (decoded_options
[j
].opt_index
== OPT_SPECIAL_input_file
)
4924 const char *arg
= decoded_options
[j
].arg
;
4926 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4927 arg
= convert_filename (arg
, 0, access (arg
, F_OK
));
4929 add_infile (arg
, spec_lang
);
4934 read_cmdline_option (&global_options
, &global_options_set
,
4935 decoded_options
+ j
, UNKNOWN_LOCATION
,
4936 CL_DRIVER
, &handlers
, global_dc
);
4939 /* If the user didn't specify any, default to all configured offload
4941 if (ENABLE_OFFLOADING
&& offload_targets
== NULL
)
4943 handle_foffload_option (OFFLOAD_TARGETS
);
4944 #if OFFLOAD_DEFAULTED
4945 offload_targets_default
= true;
4949 /* Handle -gtoggle as it would later in toplev.cc:process_options to
4950 make the debug-level-gt spec function work as expected. */
4953 if (debug_info_level
== DINFO_LEVEL_NONE
)
4954 debug_info_level
= DINFO_LEVEL_NORMAL
;
4956 debug_info_level
= DINFO_LEVEL_NONE
;
4960 && strcmp (output_file
, "-") != 0
4961 && strcmp (output_file
, HOST_BIT_BUCKET
) != 0)
4964 for (i
= 0; i
< n_infiles
; i
++)
4965 if ((!infiles
[i
].language
|| infiles
[i
].language
[0] != '*')
4966 && canonical_filename_eq (infiles
[i
].name
, output_file
))
4967 fatal_error (input_location
,
4968 "input file %qs is the same as output file",
4972 if (output_file
!= NULL
&& output_file
[0] == '\0')
4973 fatal_error (input_location
, "output filename may not be empty");
4975 /* -dumpdir and -save-temps=* both specify the location of aux/dump
4976 outputs; the one that appears last prevails. When compiling
4977 multiple sources, an explicit dumpbase (minus -ext) may be
4978 combined with an explicit or implicit dumpdir, whereas when
4979 linking, a specified or implied link output name (minus
4980 extension) may be combined with a prevailing -save-temps=* or an
4981 otherwise implied dumpdir, but not override a prevailing
4982 -dumpdir. Primary outputs (e.g., linker output when linking
4983 without -o, or .i, .s or .o outputs when processing multiple
4984 inputs with -E, -S or -c, respectively) are NOT affected by these
4985 -save-temps=/-dump* options, always landing in the current
4986 directory and with the same basename as the input when an output
4987 name is not given, but when they're intermediate outputs, they
4988 are named like other aux outputs, so the options affect their
4991 Here are some examples. There are several more in the
4992 documentation of -o and -dump*, and some quite exhaustive tests
4993 in gcc.misc-tests/outputs.exp.
4995 When compiling any number of sources, no -dump* nor
4996 -save-temps=*, all outputs in cwd without prefix:
4998 # gcc -c b.c -gsplit-dwarf
4999 -> cc1 [-dumpdir ./] -dumpbase b.c -dumpbase-ext .c # b.o b.dwo
5001 # gcc -c b.c d.c -gsplit-dwarf
5002 -> cc1 [-dumpdir ./] -dumpbase b.c -dumpbase-ext .c # b.o b.dwo
5003 && cc1 [-dumpdir ./] -dumpbase d.c -dumpbase-ext .c # d.o d.dwo
5005 When compiling and linking, no -dump* nor -save-temps=*, .o
5006 outputs are temporary, aux outputs land in the dir of the output,
5007 prefixed with the basename of the linker output:
5009 # gcc b.c d.c -o ab -gsplit-dwarf
5010 -> cc1 -dumpdir ab- -dumpbase b.c -dumpbase-ext .c # ab-b.dwo
5011 && cc1 -dumpdir ab- -dumpbase d.c -dumpbase-ext .c # ab-d.dwo
5014 # gcc b.c d.c [-o a.out] -gsplit-dwarf
5015 -> cc1 -dumpdir a- -dumpbase b.c -dumpbase-ext .c # a-b.dwo
5016 && cc1 -dumpdir a- -dumpbase d.c -dumpbase-ext .c # a-d.dwo
5017 && link ... [-o a.out]
5019 When compiling and linking, a prevailing -dumpdir fully overrides
5020 the prefix of aux outputs given by the output name:
5022 # gcc -dumpdir f b.c d.c -gsplit-dwarf [-o [dir/]whatever]
5023 -> cc1 -dumpdir f -dumpbase b.c -dumpbase-ext .c # fb.dwo
5024 && cc1 -dumpdir f -dumpbase d.c -dumpbase-ext .c # fd.dwo
5025 && link ... [-o whatever]
5027 When compiling multiple inputs, an explicit -dumpbase is combined
5028 with -dumpdir, affecting aux outputs, but not the .o outputs:
5030 # gcc -dumpdir f -dumpbase g- b.c d.c -gsplit-dwarf -c
5031 -> cc1 -dumpdir fg- -dumpbase b.c -dumpbase-ext .c # b.o fg-b.dwo
5032 && cc1 -dumpdir fg- -dumpbase d.c -dumpbase-ext .c # d.o fg-d.dwo
5034 When compiling and linking with -save-temps, the .o outputs that
5035 would have been temporary become aux outputs, so they get
5036 affected by -dump* flags:
5038 # gcc -dumpdir f -dumpbase g- -save-temps b.c d.c
5039 -> cc1 -dumpdir fg- -dumpbase b.c -dumpbase-ext .c # fg-b.o
5040 && cc1 -dumpdir fg- -dumpbase d.c -dumpbase-ext .c # fg-d.o
5043 If -save-temps=* prevails over -dumpdir, however, the explicit
5044 -dumpdir is discarded, as if it wasn't there. The basename of
5045 the implicit linker output, a.out or a.exe, becomes a- as the aux
5046 output prefix for all compilations:
5048 # gcc [-dumpdir f] -save-temps=cwd b.c d.c
5049 -> cc1 -dumpdir a- -dumpbase b.c -dumpbase-ext .c # a-b.o
5050 && cc1 -dumpdir a- -dumpbase d.c -dumpbase-ext .c # a-d.o
5053 A single -dumpbase, applying to multiple inputs, overrides the
5054 linker output name, implied or explicit, as the aux output prefix:
5056 # gcc [-dumpdir f] -dumpbase g- -save-temps=cwd b.c d.c
5057 -> cc1 -dumpdir g- -dumpbase b.c -dumpbase-ext .c # g-b.o
5058 && cc1 -dumpdir g- -dumpbase d.c -dumpbase-ext .c # g-d.o
5061 # gcc [-dumpdir f] -dumpbase g- -save-temps=cwd b.c d.c -o dir/h.out
5062 -> cc1 -dumpdir g- -dumpbase b.c -dumpbase-ext .c # g-b.o
5063 && cc1 -dumpdir g- -dumpbase d.c -dumpbase-ext .c # g-d.o
5064 && link -o dir/h.out
5066 Now, if the linker output is NOT overridden as a prefix, but
5067 -save-temps=* overrides implicit or explicit -dumpdir, the
5068 effective dump dir combines the dir selected by the -save-temps=*
5069 option with the basename of the specified or implied link output:
5071 # gcc [-dumpdir f] -save-temps=cwd b.c d.c -o dir/h.out
5072 -> cc1 -dumpdir h- -dumpbase b.c -dumpbase-ext .c # h-b.o
5073 && cc1 -dumpdir h- -dumpbase d.c -dumpbase-ext .c # h-d.o
5074 && link -o dir/h.out
5076 # gcc [-dumpdir f] -save-temps=obj b.c d.c -o dir/h.out
5077 -> cc1 -dumpdir dir/h- -dumpbase b.c -dumpbase-ext .c # dir/h-b.o
5078 && cc1 -dumpdir dir/h- -dumpbase d.c -dumpbase-ext .c # dir/h-d.o
5079 && link -o dir/h.out
5081 But then again, a single -dumpbase applying to multiple inputs
5082 gets used instead of the linker output basename in the combined
5085 # gcc [-dumpdir f] -dumpbase g- -save-temps=obj b.c d.c -o dir/h.out
5086 -> cc1 -dumpdir dir/g- -dumpbase b.c -dumpbase-ext .c # dir/g-b.o
5087 && cc1 -dumpdir dir/g- -dumpbase d.c -dumpbase-ext .c # dir/g-d.o
5088 && link -o dir/h.out
5090 With a single input being compiled, the output basename does NOT
5091 affect the dumpdir prefix.
5093 # gcc -save-temps=obj b.c -gsplit-dwarf -c -o dir/b.o
5094 -> cc1 -dumpdir dir/ -dumpbase b.c -dumpbase-ext .c # dir/b.o dir/b.dwo
5096 but when compiling and linking even a single file, it does:
5098 # gcc -save-temps=obj b.c -o dir/h.out
5099 -> cc1 -dumpdir dir/h- -dumpbase b.c -dumpbase-ext .c # dir/h-b.o
5101 unless an explicit -dumpdir prevails:
5103 # gcc -save-temps[=obj] -dumpdir g- b.c -o dir/h.out
5104 -> cc1 -dumpdir g- -dumpbase b.c -dumpbase-ext .c # g-b.o
5108 bool explicit_dumpdir
= dumpdir
;
5110 if ((!save_temps_overrides_dumpdir
&& explicit_dumpdir
)
5111 || (output_file
&& not_actual_file_p (output_file
)))
5116 /* If -save-temps=obj and -o name, create the prefix to use for %b.
5117 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
5118 else if (save_temps_flag
!= SAVE_TEMPS_CWD
&& output_file
!= NULL
)
5122 temp
= lbasename (output_file
);
5123 if (temp
!= output_file
)
5124 dumpdir
= xstrndup (output_file
,
5125 strlen (output_file
) - strlen (temp
));
5133 if (save_temps_flag
)
5134 save_temps_flag
= SAVE_TEMPS_DUMP
;
5136 /* If there is any pathname component in an explicit -dumpbase, it
5137 overrides dumpdir entirely, so discard it right away. Although
5138 the presence of an explicit -dumpdir matters for the driver, it
5139 shouldn't matter for other processes, that get all that's needed
5140 from the -dumpdir and -dumpbase always passed to them. */
5141 if (dumpdir
&& dumpbase
&& lbasename (dumpbase
) != dumpbase
)
5147 /* Check that dumpbase_ext matches the end of dumpbase, drop it
5149 if (dumpbase_ext
&& dumpbase
&& *dumpbase
)
5151 int lendb
= strlen (dumpbase
);
5152 int lendbx
= strlen (dumpbase_ext
);
5154 /* -dumpbase-ext must be a suffix proper; discard it if it
5155 matches all of -dumpbase, as that would make for an empty
5158 || strcmp (dumpbase
+ lendb
- lendbx
, dumpbase_ext
) != 0)
5160 free (dumpbase_ext
);
5161 dumpbase_ext
= NULL
;
5165 /* -dumpbase with multiple sources goes into dumpdir. With a single
5166 source, it does only if linking and if dumpdir was not explicitly
5168 if (dumpbase
&& *dumpbase
5169 && (single_input_file_index () == -2
5170 || (!have_c
&& !explicit_dumpdir
)))
5175 /* We checked that they match above. */
5176 dumpbase
[strlen (dumpbase
) - strlen (dumpbase_ext
)] = '\0';
5179 prefix
= concat (dumpdir
, dumpbase
, "-", NULL
);
5181 prefix
= concat (dumpbase
, "-", NULL
);
5185 free (dumpbase_ext
);
5186 dumpbase
= dumpbase_ext
= NULL
;
5188 dumpdir_trailing_dash_added
= true;
5191 /* If dumpbase was not brought into dumpdir but we're linking, bring
5192 output_file into dumpdir unless dumpdir was explicitly specified.
5193 The test for !explicit_dumpdir is further below, because we want
5194 to use the obase computation for a ghost outbase, passed to
5195 GCC_COLLECT_OPTIONS. */
5196 else if (!have_c
&& (!explicit_dumpdir
|| (dumpbase
&& !*dumpbase
)))
5198 /* If we get here, we know dumpbase was not specified, or it was
5199 specified as an empty string. If it was anything else, it
5200 would have combined with dumpdir above, because the condition
5201 for dumpbase to be used when present is broader than the
5202 condition that gets us here. */
5203 gcc_assert (!dumpbase
|| !*dumpbase
);
5206 char *tofree
= NULL
;
5207 if (!output_file
|| not_actual_file_p (output_file
))
5211 obase
= lbasename (output_file
);
5212 size_t blen
= strlen (obase
), xlen
;
5213 /* Drop the suffix if it's dumpbase_ext, if given,
5214 otherwise .exe or the target executable suffix, or if the
5215 output was explicitly named a.out, but not otherwise. */
5217 ? (blen
> (xlen
= strlen (dumpbase_ext
))
5218 && strcmp ((temp
= (obase
+ blen
- xlen
)),
5220 : ((temp
= strrchr (obase
+ 1, '.'))
5221 && (xlen
= strlen (temp
))
5222 && (strcmp (temp
, ".exe") == 0
5223 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
5224 || strcmp (temp
, TARGET_EXECUTABLE_SUFFIX
) == 0
5226 || strcmp (obase
, "a.out") == 0)))
5228 tofree
= xstrndup (obase
, blen
- xlen
);
5233 /* We wish to save this basename to the -dumpdir passed through
5234 GCC_COLLECT_OPTIONS within maybe_run_linker, for e.g. LTO,
5235 but we do NOT wish to add it to e.g. %b, so we keep
5236 outbase_length as zero. */
5237 gcc_assert (!outbase
);
5240 /* If we're building [dir1/]foo[.exe] out of a single input
5241 [dir2/]foo.c that shares the same basename, dump to
5242 [dir2/]foo.c.* rather than duplicating the basename into
5243 [dir2/]foo-foo.c.*. */
5246 || ((idxin
= single_input_file_index ()) >= 0
5247 && adds_single_suffix_p (lbasename (infiles
[idxin
].name
),
5250 if (obase
== tofree
)
5254 outbase
= xstrdup (obase
);
5257 obase
= tofree
= NULL
;
5263 char *p
= concat (dumpdir
, obase
, "-", NULL
);
5268 dumpdir
= concat (obase
, "-", NULL
);
5270 dumpdir_trailing_dash_added
= true;
5273 obase
= tofree
= NULL
;
5276 if (!explicit_dumpdir
|| dumpbase
)
5278 /* Absent -dumpbase and present -dumpbase-ext have been applied
5279 to the linker output name, so compute fresh defaults for each
5281 free (dumpbase_ext
);
5282 dumpbase_ext
= NULL
;
5286 /* Now, if we're compiling, or if we haven't used the dumpbase
5287 above, then outbase (%B) is derived from dumpbase, if given, or
5288 from the output name, given or implied. We can't precompute
5289 implied output names, but that's ok, since they're derived from
5290 input names. Just make sure we skip this if dumpbase is the
5291 empty string: we want to use input names then, so don't set
5293 if ((dumpbase
|| have_c
)
5294 && !(dumpbase
&& !*dumpbase
))
5296 gcc_assert (!outbase
);
5300 gcc_assert (single_input_file_index () != -2);
5301 /* We do not want lbasename here; dumpbase with dirnames
5302 overrides dumpdir entirely, even if dumpdir is
5305 /* We've already checked above that the suffix matches. */
5306 outbase
= xstrndup (dumpbase
,
5307 strlen (dumpbase
) - strlen (dumpbase_ext
));
5309 outbase
= xstrdup (dumpbase
);
5311 else if (output_file
&& !not_actual_file_p (output_file
))
5313 outbase
= xstrdup (lbasename (output_file
));
5314 char *p
= strrchr (outbase
+ 1, '.');
5320 outbase_length
= strlen (outbase
);
5323 /* If there is any pathname component in an explicit -dumpbase, do
5324 not use dumpdir, but retain it to pass it on to the compiler. */
5326 dumpdir_length
= strlen (dumpdir
);
5330 /* Check that dumpbase_ext, if still present, still matches the end
5331 of dumpbase, if present, and drop it otherwise. We only retained
5332 it above when dumpbase was absent to maybe use it to drop the
5333 extension from output_name before combining it with dumpdir. We
5334 won't deal with -dumpbase-ext when -dumpbase is not explicitly
5335 given, even if just to activate backward-compatible dumpbase:
5336 dropping it on the floor is correct, expected and documented
5337 behavior. Attempting to deal with a -dumpbase-ext that might
5338 match the end of some input filename, or of the combination of
5339 the output basename with the suffix of the input filename,
5340 possible with an intermediate .gk extension for -fcompare-debug,
5341 is just calling for trouble. */
5344 if (!dumpbase
|| !*dumpbase
)
5346 free (dumpbase_ext
);
5347 dumpbase_ext
= NULL
;
5350 gcc_assert (strcmp (dumpbase
+ strlen (dumpbase
)
5351 - strlen (dumpbase_ext
), dumpbase_ext
) == 0);
5354 if (save_temps_flag
&& use_pipes
)
5356 /* -save-temps overrides -pipe, so that temp files are produced */
5357 if (save_temps_flag
)
5358 warning (0, "%<-pipe%> ignored because %<-save-temps%> specified");
5364 const char *gcd
= env
.get ("GCC_COMPARE_DEBUG");
5366 if (gcd
&& gcd
[0] == '-')
5369 compare_debug_opt
= gcd
;
5371 else if (gcd
&& *gcd
&& strcmp (gcd
, "0"))
5374 compare_debug_opt
= "-gtoggle";
5377 else if (compare_debug
< 0)
5380 gcc_assert (!compare_debug_opt
);
5383 /* Set up the search paths. We add directories that we expect to
5384 contain GNU Toolchain components before directories specified by
5385 the machine description so that we will find GNU components (like
5386 the GNU assembler) before those of the host system. */
5388 /* If we don't know where the toolchain has been installed, use the
5389 configured-in locations. */
5390 if (!gcc_exec_prefix
)
5393 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "GCC",
5394 PREFIX_PRIORITY_LAST
, 1, 0);
5395 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "BINUTILS",
5396 PREFIX_PRIORITY_LAST
, 2, 0);
5397 add_prefix (&exec_prefixes
, standard_exec_prefix
, "BINUTILS",
5398 PREFIX_PRIORITY_LAST
, 2, 0);
5400 add_prefix (&startfile_prefixes
, standard_exec_prefix
, "BINUTILS",
5401 PREFIX_PRIORITY_LAST
, 1, 0);
5404 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix
));
5405 tooldir_prefix2
= concat (tooldir_base_prefix
, spec_machine
,
5406 dir_separator_str
, NULL
);
5408 /* Look for tools relative to the location from which the driver is
5409 running, or, if that is not available, the configured prefix. */
5411 = concat (gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
5412 spec_host_machine
, dir_separator_str
, spec_version
,
5413 accel_dir_suffix
, dir_separator_str
, tooldir_prefix2
, NULL
);
5414 free (tooldir_prefix2
);
5416 add_prefix (&exec_prefixes
,
5417 concat (tooldir_prefix
, "bin", dir_separator_str
, NULL
),
5418 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 0);
5419 add_prefix (&startfile_prefixes
,
5420 concat (tooldir_prefix
, "lib", dir_separator_str
, NULL
),
5421 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 1);
5422 free (tooldir_prefix
);
5424 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
5425 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
5426 then consider it to relocate with the rest of the GCC installation
5427 if GCC_EXEC_PREFIX is set.
5428 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
5429 if (target_system_root
&& !target_system_root_changed
&& gcc_exec_prefix
)
5431 char *tmp_prefix
= get_relative_prefix (decoded_options
[0].arg
,
5432 standard_bindir_prefix
,
5433 target_system_root
);
5434 if (tmp_prefix
&& access_check (tmp_prefix
, F_OK
) == 0)
5436 target_system_root
= tmp_prefix
;
5437 target_system_root_changed
= 1;
5442 /* More prefixes are enabled in main, after we read the specs file
5443 and determine whether this is cross-compilation or not. */
5445 if (n_infiles
!= 0 && n_infiles
== last_language_n_infiles
&& spec_lang
!= 0)
5446 warning (0, "%<-x %s%> after last input file has no effect", spec_lang
);
5448 /* Synthesize -fcompare-debug flag from the GCC_COMPARE_DEBUG
5449 environment variable. */
5450 if (compare_debug
== 2 || compare_debug
== 3)
5452 const char *opt
= concat ("-fcompare-debug=", compare_debug_opt
, NULL
);
5453 save_switch (opt
, 0, NULL
, false, true);
5457 /* Ensure we only invoke each subprocess once. */
5459 && (print_subprocess_help
|| print_help_list
|| print_version
))
5461 /* Create a dummy input file, so that we can pass
5462 the help option on to the various sub-processes. */
5463 add_infile ("help-dummy", "c");
5466 /* Decide if undefined variable references are allowed in specs. */
5468 /* -v alone is safe. --version and --help alone or together are safe. Note
5469 that -v would make them unsafe, as they'd then be run for subprocesses as
5470 well, the location of which might depend on variables possibly coming
5471 from self-specs. Note also that the command name is counted in
5472 decoded_options_count. */
5474 unsigned help_version_count
= 0;
5477 help_version_count
++;
5479 if (print_help_list
)
5480 help_version_count
++;
5482 spec_undefvar_allowed
=
5483 ((verbose_flag
&& decoded_options_count
== 2)
5484 || help_version_count
== decoded_options_count
- 1);
5487 switches
[n_switches
].part1
= 0;
5489 infiles
[n_infiles
].name
= 0;
5492 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
5493 and place that in the environment. */
5496 set_collect_gcc_options (void)
5501 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
5503 obstack_grow (&collect_obstack
, "COLLECT_GCC_OPTIONS=",
5504 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
5507 for (i
= 0; (int) i
< n_switches
; i
++)
5509 const char *const *args
;
5512 obstack_grow (&collect_obstack
, " ", 1);
5516 /* Ignore elided switches. */
5517 if ((switches
[i
].live_cond
5518 & (SWITCH_IGNORE
| SWITCH_KEEP_FOR_GCC
))
5522 obstack_grow (&collect_obstack
, "'-", 2);
5523 q
= switches
[i
].part1
;
5524 while ((p
= strchr (q
, '\'')))
5526 obstack_grow (&collect_obstack
, q
, p
- q
);
5527 obstack_grow (&collect_obstack
, "'\\''", 4);
5530 obstack_grow (&collect_obstack
, q
, strlen (q
));
5531 obstack_grow (&collect_obstack
, "'", 1);
5533 for (args
= switches
[i
].args
; args
&& *args
; args
++)
5535 obstack_grow (&collect_obstack
, " '", 2);
5537 while ((p
= strchr (q
, '\'')))
5539 obstack_grow (&collect_obstack
, q
, p
- q
);
5540 obstack_grow (&collect_obstack
, "'\\''", 4);
5543 obstack_grow (&collect_obstack
, q
, strlen (q
));
5544 obstack_grow (&collect_obstack
, "'", 1);
5551 obstack_grow (&collect_obstack
, " ", 1);
5554 obstack_grow (&collect_obstack
, "'-dumpdir' '", 12);
5558 while ((p
= strchr (q
, '\'')))
5560 obstack_grow (&collect_obstack
, q
, p
- q
);
5561 obstack_grow (&collect_obstack
, "'\\''", 4);
5564 obstack_grow (&collect_obstack
, q
, strlen (q
));
5566 obstack_grow (&collect_obstack
, "'", 1);
5569 obstack_grow (&collect_obstack
, "\0", 1);
5570 xputenv (XOBFINISH (&collect_obstack
, char *));
5573 /* Process a spec string, accumulating and running commands. */
5575 /* These variables describe the input file name.
5576 input_file_number is the index on outfiles of this file,
5577 so that the output file name can be stored for later use by %o.
5578 input_basename is the start of the part of the input file
5579 sans all directory names, and basename_length is the number
5580 of characters starting there excluding the suffix .c or whatever. */
5582 static const char *gcc_input_filename
;
5583 static int input_file_number
;
5584 size_t input_filename_length
;
5585 static int basename_length
;
5586 static int suffixed_basename_length
;
5587 static const char *input_basename
;
5588 static const char *input_suffix
;
5589 #ifndef HOST_LACKS_INODE_NUMBERS
5590 static struct stat input_stat
;
5592 static int input_stat_set
;
5594 /* The compiler used to process the current input file. */
5595 static struct compiler
*input_file_compiler
;
5597 /* These are variables used within do_spec and do_spec_1. */
5599 /* Nonzero if an arg has been started and not yet terminated
5600 (with space, tab or newline). */
5601 static int arg_going
;
5603 /* Nonzero means %d or %g has been seen; the next arg to be terminated
5604 is a temporary file name. */
5605 static int delete_this_arg
;
5607 /* Nonzero means %w has been seen; the next arg to be terminated
5608 is the output file name of this compilation. */
5609 static int this_is_output_file
;
5611 /* Nonzero means %s has been seen; the next arg to be terminated
5612 is the name of a library file and we should try the standard
5613 search dirs for it. */
5614 static int this_is_library_file
;
5616 /* Nonzero means %T has been seen; the next arg to be terminated
5617 is the name of a linker script and we should try all of the
5618 standard search dirs for it. If it is found insert a --script
5619 command line switch and then substitute the full path in place,
5620 otherwise generate an error message. */
5621 static int this_is_linker_script
;
5623 /* Nonzero means that the input of this command is coming from a pipe. */
5624 static int input_from_pipe
;
5626 /* Nonnull means substitute this for any suffix when outputting a switches
5628 static const char *suffix_subst
;
5630 /* If there is an argument being accumulated, terminate it and store it. */
5633 end_going_arg (void)
5639 obstack_1grow (&obstack
, 0);
5640 string
= XOBFINISH (&obstack
, const char *);
5641 if (this_is_library_file
)
5642 string
= find_file (string
);
5643 if (this_is_linker_script
)
5645 char * full_script_path
= find_a_file (&startfile_prefixes
, string
, R_OK
, true);
5647 if (full_script_path
== NULL
)
5649 error ("unable to locate default linker script %qs in the library search paths", string
);
5650 /* Script was not found on search path. */
5653 store_arg ("--script", false, false);
5654 string
= full_script_path
;
5656 store_arg (string
, delete_this_arg
, this_is_output_file
);
5657 if (this_is_output_file
)
5658 outfiles
[input_file_number
] = string
;
5664 /* Parse the WRAPPER string which is a comma separated list of the command line
5665 and insert them into the beginning of argbuf. */
5668 insert_wrapper (const char *wrapper
)
5672 char *buf
= xstrdup (wrapper
);
5674 unsigned int old_length
= argbuf
.length ();
5682 while ((p
= strchr (p
, ',')) != NULL
);
5684 argbuf
.safe_grow (old_length
+ n
, true);
5685 memmove (argbuf
.address () + n
,
5687 old_length
* sizeof (const_char_p
));
5701 while ((p
= strchr (p
, ',')) != NULL
);
5702 gcc_assert (i
== n
);
5705 /* Process the spec SPEC and run the commands specified therein.
5706 Returns 0 if the spec is successfully processed; -1 if failed. */
5709 do_spec (const char *spec
)
5713 value
= do_spec_2 (spec
, NULL
);
5715 /* Force out any unfinished command.
5716 If -pipe, this forces out the last command if it ended in `|'. */
5719 if (argbuf
.length () > 0
5720 && !strcmp (argbuf
.last (), "|"))
5723 set_collect_gcc_options ();
5725 if (argbuf
.length () > 0)
5732 /* Process the spec SPEC, with SOFT_MATCHED_PART designating the current value
5733 of a matched * pattern which may be re-injected by way of %*. */
5736 do_spec_2 (const char *spec
, const char *soft_matched_part
)
5742 delete_this_arg
= 0;
5743 this_is_output_file
= 0;
5744 this_is_library_file
= 0;
5745 this_is_linker_script
= 0;
5746 input_from_pipe
= 0;
5747 suffix_subst
= NULL
;
5749 result
= do_spec_1 (spec
, 0, soft_matched_part
);
5756 /* Process the given spec string and add any new options to the end
5757 of the switches/n_switches array. */
5760 do_option_spec (const char *name
, const char *spec
)
5762 unsigned int i
, value_count
, value_len
;
5763 const char *p
, *q
, *value
;
5764 char *tmp_spec
, *tmp_spec_p
;
5766 if (configure_default_options
[0].name
== NULL
)
5769 for (i
= 0; i
< ARRAY_SIZE (configure_default_options
); i
++)
5770 if (strcmp (configure_default_options
[i
].name
, name
) == 0)
5772 if (i
== ARRAY_SIZE (configure_default_options
))
5775 value
= configure_default_options
[i
].value
;
5776 value_len
= strlen (value
);
5778 /* Compute the size of the final spec. */
5781 while ((p
= strstr (p
, "%(VALUE)")) != NULL
)
5787 /* Replace each %(VALUE) by the specified value. */
5788 tmp_spec
= (char *) alloca (strlen (spec
) + 1
5789 + value_count
* (value_len
- strlen ("%(VALUE)")));
5790 tmp_spec_p
= tmp_spec
;
5792 while ((p
= strstr (q
, "%(VALUE)")) != NULL
)
5794 memcpy (tmp_spec_p
, q
, p
- q
);
5795 tmp_spec_p
= tmp_spec_p
+ (p
- q
);
5796 memcpy (tmp_spec_p
, value
, value_len
);
5797 tmp_spec_p
+= value_len
;
5798 q
= p
+ strlen ("%(VALUE)");
5800 strcpy (tmp_spec_p
, q
);
5802 do_self_spec (tmp_spec
);
5805 /* Process the given spec string and add any new options to the end
5806 of the switches/n_switches array. */
5809 do_self_spec (const char *spec
)
5813 do_spec_2 (spec
, NULL
);
5814 do_spec_1 (" ", 0, NULL
);
5816 /* Mark %<S switches processed by do_self_spec to be ignored permanently.
5817 do_self_specs adds the replacements to switches array, so it shouldn't
5818 be processed afterwards. */
5819 for (i
= 0; i
< n_switches
; i
++)
5820 if ((switches
[i
].live_cond
& SWITCH_IGNORE
))
5821 switches
[i
].live_cond
|= SWITCH_IGNORE_PERMANENTLY
;
5823 if (argbuf
.length () > 0)
5825 const char **argbuf_copy
;
5826 struct cl_decoded_option
*decoded_options
;
5827 struct cl_option_handlers handlers
;
5828 unsigned int decoded_options_count
;
5831 /* Create a copy of argbuf with a dummy argv[0] entry for
5832 decode_cmdline_options_to_array. */
5833 argbuf_copy
= XNEWVEC (const char *,
5834 argbuf
.length () + 1);
5835 argbuf_copy
[0] = "";
5836 memcpy (argbuf_copy
+ 1, argbuf
.address (),
5837 argbuf
.length () * sizeof (const char *));
5839 decode_cmdline_options_to_array (argbuf
.length () + 1,
5841 CL_DRIVER
, &decoded_options
,
5842 &decoded_options_count
);
5845 set_option_handlers (&handlers
);
5847 for (j
= 1; j
< decoded_options_count
; j
++)
5849 switch (decoded_options
[j
].opt_index
)
5851 case OPT_SPECIAL_input_file
:
5852 /* Specs should only generate options, not input
5854 if (strcmp (decoded_options
[j
].arg
, "-") != 0)
5855 fatal_error (input_location
,
5856 "switch %qs does not start with %<-%>",
5857 decoded_options
[j
].arg
);
5859 fatal_error (input_location
,
5860 "spec-generated switch is just %<-%>");
5863 case OPT_fcompare_debug_second
:
5864 case OPT_fcompare_debug
:
5865 case OPT_fcompare_debug_
:
5867 /* Avoid duplicate processing of some options from
5868 compare-debug specs; just save them here. */
5869 save_switch (decoded_options
[j
].canonical_option
[0],
5870 (decoded_options
[j
].canonical_option_num_elements
5872 &decoded_options
[j
].canonical_option
[1], false, true);
5876 read_cmdline_option (&global_options
, &global_options_set
,
5877 decoded_options
+ j
, UNKNOWN_LOCATION
,
5878 CL_DRIVER
, &handlers
, global_dc
);
5883 free (decoded_options
);
5886 switches
[n_switches
].part1
= 0;
5890 /* Callback for processing %D and %I specs. */
5892 struct spec_path_info
{
5897 bool separate_options
;
5901 spec_path (char *path
, void *data
)
5903 struct spec_path_info
*info
= (struct spec_path_info
*) data
;
5907 if (info
->omit_relative
&& !IS_ABSOLUTE_PATH (path
))
5910 if (info
->append_len
!= 0)
5912 len
= strlen (path
);
5913 memcpy (path
+ len
, info
->append
, info
->append_len
+ 1);
5916 if (!is_directory (path
, true))
5919 do_spec_1 (info
->option
, 1, NULL
);
5920 if (info
->separate_options
)
5921 do_spec_1 (" ", 0, NULL
);
5923 if (info
->append_len
== 0)
5925 len
= strlen (path
);
5926 save
= path
[len
- 1];
5927 if (IS_DIR_SEPARATOR (path
[len
- 1]))
5928 path
[len
- 1] = '\0';
5931 do_spec_1 (path
, 1, NULL
);
5932 do_spec_1 (" ", 0, NULL
);
5934 /* Must not damage the original path. */
5935 if (info
->append_len
== 0)
5936 path
[len
- 1] = save
;
5941 /* True if we should compile INFILE. */
5944 compile_input_file_p (struct infile
*infile
)
5946 if ((!infile
->language
) || (infile
->language
[0] != '*'))
5947 if (infile
->incompiler
== input_file_compiler
)
5952 /* Process each member of VEC as a spec. */
5955 do_specs_vec (vec
<char_p
> vec
)
5957 for (char *opt
: vec
)
5959 do_spec_1 (opt
, 1, NULL
);
5960 /* Make each accumulated option a separate argument. */
5961 do_spec_1 (" ", 0, NULL
);
5965 /* Add options passed via -Xassembler or -Wa to COLLECT_AS_OPTIONS. */
5968 putenv_COLLECT_AS_OPTIONS (vec
<char_p
> vec
)
5970 if (vec
.is_empty ())
5973 obstack_init (&collect_obstack
);
5974 obstack_grow (&collect_obstack
, "COLLECT_AS_OPTIONS=",
5975 strlen ("COLLECT_AS_OPTIONS="));
5980 FOR_EACH_VEC_ELT (vec
, ix
, opt
)
5982 obstack_1grow (&collect_obstack
, '\'');
5983 obstack_grow (&collect_obstack
, opt
, strlen (opt
));
5984 obstack_1grow (&collect_obstack
, '\'');
5985 if (ix
< vec
.length () - 1)
5986 obstack_1grow(&collect_obstack
, ' ');
5989 obstack_1grow (&collect_obstack
, '\0');
5990 xputenv (XOBFINISH (&collect_obstack
, char *));
5993 /* Process the sub-spec SPEC as a portion of a larger spec.
5994 This is like processing a whole spec except that we do
5995 not initialize at the beginning and we do not supply a
5996 newline by default at the end.
5997 INSWITCH nonzero means don't process %-sequences in SPEC;
5998 in this case, % is treated as an ordinary character.
5999 This is used while substituting switches.
6000 INSWITCH nonzero also causes SPC not to terminate an argument.
6002 Value is zero unless a line was finished
6003 and the command on that line reported an error. */
6006 do_spec_1 (const char *spec
, int inswitch
, const char *soft_matched_part
)
6008 const char *p
= spec
;
6013 /* If it's an empty string argument to a switch, keep it as is. */
6014 if (inswitch
&& !*p
)
6018 /* If substituting a switch, treat all chars like letters.
6019 Otherwise, NL, SPC, TAB and % are special. */
6020 switch (inswitch
? 'a' : c
)
6025 if (argbuf
.length () > 0
6026 && !strcmp (argbuf
.last (), "|"))
6028 /* A `|' before the newline means use a pipe here,
6029 but only if -pipe was specified.
6030 Otherwise, execute now and don't pass the `|' as an arg. */
6033 input_from_pipe
= 1;
6040 set_collect_gcc_options ();
6042 if (argbuf
.length () > 0)
6048 /* Reinitialize for a new command, and for a new argument. */
6051 delete_this_arg
= 0;
6052 this_is_output_file
= 0;
6053 this_is_library_file
= 0;
6054 this_is_linker_script
= 0;
6055 input_from_pipe
= 0;
6062 obstack_1grow (&obstack
, c
);
6070 /* Reinitialize for a new argument. */
6071 delete_this_arg
= 0;
6072 this_is_output_file
= 0;
6073 this_is_library_file
= 0;
6074 this_is_linker_script
= 0;
6081 fatal_error (input_location
, "spec %qs invalid", spec
);
6084 /* Don't use %b in the linker command. */
6085 gcc_assert (suffixed_basename_length
);
6086 if (!this_is_output_file
&& dumpdir_length
)
6087 obstack_grow (&obstack
, dumpdir
, dumpdir_length
);
6088 if (this_is_output_file
|| !outbase_length
)
6089 obstack_grow (&obstack
, input_basename
, basename_length
);
6091 obstack_grow (&obstack
, outbase
, outbase_length
);
6092 if (compare_debug
< 0)
6093 obstack_grow (&obstack
, ".gk", 3);
6098 /* Don't use %B in the linker command. */
6099 gcc_assert (suffixed_basename_length
);
6100 if (!this_is_output_file
&& dumpdir_length
)
6101 obstack_grow (&obstack
, dumpdir
, dumpdir_length
);
6102 if (this_is_output_file
|| !outbase_length
)
6103 obstack_grow (&obstack
, input_basename
, basename_length
);
6105 obstack_grow (&obstack
, outbase
, outbase_length
);
6106 if (compare_debug
< 0)
6107 obstack_grow (&obstack
, ".gk", 3);
6108 obstack_grow (&obstack
, input_basename
+ basename_length
,
6109 suffixed_basename_length
- basename_length
);
6115 delete_this_arg
= 2;
6118 /* Dump out the directories specified with LIBRARY_PATH,
6119 followed by the absolute directories
6120 that we search for startfiles. */
6123 struct spec_path_info info
;
6126 info
.append_len
= 0;
6127 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
6128 /* Used on systems which record the specified -L dirs
6129 and use them to search for dynamic linking.
6130 Relative directories always come from -B,
6131 and it is better not to use them for searching
6132 at run time. In particular, stage1 loses. */
6133 info
.omit_relative
= true;
6135 info
.omit_relative
= false;
6137 info
.separate_options
= false;
6139 for_each_path (&startfile_prefixes
, true, 0, spec_path
, &info
);
6144 /* %efoo means report an error with `foo' as error message
6145 and don't execute any more commands for this file. */
6149 while (*p
!= 0 && *p
!= '\n')
6151 buf
= (char *) alloca (p
- q
+ 1);
6152 strncpy (buf
, q
, p
- q
);
6154 error ("%s", _(buf
));
6159 /* %nfoo means report a notice with `foo' on stderr. */
6163 while (*p
!= 0 && *p
!= '\n')
6165 buf
= (char *) alloca (p
- q
+ 1);
6166 strncpy (buf
, q
, p
- q
);
6168 inform (UNKNOWN_LOCATION
, "%s", _(buf
));
6178 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
6179 defined, and it is not a directory, and it is
6180 writable, use it. Otherwise, treat this like any
6181 other temporary file. */
6183 if ((!save_temps_flag
)
6184 && (stat (HOST_BIT_BUCKET
, &st
) == 0) && (!S_ISDIR (st
.st_mode
))
6185 && (access (HOST_BIT_BUCKET
, W_OK
) == 0))
6187 obstack_grow (&obstack
, HOST_BIT_BUCKET
,
6188 strlen (HOST_BIT_BUCKET
));
6189 delete_this_arg
= 0;
6194 goto create_temp_file
;
6198 obstack_1grow (&obstack
, '-');
6199 delete_this_arg
= 0;
6202 /* consume suffix */
6203 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
6205 if (p
[0] == '%' && p
[1] == 'O')
6210 goto create_temp_file
;
6214 /* consume suffix */
6215 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
6217 if (p
[0] == '%' && p
[1] == 'O')
6222 goto create_temp_file
;
6228 struct temp_name
*t
;
6230 const char *suffix
= p
;
6231 char *saved_suffix
= NULL
;
6233 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
6235 suffix_length
= p
- suffix
;
6236 if (p
[0] == '%' && p
[1] == 'O')
6239 /* We don't support extra suffix characters after %O. */
6240 if (*p
== '.' || ISALNUM ((unsigned char) *p
))
6241 fatal_error (input_location
,
6242 "spec %qs has invalid %<%%0%c%>", spec
, *p
);
6243 if (suffix_length
== 0)
6244 suffix
= TARGET_OBJECT_SUFFIX
;
6248 = XNEWVEC (char, suffix_length
6249 + strlen (TARGET_OBJECT_SUFFIX
) + 1);
6250 strncpy (saved_suffix
, suffix
, suffix_length
);
6251 strcpy (saved_suffix
+ suffix_length
,
6252 TARGET_OBJECT_SUFFIX
);
6254 suffix_length
+= strlen (TARGET_OBJECT_SUFFIX
);
6257 if (compare_debug
< 0)
6259 suffix
= concat (".gk", suffix
, NULL
);
6263 /* If -save-temps was specified, use that for the
6265 if (save_temps_flag
)
6268 bool adjusted_suffix
= false;
6270 && !outbase_length
&& !basename_length
6271 && !dumpdir_trailing_dash_added
)
6273 adjusted_suffix
= true;
6277 temp_filename_length
6278 = dumpdir_length
+ suffix_length
+ 1;
6280 temp_filename_length
+= outbase_length
;
6282 temp_filename_length
+= basename_length
;
6283 tmp
= (char *) alloca (temp_filename_length
);
6285 memcpy (tmp
, dumpdir
, dumpdir_length
);
6287 memcpy (tmp
+ dumpdir_length
, outbase
,
6289 else if (basename_length
)
6290 memcpy (tmp
+ dumpdir_length
, input_basename
,
6292 memcpy (tmp
+ temp_filename_length
- suffix_length
- 1,
6293 suffix
, suffix_length
);
6294 if (adjusted_suffix
)
6296 adjusted_suffix
= false;
6300 tmp
[temp_filename_length
- 1] = '\0';
6301 temp_filename
= tmp
;
6303 if (filename_cmp (temp_filename
, gcc_input_filename
) != 0)
6305 #ifndef HOST_LACKS_INODE_NUMBERS
6306 struct stat st_temp
;
6308 /* Note, set_input() resets input_stat_set to 0. */
6309 if (input_stat_set
== 0)
6311 input_stat_set
= stat (gcc_input_filename
,
6313 if (input_stat_set
>= 0)
6317 /* If we have the stat for the gcc_input_filename
6318 and we can do the stat for the temp_filename
6319 then the they could still refer to the same
6320 file if st_dev/st_ino's are the same. */
6321 if (input_stat_set
!= 1
6322 || stat (temp_filename
, &st_temp
) < 0
6323 || input_stat
.st_dev
!= st_temp
.st_dev
6324 || input_stat
.st_ino
!= st_temp
.st_ino
)
6326 /* Just compare canonical pathnames. */
6327 char* input_realname
= lrealpath (gcc_input_filename
);
6328 char* temp_realname
= lrealpath (temp_filename
);
6329 bool files_differ
= filename_cmp (input_realname
, temp_realname
);
6330 free (input_realname
);
6331 free (temp_realname
);
6336 = save_string (temp_filename
,
6337 temp_filename_length
- 1);
6338 obstack_grow (&obstack
, temp_filename
,
6339 temp_filename_length
);
6341 delete_this_arg
= 0;
6347 /* See if we already have an association of %g/%u/%U and
6349 for (t
= temp_names
; t
; t
= t
->next
)
6350 if (t
->length
== suffix_length
6351 && strncmp (t
->suffix
, suffix
, suffix_length
) == 0
6352 && t
->unique
== (c
== 'u' || c
== 'U' || c
== 'j'))
6355 /* Make a new association if needed. %u and %j
6357 if (t
== 0 || c
== 'u' || c
== 'j')
6361 t
= XNEW (struct temp_name
);
6362 t
->next
= temp_names
;
6365 t
->length
= suffix_length
;
6368 t
->suffix
= saved_suffix
;
6369 saved_suffix
= NULL
;
6372 t
->suffix
= save_string (suffix
, suffix_length
);
6373 t
->unique
= (c
== 'u' || c
== 'U' || c
== 'j');
6374 temp_filename
= make_temp_file (t
->suffix
);
6375 temp_filename_length
= strlen (temp_filename
);
6376 t
->filename
= temp_filename
;
6377 t
->filename_length
= temp_filename_length
;
6380 free (saved_suffix
);
6382 obstack_grow (&obstack
, t
->filename
, t
->filename_length
);
6383 delete_this_arg
= 1;
6391 /* We are going to expand `%i' into `@FILE', where FILE
6392 is a newly-created temporary filename. The filenames
6393 that would usually be expanded in place of %o will be
6394 written to the temporary file. */
6395 if (at_file_supplied
)
6398 for (i
= 0; (int) i
< n_infiles
; i
++)
6399 if (compile_input_file_p (&infiles
[i
]))
6401 store_arg (infiles
[i
].name
, 0, 0);
6402 infiles
[i
].compiled
= true;
6405 if (at_file_supplied
)
6410 obstack_grow (&obstack
, gcc_input_filename
,
6411 input_filename_length
);
6418 struct spec_path_info info
;
6422 do_spec_1 ("-imultilib", 1, NULL
);
6423 /* Make this a separate argument. */
6424 do_spec_1 (" ", 0, NULL
);
6425 do_spec_1 (multilib_dir
, 1, NULL
);
6426 do_spec_1 (" ", 0, NULL
);
6431 do_spec_1 ("-imultiarch", 1, NULL
);
6432 /* Make this a separate argument. */
6433 do_spec_1 (" ", 0, NULL
);
6434 do_spec_1 (multiarch_dir
, 1, NULL
);
6435 do_spec_1 (" ", 0, NULL
);
6438 if (gcc_exec_prefix
)
6440 do_spec_1 ("-iprefix", 1, NULL
);
6441 /* Make this a separate argument. */
6442 do_spec_1 (" ", 0, NULL
);
6443 do_spec_1 (gcc_exec_prefix
, 1, NULL
);
6444 do_spec_1 (" ", 0, NULL
);
6447 if (target_system_root_changed
||
6448 (target_system_root
&& target_sysroot_hdrs_suffix
))
6450 do_spec_1 ("-isysroot", 1, NULL
);
6451 /* Make this a separate argument. */
6452 do_spec_1 (" ", 0, NULL
);
6453 do_spec_1 (target_system_root
, 1, NULL
);
6454 if (target_sysroot_hdrs_suffix
)
6455 do_spec_1 (target_sysroot_hdrs_suffix
, 1, NULL
);
6456 do_spec_1 (" ", 0, NULL
);
6459 info
.option
= "-isystem";
6460 info
.append
= "include";
6461 info
.append_len
= strlen (info
.append
);
6462 info
.omit_relative
= false;
6463 info
.separate_options
= true;
6465 for_each_path (&include_prefixes
, false, info
.append_len
,
6468 info
.append
= "include-fixed";
6469 if (*sysroot_hdrs_suffix_spec
)
6470 info
.append
= concat (info
.append
, dir_separator_str
,
6471 multilib_dir
, NULL
);
6472 info
.append_len
= strlen (info
.append
);
6473 for_each_path (&include_prefixes
, false, info
.append_len
,
6479 /* We are going to expand `%o' into `@FILE', where FILE
6480 is a newly-created temporary filename. The filenames
6481 that would usually be expanded in place of %o will be
6482 written to the temporary file. */
6483 if (at_file_supplied
)
6486 for (i
= 0; i
< n_infiles
+ lang_specific_extra_outfiles
; i
++)
6488 store_arg (outfiles
[i
], 0, 0);
6490 if (at_file_supplied
)
6495 obstack_grow (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
6500 this_is_library_file
= 1;
6504 this_is_linker_script
= 1;
6508 outfiles
[input_file_number
] = NULL
;
6512 this_is_output_file
= 1;
6517 unsigned int cur_index
= argbuf
.length ();
6518 /* Handle the {...} following the %W. */
6520 fatal_error (input_location
,
6521 "spec %qs has invalid %<%%W%c%>", spec
, *p
);
6522 p
= handle_braces (p
+ 1);
6526 /* If any args were output, mark the last one for deletion
6528 if (argbuf
.length () != cur_index
)
6529 record_temp_file (argbuf
.last (), 0, 1);
6534 /* Handle the {...} following the %@. */
6536 fatal_error (input_location
,
6537 "spec %qs has invalid %<%%@%c%>", spec
, *p
);
6538 if (at_file_supplied
)
6540 p
= handle_braces (p
+ 1);
6541 if (at_file_supplied
)
6547 /* %x{OPTION} records OPTION for %X to output. */
6553 /* Skip past the option value and make a copy. */
6555 fatal_error (input_location
,
6556 "spec %qs has invalid %<%%x%c%>", spec
, *p
);
6559 string
= save_string (p1
+ 1, p
- p1
- 2);
6561 /* See if we already recorded this option. */
6562 for (const char *opt
: linker_options
)
6563 if (! strcmp (string
, opt
))
6569 /* This option is new; add it. */
6570 add_linker_option (string
, strlen (string
));
6575 /* Dump out the options accumulated previously using %x. */
6577 do_specs_vec (linker_options
);
6580 /* Dump out the options accumulated previously using -Wa,. */
6582 do_specs_vec (assembler_options
);
6585 /* Dump out the options accumulated previously using -Wp,. */
6587 do_specs_vec (preprocessor_options
);
6590 /* Here are digits and numbers that just process
6591 a certain constant string as a spec. */
6594 value
= do_spec_1 (cc1_spec
, 0, NULL
);
6600 value
= do_spec_1 (cc1plus_spec
, 0, NULL
);
6606 value
= do_spec_1 (asm_spec
, 0, NULL
);
6612 value
= do_spec_1 (asm_final_spec
, 0, NULL
);
6619 const char *const spec
6620 = (input_file_compiler
->cpp_spec
6621 ? input_file_compiler
->cpp_spec
6623 value
= do_spec_1 (spec
, 0, NULL
);
6630 value
= do_spec_1 (endfile_spec
, 0, NULL
);
6636 value
= do_spec_1 (link_spec
, 0, NULL
);
6642 value
= do_spec_1 (lib_spec
, 0, NULL
);
6648 if (multilib_os_dir
== NULL
)
6649 obstack_1grow (&obstack
, '.');
6651 obstack_grow (&obstack
, multilib_os_dir
,
6652 strlen (multilib_os_dir
));
6656 value
= do_spec_1 (libgcc_spec
, 0, NULL
);
6662 /* We assume there is a directory
6663 separator at the end of this string. */
6664 if (target_system_root
)
6666 obstack_grow (&obstack
, target_system_root
,
6667 strlen (target_system_root
));
6668 if (target_sysroot_suffix
)
6669 obstack_grow (&obstack
, target_sysroot_suffix
,
6670 strlen (target_sysroot_suffix
));
6675 value
= do_spec_1 (startfile_spec
, 0, NULL
);
6680 /* Here we define characters other than letters and digits. */
6683 p
= handle_braces (p
);
6689 p
= handle_spec_function (p
, NULL
, soft_matched_part
);
6695 obstack_1grow (&obstack
, '%');
6702 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '%')
6704 suffix_subst
= save_string (p
- 1, len
+ 1);
6709 /* Henceforth ignore the option(s) matching the pattern
6715 int have_wildcard
= 0;
6720 switch_option
= SWITCH_IGNORE
| SWITCH_KEEP_FOR_GCC
;
6722 switch_option
= SWITCH_IGNORE
;
6724 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '\t')
6727 if (p
[len
-1] == '*')
6730 for (i
= 0; i
< n_switches
; i
++)
6731 if (!strncmp (switches
[i
].part1
, p
, len
- have_wildcard
)
6732 && (have_wildcard
|| switches
[i
].part1
[len
] == '\0'))
6734 switches
[i
].live_cond
|= switch_option
;
6735 /* User switch be validated from validate_all_switches.
6736 when the definition is seen from the spec file.
6737 If not defined anywhere, will be rejected. */
6738 if (switches
[i
].known
)
6739 switches
[i
].validated
= true;
6747 if (soft_matched_part
)
6749 if (soft_matched_part
[0])
6750 do_spec_1 (soft_matched_part
, 1, NULL
);
6751 /* Only insert a space after the substitution if it is at the
6752 end of the current sequence. So if:
6754 "%{foo=*:bar%*}%{foo=*:one%*two}"
6756 matches -foo=hello then it will produce:
6758 barhello onehellotwo
6760 if (*p
== 0 || *p
== '}')
6761 do_spec_1 (" ", 0, NULL
);
6764 /* Catch the case where a spec string contains something like
6765 '%{foo:%*}'. i.e. there is no * in the pattern on the left
6766 hand side of the :. */
6767 error ("spec failure: %<%%*%> has not been initialized by pattern match");
6770 /* Process a string found as the value of a spec given by name.
6771 This feature allows individual machine descriptions
6772 to add and use their own specs. */
6775 const char *name
= p
;
6776 struct spec_list
*sl
;
6779 /* The string after the S/P is the name of a spec that is to be
6781 while (*p
&& *p
!= ')')
6784 /* See if it's in the list. */
6785 for (len
= p
- name
, sl
= specs
; sl
; sl
= sl
->next
)
6786 if (sl
->name_len
== len
&& !strncmp (sl
->name
, name
, len
))
6788 name
= *(sl
->ptr_spec
);
6790 fnotice (stderr
, "Processing spec (%s), which is '%s'\n",
6798 value
= do_spec_1 (name
, 0, NULL
);
6803 /* Discard the closing paren. */
6810 /* End a previous argument, if there is one, then issue an
6818 error ("spec failure: unrecognized spec option %qc", c
);
6824 /* Backslash: treat next character as ordinary. */
6827 /* When adding more cases that previously matched default, make
6828 sure to adjust quote_spec_char_p as well. */
6832 /* Ordinary character: put it into the current argument. */
6833 obstack_1grow (&obstack
, c
);
6837 /* End of string. If we are processing a spec function, we need to
6838 end any pending argument. */
6839 if (processing_spec_function
)
6845 /* Look up a spec function. */
6847 static const struct spec_function
*
6848 lookup_spec_function (const char *name
)
6850 const struct spec_function
*sf
;
6852 for (sf
= static_spec_functions
; sf
->name
!= NULL
; sf
++)
6853 if (strcmp (sf
->name
, name
) == 0)
6859 /* Evaluate a spec function. */
6862 eval_spec_function (const char *func
, const char *args
,
6863 const char *soft_matched_part
)
6865 const struct spec_function
*sf
;
6866 const char *funcval
;
6868 /* Saved spec processing context. */
6869 vec
<const_char_p
> save_argbuf
;
6872 int save_delete_this_arg
;
6873 int save_this_is_output_file
;
6874 int save_this_is_library_file
;
6875 int save_input_from_pipe
;
6876 int save_this_is_linker_script
;
6877 const char *save_suffix_subst
;
6879 int save_growing_size
;
6880 void *save_growing_value
= NULL
;
6882 sf
= lookup_spec_function (func
);
6884 fatal_error (input_location
, "unknown spec function %qs", func
);
6886 /* Push the spec processing context. */
6887 save_argbuf
= argbuf
;
6889 save_arg_going
= arg_going
;
6890 save_delete_this_arg
= delete_this_arg
;
6891 save_this_is_output_file
= this_is_output_file
;
6892 save_this_is_library_file
= this_is_library_file
;
6893 save_this_is_linker_script
= this_is_linker_script
;
6894 save_input_from_pipe
= input_from_pipe
;
6895 save_suffix_subst
= suffix_subst
;
6897 /* If we have some object growing now, finalize it so the args and function
6898 eval proceed from a cleared context. This is needed to prevent the first
6899 constructed arg from mistakenly including the growing value. We'll push
6900 this value back on the obstack once the function evaluation is done, to
6901 restore a consistent processing context for our caller. This is fine as
6902 the address of growing objects isn't guaranteed to remain stable until
6903 they are finalized, and we expect this situation to be rare enough for
6904 the extra copy not to be an issue. */
6905 save_growing_size
= obstack_object_size (&obstack
);
6906 if (save_growing_size
> 0)
6907 save_growing_value
= obstack_finish (&obstack
);
6909 /* Create a new spec processing context, and build the function
6913 if (do_spec_2 (args
, soft_matched_part
) < 0)
6914 fatal_error (input_location
, "error in arguments to spec function %qs",
6917 /* argbuf_index is an index for the next argument to be inserted, and
6918 so contains the count of the args already inserted. */
6920 funcval
= (*sf
->func
) (argbuf
.length (),
6923 /* Pop the spec processing context. */
6925 argbuf
= save_argbuf
;
6927 arg_going
= save_arg_going
;
6928 delete_this_arg
= save_delete_this_arg
;
6929 this_is_output_file
= save_this_is_output_file
;
6930 this_is_library_file
= save_this_is_library_file
;
6931 this_is_linker_script
= save_this_is_linker_script
;
6932 input_from_pipe
= save_input_from_pipe
;
6933 suffix_subst
= save_suffix_subst
;
6935 if (save_growing_size
> 0)
6936 obstack_grow (&obstack
, save_growing_value
, save_growing_size
);
6941 /* Handle a spec function call of the form:
6945 ARGS is processed as a spec in a separate context and split into an
6946 argument vector in the normal fashion. The function returns a string
6947 containing a spec which we then process in the caller's context, or
6948 NULL if no processing is required.
6950 If RETVAL_NONNULL is not NULL, then store a bool whether function
6953 SOFT_MATCHED_PART holds the current value of a matched * pattern, which
6954 may be re-expanded with a %* as part of the function arguments. */
6957 handle_spec_function (const char *p
, bool *retval_nonnull
,
6958 const char *soft_matched_part
)
6961 const char *endp
, *funcval
;
6964 processing_spec_function
++;
6966 /* Get the function name. */
6967 for (endp
= p
; *endp
!= '\0'; endp
++)
6969 if (*endp
== '(') /* ) */
6971 /* Only allow [A-Za-z0-9], -, and _ in function names. */
6972 if (!ISALNUM (*endp
) && !(*endp
== '-' || *endp
== '_'))
6973 fatal_error (input_location
, "malformed spec function name");
6975 if (*endp
!= '(') /* ) */
6976 fatal_error (input_location
, "no arguments for spec function");
6977 func
= save_string (p
, endp
- p
);
6980 /* Get the arguments. */
6981 for (count
= 0; *endp
!= '\0'; endp
++)
6990 else if (*endp
== '(') /* ) */
6995 fatal_error (input_location
, "malformed spec function arguments");
6996 args
= save_string (p
, endp
- p
);
6999 /* p now points to just past the end of the spec function expression. */
7001 funcval
= eval_spec_function (func
, args
, soft_matched_part
);
7002 if (funcval
!= NULL
&& do_spec_1 (funcval
, 0, NULL
) < 0)
7005 *retval_nonnull
= funcval
!= NULL
;
7010 processing_spec_function
--;
7015 /* Inline subroutine of handle_braces. Returns true if the current
7016 input suffix matches the atom bracketed by ATOM and END_ATOM. */
7018 input_suffix_matches (const char *atom
, const char *end_atom
)
7020 return (input_suffix
7021 && !strncmp (input_suffix
, atom
, end_atom
- atom
)
7022 && input_suffix
[end_atom
- atom
] == '\0');
7025 /* Subroutine of handle_braces. Returns true if the current
7026 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
7028 input_spec_matches (const char *atom
, const char *end_atom
)
7030 return (input_file_compiler
7031 && input_file_compiler
->suffix
7032 && input_file_compiler
->suffix
[0] != '\0'
7033 && !strncmp (input_file_compiler
->suffix
+ 1, atom
,
7035 && input_file_compiler
->suffix
[end_atom
- atom
+ 1] == '\0');
7038 /* Subroutine of handle_braces. Returns true if a switch
7039 matching the atom bracketed by ATOM and END_ATOM appeared on the
7042 switch_matches (const char *atom
, const char *end_atom
, int starred
)
7045 int len
= end_atom
- atom
;
7046 int plen
= starred
? len
: -1;
7048 for (i
= 0; i
< n_switches
; i
++)
7049 if (!strncmp (switches
[i
].part1
, atom
, len
)
7050 && (starred
|| switches
[i
].part1
[len
] == '\0')
7051 && check_live_switch (i
, plen
))
7054 /* Check if a switch with separated form matching the atom.
7055 We check -D and -U switches. */
7056 else if (switches
[i
].args
!= 0)
7058 if ((*switches
[i
].part1
== 'D' || *switches
[i
].part1
== 'U')
7059 && *switches
[i
].part1
== atom
[0])
7061 if (!strncmp (switches
[i
].args
[0], &atom
[1], len
- 1)
7062 && (starred
|| (switches
[i
].part1
[1] == '\0'
7063 && switches
[i
].args
[0][len
- 1] == '\0'))
7064 && check_live_switch (i
, (starred
? 1 : -1)))
7072 /* Inline subroutine of handle_braces. Mark all of the switches which
7073 match ATOM (extends to END_ATOM; STARRED indicates whether there
7074 was a star after the atom) for later processing. */
7076 mark_matching_switches (const char *atom
, const char *end_atom
, int starred
)
7079 int len
= end_atom
- atom
;
7080 int plen
= starred
? len
: -1;
7082 for (i
= 0; i
< n_switches
; i
++)
7083 if (!strncmp (switches
[i
].part1
, atom
, len
)
7084 && (starred
|| switches
[i
].part1
[len
] == '\0')
7085 && check_live_switch (i
, plen
))
7086 switches
[i
].ordering
= 1;
7089 /* Inline subroutine of handle_braces. Process all the currently
7090 marked switches through give_switch, and clear the marks. */
7092 process_marked_switches (void)
7096 for (i
= 0; i
< n_switches
; i
++)
7097 if (switches
[i
].ordering
== 1)
7099 switches
[i
].ordering
= 0;
7104 /* Handle a %{ ... } construct. P points just inside the leading {.
7105 Returns a pointer one past the end of the brace block, or 0
7106 if we call do_spec_1 and that returns -1. */
7109 handle_braces (const char *p
)
7111 const char *atom
, *end_atom
;
7112 const char *d_atom
= NULL
, *d_end_atom
= NULL
;
7113 char *esc_buf
= NULL
, *d_esc_buf
= NULL
;
7115 const char *orig
= p
;
7123 bool a_must_be_last
= false;
7124 bool ordered_set
= false;
7125 bool disjunct_set
= false;
7126 bool disj_matched
= false;
7127 bool disj_starred
= true;
7128 bool n_way_choice
= false;
7129 bool n_way_matched
= false;
7131 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7138 /* Scan one "atom" (S in the description above of %{}, possibly
7139 with '!', '.', '@', ',', or '*' modifiers). */
7141 a_is_suffix
= false;
7142 a_is_starred
= false;
7143 a_is_negated
= false;
7144 a_is_spectype
= false;
7148 p
++, a_is_negated
= true;
7151 if (*p
== '%' && p
[1] == ':')
7155 p
= handle_spec_function (p
+ 2, &a_matched
, NULL
);
7160 p
++, a_is_suffix
= true;
7162 p
++, a_is_spectype
= true;
7166 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
7167 || *p
== ',' || *p
== '.' || *p
== '@' || *p
== '\\')
7173 fatal_error (input_location
,
7174 "braced spec %qs ends in escape", orig
);
7186 if (esc_buf
&& esc_buf
!= d_esc_buf
)
7189 ep
= esc_buf
= (char *) xmalloc (end_atom
- atom
- esc
+ 1);
7190 for (ap
= atom
; ap
!= end_atom
; ap
++, ep
++)
7202 p
++, a_is_starred
= 1;
7209 /* Substitute the switch(es) indicated by the current atom. */
7211 if (disjunct_set
|| n_way_choice
|| a_is_negated
|| a_is_suffix
7212 || a_is_spectype
|| atom
== end_atom
)
7215 mark_matching_switches (atom
, end_atom
, a_is_starred
);
7218 process_marked_switches ();
7222 /* Substitute some text if the current atom appears as a switch
7224 disjunct_set
= true;
7228 if (atom
&& atom
== end_atom
)
7230 if (!n_way_choice
|| disj_matched
|| *p
== '|'
7231 || a_is_negated
|| a_is_suffix
|| a_is_spectype
7235 /* An empty term may appear as the last choice of an
7236 N-way choice set; it means "otherwise". */
7237 a_must_be_last
= true;
7238 disj_matched
= !n_way_matched
;
7239 disj_starred
= false;
7243 if ((a_is_suffix
|| a_is_spectype
) && a_is_starred
)
7247 disj_starred
= false;
7249 /* Don't bother testing this atom if we already have a
7251 if (!disj_matched
&& !n_way_matched
)
7254 /* a_matched is already set by handle_spec_function. */;
7255 else if (a_is_suffix
)
7256 a_matched
= input_suffix_matches (atom
, end_atom
);
7257 else if (a_is_spectype
)
7258 a_matched
= input_spec_matches (atom
, end_atom
);
7260 a_matched
= switch_matches (atom
, end_atom
, a_is_starred
);
7262 if (a_matched
!= a_is_negated
)
7264 disj_matched
= true;
7266 d_end_atom
= end_atom
;
7267 d_esc_buf
= esc_buf
;
7274 /* Found the body, that is, the text to substitute if the
7275 current disjunction matches. */
7276 p
= process_brace_body (p
+ 1, d_atom
, d_end_atom
, disj_starred
,
7277 disj_matched
&& !n_way_matched
);
7281 /* If we have an N-way choice, reset state for the next
7285 n_way_choice
= true;
7286 n_way_matched
|= disj_matched
;
7287 disj_matched
= false;
7288 disj_starred
= true;
7289 d_atom
= d_end_atom
= NULL
;
7298 while (*p
++ != '}');
7301 if (d_esc_buf
&& d_esc_buf
!= esc_buf
)
7309 fatal_error (input_location
, "braced spec %qs is invalid at %qc", orig
, *p
);
7314 /* Subroutine of handle_braces. Scan and process a brace substitution body
7315 (X in the description of %{} syntax). P points one past the colon;
7316 ATOM and END_ATOM bracket the first atom which was found to be true
7317 (present) in the current disjunction; STARRED indicates whether all
7318 the atoms in the current disjunction were starred (for syntax validation);
7319 MATCHED indicates whether the disjunction matched or not, and therefore
7320 whether or not the body is to be processed through do_spec_1 or just
7321 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
7325 process_brace_body (const char *p
, const char *atom
, const char *end_atom
,
7326 int starred
, int matched
)
7328 const char *body
, *end_body
;
7329 unsigned int nesting_level
;
7330 bool have_subst
= false;
7332 /* Locate the closing } or ;, honoring nested braces.
7333 Trim trailing whitespace. */
7342 if (!--nesting_level
)
7345 else if (*p
== ';' && nesting_level
== 1)
7347 else if (*p
== '%' && p
[1] == '*' && nesting_level
== 1)
7349 else if (*p
== '\0')
7355 while (end_body
[-1] == ' ' || end_body
[-1] == '\t')
7358 if (have_subst
&& !starred
)
7363 /* Copy the substitution body to permanent storage and execute it.
7364 If have_subst is false, this is a simple matter of running the
7365 body through do_spec_1... */
7366 char *string
= save_string (body
, end_body
- body
);
7369 if (do_spec_1 (string
, 0, NULL
) < 0)
7377 /* ... but if have_subst is true, we have to process the
7378 body once for each matching switch, with %* set to the
7379 variant part of the switch. */
7380 unsigned int hard_match_len
= end_atom
- atom
;
7383 for (i
= 0; i
< n_switches
; i
++)
7384 if (!strncmp (switches
[i
].part1
, atom
, hard_match_len
)
7385 && check_live_switch (i
, hard_match_len
))
7387 if (do_spec_1 (string
, 0,
7388 &switches
[i
].part1
[hard_match_len
]) < 0)
7393 /* Pass any arguments this switch has. */
7395 suffix_subst
= NULL
;
7404 fatal_error (input_location
, "braced spec body %qs is invalid", body
);
7407 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
7408 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
7409 spec, or -1 if either exact match or %* is used.
7411 A -O switch is obsoleted by a later -O switch. A -f, -g, -m, or -W switch
7412 whose value does not begin with "no-" is obsoleted by the same value
7413 with the "no-", similarly for a switch with the "no-" prefix. */
7416 check_live_switch (int switchnum
, int prefix_length
)
7418 const char *name
= switches
[switchnum
].part1
;
7421 /* If we already processed this switch and determined if it was
7422 live or not, return our past determination. */
7423 if (switches
[switchnum
].live_cond
!= 0)
7424 return ((switches
[switchnum
].live_cond
& SWITCH_LIVE
) != 0
7425 && (switches
[switchnum
].live_cond
& SWITCH_FALSE
) == 0
7426 && (switches
[switchnum
].live_cond
& SWITCH_IGNORE_PERMANENTLY
)
7429 /* In the common case of {<at-most-one-letter>*}, a negating
7430 switch would always match, so ignore that case. We will just
7431 send the conflicting switches to the compiler phase. */
7432 if (prefix_length
>= 0 && prefix_length
<= 1)
7435 /* Now search for duplicate in a manner that depends on the name. */
7439 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
7440 if (switches
[i
].part1
[0] == 'O')
7442 switches
[switchnum
].validated
= true;
7443 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
7448 case 'W': case 'f': case 'm': case 'g':
7449 if (startswith (name
+ 1, "no-"))
7451 /* We have Xno-YYY, search for XYYY. */
7452 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
7453 if (switches
[i
].part1
[0] == name
[0]
7454 && ! strcmp (&switches
[i
].part1
[1], &name
[4]))
7456 /* --specs are validated with the validate_switches mechanism. */
7457 if (switches
[switchnum
].known
)
7458 switches
[switchnum
].validated
= true;
7459 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
7465 /* We have XYYY, search for Xno-YYY. */
7466 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
7467 if (switches
[i
].part1
[0] == name
[0]
7468 && switches
[i
].part1
[1] == 'n'
7469 && switches
[i
].part1
[2] == 'o'
7470 && switches
[i
].part1
[3] == '-'
7471 && !strcmp (&switches
[i
].part1
[4], &name
[1]))
7473 /* --specs are validated with the validate_switches mechanism. */
7474 if (switches
[switchnum
].known
)
7475 switches
[switchnum
].validated
= true;
7476 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
7483 /* Otherwise the switch is live. */
7484 switches
[switchnum
].live_cond
|= SWITCH_LIVE
;
7488 /* Pass a switch to the current accumulating command
7489 in the same form that we received it.
7490 SWITCHNUM identifies the switch; it is an index into
7491 the vector of switches gcc received, which is `switches'.
7492 This cannot fail since it never finishes a command line.
7494 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
7497 give_switch (int switchnum
, int omit_first_word
)
7499 if ((switches
[switchnum
].live_cond
& SWITCH_IGNORE
) != 0)
7502 if (!omit_first_word
)
7504 do_spec_1 ("-", 0, NULL
);
7505 do_spec_1 (switches
[switchnum
].part1
, 1, NULL
);
7508 if (switches
[switchnum
].args
!= 0)
7511 for (p
= switches
[switchnum
].args
; *p
; p
++)
7513 const char *arg
= *p
;
7515 do_spec_1 (" ", 0, NULL
);
7518 unsigned length
= strlen (arg
);
7521 while (length
-- && !IS_DIR_SEPARATOR (arg
[length
]))
7522 if (arg
[length
] == '.')
7524 (CONST_CAST (char *, arg
))[length
] = 0;
7528 do_spec_1 (arg
, 1, NULL
);
7530 (CONST_CAST (char *, arg
))[length
] = '.';
7531 do_spec_1 (suffix_subst
, 1, NULL
);
7534 do_spec_1 (arg
, 1, NULL
);
7538 do_spec_1 (" ", 0, NULL
);
7539 switches
[switchnum
].validated
= true;
7542 /* Print GCC configuration (e.g. version, thread model, target,
7543 configuration_arguments) to a given FILE. */
7546 print_configuration (FILE *file
)
7551 fnotice (file
, "Target: %s\n", spec_machine
);
7552 fnotice (file
, "Configured with: %s\n", configuration_arguments
);
7554 #ifdef THREAD_MODEL_SPEC
7555 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
7556 but there's no point in doing all this processing just to get
7557 thread_model back. */
7558 obstack_init (&obstack
);
7559 do_spec_1 (THREAD_MODEL_SPEC
, 0, thread_model
);
7560 obstack_1grow (&obstack
, '\0');
7561 thrmod
= XOBFINISH (&obstack
, const char *);
7563 thrmod
= thread_model
;
7566 fnotice (file
, "Thread model: %s\n", thrmod
);
7567 fnotice (file
, "Supported LTO compression algorithms: zlib");
7569 fnotice (file
, " zstd");
7571 fnotice (file
, "\n");
7573 /* compiler_version is truncated at the first space when initialized
7574 from version string, so truncate version_string at the first space
7575 before comparing. */
7576 for (n
= 0; version_string
[n
]; n
++)
7577 if (version_string
[n
] == ' ')
7580 if (! strncmp (version_string
, compiler_version
, n
)
7581 && compiler_version
[n
] == 0)
7582 fnotice (file
, "gcc version %s %s\n", version_string
,
7585 fnotice (file
, "gcc driver version %s %sexecuting gcc version %s\n",
7586 version_string
, pkgversion_string
, compiler_version
);
7590 #define RETRY_ICE_ATTEMPTS 3
7592 /* Returns true if FILE1 and FILE2 contain equivalent data, 0 otherwise. */
7595 files_equal_p (char *file1
, char *file2
)
7597 struct stat st1
, st2
;
7600 const int bufsize
= 8192;
7601 char *buf
= XNEWVEC (char, bufsize
);
7603 fd1
= open (file1
, O_RDONLY
);
7604 fd2
= open (file2
, O_RDONLY
);
7606 if (fd1
< 0 || fd2
< 0)
7609 if (fstat (fd1
, &st1
) < 0 || fstat (fd2
, &st2
) < 0)
7612 if (st1
.st_size
!= st2
.st_size
)
7615 for (n
= st1
.st_size
; n
; n
-= len
)
7618 if ((int) len
> bufsize
/ 2)
7621 if (read (fd1
, buf
, len
) != (int) len
7622 || read (fd2
, buf
+ bufsize
/ 2, len
) != (int) len
)
7627 if (memcmp (buf
, buf
+ bufsize
/ 2, len
) != 0)
7644 /* Check that compiler's output doesn't differ across runs.
7645 TEMP_STDOUT_FILES and TEMP_STDERR_FILES are arrays of files, containing
7646 stdout and stderr for each compiler run. Return true if all of
7647 TEMP_STDOUT_FILES and TEMP_STDERR_FILES are equivalent. */
7650 check_repro (char **temp_stdout_files
, char **temp_stderr_files
)
7653 for (i
= 0; i
< RETRY_ICE_ATTEMPTS
- 2; ++i
)
7655 if (!files_equal_p (temp_stdout_files
[i
], temp_stdout_files
[i
+ 1])
7656 || !files_equal_p (temp_stderr_files
[i
], temp_stderr_files
[i
+ 1]))
7658 fnotice (stderr
, "The bug is not reproducible, so it is"
7659 " likely a hardware or OS problem.\n");
7663 return i
== RETRY_ICE_ATTEMPTS
- 2;
7666 enum attempt_status
{
7667 ATTEMPT_STATUS_FAIL_TO_RUN
,
7668 ATTEMPT_STATUS_SUCCESS
,
7673 /* Run compiler with arguments NEW_ARGV to reproduce the ICE, storing stdout
7674 to OUT_TEMP and stderr to ERR_TEMP. If APPEND is TRUE, append to OUT_TEMP
7675 and ERR_TEMP instead of truncating. If EMIT_SYSTEM_INFO is TRUE, also write
7676 GCC configuration into to ERR_TEMP. Return ATTEMPT_STATUS_FAIL_TO_RUN if
7677 compiler failed to run, ATTEMPT_STATUS_ICE if compiled ICE-ed and
7678 ATTEMPT_STATUS_SUCCESS otherwise. */
7680 static enum attempt_status
7681 run_attempt (const char **new_argv
, const char *out_temp
,
7682 const char *err_temp
, int emit_system_info
, int append
)
7685 if (emit_system_info
)
7687 FILE *file_out
= fopen (err_temp
, "a");
7688 print_configuration (file_out
);
7689 fputs ("\n", file_out
);
7695 struct pex_obj
*pex
;
7697 int pex_flags
= PEX_USE_PIPES
| PEX_LAST
;
7698 enum attempt_status status
= ATTEMPT_STATUS_FAIL_TO_RUN
;
7701 pex_flags
|= PEX_STDOUT_APPEND
| PEX_STDERR_APPEND
;
7703 pex
= pex_init (PEX_USE_PIPES
, new_argv
[0], NULL
);
7705 fatal_error (input_location
, "%<pex_init%> failed: %m");
7707 errmsg
= pex_run (pex
, pex_flags
, new_argv
[0],
7708 CONST_CAST2 (char *const *, const char **, &new_argv
[1]),
7709 out_temp
, err_temp
, &err
);
7713 fatal_error (input_location
,
7714 err
? G_ ("cannot execute %qs: %s: %m")
7715 : G_ ("cannot execute %qs: %s"),
7716 new_argv
[0], errmsg
);
7719 if (!pex_get_status (pex
, 1, &exit_status
))
7722 switch (WEXITSTATUS (exit_status
))
7725 status
= ATTEMPT_STATUS_ICE
;
7728 case SUCCESS_EXIT_CODE
:
7729 status
= ATTEMPT_STATUS_SUCCESS
;
7741 /* This routine reads lines from IN file, adds C++ style comments
7742 at the begining of each line and writes result into OUT. */
7745 insert_comments (const char *file_in
, const char *file_out
)
7747 FILE *in
= fopen (file_in
, "rb");
7748 FILE *out
= fopen (file_out
, "wb");
7751 bool add_comment
= true;
7752 while (fgets (line
, sizeof (line
), in
))
7757 add_comment
= strchr (line
, '\n') != NULL
;
7764 /* This routine adds preprocessed source code into the given ERR_FILE.
7765 To do this, it adds "-E" to NEW_ARGV and execute RUN_ATTEMPT routine to
7766 add information in report file. RUN_ATTEMPT should return
7767 ATTEMPT_STATUS_SUCCESS, in other case we cannot generate the report. */
7770 do_report_bug (const char **new_argv
, const int nargs
,
7771 char **out_file
, char **err_file
)
7774 int fd
= open (*out_file
, O_RDWR
| O_APPEND
);
7777 write (fd
, "\n//", 3);
7778 for (i
= 0; i
< nargs
; i
++)
7781 write (fd
, new_argv
[i
], strlen (new_argv
[i
]));
7783 write (fd
, "\n\n", 2);
7785 new_argv
[nargs
] = "-E";
7786 new_argv
[nargs
+ 1] = NULL
;
7788 status
= run_attempt (new_argv
, *out_file
, *err_file
, 0, 1);
7790 if (status
== ATTEMPT_STATUS_SUCCESS
)
7792 fnotice (stderr
, "Preprocessed source stored into %s file,"
7793 " please attach this to your bugreport.\n", *out_file
);
7794 /* Make sure it is not deleted. */
7800 /* Try to reproduce ICE. If bug is reproducible, generate report .err file
7801 containing GCC configuration, backtrace, compiler's command line options
7802 and preprocessed source code. */
7805 try_generate_repro (const char **argv
)
7807 int i
, nargs
, out_arg
= -1, quiet
= 0, attempt
;
7808 const char **new_argv
;
7809 char *temp_files
[RETRY_ICE_ATTEMPTS
* 2];
7810 char **temp_stdout_files
= &temp_files
[0];
7811 char **temp_stderr_files
= &temp_files
[RETRY_ICE_ATTEMPTS
];
7813 if (gcc_input_filename
== NULL
|| ! strcmp (gcc_input_filename
, "-"))
7816 for (nargs
= 0; argv
[nargs
] != NULL
; ++nargs
)
7817 /* Only retry compiler ICEs, not preprocessor ones. */
7818 if (! strcmp (argv
[nargs
], "-E"))
7820 else if (argv
[nargs
][0] == '-' && argv
[nargs
][1] == 'o')
7827 /* If the compiler is going to output any time information,
7828 it might varry between invocations. */
7829 else if (! strcmp (argv
[nargs
], "-quiet"))
7831 else if (! strcmp (argv
[nargs
], "-ftime-report"))
7834 if (out_arg
== -1 || !quiet
)
7837 memset (temp_files
, '\0', sizeof (temp_files
));
7838 new_argv
= XALLOCAVEC (const char *, nargs
+ 4);
7839 memcpy (new_argv
, argv
, (nargs
+ 1) * sizeof (const char *));
7840 new_argv
[nargs
++] = "-frandom-seed=0";
7841 new_argv
[nargs
++] = "-fdump-noaddr";
7842 new_argv
[nargs
] = NULL
;
7843 if (new_argv
[out_arg
][2] == '\0')
7844 new_argv
[out_arg
+ 1] = "-";
7846 new_argv
[out_arg
] = "-o-";
7849 for (attempt
= 0; attempt
< RETRY_ICE_ATTEMPTS
; ++attempt
)
7851 int emit_system_info
= 0;
7853 temp_stdout_files
[attempt
] = make_temp_file (".out");
7854 temp_stderr_files
[attempt
] = make_temp_file (".err");
7856 if (attempt
== RETRY_ICE_ATTEMPTS
- 1)
7859 emit_system_info
= 1;
7862 status
= run_attempt (new_argv
, temp_stdout_files
[attempt
],
7863 temp_stderr_files
[attempt
], emit_system_info
,
7866 if (status
!= ATTEMPT_STATUS_ICE
)
7868 fnotice (stderr
, "The bug is not reproducible, so it is"
7869 " likely a hardware or OS problem.\n");
7874 if (!check_repro (temp_stdout_files
, temp_stderr_files
))
7878 /* Insert commented out backtrace into report file. */
7879 char **stderr_commented
= &temp_stdout_files
[RETRY_ICE_ATTEMPTS
- 1];
7880 insert_comments (temp_stderr_files
[RETRY_ICE_ATTEMPTS
- 1],
7883 /* In final attempt we append compiler options and preprocesssed code to last
7884 generated .out file with configuration and backtrace. */
7885 char **err
= &temp_stderr_files
[RETRY_ICE_ATTEMPTS
- 1];
7886 do_report_bug (new_argv
, nargs
, stderr_commented
, err
);
7890 for (i
= 0; i
< RETRY_ICE_ATTEMPTS
* 2; i
++)
7893 unlink (temp_stdout_files
[i
]);
7894 free (temp_stdout_files
[i
]);
7898 /* Search for a file named NAME trying various prefixes including the
7899 user's -B prefix and some standard ones.
7900 Return the absolute file name found. If nothing is found, return NAME. */
7903 find_file (const char *name
)
7905 char *newname
= find_a_file (&startfile_prefixes
, name
, R_OK
, true);
7906 return newname
? newname
: name
;
7909 /* Determine whether a directory exists. If LINKER, return 0 for
7910 certain fixed names not needed by the linker. */
7913 is_directory (const char *path1
, bool linker
)
7920 /* Ensure the string ends with "/.". The resulting path will be a
7921 directory even if the given path is a symbolic link. */
7922 len1
= strlen (path1
);
7923 path
= (char *) alloca (3 + len1
);
7924 memcpy (path
, path1
, len1
);
7926 if (!IS_DIR_SEPARATOR (cp
[-1]))
7927 *cp
++ = DIR_SEPARATOR
;
7931 /* Exclude directories that the linker is known to search. */
7933 && IS_DIR_SEPARATOR (path
[0])
7935 && filename_ncmp (path
+ 1, "lib", 3) == 0)
7937 && filename_ncmp (path
+ 1, "usr", 3) == 0
7938 && IS_DIR_SEPARATOR (path
[4])
7939 && filename_ncmp (path
+ 5, "lib", 3) == 0)))
7942 return (stat (path
, &st
) >= 0 && S_ISDIR (st
.st_mode
));
7945 /* Set up the various global variables to indicate that we're processing
7946 the input file named FILENAME. */
7949 set_input (const char *filename
)
7953 gcc_input_filename
= filename
;
7954 input_filename_length
= strlen (gcc_input_filename
);
7955 input_basename
= lbasename (gcc_input_filename
);
7957 /* Find a suffix starting with the last period,
7958 and set basename_length to exclude that suffix. */
7959 basename_length
= strlen (input_basename
);
7960 suffixed_basename_length
= basename_length
;
7961 p
= input_basename
+ basename_length
;
7962 while (p
!= input_basename
&& *p
!= '.')
7964 if (*p
== '.' && p
!= input_basename
)
7966 basename_length
= p
- input_basename
;
7967 input_suffix
= p
+ 1;
7972 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
7973 we will need to do a stat on the gcc_input_filename. The
7974 INPUT_STAT_SET signals that the stat is needed. */
7978 /* On fatal signals, delete all the temporary files. */
7981 fatal_signal (int signum
)
7983 signal (signum
, SIG_DFL
);
7984 delete_failure_queue ();
7985 delete_temp_files ();
7986 /* Get the same signal again, this time not handled,
7987 so its normal effect occurs. */
7988 kill (getpid (), signum
);
7991 /* Compare the contents of the two files named CMPFILE[0] and
7992 CMPFILE[1]. Return zero if they're identical, nonzero
7996 compare_files (char *cmpfile
[])
7999 FILE *temp
[2] = { NULL
, NULL
};
8005 void *map
[2] = { NULL
, NULL
};
8007 for (i
= 0; i
< 2; i
++)
8011 if (stat (cmpfile
[i
], &st
) < 0 || !S_ISREG (st
.st_mode
))
8013 error ("%s: could not determine length of compare-debug file %s",
8014 gcc_input_filename
, cmpfile
[i
]);
8019 length
[i
] = st
.st_size
;
8022 if (!ret
&& length
[0] != length
[1])
8024 error ("%s: %<-fcompare-debug%> failure (length)", gcc_input_filename
);
8029 for (i
= 0; i
< 2; i
++)
8031 int fd
= open (cmpfile
[i
], O_RDONLY
);
8034 error ("%s: could not open compare-debug file %s",
8035 gcc_input_filename
, cmpfile
[i
]);
8040 map
[i
] = mmap (NULL
, length
[i
], PROT_READ
, MAP_PRIVATE
, fd
, 0);
8043 if (map
[i
] == (void *) MAP_FAILED
)
8052 if (memcmp (map
[0], map
[1], length
[0]) != 0)
8054 error ("%s: %<-fcompare-debug%> failure", gcc_input_filename
);
8059 for (i
= 0; i
< 2; i
++)
8061 munmap ((caddr_t
) map
[i
], length
[i
]);
8070 for (i
= 0; i
< 2; i
++)
8072 temp
[i
] = fopen (cmpfile
[i
], "r");
8075 error ("%s: could not open compare-debug file %s",
8076 gcc_input_filename
, cmpfile
[i
]);
8082 if (!ret
&& temp
[0] && temp
[1])
8086 c0
= fgetc (temp
[0]);
8087 c1
= fgetc (temp
[1]);
8091 error ("%s: %<-fcompare-debug%> failure",
8092 gcc_input_filename
);
8101 for (i
= 1; i
>= 0; i
--)
8110 driver::driver (bool can_finalize
, bool debug
) :
8111 explicit_link_files (NULL
),
8112 decoded_options (NULL
)
8114 env
.init (can_finalize
, debug
);
8119 XDELETEVEC (explicit_link_files
);
8120 XDELETEVEC (decoded_options
);
8123 /* driver::main is implemented as a series of driver:: method calls. */
8126 driver::main (int argc
, char **argv
)
8130 set_progname (argv
[0]);
8131 expand_at_files (&argc
, &argv
);
8132 decode_argv (argc
, const_cast <const char **> (argv
));
8133 global_initializations ();
8134 build_multilib_strings ();
8136 putenv_COLLECT_AS_OPTIONS (assembler_options
);
8137 putenv_COLLECT_GCC (argv
[0]);
8138 maybe_putenv_COLLECT_LTO_WRAPPER ();
8139 maybe_putenv_OFFLOAD_TARGETS ();
8140 handle_unrecognized_options ();
8144 m_option_proposer
.suggest_completion (completion
);
8148 if (!maybe_print_and_exit ())
8151 early_exit
= prepare_infiles ();
8153 return get_exit_code ();
8155 do_spec_on_infiles ();
8156 maybe_run_linker (argv
[0]);
8158 return get_exit_code ();
8161 /* Locate the final component of argv[0] after any leading path, and set
8162 the program name accordingly. */
8165 driver::set_progname (const char *argv0
) const
8167 const char *p
= argv0
+ strlen (argv0
);
8168 while (p
!= argv0
&& !IS_DIR_SEPARATOR (p
[-1]))
8172 xmalloc_set_program_name (progname
);
8175 /* Expand any @ files within the command-line args,
8176 setting at_file_supplied if any were expanded. */
8179 driver::expand_at_files (int *argc
, char ***argv
) const
8181 char **old_argv
= *argv
;
8183 expandargv (argc
, argv
);
8185 /* Determine if any expansions were made. */
8186 if (*argv
!= old_argv
)
8187 at_file_supplied
= true;
8190 /* Decode the command-line arguments from argc/argv into the
8191 decoded_options array. */
8194 driver::decode_argv (int argc
, const char **argv
)
8196 init_opts_obstack ();
8197 init_options_struct (&global_options
, &global_options_set
);
8199 decode_cmdline_options_to_array (argc
, argv
,
8201 &decoded_options
, &decoded_options_count
);
8204 /* Perform various initializations and setup. */
8207 driver::global_initializations ()
8209 /* Unlock the stdio streams. */
8210 unlock_std_streams ();
8212 gcc_init_libintl ();
8214 diagnostic_initialize (global_dc
, 0);
8215 diagnostic_color_init (global_dc
);
8216 diagnostic_urls_init (global_dc
);
8218 #ifdef GCC_DRIVER_HOST_INITIALIZATION
8219 /* Perform host dependent initialization when needed. */
8220 GCC_DRIVER_HOST_INITIALIZATION
;
8223 if (atexit (delete_temp_files
) != 0)
8224 fatal_error (input_location
, "atexit failed");
8226 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
8227 signal (SIGINT
, fatal_signal
);
8229 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
8230 signal (SIGHUP
, fatal_signal
);
8232 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
8233 signal (SIGTERM
, fatal_signal
);
8235 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
8236 signal (SIGPIPE
, fatal_signal
);
8239 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
8240 receive the signal. A different setting is inheritable */
8241 signal (SIGCHLD
, SIG_DFL
);
8244 /* Parsing and gimplification sometimes need quite large stack.
8245 Increase stack size limits if possible. */
8246 stack_limit_increase (64 * 1024 * 1024);
8248 /* Allocate the argument vector. */
8251 obstack_init (&obstack
);
8254 /* Build multilib_select, et. al from the separate lines that make up each
8255 multilib selection. */
8258 driver::build_multilib_strings () const
8262 const char *const *q
= multilib_raw
;
8265 obstack_init (&multilib_obstack
);
8266 while ((p
= *q
++) != (char *) 0)
8267 obstack_grow (&multilib_obstack
, p
, strlen (p
));
8269 obstack_1grow (&multilib_obstack
, 0);
8270 multilib_select
= XOBFINISH (&multilib_obstack
, const char *);
8272 q
= multilib_matches_raw
;
8273 while ((p
= *q
++) != (char *) 0)
8274 obstack_grow (&multilib_obstack
, p
, strlen (p
));
8276 obstack_1grow (&multilib_obstack
, 0);
8277 multilib_matches
= XOBFINISH (&multilib_obstack
, const char *);
8279 q
= multilib_exclusions_raw
;
8280 while ((p
= *q
++) != (char *) 0)
8281 obstack_grow (&multilib_obstack
, p
, strlen (p
));
8283 obstack_1grow (&multilib_obstack
, 0);
8284 multilib_exclusions
= XOBFINISH (&multilib_obstack
, const char *);
8286 q
= multilib_reuse_raw
;
8287 while ((p
= *q
++) != (char *) 0)
8288 obstack_grow (&multilib_obstack
, p
, strlen (p
));
8290 obstack_1grow (&multilib_obstack
, 0);
8291 multilib_reuse
= XOBFINISH (&multilib_obstack
, const char *);
8294 for (size_t i
= 0; i
< ARRAY_SIZE (multilib_defaults_raw
); i
++)
8297 obstack_1grow (&multilib_obstack
, ' ');
8298 obstack_grow (&multilib_obstack
,
8299 multilib_defaults_raw
[i
],
8300 strlen (multilib_defaults_raw
[i
]));
8304 obstack_1grow (&multilib_obstack
, 0);
8305 multilib_defaults
= XOBFINISH (&multilib_obstack
, const char *);
8309 /* Set up the spec-handling machinery. */
8312 driver::set_up_specs () const
8314 const char *spec_machine_suffix
;
8318 #ifdef INIT_ENVIRONMENT
8319 /* Set up any other necessary machine specific environment variables. */
8320 xputenv (INIT_ENVIRONMENT
);
8323 /* Make a table of what switches there are (switches, n_switches).
8324 Make a table of specified input files (infiles, n_infiles).
8325 Decode switches that are handled locally. */
8327 process_command (decoded_options_count
, decoded_options
);
8329 /* Initialize the vector of specs to just the default.
8330 This means one element containing 0s, as a terminator. */
8332 compilers
= XNEWVAR (struct compiler
, sizeof default_compilers
);
8333 memcpy (compilers
, default_compilers
, sizeof default_compilers
);
8334 n_compilers
= n_default_compilers
;
8336 /* Read specs from a file if there is one. */
8338 machine_suffix
= concat (spec_host_machine
, dir_separator_str
, spec_version
,
8339 accel_dir_suffix
, dir_separator_str
, NULL
);
8340 just_machine_suffix
= concat (spec_machine
, dir_separator_str
, NULL
);
8342 specs_file
= find_a_file (&startfile_prefixes
, "specs", R_OK
, true);
8343 /* Read the specs file unless it is a default one. */
8344 if (specs_file
!= 0 && strcmp (specs_file
, "specs"))
8345 read_specs (specs_file
, true, false);
8349 #ifdef ACCEL_COMPILER
8350 spec_machine_suffix
= machine_suffix
;
8352 spec_machine_suffix
= just_machine_suffix
;
8355 /* We need to check standard_exec_prefix/spec_machine_suffix/specs
8356 for any override of as, ld and libraries. */
8357 specs_file
= (char *) alloca (strlen (standard_exec_prefix
)
8358 + strlen (spec_machine_suffix
) + sizeof ("specs"));
8359 strcpy (specs_file
, standard_exec_prefix
);
8360 strcat (specs_file
, spec_machine_suffix
);
8361 strcat (specs_file
, "specs");
8362 if (access (specs_file
, R_OK
) == 0)
8363 read_specs (specs_file
, true, false);
8365 /* Process any configure-time defaults specified for the command line
8366 options, via OPTION_DEFAULT_SPECS. */
8367 for (i
= 0; i
< ARRAY_SIZE (option_default_specs
); i
++)
8368 do_option_spec (option_default_specs
[i
].name
,
8369 option_default_specs
[i
].spec
);
8371 /* Process DRIVER_SELF_SPECS, adding any new options to the end
8372 of the command line. */
8374 for (i
= 0; i
< ARRAY_SIZE (driver_self_specs
); i
++)
8375 do_self_spec (driver_self_specs
[i
]);
8377 /* If not cross-compiling, look for executables in the standard
8379 if (*cross_compile
== '0')
8381 if (*md_exec_prefix
)
8383 add_prefix (&exec_prefixes
, md_exec_prefix
, "GCC",
8384 PREFIX_PRIORITY_LAST
, 0, 0);
8388 /* Process sysroot_suffix_spec. */
8389 if (*sysroot_suffix_spec
!= 0
8390 && !no_sysroot_suffix
8391 && do_spec_2 (sysroot_suffix_spec
, NULL
) == 0)
8393 if (argbuf
.length () > 1)
8394 error ("spec failure: more than one argument to "
8395 "%<SYSROOT_SUFFIX_SPEC%>");
8396 else if (argbuf
.length () == 1)
8397 target_sysroot_suffix
= xstrdup (argbuf
.last ());
8400 #ifdef HAVE_LD_SYSROOT
8401 /* Pass the --sysroot option to the linker, if it supports that. If
8402 there is a sysroot_suffix_spec, it has already been processed by
8403 this point, so target_system_root really is the system root we
8405 if (target_system_root
)
8407 obstack_grow (&obstack
, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
8408 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
8409 set_spec ("link", XOBFINISH (&obstack
, const char *), false);
8413 /* Process sysroot_hdrs_suffix_spec. */
8414 if (*sysroot_hdrs_suffix_spec
!= 0
8415 && !no_sysroot_suffix
8416 && do_spec_2 (sysroot_hdrs_suffix_spec
, NULL
) == 0)
8418 if (argbuf
.length () > 1)
8419 error ("spec failure: more than one argument "
8420 "to %<SYSROOT_HEADERS_SUFFIX_SPEC%>");
8421 else if (argbuf
.length () == 1)
8422 target_sysroot_hdrs_suffix
= xstrdup (argbuf
.last ());
8425 /* Look for startfiles in the standard places. */
8426 if (*startfile_prefix_spec
!= 0
8427 && do_spec_2 (startfile_prefix_spec
, NULL
) == 0
8428 && do_spec_1 (" ", 0, NULL
) == 0)
8430 for (const char *arg
: argbuf
)
8431 add_sysrooted_prefix (&startfile_prefixes
, arg
, "BINUTILS",
8432 PREFIX_PRIORITY_LAST
, 0, 1);
8434 /* We should eventually get rid of all these and stick to
8435 startfile_prefix_spec exclusively. */
8436 else if (*cross_compile
== '0' || target_system_root
)
8438 if (*md_startfile_prefix
)
8439 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix
,
8440 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
8442 if (*md_startfile_prefix_1
)
8443 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix_1
,
8444 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
8446 /* If standard_startfile_prefix is relative, base it on
8447 standard_exec_prefix. This lets us move the installed tree
8448 as a unit. If GCC_EXEC_PREFIX is defined, base
8449 standard_startfile_prefix on that as well.
8451 If the prefix is relative, only search it for native compilers;
8452 otherwise we will search a directory containing host libraries. */
8453 if (IS_ABSOLUTE_PATH (standard_startfile_prefix
))
8454 add_sysrooted_prefix (&startfile_prefixes
,
8455 standard_startfile_prefix
, "BINUTILS",
8456 PREFIX_PRIORITY_LAST
, 0, 1);
8457 else if (*cross_compile
== '0')
8459 add_prefix (&startfile_prefixes
,
8460 concat (gcc_exec_prefix
8461 ? gcc_exec_prefix
: standard_exec_prefix
,
8463 standard_startfile_prefix
, NULL
),
8464 NULL
, PREFIX_PRIORITY_LAST
, 0, 1);
8467 /* Sysrooted prefixes are relocated because target_system_root is
8468 also relocated by gcc_exec_prefix. */
8469 if (*standard_startfile_prefix_1
)
8470 add_sysrooted_prefix (&startfile_prefixes
,
8471 standard_startfile_prefix_1
, "BINUTILS",
8472 PREFIX_PRIORITY_LAST
, 0, 1);
8473 if (*standard_startfile_prefix_2
)
8474 add_sysrooted_prefix (&startfile_prefixes
,
8475 standard_startfile_prefix_2
, "BINUTILS",
8476 PREFIX_PRIORITY_LAST
, 0, 1);
8479 /* Process any user specified specs in the order given on the command
8481 for (struct user_specs
*uptr
= user_specs_head
; uptr
; uptr
= uptr
->next
)
8483 char *filename
= find_a_file (&startfile_prefixes
, uptr
->filename
,
8485 read_specs (filename
? filename
: uptr
->filename
, false, true);
8488 /* Process any user self specs. */
8490 struct spec_list
*sl
;
8491 for (sl
= specs
; sl
; sl
= sl
->next
)
8492 if (sl
->name_len
== sizeof "self_spec" - 1
8493 && !strcmp (sl
->name
, "self_spec"))
8494 do_self_spec (*sl
->ptr_spec
);
8499 enum save_temps save
;
8501 if (!compare_debug_second
)
8503 n_switches_debug_check
[1] = n_switches
;
8504 n_switches_alloc_debug_check
[1] = n_switches_alloc
;
8505 switches_debug_check
[1] = XDUPVEC (struct switchstr
, switches
,
8508 do_self_spec ("%:compare-debug-self-opt()");
8509 n_switches_debug_check
[0] = n_switches
;
8510 n_switches_alloc_debug_check
[0] = n_switches_alloc
;
8511 switches_debug_check
[0] = switches
;
8513 n_switches
= n_switches_debug_check
[1];
8514 n_switches_alloc
= n_switches_alloc_debug_check
[1];
8515 switches
= switches_debug_check
[1];
8518 /* Avoid crash when computing %j in this early. */
8519 save
= save_temps_flag
;
8520 save_temps_flag
= SAVE_TEMPS_NONE
;
8522 compare_debug
= -compare_debug
;
8523 do_self_spec ("%:compare-debug-self-opt()");
8525 save_temps_flag
= save
;
8527 if (!compare_debug_second
)
8529 n_switches_debug_check
[1] = n_switches
;
8530 n_switches_alloc_debug_check
[1] = n_switches_alloc
;
8531 switches_debug_check
[1] = switches
;
8532 compare_debug
= -compare_debug
;
8533 n_switches
= n_switches_debug_check
[0];
8534 n_switches_alloc
= n_switches_debug_check
[0];
8535 switches
= switches_debug_check
[0];
8540 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
8541 if (gcc_exec_prefix
)
8542 gcc_exec_prefix
= concat (gcc_exec_prefix
, spec_host_machine
,
8543 dir_separator_str
, spec_version
,
8544 accel_dir_suffix
, dir_separator_str
, NULL
);
8546 /* Now we have the specs.
8547 Set the `valid' bits for switches that match anything in any spec. */
8549 validate_all_switches ();
8551 /* Now that we have the switches and the specs, set
8552 the subdirectory based on the options. */
8553 set_multilib_dir ();
8556 /* Set up to remember the pathname of gcc and any options
8557 needed for collect. We use argv[0] instead of progname because
8558 we need the complete pathname. */
8561 driver::putenv_COLLECT_GCC (const char *argv0
) const
8563 obstack_init (&collect_obstack
);
8564 obstack_grow (&collect_obstack
, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
8565 obstack_grow (&collect_obstack
, argv0
, strlen (argv0
) + 1);
8566 xputenv (XOBFINISH (&collect_obstack
, char *));
8569 /* Set up to remember the pathname of the lto wrapper. */
8572 driver::maybe_putenv_COLLECT_LTO_WRAPPER () const
8574 char *lto_wrapper_file
;
8577 lto_wrapper_file
= NULL
;
8579 lto_wrapper_file
= find_a_program ("lto-wrapper");
8580 if (lto_wrapper_file
)
8582 lto_wrapper_file
= convert_white_space (lto_wrapper_file
);
8583 set_static_spec_owned (<o_wrapper_spec
, lto_wrapper_file
);
8584 obstack_init (&collect_obstack
);
8585 obstack_grow (&collect_obstack
, "COLLECT_LTO_WRAPPER=",
8586 sizeof ("COLLECT_LTO_WRAPPER=") - 1);
8587 obstack_grow (&collect_obstack
, lto_wrapper_spec
,
8588 strlen (lto_wrapper_spec
) + 1);
8589 xputenv (XOBFINISH (&collect_obstack
, char *));
8594 /* Set up to remember the names of offload targets. */
8597 driver::maybe_putenv_OFFLOAD_TARGETS () const
8599 if (offload_targets
&& offload_targets
[0] != '\0')
8601 obstack_grow (&collect_obstack
, "OFFLOAD_TARGET_NAMES=",
8602 sizeof ("OFFLOAD_TARGET_NAMES=") - 1);
8603 obstack_grow (&collect_obstack
, offload_targets
,
8604 strlen (offload_targets
) + 1);
8605 xputenv (XOBFINISH (&collect_obstack
, char *));
8606 #if OFFLOAD_DEFAULTED
8607 if (offload_targets_default
)
8608 xputenv ("OFFLOAD_TARGET_DEFAULT=1");
8612 free (offload_targets
);
8613 offload_targets
= NULL
;
8616 /* Reject switches that no pass was interested in. */
8619 driver::handle_unrecognized_options ()
8621 for (size_t i
= 0; (int) i
< n_switches
; i
++)
8622 if (! switches
[i
].validated
)
8624 const char *hint
= m_option_proposer
.suggest_option (switches
[i
].part1
);
8626 error ("unrecognized command-line option %<-%s%>;"
8627 " did you mean %<-%s%>?",
8628 switches
[i
].part1
, hint
);
8630 error ("unrecognized command-line option %<-%s%>",
8635 /* Handle the various -print-* options, returning 0 if the driver
8636 should exit, or nonzero if the driver should continue. */
8639 driver::maybe_print_and_exit () const
8641 if (print_search_dirs
)
8643 printf (_("install: %s%s\n"),
8644 gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
8645 gcc_exec_prefix
? "" : machine_suffix
);
8646 printf (_("programs: %s\n"),
8647 build_search_list (&exec_prefixes
, "", false, false));
8648 printf (_("libraries: %s\n"),
8649 build_search_list (&startfile_prefixes
, "", false, true));
8653 if (print_file_name
)
8655 printf ("%s\n", find_file (print_file_name
));
8659 if (print_prog_name
)
8661 if (use_ld
!= NULL
&& ! strcmp (print_prog_name
, "ld"))
8663 /* Append USE_LD to the default linker. */
8664 #ifdef DEFAULT_LINKER
8666 # ifdef HAVE_HOST_EXECUTABLE_SUFFIX
8667 int len
= (sizeof (DEFAULT_LINKER
)
8668 - sizeof (HOST_EXECUTABLE_SUFFIX
));
8672 char *default_linker
= xstrdup (DEFAULT_LINKER
);
8673 /* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains
8674 HOST_EXECUTABLE_SUFFIX. */
8675 if (! strcmp (&default_linker
[len
], HOST_EXECUTABLE_SUFFIX
))
8677 default_linker
[len
] = '\0';
8678 ld
= concat (default_linker
, use_ld
,
8679 HOST_EXECUTABLE_SUFFIX
, NULL
);
8684 ld
= concat (DEFAULT_LINKER
, use_ld
, NULL
);
8685 if (access (ld
, X_OK
) == 0)
8687 printf ("%s\n", ld
);
8691 print_prog_name
= concat (print_prog_name
, use_ld
, NULL
);
8693 char *newname
= find_a_program (print_prog_name
);
8694 printf ("%s\n", (newname
? newname
: print_prog_name
));
8698 if (print_multi_lib
)
8700 print_multilib_info ();
8704 if (print_multi_directory
)
8706 if (multilib_dir
== NULL
)
8709 printf ("%s\n", multilib_dir
);
8713 if (print_multiarch
)
8715 if (multiarch_dir
== NULL
)
8718 printf ("%s\n", multiarch_dir
);
8724 if (target_system_root
)
8726 if (target_sysroot_suffix
)
8727 printf ("%s%s\n", target_system_root
, target_sysroot_suffix
);
8729 printf ("%s\n", target_system_root
);
8734 if (print_multi_os_directory
)
8736 if (multilib_os_dir
== NULL
)
8739 printf ("%s\n", multilib_os_dir
);
8743 if (print_sysroot_headers_suffix
)
8745 if (*sysroot_hdrs_suffix_spec
)
8747 printf("%s\n", (target_sysroot_hdrs_suffix
8748 ? target_sysroot_hdrs_suffix
8753 /* The error status indicates that only one set of fixed
8754 headers should be built. */
8755 fatal_error (input_location
,
8756 "not configured with sysroot headers suffix");
8759 if (print_help_list
)
8765 printf (_("\nFor bug reporting instructions, please see:\n"));
8766 printf ("%s.\n", bug_report_url
);
8771 /* We do not exit here. Instead we have created a fake input file
8772 called 'help-dummy' which needs to be compiled, and we pass this
8773 on the various sub-processes, along with the --help switch.
8774 Ensure their output appears after ours. */
8775 fputc ('\n', stdout
);
8781 printf (_("%s %s%s\n"), progname
, pkgversion_string
,
8783 printf ("Copyright %s 2022 Free Software Foundation, Inc.\n",
8785 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
8786 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
8791 /* We do not exit here. We use the same mechanism of --help to print
8792 the version of the sub-processes. */
8793 fputc ('\n', stdout
);
8799 print_configuration (stderr
);
8807 /* Figure out what to do with each input file.
8808 Return true if we need to exit early from "main", false otherwise. */
8811 driver::prepare_infiles ()
8814 int lang_n_infiles
= 0;
8816 if (n_infiles
== added_libraries
)
8817 fatal_error (input_location
, "no input files");
8820 /* Early exit needed from main. */
8823 /* Make a place to record the compiler output file names
8824 that correspond to the input files. */
8827 i
+= lang_specific_extra_outfiles
;
8828 outfiles
= XCNEWVEC (const char *, i
);
8830 /* Record which files were specified explicitly as link input. */
8832 explicit_link_files
= XCNEWVEC (char, n_infiles
);
8834 combine_inputs
= have_o
|| flag_wpa
;
8836 for (i
= 0; (int) i
< n_infiles
; i
++)
8838 const char *name
= infiles
[i
].name
;
8839 struct compiler
*compiler
= lookup_compiler (name
,
8841 infiles
[i
].language
);
8843 if (compiler
&& !(compiler
->combinable
))
8844 combine_inputs
= false;
8846 if (lang_n_infiles
> 0 && compiler
!= input_file_compiler
8847 && infiles
[i
].language
&& infiles
[i
].language
[0] != '*')
8848 infiles
[i
].incompiler
= compiler
;
8852 input_file_compiler
= compiler
;
8853 infiles
[i
].incompiler
= compiler
;
8857 /* Since there is no compiler for this input file, assume it is a
8859 explicit_link_files
[i
] = 1;
8860 infiles
[i
].incompiler
= NULL
;
8862 infiles
[i
].compiled
= false;
8863 infiles
[i
].preprocessed
= false;
8866 if (!combine_inputs
&& have_c
&& have_o
&& lang_n_infiles
> 1)
8867 fatal_error (input_location
,
8868 "cannot specify %<-o%> with %<-c%>, %<-S%> or %<-E%> "
8869 "with multiple files");
8871 /* No early exit needed from main; we can continue. */
8875 /* Run the spec machinery on each input file. */
8878 driver::do_spec_on_infiles () const
8882 for (i
= 0; (int) i
< n_infiles
; i
++)
8884 int this_file_error
= 0;
8886 /* Tell do_spec what to substitute for %i. */
8888 input_file_number
= i
;
8889 set_input (infiles
[i
].name
);
8891 if (infiles
[i
].compiled
)
8894 /* Use the same thing in %o, unless cp->spec says otherwise. */
8896 outfiles
[i
] = gcc_input_filename
;
8898 /* Figure out which compiler from the file's suffix. */
8901 = lookup_compiler (infiles
[i
].name
, input_filename_length
,
8902 infiles
[i
].language
);
8904 if (input_file_compiler
)
8906 /* Ok, we found an applicable compiler. Run its spec. */
8908 if (input_file_compiler
->spec
[0] == '#')
8910 error ("%s: %s compiler not installed on this system",
8911 gcc_input_filename
, &input_file_compiler
->spec
[1]);
8912 this_file_error
= 1;
8920 free (debug_check_temp_file
[0]);
8921 debug_check_temp_file
[0] = NULL
;
8923 free (debug_check_temp_file
[1]);
8924 debug_check_temp_file
[1] = NULL
;
8927 value
= do_spec (input_file_compiler
->spec
);
8928 infiles
[i
].compiled
= true;
8930 this_file_error
= 1;
8931 else if (compare_debug
&& debug_check_temp_file
[0])
8934 inform (UNKNOWN_LOCATION
,
8935 "recompiling with %<-fcompare-debug%>");
8937 compare_debug
= -compare_debug
;
8938 n_switches
= n_switches_debug_check
[1];
8939 n_switches_alloc
= n_switches_alloc_debug_check
[1];
8940 switches
= switches_debug_check
[1];
8942 value
= do_spec (input_file_compiler
->spec
);
8944 compare_debug
= -compare_debug
;
8945 n_switches
= n_switches_debug_check
[0];
8946 n_switches_alloc
= n_switches_alloc_debug_check
[0];
8947 switches
= switches_debug_check
[0];
8951 error ("during %<-fcompare-debug%> recompilation");
8952 this_file_error
= 1;
8955 gcc_assert (debug_check_temp_file
[1]
8956 && filename_cmp (debug_check_temp_file
[0],
8957 debug_check_temp_file
[1]));
8960 inform (UNKNOWN_LOCATION
, "comparing final insns dumps");
8962 if (compare_files (debug_check_temp_file
))
8963 this_file_error
= 1;
8968 free (debug_check_temp_file
[0]);
8969 debug_check_temp_file
[0] = NULL
;
8971 free (debug_check_temp_file
[1]);
8972 debug_check_temp_file
[1] = NULL
;
8977 /* If this file's name does not contain a recognized suffix,
8978 record it as explicit linker input. */
8981 explicit_link_files
[i
] = 1;
8983 /* Clear the delete-on-failure queue, deleting the files in it
8984 if this compilation failed. */
8986 if (this_file_error
)
8988 delete_failure_queue ();
8991 /* If this compilation succeeded, don't delete those files later. */
8992 clear_failure_queue ();
8995 /* Reset the input file name to the first compile/object file name, for use
8996 with %b in LINK_SPEC. We use the first input file that we can find
8997 a compiler to compile it instead of using infiles.language since for
8998 languages other than C we use aliases that we then lookup later. */
9003 for (i
= 0; i
< n_infiles
; i
++)
9004 if (infiles
[i
].incompiler
9005 || (infiles
[i
].language
&& infiles
[i
].language
[0] != '*'))
9007 set_input (infiles
[i
].name
);
9014 /* Make sure INPUT_FILE_NUMBER points to first available open
9016 input_file_number
= n_infiles
;
9017 if (lang_specific_pre_link ())
9022 /* If we have to run the linker, do it now. */
9025 driver::maybe_run_linker (const char *argv0
) const
9028 int linker_was_run
= 0;
9029 int num_linker_inputs
;
9031 /* Determine if there are any linker input files. */
9032 num_linker_inputs
= 0;
9033 for (i
= 0; (int) i
< n_infiles
; i
++)
9034 if (explicit_link_files
[i
] || outfiles
[i
] != NULL
)
9035 num_linker_inputs
++;
9037 /* Arrange for temporary file names created during linking to take
9038 on names related with the linker output rather than with the
9039 inputs when appropriate. */
9040 if (outbase
&& *outbase
)
9044 char *tofree
= dumpdir
;
9045 gcc_checking_assert (strlen (dumpdir
) == dumpdir_length
);
9046 dumpdir
= concat (dumpdir
, outbase
, ".", NULL
);
9050 dumpdir
= concat (outbase
, ".", NULL
);
9051 dumpdir_length
+= strlen (outbase
) + 1;
9052 dumpdir_trailing_dash_added
= true;
9054 else if (dumpdir_trailing_dash_added
)
9056 gcc_assert (dumpdir
[dumpdir_length
- 1] == '-');
9057 dumpdir
[dumpdir_length
- 1] = '.';
9060 if (dumpdir_trailing_dash_added
)
9062 gcc_assert (dumpdir_length
> 0);
9063 gcc_assert (dumpdir
[dumpdir_length
- 1] == '.');
9068 input_basename
= outbase
= NULL
;
9069 outbase_length
= suffixed_basename_length
= basename_length
= 0;
9071 /* Run ld to link all the compiler output files. */
9073 if (num_linker_inputs
> 0 && !seen_error () && print_subprocess_help
< 2)
9075 int tmp
= execution_count
;
9077 detect_jobserver ();
9081 #if HAVE_LTO_PLUGIN > 0
9082 #if HAVE_LTO_PLUGIN == 2
9083 const char *fno_use_linker_plugin
= "fno-use-linker-plugin";
9085 const char *fuse_linker_plugin
= "fuse-linker-plugin";
9089 /* We'll use ld if we can't find collect2. */
9090 if (! strcmp (linker_name_spec
, "collect2"))
9092 char *s
= find_a_program ("collect2");
9094 set_static_spec_shared (&linker_name_spec
, "ld");
9097 #if HAVE_LTO_PLUGIN > 0
9098 #if HAVE_LTO_PLUGIN == 2
9099 if (!switch_matches (fno_use_linker_plugin
,
9100 fno_use_linker_plugin
9101 + strlen (fno_use_linker_plugin
), 0))
9103 if (switch_matches (fuse_linker_plugin
,
9105 + strlen (fuse_linker_plugin
), 0))
9108 char *temp_spec
= find_a_file (&exec_prefixes
,
9109 LTOPLUGINSONAME
, R_OK
,
9112 fatal_error (input_location
,
9113 "%<-fuse-linker-plugin%>, but %s not found",
9115 linker_plugin_file_spec
= convert_white_space (temp_spec
);
9118 set_static_spec_shared (<o_gcc_spec
, argv0
);
9121 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
9123 putenv_from_prefixes (&exec_prefixes
, "COMPILER_PATH", false);
9124 putenv_from_prefixes (&startfile_prefixes
, LIBRARY_PATH_ENV
, true);
9126 if (print_subprocess_help
== 1)
9128 printf (_("\nLinker options\n==============\n\n"));
9129 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
9130 " to the linker.\n\n"));
9133 int value
= do_spec (link_command_spec
);
9136 linker_was_run
= (tmp
!= execution_count
);
9139 /* If options said don't run linker,
9140 complain about input files to be given to the linker. */
9142 if (! linker_was_run
&& !seen_error ())
9143 for (i
= 0; (int) i
< n_infiles
; i
++)
9144 if (explicit_link_files
[i
]
9145 && !(infiles
[i
].language
&& infiles
[i
].language
[0] == '*'))
9147 warning (0, "%s: linker input file unused because linking not done",
9149 if (access (outfiles
[i
], F_OK
) < 0)
9150 /* This is can be an indication the user specifed an errorneous
9151 separated option value, (or used the wrong prefix for an
9153 error ("%s: linker input file not found: %m", outfiles
[i
]);
9157 /* The end of "main". */
9160 driver::final_actions () const
9162 /* Delete some or all of the temporary files we made. */
9165 delete_failure_queue ();
9166 delete_temp_files ();
9168 if (print_help_list
)
9170 printf (("\nFor bug reporting instructions, please see:\n"));
9171 printf ("%s\n", bug_report_url
);
9175 /* Detect whether jobserver is active and working. If not drop
9176 --jobserver-auth from MAKEFLAGS. */
9179 driver::detect_jobserver () const
9181 /* Detect jobserver and drop it if it's not working. */
9182 const char *makeflags
= env
.get ("MAKEFLAGS");
9183 if (makeflags
!= NULL
)
9185 const char *needle
= "--jobserver-auth=";
9186 const char *n
= strstr (makeflags
, needle
);
9193 = (sscanf (n
+ strlen (needle
), "%d,%d", &rfd
, &wfd
) == 2
9196 && is_valid_fd (rfd
)
9197 && is_valid_fd (wfd
));
9199 /* Drop the jobserver if it's not working now. */
9202 unsigned offset
= n
- makeflags
;
9203 char *dup
= xstrdup (makeflags
);
9206 const char *space
= strchr (makeflags
+ offset
, ' ');
9208 strcpy (dup
+ offset
, space
);
9209 xputenv (concat ("MAKEFLAGS=", dup
, NULL
));
9215 /* Determine what the exit code of the driver should be. */
9218 driver::get_exit_code () const
9220 return (signal_count
!= 0 ? 2
9221 : seen_error () ? (pass_exit_codes
? greatest_status
: 1)
9225 /* Find the proper compilation spec for the file name NAME,
9226 whose length is LENGTH. LANGUAGE is the specified language,
9227 or 0 if this file is to be passed to the linker. */
9229 static struct compiler
*
9230 lookup_compiler (const char *name
, size_t length
, const char *language
)
9232 struct compiler
*cp
;
9234 /* If this was specified by the user to be a linker input, indicate that. */
9235 if (language
!= 0 && language
[0] == '*')
9238 /* Otherwise, look for the language, if one is spec'd. */
9241 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
9242 if (cp
->suffix
[0] == '@' && !strcmp (cp
->suffix
+ 1, language
))
9244 if (name
!= NULL
&& strcmp (name
, "-") == 0
9245 && (strcmp (cp
->suffix
, "@c-header") == 0
9246 || strcmp (cp
->suffix
, "@c++-header") == 0)
9248 fatal_error (input_location
,
9249 "cannot use %<-%> as input filename for a "
9250 "precompiled header");
9255 error ("language %s not recognized", language
);
9259 /* Look for a suffix. */
9260 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
9262 if (/* The suffix `-' matches only the file name `-'. */
9263 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
9264 || (strlen (cp
->suffix
) < length
9265 /* See if the suffix matches the end of NAME. */
9266 && !strcmp (cp
->suffix
,
9267 name
+ length
- strlen (cp
->suffix
))
9272 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
9273 /* Look again, but case-insensitively this time. */
9275 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
9277 if (/* The suffix `-' matches only the file name `-'. */
9278 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
9279 || (strlen (cp
->suffix
) < length
9280 /* See if the suffix matches the end of NAME. */
9281 && ((!strcmp (cp
->suffix
,
9282 name
+ length
- strlen (cp
->suffix
))
9283 || !strpbrk (cp
->suffix
, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
9284 && !strcasecmp (cp
->suffix
,
9285 name
+ length
- strlen (cp
->suffix
)))
9291 if (cp
>= compilers
)
9293 if (cp
->spec
[0] != '@')
9294 /* A non-alias entry: return it. */
9297 /* An alias entry maps a suffix to a language.
9298 Search for the language; pass 0 for NAME and LENGTH
9299 to avoid infinite recursion if language not found. */
9300 return lookup_compiler (NULL
, 0, cp
->spec
+ 1);
9306 save_string (const char *s
, int len
)
9308 char *result
= XNEWVEC (char, len
+ 1);
9310 gcc_checking_assert (strlen (s
) >= (unsigned int) len
);
9311 memcpy (result
, s
, len
);
9318 validate_switches_from_spec (const char *spec
, bool user
)
9320 const char *p
= spec
;
9326 || (*p
== 'W' && *++p
== '{')
9327 || (*p
== '@' && *++p
== '{')))
9328 /* We have a switch spec. */
9329 p
= validate_switches (p
+ 1, user
, *p
== '{');
9333 validate_all_switches (void)
9335 struct compiler
*comp
;
9336 struct spec_list
*spec
;
9338 for (comp
= compilers
; comp
->spec
; comp
++)
9339 validate_switches_from_spec (comp
->spec
, false);
9341 /* Look through the linked list of specs read from the specs file. */
9342 for (spec
= specs
; spec
; spec
= spec
->next
)
9343 validate_switches_from_spec (*spec
->ptr_spec
, spec
->user_p
);
9345 validate_switches_from_spec (link_command_spec
, false);
9348 /* Look at the switch-name that comes after START and mark as valid
9349 all supplied switches that match it. If BRACED, handle other
9350 switches after '|' and '&', and specs after ':' until ';' or '}',
9351 going back for more switches after ';'. Without BRACED, handle
9352 only one atom. Return a pointer to whatever follows the handled
9353 items, after the closing brace if BRACED. */
9356 validate_switches (const char *start
, bool user_spec
, bool braced
)
9358 const char *p
= start
;
9362 bool suffix
= false;
9363 bool starred
= false;
9365 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
9374 if (*p
== '.' || *p
== ',')
9378 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
9379 || *p
== ',' || *p
== '.' || *p
== '@')
9384 starred
= true, p
++;
9390 /* Mark all matching switches as valid. */
9391 for (i
= 0; i
< n_switches
; i
++)
9392 if (!strncmp (switches
[i
].part1
, atom
, len
)
9393 && (starred
|| switches
[i
].part1
[len
] == '\0')
9394 && (switches
[i
].known
|| user_spec
))
9395 switches
[i
].validated
= true;
9402 if (*p
&& (p
[-1] == '|' || p
[-1] == '&'))
9405 if (*p
&& p
[-1] == ':')
9407 while (*p
&& *p
!= ';' && *p
!= '}')
9412 if (*p
== '{' || *p
== '<')
9413 p
= validate_switches (p
+1, user_spec
, *p
== '{');
9414 else if (p
[0] == 'W' && p
[1] == '{')
9415 p
= validate_switches (p
+2, user_spec
, true);
9416 else if (p
[0] == '@' && p
[1] == '{')
9417 p
= validate_switches (p
+2, user_spec
, true);
9424 if (*p
&& p
[-1] == ';')
9438 static struct mdswitchstr
*mdswitches
;
9439 static int n_mdswitches
;
9441 /* Check whether a particular argument was used. The first time we
9442 canonicalize the switches to keep only the ones we care about. */
9447 int operator () (const char *p
, int len
);
9454 const char *replace
;
9459 mswitchstr
*mswitches
;
9464 used_arg_t used_arg
;
9467 used_arg_t::operator () (const char *p
, int len
)
9473 struct mswitchstr
*matches
;
9477 /* Break multilib_matches into the component strings of string
9478 and replacement string. */
9479 for (q
= multilib_matches
; *q
!= '\0'; q
++)
9484 = (struct mswitchstr
*) alloca ((sizeof (struct mswitchstr
)) * cnt
);
9486 q
= multilib_matches
;
9495 fatal_error (input_location
, "multilib spec %qs is invalid",
9500 matches
[i
].len
= q
- matches
[i
].str
;
9502 matches
[i
].replace
= ++q
;
9503 while (*q
!= ';' && *q
!= '\0')
9506 goto invalid_matches
;
9509 matches
[i
].rep_len
= q
- matches
[i
].replace
;
9515 /* Now build a list of the replacement string for switches that we care
9516 about. Make sure we allocate at least one entry. This prevents
9517 xmalloc from calling fatal, and prevents us from re-executing this
9520 = XNEWVEC (struct mswitchstr
, n_mdswitches
+ (n_switches
? n_switches
: 1));
9521 for (i
= 0; i
< n_switches
; i
++)
9522 if ((switches
[i
].live_cond
& SWITCH_IGNORE
) == 0)
9524 int xlen
= strlen (switches
[i
].part1
);
9525 for (j
= 0; j
< cnt
; j
++)
9526 if (xlen
== matches
[j
].len
9527 && ! strncmp (switches
[i
].part1
, matches
[j
].str
, xlen
))
9529 mswitches
[n_mswitches
].str
= matches
[j
].replace
;
9530 mswitches
[n_mswitches
].len
= matches
[j
].rep_len
;
9531 mswitches
[n_mswitches
].replace
= (char *) 0;
9532 mswitches
[n_mswitches
].rep_len
= 0;
9538 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
9539 on the command line nor any options mutually incompatible with
9541 for (i
= 0; i
< n_mdswitches
; i
++)
9545 for (q
= multilib_options
; *q
!= '\0'; *q
&& q
++)
9551 while (strncmp (q
, mdswitches
[i
].str
, mdswitches
[i
].len
) != 0
9552 || strchr (" /", q
[mdswitches
[i
].len
]) == NULL
)
9554 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
9561 if (*q
!= ' ' && *q
!= '\0')
9563 while (*r
!= ' ' && *r
!= '\0')
9566 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
9569 if (used_arg (r
, q
- r
))
9574 mswitches
[n_mswitches
].str
= mdswitches
[i
].str
;
9575 mswitches
[n_mswitches
].len
= mdswitches
[i
].len
;
9576 mswitches
[n_mswitches
].replace
= (char *) 0;
9577 mswitches
[n_mswitches
].rep_len
= 0;
9590 for (i
= 0; i
< n_mswitches
; i
++)
9591 if (len
== mswitches
[i
].len
&& ! strncmp (p
, mswitches
[i
].str
, len
))
9597 void used_arg_t::finalize ()
9599 XDELETEVEC (mswitches
);
9606 default_arg (const char *p
, int len
)
9610 for (i
= 0; i
< n_mdswitches
; i
++)
9611 if (len
== mdswitches
[i
].len
&& ! strncmp (p
, mdswitches
[i
].str
, len
))
9617 /* Work out the subdirectory to use based on the options. The format of
9618 multilib_select is a list of elements. Each element is a subdirectory
9619 name followed by a list of options followed by a semicolon. The format
9620 of multilib_exclusions is the same, but without the preceding
9621 directory. First gcc will check the exclusions, if none of the options
9622 beginning with an exclamation point are present, and all of the other
9623 options are present, then we will ignore this completely. Passing
9624 that, gcc will consider each multilib_select in turn using the same
9625 rules for matching the options. If a match is found, that subdirectory
9627 A subdirectory name is optionally followed by a colon and the corresponding
9631 set_multilib_dir (void)
9634 unsigned int this_path_len
;
9635 const char *this_path
, *this_arg
;
9636 const char *start
, *end
;
9638 int ok
, ndfltok
, first
;
9641 start
= multilib_defaults
;
9642 while (*start
== ' ' || *start
== '\t')
9644 while (*start
!= '\0')
9647 while (*start
!= ' ' && *start
!= '\t' && *start
!= '\0')
9649 while (*start
== ' ' || *start
== '\t')
9657 mdswitches
= XNEWVEC (struct mdswitchstr
, n_mdswitches
);
9658 for (start
= multilib_defaults
; *start
!= '\0'; start
= end
+ 1)
9660 while (*start
== ' ' || *start
== '\t')
9666 for (end
= start
+ 1;
9667 *end
!= ' ' && *end
!= '\t' && *end
!= '\0'; end
++)
9670 obstack_grow (&multilib_obstack
, start
, end
- start
);
9671 obstack_1grow (&multilib_obstack
, 0);
9672 mdswitches
[i
].str
= XOBFINISH (&multilib_obstack
, const char *);
9673 mdswitches
[i
++].len
= end
- start
;
9680 p
= multilib_exclusions
;
9683 /* Ignore newlines. */
9690 /* Check the arguments. */
9697 fatal_error (input_location
, "multilib exclusions %qs is invalid",
9698 multilib_exclusions
);
9708 while (*p
!= ' ' && *p
!= ';')
9711 goto invalid_exclusions
;
9715 if (*this_arg
!= '!')
9723 ok
= used_arg (this_arg
, p
- this_arg
);
9738 p
= multilib_select
;
9740 /* Append multilib reuse rules if any. With those rules, we can reuse
9741 one multilib for certain different options sets. */
9742 if (strlen (multilib_reuse
) > 0)
9743 p
= concat (p
, multilib_reuse
, NULL
);
9747 /* Ignore newlines. */
9754 /* Get the initial path. */
9761 fatal_error (input_location
, "multilib select %qs %qs is invalid",
9762 multilib_select
, multilib_reuse
);
9766 this_path_len
= p
- this_path
;
9768 /* Check the arguments. */
9775 goto invalid_select
;
9784 while (*p
!= ' ' && *p
!= ';')
9787 goto invalid_select
;
9791 if (*this_arg
!= '!')
9799 /* If this is a default argument, we can just ignore it.
9800 This is true even if this_arg begins with '!'. Beginning
9801 with '!' does not mean that this argument is necessarily
9802 inappropriate for this library: it merely means that
9803 there is a more specific library which uses this
9804 argument. If this argument is a default, we need not
9805 consider that more specific library. */
9806 ok
= used_arg (this_arg
, p
- this_arg
);
9813 if (default_arg (this_arg
, p
- this_arg
))
9822 if (this_path_len
!= 1
9823 || this_path
[0] != '.')
9825 char *new_multilib_dir
= XNEWVEC (char, this_path_len
+ 1);
9828 strncpy (new_multilib_dir
, this_path
, this_path_len
);
9829 new_multilib_dir
[this_path_len
] = '\0';
9830 q
= strchr (new_multilib_dir
, ':');
9833 multilib_dir
= new_multilib_dir
;
9840 const char *q
= this_path
, *end
= this_path
+ this_path_len
;
9842 while (q
< end
&& *q
!= ':')
9846 const char *q2
= q
+ 1, *ml_end
= end
;
9847 char *new_multilib_os_dir
;
9849 while (q2
< end
&& *q2
!= ':')
9853 if (ml_end
- q
== 1)
9854 multilib_os_dir
= xstrdup (".");
9857 new_multilib_os_dir
= XNEWVEC (char, ml_end
- q
);
9858 memcpy (new_multilib_os_dir
, q
+ 1, ml_end
- q
- 1);
9859 new_multilib_os_dir
[ml_end
- q
- 1] = '\0';
9860 multilib_os_dir
= new_multilib_os_dir
;
9863 if (q2
< end
&& *q2
== ':')
9865 char *new_multiarch_dir
= XNEWVEC (char, end
- q2
);
9866 memcpy (new_multiarch_dir
, q2
+ 1, end
- q2
- 1);
9867 new_multiarch_dir
[end
- q2
- 1] = '\0';
9868 multiarch_dir
= new_multiarch_dir
;
9877 if (multilib_dir
== NULL
&& multilib_os_dir
!= NULL
9878 && strcmp (multilib_os_dir
, ".") == 0)
9880 free (CONST_CAST (char *, multilib_os_dir
));
9881 multilib_os_dir
= NULL
;
9883 else if (multilib_dir
!= NULL
&& multilib_os_dir
== NULL
)
9884 multilib_os_dir
= multilib_dir
;
9887 /* Print out the multiple library subdirectory selection
9888 information. This prints out a series of lines. Each line looks
9889 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
9890 required. Only the desired options are printed out, the negative
9891 matches. The options are print without a leading dash. There are
9892 no spaces to make it easy to use the information in the shell.
9893 Each subdirectory is printed only once. This assumes the ordering
9894 generated by the genmultilib script. Also, we leave out ones that match
9898 print_multilib_info (void)
9900 const char *p
= multilib_select
;
9901 const char *last_path
= 0, *this_path
;
9904 unsigned int last_path_len
= 0;
9909 /* Ignore newlines. */
9916 /* Get the initial path. */
9923 fatal_error (input_location
,
9924 "multilib select %qs is invalid", multilib_select
);
9930 /* When --disable-multilib was used but target defines
9931 MULTILIB_OSDIRNAMES, entries starting with .: (and not starting
9932 with .:: for multiarch configurations) are there just to find
9933 multilib_os_dir, so skip them from output. */
9934 if (this_path
[0] == '.' && this_path
[1] == ':' && this_path
[2] != ':')
9937 /* Check for matches with the multilib_exclusions. We don't bother
9938 with the '!' in either list. If any of the exclusion rules match
9939 all of its options with the select rule, we skip it. */
9941 const char *e
= multilib_exclusions
;
9942 const char *this_arg
;
9947 /* Ignore newlines. */
9954 /* Check the arguments. */
9963 fatal_error (input_location
,
9964 "multilib exclusion %qs is invalid",
9965 multilib_exclusions
);
9976 while (*e
!= ' ' && *e
!= ';')
9979 goto invalid_exclusion
;
9987 int len
= e
- this_arg
;
9990 goto invalid_select
;
9994 while (*q
!= ' ' && *q
!= ';')
9997 goto invalid_select
;
10001 if (! strncmp (arg
, this_arg
,
10002 (len
< q
- arg
) ? q
- arg
: len
)
10003 || default_arg (this_arg
, e
- this_arg
))
10033 /* If this is a duplicate, skip it. */
10034 skip
= (last_path
!= 0
10035 && (unsigned int) (p
- this_path
) == last_path_len
10036 && ! filename_ncmp (last_path
, this_path
, last_path_len
));
10038 last_path
= this_path
;
10039 last_path_len
= p
- this_path
;
10042 /* If all required arguments are default arguments, and no default
10043 arguments appear in the ! argument list, then we can skip it.
10044 We will already have printed a directory identical to this one
10045 which does not require that default argument. */
10049 bool default_arg_ok
= false;
10057 goto invalid_select
;
10068 while (*q
!= ' ' && *q
!= ';')
10071 goto invalid_select
;
10075 if (default_arg (arg
, q
- arg
))
10077 /* Stop checking if any default arguments appeared in not
10081 default_arg_ok
= false;
10085 default_arg_ok
= true;
10089 /* Stop checking if any required argument is not provided by
10090 default arguments. */
10091 default_arg_ok
= false;
10099 /* Make sure all default argument is OK for this multi-lib set. */
10100 if (default_arg_ok
)
10110 for (p1
= last_path
; p1
< p
&& *p1
!= ':'; p1
++)
10121 goto invalid_select
;
10129 use_arg
= *p
!= '!';
10134 while (*p
!= ' ' && *p
!= ';')
10137 goto invalid_select
;
10149 /* If there are extra options, print them now. */
10150 if (multilib_extra
&& *multilib_extra
)
10152 int print_at
= TRUE
;
10155 for (q
= multilib_extra
; *q
!= '\0'; q
++)
10176 /* getenv built-in spec function.
10178 Returns the value of the environment variable given by its first argument,
10179 concatenated with the second argument. If the variable is not defined, a
10180 fatal error is issued unless such undefs are internally allowed, in which
10181 case the variable name prefixed by a '/' is used as the variable value.
10183 The leading '/' allows using the result at a spot where a full path would
10184 normally be expected and when the actual value doesn't really matter since
10185 undef vars are allowed. */
10187 static const char *
10188 getenv_spec_function (int argc
, const char **argv
)
10191 const char *varname
;
10201 value
= env
.get (varname
);
10203 /* If the variable isn't defined and this is allowed, craft our expected
10204 return value. Assume variable names used in specs strings don't contain
10205 any active spec character so don't need escaping. */
10206 if (!value
&& spec_undefvar_allowed
)
10208 result
= XNEWVAR (char, strlen(varname
) + 2);
10209 sprintf (result
, "/%s", varname
);
10214 fatal_error (input_location
,
10215 "environment variable %qs not defined", varname
);
10217 /* We have to escape every character of the environment variable so
10218 they are not interpreted as active spec characters. A
10219 particularly painful case is when we are reading a variable
10220 holding a windows path complete with \ separators. */
10221 len
= strlen (value
) * 2 + strlen (argv
[1]) + 1;
10222 result
= XNEWVAR (char, len
);
10223 for (ptr
= result
; *value
; ptr
+= 2)
10229 strcpy (ptr
, argv
[1]);
10234 /* if-exists built-in spec function.
10236 Checks to see if the file specified by the absolute pathname in
10237 ARGS exists. Returns that pathname if found.
10239 The usual use for this function is to check for a library file
10240 (whose name has been expanded with %s). */
10242 static const char *
10243 if_exists_spec_function (int argc
, const char **argv
)
10245 /* Must have only one argument. */
10246 if (argc
== 1 && IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
10252 /* if-exists-else built-in spec function.
10254 This is like if-exists, but takes an additional argument which
10255 is returned if the first argument does not exist. */
10257 static const char *
10258 if_exists_else_spec_function (int argc
, const char **argv
)
10260 /* Must have exactly two arguments. */
10264 if (IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
10270 /* if-exists-then-else built-in spec function.
10272 Checks to see if the file specified by the absolute pathname in
10273 the first arg exists. Returns the second arg if so, otherwise returns
10274 the third arg if it is present. */
10276 static const char *
10277 if_exists_then_else_spec_function (int argc
, const char **argv
)
10280 /* Must have two or three arguments. */
10281 if (argc
!= 2 && argc
!= 3)
10284 if (IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
10293 /* sanitize built-in spec function.
10295 This returns non-NULL, if sanitizing address, thread or
10296 any of the undefined behavior sanitizers. */
10298 static const char *
10299 sanitize_spec_function (int argc
, const char **argv
)
10304 if (strcmp (argv
[0], "address") == 0)
10305 return (flag_sanitize
& SANITIZE_USER_ADDRESS
) ? "" : NULL
;
10306 if (strcmp (argv
[0], "hwaddress") == 0)
10307 return (flag_sanitize
& SANITIZE_USER_HWADDRESS
) ? "" : NULL
;
10308 if (strcmp (argv
[0], "kernel-address") == 0)
10309 return (flag_sanitize
& SANITIZE_KERNEL_ADDRESS
) ? "" : NULL
;
10310 if (strcmp (argv
[0], "kernel-hwaddress") == 0)
10311 return (flag_sanitize
& SANITIZE_KERNEL_HWADDRESS
) ? "" : NULL
;
10312 if (strcmp (argv
[0], "thread") == 0)
10313 return (flag_sanitize
& SANITIZE_THREAD
) ? "" : NULL
;
10314 if (strcmp (argv
[0], "undefined") == 0)
10315 return ((flag_sanitize
10316 & (SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
))
10317 && !flag_sanitize_undefined_trap_on_error
) ? "" : NULL
;
10318 if (strcmp (argv
[0], "leak") == 0)
10319 return ((flag_sanitize
10320 & (SANITIZE_ADDRESS
| SANITIZE_LEAK
| SANITIZE_THREAD
))
10321 == SANITIZE_LEAK
) ? "" : NULL
;
10325 /* replace-outfile built-in spec function.
10327 This looks for the first argument in the outfiles array's name and
10328 replaces it with the second argument. */
10330 static const char *
10331 replace_outfile_spec_function (int argc
, const char **argv
)
10334 /* Must have exactly two arguments. */
10338 for (i
= 0; i
< n_infiles
; i
++)
10340 if (outfiles
[i
] && !filename_cmp (outfiles
[i
], argv
[0]))
10341 outfiles
[i
] = xstrdup (argv
[1]);
10346 /* remove-outfile built-in spec function.
10348 * This looks for the first argument in the outfiles array's name and
10351 static const char *
10352 remove_outfile_spec_function (int argc
, const char **argv
)
10355 /* Must have exactly one argument. */
10359 for (i
= 0; i
< n_infiles
; i
++)
10361 if (outfiles
[i
] && !filename_cmp (outfiles
[i
], argv
[0]))
10362 outfiles
[i
] = NULL
;
10367 /* Given two version numbers, compares the two numbers.
10368 A version number must match the regular expression
10369 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
10372 compare_version_strings (const char *v1
, const char *v2
)
10377 if (regcomp (&r
, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
10378 REG_EXTENDED
| REG_NOSUB
) != 0)
10380 rresult
= regexec (&r
, v1
, 0, NULL
, 0);
10381 if (rresult
== REG_NOMATCH
)
10382 fatal_error (input_location
, "invalid version number %qs", v1
);
10383 else if (rresult
!= 0)
10385 rresult
= regexec (&r
, v2
, 0, NULL
, 0);
10386 if (rresult
== REG_NOMATCH
)
10387 fatal_error (input_location
, "invalid version number %qs", v2
);
10388 else if (rresult
!= 0)
10391 return strverscmp (v1
, v2
);
10395 /* version_compare built-in spec function.
10397 This takes an argument of the following form:
10399 <comparison-op> <arg1> [<arg2>] <switch> <result>
10401 and produces "result" if the comparison evaluates to true,
10402 and nothing if it doesn't.
10404 The supported <comparison-op> values are:
10406 >= true if switch is a later (or same) version than arg1
10408 < true if switch is an earlier version than arg1
10410 >< true if switch is arg1 or later, and earlier than arg2
10411 <> true if switch is earlier than arg1 or is arg2 or later
10413 If the switch is not present, the condition is false unless
10414 the first character of the <comparison-op> is '!'.
10417 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
10418 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
10420 static const char *
10421 version_compare_spec_function (int argc
, const char **argv
)
10425 const char *switch_value
= NULL
;
10430 fatal_error (input_location
, "too few arguments to %%:version-compare");
10431 if (argv
[0][0] == '\0')
10433 if ((argv
[0][1] == '<' || argv
[0][1] == '>') && argv
[0][0] != '!')
10435 if (argc
!= nargs
+ 3)
10436 fatal_error (input_location
, "too many arguments to %%:version-compare");
10438 switch_len
= strlen (argv
[nargs
+ 1]);
10439 for (i
= 0; i
< n_switches
; i
++)
10440 if (!strncmp (switches
[i
].part1
, argv
[nargs
+ 1], switch_len
)
10441 && check_live_switch (i
, switch_len
))
10442 switch_value
= switches
[i
].part1
+ switch_len
;
10444 if (switch_value
== NULL
)
10445 comp1
= comp2
= -1;
10448 comp1
= compare_version_strings (switch_value
, argv
[1]);
10450 comp2
= compare_version_strings (switch_value
, argv
[2]);
10452 comp2
= -1; /* This value unused. */
10455 switch (argv
[0][0] << 8 | argv
[0][1])
10457 case '>' << 8 | '=':
10458 result
= comp1
>= 0;
10460 case '!' << 8 | '<':
10461 result
= comp1
>= 0 || switch_value
== NULL
;
10464 result
= comp1
< 0;
10466 case '!' << 8 | '>':
10467 result
= comp1
< 0 || switch_value
== NULL
;
10469 case '>' << 8 | '<':
10470 result
= comp1
>= 0 && comp2
< 0;
10472 case '<' << 8 | '>':
10473 result
= comp1
< 0 || comp2
>= 0;
10477 fatal_error (input_location
,
10478 "unknown operator %qs in %%:version-compare", argv
[0]);
10483 return argv
[nargs
+ 2];
10486 /* %:include builtin spec function. This differs from %include in that it
10487 can be nested inside a spec, and thus be conditionalized. It takes
10488 one argument, the filename, and looks for it in the startfile path.
10489 The result is always NULL, i.e. an empty expansion. */
10491 static const char *
10492 include_spec_function (int argc
, const char **argv
)
10499 file
= find_a_file (&startfile_prefixes
, argv
[0], R_OK
, true);
10500 read_specs (file
? file
: argv
[0], false, false);
10505 /* %:find-file spec function. This function replaces its argument by
10506 the file found through find_file, that is the -print-file-name gcc
10508 static const char *
10509 find_file_spec_function (int argc
, const char **argv
)
10516 file
= find_file (argv
[0]);
10521 /* %:find-plugindir spec function. This function replaces its argument
10522 by the -iplugindir=<dir> option. `dir' is found through find_file, that
10523 is the -print-file-name gcc program option. */
10524 static const char *
10525 find_plugindir_spec_function (int argc
, const char **argv ATTRIBUTE_UNUSED
)
10527 const char *option
;
10532 option
= concat ("-iplugindir=", find_file ("plugin"), NULL
);
10537 /* %:print-asm-header spec function. Print a banner to say that the
10538 following output is from the assembler. */
10540 static const char *
10541 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED
,
10542 const char **argv ATTRIBUTE_UNUSED
)
10544 printf (_("Assembler options\n=================\n\n"));
10545 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
10550 /* Get a random number for -frandom-seed */
10552 static unsigned HOST_WIDE_INT
10553 get_random_number (void)
10555 unsigned HOST_WIDE_INT ret
= 0;
10558 fd
= open ("/dev/urandom", O_RDONLY
);
10561 read (fd
, &ret
, sizeof (HOST_WIDE_INT
));
10567 /* Get some more or less random data. */
10568 #ifdef HAVE_GETTIMEOFDAY
10572 gettimeofday (&tv
, NULL
);
10573 ret
= tv
.tv_sec
* 1000 + tv
.tv_usec
/ 1000;
10577 time_t now
= time (NULL
);
10579 if (now
!= (time_t)-1)
10580 ret
= (unsigned) now
;
10584 return ret
^ getpid ();
10587 /* %:compare-debug-dump-opt spec function. Save the last argument,
10588 expected to be the last -fdump-final-insns option, or generate a
10591 static const char *
10592 compare_debug_dump_opt_spec_function (int arg
,
10593 const char **argv ATTRIBUTE_UNUSED
)
10598 static char random_seed
[HOST_BITS_PER_WIDE_INT
/ 4 + 3];
10601 fatal_error (input_location
,
10602 "too many arguments to %%:compare-debug-dump-opt");
10604 do_spec_2 ("%{fdump-final-insns=*:%*}", NULL
);
10605 do_spec_1 (" ", 0, NULL
);
10607 if (argbuf
.length () > 0
10608 && strcmp (argv
[argbuf
.length () - 1], ".") != 0)
10610 if (!compare_debug
)
10613 name
= xstrdup (argv
[argbuf
.length () - 1]);
10618 if (argbuf
.length () > 0)
10619 do_spec_2 ("%B.gkd", NULL
);
10620 else if (!compare_debug
)
10623 do_spec_2 ("%{!save-temps*:%g.gkd}%{save-temps*:%B.gkd}", NULL
);
10625 do_spec_1 (" ", 0, NULL
);
10627 gcc_assert (argbuf
.length () > 0);
10629 name
= xstrdup (argbuf
.last ());
10631 char *arg
= quote_spec (xstrdup (name
));
10632 ret
= concat ("-fdump-final-insns=", arg
, NULL
);
10636 which
= compare_debug
< 0;
10637 debug_check_temp_file
[which
] = name
;
10641 unsigned HOST_WIDE_INT value
= get_random_number ();
10643 sprintf (random_seed
, HOST_WIDE_INT_PRINT_HEX
, value
);
10649 ret
= concat ("%{!frandom-seed=*:-frandom-seed=", random_seed
, "} ",
10660 /* %:compare-debug-self-opt spec function. Expands to the options
10661 that are to be passed in the second compilation of
10664 static const char *
10665 compare_debug_self_opt_spec_function (int arg
,
10666 const char **argv ATTRIBUTE_UNUSED
)
10669 fatal_error (input_location
,
10670 "too many arguments to %%:compare-debug-self-opt");
10672 if (compare_debug
>= 0)
10676 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
10677 %<fdump-final-insns=* -w -S -o %j \
10678 %{!fcompare-debug-second:-fcompare-debug-second} \
10679 ", compare_debug_opt
, NULL
);
10682 /* %:pass-through-libs spec function. Finds all -l options and input
10683 file names in the lib spec passed to it, and makes a list of them
10684 prepended with the plugin option to cause them to be passed through
10685 to the final link after all the new object files have been added. */
10688 pass_through_libs_spec_func (int argc
, const char **argv
)
10690 char *prepended
= xstrdup (" ");
10692 /* Shlemiel the painter's algorithm. Innately horrible, but at least
10693 we know that there will never be more than a handful of strings to
10694 concat, and it's only once per run, so it's not worth optimising. */
10695 for (n
= 0; n
< argc
; n
++)
10697 char *old
= prepended
;
10698 /* Anything that isn't an option is a full path to an output
10699 file; pass it through if it ends in '.a'. Among options,
10701 if (argv
[n
][0] == '-' && argv
[n
][1] == 'l')
10703 const char *lopt
= argv
[n
] + 2;
10704 /* Handle both joined and non-joined -l options. If for any
10705 reason there's a trailing -l with no joined or following
10706 arg just discard it. */
10707 if (!*lopt
&& ++n
>= argc
)
10711 prepended
= concat (prepended
, "-plugin-opt=-pass-through=-l",
10714 else if (!strcmp (".a", argv
[n
] + strlen (argv
[n
]) - 2))
10716 prepended
= concat (prepended
, "-plugin-opt=-pass-through=",
10717 argv
[n
], " ", NULL
);
10719 if (prepended
!= old
)
10726 not_actual_file_p (const char *name
)
10728 return (strcmp (name
, "-") == 0
10729 || strcmp (name
, HOST_BIT_BUCKET
) == 0);
10732 /* %:dumps spec function. Take an optional argument that overrides
10733 the default extension for -dumpbase and -dumpbase-ext.
10734 Return -dumpdir, -dumpbase and -dumpbase-ext, if needed. */
10736 dumps_spec_func (int argc
, const char **argv ATTRIBUTE_UNUSED
)
10738 const char *ext
= dumpbase_ext
;
10741 char *args
[3] = { NULL
, NULL
, NULL
};
10744 /* Do not compute a default for -dumpbase-ext when -dumpbase was
10745 given explicitly. */
10746 if (dumpbase
&& *dumpbase
&& !ext
)
10751 /* Do not override the explicitly-specified -dumpbase-ext with
10752 the specs-provided overrider. */
10756 else if (argc
!= 0)
10757 fatal_error (input_location
, "too many arguments for %%:dumps");
10761 p
= quote_spec_arg (xstrdup (dumpdir
));
10762 args
[nargs
++] = concat (" -dumpdir ", p
, NULL
);
10767 ext
= input_basename
+ basename_length
;
10769 /* Use the precomputed outbase, or compute dumpbase from
10770 input_basename, just like %b would. */
10773 if (dumpbase
&& *dumpbase
)
10775 base
= xstrdup (dumpbase
);
10776 p
= base
+ outbase_length
;
10777 gcc_checking_assert (strncmp (base
, outbase
, outbase_length
) == 0);
10778 gcc_checking_assert (strcmp (p
, ext
) == 0);
10780 else if (outbase_length
)
10782 base
= xstrndup (outbase
, outbase_length
);
10787 base
= xstrndup (input_basename
, suffixed_basename_length
);
10788 p
= base
+ basename_length
;
10791 if (compare_debug
< 0 || !p
|| strcmp (p
, ext
) != 0)
10797 if (compare_debug
< 0)
10802 p
= concat (base
, gk
, ext
, NULL
);
10808 base
= quote_spec_arg (base
);
10809 args
[nargs
++] = concat (" -dumpbase ", base
, NULL
);
10814 p
= quote_spec_arg (xstrdup (ext
));
10815 args
[nargs
++] = concat (" -dumpbase-ext ", p
, NULL
);
10819 const char *ret
= concat (args
[0], args
[1], args
[2], NULL
);
10821 free (args
[--nargs
]);
10826 /* Returns "" if ARGV[ARGC - 2] is greater than ARGV[ARGC-1].
10827 Otherwise, return NULL. */
10829 static const char *
10830 greater_than_spec_func (int argc
, const char **argv
)
10837 gcc_assert (argc
>= 2);
10839 long arg
= strtol (argv
[argc
- 2], &converted
, 10);
10840 gcc_assert (converted
!= argv
[argc
- 2]);
10842 long lim
= strtol (argv
[argc
- 1], &converted
, 10);
10843 gcc_assert (converted
!= argv
[argc
- 1]);
10851 /* Returns "" if debug_info_level is greater than ARGV[ARGC-1].
10852 Otherwise, return NULL. */
10854 static const char *
10855 debug_level_greater_than_spec_func (int argc
, const char **argv
)
10860 fatal_error (input_location
,
10861 "wrong number of arguments to %%:debug-level-gt");
10863 long arg
= strtol (argv
[0], &converted
, 10);
10864 gcc_assert (converted
!= argv
[0]);
10866 if (debug_info_level
> arg
)
10872 /* Returns "" if dwarf_version is greater than ARGV[ARGC-1].
10873 Otherwise, return NULL. */
10875 static const char *
10876 dwarf_version_greater_than_spec_func (int argc
, const char **argv
)
10881 fatal_error (input_location
,
10882 "wrong number of arguments to %%:dwarf-version-gt");
10884 long arg
= strtol (argv
[0], &converted
, 10);
10885 gcc_assert (converted
!= argv
[0]);
10887 if (dwarf_version
> arg
)
10894 path_prefix_reset (path_prefix
*prefix
)
10896 struct prefix_list
*iter
, *next
;
10897 iter
= prefix
->plist
;
10901 free (const_cast <char *> (iter
->prefix
));
10906 prefix
->max_len
= 0;
10909 /* The function takes 3 arguments: OPTION name, file name and location
10910 where we search for Fortran modules.
10911 When the FILE is found by find_file, return OPTION=path_to_file. */
10913 static const char *
10914 find_fortran_preinclude_file (int argc
, const char **argv
)
10916 char *result
= NULL
;
10920 struct path_prefix prefixes
= { 0, 0, "preinclude" };
10922 /* Search first for 'finclude' folder location for a header file
10923 installed by the compiler (similar to omp_lib.h). */
10924 add_prefix (&prefixes
, argv
[2], NULL
, 0, 0, 0);
10925 #ifdef TOOL_INCLUDE_DIR
10926 /* Then search: <prefix>/<target>/<include>/finclude */
10927 add_prefix (&prefixes
, TOOL_INCLUDE_DIR
"/finclude/",
10930 #ifdef NATIVE_SYSTEM_HEADER_DIR
10931 /* Then search: <sysroot>/usr/include/finclude/<multilib> */
10932 add_sysrooted_hdrs_prefix (&prefixes
, NATIVE_SYSTEM_HEADER_DIR
"/finclude/",
10936 const char *path
= find_a_file (&include_prefixes
, argv
[1], R_OK
, false);
10938 result
= concat (argv
[0], path
, NULL
);
10941 path
= find_a_file (&prefixes
, argv
[1], R_OK
, false);
10943 result
= concat (argv
[0], path
, NULL
);
10946 path_prefix_reset (&prefixes
);
10950 /* If any character in ORIG fits QUOTE_P (_, P), reallocate the string
10951 so as to precede every one of them with a backslash. Return the
10952 original string or the reallocated one. */
10954 static inline char *
10955 quote_string (char *orig
, bool (*quote_p
)(char, void *), void *p
)
10957 int len
, number_of_space
= 0;
10959 for (len
= 0; orig
[len
]; len
++)
10960 if (quote_p (orig
[len
], p
))
10963 if (number_of_space
)
10965 char *new_spec
= (char *) xmalloc (len
+ number_of_space
+ 1);
10967 for (j
= 0, k
= 0; j
<= len
; j
++, k
++)
10969 if (quote_p (orig
[j
], p
))
10970 new_spec
[k
++] = '\\';
10971 new_spec
[k
] = orig
[j
];
10980 /* Return true iff C is any of the characters convert_white_space
10984 whitespace_to_convert_p (char c
, void *)
10986 return (c
== ' ' || c
== '\t');
10989 /* Insert backslash before spaces in ORIG (usually a file path), to
10990 avoid being broken by spec parser.
10992 This function is needed as do_spec_1 treats white space (' ' and '\t')
10993 as the end of an argument. But in case of -plugin /usr/gcc install/xxx.so,
10994 the file name should be treated as a single argument rather than being
10995 broken into multiple. Solution is to insert '\\' before the space in a
10998 This function converts and only converts all occurrence of ' '
10999 to '\\' + ' ' and '\t' to '\\' + '\t'. For example:
11001 "a b" -> "a\\ \\ b"
11003 "a\\ b" -> "a\\\\ b"
11005 orig: input null-terminating string that was allocated by xalloc. The
11006 memory it points to might be freed in this function. Behavior undefined
11007 if ORIG wasn't xalloced or was freed already at entry.
11009 Return: ORIG if no conversion needed. Otherwise a newly allocated string
11010 that was converted from ORIG. */
11013 convert_white_space (char *orig
)
11015 return quote_string (orig
, whitespace_to_convert_p
, NULL
);
11018 /* Return true iff C matches any of the spec active characters. */
11020 quote_spec_char_p (char c
, void *)
11037 /* Like convert_white_space, but deactivate all active spec chars by
11040 static inline char *
11041 quote_spec (char *orig
)
11043 return quote_string (orig
, quote_spec_char_p
, NULL
);
11046 /* Like quote_spec, but also turn an empty string into the spec for an
11049 static inline char *
11050 quote_spec_arg (char *orig
)
11055 return xstrdup ("%\"");
11058 return quote_spec (orig
);
11061 /* Restore all state within gcc.cc to the initial state, so that the driver
11062 code can be safely re-run in-process.
11064 Many const char * variables are referenced by static specs (see
11065 INIT_STATIC_SPEC above). These variables are restored to their default
11066 values by a simple loop over the static specs.
11068 For other variables, we directly restore them all to their initial
11069 values (often implicitly 0).
11071 Free the various obstacks in this file, along with "opts_obstack"
11074 This function also restores any environment variables that were changed. */
11077 driver::finalize ()
11080 diagnostic_finish (global_dc
);
11083 at_file_supplied
= 0;
11084 print_help_list
= 0;
11086 verbose_only_flag
= 0;
11087 print_subprocess_help
= 0;
11089 report_times_to_file
= NULL
;
11090 target_system_root
= DEFAULT_TARGET_SYSTEM_ROOT
;
11091 target_system_root_changed
= 0;
11092 target_sysroot_suffix
= 0;
11093 target_sysroot_hdrs_suffix
= 0;
11094 save_temps_flag
= SAVE_TEMPS_NONE
;
11095 save_temps_overrides_dumpdir
= false;
11096 dumpdir_trailing_dash_added
= false;
11099 free (dumpbase_ext
);
11101 dumpdir
= dumpbase
= dumpbase_ext
= outbase
= NULL
;
11102 dumpdir_length
= outbase_length
= 0;
11103 spec_machine
= DEFAULT_TARGET_MACHINE
;
11104 greatest_status
= 1;
11106 obstack_free (&obstack
, NULL
);
11107 obstack_free (&opts_obstack
, NULL
); /* in opts.cc */
11108 obstack_free (&collect_obstack
, NULL
);
11110 link_command_spec
= LINK_COMMAND_SPEC
;
11112 obstack_free (&multilib_obstack
, NULL
);
11114 user_specs_head
= NULL
;
11115 user_specs_tail
= NULL
;
11117 /* Within the "compilers" vec, the fields "suffix" and "spec" were
11118 statically allocated for the default compilers, but dynamically
11119 allocated for additional compilers. Delete them for the latter. */
11120 for (int i
= n_default_compilers
; i
< n_compilers
; i
++)
11122 free (const_cast <char *> (compilers
[i
].suffix
));
11123 free (const_cast <char *> (compilers
[i
].spec
));
11125 XDELETEVEC (compilers
);
11129 linker_options
.truncate (0);
11130 assembler_options
.truncate (0);
11131 preprocessor_options
.truncate (0);
11133 path_prefix_reset (&exec_prefixes
);
11134 path_prefix_reset (&startfile_prefixes
);
11135 path_prefix_reset (&include_prefixes
);
11137 machine_suffix
= 0;
11138 just_machine_suffix
= 0;
11139 gcc_exec_prefix
= 0;
11140 gcc_libexec_prefix
= 0;
11141 set_static_spec_shared (&md_exec_prefix
, MD_EXEC_PREFIX
);
11142 set_static_spec_shared (&md_startfile_prefix
, MD_STARTFILE_PREFIX
);
11143 set_static_spec_shared (&md_startfile_prefix_1
, MD_STARTFILE_PREFIX_1
);
11145 multilib_os_dir
= 0;
11148 /* Free any specs dynamically-allocated by set_spec.
11149 These will be at the head of the list, before the
11150 statically-allocated ones. */
11153 while (specs
!= static_specs
)
11155 spec_list
*next
= specs
->next
;
11156 free (const_cast <char *> (specs
->name
));
11162 for (unsigned i
= 0; i
< ARRAY_SIZE (static_specs
); i
++)
11164 spec_list
*sl
= &static_specs
[i
];
11167 free (const_cast <char *> (*(sl
->ptr_spec
)));
11168 sl
->alloc_p
= false;
11170 *(sl
->ptr_spec
) = sl
->default_ptr
;
11173 extra_specs
= NULL
;
11176 processing_spec_function
= 0;
11184 execution_count
= 0;
11187 temp_filename
= NULL
;
11188 temp_filename_length
= 0;
11189 always_delete_queue
= NULL
;
11190 failure_delete_queue
= NULL
;
11192 XDELETEVEC (switches
);
11195 n_switches_alloc
= 0;
11198 compare_debug_second
= 0;
11199 compare_debug_opt
= NULL
;
11200 for (int i
= 0; i
< 2; i
++)
11202 switches_debug_check
[i
] = NULL
;
11203 n_switches_debug_check
[i
] = 0;
11204 n_switches_alloc_debug_check
[i
] = 0;
11205 debug_check_temp_file
[i
] = NULL
;
11208 XDELETEVEC (infiles
);
11211 n_infiles_alloc
= 0;
11213 combine_inputs
= false;
11214 added_libraries
= 0;
11215 XDELETEVEC (outfiles
);
11218 last_language_n_infiles
= 0;
11219 gcc_input_filename
= NULL
;
11220 input_file_number
= 0;
11221 input_filename_length
= 0;
11222 basename_length
= 0;
11223 suffixed_basename_length
= 0;
11224 input_basename
= NULL
;
11225 input_suffix
= NULL
;
11226 /* We don't need to purge "input_stat", just to unset "input_stat_set". */
11227 input_stat_set
= 0;
11228 input_file_compiler
= NULL
;
11230 delete_this_arg
= 0;
11231 this_is_output_file
= 0;
11232 this_is_library_file
= 0;
11233 this_is_linker_script
= 0;
11234 input_from_pipe
= 0;
11235 suffix_subst
= NULL
;
11240 used_arg
.finalize ();
11244 Targets can provide configure-time default options in
11245 OPTION_DEFAULT_SPECS. The jit needs to access these, but
11246 they are expressed in the spec language.
11248 Run just enough of the driver to be able to expand these
11249 specs, and then call the callback CB on each
11250 such option. The options strings are *without* a leading
11251 '-' character e.g. ("march=x86-64"). Finally, clean up. */
11254 driver_get_configure_time_options (void (*cb
) (const char *option
,
11260 obstack_init (&obstack
);
11261 init_opts_obstack ();
11264 for (i
= 0; i
< ARRAY_SIZE (option_default_specs
); i
++)
11265 do_option_spec (option_default_specs
[i
].name
,
11266 option_default_specs
[i
].spec
);
11268 for (i
= 0; (int) i
< n_switches
; i
++)
11270 gcc_assert (switches
[i
].part1
);
11271 (*cb
) (switches
[i
].part1
, user_data
);
11274 obstack_free (&opts_obstack
, NULL
);
11275 obstack_free (&obstack
, NULL
);