1 /* Compiler driver program that can handle many languages.
2 Copyright (C) 1987-2021 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.c 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.\n"), stdout
);
3762 fputs (_(" --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...].\n"), stdout
);
3763 fputs (_(" Display specific types of command line options.\n"), stdout
);
3765 fputs (_(" (Use '-v --help' to display command line options of sub-processes).\n"), stdout
);
3766 fputs (_(" --version Display compiler version information.\n"), stdout
);
3767 fputs (_(" -dumpspecs Display all of the built in spec strings.\n"), stdout
);
3768 fputs (_(" -dumpversion Display the version of the compiler.\n"), stdout
);
3769 fputs (_(" -dumpmachine Display the compiler's target processor.\n"), stdout
);
3770 fputs (_(" -foffload=<targets> Specify offloading targets.\n"), stdout
);
3771 fputs (_(" -print-search-dirs Display the directories in the compiler's search path.\n"), stdout
);
3772 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library.\n"), stdout
);
3773 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>.\n"), stdout
);
3774 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>.\n"), stdout
);
3776 -print-multiarch Display the target's normalized GNU triplet, used as\n\
3777 a component in the library path.\n"), stdout
);
3778 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc.\n"), stdout
);
3780 -print-multi-lib Display the mapping between command line options and\n\
3781 multiple library search directories.\n"), stdout
);
3782 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries.\n"), stdout
);
3783 fputs (_(" -print-sysroot Display the target libraries directory.\n"), stdout
);
3784 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers.\n"), stdout
);
3785 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler.\n"), stdout
);
3786 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor.\n"), stdout
);
3787 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker.\n"), stdout
);
3788 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler.\n"), stdout
);
3789 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor.\n"), stdout
);
3790 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker.\n"), stdout
);
3791 fputs (_(" -save-temps Do not delete intermediate files.\n"), stdout
);
3792 fputs (_(" -save-temps=<arg> Do not delete intermediate files.\n"), stdout
);
3794 -no-canonical-prefixes Do not canonicalize paths when building relative\n\
3795 prefixes to other gcc components.\n"), stdout
);
3796 fputs (_(" -pipe Use pipes rather than intermediate files.\n"), stdout
);
3797 fputs (_(" -time Time the execution of each subprocess.\n"), stdout
);
3798 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>.\n"), stdout
);
3799 fputs (_(" -std=<standard> Assume that the input sources are for <standard>.\n"), stdout
);
3801 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3802 and libraries.\n"), stdout
);
3803 fputs (_(" -B <directory> Add <directory> to the compiler's search paths.\n"), stdout
);
3804 fputs (_(" -v Display the programs invoked by the compiler.\n"), stdout
);
3805 fputs (_(" -### Like -v but options quoted and commands not executed.\n"), stdout
);
3806 fputs (_(" -E Preprocess only; do not compile, assemble or link.\n"), stdout
);
3807 fputs (_(" -S Compile only; do not assemble or link.\n"), stdout
);
3808 fputs (_(" -c Compile and assemble, but do not link.\n"), stdout
);
3809 fputs (_(" -o <file> Place the output into <file>.\n"), stdout
);
3810 fputs (_(" -pie Create a dynamically linked position independent\n\
3811 executable.\n"), stdout
);
3812 fputs (_(" -shared Create a shared library.\n"), stdout
);
3814 -x <language> Specify the language of the following input files.\n\
3815 Permissible languages include: c c++ assembler none\n\
3816 'none' means revert to the default behavior of\n\
3817 guessing the language based on the file's extension.\n\
3821 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3822 passed on to the various sub-processes invoked by %s. In order to pass\n\
3823 other options on to these processes the -W<letter> options must be used.\n\
3826 /* The rest of the options are displayed by invocations of the various
3831 add_preprocessor_option (const char *option
, int len
)
3833 preprocessor_options
.safe_push (save_string (option
, len
));
3837 add_assembler_option (const char *option
, int len
)
3839 assembler_options
.safe_push (save_string (option
, len
));
3843 add_linker_option (const char *option
, int len
)
3845 linker_options
.safe_push (save_string (option
, len
));
3848 /* Allocate space for an input file in infiles. */
3853 if (n_infiles_alloc
== 0)
3855 n_infiles_alloc
= 16;
3856 infiles
= XNEWVEC (struct infile
, n_infiles_alloc
);
3858 else if (n_infiles_alloc
== n_infiles
)
3860 n_infiles_alloc
*= 2;
3861 infiles
= XRESIZEVEC (struct infile
, infiles
, n_infiles_alloc
);
3865 /* Store an input file with the given NAME and LANGUAGE in
3869 add_infile (const char *name
, const char *language
)
3872 infiles
[n_infiles
].name
= name
;
3873 infiles
[n_infiles
++].language
= language
;
3876 /* Allocate space for a switch in switches. */
3881 if (n_switches_alloc
== 0)
3883 n_switches_alloc
= 16;
3884 switches
= XNEWVEC (struct switchstr
, n_switches_alloc
);
3886 else if (n_switches_alloc
== n_switches
)
3888 n_switches_alloc
*= 2;
3889 switches
= XRESIZEVEC (struct switchstr
, switches
, n_switches_alloc
);
3893 /* Save an option OPT with N_ARGS arguments in array ARGS, marking it
3894 as validated if VALIDATED and KNOWN if it is an internal switch. */
3897 save_switch (const char *opt
, size_t n_args
, const char *const *args
,
3898 bool validated
, bool known
)
3901 switches
[n_switches
].part1
= opt
+ 1;
3903 switches
[n_switches
].args
= 0;
3906 switches
[n_switches
].args
= XNEWVEC (const char *, n_args
+ 1);
3907 memcpy (switches
[n_switches
].args
, args
, n_args
* sizeof (const char *));
3908 switches
[n_switches
].args
[n_args
] = NULL
;
3911 switches
[n_switches
].live_cond
= 0;
3912 switches
[n_switches
].validated
= validated
;
3913 switches
[n_switches
].known
= known
;
3914 switches
[n_switches
].ordering
= 0;
3918 /* Set the SOURCE_DATE_EPOCH environment variable to the current time if it is
3922 set_source_date_epoch_envvar ()
3924 /* Array size is 21 = ceil(log_10(2^64)) + 1 to hold string representations
3925 of 64 bit integers. */
3926 char source_date_epoch
[21];
3931 if (tt
< (time_t) 0 || errno
!= 0)
3934 snprintf (source_date_epoch
, 21, "%llu", (unsigned long long) tt
);
3935 /* Using setenv instead of xputenv because we want the variable to remain
3936 after finalizing so that it's still set in the second run when using
3938 setenv ("SOURCE_DATE_EPOCH", source_date_epoch
, 0);
3941 /* Handle an option DECODED that is unknown to the option-processing
3945 driver_unknown_option_callback (const struct cl_decoded_option
*decoded
)
3947 const char *opt
= decoded
->arg
;
3948 if (opt
[1] == 'W' && opt
[2] == 'n' && opt
[3] == 'o' && opt
[4] == '-'
3949 && !(decoded
->errors
& CL_ERR_NEGATIVE
))
3951 /* Leave unknown -Wno-* options for the compiler proper, to be
3952 diagnosed only if there are warnings. */
3953 save_switch (decoded
->canonical_option
[0],
3954 decoded
->canonical_option_num_elements
- 1,
3955 &decoded
->canonical_option
[1], false, true);
3958 if (decoded
->opt_index
== OPT_SPECIAL_unknown
)
3960 /* Give it a chance to define it a spec file. */
3961 save_switch (decoded
->canonical_option
[0],
3962 decoded
->canonical_option_num_elements
- 1,
3963 &decoded
->canonical_option
[1], false, false);
3970 /* Handle an option DECODED that is not marked as CL_DRIVER.
3971 LANG_MASK will always be CL_DRIVER. */
3974 driver_wrong_lang_callback (const struct cl_decoded_option
*decoded
,
3975 unsigned int lang_mask ATTRIBUTE_UNUSED
)
3977 /* At this point, non-driver options are accepted (and expected to
3978 be passed down by specs) unless marked to be rejected by the
3979 driver. Options to be rejected by the driver but accepted by the
3980 compilers proper are treated just like completely unknown
3982 const struct cl_option
*option
= &cl_options
[decoded
->opt_index
];
3984 if (option
->cl_reject_driver
)
3985 error ("unrecognized command-line option %qs",
3986 decoded
->orig_option_with_args_text
);
3988 save_switch (decoded
->canonical_option
[0],
3989 decoded
->canonical_option_num_elements
- 1,
3990 &decoded
->canonical_option
[1], false, true);
3993 static const char *spec_lang
= 0;
3994 static int last_language_n_infiles
;
3997 /* Check that GCC is configured to support the offload target. */
4000 check_offload_target_name (const char *target
, ptrdiff_t len
)
4002 const char *n
, *c
= OFFLOAD_TARGETS
;
4005 n
= strchr (c
, ',');
4007 n
= strchr (c
, '\0');
4008 if (len
== n
- c
&& strncmp (target
, c
, n
- c
) == 0)
4010 c
= *n
? n
+ 1 : NULL
;
4014 auto_vec
<const char*> candidates
;
4015 size_t olen
= strlen (OFFLOAD_TARGETS
) + 1;
4016 char *cand
= XALLOCAVEC (char, olen
);
4017 memcpy (cand
, OFFLOAD_TARGETS
, olen
);
4018 for (c
= strtok (cand
, ","); c
; c
= strtok (NULL
, ","))
4019 candidates
.safe_push (c
);
4021 char *target2
= XALLOCAVEC (char, len
+ 1);
4022 memcpy (target2
, target
, len
);
4023 target2
[len
] = '\0';
4025 error ("GCC is not configured to support %qs as offload target", target2
);
4027 if (candidates
.is_empty ())
4028 inform (UNKNOWN_LOCATION
, "no offloading targets configured");
4032 const char *hint
= candidates_list_and_hint (target2
, s
, candidates
);
4034 inform (UNKNOWN_LOCATION
,
4035 "valid offload targets are: %s; did you mean %qs?", s
, hint
);
4037 inform (UNKNOWN_LOCATION
, "valid offload targets 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_fcompare_debug_second
:
4287 compare_debug_second
= 1;
4290 case OPT_fcompare_debug
:
4294 compare_debug_replacement_opt
= "-fcompare-debug=";
4296 goto compare_debug_with_arg
;
4299 compare_debug_replacement_opt
= "-fcompare-debug=-gtoggle";
4301 goto compare_debug_with_arg
;
4308 case OPT_fcompare_debug_
:
4309 compare_debug_replacement_opt
= decoded
->canonical_option
[0];
4310 compare_debug_with_arg
:
4311 gcc_assert (decoded
->canonical_option_num_elements
== 1);
4312 gcc_assert (arg
!= NULL
);
4317 if (compare_debug
< 0)
4318 compare_debug_opt
= NULL
;
4320 compare_debug_opt
= arg
;
4321 save_switch (compare_debug_replacement_opt
, 0, NULL
, validated
, true);
4322 set_source_date_epoch_envvar ();
4325 case OPT_fdiagnostics_color_
:
4326 diagnostic_color_init (dc
, value
);
4329 case OPT_fdiagnostics_urls_
:
4330 diagnostic_urls_init (dc
, value
);
4333 case OPT_fdiagnostics_format_
:
4334 diagnostic_output_format_init (dc
,
4335 (enum diagnostics_output_format
)value
);
4341 /* Pass the rest of this option to the assembler. */
4343 /* Split the argument at commas. */
4345 for (j
= 0; arg
[j
]; j
++)
4348 add_assembler_option (arg
+ prev
, j
- prev
);
4352 /* Record the part after the last comma. */
4353 add_assembler_option (arg
+ prev
, j
- prev
);
4361 /* Pass the rest of this option to the preprocessor. */
4363 /* Split the argument at commas. */
4365 for (j
= 0; arg
[j
]; j
++)
4368 add_preprocessor_option (arg
+ prev
, j
- prev
);
4372 /* Record the part after the last comma. */
4373 add_preprocessor_option (arg
+ prev
, j
- prev
);
4381 /* Split the argument at commas. */
4383 for (j
= 0; arg
[j
]; j
++)
4386 add_infile (save_string (arg
+ prev
, j
- prev
), "*");
4389 /* Record the part after the last comma. */
4390 add_infile (arg
+ prev
, "*");
4396 add_infile (arg
, "*");
4400 case OPT_Xpreprocessor
:
4401 add_preprocessor_option (arg
, strlen (arg
));
4405 case OPT_Xassembler
:
4406 add_assembler_option (arg
, strlen (arg
));
4411 /* POSIX allows separation of -l and the lib arg; canonicalize
4412 by concatenating -l with its arg */
4413 add_infile (concat ("-l", arg
, NULL
), "*");
4418 /* Similarly, canonicalize -L for linkers that may not accept
4419 separate arguments. */
4420 save_switch (concat ("-L", arg
, NULL
), 0, NULL
, validated
, true);
4425 save_switch (concat ("-F", arg
, NULL
), 0, NULL
, validated
, true);
4428 case OPT_save_temps
:
4429 if (!save_temps_flag
)
4430 save_temps_flag
= SAVE_TEMPS_DUMP
;
4434 case OPT_save_temps_
:
4435 if (strcmp (arg
, "cwd") == 0)
4436 save_temps_flag
= SAVE_TEMPS_CWD
;
4437 else if (strcmp (arg
, "obj") == 0
4438 || strcmp (arg
, "object") == 0)
4439 save_temps_flag
= SAVE_TEMPS_OBJ
;
4441 fatal_error (input_location
, "%qs is an unknown %<-save-temps%> option",
4442 decoded
->orig_option_with_args_text
);
4443 save_temps_overrides_dumpdir
= true;
4448 dumpdir
= xstrdup (arg
);
4449 save_temps_overrides_dumpdir
= false;
4454 dumpbase
= xstrdup (arg
);
4457 case OPT_dumpbase_ext
:
4458 free (dumpbase_ext
);
4459 dumpbase_ext
= xstrdup (arg
);
4462 case OPT_no_canonical_prefixes
:
4463 /* Already handled as a special case, so ignored here. */
4469 /* These options set the variables specified in common.opt
4470 automatically, but do need to be saved for spec
4476 struct user_specs
*user
= XNEW (struct user_specs
);
4478 user
->next
= (struct user_specs
*) 0;
4479 user
->filename
= arg
;
4480 if (user_specs_tail
)
4481 user_specs_tail
->next
= user
;
4483 user_specs_head
= user
;
4484 user_specs_tail
= user
;
4490 target_system_root
= arg
;
4491 target_system_root_changed
= 1;
4496 if (report_times_to_file
)
4497 fclose (report_times_to_file
);
4498 report_times_to_file
= fopen (arg
, "a");
4504 This is similar to -v except that there is no execution
4505 of the commands and the echoed arguments are quoted. It
4506 is intended for use in shell scripts to capture the
4507 driver-generated command line. */
4508 verbose_only_flag
++;
4515 size_t len
= strlen (arg
);
4517 /* Catch the case where the user has forgotten to append a
4518 directory separator to the path. Note, they may be using
4519 -B to add an executable name prefix, eg "i386-elf-", in
4520 order to distinguish between multiple installations of
4521 GCC in the same directory. Hence we must check to see
4522 if appending a directory separator actually makes a
4523 valid directory name. */
4524 if (!IS_DIR_SEPARATOR (arg
[len
- 1])
4525 && is_directory (arg
, false))
4527 char *tmp
= XNEWVEC (char, len
+ 2);
4529 tmp
[len
] = DIR_SEPARATOR
;
4534 add_prefix (&exec_prefixes
, arg
, NULL
,
4535 PREFIX_PRIORITY_B_OPT
, 0, 0);
4536 add_prefix (&startfile_prefixes
, arg
, NULL
,
4537 PREFIX_PRIORITY_B_OPT
, 0, 0);
4538 add_prefix (&include_prefixes
, arg
, NULL
,
4539 PREFIX_PRIORITY_B_OPT
, 0, 0);
4550 if (!strcmp (spec_lang
, "none"))
4551 /* Suppress the warning if -xnone comes after the last input
4552 file, because alternate command interfaces like g++ might
4553 find it useful to place -xnone after each input file. */
4556 last_language_n_infiles
= n_infiles
;
4562 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
4563 arg
= convert_filename (arg
, ! have_c
, 0);
4566 /* On some systems, ld cannot handle "-o" without a space. So
4567 split the option from its argument. */
4568 save_switch ("-o", 1, &arg
, validated
, true);
4571 #ifdef ENABLE_DEFAULT_PIE
4573 /* -pie is turned on by default. */
4576 case OPT_static_libgcc
:
4577 case OPT_shared_libgcc
:
4578 case OPT_static_libgfortran
:
4579 case OPT_static_libstdc__
:
4580 /* These are always valid, since gcc.c itself understands the
4581 first two, gfortranspec.c understands -static-libgfortran and
4582 g++spec.c understands -static-libstdc++ */
4590 case OPT_foffload_options_
:
4591 check_foffload_target_names (arg
);
4595 handle_foffload_option (arg
);
4596 if (arg
[0] == '-' || NULL
!= strchr (arg
, '='))
4597 save_switch (concat ("-foffload-options=", arg
, NULL
),
4598 0, NULL
, validated
, true);
4603 /* Various driver options need no special processing at this
4604 point, having been handled in a prescan above or being
4605 handled by specs. */
4610 save_switch (decoded
->canonical_option
[0],
4611 decoded
->canonical_option_num_elements
- 1,
4612 &decoded
->canonical_option
[1], validated
, true);
4616 /* Return true if F2 is F1 followed by a single suffix, i.e., by a
4617 period and additional characters other than a period. */
4620 adds_single_suffix_p (const char *f2
, const char *f1
)
4622 size_t len
= strlen (f1
);
4624 return (strncmp (f1
, f2
, len
) == 0
4626 && strchr (f2
+ len
+ 1, '.') == NULL
);
4629 /* Put the driver's standard set of option handlers in *HANDLERS. */
4632 set_option_handlers (struct cl_option_handlers
*handlers
)
4634 handlers
->unknown_option_callback
= driver_unknown_option_callback
;
4635 handlers
->wrong_lang_callback
= driver_wrong_lang_callback
;
4636 handlers
->num_handlers
= 3;
4637 handlers
->handlers
[0].handler
= driver_handle_option
;
4638 handlers
->handlers
[0].mask
= CL_DRIVER
;
4639 handlers
->handlers
[1].handler
= common_handle_option
;
4640 handlers
->handlers
[1].mask
= CL_COMMON
;
4641 handlers
->handlers
[2].handler
= target_handle_option
;
4642 handlers
->handlers
[2].mask
= CL_TARGET
;
4646 /* Return the index into infiles for the single non-library
4647 non-lto-wpa input file, -1 if there isn't any, or -2 if there is
4650 single_input_file_index ()
4654 for (int i
= 0; i
< n_infiles
; i
++)
4656 if (infiles
[i
].language
4657 && (infiles
[i
].language
[0] == '*'
4659 && strcmp (infiles
[i
].language
, "lto") == 0)))
4671 /* Create the vector `switches' and its contents.
4672 Store its length in `n_switches'. */
4675 process_command (unsigned int decoded_options_count
,
4676 struct cl_decoded_option
*decoded_options
)
4680 char *tooldir_prefix
, *tooldir_prefix2
;
4681 char *(*get_relative_prefix
) (const char *, const char *,
4682 const char *) = NULL
;
4683 struct cl_option_handlers handlers
;
4686 gcc_exec_prefix
= env
.get ("GCC_EXEC_PREFIX");
4690 added_libraries
= 0;
4692 /* Figure compiler version from version string. */
4694 compiler_version
= temp1
= xstrdup (version_string
);
4696 for (; *temp1
; ++temp1
)
4705 /* Handle any -no-canonical-prefixes flag early, to assign the function
4706 that builds relative prefixes. This function creates default search
4707 paths that are needed later in normal option handling. */
4709 for (j
= 1; j
< decoded_options_count
; j
++)
4711 if (decoded_options
[j
].opt_index
== OPT_no_canonical_prefixes
)
4713 get_relative_prefix
= make_relative_prefix_ignore_links
;
4717 if (! get_relative_prefix
)
4718 get_relative_prefix
= make_relative_prefix
;
4720 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
4721 see if we can create it from the pathname specified in
4722 decoded_options[0].arg. */
4724 gcc_libexec_prefix
= standard_libexec_prefix
;
4726 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
4727 if (!gcc_exec_prefix
)
4729 gcc_exec_prefix
= get_relative_prefix (decoded_options
[0].arg
,
4730 standard_bindir_prefix
,
4731 standard_exec_prefix
);
4732 gcc_libexec_prefix
= get_relative_prefix (decoded_options
[0].arg
,
4733 standard_bindir_prefix
,
4734 standard_libexec_prefix
);
4735 if (gcc_exec_prefix
)
4736 xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix
, NULL
));
4740 /* make_relative_prefix requires a program name, but
4741 GCC_EXEC_PREFIX is typically a directory name with a trailing
4742 / (which is ignored by make_relative_prefix), so append a
4744 char *tmp_prefix
= concat (gcc_exec_prefix
, "gcc", NULL
);
4745 gcc_libexec_prefix
= get_relative_prefix (tmp_prefix
,
4746 standard_exec_prefix
,
4747 standard_libexec_prefix
);
4749 /* The path is unrelocated, so fallback to the original setting. */
4750 if (!gcc_libexec_prefix
)
4751 gcc_libexec_prefix
= standard_libexec_prefix
;
4757 /* From this point onward, gcc_exec_prefix is non-null if the toolchain
4758 is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
4759 or an automatically created GCC_EXEC_PREFIX from
4760 decoded_options[0].arg. */
4762 /* Do language-specific adjustment/addition of flags. */
4763 lang_specific_driver (&decoded_options
, &decoded_options_count
,
4766 if (gcc_exec_prefix
)
4768 int len
= strlen (gcc_exec_prefix
);
4770 if (len
> (int) sizeof ("/lib/gcc/") - 1
4771 && (IS_DIR_SEPARATOR (gcc_exec_prefix
[len
-1])))
4773 temp
= gcc_exec_prefix
+ len
- sizeof ("/lib/gcc/") + 1;
4774 if (IS_DIR_SEPARATOR (*temp
)
4775 && filename_ncmp (temp
+ 1, "lib", 3) == 0
4776 && IS_DIR_SEPARATOR (temp
[4])
4777 && filename_ncmp (temp
+ 5, "gcc", 3) == 0)
4778 len
-= sizeof ("/lib/gcc/") - 1;
4781 set_std_prefix (gcc_exec_prefix
, len
);
4782 add_prefix (&exec_prefixes
, gcc_libexec_prefix
, "GCC",
4783 PREFIX_PRIORITY_LAST
, 0, 0);
4784 add_prefix (&startfile_prefixes
, gcc_exec_prefix
, "GCC",
4785 PREFIX_PRIORITY_LAST
, 0, 0);
4788 /* COMPILER_PATH and LIBRARY_PATH have values
4789 that are lists of directory names with colons. */
4791 temp
= env
.get ("COMPILER_PATH");
4794 const char *startp
, *endp
;
4795 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4797 startp
= endp
= temp
;
4800 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4802 strncpy (nstore
, startp
, endp
- startp
);
4804 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4805 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4807 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4808 nstore
[endp
- startp
+ 1] = 0;
4811 nstore
[endp
- startp
] = 0;
4812 add_prefix (&exec_prefixes
, nstore
, 0,
4813 PREFIX_PRIORITY_LAST
, 0, 0);
4814 add_prefix (&include_prefixes
, nstore
, 0,
4815 PREFIX_PRIORITY_LAST
, 0, 0);
4818 endp
= startp
= endp
+ 1;
4825 temp
= env
.get (LIBRARY_PATH_ENV
);
4826 if (temp
&& *cross_compile
== '0')
4828 const char *startp
, *endp
;
4829 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4831 startp
= endp
= temp
;
4834 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4836 strncpy (nstore
, startp
, endp
- startp
);
4838 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4839 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4841 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4842 nstore
[endp
- startp
+ 1] = 0;
4845 nstore
[endp
- startp
] = 0;
4846 add_prefix (&startfile_prefixes
, nstore
, NULL
,
4847 PREFIX_PRIORITY_LAST
, 0, 1);
4850 endp
= startp
= endp
+ 1;
4857 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
4858 temp
= env
.get ("LPATH");
4859 if (temp
&& *cross_compile
== '0')
4861 const char *startp
, *endp
;
4862 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4864 startp
= endp
= temp
;
4867 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4869 strncpy (nstore
, startp
, endp
- startp
);
4871 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4872 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4874 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4875 nstore
[endp
- startp
+ 1] = 0;
4878 nstore
[endp
- startp
] = 0;
4879 add_prefix (&startfile_prefixes
, nstore
, NULL
,
4880 PREFIX_PRIORITY_LAST
, 0, 1);
4883 endp
= startp
= endp
+ 1;
4890 /* Process the options and store input files and switches in their
4893 last_language_n_infiles
= -1;
4895 set_option_handlers (&handlers
);
4897 for (j
= 1; j
< decoded_options_count
; j
++)
4899 switch (decoded_options
[j
].opt_index
)
4911 for (j
= 1; j
< decoded_options_count
; j
++)
4913 if (decoded_options
[j
].opt_index
== OPT_SPECIAL_input_file
)
4915 const char *arg
= decoded_options
[j
].arg
;
4917 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4918 arg
= convert_filename (arg
, 0, access (arg
, F_OK
));
4920 add_infile (arg
, spec_lang
);
4925 read_cmdline_option (&global_options
, &global_options_set
,
4926 decoded_options
+ j
, UNKNOWN_LOCATION
,
4927 CL_DRIVER
, &handlers
, global_dc
);
4930 /* If the user didn't specify any, default to all configured offload
4932 if (ENABLE_OFFLOADING
&& offload_targets
== NULL
)
4934 handle_foffload_option (OFFLOAD_TARGETS
);
4935 #if OFFLOAD_DEFAULTED
4936 offload_targets_default
= true;
4940 /* Handle -gtoggle as it would later in toplev.c:process_options to
4941 make the debug-level-gt spec function work as expected. */
4944 if (debug_info_level
== DINFO_LEVEL_NONE
)
4945 debug_info_level
= DINFO_LEVEL_NORMAL
;
4947 debug_info_level
= DINFO_LEVEL_NONE
;
4951 && strcmp (output_file
, "-") != 0
4952 && strcmp (output_file
, HOST_BIT_BUCKET
) != 0)
4955 for (i
= 0; i
< n_infiles
; i
++)
4956 if ((!infiles
[i
].language
|| infiles
[i
].language
[0] != '*')
4957 && canonical_filename_eq (infiles
[i
].name
, output_file
))
4958 fatal_error (input_location
,
4959 "input file %qs is the same as output file",
4963 if (output_file
!= NULL
&& output_file
[0] == '\0')
4964 fatal_error (input_location
, "output filename may not be empty");
4966 /* -dumpdir and -save-temps=* both specify the location of aux/dump
4967 outputs; the one that appears last prevails. When compiling
4968 multiple sources, an explicit dumpbase (minus -ext) may be
4969 combined with an explicit or implicit dumpdir, whereas when
4970 linking, a specified or implied link output name (minus
4971 extension) may be combined with a prevailing -save-temps=* or an
4972 otherwise implied dumpdir, but not override a prevailing
4973 -dumpdir. Primary outputs (e.g., linker output when linking
4974 without -o, or .i, .s or .o outputs when processing multiple
4975 inputs with -E, -S or -c, respectively) are NOT affected by these
4976 -save-temps=/-dump* options, always landing in the current
4977 directory and with the same basename as the input when an output
4978 name is not given, but when they're intermediate outputs, they
4979 are named like other aux outputs, so the options affect their
4982 Here are some examples. There are several more in the
4983 documentation of -o and -dump*, and some quite exhaustive tests
4984 in gcc.misc-tests/outputs.exp.
4986 When compiling any number of sources, no -dump* nor
4987 -save-temps=*, all outputs in cwd without prefix:
4989 # gcc -c b.c -gsplit-dwarf
4990 -> cc1 [-dumpdir ./] -dumpbase b.c -dumpbase-ext .c # b.o b.dwo
4992 # gcc -c b.c d.c -gsplit-dwarf
4993 -> cc1 [-dumpdir ./] -dumpbase b.c -dumpbase-ext .c # b.o b.dwo
4994 && cc1 [-dumpdir ./] -dumpbase d.c -dumpbase-ext .c # d.o d.dwo
4996 When compiling and linking, no -dump* nor -save-temps=*, .o
4997 outputs are temporary, aux outputs land in the dir of the output,
4998 prefixed with the basename of the linker output:
5000 # gcc b.c d.c -o ab -gsplit-dwarf
5001 -> cc1 -dumpdir ab- -dumpbase b.c -dumpbase-ext .c # ab-b.dwo
5002 && cc1 -dumpdir ab- -dumpbase d.c -dumpbase-ext .c # ab-d.dwo
5005 # gcc b.c d.c [-o a.out] -gsplit-dwarf
5006 -> cc1 -dumpdir a- -dumpbase b.c -dumpbase-ext .c # a-b.dwo
5007 && cc1 -dumpdir a- -dumpbase d.c -dumpbase-ext .c # a-d.dwo
5008 && link ... [-o a.out]
5010 When compiling and linking, a prevailing -dumpdir fully overrides
5011 the prefix of aux outputs given by the output name:
5013 # gcc -dumpdir f b.c d.c -gsplit-dwarf [-o [dir/]whatever]
5014 -> cc1 -dumpdir f -dumpbase b.c -dumpbase-ext .c # fb.dwo
5015 && cc1 -dumpdir f -dumpbase d.c -dumpbase-ext .c # fd.dwo
5016 && link ... [-o whatever]
5018 When compiling multiple inputs, an explicit -dumpbase is combined
5019 with -dumpdir, affecting aux outputs, but not the .o outputs:
5021 # gcc -dumpdir f -dumpbase g- b.c d.c -gsplit-dwarf -c
5022 -> cc1 -dumpdir fg- -dumpbase b.c -dumpbase-ext .c # b.o fg-b.dwo
5023 && cc1 -dumpdir fg- -dumpbase d.c -dumpbase-ext .c # d.o fg-d.dwo
5025 When compiling and linking with -save-temps, the .o outputs that
5026 would have been temporary become aux outputs, so they get
5027 affected by -dump* flags:
5029 # gcc -dumpdir f -dumpbase g- -save-temps b.c d.c
5030 -> cc1 -dumpdir fg- -dumpbase b.c -dumpbase-ext .c # fg-b.o
5031 && cc1 -dumpdir fg- -dumpbase d.c -dumpbase-ext .c # fg-d.o
5034 If -save-temps=* prevails over -dumpdir, however, the explicit
5035 -dumpdir is discarded, as if it wasn't there. The basename of
5036 the implicit linker output, a.out or a.exe, becomes a- as the aux
5037 output prefix for all compilations:
5039 # gcc [-dumpdir f] -save-temps=cwd b.c d.c
5040 -> cc1 -dumpdir a- -dumpbase b.c -dumpbase-ext .c # a-b.o
5041 && cc1 -dumpdir a- -dumpbase d.c -dumpbase-ext .c # a-d.o
5044 A single -dumpbase, applying to multiple inputs, overrides the
5045 linker output name, implied or explicit, as the aux output prefix:
5047 # gcc [-dumpdir f] -dumpbase g- -save-temps=cwd b.c d.c
5048 -> cc1 -dumpdir g- -dumpbase b.c -dumpbase-ext .c # g-b.o
5049 && cc1 -dumpdir g- -dumpbase d.c -dumpbase-ext .c # g-d.o
5052 # gcc [-dumpdir f] -dumpbase g- -save-temps=cwd b.c d.c -o dir/h.out
5053 -> cc1 -dumpdir g- -dumpbase b.c -dumpbase-ext .c # g-b.o
5054 && cc1 -dumpdir g- -dumpbase d.c -dumpbase-ext .c # g-d.o
5055 && link -o dir/h.out
5057 Now, if the linker output is NOT overridden as a prefix, but
5058 -save-temps=* overrides implicit or explicit -dumpdir, the
5059 effective dump dir combines the dir selected by the -save-temps=*
5060 option with the basename of the specified or implied link output:
5062 # gcc [-dumpdir f] -save-temps=cwd b.c d.c -o dir/h.out
5063 -> cc1 -dumpdir h- -dumpbase b.c -dumpbase-ext .c # h-b.o
5064 && cc1 -dumpdir h- -dumpbase d.c -dumpbase-ext .c # h-d.o
5065 && link -o dir/h.out
5067 # gcc [-dumpdir f] -save-temps=obj b.c d.c -o dir/h.out
5068 -> cc1 -dumpdir dir/h- -dumpbase b.c -dumpbase-ext .c # dir/h-b.o
5069 && cc1 -dumpdir dir/h- -dumpbase d.c -dumpbase-ext .c # dir/h-d.o
5070 && link -o dir/h.out
5072 But then again, a single -dumpbase applying to multiple inputs
5073 gets used instead of the linker output basename in the combined
5076 # gcc [-dumpdir f] -dumpbase g- -save-temps=obj b.c d.c -o dir/h.out
5077 -> cc1 -dumpdir dir/g- -dumpbase b.c -dumpbase-ext .c # dir/g-b.o
5078 && cc1 -dumpdir dir/g- -dumpbase d.c -dumpbase-ext .c # dir/g-d.o
5079 && link -o dir/h.out
5081 With a single input being compiled, the output basename does NOT
5082 affect the dumpdir prefix.
5084 # gcc -save-temps=obj b.c -gsplit-dwarf -c -o dir/b.o
5085 -> cc1 -dumpdir dir/ -dumpbase b.c -dumpbase-ext .c # dir/b.o dir/b.dwo
5087 but when compiling and linking even a single file, it does:
5089 # gcc -save-temps=obj b.c -o dir/h.out
5090 -> cc1 -dumpdir dir/h- -dumpbase b.c -dumpbase-ext .c # dir/h-b.o
5092 unless an explicit -dumpdir prevails:
5094 # gcc -save-temps[=obj] -dumpdir g- b.c -o dir/h.out
5095 -> cc1 -dumpdir g- -dumpbase b.c -dumpbase-ext .c # g-b.o
5099 bool explicit_dumpdir
= dumpdir
;
5101 if ((!save_temps_overrides_dumpdir
&& explicit_dumpdir
)
5102 || (output_file
&& not_actual_file_p (output_file
)))
5107 /* If -save-temps=obj and -o name, create the prefix to use for %b.
5108 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
5109 else if (save_temps_flag
!= SAVE_TEMPS_CWD
&& output_file
!= NULL
)
5113 temp
= lbasename (output_file
);
5114 if (temp
!= output_file
)
5115 dumpdir
= xstrndup (output_file
,
5116 strlen (output_file
) - strlen (temp
));
5124 if (save_temps_flag
)
5125 save_temps_flag
= SAVE_TEMPS_DUMP
;
5127 /* If there is any pathname component in an explicit -dumpbase, it
5128 overrides dumpdir entirely, so discard it right away. Although
5129 the presence of an explicit -dumpdir matters for the driver, it
5130 shouldn't matter for other processes, that get all that's needed
5131 from the -dumpdir and -dumpbase always passed to them. */
5132 if (dumpdir
&& dumpbase
&& lbasename (dumpbase
) != dumpbase
)
5138 /* Check that dumpbase_ext matches the end of dumpbase, drop it
5140 if (dumpbase_ext
&& dumpbase
&& *dumpbase
)
5142 int lendb
= strlen (dumpbase
);
5143 int lendbx
= strlen (dumpbase_ext
);
5145 /* -dumpbase-ext must be a suffix proper; discard it if it
5146 matches all of -dumpbase, as that would make for an empty
5149 || strcmp (dumpbase
+ lendb
- lendbx
, dumpbase_ext
) != 0)
5151 free (dumpbase_ext
);
5152 dumpbase_ext
= NULL
;
5156 /* -dumpbase with multiple sources goes into dumpdir. With a single
5157 source, it does only if linking and if dumpdir was not explicitly
5159 if (dumpbase
&& *dumpbase
5160 && (single_input_file_index () == -2
5161 || (!have_c
&& !explicit_dumpdir
)))
5166 /* We checked that they match above. */
5167 dumpbase
[strlen (dumpbase
) - strlen (dumpbase_ext
)] = '\0';
5170 prefix
= concat (dumpdir
, dumpbase
, "-", NULL
);
5172 prefix
= concat (dumpbase
, "-", NULL
);
5176 free (dumpbase_ext
);
5177 dumpbase
= dumpbase_ext
= NULL
;
5179 dumpdir_trailing_dash_added
= true;
5182 /* If dumpbase was not brought into dumpdir but we're linking, bring
5183 output_file into dumpdir unless dumpdir was explicitly specified.
5184 The test for !explicit_dumpdir is further below, because we want
5185 to use the obase computation for a ghost outbase, passed to
5186 GCC_COLLECT_OPTIONS. */
5187 else if (!have_c
&& (!explicit_dumpdir
|| (dumpbase
&& !*dumpbase
)))
5189 /* If we get here, we know dumpbase was not specified, or it was
5190 specified as an empty string. If it was anything else, it
5191 would have combined with dumpdir above, because the condition
5192 for dumpbase to be used when present is broader than the
5193 condition that gets us here. */
5194 gcc_assert (!dumpbase
|| !*dumpbase
);
5197 char *tofree
= NULL
;
5198 if (!output_file
|| not_actual_file_p (output_file
))
5202 obase
= lbasename (output_file
);
5203 size_t blen
= strlen (obase
), xlen
;
5204 /* Drop the suffix if it's dumpbase_ext, if given,
5205 otherwise .exe or the target executable suffix, or if the
5206 output was explicitly named a.out, but not otherwise. */
5208 ? (blen
> (xlen
= strlen (dumpbase_ext
))
5209 && strcmp ((temp
= (obase
+ blen
- xlen
)),
5211 : ((temp
= strrchr (obase
+ 1, '.'))
5212 && (xlen
= strlen (temp
))
5213 && (strcmp (temp
, ".exe") == 0
5214 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
5215 || strcmp (temp
, TARGET_EXECUTABLE_SUFFIX
) == 0
5217 || strcmp (obase
, "a.out") == 0)))
5219 tofree
= xstrndup (obase
, blen
- xlen
);
5224 /* We wish to save this basename to the -dumpdir passed through
5225 GCC_COLLECT_OPTIONS within maybe_run_linker, for e.g. LTO,
5226 but we do NOT wish to add it to e.g. %b, so we keep
5227 outbase_length as zero. */
5228 gcc_assert (!outbase
);
5231 /* If we're building [dir1/]foo[.exe] out of a single input
5232 [dir2/]foo.c that shares the same basename, dump to
5233 [dir2/]foo.c.* rather than duplicating the basename into
5234 [dir2/]foo-foo.c.*. */
5237 || ((idxin
= single_input_file_index ()) >= 0
5238 && adds_single_suffix_p (lbasename (infiles
[idxin
].name
),
5241 if (obase
== tofree
)
5245 outbase
= xstrdup (obase
);
5248 obase
= tofree
= NULL
;
5254 char *p
= concat (dumpdir
, obase
, "-", NULL
);
5259 dumpdir
= concat (obase
, "-", NULL
);
5261 dumpdir_trailing_dash_added
= true;
5264 obase
= tofree
= NULL
;
5267 if (!explicit_dumpdir
|| dumpbase
)
5269 /* Absent -dumpbase and present -dumpbase-ext have been applied
5270 to the linker output name, so compute fresh defaults for each
5272 free (dumpbase_ext
);
5273 dumpbase_ext
= NULL
;
5277 /* Now, if we're compiling, or if we haven't used the dumpbase
5278 above, then outbase (%B) is derived from dumpbase, if given, or
5279 from the output name, given or implied. We can't precompute
5280 implied output names, but that's ok, since they're derived from
5281 input names. Just make sure we skip this if dumpbase is the
5282 empty string: we want to use input names then, so don't set
5284 if ((dumpbase
|| have_c
)
5285 && !(dumpbase
&& !*dumpbase
))
5287 gcc_assert (!outbase
);
5291 gcc_assert (single_input_file_index () != -2);
5292 /* We do not want lbasename here; dumpbase with dirnames
5293 overrides dumpdir entirely, even if dumpdir is
5296 /* We've already checked above that the suffix matches. */
5297 outbase
= xstrndup (dumpbase
,
5298 strlen (dumpbase
) - strlen (dumpbase_ext
));
5300 outbase
= xstrdup (dumpbase
);
5302 else if (output_file
&& !not_actual_file_p (output_file
))
5304 outbase
= xstrdup (lbasename (output_file
));
5305 char *p
= strrchr (outbase
+ 1, '.');
5311 outbase_length
= strlen (outbase
);
5314 /* If there is any pathname component in an explicit -dumpbase, do
5315 not use dumpdir, but retain it to pass it on to the compiler. */
5317 dumpdir_length
= strlen (dumpdir
);
5321 /* Check that dumpbase_ext, if still present, still matches the end
5322 of dumpbase, if present, and drop it otherwise. We only retained
5323 it above when dumpbase was absent to maybe use it to drop the
5324 extension from output_name before combining it with dumpdir. We
5325 won't deal with -dumpbase-ext when -dumpbase is not explicitly
5326 given, even if just to activate backward-compatible dumpbase:
5327 dropping it on the floor is correct, expected and documented
5328 behavior. Attempting to deal with a -dumpbase-ext that might
5329 match the end of some input filename, or of the combination of
5330 the output basename with the suffix of the input filename,
5331 possible with an intermediate .gk extension for -fcompare-debug,
5332 is just calling for trouble. */
5335 if (!dumpbase
|| !*dumpbase
)
5337 free (dumpbase_ext
);
5338 dumpbase_ext
= NULL
;
5341 gcc_assert (strcmp (dumpbase
+ strlen (dumpbase
)
5342 - strlen (dumpbase_ext
), dumpbase_ext
) == 0);
5345 if (save_temps_flag
&& use_pipes
)
5347 /* -save-temps overrides -pipe, so that temp files are produced */
5348 if (save_temps_flag
)
5349 warning (0, "%<-pipe%> ignored because %<-save-temps%> specified");
5355 const char *gcd
= env
.get ("GCC_COMPARE_DEBUG");
5357 if (gcd
&& gcd
[0] == '-')
5360 compare_debug_opt
= gcd
;
5362 else if (gcd
&& *gcd
&& strcmp (gcd
, "0"))
5365 compare_debug_opt
= "-gtoggle";
5368 else if (compare_debug
< 0)
5371 gcc_assert (!compare_debug_opt
);
5374 /* Set up the search paths. We add directories that we expect to
5375 contain GNU Toolchain components before directories specified by
5376 the machine description so that we will find GNU components (like
5377 the GNU assembler) before those of the host system. */
5379 /* If we don't know where the toolchain has been installed, use the
5380 configured-in locations. */
5381 if (!gcc_exec_prefix
)
5384 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "GCC",
5385 PREFIX_PRIORITY_LAST
, 1, 0);
5386 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "BINUTILS",
5387 PREFIX_PRIORITY_LAST
, 2, 0);
5388 add_prefix (&exec_prefixes
, standard_exec_prefix
, "BINUTILS",
5389 PREFIX_PRIORITY_LAST
, 2, 0);
5391 add_prefix (&startfile_prefixes
, standard_exec_prefix
, "BINUTILS",
5392 PREFIX_PRIORITY_LAST
, 1, 0);
5395 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix
));
5396 tooldir_prefix2
= concat (tooldir_base_prefix
, spec_machine
,
5397 dir_separator_str
, NULL
);
5399 /* Look for tools relative to the location from which the driver is
5400 running, or, if that is not available, the configured prefix. */
5402 = concat (gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
5403 spec_host_machine
, dir_separator_str
, spec_version
,
5404 accel_dir_suffix
, dir_separator_str
, tooldir_prefix2
, NULL
);
5405 free (tooldir_prefix2
);
5407 add_prefix (&exec_prefixes
,
5408 concat (tooldir_prefix
, "bin", dir_separator_str
, NULL
),
5409 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 0);
5410 add_prefix (&startfile_prefixes
,
5411 concat (tooldir_prefix
, "lib", dir_separator_str
, NULL
),
5412 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 1);
5413 free (tooldir_prefix
);
5415 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
5416 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
5417 then consider it to relocate with the rest of the GCC installation
5418 if GCC_EXEC_PREFIX is set.
5419 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
5420 if (target_system_root
&& !target_system_root_changed
&& gcc_exec_prefix
)
5422 char *tmp_prefix
= get_relative_prefix (decoded_options
[0].arg
,
5423 standard_bindir_prefix
,
5424 target_system_root
);
5425 if (tmp_prefix
&& access_check (tmp_prefix
, F_OK
) == 0)
5427 target_system_root
= tmp_prefix
;
5428 target_system_root_changed
= 1;
5433 /* More prefixes are enabled in main, after we read the specs file
5434 and determine whether this is cross-compilation or not. */
5436 if (n_infiles
!= 0 && n_infiles
== last_language_n_infiles
&& spec_lang
!= 0)
5437 warning (0, "%<-x %s%> after last input file has no effect", spec_lang
);
5439 /* Synthesize -fcompare-debug flag from the GCC_COMPARE_DEBUG
5440 environment variable. */
5441 if (compare_debug
== 2 || compare_debug
== 3)
5443 const char *opt
= concat ("-fcompare-debug=", compare_debug_opt
, NULL
);
5444 save_switch (opt
, 0, NULL
, false, true);
5448 /* Ensure we only invoke each subprocess once. */
5450 && (print_subprocess_help
|| print_help_list
|| print_version
))
5452 /* Create a dummy input file, so that we can pass
5453 the help option on to the various sub-processes. */
5454 add_infile ("help-dummy", "c");
5457 /* Decide if undefined variable references are allowed in specs. */
5459 /* -v alone is safe. --version and --help alone or together are safe. Note
5460 that -v would make them unsafe, as they'd then be run for subprocesses as
5461 well, the location of which might depend on variables possibly coming
5462 from self-specs. Note also that the command name is counted in
5463 decoded_options_count. */
5465 unsigned help_version_count
= 0;
5468 help_version_count
++;
5470 if (print_help_list
)
5471 help_version_count
++;
5473 spec_undefvar_allowed
=
5474 ((verbose_flag
&& decoded_options_count
== 2)
5475 || help_version_count
== decoded_options_count
- 1);
5478 switches
[n_switches
].part1
= 0;
5480 infiles
[n_infiles
].name
= 0;
5483 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
5484 and place that in the environment. */
5487 set_collect_gcc_options (void)
5492 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
5494 obstack_grow (&collect_obstack
, "COLLECT_GCC_OPTIONS=",
5495 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
5498 for (i
= 0; (int) i
< n_switches
; i
++)
5500 const char *const *args
;
5503 obstack_grow (&collect_obstack
, " ", 1);
5507 /* Ignore elided switches. */
5508 if ((switches
[i
].live_cond
5509 & (SWITCH_IGNORE
| SWITCH_KEEP_FOR_GCC
))
5513 obstack_grow (&collect_obstack
, "'-", 2);
5514 q
= switches
[i
].part1
;
5515 while ((p
= strchr (q
, '\'')))
5517 obstack_grow (&collect_obstack
, q
, p
- q
);
5518 obstack_grow (&collect_obstack
, "'\\''", 4);
5521 obstack_grow (&collect_obstack
, q
, strlen (q
));
5522 obstack_grow (&collect_obstack
, "'", 1);
5524 for (args
= switches
[i
].args
; args
&& *args
; args
++)
5526 obstack_grow (&collect_obstack
, " '", 2);
5528 while ((p
= strchr (q
, '\'')))
5530 obstack_grow (&collect_obstack
, q
, p
- q
);
5531 obstack_grow (&collect_obstack
, "'\\''", 4);
5534 obstack_grow (&collect_obstack
, q
, strlen (q
));
5535 obstack_grow (&collect_obstack
, "'", 1);
5542 obstack_grow (&collect_obstack
, " ", 1);
5545 obstack_grow (&collect_obstack
, "'-dumpdir' '", 12);
5549 while ((p
= strchr (q
, '\'')))
5551 obstack_grow (&collect_obstack
, q
, p
- q
);
5552 obstack_grow (&collect_obstack
, "'\\''", 4);
5555 obstack_grow (&collect_obstack
, q
, strlen (q
));
5557 obstack_grow (&collect_obstack
, "'", 1);
5560 obstack_grow (&collect_obstack
, "\0", 1);
5561 xputenv (XOBFINISH (&collect_obstack
, char *));
5564 /* Process a spec string, accumulating and running commands. */
5566 /* These variables describe the input file name.
5567 input_file_number is the index on outfiles of this file,
5568 so that the output file name can be stored for later use by %o.
5569 input_basename is the start of the part of the input file
5570 sans all directory names, and basename_length is the number
5571 of characters starting there excluding the suffix .c or whatever. */
5573 static const char *gcc_input_filename
;
5574 static int input_file_number
;
5575 size_t input_filename_length
;
5576 static int basename_length
;
5577 static int suffixed_basename_length
;
5578 static const char *input_basename
;
5579 static const char *input_suffix
;
5580 #ifndef HOST_LACKS_INODE_NUMBERS
5581 static struct stat input_stat
;
5583 static int input_stat_set
;
5585 /* The compiler used to process the current input file. */
5586 static struct compiler
*input_file_compiler
;
5588 /* These are variables used within do_spec and do_spec_1. */
5590 /* Nonzero if an arg has been started and not yet terminated
5591 (with space, tab or newline). */
5592 static int arg_going
;
5594 /* Nonzero means %d or %g has been seen; the next arg to be terminated
5595 is a temporary file name. */
5596 static int delete_this_arg
;
5598 /* Nonzero means %w has been seen; the next arg to be terminated
5599 is the output file name of this compilation. */
5600 static int this_is_output_file
;
5602 /* Nonzero means %s has been seen; the next arg to be terminated
5603 is the name of a library file and we should try the standard
5604 search dirs for it. */
5605 static int this_is_library_file
;
5607 /* Nonzero means %T has been seen; the next arg to be terminated
5608 is the name of a linker script and we should try all of the
5609 standard search dirs for it. If it is found insert a --script
5610 command line switch and then substitute the full path in place,
5611 otherwise generate an error message. */
5612 static int this_is_linker_script
;
5614 /* Nonzero means that the input of this command is coming from a pipe. */
5615 static int input_from_pipe
;
5617 /* Nonnull means substitute this for any suffix when outputting a switches
5619 static const char *suffix_subst
;
5621 /* If there is an argument being accumulated, terminate it and store it. */
5624 end_going_arg (void)
5630 obstack_1grow (&obstack
, 0);
5631 string
= XOBFINISH (&obstack
, const char *);
5632 if (this_is_library_file
)
5633 string
= find_file (string
);
5634 if (this_is_linker_script
)
5636 char * full_script_path
= find_a_file (&startfile_prefixes
, string
, R_OK
, true);
5638 if (full_script_path
== NULL
)
5640 error ("unable to locate default linker script %qs in the library search paths", string
);
5641 /* Script was not found on search path. */
5644 store_arg ("--script", false, false);
5645 string
= full_script_path
;
5647 store_arg (string
, delete_this_arg
, this_is_output_file
);
5648 if (this_is_output_file
)
5649 outfiles
[input_file_number
] = string
;
5655 /* Parse the WRAPPER string which is a comma separated list of the command line
5656 and insert them into the beginning of argbuf. */
5659 insert_wrapper (const char *wrapper
)
5663 char *buf
= xstrdup (wrapper
);
5665 unsigned int old_length
= argbuf
.length ();
5673 while ((p
= strchr (p
, ',')) != NULL
);
5675 argbuf
.safe_grow (old_length
+ n
, true);
5676 memmove (argbuf
.address () + n
,
5678 old_length
* sizeof (const_char_p
));
5692 while ((p
= strchr (p
, ',')) != NULL
);
5693 gcc_assert (i
== n
);
5696 /* Process the spec SPEC and run the commands specified therein.
5697 Returns 0 if the spec is successfully processed; -1 if failed. */
5700 do_spec (const char *spec
)
5704 value
= do_spec_2 (spec
, NULL
);
5706 /* Force out any unfinished command.
5707 If -pipe, this forces out the last command if it ended in `|'. */
5710 if (argbuf
.length () > 0
5711 && !strcmp (argbuf
.last (), "|"))
5714 set_collect_gcc_options ();
5716 if (argbuf
.length () > 0)
5723 /* Process the spec SPEC, with SOFT_MATCHED_PART designating the current value
5724 of a matched * pattern which may be re-injected by way of %*. */
5727 do_spec_2 (const char *spec
, const char *soft_matched_part
)
5733 delete_this_arg
= 0;
5734 this_is_output_file
= 0;
5735 this_is_library_file
= 0;
5736 this_is_linker_script
= 0;
5737 input_from_pipe
= 0;
5738 suffix_subst
= NULL
;
5740 result
= do_spec_1 (spec
, 0, soft_matched_part
);
5747 /* Process the given spec string and add any new options to the end
5748 of the switches/n_switches array. */
5751 do_option_spec (const char *name
, const char *spec
)
5753 unsigned int i
, value_count
, value_len
;
5754 const char *p
, *q
, *value
;
5755 char *tmp_spec
, *tmp_spec_p
;
5757 if (configure_default_options
[0].name
== NULL
)
5760 for (i
= 0; i
< ARRAY_SIZE (configure_default_options
); i
++)
5761 if (strcmp (configure_default_options
[i
].name
, name
) == 0)
5763 if (i
== ARRAY_SIZE (configure_default_options
))
5766 value
= configure_default_options
[i
].value
;
5767 value_len
= strlen (value
);
5769 /* Compute the size of the final spec. */
5772 while ((p
= strstr (p
, "%(VALUE)")) != NULL
)
5778 /* Replace each %(VALUE) by the specified value. */
5779 tmp_spec
= (char *) alloca (strlen (spec
) + 1
5780 + value_count
* (value_len
- strlen ("%(VALUE)")));
5781 tmp_spec_p
= tmp_spec
;
5783 while ((p
= strstr (q
, "%(VALUE)")) != NULL
)
5785 memcpy (tmp_spec_p
, q
, p
- q
);
5786 tmp_spec_p
= tmp_spec_p
+ (p
- q
);
5787 memcpy (tmp_spec_p
, value
, value_len
);
5788 tmp_spec_p
+= value_len
;
5789 q
= p
+ strlen ("%(VALUE)");
5791 strcpy (tmp_spec_p
, q
);
5793 do_self_spec (tmp_spec
);
5796 /* Process the given spec string and add any new options to the end
5797 of the switches/n_switches array. */
5800 do_self_spec (const char *spec
)
5804 do_spec_2 (spec
, NULL
);
5805 do_spec_1 (" ", 0, NULL
);
5807 /* Mark %<S switches processed by do_self_spec to be ignored permanently.
5808 do_self_specs adds the replacements to switches array, so it shouldn't
5809 be processed afterwards. */
5810 for (i
= 0; i
< n_switches
; i
++)
5811 if ((switches
[i
].live_cond
& SWITCH_IGNORE
))
5812 switches
[i
].live_cond
|= SWITCH_IGNORE_PERMANENTLY
;
5814 if (argbuf
.length () > 0)
5816 const char **argbuf_copy
;
5817 struct cl_decoded_option
*decoded_options
;
5818 struct cl_option_handlers handlers
;
5819 unsigned int decoded_options_count
;
5822 /* Create a copy of argbuf with a dummy argv[0] entry for
5823 decode_cmdline_options_to_array. */
5824 argbuf_copy
= XNEWVEC (const char *,
5825 argbuf
.length () + 1);
5826 argbuf_copy
[0] = "";
5827 memcpy (argbuf_copy
+ 1, argbuf
.address (),
5828 argbuf
.length () * sizeof (const char *));
5830 decode_cmdline_options_to_array (argbuf
.length () + 1,
5832 CL_DRIVER
, &decoded_options
,
5833 &decoded_options_count
);
5836 set_option_handlers (&handlers
);
5838 for (j
= 1; j
< decoded_options_count
; j
++)
5840 switch (decoded_options
[j
].opt_index
)
5842 case OPT_SPECIAL_input_file
:
5843 /* Specs should only generate options, not input
5845 if (strcmp (decoded_options
[j
].arg
, "-") != 0)
5846 fatal_error (input_location
,
5847 "switch %qs does not start with %<-%>",
5848 decoded_options
[j
].arg
);
5850 fatal_error (input_location
,
5851 "spec-generated switch is just %<-%>");
5854 case OPT_fcompare_debug_second
:
5855 case OPT_fcompare_debug
:
5856 case OPT_fcompare_debug_
:
5858 /* Avoid duplicate processing of some options from
5859 compare-debug specs; just save them here. */
5860 save_switch (decoded_options
[j
].canonical_option
[0],
5861 (decoded_options
[j
].canonical_option_num_elements
5863 &decoded_options
[j
].canonical_option
[1], false, true);
5867 read_cmdline_option (&global_options
, &global_options_set
,
5868 decoded_options
+ j
, UNKNOWN_LOCATION
,
5869 CL_DRIVER
, &handlers
, global_dc
);
5874 free (decoded_options
);
5877 switches
[n_switches
].part1
= 0;
5881 /* Callback for processing %D and %I specs. */
5883 struct spec_path_info
{
5888 bool separate_options
;
5892 spec_path (char *path
, void *data
)
5894 struct spec_path_info
*info
= (struct spec_path_info
*) data
;
5898 if (info
->omit_relative
&& !IS_ABSOLUTE_PATH (path
))
5901 if (info
->append_len
!= 0)
5903 len
= strlen (path
);
5904 memcpy (path
+ len
, info
->append
, info
->append_len
+ 1);
5907 if (!is_directory (path
, true))
5910 do_spec_1 (info
->option
, 1, NULL
);
5911 if (info
->separate_options
)
5912 do_spec_1 (" ", 0, NULL
);
5914 if (info
->append_len
== 0)
5916 len
= strlen (path
);
5917 save
= path
[len
- 1];
5918 if (IS_DIR_SEPARATOR (path
[len
- 1]))
5919 path
[len
- 1] = '\0';
5922 do_spec_1 (path
, 1, NULL
);
5923 do_spec_1 (" ", 0, NULL
);
5925 /* Must not damage the original path. */
5926 if (info
->append_len
== 0)
5927 path
[len
- 1] = save
;
5932 /* True if we should compile INFILE. */
5935 compile_input_file_p (struct infile
*infile
)
5937 if ((!infile
->language
) || (infile
->language
[0] != '*'))
5938 if (infile
->incompiler
== input_file_compiler
)
5943 /* Process each member of VEC as a spec. */
5946 do_specs_vec (vec
<char_p
> vec
)
5948 for (char *opt
: vec
)
5950 do_spec_1 (opt
, 1, NULL
);
5951 /* Make each accumulated option a separate argument. */
5952 do_spec_1 (" ", 0, NULL
);
5956 /* Add options passed via -Xassembler or -Wa to COLLECT_AS_OPTIONS. */
5959 putenv_COLLECT_AS_OPTIONS (vec
<char_p
> vec
)
5961 if (vec
.is_empty ())
5964 obstack_init (&collect_obstack
);
5965 obstack_grow (&collect_obstack
, "COLLECT_AS_OPTIONS=",
5966 strlen ("COLLECT_AS_OPTIONS="));
5971 FOR_EACH_VEC_ELT (vec
, ix
, opt
)
5973 obstack_1grow (&collect_obstack
, '\'');
5974 obstack_grow (&collect_obstack
, opt
, strlen (opt
));
5975 obstack_1grow (&collect_obstack
, '\'');
5976 if (ix
< vec
.length () - 1)
5977 obstack_1grow(&collect_obstack
, ' ');
5980 obstack_1grow (&collect_obstack
, '\0');
5981 xputenv (XOBFINISH (&collect_obstack
, char *));
5984 /* Process the sub-spec SPEC as a portion of a larger spec.
5985 This is like processing a whole spec except that we do
5986 not initialize at the beginning and we do not supply a
5987 newline by default at the end.
5988 INSWITCH nonzero means don't process %-sequences in SPEC;
5989 in this case, % is treated as an ordinary character.
5990 This is used while substituting switches.
5991 INSWITCH nonzero also causes SPC not to terminate an argument.
5993 Value is zero unless a line was finished
5994 and the command on that line reported an error. */
5997 do_spec_1 (const char *spec
, int inswitch
, const char *soft_matched_part
)
5999 const char *p
= spec
;
6004 /* If it's an empty string argument to a switch, keep it as is. */
6005 if (inswitch
&& !*p
)
6009 /* If substituting a switch, treat all chars like letters.
6010 Otherwise, NL, SPC, TAB and % are special. */
6011 switch (inswitch
? 'a' : c
)
6016 if (argbuf
.length () > 0
6017 && !strcmp (argbuf
.last (), "|"))
6019 /* A `|' before the newline means use a pipe here,
6020 but only if -pipe was specified.
6021 Otherwise, execute now and don't pass the `|' as an arg. */
6024 input_from_pipe
= 1;
6031 set_collect_gcc_options ();
6033 if (argbuf
.length () > 0)
6039 /* Reinitialize for a new command, and for a new argument. */
6042 delete_this_arg
= 0;
6043 this_is_output_file
= 0;
6044 this_is_library_file
= 0;
6045 this_is_linker_script
= 0;
6046 input_from_pipe
= 0;
6053 obstack_1grow (&obstack
, c
);
6061 /* Reinitialize for a new argument. */
6062 delete_this_arg
= 0;
6063 this_is_output_file
= 0;
6064 this_is_library_file
= 0;
6065 this_is_linker_script
= 0;
6072 fatal_error (input_location
, "spec %qs invalid", spec
);
6075 /* Don't use %b in the linker command. */
6076 gcc_assert (suffixed_basename_length
);
6077 if (!this_is_output_file
&& dumpdir_length
)
6078 obstack_grow (&obstack
, dumpdir
, dumpdir_length
);
6079 if (this_is_output_file
|| !outbase_length
)
6080 obstack_grow (&obstack
, input_basename
, basename_length
);
6082 obstack_grow (&obstack
, outbase
, outbase_length
);
6083 if (compare_debug
< 0)
6084 obstack_grow (&obstack
, ".gk", 3);
6089 /* Don't use %B in the linker command. */
6090 gcc_assert (suffixed_basename_length
);
6091 if (!this_is_output_file
&& dumpdir_length
)
6092 obstack_grow (&obstack
, dumpdir
, dumpdir_length
);
6093 if (this_is_output_file
|| !outbase_length
)
6094 obstack_grow (&obstack
, input_basename
, basename_length
);
6096 obstack_grow (&obstack
, outbase
, outbase_length
);
6097 if (compare_debug
< 0)
6098 obstack_grow (&obstack
, ".gk", 3);
6099 obstack_grow (&obstack
, input_basename
+ basename_length
,
6100 suffixed_basename_length
- basename_length
);
6106 delete_this_arg
= 2;
6109 /* Dump out the directories specified with LIBRARY_PATH,
6110 followed by the absolute directories
6111 that we search for startfiles. */
6114 struct spec_path_info info
;
6117 info
.append_len
= 0;
6118 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
6119 /* Used on systems which record the specified -L dirs
6120 and use them to search for dynamic linking.
6121 Relative directories always come from -B,
6122 and it is better not to use them for searching
6123 at run time. In particular, stage1 loses. */
6124 info
.omit_relative
= true;
6126 info
.omit_relative
= false;
6128 info
.separate_options
= false;
6130 for_each_path (&startfile_prefixes
, true, 0, spec_path
, &info
);
6135 /* %efoo means report an error with `foo' as error message
6136 and don't execute any more commands for this file. */
6140 while (*p
!= 0 && *p
!= '\n')
6142 buf
= (char *) alloca (p
- q
+ 1);
6143 strncpy (buf
, q
, p
- q
);
6145 error ("%s", _(buf
));
6150 /* %nfoo means report a notice with `foo' on stderr. */
6154 while (*p
!= 0 && *p
!= '\n')
6156 buf
= (char *) alloca (p
- q
+ 1);
6157 strncpy (buf
, q
, p
- q
);
6159 inform (UNKNOWN_LOCATION
, "%s", _(buf
));
6169 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
6170 defined, and it is not a directory, and it is
6171 writable, use it. Otherwise, treat this like any
6172 other temporary file. */
6174 if ((!save_temps_flag
)
6175 && (stat (HOST_BIT_BUCKET
, &st
) == 0) && (!S_ISDIR (st
.st_mode
))
6176 && (access (HOST_BIT_BUCKET
, W_OK
) == 0))
6178 obstack_grow (&obstack
, HOST_BIT_BUCKET
,
6179 strlen (HOST_BIT_BUCKET
));
6180 delete_this_arg
= 0;
6185 goto create_temp_file
;
6189 obstack_1grow (&obstack
, '-');
6190 delete_this_arg
= 0;
6193 /* consume suffix */
6194 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
6196 if (p
[0] == '%' && p
[1] == 'O')
6201 goto create_temp_file
;
6205 /* consume suffix */
6206 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
6208 if (p
[0] == '%' && p
[1] == 'O')
6213 goto create_temp_file
;
6219 struct temp_name
*t
;
6221 const char *suffix
= p
;
6222 char *saved_suffix
= NULL
;
6224 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
6226 suffix_length
= p
- suffix
;
6227 if (p
[0] == '%' && p
[1] == 'O')
6230 /* We don't support extra suffix characters after %O. */
6231 if (*p
== '.' || ISALNUM ((unsigned char) *p
))
6232 fatal_error (input_location
,
6233 "spec %qs has invalid %<%%0%c%>", spec
, *p
);
6234 if (suffix_length
== 0)
6235 suffix
= TARGET_OBJECT_SUFFIX
;
6239 = XNEWVEC (char, suffix_length
6240 + strlen (TARGET_OBJECT_SUFFIX
) + 1);
6241 strncpy (saved_suffix
, suffix
, suffix_length
);
6242 strcpy (saved_suffix
+ suffix_length
,
6243 TARGET_OBJECT_SUFFIX
);
6245 suffix_length
+= strlen (TARGET_OBJECT_SUFFIX
);
6248 if (compare_debug
< 0)
6250 suffix
= concat (".gk", suffix
, NULL
);
6254 /* If -save-temps was specified, use that for the
6256 if (save_temps_flag
)
6259 bool adjusted_suffix
= false;
6261 && !outbase_length
&& !basename_length
6262 && !dumpdir_trailing_dash_added
)
6264 adjusted_suffix
= true;
6268 temp_filename_length
6269 = dumpdir_length
+ suffix_length
+ 1;
6271 temp_filename_length
+= outbase_length
;
6273 temp_filename_length
+= basename_length
;
6274 tmp
= (char *) alloca (temp_filename_length
);
6276 memcpy (tmp
, dumpdir
, dumpdir_length
);
6278 memcpy (tmp
+ dumpdir_length
, outbase
,
6280 else if (basename_length
)
6281 memcpy (tmp
+ dumpdir_length
, input_basename
,
6283 memcpy (tmp
+ temp_filename_length
- suffix_length
- 1,
6284 suffix
, suffix_length
);
6285 if (adjusted_suffix
)
6287 adjusted_suffix
= false;
6291 tmp
[temp_filename_length
- 1] = '\0';
6292 temp_filename
= tmp
;
6294 if (filename_cmp (temp_filename
, gcc_input_filename
) != 0)
6296 #ifndef HOST_LACKS_INODE_NUMBERS
6297 struct stat st_temp
;
6299 /* Note, set_input() resets input_stat_set to 0. */
6300 if (input_stat_set
== 0)
6302 input_stat_set
= stat (gcc_input_filename
,
6304 if (input_stat_set
>= 0)
6308 /* If we have the stat for the gcc_input_filename
6309 and we can do the stat for the temp_filename
6310 then the they could still refer to the same
6311 file if st_dev/st_ino's are the same. */
6312 if (input_stat_set
!= 1
6313 || stat (temp_filename
, &st_temp
) < 0
6314 || input_stat
.st_dev
!= st_temp
.st_dev
6315 || input_stat
.st_ino
!= st_temp
.st_ino
)
6317 /* Just compare canonical pathnames. */
6318 char* input_realname
= lrealpath (gcc_input_filename
);
6319 char* temp_realname
= lrealpath (temp_filename
);
6320 bool files_differ
= filename_cmp (input_realname
, temp_realname
);
6321 free (input_realname
);
6322 free (temp_realname
);
6327 = save_string (temp_filename
,
6328 temp_filename_length
- 1);
6329 obstack_grow (&obstack
, temp_filename
,
6330 temp_filename_length
);
6332 delete_this_arg
= 0;
6338 /* See if we already have an association of %g/%u/%U and
6340 for (t
= temp_names
; t
; t
= t
->next
)
6341 if (t
->length
== suffix_length
6342 && strncmp (t
->suffix
, suffix
, suffix_length
) == 0
6343 && t
->unique
== (c
== 'u' || c
== 'U' || c
== 'j'))
6346 /* Make a new association if needed. %u and %j
6348 if (t
== 0 || c
== 'u' || c
== 'j')
6352 t
= XNEW (struct temp_name
);
6353 t
->next
= temp_names
;
6356 t
->length
= suffix_length
;
6359 t
->suffix
= saved_suffix
;
6360 saved_suffix
= NULL
;
6363 t
->suffix
= save_string (suffix
, suffix_length
);
6364 t
->unique
= (c
== 'u' || c
== 'U' || c
== 'j');
6365 temp_filename
= make_temp_file (t
->suffix
);
6366 temp_filename_length
= strlen (temp_filename
);
6367 t
->filename
= temp_filename
;
6368 t
->filename_length
= temp_filename_length
;
6371 free (saved_suffix
);
6373 obstack_grow (&obstack
, t
->filename
, t
->filename_length
);
6374 delete_this_arg
= 1;
6382 /* We are going to expand `%i' into `@FILE', where FILE
6383 is a newly-created temporary filename. The filenames
6384 that would usually be expanded in place of %o will be
6385 written to the temporary file. */
6386 if (at_file_supplied
)
6389 for (i
= 0; (int) i
< n_infiles
; i
++)
6390 if (compile_input_file_p (&infiles
[i
]))
6392 store_arg (infiles
[i
].name
, 0, 0);
6393 infiles
[i
].compiled
= true;
6396 if (at_file_supplied
)
6401 obstack_grow (&obstack
, gcc_input_filename
,
6402 input_filename_length
);
6409 struct spec_path_info info
;
6413 do_spec_1 ("-imultilib", 1, NULL
);
6414 /* Make this a separate argument. */
6415 do_spec_1 (" ", 0, NULL
);
6416 do_spec_1 (multilib_dir
, 1, NULL
);
6417 do_spec_1 (" ", 0, NULL
);
6422 do_spec_1 ("-imultiarch", 1, NULL
);
6423 /* Make this a separate argument. */
6424 do_spec_1 (" ", 0, NULL
);
6425 do_spec_1 (multiarch_dir
, 1, NULL
);
6426 do_spec_1 (" ", 0, NULL
);
6429 if (gcc_exec_prefix
)
6431 do_spec_1 ("-iprefix", 1, NULL
);
6432 /* Make this a separate argument. */
6433 do_spec_1 (" ", 0, NULL
);
6434 do_spec_1 (gcc_exec_prefix
, 1, NULL
);
6435 do_spec_1 (" ", 0, NULL
);
6438 if (target_system_root_changed
||
6439 (target_system_root
&& target_sysroot_hdrs_suffix
))
6441 do_spec_1 ("-isysroot", 1, NULL
);
6442 /* Make this a separate argument. */
6443 do_spec_1 (" ", 0, NULL
);
6444 do_spec_1 (target_system_root
, 1, NULL
);
6445 if (target_sysroot_hdrs_suffix
)
6446 do_spec_1 (target_sysroot_hdrs_suffix
, 1, NULL
);
6447 do_spec_1 (" ", 0, NULL
);
6450 info
.option
= "-isystem";
6451 info
.append
= "include";
6452 info
.append_len
= strlen (info
.append
);
6453 info
.omit_relative
= false;
6454 info
.separate_options
= true;
6456 for_each_path (&include_prefixes
, false, info
.append_len
,
6459 info
.append
= "include-fixed";
6460 if (*sysroot_hdrs_suffix_spec
)
6461 info
.append
= concat (info
.append
, dir_separator_str
,
6462 multilib_dir
, NULL
);
6463 info
.append_len
= strlen (info
.append
);
6464 for_each_path (&include_prefixes
, false, info
.append_len
,
6470 /* We are going to expand `%o' into `@FILE', where FILE
6471 is a newly-created temporary filename. The filenames
6472 that would usually be expanded in place of %o will be
6473 written to the temporary file. */
6474 if (at_file_supplied
)
6477 for (i
= 0; i
< n_infiles
+ lang_specific_extra_outfiles
; i
++)
6479 store_arg (outfiles
[i
], 0, 0);
6481 if (at_file_supplied
)
6486 obstack_grow (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
6491 this_is_library_file
= 1;
6495 this_is_linker_script
= 1;
6499 outfiles
[input_file_number
] = NULL
;
6503 this_is_output_file
= 1;
6508 unsigned int cur_index
= argbuf
.length ();
6509 /* Handle the {...} following the %W. */
6511 fatal_error (input_location
,
6512 "spec %qs has invalid %<%%W%c%>", spec
, *p
);
6513 p
= handle_braces (p
+ 1);
6517 /* If any args were output, mark the last one for deletion
6519 if (argbuf
.length () != cur_index
)
6520 record_temp_file (argbuf
.last (), 0, 1);
6525 /* Handle the {...} following the %@. */
6527 fatal_error (input_location
,
6528 "spec %qs has invalid %<%%@%c%>", spec
, *p
);
6529 if (at_file_supplied
)
6531 p
= handle_braces (p
+ 1);
6532 if (at_file_supplied
)
6538 /* %x{OPTION} records OPTION for %X to output. */
6544 /* Skip past the option value and make a copy. */
6546 fatal_error (input_location
,
6547 "spec %qs has invalid %<%%x%c%>", spec
, *p
);
6550 string
= save_string (p1
+ 1, p
- p1
- 2);
6552 /* See if we already recorded this option. */
6553 for (const char *opt
: linker_options
)
6554 if (! strcmp (string
, opt
))
6560 /* This option is new; add it. */
6561 add_linker_option (string
, strlen (string
));
6566 /* Dump out the options accumulated previously using %x. */
6568 do_specs_vec (linker_options
);
6571 /* Dump out the options accumulated previously using -Wa,. */
6573 do_specs_vec (assembler_options
);
6576 /* Dump out the options accumulated previously using -Wp,. */
6578 do_specs_vec (preprocessor_options
);
6581 /* Here are digits and numbers that just process
6582 a certain constant string as a spec. */
6585 value
= do_spec_1 (cc1_spec
, 0, NULL
);
6591 value
= do_spec_1 (cc1plus_spec
, 0, NULL
);
6597 value
= do_spec_1 (asm_spec
, 0, NULL
);
6603 value
= do_spec_1 (asm_final_spec
, 0, NULL
);
6610 const char *const spec
6611 = (input_file_compiler
->cpp_spec
6612 ? input_file_compiler
->cpp_spec
6614 value
= do_spec_1 (spec
, 0, NULL
);
6621 value
= do_spec_1 (endfile_spec
, 0, NULL
);
6627 value
= do_spec_1 (link_spec
, 0, NULL
);
6633 value
= do_spec_1 (lib_spec
, 0, NULL
);
6639 if (multilib_os_dir
== NULL
)
6640 obstack_1grow (&obstack
, '.');
6642 obstack_grow (&obstack
, multilib_os_dir
,
6643 strlen (multilib_os_dir
));
6647 value
= do_spec_1 (libgcc_spec
, 0, NULL
);
6653 /* We assume there is a directory
6654 separator at the end of this string. */
6655 if (target_system_root
)
6657 obstack_grow (&obstack
, target_system_root
,
6658 strlen (target_system_root
));
6659 if (target_sysroot_suffix
)
6660 obstack_grow (&obstack
, target_sysroot_suffix
,
6661 strlen (target_sysroot_suffix
));
6666 value
= do_spec_1 (startfile_spec
, 0, NULL
);
6671 /* Here we define characters other than letters and digits. */
6674 p
= handle_braces (p
);
6680 p
= handle_spec_function (p
, NULL
, soft_matched_part
);
6686 obstack_1grow (&obstack
, '%');
6693 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '%')
6695 suffix_subst
= save_string (p
- 1, len
+ 1);
6700 /* Henceforth ignore the option(s) matching the pattern
6706 int have_wildcard
= 0;
6711 switch_option
= SWITCH_IGNORE
| SWITCH_KEEP_FOR_GCC
;
6713 switch_option
= SWITCH_IGNORE
;
6715 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '\t')
6718 if (p
[len
-1] == '*')
6721 for (i
= 0; i
< n_switches
; i
++)
6722 if (!strncmp (switches
[i
].part1
, p
, len
- have_wildcard
)
6723 && (have_wildcard
|| switches
[i
].part1
[len
] == '\0'))
6725 switches
[i
].live_cond
|= switch_option
;
6726 /* User switch be validated from validate_all_switches.
6727 when the definition is seen from the spec file.
6728 If not defined anywhere, will be rejected. */
6729 if (switches
[i
].known
)
6730 switches
[i
].validated
= true;
6738 if (soft_matched_part
)
6740 if (soft_matched_part
[0])
6741 do_spec_1 (soft_matched_part
, 1, NULL
);
6742 /* Only insert a space after the substitution if it is at the
6743 end of the current sequence. So if:
6745 "%{foo=*:bar%*}%{foo=*:one%*two}"
6747 matches -foo=hello then it will produce:
6749 barhello onehellotwo
6751 if (*p
== 0 || *p
== '}')
6752 do_spec_1 (" ", 0, NULL
);
6755 /* Catch the case where a spec string contains something like
6756 '%{foo:%*}'. i.e. there is no * in the pattern on the left
6757 hand side of the :. */
6758 error ("spec failure: %<%%*%> has not been initialized by pattern match");
6761 /* Process a string found as the value of a spec given by name.
6762 This feature allows individual machine descriptions
6763 to add and use their own specs. */
6766 const char *name
= p
;
6767 struct spec_list
*sl
;
6770 /* The string after the S/P is the name of a spec that is to be
6772 while (*p
&& *p
!= ')')
6775 /* See if it's in the list. */
6776 for (len
= p
- name
, sl
= specs
; sl
; sl
= sl
->next
)
6777 if (sl
->name_len
== len
&& !strncmp (sl
->name
, name
, len
))
6779 name
= *(sl
->ptr_spec
);
6781 fnotice (stderr
, "Processing spec (%s), which is '%s'\n",
6789 value
= do_spec_1 (name
, 0, NULL
);
6794 /* Discard the closing paren. */
6801 /* End a previous argument, if there is one, then issue an
6809 error ("spec failure: unrecognized spec option %qc", c
);
6815 /* Backslash: treat next character as ordinary. */
6818 /* When adding more cases that previously matched default, make
6819 sure to adjust quote_spec_char_p as well. */
6823 /* Ordinary character: put it into the current argument. */
6824 obstack_1grow (&obstack
, c
);
6828 /* End of string. If we are processing a spec function, we need to
6829 end any pending argument. */
6830 if (processing_spec_function
)
6836 /* Look up a spec function. */
6838 static const struct spec_function
*
6839 lookup_spec_function (const char *name
)
6841 const struct spec_function
*sf
;
6843 for (sf
= static_spec_functions
; sf
->name
!= NULL
; sf
++)
6844 if (strcmp (sf
->name
, name
) == 0)
6850 /* Evaluate a spec function. */
6853 eval_spec_function (const char *func
, const char *args
,
6854 const char *soft_matched_part
)
6856 const struct spec_function
*sf
;
6857 const char *funcval
;
6859 /* Saved spec processing context. */
6860 vec
<const_char_p
> save_argbuf
;
6863 int save_delete_this_arg
;
6864 int save_this_is_output_file
;
6865 int save_this_is_library_file
;
6866 int save_input_from_pipe
;
6867 int save_this_is_linker_script
;
6868 const char *save_suffix_subst
;
6870 int save_growing_size
;
6871 void *save_growing_value
= NULL
;
6873 sf
= lookup_spec_function (func
);
6875 fatal_error (input_location
, "unknown spec function %qs", func
);
6877 /* Push the spec processing context. */
6878 save_argbuf
= argbuf
;
6880 save_arg_going
= arg_going
;
6881 save_delete_this_arg
= delete_this_arg
;
6882 save_this_is_output_file
= this_is_output_file
;
6883 save_this_is_library_file
= this_is_library_file
;
6884 save_this_is_linker_script
= this_is_linker_script
;
6885 save_input_from_pipe
= input_from_pipe
;
6886 save_suffix_subst
= suffix_subst
;
6888 /* If we have some object growing now, finalize it so the args and function
6889 eval proceed from a cleared context. This is needed to prevent the first
6890 constructed arg from mistakenly including the growing value. We'll push
6891 this value back on the obstack once the function evaluation is done, to
6892 restore a consistent processing context for our caller. This is fine as
6893 the address of growing objects isn't guaranteed to remain stable until
6894 they are finalized, and we expect this situation to be rare enough for
6895 the extra copy not to be an issue. */
6896 save_growing_size
= obstack_object_size (&obstack
);
6897 if (save_growing_size
> 0)
6898 save_growing_value
= obstack_finish (&obstack
);
6900 /* Create a new spec processing context, and build the function
6904 if (do_spec_2 (args
, soft_matched_part
) < 0)
6905 fatal_error (input_location
, "error in arguments to spec function %qs",
6908 /* argbuf_index is an index for the next argument to be inserted, and
6909 so contains the count of the args already inserted. */
6911 funcval
= (*sf
->func
) (argbuf
.length (),
6914 /* Pop the spec processing context. */
6916 argbuf
= save_argbuf
;
6918 arg_going
= save_arg_going
;
6919 delete_this_arg
= save_delete_this_arg
;
6920 this_is_output_file
= save_this_is_output_file
;
6921 this_is_library_file
= save_this_is_library_file
;
6922 this_is_linker_script
= save_this_is_linker_script
;
6923 input_from_pipe
= save_input_from_pipe
;
6924 suffix_subst
= save_suffix_subst
;
6926 if (save_growing_size
> 0)
6927 obstack_grow (&obstack
, save_growing_value
, save_growing_size
);
6932 /* Handle a spec function call of the form:
6936 ARGS is processed as a spec in a separate context and split into an
6937 argument vector in the normal fashion. The function returns a string
6938 containing a spec which we then process in the caller's context, or
6939 NULL if no processing is required.
6941 If RETVAL_NONNULL is not NULL, then store a bool whether function
6944 SOFT_MATCHED_PART holds the current value of a matched * pattern, which
6945 may be re-expanded with a %* as part of the function arguments. */
6948 handle_spec_function (const char *p
, bool *retval_nonnull
,
6949 const char *soft_matched_part
)
6952 const char *endp
, *funcval
;
6955 processing_spec_function
++;
6957 /* Get the function name. */
6958 for (endp
= p
; *endp
!= '\0'; endp
++)
6960 if (*endp
== '(') /* ) */
6962 /* Only allow [A-Za-z0-9], -, and _ in function names. */
6963 if (!ISALNUM (*endp
) && !(*endp
== '-' || *endp
== '_'))
6964 fatal_error (input_location
, "malformed spec function name");
6966 if (*endp
!= '(') /* ) */
6967 fatal_error (input_location
, "no arguments for spec function");
6968 func
= save_string (p
, endp
- p
);
6971 /* Get the arguments. */
6972 for (count
= 0; *endp
!= '\0'; endp
++)
6981 else if (*endp
== '(') /* ) */
6986 fatal_error (input_location
, "malformed spec function arguments");
6987 args
= save_string (p
, endp
- p
);
6990 /* p now points to just past the end of the spec function expression. */
6992 funcval
= eval_spec_function (func
, args
, soft_matched_part
);
6993 if (funcval
!= NULL
&& do_spec_1 (funcval
, 0, NULL
) < 0)
6996 *retval_nonnull
= funcval
!= NULL
;
7001 processing_spec_function
--;
7006 /* Inline subroutine of handle_braces. Returns true if the current
7007 input suffix matches the atom bracketed by ATOM and END_ATOM. */
7009 input_suffix_matches (const char *atom
, const char *end_atom
)
7011 return (input_suffix
7012 && !strncmp (input_suffix
, atom
, end_atom
- atom
)
7013 && input_suffix
[end_atom
- atom
] == '\0');
7016 /* Subroutine of handle_braces. Returns true if the current
7017 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
7019 input_spec_matches (const char *atom
, const char *end_atom
)
7021 return (input_file_compiler
7022 && input_file_compiler
->suffix
7023 && input_file_compiler
->suffix
[0] != '\0'
7024 && !strncmp (input_file_compiler
->suffix
+ 1, atom
,
7026 && input_file_compiler
->suffix
[end_atom
- atom
+ 1] == '\0');
7029 /* Subroutine of handle_braces. Returns true if a switch
7030 matching the atom bracketed by ATOM and END_ATOM appeared on the
7033 switch_matches (const char *atom
, const char *end_atom
, int starred
)
7036 int len
= end_atom
- atom
;
7037 int plen
= starred
? len
: -1;
7039 for (i
= 0; i
< n_switches
; i
++)
7040 if (!strncmp (switches
[i
].part1
, atom
, len
)
7041 && (starred
|| switches
[i
].part1
[len
] == '\0')
7042 && check_live_switch (i
, plen
))
7045 /* Check if a switch with separated form matching the atom.
7046 We check -D and -U switches. */
7047 else if (switches
[i
].args
!= 0)
7049 if ((*switches
[i
].part1
== 'D' || *switches
[i
].part1
== 'U')
7050 && *switches
[i
].part1
== atom
[0])
7052 if (!strncmp (switches
[i
].args
[0], &atom
[1], len
- 1)
7053 && (starred
|| (switches
[i
].part1
[1] == '\0'
7054 && switches
[i
].args
[0][len
- 1] == '\0'))
7055 && check_live_switch (i
, (starred
? 1 : -1)))
7063 /* Inline subroutine of handle_braces. Mark all of the switches which
7064 match ATOM (extends to END_ATOM; STARRED indicates whether there
7065 was a star after the atom) for later processing. */
7067 mark_matching_switches (const char *atom
, const char *end_atom
, int starred
)
7070 int len
= end_atom
- atom
;
7071 int plen
= starred
? len
: -1;
7073 for (i
= 0; i
< n_switches
; i
++)
7074 if (!strncmp (switches
[i
].part1
, atom
, len
)
7075 && (starred
|| switches
[i
].part1
[len
] == '\0')
7076 && check_live_switch (i
, plen
))
7077 switches
[i
].ordering
= 1;
7080 /* Inline subroutine of handle_braces. Process all the currently
7081 marked switches through give_switch, and clear the marks. */
7083 process_marked_switches (void)
7087 for (i
= 0; i
< n_switches
; i
++)
7088 if (switches
[i
].ordering
== 1)
7090 switches
[i
].ordering
= 0;
7095 /* Handle a %{ ... } construct. P points just inside the leading {.
7096 Returns a pointer one past the end of the brace block, or 0
7097 if we call do_spec_1 and that returns -1. */
7100 handle_braces (const char *p
)
7102 const char *atom
, *end_atom
;
7103 const char *d_atom
= NULL
, *d_end_atom
= NULL
;
7104 char *esc_buf
= NULL
, *d_esc_buf
= NULL
;
7106 const char *orig
= p
;
7114 bool a_must_be_last
= false;
7115 bool ordered_set
= false;
7116 bool disjunct_set
= false;
7117 bool disj_matched
= false;
7118 bool disj_starred
= true;
7119 bool n_way_choice
= false;
7120 bool n_way_matched
= false;
7122 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7129 /* Scan one "atom" (S in the description above of %{}, possibly
7130 with '!', '.', '@', ',', or '*' modifiers). */
7132 a_is_suffix
= false;
7133 a_is_starred
= false;
7134 a_is_negated
= false;
7135 a_is_spectype
= false;
7139 p
++, a_is_negated
= true;
7142 if (*p
== '%' && p
[1] == ':')
7146 p
= handle_spec_function (p
+ 2, &a_matched
, NULL
);
7151 p
++, a_is_suffix
= true;
7153 p
++, a_is_spectype
= true;
7157 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
7158 || *p
== ',' || *p
== '.' || *p
== '@' || *p
== '\\')
7164 fatal_error (input_location
,
7165 "braced spec %qs ends in escape", orig
);
7177 if (esc_buf
&& esc_buf
!= d_esc_buf
)
7180 ep
= esc_buf
= (char *) xmalloc (end_atom
- atom
- esc
+ 1);
7181 for (ap
= atom
; ap
!= end_atom
; ap
++, ep
++)
7193 p
++, a_is_starred
= 1;
7200 /* Substitute the switch(es) indicated by the current atom. */
7202 if (disjunct_set
|| n_way_choice
|| a_is_negated
|| a_is_suffix
7203 || a_is_spectype
|| atom
== end_atom
)
7206 mark_matching_switches (atom
, end_atom
, a_is_starred
);
7209 process_marked_switches ();
7213 /* Substitute some text if the current atom appears as a switch
7215 disjunct_set
= true;
7219 if (atom
&& atom
== end_atom
)
7221 if (!n_way_choice
|| disj_matched
|| *p
== '|'
7222 || a_is_negated
|| a_is_suffix
|| a_is_spectype
7226 /* An empty term may appear as the last choice of an
7227 N-way choice set; it means "otherwise". */
7228 a_must_be_last
= true;
7229 disj_matched
= !n_way_matched
;
7230 disj_starred
= false;
7234 if ((a_is_suffix
|| a_is_spectype
) && a_is_starred
)
7238 disj_starred
= false;
7240 /* Don't bother testing this atom if we already have a
7242 if (!disj_matched
&& !n_way_matched
)
7245 /* a_matched is already set by handle_spec_function. */;
7246 else if (a_is_suffix
)
7247 a_matched
= input_suffix_matches (atom
, end_atom
);
7248 else if (a_is_spectype
)
7249 a_matched
= input_spec_matches (atom
, end_atom
);
7251 a_matched
= switch_matches (atom
, end_atom
, a_is_starred
);
7253 if (a_matched
!= a_is_negated
)
7255 disj_matched
= true;
7257 d_end_atom
= end_atom
;
7258 d_esc_buf
= esc_buf
;
7265 /* Found the body, that is, the text to substitute if the
7266 current disjunction matches. */
7267 p
= process_brace_body (p
+ 1, d_atom
, d_end_atom
, disj_starred
,
7268 disj_matched
&& !n_way_matched
);
7272 /* If we have an N-way choice, reset state for the next
7276 n_way_choice
= true;
7277 n_way_matched
|= disj_matched
;
7278 disj_matched
= false;
7279 disj_starred
= true;
7280 d_atom
= d_end_atom
= NULL
;
7289 while (*p
++ != '}');
7292 if (d_esc_buf
&& d_esc_buf
!= esc_buf
)
7300 fatal_error (input_location
, "braced spec %qs is invalid at %qc", orig
, *p
);
7305 /* Subroutine of handle_braces. Scan and process a brace substitution body
7306 (X in the description of %{} syntax). P points one past the colon;
7307 ATOM and END_ATOM bracket the first atom which was found to be true
7308 (present) in the current disjunction; STARRED indicates whether all
7309 the atoms in the current disjunction were starred (for syntax validation);
7310 MATCHED indicates whether the disjunction matched or not, and therefore
7311 whether or not the body is to be processed through do_spec_1 or just
7312 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
7316 process_brace_body (const char *p
, const char *atom
, const char *end_atom
,
7317 int starred
, int matched
)
7319 const char *body
, *end_body
;
7320 unsigned int nesting_level
;
7321 bool have_subst
= false;
7323 /* Locate the closing } or ;, honoring nested braces.
7324 Trim trailing whitespace. */
7333 if (!--nesting_level
)
7336 else if (*p
== ';' && nesting_level
== 1)
7338 else if (*p
== '%' && p
[1] == '*' && nesting_level
== 1)
7340 else if (*p
== '\0')
7346 while (end_body
[-1] == ' ' || end_body
[-1] == '\t')
7349 if (have_subst
&& !starred
)
7354 /* Copy the substitution body to permanent storage and execute it.
7355 If have_subst is false, this is a simple matter of running the
7356 body through do_spec_1... */
7357 char *string
= save_string (body
, end_body
- body
);
7360 if (do_spec_1 (string
, 0, NULL
) < 0)
7368 /* ... but if have_subst is true, we have to process the
7369 body once for each matching switch, with %* set to the
7370 variant part of the switch. */
7371 unsigned int hard_match_len
= end_atom
- atom
;
7374 for (i
= 0; i
< n_switches
; i
++)
7375 if (!strncmp (switches
[i
].part1
, atom
, hard_match_len
)
7376 && check_live_switch (i
, hard_match_len
))
7378 if (do_spec_1 (string
, 0,
7379 &switches
[i
].part1
[hard_match_len
]) < 0)
7384 /* Pass any arguments this switch has. */
7386 suffix_subst
= NULL
;
7395 fatal_error (input_location
, "braced spec body %qs is invalid", body
);
7398 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
7399 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
7400 spec, or -1 if either exact match or %* is used.
7402 A -O switch is obsoleted by a later -O switch. A -f, -g, -m, or -W switch
7403 whose value does not begin with "no-" is obsoleted by the same value
7404 with the "no-", similarly for a switch with the "no-" prefix. */
7407 check_live_switch (int switchnum
, int prefix_length
)
7409 const char *name
= switches
[switchnum
].part1
;
7412 /* If we already processed this switch and determined if it was
7413 live or not, return our past determination. */
7414 if (switches
[switchnum
].live_cond
!= 0)
7415 return ((switches
[switchnum
].live_cond
& SWITCH_LIVE
) != 0
7416 && (switches
[switchnum
].live_cond
& SWITCH_FALSE
) == 0
7417 && (switches
[switchnum
].live_cond
& SWITCH_IGNORE_PERMANENTLY
)
7420 /* In the common case of {<at-most-one-letter>*}, a negating
7421 switch would always match, so ignore that case. We will just
7422 send the conflicting switches to the compiler phase. */
7423 if (prefix_length
>= 0 && prefix_length
<= 1)
7426 /* Now search for duplicate in a manner that depends on the name. */
7430 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
7431 if (switches
[i
].part1
[0] == 'O')
7433 switches
[switchnum
].validated
= true;
7434 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
7439 case 'W': case 'f': case 'm': case 'g':
7440 if (startswith (name
+ 1, "no-"))
7442 /* We have Xno-YYY, search for XYYY. */
7443 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
7444 if (switches
[i
].part1
[0] == name
[0]
7445 && ! strcmp (&switches
[i
].part1
[1], &name
[4]))
7447 /* --specs are validated with the validate_switches mechanism. */
7448 if (switches
[switchnum
].known
)
7449 switches
[switchnum
].validated
= true;
7450 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
7456 /* We have XYYY, search for Xno-YYY. */
7457 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
7458 if (switches
[i
].part1
[0] == name
[0]
7459 && switches
[i
].part1
[1] == 'n'
7460 && switches
[i
].part1
[2] == 'o'
7461 && switches
[i
].part1
[3] == '-'
7462 && !strcmp (&switches
[i
].part1
[4], &name
[1]))
7464 /* --specs are validated with the validate_switches mechanism. */
7465 if (switches
[switchnum
].known
)
7466 switches
[switchnum
].validated
= true;
7467 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
7474 /* Otherwise the switch is live. */
7475 switches
[switchnum
].live_cond
|= SWITCH_LIVE
;
7479 /* Pass a switch to the current accumulating command
7480 in the same form that we received it.
7481 SWITCHNUM identifies the switch; it is an index into
7482 the vector of switches gcc received, which is `switches'.
7483 This cannot fail since it never finishes a command line.
7485 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
7488 give_switch (int switchnum
, int omit_first_word
)
7490 if ((switches
[switchnum
].live_cond
& SWITCH_IGNORE
) != 0)
7493 if (!omit_first_word
)
7495 do_spec_1 ("-", 0, NULL
);
7496 do_spec_1 (switches
[switchnum
].part1
, 1, NULL
);
7499 if (switches
[switchnum
].args
!= 0)
7502 for (p
= switches
[switchnum
].args
; *p
; p
++)
7504 const char *arg
= *p
;
7506 do_spec_1 (" ", 0, NULL
);
7509 unsigned length
= strlen (arg
);
7512 while (length
-- && !IS_DIR_SEPARATOR (arg
[length
]))
7513 if (arg
[length
] == '.')
7515 (CONST_CAST (char *, arg
))[length
] = 0;
7519 do_spec_1 (arg
, 1, NULL
);
7521 (CONST_CAST (char *, arg
))[length
] = '.';
7522 do_spec_1 (suffix_subst
, 1, NULL
);
7525 do_spec_1 (arg
, 1, NULL
);
7529 do_spec_1 (" ", 0, NULL
);
7530 switches
[switchnum
].validated
= true;
7533 /* Print GCC configuration (e.g. version, thread model, target,
7534 configuration_arguments) to a given FILE. */
7537 print_configuration (FILE *file
)
7542 fnotice (file
, "Target: %s\n", spec_machine
);
7543 fnotice (file
, "Configured with: %s\n", configuration_arguments
);
7545 #ifdef THREAD_MODEL_SPEC
7546 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
7547 but there's no point in doing all this processing just to get
7548 thread_model back. */
7549 obstack_init (&obstack
);
7550 do_spec_1 (THREAD_MODEL_SPEC
, 0, thread_model
);
7551 obstack_1grow (&obstack
, '\0');
7552 thrmod
= XOBFINISH (&obstack
, const char *);
7554 thrmod
= thread_model
;
7557 fnotice (file
, "Thread model: %s\n", thrmod
);
7558 fnotice (file
, "Supported LTO compression algorithms: zlib");
7560 fnotice (file
, " zstd");
7562 fnotice (file
, "\n");
7564 /* compiler_version is truncated at the first space when initialized
7565 from version string, so truncate version_string at the first space
7566 before comparing. */
7567 for (n
= 0; version_string
[n
]; n
++)
7568 if (version_string
[n
] == ' ')
7571 if (! strncmp (version_string
, compiler_version
, n
)
7572 && compiler_version
[n
] == 0)
7573 fnotice (file
, "gcc version %s %s\n", version_string
,
7576 fnotice (file
, "gcc driver version %s %sexecuting gcc version %s\n",
7577 version_string
, pkgversion_string
, compiler_version
);
7581 #define RETRY_ICE_ATTEMPTS 3
7583 /* Returns true if FILE1 and FILE2 contain equivalent data, 0 otherwise. */
7586 files_equal_p (char *file1
, char *file2
)
7588 struct stat st1
, st2
;
7591 const int bufsize
= 8192;
7592 char *buf
= XNEWVEC (char, bufsize
);
7594 fd1
= open (file1
, O_RDONLY
);
7595 fd2
= open (file2
, O_RDONLY
);
7597 if (fd1
< 0 || fd2
< 0)
7600 if (fstat (fd1
, &st1
) < 0 || fstat (fd2
, &st2
) < 0)
7603 if (st1
.st_size
!= st2
.st_size
)
7606 for (n
= st1
.st_size
; n
; n
-= len
)
7609 if ((int) len
> bufsize
/ 2)
7612 if (read (fd1
, buf
, len
) != (int) len
7613 || read (fd2
, buf
+ bufsize
/ 2, len
) != (int) len
)
7618 if (memcmp (buf
, buf
+ bufsize
/ 2, len
) != 0)
7635 /* Check that compiler's output doesn't differ across runs.
7636 TEMP_STDOUT_FILES and TEMP_STDERR_FILES are arrays of files, containing
7637 stdout and stderr for each compiler run. Return true if all of
7638 TEMP_STDOUT_FILES and TEMP_STDERR_FILES are equivalent. */
7641 check_repro (char **temp_stdout_files
, char **temp_stderr_files
)
7644 for (i
= 0; i
< RETRY_ICE_ATTEMPTS
- 2; ++i
)
7646 if (!files_equal_p (temp_stdout_files
[i
], temp_stdout_files
[i
+ 1])
7647 || !files_equal_p (temp_stderr_files
[i
], temp_stderr_files
[i
+ 1]))
7649 fnotice (stderr
, "The bug is not reproducible, so it is"
7650 " likely a hardware or OS problem.\n");
7654 return i
== RETRY_ICE_ATTEMPTS
- 2;
7657 enum attempt_status
{
7658 ATTEMPT_STATUS_FAIL_TO_RUN
,
7659 ATTEMPT_STATUS_SUCCESS
,
7664 /* Run compiler with arguments NEW_ARGV to reproduce the ICE, storing stdout
7665 to OUT_TEMP and stderr to ERR_TEMP. If APPEND is TRUE, append to OUT_TEMP
7666 and ERR_TEMP instead of truncating. If EMIT_SYSTEM_INFO is TRUE, also write
7667 GCC configuration into to ERR_TEMP. Return ATTEMPT_STATUS_FAIL_TO_RUN if
7668 compiler failed to run, ATTEMPT_STATUS_ICE if compiled ICE-ed and
7669 ATTEMPT_STATUS_SUCCESS otherwise. */
7671 static enum attempt_status
7672 run_attempt (const char **new_argv
, const char *out_temp
,
7673 const char *err_temp
, int emit_system_info
, int append
)
7676 if (emit_system_info
)
7678 FILE *file_out
= fopen (err_temp
, "a");
7679 print_configuration (file_out
);
7680 fputs ("\n", file_out
);
7686 struct pex_obj
*pex
;
7688 int pex_flags
= PEX_USE_PIPES
| PEX_LAST
;
7689 enum attempt_status status
= ATTEMPT_STATUS_FAIL_TO_RUN
;
7692 pex_flags
|= PEX_STDOUT_APPEND
| PEX_STDERR_APPEND
;
7694 pex
= pex_init (PEX_USE_PIPES
, new_argv
[0], NULL
);
7696 fatal_error (input_location
, "%<pex_init%> failed: %m");
7698 errmsg
= pex_run (pex
, pex_flags
, new_argv
[0],
7699 CONST_CAST2 (char *const *, const char **, &new_argv
[1]),
7700 out_temp
, err_temp
, &err
);
7704 fatal_error (input_location
,
7705 err
? G_ ("cannot execute %qs: %s: %m")
7706 : G_ ("cannot execute %qs: %s"),
7707 new_argv
[0], errmsg
);
7710 if (!pex_get_status (pex
, 1, &exit_status
))
7713 switch (WEXITSTATUS (exit_status
))
7716 status
= ATTEMPT_STATUS_ICE
;
7719 case SUCCESS_EXIT_CODE
:
7720 status
= ATTEMPT_STATUS_SUCCESS
;
7732 /* This routine reads lines from IN file, adds C++ style comments
7733 at the begining of each line and writes result into OUT. */
7736 insert_comments (const char *file_in
, const char *file_out
)
7738 FILE *in
= fopen (file_in
, "rb");
7739 FILE *out
= fopen (file_out
, "wb");
7742 bool add_comment
= true;
7743 while (fgets (line
, sizeof (line
), in
))
7748 add_comment
= strchr (line
, '\n') != NULL
;
7755 /* This routine adds preprocessed source code into the given ERR_FILE.
7756 To do this, it adds "-E" to NEW_ARGV and execute RUN_ATTEMPT routine to
7757 add information in report file. RUN_ATTEMPT should return
7758 ATTEMPT_STATUS_SUCCESS, in other case we cannot generate the report. */
7761 do_report_bug (const char **new_argv
, const int nargs
,
7762 char **out_file
, char **err_file
)
7765 int fd
= open (*out_file
, O_RDWR
| O_APPEND
);
7768 write (fd
, "\n//", 3);
7769 for (i
= 0; i
< nargs
; i
++)
7772 write (fd
, new_argv
[i
], strlen (new_argv
[i
]));
7774 write (fd
, "\n\n", 2);
7776 new_argv
[nargs
] = "-E";
7777 new_argv
[nargs
+ 1] = NULL
;
7779 status
= run_attempt (new_argv
, *out_file
, *err_file
, 0, 1);
7781 if (status
== ATTEMPT_STATUS_SUCCESS
)
7783 fnotice (stderr
, "Preprocessed source stored into %s file,"
7784 " please attach this to your bugreport.\n", *out_file
);
7785 /* Make sure it is not deleted. */
7791 /* Try to reproduce ICE. If bug is reproducible, generate report .err file
7792 containing GCC configuration, backtrace, compiler's command line options
7793 and preprocessed source code. */
7796 try_generate_repro (const char **argv
)
7798 int i
, nargs
, out_arg
= -1, quiet
= 0, attempt
;
7799 const char **new_argv
;
7800 char *temp_files
[RETRY_ICE_ATTEMPTS
* 2];
7801 char **temp_stdout_files
= &temp_files
[0];
7802 char **temp_stderr_files
= &temp_files
[RETRY_ICE_ATTEMPTS
];
7804 if (gcc_input_filename
== NULL
|| ! strcmp (gcc_input_filename
, "-"))
7807 for (nargs
= 0; argv
[nargs
] != NULL
; ++nargs
)
7808 /* Only retry compiler ICEs, not preprocessor ones. */
7809 if (! strcmp (argv
[nargs
], "-E"))
7811 else if (argv
[nargs
][0] == '-' && argv
[nargs
][1] == 'o')
7818 /* If the compiler is going to output any time information,
7819 it might varry between invocations. */
7820 else if (! strcmp (argv
[nargs
], "-quiet"))
7822 else if (! strcmp (argv
[nargs
], "-ftime-report"))
7825 if (out_arg
== -1 || !quiet
)
7828 memset (temp_files
, '\0', sizeof (temp_files
));
7829 new_argv
= XALLOCAVEC (const char *, nargs
+ 4);
7830 memcpy (new_argv
, argv
, (nargs
+ 1) * sizeof (const char *));
7831 new_argv
[nargs
++] = "-frandom-seed=0";
7832 new_argv
[nargs
++] = "-fdump-noaddr";
7833 new_argv
[nargs
] = NULL
;
7834 if (new_argv
[out_arg
][2] == '\0')
7835 new_argv
[out_arg
+ 1] = "-";
7837 new_argv
[out_arg
] = "-o-";
7840 for (attempt
= 0; attempt
< RETRY_ICE_ATTEMPTS
; ++attempt
)
7842 int emit_system_info
= 0;
7844 temp_stdout_files
[attempt
] = make_temp_file (".out");
7845 temp_stderr_files
[attempt
] = make_temp_file (".err");
7847 if (attempt
== RETRY_ICE_ATTEMPTS
- 1)
7850 emit_system_info
= 1;
7853 status
= run_attempt (new_argv
, temp_stdout_files
[attempt
],
7854 temp_stderr_files
[attempt
], emit_system_info
,
7857 if (status
!= ATTEMPT_STATUS_ICE
)
7859 fnotice (stderr
, "The bug is not reproducible, so it is"
7860 " likely a hardware or OS problem.\n");
7865 if (!check_repro (temp_stdout_files
, temp_stderr_files
))
7869 /* Insert commented out backtrace into report file. */
7870 char **stderr_commented
= &temp_stdout_files
[RETRY_ICE_ATTEMPTS
- 1];
7871 insert_comments (temp_stderr_files
[RETRY_ICE_ATTEMPTS
- 1],
7874 /* In final attempt we append compiler options and preprocesssed code to last
7875 generated .out file with configuration and backtrace. */
7876 char **err
= &temp_stderr_files
[RETRY_ICE_ATTEMPTS
- 1];
7877 do_report_bug (new_argv
, nargs
, stderr_commented
, err
);
7881 for (i
= 0; i
< RETRY_ICE_ATTEMPTS
* 2; i
++)
7884 unlink (temp_stdout_files
[i
]);
7885 free (temp_stdout_files
[i
]);
7889 /* Search for a file named NAME trying various prefixes including the
7890 user's -B prefix and some standard ones.
7891 Return the absolute file name found. If nothing is found, return NAME. */
7894 find_file (const char *name
)
7896 char *newname
= find_a_file (&startfile_prefixes
, name
, R_OK
, true);
7897 return newname
? newname
: name
;
7900 /* Determine whether a directory exists. If LINKER, return 0 for
7901 certain fixed names not needed by the linker. */
7904 is_directory (const char *path1
, bool linker
)
7911 /* Ensure the string ends with "/.". The resulting path will be a
7912 directory even if the given path is a symbolic link. */
7913 len1
= strlen (path1
);
7914 path
= (char *) alloca (3 + len1
);
7915 memcpy (path
, path1
, len1
);
7917 if (!IS_DIR_SEPARATOR (cp
[-1]))
7918 *cp
++ = DIR_SEPARATOR
;
7922 /* Exclude directories that the linker is known to search. */
7924 && IS_DIR_SEPARATOR (path
[0])
7926 && filename_ncmp (path
+ 1, "lib", 3) == 0)
7928 && filename_ncmp (path
+ 1, "usr", 3) == 0
7929 && IS_DIR_SEPARATOR (path
[4])
7930 && filename_ncmp (path
+ 5, "lib", 3) == 0)))
7933 return (stat (path
, &st
) >= 0 && S_ISDIR (st
.st_mode
));
7936 /* Set up the various global variables to indicate that we're processing
7937 the input file named FILENAME. */
7940 set_input (const char *filename
)
7944 gcc_input_filename
= filename
;
7945 input_filename_length
= strlen (gcc_input_filename
);
7946 input_basename
= lbasename (gcc_input_filename
);
7948 /* Find a suffix starting with the last period,
7949 and set basename_length to exclude that suffix. */
7950 basename_length
= strlen (input_basename
);
7951 suffixed_basename_length
= basename_length
;
7952 p
= input_basename
+ basename_length
;
7953 while (p
!= input_basename
&& *p
!= '.')
7955 if (*p
== '.' && p
!= input_basename
)
7957 basename_length
= p
- input_basename
;
7958 input_suffix
= p
+ 1;
7963 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
7964 we will need to do a stat on the gcc_input_filename. The
7965 INPUT_STAT_SET signals that the stat is needed. */
7969 /* On fatal signals, delete all the temporary files. */
7972 fatal_signal (int signum
)
7974 signal (signum
, SIG_DFL
);
7975 delete_failure_queue ();
7976 delete_temp_files ();
7977 /* Get the same signal again, this time not handled,
7978 so its normal effect occurs. */
7979 kill (getpid (), signum
);
7982 /* Compare the contents of the two files named CMPFILE[0] and
7983 CMPFILE[1]. Return zero if they're identical, nonzero
7987 compare_files (char *cmpfile
[])
7990 FILE *temp
[2] = { NULL
, NULL
};
7996 void *map
[2] = { NULL
, NULL
};
7998 for (i
= 0; i
< 2; i
++)
8002 if (stat (cmpfile
[i
], &st
) < 0 || !S_ISREG (st
.st_mode
))
8004 error ("%s: could not determine length of compare-debug file %s",
8005 gcc_input_filename
, cmpfile
[i
]);
8010 length
[i
] = st
.st_size
;
8013 if (!ret
&& length
[0] != length
[1])
8015 error ("%s: %<-fcompare-debug%> failure (length)", gcc_input_filename
);
8020 for (i
= 0; i
< 2; i
++)
8022 int fd
= open (cmpfile
[i
], O_RDONLY
);
8025 error ("%s: could not open compare-debug file %s",
8026 gcc_input_filename
, cmpfile
[i
]);
8031 map
[i
] = mmap (NULL
, length
[i
], PROT_READ
, MAP_PRIVATE
, fd
, 0);
8034 if (map
[i
] == (void *) MAP_FAILED
)
8043 if (memcmp (map
[0], map
[1], length
[0]) != 0)
8045 error ("%s: %<-fcompare-debug%> failure", gcc_input_filename
);
8050 for (i
= 0; i
< 2; i
++)
8052 munmap ((caddr_t
) map
[i
], length
[i
]);
8061 for (i
= 0; i
< 2; i
++)
8063 temp
[i
] = fopen (cmpfile
[i
], "r");
8066 error ("%s: could not open compare-debug file %s",
8067 gcc_input_filename
, cmpfile
[i
]);
8073 if (!ret
&& temp
[0] && temp
[1])
8077 c0
= fgetc (temp
[0]);
8078 c1
= fgetc (temp
[1]);
8082 error ("%s: %<-fcompare-debug%> failure",
8083 gcc_input_filename
);
8092 for (i
= 1; i
>= 0; i
--)
8101 driver::driver (bool can_finalize
, bool debug
) :
8102 explicit_link_files (NULL
),
8103 decoded_options (NULL
)
8105 env
.init (can_finalize
, debug
);
8110 XDELETEVEC (explicit_link_files
);
8111 XDELETEVEC (decoded_options
);
8114 /* driver::main is implemented as a series of driver:: method calls. */
8117 driver::main (int argc
, char **argv
)
8121 set_progname (argv
[0]);
8122 expand_at_files (&argc
, &argv
);
8123 decode_argv (argc
, const_cast <const char **> (argv
));
8124 global_initializations ();
8125 build_multilib_strings ();
8127 putenv_COLLECT_AS_OPTIONS (assembler_options
);
8128 putenv_COLLECT_GCC (argv
[0]);
8129 maybe_putenv_COLLECT_LTO_WRAPPER ();
8130 maybe_putenv_OFFLOAD_TARGETS ();
8131 handle_unrecognized_options ();
8135 m_option_proposer
.suggest_completion (completion
);
8139 if (!maybe_print_and_exit ())
8142 early_exit
= prepare_infiles ();
8144 return get_exit_code ();
8146 do_spec_on_infiles ();
8147 maybe_run_linker (argv
[0]);
8149 return get_exit_code ();
8152 /* Locate the final component of argv[0] after any leading path, and set
8153 the program name accordingly. */
8156 driver::set_progname (const char *argv0
) const
8158 const char *p
= argv0
+ strlen (argv0
);
8159 while (p
!= argv0
&& !IS_DIR_SEPARATOR (p
[-1]))
8163 xmalloc_set_program_name (progname
);
8166 /* Expand any @ files within the command-line args,
8167 setting at_file_supplied if any were expanded. */
8170 driver::expand_at_files (int *argc
, char ***argv
) const
8172 char **old_argv
= *argv
;
8174 expandargv (argc
, argv
);
8176 /* Determine if any expansions were made. */
8177 if (*argv
!= old_argv
)
8178 at_file_supplied
= true;
8181 /* Decode the command-line arguments from argc/argv into the
8182 decoded_options array. */
8185 driver::decode_argv (int argc
, const char **argv
)
8187 init_opts_obstack ();
8188 init_options_struct (&global_options
, &global_options_set
);
8190 decode_cmdline_options_to_array (argc
, argv
,
8192 &decoded_options
, &decoded_options_count
);
8195 /* Perform various initializations and setup. */
8198 driver::global_initializations ()
8200 /* Unlock the stdio streams. */
8201 unlock_std_streams ();
8203 gcc_init_libintl ();
8205 diagnostic_initialize (global_dc
, 0);
8206 diagnostic_color_init (global_dc
);
8207 diagnostic_urls_init (global_dc
);
8209 #ifdef GCC_DRIVER_HOST_INITIALIZATION
8210 /* Perform host dependent initialization when needed. */
8211 GCC_DRIVER_HOST_INITIALIZATION
;
8214 if (atexit (delete_temp_files
) != 0)
8215 fatal_error (input_location
, "atexit failed");
8217 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
8218 signal (SIGINT
, fatal_signal
);
8220 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
8221 signal (SIGHUP
, fatal_signal
);
8223 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
8224 signal (SIGTERM
, fatal_signal
);
8226 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
8227 signal (SIGPIPE
, fatal_signal
);
8230 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
8231 receive the signal. A different setting is inheritable */
8232 signal (SIGCHLD
, SIG_DFL
);
8235 /* Parsing and gimplification sometimes need quite large stack.
8236 Increase stack size limits if possible. */
8237 stack_limit_increase (64 * 1024 * 1024);
8239 /* Allocate the argument vector. */
8242 obstack_init (&obstack
);
8245 /* Build multilib_select, et. al from the separate lines that make up each
8246 multilib selection. */
8249 driver::build_multilib_strings () const
8253 const char *const *q
= multilib_raw
;
8256 obstack_init (&multilib_obstack
);
8257 while ((p
= *q
++) != (char *) 0)
8258 obstack_grow (&multilib_obstack
, p
, strlen (p
));
8260 obstack_1grow (&multilib_obstack
, 0);
8261 multilib_select
= XOBFINISH (&multilib_obstack
, const char *);
8263 q
= multilib_matches_raw
;
8264 while ((p
= *q
++) != (char *) 0)
8265 obstack_grow (&multilib_obstack
, p
, strlen (p
));
8267 obstack_1grow (&multilib_obstack
, 0);
8268 multilib_matches
= XOBFINISH (&multilib_obstack
, const char *);
8270 q
= multilib_exclusions_raw
;
8271 while ((p
= *q
++) != (char *) 0)
8272 obstack_grow (&multilib_obstack
, p
, strlen (p
));
8274 obstack_1grow (&multilib_obstack
, 0);
8275 multilib_exclusions
= XOBFINISH (&multilib_obstack
, const char *);
8277 q
= multilib_reuse_raw
;
8278 while ((p
= *q
++) != (char *) 0)
8279 obstack_grow (&multilib_obstack
, p
, strlen (p
));
8281 obstack_1grow (&multilib_obstack
, 0);
8282 multilib_reuse
= XOBFINISH (&multilib_obstack
, const char *);
8285 for (size_t i
= 0; i
< ARRAY_SIZE (multilib_defaults_raw
); i
++)
8288 obstack_1grow (&multilib_obstack
, ' ');
8289 obstack_grow (&multilib_obstack
,
8290 multilib_defaults_raw
[i
],
8291 strlen (multilib_defaults_raw
[i
]));
8295 obstack_1grow (&multilib_obstack
, 0);
8296 multilib_defaults
= XOBFINISH (&multilib_obstack
, const char *);
8300 /* Set up the spec-handling machinery. */
8303 driver::set_up_specs () const
8305 const char *spec_machine_suffix
;
8309 #ifdef INIT_ENVIRONMENT
8310 /* Set up any other necessary machine specific environment variables. */
8311 xputenv (INIT_ENVIRONMENT
);
8314 /* Make a table of what switches there are (switches, n_switches).
8315 Make a table of specified input files (infiles, n_infiles).
8316 Decode switches that are handled locally. */
8318 process_command (decoded_options_count
, decoded_options
);
8320 /* Initialize the vector of specs to just the default.
8321 This means one element containing 0s, as a terminator. */
8323 compilers
= XNEWVAR (struct compiler
, sizeof default_compilers
);
8324 memcpy (compilers
, default_compilers
, sizeof default_compilers
);
8325 n_compilers
= n_default_compilers
;
8327 /* Read specs from a file if there is one. */
8329 machine_suffix
= concat (spec_host_machine
, dir_separator_str
, spec_version
,
8330 accel_dir_suffix
, dir_separator_str
, NULL
);
8331 just_machine_suffix
= concat (spec_machine
, dir_separator_str
, NULL
);
8333 specs_file
= find_a_file (&startfile_prefixes
, "specs", R_OK
, true);
8334 /* Read the specs file unless it is a default one. */
8335 if (specs_file
!= 0 && strcmp (specs_file
, "specs"))
8336 read_specs (specs_file
, true, false);
8340 #ifdef ACCEL_COMPILER
8341 spec_machine_suffix
= machine_suffix
;
8343 spec_machine_suffix
= just_machine_suffix
;
8346 /* We need to check standard_exec_prefix/spec_machine_suffix/specs
8347 for any override of as, ld and libraries. */
8348 specs_file
= (char *) alloca (strlen (standard_exec_prefix
)
8349 + strlen (spec_machine_suffix
) + sizeof ("specs"));
8350 strcpy (specs_file
, standard_exec_prefix
);
8351 strcat (specs_file
, spec_machine_suffix
);
8352 strcat (specs_file
, "specs");
8353 if (access (specs_file
, R_OK
) == 0)
8354 read_specs (specs_file
, true, false);
8356 /* Process any configure-time defaults specified for the command line
8357 options, via OPTION_DEFAULT_SPECS. */
8358 for (i
= 0; i
< ARRAY_SIZE (option_default_specs
); i
++)
8359 do_option_spec (option_default_specs
[i
].name
,
8360 option_default_specs
[i
].spec
);
8362 /* Process DRIVER_SELF_SPECS, adding any new options to the end
8363 of the command line. */
8365 for (i
= 0; i
< ARRAY_SIZE (driver_self_specs
); i
++)
8366 do_self_spec (driver_self_specs
[i
]);
8368 /* If not cross-compiling, look for executables in the standard
8370 if (*cross_compile
== '0')
8372 if (*md_exec_prefix
)
8374 add_prefix (&exec_prefixes
, md_exec_prefix
, "GCC",
8375 PREFIX_PRIORITY_LAST
, 0, 0);
8379 /* Process sysroot_suffix_spec. */
8380 if (*sysroot_suffix_spec
!= 0
8381 && !no_sysroot_suffix
8382 && do_spec_2 (sysroot_suffix_spec
, NULL
) == 0)
8384 if (argbuf
.length () > 1)
8385 error ("spec failure: more than one argument to "
8386 "%<SYSROOT_SUFFIX_SPEC%>");
8387 else if (argbuf
.length () == 1)
8388 target_sysroot_suffix
= xstrdup (argbuf
.last ());
8391 #ifdef HAVE_LD_SYSROOT
8392 /* Pass the --sysroot option to the linker, if it supports that. If
8393 there is a sysroot_suffix_spec, it has already been processed by
8394 this point, so target_system_root really is the system root we
8396 if (target_system_root
)
8398 obstack_grow (&obstack
, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
8399 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
8400 set_spec ("link", XOBFINISH (&obstack
, const char *), false);
8404 /* Process sysroot_hdrs_suffix_spec. */
8405 if (*sysroot_hdrs_suffix_spec
!= 0
8406 && !no_sysroot_suffix
8407 && do_spec_2 (sysroot_hdrs_suffix_spec
, NULL
) == 0)
8409 if (argbuf
.length () > 1)
8410 error ("spec failure: more than one argument "
8411 "to %<SYSROOT_HEADERS_SUFFIX_SPEC%>");
8412 else if (argbuf
.length () == 1)
8413 target_sysroot_hdrs_suffix
= xstrdup (argbuf
.last ());
8416 /* Look for startfiles in the standard places. */
8417 if (*startfile_prefix_spec
!= 0
8418 && do_spec_2 (startfile_prefix_spec
, NULL
) == 0
8419 && do_spec_1 (" ", 0, NULL
) == 0)
8421 for (const char *arg
: argbuf
)
8422 add_sysrooted_prefix (&startfile_prefixes
, arg
, "BINUTILS",
8423 PREFIX_PRIORITY_LAST
, 0, 1);
8425 /* We should eventually get rid of all these and stick to
8426 startfile_prefix_spec exclusively. */
8427 else if (*cross_compile
== '0' || target_system_root
)
8429 if (*md_startfile_prefix
)
8430 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix
,
8431 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
8433 if (*md_startfile_prefix_1
)
8434 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix_1
,
8435 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
8437 /* If standard_startfile_prefix is relative, base it on
8438 standard_exec_prefix. This lets us move the installed tree
8439 as a unit. If GCC_EXEC_PREFIX is defined, base
8440 standard_startfile_prefix on that as well.
8442 If the prefix is relative, only search it for native compilers;
8443 otherwise we will search a directory containing host libraries. */
8444 if (IS_ABSOLUTE_PATH (standard_startfile_prefix
))
8445 add_sysrooted_prefix (&startfile_prefixes
,
8446 standard_startfile_prefix
, "BINUTILS",
8447 PREFIX_PRIORITY_LAST
, 0, 1);
8448 else if (*cross_compile
== '0')
8450 add_prefix (&startfile_prefixes
,
8451 concat (gcc_exec_prefix
8452 ? gcc_exec_prefix
: standard_exec_prefix
,
8454 standard_startfile_prefix
, NULL
),
8455 NULL
, PREFIX_PRIORITY_LAST
, 0, 1);
8458 /* Sysrooted prefixes are relocated because target_system_root is
8459 also relocated by gcc_exec_prefix. */
8460 if (*standard_startfile_prefix_1
)
8461 add_sysrooted_prefix (&startfile_prefixes
,
8462 standard_startfile_prefix_1
, "BINUTILS",
8463 PREFIX_PRIORITY_LAST
, 0, 1);
8464 if (*standard_startfile_prefix_2
)
8465 add_sysrooted_prefix (&startfile_prefixes
,
8466 standard_startfile_prefix_2
, "BINUTILS",
8467 PREFIX_PRIORITY_LAST
, 0, 1);
8470 /* Process any user specified specs in the order given on the command
8472 for (struct user_specs
*uptr
= user_specs_head
; uptr
; uptr
= uptr
->next
)
8474 char *filename
= find_a_file (&startfile_prefixes
, uptr
->filename
,
8476 read_specs (filename
? filename
: uptr
->filename
, false, true);
8479 /* Process any user self specs. */
8481 struct spec_list
*sl
;
8482 for (sl
= specs
; sl
; sl
= sl
->next
)
8483 if (sl
->name_len
== sizeof "self_spec" - 1
8484 && !strcmp (sl
->name
, "self_spec"))
8485 do_self_spec (*sl
->ptr_spec
);
8490 enum save_temps save
;
8492 if (!compare_debug_second
)
8494 n_switches_debug_check
[1] = n_switches
;
8495 n_switches_alloc_debug_check
[1] = n_switches_alloc
;
8496 switches_debug_check
[1] = XDUPVEC (struct switchstr
, switches
,
8499 do_self_spec ("%:compare-debug-self-opt()");
8500 n_switches_debug_check
[0] = n_switches
;
8501 n_switches_alloc_debug_check
[0] = n_switches_alloc
;
8502 switches_debug_check
[0] = switches
;
8504 n_switches
= n_switches_debug_check
[1];
8505 n_switches_alloc
= n_switches_alloc_debug_check
[1];
8506 switches
= switches_debug_check
[1];
8509 /* Avoid crash when computing %j in this early. */
8510 save
= save_temps_flag
;
8511 save_temps_flag
= SAVE_TEMPS_NONE
;
8513 compare_debug
= -compare_debug
;
8514 do_self_spec ("%:compare-debug-self-opt()");
8516 save_temps_flag
= save
;
8518 if (!compare_debug_second
)
8520 n_switches_debug_check
[1] = n_switches
;
8521 n_switches_alloc_debug_check
[1] = n_switches_alloc
;
8522 switches_debug_check
[1] = switches
;
8523 compare_debug
= -compare_debug
;
8524 n_switches
= n_switches_debug_check
[0];
8525 n_switches_alloc
= n_switches_debug_check
[0];
8526 switches
= switches_debug_check
[0];
8531 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
8532 if (gcc_exec_prefix
)
8533 gcc_exec_prefix
= concat (gcc_exec_prefix
, spec_host_machine
,
8534 dir_separator_str
, spec_version
,
8535 accel_dir_suffix
, dir_separator_str
, NULL
);
8537 /* Now we have the specs.
8538 Set the `valid' bits for switches that match anything in any spec. */
8540 validate_all_switches ();
8542 /* Now that we have the switches and the specs, set
8543 the subdirectory based on the options. */
8544 set_multilib_dir ();
8547 /* Set up to remember the pathname of gcc and any options
8548 needed for collect. We use argv[0] instead of progname because
8549 we need the complete pathname. */
8552 driver::putenv_COLLECT_GCC (const char *argv0
) const
8554 obstack_init (&collect_obstack
);
8555 obstack_grow (&collect_obstack
, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
8556 obstack_grow (&collect_obstack
, argv0
, strlen (argv0
) + 1);
8557 xputenv (XOBFINISH (&collect_obstack
, char *));
8560 /* Set up to remember the pathname of the lto wrapper. */
8563 driver::maybe_putenv_COLLECT_LTO_WRAPPER () const
8565 char *lto_wrapper_file
;
8568 lto_wrapper_file
= NULL
;
8570 lto_wrapper_file
= find_a_program ("lto-wrapper");
8571 if (lto_wrapper_file
)
8573 lto_wrapper_file
= convert_white_space (lto_wrapper_file
);
8574 set_static_spec_owned (<o_wrapper_spec
, lto_wrapper_file
);
8575 obstack_init (&collect_obstack
);
8576 obstack_grow (&collect_obstack
, "COLLECT_LTO_WRAPPER=",
8577 sizeof ("COLLECT_LTO_WRAPPER=") - 1);
8578 obstack_grow (&collect_obstack
, lto_wrapper_spec
,
8579 strlen (lto_wrapper_spec
) + 1);
8580 xputenv (XOBFINISH (&collect_obstack
, char *));
8585 /* Set up to remember the names of offload targets. */
8588 driver::maybe_putenv_OFFLOAD_TARGETS () const
8590 if (offload_targets
&& offload_targets
[0] != '\0')
8592 obstack_grow (&collect_obstack
, "OFFLOAD_TARGET_NAMES=",
8593 sizeof ("OFFLOAD_TARGET_NAMES=") - 1);
8594 obstack_grow (&collect_obstack
, offload_targets
,
8595 strlen (offload_targets
) + 1);
8596 xputenv (XOBFINISH (&collect_obstack
, char *));
8597 #if OFFLOAD_DEFAULTED
8598 if (offload_targets_default
)
8599 xputenv ("OFFLOAD_TARGET_DEFAULT=1");
8603 free (offload_targets
);
8604 offload_targets
= NULL
;
8607 /* Reject switches that no pass was interested in. */
8610 driver::handle_unrecognized_options ()
8612 for (size_t i
= 0; (int) i
< n_switches
; i
++)
8613 if (! switches
[i
].validated
)
8615 const char *hint
= m_option_proposer
.suggest_option (switches
[i
].part1
);
8617 error ("unrecognized command-line option %<-%s%>;"
8618 " did you mean %<-%s%>?",
8619 switches
[i
].part1
, hint
);
8621 error ("unrecognized command-line option %<-%s%>",
8626 /* Handle the various -print-* options, returning 0 if the driver
8627 should exit, or nonzero if the driver should continue. */
8630 driver::maybe_print_and_exit () const
8632 if (print_search_dirs
)
8634 printf (_("install: %s%s\n"),
8635 gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
8636 gcc_exec_prefix
? "" : machine_suffix
);
8637 printf (_("programs: %s\n"),
8638 build_search_list (&exec_prefixes
, "", false, false));
8639 printf (_("libraries: %s\n"),
8640 build_search_list (&startfile_prefixes
, "", false, true));
8644 if (print_file_name
)
8646 printf ("%s\n", find_file (print_file_name
));
8650 if (print_prog_name
)
8652 if (use_ld
!= NULL
&& ! strcmp (print_prog_name
, "ld"))
8654 /* Append USE_LD to the default linker. */
8655 #ifdef DEFAULT_LINKER
8657 # ifdef HAVE_HOST_EXECUTABLE_SUFFIX
8658 int len
= (sizeof (DEFAULT_LINKER
)
8659 - sizeof (HOST_EXECUTABLE_SUFFIX
));
8663 char *default_linker
= xstrdup (DEFAULT_LINKER
);
8664 /* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains
8665 HOST_EXECUTABLE_SUFFIX. */
8666 if (! strcmp (&default_linker
[len
], HOST_EXECUTABLE_SUFFIX
))
8668 default_linker
[len
] = '\0';
8669 ld
= concat (default_linker
, use_ld
,
8670 HOST_EXECUTABLE_SUFFIX
, NULL
);
8675 ld
= concat (DEFAULT_LINKER
, use_ld
, NULL
);
8676 if (access (ld
, X_OK
) == 0)
8678 printf ("%s\n", ld
);
8682 print_prog_name
= concat (print_prog_name
, use_ld
, NULL
);
8684 char *newname
= find_a_program (print_prog_name
);
8685 printf ("%s\n", (newname
? newname
: print_prog_name
));
8689 if (print_multi_lib
)
8691 print_multilib_info ();
8695 if (print_multi_directory
)
8697 if (multilib_dir
== NULL
)
8700 printf ("%s\n", multilib_dir
);
8704 if (print_multiarch
)
8706 if (multiarch_dir
== NULL
)
8709 printf ("%s\n", multiarch_dir
);
8715 if (target_system_root
)
8717 if (target_sysroot_suffix
)
8718 printf ("%s%s\n", target_system_root
, target_sysroot_suffix
);
8720 printf ("%s\n", target_system_root
);
8725 if (print_multi_os_directory
)
8727 if (multilib_os_dir
== NULL
)
8730 printf ("%s\n", multilib_os_dir
);
8734 if (print_sysroot_headers_suffix
)
8736 if (*sysroot_hdrs_suffix_spec
)
8738 printf("%s\n", (target_sysroot_hdrs_suffix
8739 ? target_sysroot_hdrs_suffix
8744 /* The error status indicates that only one set of fixed
8745 headers should be built. */
8746 fatal_error (input_location
,
8747 "not configured with sysroot headers suffix");
8750 if (print_help_list
)
8756 printf (_("\nFor bug reporting instructions, please see:\n"));
8757 printf ("%s.\n", bug_report_url
);
8762 /* We do not exit here. Instead we have created a fake input file
8763 called 'help-dummy' which needs to be compiled, and we pass this
8764 on the various sub-processes, along with the --help switch.
8765 Ensure their output appears after ours. */
8766 fputc ('\n', stdout
);
8772 printf (_("%s %s%s\n"), progname
, pkgversion_string
,
8774 printf ("Copyright %s 2021 Free Software Foundation, Inc.\n",
8776 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
8777 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
8782 /* We do not exit here. We use the same mechanism of --help to print
8783 the version of the sub-processes. */
8784 fputc ('\n', stdout
);
8790 print_configuration (stderr
);
8798 /* Figure out what to do with each input file.
8799 Return true if we need to exit early from "main", false otherwise. */
8802 driver::prepare_infiles ()
8805 int lang_n_infiles
= 0;
8807 if (n_infiles
== added_libraries
)
8808 fatal_error (input_location
, "no input files");
8811 /* Early exit needed from main. */
8814 /* Make a place to record the compiler output file names
8815 that correspond to the input files. */
8818 i
+= lang_specific_extra_outfiles
;
8819 outfiles
= XCNEWVEC (const char *, i
);
8821 /* Record which files were specified explicitly as link input. */
8823 explicit_link_files
= XCNEWVEC (char, n_infiles
);
8825 combine_inputs
= have_o
|| flag_wpa
;
8827 for (i
= 0; (int) i
< n_infiles
; i
++)
8829 const char *name
= infiles
[i
].name
;
8830 struct compiler
*compiler
= lookup_compiler (name
,
8832 infiles
[i
].language
);
8834 if (compiler
&& !(compiler
->combinable
))
8835 combine_inputs
= false;
8837 if (lang_n_infiles
> 0 && compiler
!= input_file_compiler
8838 && infiles
[i
].language
&& infiles
[i
].language
[0] != '*')
8839 infiles
[i
].incompiler
= compiler
;
8843 input_file_compiler
= compiler
;
8844 infiles
[i
].incompiler
= compiler
;
8848 /* Since there is no compiler for this input file, assume it is a
8850 explicit_link_files
[i
] = 1;
8851 infiles
[i
].incompiler
= NULL
;
8853 infiles
[i
].compiled
= false;
8854 infiles
[i
].preprocessed
= false;
8857 if (!combine_inputs
&& have_c
&& have_o
&& lang_n_infiles
> 1)
8858 fatal_error (input_location
,
8859 "cannot specify %<-o%> with %<-c%>, %<-S%> or %<-E%> "
8860 "with multiple files");
8862 /* No early exit needed from main; we can continue. */
8866 /* Run the spec machinery on each input file. */
8869 driver::do_spec_on_infiles () const
8873 for (i
= 0; (int) i
< n_infiles
; i
++)
8875 int this_file_error
= 0;
8877 /* Tell do_spec what to substitute for %i. */
8879 input_file_number
= i
;
8880 set_input (infiles
[i
].name
);
8882 if (infiles
[i
].compiled
)
8885 /* Use the same thing in %o, unless cp->spec says otherwise. */
8887 outfiles
[i
] = gcc_input_filename
;
8889 /* Figure out which compiler from the file's suffix. */
8892 = lookup_compiler (infiles
[i
].name
, input_filename_length
,
8893 infiles
[i
].language
);
8895 if (input_file_compiler
)
8897 /* Ok, we found an applicable compiler. Run its spec. */
8899 if (input_file_compiler
->spec
[0] == '#')
8901 error ("%s: %s compiler not installed on this system",
8902 gcc_input_filename
, &input_file_compiler
->spec
[1]);
8903 this_file_error
= 1;
8911 free (debug_check_temp_file
[0]);
8912 debug_check_temp_file
[0] = NULL
;
8914 free (debug_check_temp_file
[1]);
8915 debug_check_temp_file
[1] = NULL
;
8918 value
= do_spec (input_file_compiler
->spec
);
8919 infiles
[i
].compiled
= true;
8921 this_file_error
= 1;
8922 else if (compare_debug
&& debug_check_temp_file
[0])
8925 inform (UNKNOWN_LOCATION
,
8926 "recompiling with %<-fcompare-debug%>");
8928 compare_debug
= -compare_debug
;
8929 n_switches
= n_switches_debug_check
[1];
8930 n_switches_alloc
= n_switches_alloc_debug_check
[1];
8931 switches
= switches_debug_check
[1];
8933 value
= do_spec (input_file_compiler
->spec
);
8935 compare_debug
= -compare_debug
;
8936 n_switches
= n_switches_debug_check
[0];
8937 n_switches_alloc
= n_switches_alloc_debug_check
[0];
8938 switches
= switches_debug_check
[0];
8942 error ("during %<-fcompare-debug%> recompilation");
8943 this_file_error
= 1;
8946 gcc_assert (debug_check_temp_file
[1]
8947 && filename_cmp (debug_check_temp_file
[0],
8948 debug_check_temp_file
[1]));
8951 inform (UNKNOWN_LOCATION
, "comparing final insns dumps");
8953 if (compare_files (debug_check_temp_file
))
8954 this_file_error
= 1;
8959 free (debug_check_temp_file
[0]);
8960 debug_check_temp_file
[0] = NULL
;
8962 free (debug_check_temp_file
[1]);
8963 debug_check_temp_file
[1] = NULL
;
8968 /* If this file's name does not contain a recognized suffix,
8969 record it as explicit linker input. */
8972 explicit_link_files
[i
] = 1;
8974 /* Clear the delete-on-failure queue, deleting the files in it
8975 if this compilation failed. */
8977 if (this_file_error
)
8979 delete_failure_queue ();
8982 /* If this compilation succeeded, don't delete those files later. */
8983 clear_failure_queue ();
8986 /* Reset the input file name to the first compile/object file name, for use
8987 with %b in LINK_SPEC. We use the first input file that we can find
8988 a compiler to compile it instead of using infiles.language since for
8989 languages other than C we use aliases that we then lookup later. */
8994 for (i
= 0; i
< n_infiles
; i
++)
8995 if (infiles
[i
].incompiler
8996 || (infiles
[i
].language
&& infiles
[i
].language
[0] != '*'))
8998 set_input (infiles
[i
].name
);
9005 /* Make sure INPUT_FILE_NUMBER points to first available open
9007 input_file_number
= n_infiles
;
9008 if (lang_specific_pre_link ())
9013 /* If we have to run the linker, do it now. */
9016 driver::maybe_run_linker (const char *argv0
) const
9019 int linker_was_run
= 0;
9020 int num_linker_inputs
;
9022 /* Determine if there are any linker input files. */
9023 num_linker_inputs
= 0;
9024 for (i
= 0; (int) i
< n_infiles
; i
++)
9025 if (explicit_link_files
[i
] || outfiles
[i
] != NULL
)
9026 num_linker_inputs
++;
9028 /* Arrange for temporary file names created during linking to take
9029 on names related with the linker output rather than with the
9030 inputs when appropriate. */
9031 if (outbase
&& *outbase
)
9035 char *tofree
= dumpdir
;
9036 gcc_checking_assert (strlen (dumpdir
) == dumpdir_length
);
9037 dumpdir
= concat (dumpdir
, outbase
, ".", NULL
);
9041 dumpdir
= concat (outbase
, ".", NULL
);
9042 dumpdir_length
+= strlen (outbase
) + 1;
9043 dumpdir_trailing_dash_added
= true;
9045 else if (dumpdir_trailing_dash_added
)
9047 gcc_assert (dumpdir
[dumpdir_length
- 1] == '-');
9048 dumpdir
[dumpdir_length
- 1] = '.';
9051 if (dumpdir_trailing_dash_added
)
9053 gcc_assert (dumpdir_length
> 0);
9054 gcc_assert (dumpdir
[dumpdir_length
- 1] == '.');
9059 input_basename
= outbase
= NULL
;
9060 outbase_length
= suffixed_basename_length
= basename_length
= 0;
9062 /* Run ld to link all the compiler output files. */
9064 if (num_linker_inputs
> 0 && !seen_error () && print_subprocess_help
< 2)
9066 int tmp
= execution_count
;
9068 detect_jobserver ();
9072 #if HAVE_LTO_PLUGIN > 0
9073 #if HAVE_LTO_PLUGIN == 2
9074 const char *fno_use_linker_plugin
= "fno-use-linker-plugin";
9076 const char *fuse_linker_plugin
= "fuse-linker-plugin";
9080 /* We'll use ld if we can't find collect2. */
9081 if (! strcmp (linker_name_spec
, "collect2"))
9083 char *s
= find_a_program ("collect2");
9085 set_static_spec_shared (&linker_name_spec
, "ld");
9088 #if HAVE_LTO_PLUGIN > 0
9089 #if HAVE_LTO_PLUGIN == 2
9090 if (!switch_matches (fno_use_linker_plugin
,
9091 fno_use_linker_plugin
9092 + strlen (fno_use_linker_plugin
), 0))
9094 if (switch_matches (fuse_linker_plugin
,
9096 + strlen (fuse_linker_plugin
), 0))
9099 char *temp_spec
= find_a_file (&exec_prefixes
,
9100 LTOPLUGINSONAME
, R_OK
,
9103 fatal_error (input_location
,
9104 "%<-fuse-linker-plugin%>, but %s not found",
9106 linker_plugin_file_spec
= convert_white_space (temp_spec
);
9109 set_static_spec_shared (<o_gcc_spec
, argv0
);
9112 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
9114 putenv_from_prefixes (&exec_prefixes
, "COMPILER_PATH", false);
9115 putenv_from_prefixes (&startfile_prefixes
, LIBRARY_PATH_ENV
, true);
9117 if (print_subprocess_help
== 1)
9119 printf (_("\nLinker options\n==============\n\n"));
9120 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
9121 " to the linker.\n\n"));
9124 int value
= do_spec (link_command_spec
);
9127 linker_was_run
= (tmp
!= execution_count
);
9130 /* If options said don't run linker,
9131 complain about input files to be given to the linker. */
9133 if (! linker_was_run
&& !seen_error ())
9134 for (i
= 0; (int) i
< n_infiles
; i
++)
9135 if (explicit_link_files
[i
]
9136 && !(infiles
[i
].language
&& infiles
[i
].language
[0] == '*'))
9138 warning (0, "%s: linker input file unused because linking not done",
9140 if (access (outfiles
[i
], F_OK
) < 0)
9141 /* This is can be an indication the user specifed an errorneous
9142 separated option value, (or used the wrong prefix for an
9144 error ("%s: linker input file not found: %m", outfiles
[i
]);
9148 /* The end of "main". */
9151 driver::final_actions () const
9153 /* Delete some or all of the temporary files we made. */
9156 delete_failure_queue ();
9157 delete_temp_files ();
9159 if (print_help_list
)
9161 printf (("\nFor bug reporting instructions, please see:\n"));
9162 printf ("%s\n", bug_report_url
);
9166 /* Detect whether jobserver is active and working. If not drop
9167 --jobserver-auth from MAKEFLAGS. */
9170 driver::detect_jobserver () const
9172 /* Detect jobserver and drop it if it's not working. */
9173 const char *makeflags
= env
.get ("MAKEFLAGS");
9174 if (makeflags
!= NULL
)
9176 const char *needle
= "--jobserver-auth=";
9177 const char *n
= strstr (makeflags
, needle
);
9184 = (sscanf (n
+ strlen (needle
), "%d,%d", &rfd
, &wfd
) == 2
9187 && is_valid_fd (rfd
)
9188 && is_valid_fd (wfd
));
9190 /* Drop the jobserver if it's not working now. */
9193 unsigned offset
= n
- makeflags
;
9194 char *dup
= xstrdup (makeflags
);
9197 const char *space
= strchr (makeflags
+ offset
, ' ');
9199 strcpy (dup
+ offset
, space
);
9200 xputenv (concat ("MAKEFLAGS=", dup
, NULL
));
9206 /* Determine what the exit code of the driver should be. */
9209 driver::get_exit_code () const
9211 return (signal_count
!= 0 ? 2
9212 : seen_error () ? (pass_exit_codes
? greatest_status
: 1)
9216 /* Find the proper compilation spec for the file name NAME,
9217 whose length is LENGTH. LANGUAGE is the specified language,
9218 or 0 if this file is to be passed to the linker. */
9220 static struct compiler
*
9221 lookup_compiler (const char *name
, size_t length
, const char *language
)
9223 struct compiler
*cp
;
9225 /* If this was specified by the user to be a linker input, indicate that. */
9226 if (language
!= 0 && language
[0] == '*')
9229 /* Otherwise, look for the language, if one is spec'd. */
9232 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
9233 if (cp
->suffix
[0] == '@' && !strcmp (cp
->suffix
+ 1, language
))
9235 if (name
!= NULL
&& strcmp (name
, "-") == 0
9236 && (strcmp (cp
->suffix
, "@c-header") == 0
9237 || strcmp (cp
->suffix
, "@c++-header") == 0)
9239 fatal_error (input_location
,
9240 "cannot use %<-%> as input filename for a "
9241 "precompiled header");
9246 error ("language %s not recognized", language
);
9250 /* Look for a suffix. */
9251 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
9253 if (/* The suffix `-' matches only the file name `-'. */
9254 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
9255 || (strlen (cp
->suffix
) < length
9256 /* See if the suffix matches the end of NAME. */
9257 && !strcmp (cp
->suffix
,
9258 name
+ length
- strlen (cp
->suffix
))
9263 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
9264 /* Look again, but case-insensitively this time. */
9266 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
9268 if (/* The suffix `-' matches only the file name `-'. */
9269 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
9270 || (strlen (cp
->suffix
) < length
9271 /* See if the suffix matches the end of NAME. */
9272 && ((!strcmp (cp
->suffix
,
9273 name
+ length
- strlen (cp
->suffix
))
9274 || !strpbrk (cp
->suffix
, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
9275 && !strcasecmp (cp
->suffix
,
9276 name
+ length
- strlen (cp
->suffix
)))
9282 if (cp
>= compilers
)
9284 if (cp
->spec
[0] != '@')
9285 /* A non-alias entry: return it. */
9288 /* An alias entry maps a suffix to a language.
9289 Search for the language; pass 0 for NAME and LENGTH
9290 to avoid infinite recursion if language not found. */
9291 return lookup_compiler (NULL
, 0, cp
->spec
+ 1);
9297 save_string (const char *s
, int len
)
9299 char *result
= XNEWVEC (char, len
+ 1);
9301 gcc_checking_assert (strlen (s
) >= (unsigned int) len
);
9302 memcpy (result
, s
, len
);
9309 validate_switches_from_spec (const char *spec
, bool user
)
9311 const char *p
= spec
;
9317 || (*p
== 'W' && *++p
== '{')
9318 || (*p
== '@' && *++p
== '{')))
9319 /* We have a switch spec. */
9320 p
= validate_switches (p
+ 1, user
, *p
== '{');
9324 validate_all_switches (void)
9326 struct compiler
*comp
;
9327 struct spec_list
*spec
;
9329 for (comp
= compilers
; comp
->spec
; comp
++)
9330 validate_switches_from_spec (comp
->spec
, false);
9332 /* Look through the linked list of specs read from the specs file. */
9333 for (spec
= specs
; spec
; spec
= spec
->next
)
9334 validate_switches_from_spec (*spec
->ptr_spec
, spec
->user_p
);
9336 validate_switches_from_spec (link_command_spec
, false);
9339 /* Look at the switch-name that comes after START and mark as valid
9340 all supplied switches that match it. If BRACED, handle other
9341 switches after '|' and '&', and specs after ':' until ';' or '}',
9342 going back for more switches after ';'. Without BRACED, handle
9343 only one atom. Return a pointer to whatever follows the handled
9344 items, after the closing brace if BRACED. */
9347 validate_switches (const char *start
, bool user_spec
, bool braced
)
9349 const char *p
= start
;
9353 bool suffix
= false;
9354 bool starred
= false;
9356 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
9365 if (*p
== '.' || *p
== ',')
9369 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
9370 || *p
== ',' || *p
== '.' || *p
== '@')
9375 starred
= true, p
++;
9381 /* Mark all matching switches as valid. */
9382 for (i
= 0; i
< n_switches
; i
++)
9383 if (!strncmp (switches
[i
].part1
, atom
, len
)
9384 && (starred
|| switches
[i
].part1
[len
] == '\0')
9385 && (switches
[i
].known
|| user_spec
))
9386 switches
[i
].validated
= true;
9393 if (*p
&& (p
[-1] == '|' || p
[-1] == '&'))
9396 if (*p
&& p
[-1] == ':')
9398 while (*p
&& *p
!= ';' && *p
!= '}')
9403 if (*p
== '{' || *p
== '<')
9404 p
= validate_switches (p
+1, user_spec
, *p
== '{');
9405 else if (p
[0] == 'W' && p
[1] == '{')
9406 p
= validate_switches (p
+2, user_spec
, true);
9407 else if (p
[0] == '@' && p
[1] == '{')
9408 p
= validate_switches (p
+2, user_spec
, true);
9415 if (*p
&& p
[-1] == ';')
9429 static struct mdswitchstr
*mdswitches
;
9430 static int n_mdswitches
;
9432 /* Check whether a particular argument was used. The first time we
9433 canonicalize the switches to keep only the ones we care about. */
9438 int operator () (const char *p
, int len
);
9445 const char *replace
;
9450 mswitchstr
*mswitches
;
9455 used_arg_t used_arg
;
9458 used_arg_t::operator () (const char *p
, int len
)
9464 struct mswitchstr
*matches
;
9468 /* Break multilib_matches into the component strings of string
9469 and replacement string. */
9470 for (q
= multilib_matches
; *q
!= '\0'; q
++)
9475 = (struct mswitchstr
*) alloca ((sizeof (struct mswitchstr
)) * cnt
);
9477 q
= multilib_matches
;
9486 fatal_error (input_location
, "multilib spec %qs is invalid",
9491 matches
[i
].len
= q
- matches
[i
].str
;
9493 matches
[i
].replace
= ++q
;
9494 while (*q
!= ';' && *q
!= '\0')
9497 goto invalid_matches
;
9500 matches
[i
].rep_len
= q
- matches
[i
].replace
;
9506 /* Now build a list of the replacement string for switches that we care
9507 about. Make sure we allocate at least one entry. This prevents
9508 xmalloc from calling fatal, and prevents us from re-executing this
9511 = XNEWVEC (struct mswitchstr
, n_mdswitches
+ (n_switches
? n_switches
: 1));
9512 for (i
= 0; i
< n_switches
; i
++)
9513 if ((switches
[i
].live_cond
& SWITCH_IGNORE
) == 0)
9515 int xlen
= strlen (switches
[i
].part1
);
9516 for (j
= 0; j
< cnt
; j
++)
9517 if (xlen
== matches
[j
].len
9518 && ! strncmp (switches
[i
].part1
, matches
[j
].str
, xlen
))
9520 mswitches
[n_mswitches
].str
= matches
[j
].replace
;
9521 mswitches
[n_mswitches
].len
= matches
[j
].rep_len
;
9522 mswitches
[n_mswitches
].replace
= (char *) 0;
9523 mswitches
[n_mswitches
].rep_len
= 0;
9529 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
9530 on the command line nor any options mutually incompatible with
9532 for (i
= 0; i
< n_mdswitches
; i
++)
9536 for (q
= multilib_options
; *q
!= '\0'; *q
&& q
++)
9542 while (strncmp (q
, mdswitches
[i
].str
, mdswitches
[i
].len
) != 0
9543 || strchr (" /", q
[mdswitches
[i
].len
]) == NULL
)
9545 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
9552 if (*q
!= ' ' && *q
!= '\0')
9554 while (*r
!= ' ' && *r
!= '\0')
9557 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
9560 if (used_arg (r
, q
- r
))
9565 mswitches
[n_mswitches
].str
= mdswitches
[i
].str
;
9566 mswitches
[n_mswitches
].len
= mdswitches
[i
].len
;
9567 mswitches
[n_mswitches
].replace
= (char *) 0;
9568 mswitches
[n_mswitches
].rep_len
= 0;
9581 for (i
= 0; i
< n_mswitches
; i
++)
9582 if (len
== mswitches
[i
].len
&& ! strncmp (p
, mswitches
[i
].str
, len
))
9588 void used_arg_t::finalize ()
9590 XDELETEVEC (mswitches
);
9597 default_arg (const char *p
, int len
)
9601 for (i
= 0; i
< n_mdswitches
; i
++)
9602 if (len
== mdswitches
[i
].len
&& ! strncmp (p
, mdswitches
[i
].str
, len
))
9608 /* Work out the subdirectory to use based on the options. The format of
9609 multilib_select is a list of elements. Each element is a subdirectory
9610 name followed by a list of options followed by a semicolon. The format
9611 of multilib_exclusions is the same, but without the preceding
9612 directory. First gcc will check the exclusions, if none of the options
9613 beginning with an exclamation point are present, and all of the other
9614 options are present, then we will ignore this completely. Passing
9615 that, gcc will consider each multilib_select in turn using the same
9616 rules for matching the options. If a match is found, that subdirectory
9618 A subdirectory name is optionally followed by a colon and the corresponding
9622 set_multilib_dir (void)
9625 unsigned int this_path_len
;
9626 const char *this_path
, *this_arg
;
9627 const char *start
, *end
;
9629 int ok
, ndfltok
, first
;
9632 start
= multilib_defaults
;
9633 while (*start
== ' ' || *start
== '\t')
9635 while (*start
!= '\0')
9638 while (*start
!= ' ' && *start
!= '\t' && *start
!= '\0')
9640 while (*start
== ' ' || *start
== '\t')
9648 mdswitches
= XNEWVEC (struct mdswitchstr
, n_mdswitches
);
9649 for (start
= multilib_defaults
; *start
!= '\0'; start
= end
+ 1)
9651 while (*start
== ' ' || *start
== '\t')
9657 for (end
= start
+ 1;
9658 *end
!= ' ' && *end
!= '\t' && *end
!= '\0'; end
++)
9661 obstack_grow (&multilib_obstack
, start
, end
- start
);
9662 obstack_1grow (&multilib_obstack
, 0);
9663 mdswitches
[i
].str
= XOBFINISH (&multilib_obstack
, const char *);
9664 mdswitches
[i
++].len
= end
- start
;
9671 p
= multilib_exclusions
;
9674 /* Ignore newlines. */
9681 /* Check the arguments. */
9688 fatal_error (input_location
, "multilib exclusions %qs is invalid",
9689 multilib_exclusions
);
9699 while (*p
!= ' ' && *p
!= ';')
9702 goto invalid_exclusions
;
9706 if (*this_arg
!= '!')
9714 ok
= used_arg (this_arg
, p
- this_arg
);
9729 p
= multilib_select
;
9731 /* Append multilib reuse rules if any. With those rules, we can reuse
9732 one multilib for certain different options sets. */
9733 if (strlen (multilib_reuse
) > 0)
9734 p
= concat (p
, multilib_reuse
, NULL
);
9738 /* Ignore newlines. */
9745 /* Get the initial path. */
9752 fatal_error (input_location
, "multilib select %qs %qs is invalid",
9753 multilib_select
, multilib_reuse
);
9757 this_path_len
= p
- this_path
;
9759 /* Check the arguments. */
9766 goto invalid_select
;
9775 while (*p
!= ' ' && *p
!= ';')
9778 goto invalid_select
;
9782 if (*this_arg
!= '!')
9790 /* If this is a default argument, we can just ignore it.
9791 This is true even if this_arg begins with '!'. Beginning
9792 with '!' does not mean that this argument is necessarily
9793 inappropriate for this library: it merely means that
9794 there is a more specific library which uses this
9795 argument. If this argument is a default, we need not
9796 consider that more specific library. */
9797 ok
= used_arg (this_arg
, p
- this_arg
);
9804 if (default_arg (this_arg
, p
- this_arg
))
9813 if (this_path_len
!= 1
9814 || this_path
[0] != '.')
9816 char *new_multilib_dir
= XNEWVEC (char, this_path_len
+ 1);
9819 strncpy (new_multilib_dir
, this_path
, this_path_len
);
9820 new_multilib_dir
[this_path_len
] = '\0';
9821 q
= strchr (new_multilib_dir
, ':');
9824 multilib_dir
= new_multilib_dir
;
9831 const char *q
= this_path
, *end
= this_path
+ this_path_len
;
9833 while (q
< end
&& *q
!= ':')
9837 const char *q2
= q
+ 1, *ml_end
= end
;
9838 char *new_multilib_os_dir
;
9840 while (q2
< end
&& *q2
!= ':')
9844 if (ml_end
- q
== 1)
9845 multilib_os_dir
= xstrdup (".");
9848 new_multilib_os_dir
= XNEWVEC (char, ml_end
- q
);
9849 memcpy (new_multilib_os_dir
, q
+ 1, ml_end
- q
- 1);
9850 new_multilib_os_dir
[ml_end
- q
- 1] = '\0';
9851 multilib_os_dir
= new_multilib_os_dir
;
9854 if (q2
< end
&& *q2
== ':')
9856 char *new_multiarch_dir
= XNEWVEC (char, end
- q2
);
9857 memcpy (new_multiarch_dir
, q2
+ 1, end
- q2
- 1);
9858 new_multiarch_dir
[end
- q2
- 1] = '\0';
9859 multiarch_dir
= new_multiarch_dir
;
9868 if (multilib_dir
== NULL
&& multilib_os_dir
!= NULL
9869 && strcmp (multilib_os_dir
, ".") == 0)
9871 free (CONST_CAST (char *, multilib_os_dir
));
9872 multilib_os_dir
= NULL
;
9874 else if (multilib_dir
!= NULL
&& multilib_os_dir
== NULL
)
9875 multilib_os_dir
= multilib_dir
;
9878 /* Print out the multiple library subdirectory selection
9879 information. This prints out a series of lines. Each line looks
9880 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
9881 required. Only the desired options are printed out, the negative
9882 matches. The options are print without a leading dash. There are
9883 no spaces to make it easy to use the information in the shell.
9884 Each subdirectory is printed only once. This assumes the ordering
9885 generated by the genmultilib script. Also, we leave out ones that match
9889 print_multilib_info (void)
9891 const char *p
= multilib_select
;
9892 const char *last_path
= 0, *this_path
;
9895 unsigned int last_path_len
= 0;
9900 /* Ignore newlines. */
9907 /* Get the initial path. */
9914 fatal_error (input_location
,
9915 "multilib select %qs is invalid", multilib_select
);
9921 /* When --disable-multilib was used but target defines
9922 MULTILIB_OSDIRNAMES, entries starting with .: (and not starting
9923 with .:: for multiarch configurations) are there just to find
9924 multilib_os_dir, so skip them from output. */
9925 if (this_path
[0] == '.' && this_path
[1] == ':' && this_path
[2] != ':')
9928 /* Check for matches with the multilib_exclusions. We don't bother
9929 with the '!' in either list. If any of the exclusion rules match
9930 all of its options with the select rule, we skip it. */
9932 const char *e
= multilib_exclusions
;
9933 const char *this_arg
;
9938 /* Ignore newlines. */
9945 /* Check the arguments. */
9954 fatal_error (input_location
,
9955 "multilib exclusion %qs is invalid",
9956 multilib_exclusions
);
9967 while (*e
!= ' ' && *e
!= ';')
9970 goto invalid_exclusion
;
9978 int len
= e
- this_arg
;
9981 goto invalid_select
;
9985 while (*q
!= ' ' && *q
!= ';')
9988 goto invalid_select
;
9992 if (! strncmp (arg
, this_arg
,
9993 (len
< q
- arg
) ? q
- arg
: len
)
9994 || default_arg (this_arg
, e
- this_arg
))
10024 /* If this is a duplicate, skip it. */
10025 skip
= (last_path
!= 0
10026 && (unsigned int) (p
- this_path
) == last_path_len
10027 && ! filename_ncmp (last_path
, this_path
, last_path_len
));
10029 last_path
= this_path
;
10030 last_path_len
= p
- this_path
;
10033 /* If all required arguments are default arguments, and no default
10034 arguments appear in the ! argument list, then we can skip it.
10035 We will already have printed a directory identical to this one
10036 which does not require that default argument. */
10040 bool default_arg_ok
= false;
10048 goto invalid_select
;
10059 while (*q
!= ' ' && *q
!= ';')
10062 goto invalid_select
;
10066 if (default_arg (arg
, q
- arg
))
10068 /* Stop checking if any default arguments appeared in not
10072 default_arg_ok
= false;
10076 default_arg_ok
= true;
10080 /* Stop checking if any required argument is not provided by
10081 default arguments. */
10082 default_arg_ok
= false;
10090 /* Make sure all default argument is OK for this multi-lib set. */
10091 if (default_arg_ok
)
10101 for (p1
= last_path
; p1
< p
&& *p1
!= ':'; p1
++)
10112 goto invalid_select
;
10120 use_arg
= *p
!= '!';
10125 while (*p
!= ' ' && *p
!= ';')
10128 goto invalid_select
;
10140 /* If there are extra options, print them now. */
10141 if (multilib_extra
&& *multilib_extra
)
10143 int print_at
= TRUE
;
10146 for (q
= multilib_extra
; *q
!= '\0'; q
++)
10167 /* getenv built-in spec function.
10169 Returns the value of the environment variable given by its first argument,
10170 concatenated with the second argument. If the variable is not defined, a
10171 fatal error is issued unless such undefs are internally allowed, in which
10172 case the variable name prefixed by a '/' is used as the variable value.
10174 The leading '/' allows using the result at a spot where a full path would
10175 normally be expected and when the actual value doesn't really matter since
10176 undef vars are allowed. */
10178 static const char *
10179 getenv_spec_function (int argc
, const char **argv
)
10182 const char *varname
;
10192 value
= env
.get (varname
);
10194 /* If the variable isn't defined and this is allowed, craft our expected
10195 return value. Assume variable names used in specs strings don't contain
10196 any active spec character so don't need escaping. */
10197 if (!value
&& spec_undefvar_allowed
)
10199 result
= XNEWVAR (char, strlen(varname
) + 2);
10200 sprintf (result
, "/%s", varname
);
10205 fatal_error (input_location
,
10206 "environment variable %qs not defined", varname
);
10208 /* We have to escape every character of the environment variable so
10209 they are not interpreted as active spec characters. A
10210 particularly painful case is when we are reading a variable
10211 holding a windows path complete with \ separators. */
10212 len
= strlen (value
) * 2 + strlen (argv
[1]) + 1;
10213 result
= XNEWVAR (char, len
);
10214 for (ptr
= result
; *value
; ptr
+= 2)
10220 strcpy (ptr
, argv
[1]);
10225 /* if-exists built-in spec function.
10227 Checks to see if the file specified by the absolute pathname in
10228 ARGS exists. Returns that pathname if found.
10230 The usual use for this function is to check for a library file
10231 (whose name has been expanded with %s). */
10233 static const char *
10234 if_exists_spec_function (int argc
, const char **argv
)
10236 /* Must have only one argument. */
10237 if (argc
== 1 && IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
10243 /* if-exists-else built-in spec function.
10245 This is like if-exists, but takes an additional argument which
10246 is returned if the first argument does not exist. */
10248 static const char *
10249 if_exists_else_spec_function (int argc
, const char **argv
)
10251 /* Must have exactly two arguments. */
10255 if (IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
10261 /* if-exists-then-else built-in spec function.
10263 Checks to see if the file specified by the absolute pathname in
10264 the first arg exists. Returns the second arg if so, otherwise returns
10265 the third arg if it is present. */
10267 static const char *
10268 if_exists_then_else_spec_function (int argc
, const char **argv
)
10271 /* Must have two or three arguments. */
10272 if (argc
!= 2 && argc
!= 3)
10275 if (IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
10284 /* sanitize built-in spec function.
10286 This returns non-NULL, if sanitizing address, thread or
10287 any of the undefined behavior sanitizers. */
10289 static const char *
10290 sanitize_spec_function (int argc
, const char **argv
)
10295 if (strcmp (argv
[0], "address") == 0)
10296 return (flag_sanitize
& SANITIZE_USER_ADDRESS
) ? "" : NULL
;
10297 if (strcmp (argv
[0], "hwaddress") == 0)
10298 return (flag_sanitize
& SANITIZE_USER_HWADDRESS
) ? "" : NULL
;
10299 if (strcmp (argv
[0], "kernel-address") == 0)
10300 return (flag_sanitize
& SANITIZE_KERNEL_ADDRESS
) ? "" : NULL
;
10301 if (strcmp (argv
[0], "kernel-hwaddress") == 0)
10302 return (flag_sanitize
& SANITIZE_KERNEL_HWADDRESS
) ? "" : NULL
;
10303 if (strcmp (argv
[0], "thread") == 0)
10304 return (flag_sanitize
& SANITIZE_THREAD
) ? "" : NULL
;
10305 if (strcmp (argv
[0], "undefined") == 0)
10306 return ((flag_sanitize
10307 & (SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
))
10308 && !flag_sanitize_undefined_trap_on_error
) ? "" : NULL
;
10309 if (strcmp (argv
[0], "leak") == 0)
10310 return ((flag_sanitize
10311 & (SANITIZE_ADDRESS
| SANITIZE_LEAK
| SANITIZE_THREAD
))
10312 == SANITIZE_LEAK
) ? "" : NULL
;
10316 /* replace-outfile built-in spec function.
10318 This looks for the first argument in the outfiles array's name and
10319 replaces it with the second argument. */
10321 static const char *
10322 replace_outfile_spec_function (int argc
, const char **argv
)
10325 /* Must have exactly two arguments. */
10329 for (i
= 0; i
< n_infiles
; i
++)
10331 if (outfiles
[i
] && !filename_cmp (outfiles
[i
], argv
[0]))
10332 outfiles
[i
] = xstrdup (argv
[1]);
10337 /* remove-outfile built-in spec function.
10339 * This looks for the first argument in the outfiles array's name and
10342 static const char *
10343 remove_outfile_spec_function (int argc
, const char **argv
)
10346 /* Must have exactly one argument. */
10350 for (i
= 0; i
< n_infiles
; i
++)
10352 if (outfiles
[i
] && !filename_cmp (outfiles
[i
], argv
[0]))
10353 outfiles
[i
] = NULL
;
10358 /* Given two version numbers, compares the two numbers.
10359 A version number must match the regular expression
10360 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
10363 compare_version_strings (const char *v1
, const char *v2
)
10368 if (regcomp (&r
, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
10369 REG_EXTENDED
| REG_NOSUB
) != 0)
10371 rresult
= regexec (&r
, v1
, 0, NULL
, 0);
10372 if (rresult
== REG_NOMATCH
)
10373 fatal_error (input_location
, "invalid version number %qs", v1
);
10374 else if (rresult
!= 0)
10376 rresult
= regexec (&r
, v2
, 0, NULL
, 0);
10377 if (rresult
== REG_NOMATCH
)
10378 fatal_error (input_location
, "invalid version number %qs", v2
);
10379 else if (rresult
!= 0)
10382 return strverscmp (v1
, v2
);
10386 /* version_compare built-in spec function.
10388 This takes an argument of the following form:
10390 <comparison-op> <arg1> [<arg2>] <switch> <result>
10392 and produces "result" if the comparison evaluates to true,
10393 and nothing if it doesn't.
10395 The supported <comparison-op> values are:
10397 >= true if switch is a later (or same) version than arg1
10399 < true if switch is an earlier version than arg1
10401 >< true if switch is arg1 or later, and earlier than arg2
10402 <> true if switch is earlier than arg1 or is arg2 or later
10404 If the switch is not present, the condition is false unless
10405 the first character of the <comparison-op> is '!'.
10408 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
10409 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
10411 static const char *
10412 version_compare_spec_function (int argc
, const char **argv
)
10416 const char *switch_value
= NULL
;
10421 fatal_error (input_location
, "too few arguments to %%:version-compare");
10422 if (argv
[0][0] == '\0')
10424 if ((argv
[0][1] == '<' || argv
[0][1] == '>') && argv
[0][0] != '!')
10426 if (argc
!= nargs
+ 3)
10427 fatal_error (input_location
, "too many arguments to %%:version-compare");
10429 switch_len
= strlen (argv
[nargs
+ 1]);
10430 for (i
= 0; i
< n_switches
; i
++)
10431 if (!strncmp (switches
[i
].part1
, argv
[nargs
+ 1], switch_len
)
10432 && check_live_switch (i
, switch_len
))
10433 switch_value
= switches
[i
].part1
+ switch_len
;
10435 if (switch_value
== NULL
)
10436 comp1
= comp2
= -1;
10439 comp1
= compare_version_strings (switch_value
, argv
[1]);
10441 comp2
= compare_version_strings (switch_value
, argv
[2]);
10443 comp2
= -1; /* This value unused. */
10446 switch (argv
[0][0] << 8 | argv
[0][1])
10448 case '>' << 8 | '=':
10449 result
= comp1
>= 0;
10451 case '!' << 8 | '<':
10452 result
= comp1
>= 0 || switch_value
== NULL
;
10455 result
= comp1
< 0;
10457 case '!' << 8 | '>':
10458 result
= comp1
< 0 || switch_value
== NULL
;
10460 case '>' << 8 | '<':
10461 result
= comp1
>= 0 && comp2
< 0;
10463 case '<' << 8 | '>':
10464 result
= comp1
< 0 || comp2
>= 0;
10468 fatal_error (input_location
,
10469 "unknown operator %qs in %%:version-compare", argv
[0]);
10474 return argv
[nargs
+ 2];
10477 /* %:include builtin spec function. This differs from %include in that it
10478 can be nested inside a spec, and thus be conditionalized. It takes
10479 one argument, the filename, and looks for it in the startfile path.
10480 The result is always NULL, i.e. an empty expansion. */
10482 static const char *
10483 include_spec_function (int argc
, const char **argv
)
10490 file
= find_a_file (&startfile_prefixes
, argv
[0], R_OK
, true);
10491 read_specs (file
? file
: argv
[0], false, false);
10496 /* %:find-file spec function. This function replaces its argument by
10497 the file found through find_file, that is the -print-file-name gcc
10499 static const char *
10500 find_file_spec_function (int argc
, const char **argv
)
10507 file
= find_file (argv
[0]);
10512 /* %:find-plugindir spec function. This function replaces its argument
10513 by the -iplugindir=<dir> option. `dir' is found through find_file, that
10514 is the -print-file-name gcc program option. */
10515 static const char *
10516 find_plugindir_spec_function (int argc
, const char **argv ATTRIBUTE_UNUSED
)
10518 const char *option
;
10523 option
= concat ("-iplugindir=", find_file ("plugin"), NULL
);
10528 /* %:print-asm-header spec function. Print a banner to say that the
10529 following output is from the assembler. */
10531 static const char *
10532 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED
,
10533 const char **argv ATTRIBUTE_UNUSED
)
10535 printf (_("Assembler options\n=================\n\n"));
10536 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
10541 /* Get a random number for -frandom-seed */
10543 static unsigned HOST_WIDE_INT
10544 get_random_number (void)
10546 unsigned HOST_WIDE_INT ret
= 0;
10549 fd
= open ("/dev/urandom", O_RDONLY
);
10552 read (fd
, &ret
, sizeof (HOST_WIDE_INT
));
10558 /* Get some more or less random data. */
10559 #ifdef HAVE_GETTIMEOFDAY
10563 gettimeofday (&tv
, NULL
);
10564 ret
= tv
.tv_sec
* 1000 + tv
.tv_usec
/ 1000;
10568 time_t now
= time (NULL
);
10570 if (now
!= (time_t)-1)
10571 ret
= (unsigned) now
;
10575 return ret
^ getpid ();
10578 /* %:compare-debug-dump-opt spec function. Save the last argument,
10579 expected to be the last -fdump-final-insns option, or generate a
10582 static const char *
10583 compare_debug_dump_opt_spec_function (int arg
,
10584 const char **argv ATTRIBUTE_UNUSED
)
10589 static char random_seed
[HOST_BITS_PER_WIDE_INT
/ 4 + 3];
10592 fatal_error (input_location
,
10593 "too many arguments to %%:compare-debug-dump-opt");
10595 do_spec_2 ("%{fdump-final-insns=*:%*}", NULL
);
10596 do_spec_1 (" ", 0, NULL
);
10598 if (argbuf
.length () > 0
10599 && strcmp (argv
[argbuf
.length () - 1], ".") != 0)
10601 if (!compare_debug
)
10604 name
= xstrdup (argv
[argbuf
.length () - 1]);
10609 if (argbuf
.length () > 0)
10610 do_spec_2 ("%B.gkd", NULL
);
10611 else if (!compare_debug
)
10614 do_spec_2 ("%{!save-temps*:%g.gkd}%{save-temps*:%B.gkd}", NULL
);
10616 do_spec_1 (" ", 0, NULL
);
10618 gcc_assert (argbuf
.length () > 0);
10620 name
= xstrdup (argbuf
.last ());
10622 char *arg
= quote_spec (xstrdup (name
));
10623 ret
= concat ("-fdump-final-insns=", arg
, NULL
);
10627 which
= compare_debug
< 0;
10628 debug_check_temp_file
[which
] = name
;
10632 unsigned HOST_WIDE_INT value
= get_random_number ();
10634 sprintf (random_seed
, HOST_WIDE_INT_PRINT_HEX
, value
);
10640 ret
= concat ("%{!frandom-seed=*:-frandom-seed=", random_seed
, "} ",
10651 /* %:compare-debug-self-opt spec function. Expands to the options
10652 that are to be passed in the second compilation of
10655 static const char *
10656 compare_debug_self_opt_spec_function (int arg
,
10657 const char **argv ATTRIBUTE_UNUSED
)
10660 fatal_error (input_location
,
10661 "too many arguments to %%:compare-debug-self-opt");
10663 if (compare_debug
>= 0)
10667 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
10668 %<fdump-final-insns=* -w -S -o %j \
10669 %{!fcompare-debug-second:-fcompare-debug-second} \
10670 ", compare_debug_opt
, NULL
);
10673 /* %:pass-through-libs spec function. Finds all -l options and input
10674 file names in the lib spec passed to it, and makes a list of them
10675 prepended with the plugin option to cause them to be passed through
10676 to the final link after all the new object files have been added. */
10679 pass_through_libs_spec_func (int argc
, const char **argv
)
10681 char *prepended
= xstrdup (" ");
10683 /* Shlemiel the painter's algorithm. Innately horrible, but at least
10684 we know that there will never be more than a handful of strings to
10685 concat, and it's only once per run, so it's not worth optimising. */
10686 for (n
= 0; n
< argc
; n
++)
10688 char *old
= prepended
;
10689 /* Anything that isn't an option is a full path to an output
10690 file; pass it through if it ends in '.a'. Among options,
10692 if (argv
[n
][0] == '-' && argv
[n
][1] == 'l')
10694 const char *lopt
= argv
[n
] + 2;
10695 /* Handle both joined and non-joined -l options. If for any
10696 reason there's a trailing -l with no joined or following
10697 arg just discard it. */
10698 if (!*lopt
&& ++n
>= argc
)
10702 prepended
= concat (prepended
, "-plugin-opt=-pass-through=-l",
10705 else if (!strcmp (".a", argv
[n
] + strlen (argv
[n
]) - 2))
10707 prepended
= concat (prepended
, "-plugin-opt=-pass-through=",
10708 argv
[n
], " ", NULL
);
10710 if (prepended
!= old
)
10717 not_actual_file_p (const char *name
)
10719 return (strcmp (name
, "-") == 0
10720 || strcmp (name
, HOST_BIT_BUCKET
) == 0);
10723 /* %:dumps spec function. Take an optional argument that overrides
10724 the default extension for -dumpbase and -dumpbase-ext.
10725 Return -dumpdir, -dumpbase and -dumpbase-ext, if needed. */
10727 dumps_spec_func (int argc
, const char **argv ATTRIBUTE_UNUSED
)
10729 const char *ext
= dumpbase_ext
;
10732 char *args
[3] = { NULL
, NULL
, NULL
};
10735 /* Do not compute a default for -dumpbase-ext when -dumpbase was
10736 given explicitly. */
10737 if (dumpbase
&& *dumpbase
&& !ext
)
10742 /* Do not override the explicitly-specified -dumpbase-ext with
10743 the specs-provided overrider. */
10747 else if (argc
!= 0)
10748 fatal_error (input_location
, "too many arguments for %%:dumps");
10752 p
= quote_spec_arg (xstrdup (dumpdir
));
10753 args
[nargs
++] = concat (" -dumpdir ", p
, NULL
);
10758 ext
= input_basename
+ basename_length
;
10760 /* Use the precomputed outbase, or compute dumpbase from
10761 input_basename, just like %b would. */
10764 if (dumpbase
&& *dumpbase
)
10766 base
= xstrdup (dumpbase
);
10767 p
= base
+ outbase_length
;
10768 gcc_checking_assert (strncmp (base
, outbase
, outbase_length
) == 0);
10769 gcc_checking_assert (strcmp (p
, ext
) == 0);
10771 else if (outbase_length
)
10773 base
= xstrndup (outbase
, outbase_length
);
10778 base
= xstrndup (input_basename
, suffixed_basename_length
);
10779 p
= base
+ basename_length
;
10782 if (compare_debug
< 0 || !p
|| strcmp (p
, ext
) != 0)
10788 if (compare_debug
< 0)
10793 p
= concat (base
, gk
, ext
, NULL
);
10799 base
= quote_spec_arg (base
);
10800 args
[nargs
++] = concat (" -dumpbase ", base
, NULL
);
10805 p
= quote_spec_arg (xstrdup (ext
));
10806 args
[nargs
++] = concat (" -dumpbase-ext ", p
, NULL
);
10810 const char *ret
= concat (args
[0], args
[1], args
[2], NULL
);
10812 free (args
[--nargs
]);
10817 /* Returns "" if ARGV[ARGC - 2] is greater than ARGV[ARGC-1].
10818 Otherwise, return NULL. */
10820 static const char *
10821 greater_than_spec_func (int argc
, const char **argv
)
10828 gcc_assert (argc
>= 2);
10830 long arg
= strtol (argv
[argc
- 2], &converted
, 10);
10831 gcc_assert (converted
!= argv
[argc
- 2]);
10833 long lim
= strtol (argv
[argc
- 1], &converted
, 10);
10834 gcc_assert (converted
!= argv
[argc
- 1]);
10842 /* Returns "" if debug_info_level is greater than ARGV[ARGC-1].
10843 Otherwise, return NULL. */
10845 static const char *
10846 debug_level_greater_than_spec_func (int argc
, const char **argv
)
10851 fatal_error (input_location
,
10852 "wrong number of arguments to %%:debug-level-gt");
10854 long arg
= strtol (argv
[0], &converted
, 10);
10855 gcc_assert (converted
!= argv
[0]);
10857 if (debug_info_level
> arg
)
10863 /* Returns "" if dwarf_version is greater than ARGV[ARGC-1].
10864 Otherwise, return NULL. */
10866 static const char *
10867 dwarf_version_greater_than_spec_func (int argc
, const char **argv
)
10872 fatal_error (input_location
,
10873 "wrong number of arguments to %%:dwarf-version-gt");
10875 long arg
= strtol (argv
[0], &converted
, 10);
10876 gcc_assert (converted
!= argv
[0]);
10878 if (dwarf_version
> arg
)
10885 path_prefix_reset (path_prefix
*prefix
)
10887 struct prefix_list
*iter
, *next
;
10888 iter
= prefix
->plist
;
10892 free (const_cast <char *> (iter
->prefix
));
10897 prefix
->max_len
= 0;
10900 /* The function takes 3 arguments: OPTION name, file name and location
10901 where we search for Fortran modules.
10902 When the FILE is found by find_file, return OPTION=path_to_file. */
10904 static const char *
10905 find_fortran_preinclude_file (int argc
, const char **argv
)
10907 char *result
= NULL
;
10911 struct path_prefix prefixes
= { 0, 0, "preinclude" };
10913 /* Search first for 'finclude' folder location for a header file
10914 installed by the compiler (similar to omp_lib.h). */
10915 add_prefix (&prefixes
, argv
[2], NULL
, 0, 0, 0);
10916 #ifdef TOOL_INCLUDE_DIR
10917 /* Then search: <prefix>/<target>/<include>/finclude */
10918 add_prefix (&prefixes
, TOOL_INCLUDE_DIR
"/finclude/",
10921 #ifdef NATIVE_SYSTEM_HEADER_DIR
10922 /* Then search: <sysroot>/usr/include/finclude/<multilib> */
10923 add_sysrooted_hdrs_prefix (&prefixes
, NATIVE_SYSTEM_HEADER_DIR
"/finclude/",
10927 const char *path
= find_a_file (&include_prefixes
, argv
[1], R_OK
, false);
10929 result
= concat (argv
[0], path
, NULL
);
10932 path
= find_a_file (&prefixes
, argv
[1], R_OK
, false);
10934 result
= concat (argv
[0], path
, NULL
);
10937 path_prefix_reset (&prefixes
);
10941 /* If any character in ORIG fits QUOTE_P (_, P), reallocate the string
10942 so as to precede every one of them with a backslash. Return the
10943 original string or the reallocated one. */
10945 static inline char *
10946 quote_string (char *orig
, bool (*quote_p
)(char, void *), void *p
)
10948 int len
, number_of_space
= 0;
10950 for (len
= 0; orig
[len
]; len
++)
10951 if (quote_p (orig
[len
], p
))
10954 if (number_of_space
)
10956 char *new_spec
= (char *) xmalloc (len
+ number_of_space
+ 1);
10958 for (j
= 0, k
= 0; j
<= len
; j
++, k
++)
10960 if (quote_p (orig
[j
], p
))
10961 new_spec
[k
++] = '\\';
10962 new_spec
[k
] = orig
[j
];
10971 /* Return true iff C is any of the characters convert_white_space
10975 whitespace_to_convert_p (char c
, void *)
10977 return (c
== ' ' || c
== '\t');
10980 /* Insert backslash before spaces in ORIG (usually a file path), to
10981 avoid being broken by spec parser.
10983 This function is needed as do_spec_1 treats white space (' ' and '\t')
10984 as the end of an argument. But in case of -plugin /usr/gcc install/xxx.so,
10985 the file name should be treated as a single argument rather than being
10986 broken into multiple. Solution is to insert '\\' before the space in a
10989 This function converts and only converts all occurrence of ' '
10990 to '\\' + ' ' and '\t' to '\\' + '\t'. For example:
10992 "a b" -> "a\\ \\ b"
10994 "a\\ b" -> "a\\\\ b"
10996 orig: input null-terminating string that was allocated by xalloc. The
10997 memory it points to might be freed in this function. Behavior undefined
10998 if ORIG wasn't xalloced or was freed already at entry.
11000 Return: ORIG if no conversion needed. Otherwise a newly allocated string
11001 that was converted from ORIG. */
11004 convert_white_space (char *orig
)
11006 return quote_string (orig
, whitespace_to_convert_p
, NULL
);
11009 /* Return true iff C matches any of the spec active characters. */
11011 quote_spec_char_p (char c
, void *)
11028 /* Like convert_white_space, but deactivate all active spec chars by
11031 static inline char *
11032 quote_spec (char *orig
)
11034 return quote_string (orig
, quote_spec_char_p
, NULL
);
11037 /* Like quote_spec, but also turn an empty string into the spec for an
11040 static inline char *
11041 quote_spec_arg (char *orig
)
11046 return xstrdup ("%\"");
11049 return quote_spec (orig
);
11052 /* Restore all state within gcc.c to the initial state, so that the driver
11053 code can be safely re-run in-process.
11055 Many const char * variables are referenced by static specs (see
11056 INIT_STATIC_SPEC above). These variables are restored to their default
11057 values by a simple loop over the static specs.
11059 For other variables, we directly restore them all to their initial
11060 values (often implicitly 0).
11062 Free the various obstacks in this file, along with "opts_obstack"
11065 This function also restores any environment variables that were changed. */
11068 driver::finalize ()
11071 diagnostic_finish (global_dc
);
11074 at_file_supplied
= 0;
11075 print_help_list
= 0;
11077 verbose_only_flag
= 0;
11078 print_subprocess_help
= 0;
11080 report_times_to_file
= NULL
;
11081 target_system_root
= DEFAULT_TARGET_SYSTEM_ROOT
;
11082 target_system_root_changed
= 0;
11083 target_sysroot_suffix
= 0;
11084 target_sysroot_hdrs_suffix
= 0;
11085 save_temps_flag
= SAVE_TEMPS_NONE
;
11086 save_temps_overrides_dumpdir
= false;
11087 dumpdir_trailing_dash_added
= false;
11090 free (dumpbase_ext
);
11092 dumpdir
= dumpbase
= dumpbase_ext
= outbase
= NULL
;
11093 dumpdir_length
= outbase_length
= 0;
11094 spec_machine
= DEFAULT_TARGET_MACHINE
;
11095 greatest_status
= 1;
11097 obstack_free (&obstack
, NULL
);
11098 obstack_free (&opts_obstack
, NULL
); /* in opts.c */
11099 obstack_free (&collect_obstack
, NULL
);
11101 link_command_spec
= LINK_COMMAND_SPEC
;
11103 obstack_free (&multilib_obstack
, NULL
);
11105 user_specs_head
= NULL
;
11106 user_specs_tail
= NULL
;
11108 /* Within the "compilers" vec, the fields "suffix" and "spec" were
11109 statically allocated for the default compilers, but dynamically
11110 allocated for additional compilers. Delete them for the latter. */
11111 for (int i
= n_default_compilers
; i
< n_compilers
; i
++)
11113 free (const_cast <char *> (compilers
[i
].suffix
));
11114 free (const_cast <char *> (compilers
[i
].spec
));
11116 XDELETEVEC (compilers
);
11120 linker_options
.truncate (0);
11121 assembler_options
.truncate (0);
11122 preprocessor_options
.truncate (0);
11124 path_prefix_reset (&exec_prefixes
);
11125 path_prefix_reset (&startfile_prefixes
);
11126 path_prefix_reset (&include_prefixes
);
11128 machine_suffix
= 0;
11129 just_machine_suffix
= 0;
11130 gcc_exec_prefix
= 0;
11131 gcc_libexec_prefix
= 0;
11132 set_static_spec_shared (&md_exec_prefix
, MD_EXEC_PREFIX
);
11133 set_static_spec_shared (&md_startfile_prefix
, MD_STARTFILE_PREFIX
);
11134 set_static_spec_shared (&md_startfile_prefix_1
, MD_STARTFILE_PREFIX_1
);
11136 multilib_os_dir
= 0;
11139 /* Free any specs dynamically-allocated by set_spec.
11140 These will be at the head of the list, before the
11141 statically-allocated ones. */
11144 while (specs
!= static_specs
)
11146 spec_list
*next
= specs
->next
;
11147 free (const_cast <char *> (specs
->name
));
11153 for (unsigned i
= 0; i
< ARRAY_SIZE (static_specs
); i
++)
11155 spec_list
*sl
= &static_specs
[i
];
11158 free (const_cast <char *> (*(sl
->ptr_spec
)));
11159 sl
->alloc_p
= false;
11161 *(sl
->ptr_spec
) = sl
->default_ptr
;
11164 extra_specs
= NULL
;
11167 processing_spec_function
= 0;
11175 execution_count
= 0;
11178 temp_filename
= NULL
;
11179 temp_filename_length
= 0;
11180 always_delete_queue
= NULL
;
11181 failure_delete_queue
= NULL
;
11183 XDELETEVEC (switches
);
11186 n_switches_alloc
= 0;
11189 compare_debug_second
= 0;
11190 compare_debug_opt
= NULL
;
11191 for (int i
= 0; i
< 2; i
++)
11193 switches_debug_check
[i
] = NULL
;
11194 n_switches_debug_check
[i
] = 0;
11195 n_switches_alloc_debug_check
[i
] = 0;
11196 debug_check_temp_file
[i
] = NULL
;
11199 XDELETEVEC (infiles
);
11202 n_infiles_alloc
= 0;
11204 combine_inputs
= false;
11205 added_libraries
= 0;
11206 XDELETEVEC (outfiles
);
11209 last_language_n_infiles
= 0;
11210 gcc_input_filename
= NULL
;
11211 input_file_number
= 0;
11212 input_filename_length
= 0;
11213 basename_length
= 0;
11214 suffixed_basename_length
= 0;
11215 input_basename
= NULL
;
11216 input_suffix
= NULL
;
11217 /* We don't need to purge "input_stat", just to unset "input_stat_set". */
11218 input_stat_set
= 0;
11219 input_file_compiler
= NULL
;
11221 delete_this_arg
= 0;
11222 this_is_output_file
= 0;
11223 this_is_library_file
= 0;
11224 this_is_linker_script
= 0;
11225 input_from_pipe
= 0;
11226 suffix_subst
= NULL
;
11231 used_arg
.finalize ();
11235 Targets can provide configure-time default options in
11236 OPTION_DEFAULT_SPECS. The jit needs to access these, but
11237 they are expressed in the spec language.
11239 Run just enough of the driver to be able to expand these
11240 specs, and then call the callback CB on each
11241 such option. The options strings are *without* a leading
11242 '-' character e.g. ("march=x86-64"). Finally, clean up. */
11245 driver_get_configure_time_options (void (*cb
) (const char *option
,
11251 obstack_init (&obstack
);
11252 init_opts_obstack ();
11255 for (i
= 0; i
< ARRAY_SIZE (option_default_specs
); i
++)
11256 do_option_spec (option_default_specs
[i
].name
,
11257 option_default_specs
[i
].spec
);
11259 for (i
= 0; (int) i
< n_switches
; i
++)
11261 gcc_assert (switches
[i
].part1
);
11262 (*cb
) (switches
[i
].part1
, user_data
);
11265 obstack_free (&opts_obstack
, NULL
);
11266 obstack_free (&obstack
, NULL
);