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 /* Nonzero if cross-compiling.
323 When -b is used, the value comes from the `specs' file. */
325 #ifdef CROSS_DIRECTORY_STRUCTURE
326 static const char *cross_compile
= "1";
328 static const char *cross_compile
= "0";
331 /* Greatest exit code of sub-processes that has been encountered up to
333 static int greatest_status
= 1;
335 /* This is the obstack which we use to allocate many strings. */
337 static struct obstack obstack
;
339 /* This is the obstack to build an environment variable to pass to
340 collect2 that describes all of the relevant switches of what to
341 pass the compiler in building the list of pointers to constructors
344 static struct obstack collect_obstack
;
346 /* Forward declaration for prototypes. */
350 static void init_spec (void);
351 static void store_arg (const char *, int, int);
352 static void insert_wrapper (const char *);
353 static char *load_specs (const char *);
354 static void read_specs (const char *, bool, bool);
355 static void set_spec (const char *, const char *, bool);
356 static struct compiler
*lookup_compiler (const char *, size_t, const char *);
357 static char *build_search_list (const struct path_prefix
*, const char *,
359 static void xputenv (const char *);
360 static void putenv_from_prefixes (const struct path_prefix
*, const char *,
362 static int access_check (const char *, int);
363 static char *find_a_file (const struct path_prefix
*, const char *, int, bool);
364 static void add_prefix (struct path_prefix
*, const char *, const char *,
366 static void add_sysrooted_prefix (struct path_prefix
*, const char *,
367 const char *, int, int, int);
368 static char *skip_whitespace (char *);
369 static void delete_if_ordinary (const char *);
370 static void delete_temp_files (void);
371 static void delete_failure_queue (void);
372 static void clear_failure_queue (void);
373 static int check_live_switch (int, int);
374 static const char *handle_braces (const char *);
375 static inline bool input_suffix_matches (const char *, const char *);
376 static inline bool switch_matches (const char *, const char *, int);
377 static inline void mark_matching_switches (const char *, const char *, int);
378 static inline void process_marked_switches (void);
379 static const char *process_brace_body (const char *, const char *, const char *, int, int);
380 static const struct spec_function
*lookup_spec_function (const char *);
381 static const char *eval_spec_function (const char *, const char *, const char *);
382 static const char *handle_spec_function (const char *, bool *, const char *);
383 static char *save_string (const char *, int);
384 static void set_collect_gcc_options (void);
385 static int do_spec_1 (const char *, int, const char *);
386 static int do_spec_2 (const char *, const char *);
387 static void do_option_spec (const char *, const char *);
388 static void do_self_spec (const char *);
389 static const char *find_file (const char *);
390 static int is_directory (const char *, bool);
391 static const char *validate_switches (const char *, bool, bool);
392 static void validate_all_switches (void);
393 static inline void validate_switches_from_spec (const char *, bool);
394 static void give_switch (int, int);
395 static int default_arg (const char *, int);
396 static void set_multilib_dir (void);
397 static void print_multilib_info (void);
398 static void display_help (void);
399 static void add_preprocessor_option (const char *, int);
400 static void add_assembler_option (const char *, int);
401 static void add_linker_option (const char *, int);
402 static void process_command (unsigned int, struct cl_decoded_option
*);
403 static int execute (void);
404 static void alloc_args (void);
405 static void clear_args (void);
406 static void fatal_signal (int);
407 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
408 static void init_gcc_specs (struct obstack
*, const char *, const char *,
411 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
412 static const char *convert_filename (const char *, int, int);
415 static void try_generate_repro (const char **argv
);
416 static const char *getenv_spec_function (int, const char **);
417 static const char *if_exists_spec_function (int, const char **);
418 static const char *if_exists_else_spec_function (int, const char **);
419 static const char *if_exists_then_else_spec_function (int, const char **);
420 static const char *sanitize_spec_function (int, const char **);
421 static const char *replace_outfile_spec_function (int, const char **);
422 static const char *remove_outfile_spec_function (int, const char **);
423 static const char *version_compare_spec_function (int, const char **);
424 static const char *include_spec_function (int, const char **);
425 static const char *find_file_spec_function (int, const char **);
426 static const char *find_plugindir_spec_function (int, const char **);
427 static const char *print_asm_header_spec_function (int, const char **);
428 static const char *compare_debug_dump_opt_spec_function (int, const char **);
429 static const char *compare_debug_self_opt_spec_function (int, const char **);
430 static const char *pass_through_libs_spec_func (int, const char **);
431 static const char *dumps_spec_func (int, const char **);
432 static const char *greater_than_spec_func (int, const char **);
433 static const char *debug_level_greater_than_spec_func (int, const char **);
434 static const char *dwarf_version_greater_than_spec_func (int, const char **);
435 static const char *find_fortran_preinclude_file (int, const char **);
436 static char *convert_white_space (char *);
437 static char *quote_spec (char *);
438 static char *quote_spec_arg (char *);
439 static bool not_actual_file_p (const char *);
442 /* The Specs Language
444 Specs are strings containing lines, each of which (if not blank)
445 is made up of a program name, and arguments separated by spaces.
446 The program name must be exact and start from root, since no path
447 is searched and it is unreliable to depend on the current working directory.
448 Redirection of input or output is not supported; the subprograms must
449 accept filenames saying what files to read and write.
451 In addition, the specs can contain %-sequences to substitute variable text
452 or for conditional text. Here is a table of all defined %-sequences.
453 Note that spaces are not generated automatically around the results of
454 expanding these sequences; therefore, you can concatenate them together
455 or with constant text in a single argument.
457 %% substitute one % into the program name or argument.
458 %" substitute an empty argument.
459 %i substitute the name of the input file being processed.
460 %b substitute the basename for outputs related with the input file
461 being processed. This is often a substring of the input file name,
462 up to (and not including) the last period but, unless %w is active,
463 it is affected by the directory selected by -save-temps=*, by
464 -dumpdir, and, in case of multiple compilations, even by -dumpbase
465 and -dumpbase-ext and, in case of linking, by the linker output
466 name. When %w is active, it derives the main output name only from
467 the input file base name; when it is not, it names aux/dump output
469 %B same as %b, but include the input file suffix (text after the last
472 substitute a file name that has suffix SUFFIX and is chosen
473 once per compilation, and mark the argument a la %d. To reduce
474 exposure to denial-of-service attacks, the file name is now
475 chosen in a way that is hard to predict even when previously
476 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
477 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
478 the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
479 had been pre-processed. Previously, %g was simply substituted
480 with a file name chosen once per compilation, without regard
481 to any appended suffix (which was therefore treated just like
482 ordinary text), making such attacks more likely to succeed.
484 like %g, but if -pipe is in effect, expands simply to "-".
486 like %g, but if -pipe is in effect, expands to nothing. (We have both
487 %| and %m to accommodate differences between system assemblers; see
488 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
490 like %g, but generates a new temporary file name even if %uSUFFIX
493 substitutes the last file name generated with %uSUFFIX, generating a
494 new one if there is no such last file name. In the absence of any
495 %uSUFFIX, this is just like %gSUFFIX, except they don't share
496 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
497 would involve the generation of two distinct file names, one
498 for each `%g.s' and another for each `%U.s'. Previously, %U was
499 simply substituted with a file name chosen for the previous %u,
500 without regard to any appended suffix.
502 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
503 writable, and if save-temps is off; otherwise, substitute the name
504 of a temporary file, just like %u. This temporary file is not
505 meant for communication between processes, but rather as a junk
508 substitutes .SUFFIX for the suffixes of a matched switch's args when
509 it is subsequently output with %*. SUFFIX is terminated by the next
511 %d marks the argument containing or following the %d as a
512 temporary file name, so that file will be deleted if GCC exits
513 successfully. Unlike %g, this contributes no text to the argument.
514 %w marks the argument containing or following the %w as the
515 "output file" of this compilation. This puts the argument
516 into the sequence of arguments that %o will substitute later.
517 %V indicates that this compilation produces no "output file".
519 like %{...} but marks the last argument supplied within as a file
520 to be deleted on failure.
522 like %{...} but puts the result into a FILE and substitutes @FILE
523 if an @file argument has been supplied.
524 %o substitutes the names of all the output files, with spaces
525 automatically placed around them. You should write spaces
526 around the %o as well or the results are undefined.
527 %o is for use in the specs for running the linker.
528 Input files whose names have no recognized suffix are not compiled
529 at all, but they are included among the output files, so they will
531 %O substitutes the suffix for object files. Note that this is
532 handled specially when it immediately follows %g, %u, or %U
533 (with or without a suffix argument) because of the need for
534 those to form complete file names. The handling is such that
535 %O is treated exactly as if it had already been substituted,
536 except that %g, %u, and %U do not currently support additional
537 SUFFIX characters following %O as they would following, for
539 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
540 (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
541 and -B options) and -imultilib as necessary.
542 %s current argument is the name of a library or startup file of some sort.
543 Search for that file in a standard list of directories
544 and substitute the full name found.
545 %T current argument is the name of a linker script.
546 Search for that file in the current list of directories to scan for
547 libraries. If the file is located, insert a --script option into the
548 command line followed by the full path name found. If the file is
549 not found then generate an error message.
550 Note: the current working directory is not searched.
551 %eSTR Print STR as an error message. STR is terminated by a newline.
552 Use this when inconsistent options are detected.
553 %nSTR Print STR as a notice. STR is terminated by a newline.
554 %x{OPTION} Accumulate an option for %X.
555 %X Output the accumulated linker options specified by compilations.
556 %Y Output the accumulated assembler options specified by compilations.
557 %Z Output the accumulated preprocessor options specified by compilations.
558 %a process ASM_SPEC as a spec.
559 This allows config.h to specify part of the spec for running as.
560 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
561 used here. This can be used to run a post-processor after the
562 assembler has done its job.
563 %D Dump out a -L option for each directory in startfile_prefixes.
564 If multilib_dir is set, extra entries are generated with it affixed.
565 %l process LINK_SPEC as a spec.
566 %L process LIB_SPEC as a spec.
567 %M Output multilib_os_dir.
568 %G process LIBGCC_SPEC as a spec.
569 %R Output the concatenation of target_system_root and
570 target_sysroot_suffix.
571 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
572 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
573 %C process CPP_SPEC as a spec.
574 %1 process CC1_SPEC as a spec.
575 %2 process CC1PLUS_SPEC as a spec.
576 %* substitute the variable part of a matched option. (See below.)
577 Note that each comma in the substituted string is replaced by
578 a single space. A space is appended after the last substition
579 unless there is more text in current sequence.
580 %<S remove all occurrences of -S from the command line.
581 Note - this command is position dependent. % commands in the
582 spec string before this one will see -S, % commands in the
583 spec string after this one will not.
584 %>S Similar to "%<S", but keep it in the GCC command line.
585 %<S* remove all occurrences of all switches beginning with -S from the
588 Call the named function FUNCTION, passing it ARGS. ARGS is
589 first processed as a nested spec string, then split into an
590 argument vector in the usual fashion. The function returns
591 a string which is processed as if it had appeared literally
592 as part of the current spec.
593 %{S} substitutes the -S switch, if that switch was given to GCC.
594 If that switch was not specified, this substitutes nothing.
595 Here S is a metasyntactic variable.
596 %{S*} substitutes all the switches specified to GCC whose names start
597 with -S. This is used for -o, -I, etc; switches that take
598 arguments. GCC considers `-o foo' as being one switch whose
599 name starts with `o'. %{o*} would substitute this text,
600 including the space; thus, two arguments would be generated.
601 %{S*&T*} likewise, but preserve order of S and T options (the order
602 of S and T in the spec is not significant). Can be any number
603 of ampersand-separated variables; for each the wild card is
604 optional. Useful for CPP as %{D*&U*&A*}.
606 %{S:X} substitutes X, if the -S switch was given to GCC.
607 %{!S:X} substitutes X, if the -S switch was NOT given to GCC.
608 %{S*:X} substitutes X if one or more switches whose names start
609 with -S was given to GCC. Normally X is substituted only
610 once, no matter how many such switches appeared. However,
611 if %* appears somewhere in X, then X will be substituted
612 once for each matching switch, with the %* replaced by the
613 part of that switch that matched the '*'. A space will be
614 appended after the last substition unless there is more
615 text in current sequence.
616 %{.S:X} substitutes X, if processing a file with suffix S.
617 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
618 %{,S:X} substitutes X, if processing a file which will use spec S.
619 %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
621 %{S|T:X} substitutes X if either -S or -T was given to GCC. This may be
622 combined with '!', '.', ',', and '*' as above binding stronger
624 If %* appears in X, all of the alternatives must be starred, and
625 only the first matching alternative is substituted.
626 %{%:function(args):X}
627 Call function named FUNCTION with args ARGS. If the function
628 returns non-NULL, then X is substituted, if it returns
629 NULL, it isn't substituted.
630 %{S:X; if S was given to GCC, substitutes X;
631 T:Y; else if T was given to GCC, substitutes Y;
632 :D} else substitutes D. There can be as many clauses as you need.
633 This may be combined with '.', '!', ',', '|', and '*' as above.
635 %(Spec) processes a specification defined in a specs file as *Spec:
637 The switch matching text S in a %{S}, %{S:X}, or similar construct can use
638 a backslash to ignore the special meaning of the character following it,
639 thus allowing literal matching of a character that is otherwise specially
640 treated. For example, %{std=iso9899\:1999:X} substitutes X if the
641 -std=iso9899:1999 option is given.
643 The conditional text X in a %{S:X} or similar construct may contain
644 other nested % constructs or spaces, or even newlines. They are
645 processed as usual, as described above. Trailing white space in X is
646 ignored. White space may also appear anywhere on the left side of the
647 colon in these constructs, except between . or * and the corresponding
650 The -O, -f, -g, -m, and -W switches are handled specifically in these
651 constructs. If another value of -O or the negated form of a -f, -m, or
652 -W switch is found later in the command line, the earlier switch
653 value is ignored, except with {S*} where S is just one letter; this
654 passes all matching options.
656 The character | at the beginning of the predicate text is used to indicate
657 that a command should be piped to the following command, but only if -pipe
660 Note that it is built into GCC which switches take arguments and which
661 do not. You might think it would be useful to generalize this to
662 allow each compiler's spec to say which switches take arguments. But
663 this cannot be done in a consistent fashion. GCC cannot even decide
664 which input files have been specified without knowing which switches
665 take arguments, and it must know which input files to compile in order
666 to tell which compilers to run.
668 GCC also knows implicitly that arguments starting in `-l' are to be
669 treated as compiler output files, and passed to the linker in their
670 proper position among the other output files. */
672 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
674 /* config.h can define ASM_SPEC to provide extra args to the assembler
675 or extra switch-translations. */
680 /* config.h can define ASM_FINAL_SPEC to run a post processor after
681 the assembler has run. */
682 #ifndef ASM_FINAL_SPEC
683 #define ASM_FINAL_SPEC \
685 objcopy --extract-dwo \
686 %{c:%{o*:%*}%{!o*:%w%b%O}}%{!c:%U%O} \
688 objcopy --strip-dwo \
689 %{c:%{o*:%*}%{!o*:%w%b%O}}%{!c:%U%O} \
693 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
694 or extra switch-translations. */
699 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
700 or extra switch-translations. */
705 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
706 or extra switch-translations. */
708 #define CC1PLUS_SPEC ""
711 /* config.h can define LINK_SPEC to provide extra args to the linker
712 or extra switch-translations. */
717 /* config.h can define LIB_SPEC to override the default libraries. */
719 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
722 /* When using -fsplit-stack we need to wrap pthread_create, in order
723 to initialize the stack guard. We always use wrapping, rather than
724 shared library ordering, and we keep the wrapper function in
725 libgcc. This is not yet a real spec, though it could become one;
726 it is currently just stuffed into LINK_SPEC. FIXME: This wrapping
727 only works with GNU ld and gold. */
728 #ifdef HAVE_GOLD_NON_DEFAULT_SPLIT_STACK
729 #define STACK_SPLIT_SPEC " %{fsplit-stack: -fuse-ld=gold --wrap=pthread_create}"
731 #define STACK_SPLIT_SPEC " %{fsplit-stack: --wrap=pthread_create}"
735 #define STATIC_LIBASAN_LIBS \
736 " %{static-libasan|static:%:include(libsanitizer.spec)%(link_libasan)}"
737 #ifdef LIBASAN_EARLY_SPEC
738 #define LIBASAN_SPEC STATIC_LIBASAN_LIBS
739 #elif defined(HAVE_LD_STATIC_DYNAMIC)
740 #define LIBASAN_SPEC "%{static-libasan:" LD_STATIC_OPTION \
741 "} -lasan %{static-libasan:" LD_DYNAMIC_OPTION "}" \
744 #define LIBASAN_SPEC "-lasan" STATIC_LIBASAN_LIBS
748 #ifndef LIBASAN_EARLY_SPEC
749 #define LIBASAN_EARLY_SPEC ""
752 #ifndef LIBHWASAN_SPEC
753 #define STATIC_LIBHWASAN_LIBS \
754 " %{static-libhwasan|static:%:include(libsanitizer.spec)%(link_libhwasan)}"
755 #ifdef LIBHWASAN_EARLY_SPEC
756 #define LIBHWASAN_SPEC STATIC_LIBHWASAN_LIBS
757 #elif defined(HAVE_LD_STATIC_DYNAMIC)
758 #define LIBHWASAN_SPEC "%{static-libhwasan:" LD_STATIC_OPTION \
759 "} -lhwasan %{static-libhwasan:" LD_DYNAMIC_OPTION "}" \
760 STATIC_LIBHWASAN_LIBS
762 #define LIBHWASAN_SPEC "-lhwasan" STATIC_LIBHWASAN_LIBS
766 #ifndef LIBHWASAN_EARLY_SPEC
767 #define LIBHWASAN_EARLY_SPEC ""
771 #define STATIC_LIBTSAN_LIBS \
772 " %{static-libtsan|static:%:include(libsanitizer.spec)%(link_libtsan)}"
773 #ifdef LIBTSAN_EARLY_SPEC
774 #define LIBTSAN_SPEC STATIC_LIBTSAN_LIBS
775 #elif defined(HAVE_LD_STATIC_DYNAMIC)
776 #define LIBTSAN_SPEC "%{static-libtsan:" LD_STATIC_OPTION \
777 "} -ltsan %{static-libtsan:" LD_DYNAMIC_OPTION "}" \
780 #define LIBTSAN_SPEC "-ltsan" STATIC_LIBTSAN_LIBS
784 #ifndef LIBTSAN_EARLY_SPEC
785 #define LIBTSAN_EARLY_SPEC ""
789 #define STATIC_LIBLSAN_LIBS \
790 " %{static-liblsan|static:%:include(libsanitizer.spec)%(link_liblsan)}"
791 #ifdef LIBLSAN_EARLY_SPEC
792 #define LIBLSAN_SPEC STATIC_LIBLSAN_LIBS
793 #elif defined(HAVE_LD_STATIC_DYNAMIC)
794 #define LIBLSAN_SPEC "%{static-liblsan:" LD_STATIC_OPTION \
795 "} -llsan %{static-liblsan:" LD_DYNAMIC_OPTION "}" \
798 #define LIBLSAN_SPEC "-llsan" STATIC_LIBLSAN_LIBS
802 #ifndef LIBLSAN_EARLY_SPEC
803 #define LIBLSAN_EARLY_SPEC ""
806 #ifndef LIBUBSAN_SPEC
807 #define STATIC_LIBUBSAN_LIBS \
808 " %{static-libubsan|static:%:include(libsanitizer.spec)%(link_libubsan)}"
809 #ifdef HAVE_LD_STATIC_DYNAMIC
810 #define LIBUBSAN_SPEC "%{static-libubsan:" LD_STATIC_OPTION \
811 "} -lubsan %{static-libubsan:" LD_DYNAMIC_OPTION "}" \
814 #define LIBUBSAN_SPEC "-lubsan" STATIC_LIBUBSAN_LIBS
818 /* Linker options for compressed debug sections. */
819 #if HAVE_LD_COMPRESS_DEBUG == 0
820 /* No linker support. */
821 #define LINK_COMPRESS_DEBUG_SPEC \
822 " %{gz*:%e-gz is not supported in this configuration} "
823 #elif HAVE_LD_COMPRESS_DEBUG == 1
824 /* GNU style on input, GNU ld options. Reject, not useful. */
825 #define LINK_COMPRESS_DEBUG_SPEC \
826 " %{gz*:%e-gz is not supported in this configuration} "
827 #elif HAVE_LD_COMPRESS_DEBUG == 2
828 /* GNU style, GNU gold options. */
829 #define LINK_COMPRESS_DEBUG_SPEC \
830 " %{gz|gz=zlib-gnu:" LD_COMPRESS_DEBUG_OPTION "=zlib}" \
831 " %{gz=none:" LD_COMPRESS_DEBUG_OPTION "=none}" \
832 " %{gz=zlib:%e-gz=zlib is not supported in this configuration} "
833 #elif HAVE_LD_COMPRESS_DEBUG == 3
834 /* ELF gABI style. */
835 #define LINK_COMPRESS_DEBUG_SPEC \
836 " %{gz|gz=zlib:" LD_COMPRESS_DEBUG_OPTION "=zlib}" \
837 " %{gz=none:" LD_COMPRESS_DEBUG_OPTION "=none}" \
838 " %{gz=zlib-gnu:" LD_COMPRESS_DEBUG_OPTION "=zlib-gnu} "
840 #error Unknown value for HAVE_LD_COMPRESS_DEBUG.
843 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
846 #if defined(REAL_LIBGCC_SPEC)
847 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
848 #elif defined(LINK_LIBGCC_SPECIAL_1)
849 /* Have gcc do the search for libgcc.a. */
850 #define LIBGCC_SPEC "libgcc.a%s"
852 #define LIBGCC_SPEC "-lgcc"
856 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
857 #ifndef STARTFILE_SPEC
858 #define STARTFILE_SPEC \
859 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
862 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
864 #define ENDFILE_SPEC ""
868 #define LINKER_NAME "collect2"
871 #ifdef HAVE_AS_DEBUG_PREFIX_MAP
872 #define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
877 /* Assembler options for compressed debug sections. */
878 #if HAVE_LD_COMPRESS_DEBUG < 2
879 /* Reject if the linker cannot write compressed debug sections. */
880 #define ASM_COMPRESS_DEBUG_SPEC \
881 " %{gz*:%e-gz is not supported in this configuration} "
882 #else /* HAVE_LD_COMPRESS_DEBUG >= 2 */
883 #if HAVE_AS_COMPRESS_DEBUG == 0
884 /* No assembler support. Ignore silently. */
885 #define ASM_COMPRESS_DEBUG_SPEC \
887 #elif HAVE_AS_COMPRESS_DEBUG == 1
888 /* GNU style, GNU as options. */
889 #define ASM_COMPRESS_DEBUG_SPEC \
890 " %{gz|gz=zlib-gnu:" AS_COMPRESS_DEBUG_OPTION "}" \
891 " %{gz=none:" AS_NO_COMPRESS_DEBUG_OPTION "}" \
892 " %{gz=zlib:%e-gz=zlib is not supported in this configuration} "
893 #elif HAVE_AS_COMPRESS_DEBUG == 2
894 /* ELF gABI style. */
895 #define ASM_COMPRESS_DEBUG_SPEC \
896 " %{gz|gz=zlib:" AS_COMPRESS_DEBUG_OPTION "=zlib}" \
897 " %{gz=none:" AS_COMPRESS_DEBUG_OPTION "=none}" \
898 " %{gz=zlib-gnu:" AS_COMPRESS_DEBUG_OPTION "=zlib-gnu} "
900 #error Unknown value for HAVE_AS_COMPRESS_DEBUG.
902 #endif /* HAVE_LD_COMPRESS_DEBUG >= 2 */
904 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
905 to the assembler, when compiling assembly sources only. */
906 #ifndef ASM_DEBUG_SPEC
907 # if defined(HAVE_AS_GDWARF_5_DEBUG_FLAG) && defined(HAVE_AS_WORKING_DWARF_N_FLAG)
908 /* If --gdwarf-N is supported and as can handle even compiler generated
909 .debug_line with it, supply --gdwarf-N in ASM_DEBUG_OPTION_SPEC rather
910 than in ASM_DEBUG_SPEC, so that it applies to both .s and .c etc.
912 # define ASM_DEBUG_DWARF_OPTION ""
913 # elif defined(HAVE_AS_GDWARF_5_DEBUG_FLAG)
914 # define ASM_DEBUG_DWARF_OPTION "%{%:dwarf-version-gt(4):--gdwarf-5;" \
915 "%:dwarf-version-gt(3):--gdwarf-4;" \
916 "%:dwarf-version-gt(2):--gdwarf-3;" \
919 # define ASM_DEBUG_DWARF_OPTION "--gdwarf2"
921 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
922 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
923 # define ASM_DEBUG_SPEC \
924 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
925 ? "%{%:debug-level-gt(0):" \
926 "%{gdwarf*:" ASM_DEBUG_DWARF_OPTION "};" \
927 ":%{g*:--gstabs}}" ASM_MAP \
928 : "%{%:debug-level-gt(0):" \
929 "%{gstabs*:--gstabs;" \
930 ":%{g*:" ASM_DEBUG_DWARF_OPTION "}}}" ASM_MAP)
932 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
933 # define ASM_DEBUG_SPEC "%{g*:%{%:debug-level-gt(0):--gstabs}}" ASM_MAP
935 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
936 # define ASM_DEBUG_SPEC "%{g*:%{%:debug-level-gt(0):" \
937 ASM_DEBUG_DWARF_OPTION "}}" ASM_MAP
941 #ifndef ASM_DEBUG_SPEC
942 # define ASM_DEBUG_SPEC ""
945 /* Define ASM_DEBUG_OPTION_SPEC to be a spec suitable for translating '-g'
946 to the assembler when compiling all sources. */
947 #ifndef ASM_DEBUG_OPTION_SPEC
948 # if defined(HAVE_AS_GDWARF_5_DEBUG_FLAG) && defined(HAVE_AS_WORKING_DWARF_N_FLAG)
949 # define ASM_DEBUG_OPTION_DWARF_OPT \
950 "%{%:dwarf-version-gt(4):--gdwarf-5 ;" \
951 "%:dwarf-version-gt(3):--gdwarf-4 ;" \
952 "%:dwarf-version-gt(2):--gdwarf-3 ;" \
954 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO)
955 # define ASM_DEBUG_OPTION_SPEC \
956 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
957 ? "%{%:debug-level-gt(0):" \
958 "%{gdwarf*:" ASM_DEBUG_OPTION_DWARF_OPT "}}" \
959 : "%{%:debug-level-gt(0):" \
960 "%{!gstabs*:%{g*:" ASM_DEBUG_OPTION_DWARF_OPT "}}}")
961 # elif defined(DWARF2_DEBUGGING_INFO)
962 # define ASM_DEBUG_OPTION_SPEC "%{g*:%{%:debug-level-gt(0):" \
963 ASM_DEBUG_OPTION_DWARF_OPT "}}"
967 #ifndef ASM_DEBUG_OPTION_SPEC
968 # define ASM_DEBUG_OPTION_SPEC ""
971 /* Here is the spec for running the linker, after compiling all files. */
973 /* This is overridable by the target in case they need to specify the
974 -lgcc and -lc order specially, yet not require them to override all
975 of LINK_COMMAND_SPEC. */
976 #ifndef LINK_GCC_C_SEQUENCE_SPEC
977 #define LINK_GCC_C_SEQUENCE_SPEC "%G %{!nolibc:%L %G}"
980 #ifndef LINK_SSP_SPEC
981 #ifdef TARGET_LIBC_PROVIDES_SSP
982 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all" \
983 "|fstack-protector-strong|fstack-protector-explicit:}"
985 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all" \
986 "|fstack-protector-strong|fstack-protector-explicit" \
987 ":-lssp_nonshared -lssp}"
991 #ifdef ENABLE_DEFAULT_PIE
992 #define PIE_SPEC "!no-pie"
993 #define NO_FPIE1_SPEC "fno-pie"
994 #define FPIE1_SPEC NO_FPIE1_SPEC ":;"
995 #define NO_FPIE2_SPEC "fno-PIE"
996 #define FPIE2_SPEC NO_FPIE2_SPEC ":;"
997 #define NO_FPIE_SPEC NO_FPIE1_SPEC "|" NO_FPIE2_SPEC
998 #define FPIE_SPEC NO_FPIE_SPEC ":;"
999 #define NO_FPIC1_SPEC "fno-pic"
1000 #define FPIC1_SPEC NO_FPIC1_SPEC ":;"
1001 #define NO_FPIC2_SPEC "fno-PIC"
1002 #define FPIC2_SPEC NO_FPIC2_SPEC ":;"
1003 #define NO_FPIC_SPEC NO_FPIC1_SPEC "|" NO_FPIC2_SPEC
1004 #define FPIC_SPEC NO_FPIC_SPEC ":;"
1005 #define NO_FPIE1_AND_FPIC1_SPEC NO_FPIE1_SPEC "|" NO_FPIC1_SPEC
1006 #define FPIE1_OR_FPIC1_SPEC NO_FPIE1_AND_FPIC1_SPEC ":;"
1007 #define NO_FPIE2_AND_FPIC2_SPEC NO_FPIE2_SPEC "|" NO_FPIC2_SPEC
1008 #define FPIE2_OR_FPIC2_SPEC NO_FPIE2_AND_FPIC2_SPEC ":;"
1009 #define NO_FPIE_AND_FPIC_SPEC NO_FPIE_SPEC "|" NO_FPIC_SPEC
1010 #define FPIE_OR_FPIC_SPEC NO_FPIE_AND_FPIC_SPEC ":;"
1012 #define PIE_SPEC "pie"
1013 #define FPIE1_SPEC "fpie"
1014 #define NO_FPIE1_SPEC FPIE1_SPEC ":;"
1015 #define FPIE2_SPEC "fPIE"
1016 #define NO_FPIE2_SPEC FPIE2_SPEC ":;"
1017 #define FPIE_SPEC FPIE1_SPEC "|" FPIE2_SPEC
1018 #define NO_FPIE_SPEC FPIE_SPEC ":;"
1019 #define FPIC1_SPEC "fpic"
1020 #define NO_FPIC1_SPEC FPIC1_SPEC ":;"
1021 #define FPIC2_SPEC "fPIC"
1022 #define NO_FPIC2_SPEC FPIC2_SPEC ":;"
1023 #define FPIC_SPEC FPIC1_SPEC "|" FPIC2_SPEC
1024 #define NO_FPIC_SPEC FPIC_SPEC ":;"
1025 #define FPIE1_OR_FPIC1_SPEC FPIE1_SPEC "|" FPIC1_SPEC
1026 #define NO_FPIE1_AND_FPIC1_SPEC FPIE1_OR_FPIC1_SPEC ":;"
1027 #define FPIE2_OR_FPIC2_SPEC FPIE2_SPEC "|" FPIC2_SPEC
1028 #define NO_FPIE2_AND_FPIC2_SPEC FPIE1_OR_FPIC2_SPEC ":;"
1029 #define FPIE_OR_FPIC_SPEC FPIE_SPEC "|" FPIC_SPEC
1030 #define NO_FPIE_AND_FPIC_SPEC FPIE_OR_FPIC_SPEC ":;"
1033 #ifndef LINK_PIE_SPEC
1036 #define LD_PIE_SPEC "-pie"
1039 #define LD_PIE_SPEC ""
1041 #define LINK_PIE_SPEC "%{static|shared|r:;" PIE_SPEC ":" LD_PIE_SPEC "} "
1044 #ifndef LINK_BUILDID_SPEC
1045 # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
1046 # define LINK_BUILDID_SPEC "%{!r:--build-id} "
1050 #ifndef LTO_PLUGIN_SPEC
1051 #define LTO_PLUGIN_SPEC ""
1054 /* Conditional to test whether the LTO plugin is used or not.
1055 FIXME: For slim LTO we will need to enable plugin unconditionally. This
1056 still cause problems with PLUGIN_LD != LD and when plugin is built but
1057 not useable. For GCC 4.6 we don't support slim LTO and thus we can enable
1058 plugin only when LTO is enabled. We still honor explicit
1059 -fuse-linker-plugin if the linker used understands -plugin. */
1061 /* The linker has some plugin support. */
1062 #if HAVE_LTO_PLUGIN > 0
1063 /* The linker used has full plugin support, use LTO plugin by default. */
1064 #if HAVE_LTO_PLUGIN == 2
1065 #define PLUGIN_COND "!fno-use-linker-plugin:%{!fno-lto"
1066 #define PLUGIN_COND_CLOSE "}"
1068 /* The linker used has limited plugin support, use LTO plugin with explicit
1069 -fuse-linker-plugin. */
1070 #define PLUGIN_COND "fuse-linker-plugin"
1071 #define PLUGIN_COND_CLOSE ""
1073 #define LINK_PLUGIN_SPEC \
1074 "%{" PLUGIN_COND": \
1075 -plugin %(linker_plugin_file) \
1076 -plugin-opt=%(lto_wrapper) \
1077 -plugin-opt=-fresolution=%u.res \
1078 " LTO_PLUGIN_SPEC "\
1079 %{flinker-output=*:-plugin-opt=-linker-output-known} \
1080 %{!nostdlib:%{!nodefaultlibs:%:pass-through-libs(%(link_gcc_c_sequence))}} \
1081 }" PLUGIN_COND_CLOSE
1083 /* The linker used doesn't support -plugin, reject -fuse-linker-plugin. */
1084 #define LINK_PLUGIN_SPEC "%{fuse-linker-plugin:\
1085 %e-fuse-linker-plugin is not supported in this configuration}"
1088 /* Linker command line options for -fsanitize= early on the command line. */
1089 #ifndef SANITIZER_EARLY_SPEC
1090 #define SANITIZER_EARLY_SPEC "\
1091 %{!nostdlib:%{!r:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_EARLY_SPEC "} \
1092 %{%:sanitize(hwaddress):" LIBHWASAN_EARLY_SPEC "} \
1093 %{%:sanitize(thread):" LIBTSAN_EARLY_SPEC "} \
1094 %{%:sanitize(leak):" LIBLSAN_EARLY_SPEC "}}}}"
1097 /* Linker command line options for -fsanitize= late on the command line. */
1098 #ifndef SANITIZER_SPEC
1099 #define SANITIZER_SPEC "\
1100 %{!nostdlib:%{!r:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_SPEC "\
1101 %{static:%ecannot specify -static with -fsanitize=address}}\
1102 %{%:sanitize(hwaddress):" LIBHWASAN_SPEC "\
1103 %{static:%ecannot specify -static with -fsanitize=hwaddress}}\
1104 %{%:sanitize(thread):" LIBTSAN_SPEC "\
1105 %{static:%ecannot specify -static with -fsanitize=thread}}\
1106 %{%:sanitize(undefined):" LIBUBSAN_SPEC "}\
1107 %{%:sanitize(leak):" LIBLSAN_SPEC "}}}}"
1110 #ifndef POST_LINK_SPEC
1111 #define POST_LINK_SPEC ""
1114 /* This is the spec to use, once the code for creating the vtable
1115 verification runtime library, libvtv.so, has been created. Currently
1116 the vtable verification runtime functions are in libstdc++, so we use
1117 the spec just below this one. */
1118 #ifndef VTABLE_VERIFICATION_SPEC
1119 #if ENABLE_VTABLE_VERIFY
1120 #define VTABLE_VERIFICATION_SPEC "\
1121 %{!nostdlib:%{!r:%{fvtable-verify=std: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}\
1122 %{fvtable-verify=preinit: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}}}"
1124 #define VTABLE_VERIFICATION_SPEC "\
1125 %{fvtable-verify=none:} \
1126 %{fvtable-verify=std: \
1127 %e-fvtable-verify=std is not supported in this configuration} \
1128 %{fvtable-verify=preinit: \
1129 %e-fvtable-verify=preinit is not supported in this configuration}"
1133 /* -u* was put back because both BSD and SysV seem to support it. */
1134 /* %{static|no-pie|static-pie:} simply prevents an error message:
1135 1. If the target machine doesn't handle -static.
1136 2. If PIE isn't enabled by default.
1137 3. If the target machine doesn't handle -static-pie.
1139 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
1140 scripts which exist in user specified directories, or in standard
1142 /* We pass any -flto flags on to the linker, which is expected
1143 to understand them. In practice, this means it had better be collect2. */
1144 /* %{e*} includes -export-dynamic; see comment in common.opt. */
1145 #ifndef LINK_COMMAND_SPEC
1146 #define LINK_COMMAND_SPEC "\
1147 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
1150 "%{flto|flto=*:%<fcompare-debug*} \
1151 %{flto} %{fno-lto} %{flto=*} %l " LINK_PIE_SPEC \
1152 "%{fuse-ld=*:-fuse-ld=%*} " LINK_COMPRESS_DEBUG_SPEC \
1153 "%X %{o*} %{e*} %{N} %{n} %{r}\
1154 %{s} %{t} %{u*} %{z} %{Z} %{!nostdlib:%{!r:%{!nostartfiles:%S}}} \
1155 %{static|no-pie|static-pie:} %@{L*} %(mfwrap) %(link_libgcc) " \
1156 VTABLE_VERIFICATION_SPEC " " SANITIZER_EARLY_SPEC " %o "" \
1157 %{fopenacc|fopenmp|%:gt(%{ftree-parallelize-loops=*:%*} 1):\
1158 %:include(libgomp.spec)%(link_gomp)}\
1159 %{fgnu-tm:%:include(libitm.spec)%(link_itm)}\
1160 %(mflib) " STACK_SPLIT_SPEC "\
1161 %{fprofile-arcs|fprofile-generate*|coverage:-lgcov} " SANITIZER_SPEC " \
1162 %{!nostdlib:%{!r:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}}\
1163 %{!nostdlib:%{!r:%{!nostartfiles:%E}}} %{T*} \n%(post_link) }}}}}}"
1166 #ifndef LINK_LIBGCC_SPEC
1167 /* Generate -L options for startfile prefix list. */
1168 # define LINK_LIBGCC_SPEC "%D"
1171 #ifndef STARTFILE_PREFIX_SPEC
1172 # define STARTFILE_PREFIX_SPEC ""
1175 #ifndef SYSROOT_SPEC
1176 # define SYSROOT_SPEC "--sysroot=%R"
1179 #ifndef SYSROOT_SUFFIX_SPEC
1180 # define SYSROOT_SUFFIX_SPEC ""
1183 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
1184 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
1187 static const char *asm_debug
= ASM_DEBUG_SPEC
;
1188 static const char *asm_debug_option
= ASM_DEBUG_OPTION_SPEC
;
1189 static const char *cpp_spec
= CPP_SPEC
;
1190 static const char *cc1_spec
= CC1_SPEC
;
1191 static const char *cc1plus_spec
= CC1PLUS_SPEC
;
1192 static const char *link_gcc_c_sequence_spec
= LINK_GCC_C_SEQUENCE_SPEC
;
1193 static const char *link_ssp_spec
= LINK_SSP_SPEC
;
1194 static const char *asm_spec
= ASM_SPEC
;
1195 static const char *asm_final_spec
= ASM_FINAL_SPEC
;
1196 static const char *link_spec
= LINK_SPEC
;
1197 static const char *lib_spec
= LIB_SPEC
;
1198 static const char *link_gomp_spec
= "";
1199 static const char *libgcc_spec
= LIBGCC_SPEC
;
1200 static const char *endfile_spec
= ENDFILE_SPEC
;
1201 static const char *startfile_spec
= STARTFILE_SPEC
;
1202 static const char *linker_name_spec
= LINKER_NAME
;
1203 static const char *linker_plugin_file_spec
= "";
1204 static const char *lto_wrapper_spec
= "";
1205 static const char *lto_gcc_spec
= "";
1206 static const char *post_link_spec
= POST_LINK_SPEC
;
1207 static const char *link_command_spec
= LINK_COMMAND_SPEC
;
1208 static const char *link_libgcc_spec
= LINK_LIBGCC_SPEC
;
1209 static const char *startfile_prefix_spec
= STARTFILE_PREFIX_SPEC
;
1210 static const char *sysroot_spec
= SYSROOT_SPEC
;
1211 static const char *sysroot_suffix_spec
= SYSROOT_SUFFIX_SPEC
;
1212 static const char *sysroot_hdrs_suffix_spec
= SYSROOT_HEADERS_SUFFIX_SPEC
;
1213 static const char *self_spec
= "";
1215 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
1216 There should be no need to override these in target dependent files,
1217 but we need to copy them to the specs file so that newer versions
1218 of the GCC driver can correctly drive older tool chains with the
1219 appropriate -B options. */
1221 /* When cpplib handles traditional preprocessing, get rid of this, and
1222 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
1223 that we default the front end language better. */
1224 static const char *trad_capable_cpp
=
1225 "cc1 -E %{traditional|traditional-cpp:-traditional-cpp}";
1227 /* We don't wrap .d files in %W{} since a missing .d file, and
1228 therefore no dependency entry, confuses make into thinking a .o
1229 file that happens to exist is up-to-date. */
1230 static const char *cpp_unique_options
=
1231 "%{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %@{I*&F*} %{P} %I\
1232 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
1233 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
1234 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
1235 %{Mmodules} %{Mno-modules}\
1236 %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
1237 %{remap} %{%:debug-level-gt(2):-dD}\
1238 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
1239 %{H} %C %{D*&U*&A*} %{i*} %Z %i\
1242 /* This contains cpp options which are common with cc1_options and are passed
1243 only when preprocessing only to avoid duplication. We pass the cc1 spec
1244 options to the preprocessor so that it the cc1 spec may manipulate
1245 options used to set target flags. Those special target flags settings may
1246 in turn cause preprocessor symbols to be defined specially. */
1247 static const char *cpp_options
=
1248 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
1249 %{f*} %{g*:%{%:debug-level-gt(0):%{g*}\
1250 %{!fno-working-directory:-fworking-directory}}} %{O*}\
1251 %{undef} %{save-temps*:-fpch-preprocess}";
1253 /* Pass -d* flags, possibly modifying -dumpdir, -dumpbase et al.
1255 Make it easy for a language to override the argument for the
1256 %:dumps specs function call. */
1257 #define DUMPS_OPTIONS(EXTS) \
1258 "%<dumpdir %<dumpbase %<dumpbase-ext %{d*} %:dumps(" EXTS ")"
1260 /* This contains cpp options which are not passed when the preprocessor
1261 output will be used by another program. */
1262 static const char *cpp_debug_options
= DUMPS_OPTIONS ("");
1264 /* NB: This is shared amongst all front-ends, except for Ada. */
1265 static const char *cc1_options
=
1266 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
1267 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
1268 %1 %{!Q:-quiet} %(cpp_debug_options) %{m*} %{aux-info*}\
1269 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
1270 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
1271 %{Qn:-fno-ident} %{Qy:} %{-help:--help}\
1272 %{-target-help:--target-help}\
1273 %{-version:--version}\
1274 %{-help=*:--help=%*}\
1275 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %w%b.s}}}\
1276 %{fsyntax-only:-o %j} %{-param*}\
1277 %{coverage:-fprofile-arcs -ftest-coverage}\
1278 %{fprofile-arcs|fprofile-generate*|coverage:\
1279 %{!fprofile-update=single:\
1280 %{pthread:-fprofile-update=prefer-atomic}}}";
1282 static const char *asm_options
=
1283 "%{-target-help:%:print-asm-header()} "
1285 /* If GNU AS is used, then convert -w (no warnings), -I, and -v
1286 to the assembler equivalents. */
1287 "%{v} %{w:-W} %{I*} "
1289 "%(asm_debug_option)"
1290 ASM_COMPRESS_DEBUG_SPEC
1291 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
1293 static const char *invoke_as
=
1294 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1296 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
1297 %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
1301 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
1302 %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
1306 /* Some compilers have limits on line lengths, and the multilib_select
1307 and/or multilib_matches strings can be very long, so we build them at
1309 static struct obstack multilib_obstack
;
1310 static const char *multilib_select
;
1311 static const char *multilib_matches
;
1312 static const char *multilib_defaults
;
1313 static const char *multilib_exclusions
;
1314 static const char *multilib_reuse
;
1316 /* Check whether a particular argument is a default argument. */
1318 #ifndef MULTILIB_DEFAULTS
1319 #define MULTILIB_DEFAULTS { "" }
1322 static const char *const multilib_defaults_raw
[] = MULTILIB_DEFAULTS
;
1324 #ifndef DRIVER_SELF_SPECS
1325 #define DRIVER_SELF_SPECS ""
1328 /* Linking to libgomp implies pthreads. This is particularly important
1329 for targets that use different start files and suchlike. */
1330 #ifndef GOMP_SELF_SPECS
1331 #define GOMP_SELF_SPECS \
1332 "%{fopenacc|fopenmp|%:gt(%{ftree-parallelize-loops=*:%*} 1): " \
1336 /* Likewise for -fgnu-tm. */
1337 #ifndef GTM_SELF_SPECS
1338 #define GTM_SELF_SPECS "%{fgnu-tm: -pthread}"
1341 static const char *const driver_self_specs
[] = {
1342 "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
1343 DRIVER_SELF_SPECS
, CONFIGURE_SPECS
, GOMP_SELF_SPECS
, GTM_SELF_SPECS
1346 #ifndef OPTION_DEFAULT_SPECS
1347 #define OPTION_DEFAULT_SPECS { "", "" }
1356 static const struct default_spec
1357 option_default_specs
[] = { OPTION_DEFAULT_SPECS
};
1361 struct user_specs
*next
;
1362 const char *filename
;
1365 static struct user_specs
*user_specs_head
, *user_specs_tail
;
1368 /* Record the mapping from file suffixes for compilation specs. */
1372 const char *suffix
; /* Use this compiler for input files
1373 whose names end in this suffix. */
1375 const char *spec
; /* To use this compiler, run this spec. */
1377 const char *cpp_spec
; /* If non-NULL, substitute this spec
1378 for `%C', rather than the usual
1380 int combinable
; /* If nonzero, compiler can deal with
1381 multiple source files at once (IMA). */
1382 int needs_preprocessing
; /* If nonzero, source files need to
1383 be run through a preprocessor. */
1386 /* Pointer to a vector of `struct compiler' that gives the spec for
1387 compiling a file, based on its suffix.
1388 A file that does not end in any of these suffixes will be passed
1389 unchanged to the loader and nothing else will be done to it.
1391 An entry containing two 0s is used to terminate the vector.
1393 If multiple entries match a file, the last matching one is used. */
1395 static struct compiler
*compilers
;
1397 /* Number of entries in `compilers', not counting the null terminator. */
1399 static int n_compilers
;
1401 /* The default list of file name suffixes and their compilation specs. */
1403 static const struct compiler default_compilers
[] =
1405 /* Add lists of suffixes of known languages here. If those languages
1406 were not present when we built the driver, we will hit these copies
1407 and be given a more meaningful error than "file not used since
1408 linking is not done". */
1409 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0},
1410 {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
1411 {".mii", "#Objective-C++", 0, 0, 0},
1412 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
1413 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
1414 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
1415 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
1416 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
1417 {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
1418 {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
1419 {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
1420 {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
1421 {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
1422 {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
1423 {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
1424 {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
1425 {".r", "#Ratfor", 0, 0, 0},
1426 {".go", "#Go", 0, 1, 0},
1427 {".d", "#D", 0, 1, 0}, {".dd", "#D", 0, 1, 0}, {".di", "#D", 0, 1, 0},
1428 /* Next come the entries for C. */
1429 {".c", "@c", 0, 0, 1},
1431 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1432 external preprocessor if -save-temps is given. */
1433 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1436 %eGNU C no longer supports -traditional without -E}\
1437 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1438 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1439 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1441 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1442 cc1 %(cpp_unique_options) %(cc1_options)}}}\
1443 %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 1},
1445 "%{!E:%e-E or -x required when input is from standard input}\
1446 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
1447 {".h", "@c-header", 0, 0, 0},
1449 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1450 external preprocessor if -save-temps is given. */
1451 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1453 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1454 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1455 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1457 %{!fsyntax-only:%{!S:-o %g.s} \
1458 %{!fdump-ada-spec*:%{!o*:--output-pch=%i.gch}\
1459 %W{o*:--output-pch=%*}}%V}}\
1460 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1461 cc1 %(cpp_unique_options) %(cc1_options)\
1462 %{!fsyntax-only:%{!S:-o %g.s} \
1463 %{!fdump-ada-spec*:%{!o*:--output-pch=%i.gch}\
1464 %W{o*:--output-pch=%*}}%V}}}}}}}", 0, 0, 0},
1465 {".i", "@cpp-output", 0, 0, 0},
1467 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 0},
1468 {".s", "@assembler", 0, 0, 0},
1470 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 0, 0},
1471 {".sx", "@assembler-with-cpp", 0, 0, 0},
1472 {".S", "@assembler-with-cpp", 0, 0, 0},
1473 {"@assembler-with-cpp",
1474 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1475 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1476 %{E|M|MM:%(cpp_debug_options)}\
1477 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1478 as %(asm_debug) %(asm_options) %|.s %A }}}}"
1480 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1481 %{E|M|MM:%(cpp_debug_options)}\
1482 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1483 as %(asm_debug) %(asm_options) %m.s %A }}}}"
1488 /* Mark end of table. */
1492 /* Number of elements in default_compilers, not counting the terminator. */
1494 static const int n_default_compilers
= ARRAY_SIZE (default_compilers
) - 1;
1496 typedef char *char_p
; /* For DEF_VEC_P. */
1498 /* A vector of options to give to the linker.
1499 These options are accumulated by %x,
1500 and substituted into the linker command with %X. */
1501 static vec
<char_p
> linker_options
;
1503 /* A vector of options to give to the assembler.
1504 These options are accumulated by -Wa,
1505 and substituted into the assembler command with %Y. */
1506 static vec
<char_p
> assembler_options
;
1508 /* A vector of options to give to the preprocessor.
1509 These options are accumulated by -Wp,
1510 and substituted into the preprocessor command with %Z. */
1511 static vec
<char_p
> preprocessor_options
;
1514 skip_whitespace (char *p
)
1518 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1519 be considered whitespace. */
1520 if (p
[0] == '\n' && p
[1] == '\n' && p
[2] == '\n')
1522 else if (*p
== '\n' || *p
== ' ' || *p
== '\t')
1536 /* Structures to keep track of prefixes to try when looking for files. */
1540 const char *prefix
; /* String to prepend to the path. */
1541 struct prefix_list
*next
; /* Next in linked list. */
1542 int require_machine_suffix
; /* Don't use without machine_suffix. */
1543 /* 2 means try both machine_suffix and just_machine_suffix. */
1544 int priority
; /* Sort key - priority within list. */
1545 int os_multilib
; /* 1 if OS multilib scheme should be used,
1546 0 for GCC multilib scheme. */
1551 struct prefix_list
*plist
; /* List of prefixes to try */
1552 int max_len
; /* Max length of a prefix in PLIST */
1553 const char *name
; /* Name of this list (used in config stuff) */
1556 /* List of prefixes to try when looking for executables. */
1558 static struct path_prefix exec_prefixes
= { 0, 0, "exec" };
1560 /* List of prefixes to try when looking for startup (crt0) files. */
1562 static struct path_prefix startfile_prefixes
= { 0, 0, "startfile" };
1564 /* List of prefixes to try when looking for include files. */
1566 static struct path_prefix include_prefixes
= { 0, 0, "include" };
1568 /* Suffix to attach to directories searched for commands.
1569 This looks like `MACHINE/VERSION/'. */
1571 static const char *machine_suffix
= 0;
1573 /* Suffix to attach to directories searched for commands.
1574 This is just `MACHINE/'. */
1576 static const char *just_machine_suffix
= 0;
1578 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1580 static const char *gcc_exec_prefix
;
1582 /* Adjusted value of standard_libexec_prefix. */
1584 static const char *gcc_libexec_prefix
;
1586 /* Default prefixes to attach to command names. */
1588 #ifndef STANDARD_STARTFILE_PREFIX_1
1589 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1591 #ifndef STANDARD_STARTFILE_PREFIX_2
1592 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1595 #ifdef CROSS_DIRECTORY_STRUCTURE /* Don't use these prefixes for a cross compiler. */
1596 #undef MD_EXEC_PREFIX
1597 #undef MD_STARTFILE_PREFIX
1598 #undef MD_STARTFILE_PREFIX_1
1601 /* If no prefixes defined, use the null string, which will disable them. */
1602 #ifndef MD_EXEC_PREFIX
1603 #define MD_EXEC_PREFIX ""
1605 #ifndef MD_STARTFILE_PREFIX
1606 #define MD_STARTFILE_PREFIX ""
1608 #ifndef MD_STARTFILE_PREFIX_1
1609 #define MD_STARTFILE_PREFIX_1 ""
1612 /* These directories are locations set at configure-time based on the
1613 --prefix option provided to configure. Their initializers are
1614 defined in Makefile.in. These paths are not *directly* used when
1615 gcc_exec_prefix is set because, in that case, we know where the
1616 compiler has been installed, and use paths relative to that
1617 location instead. */
1618 static const char *const standard_exec_prefix
= STANDARD_EXEC_PREFIX
;
1619 static const char *const standard_libexec_prefix
= STANDARD_LIBEXEC_PREFIX
;
1620 static const char *const standard_bindir_prefix
= STANDARD_BINDIR_PREFIX
;
1621 static const char *const standard_startfile_prefix
= STANDARD_STARTFILE_PREFIX
;
1623 /* For native compilers, these are well-known paths containing
1624 components that may be provided by the system. For cross
1625 compilers, these paths are not used. */
1626 static const char *md_exec_prefix
= MD_EXEC_PREFIX
;
1627 static const char *md_startfile_prefix
= MD_STARTFILE_PREFIX
;
1628 static const char *md_startfile_prefix_1
= MD_STARTFILE_PREFIX_1
;
1629 static const char *const standard_startfile_prefix_1
1630 = STANDARD_STARTFILE_PREFIX_1
;
1631 static const char *const standard_startfile_prefix_2
1632 = STANDARD_STARTFILE_PREFIX_2
;
1634 /* A relative path to be used in finding the location of tools
1635 relative to the driver. */
1636 static const char *const tooldir_base_prefix
= TOOLDIR_BASE_PREFIX
;
1638 /* A prefix to be used when this is an accelerator compiler. */
1639 static const char *const accel_dir_suffix
= ACCEL_DIR_SUFFIX
;
1641 /* Subdirectory to use for locating libraries. Set by
1642 set_multilib_dir based on the compilation options. */
1644 static const char *multilib_dir
;
1646 /* Subdirectory to use for locating libraries in OS conventions. Set by
1647 set_multilib_dir based on the compilation options. */
1649 static const char *multilib_os_dir
;
1651 /* Subdirectory to use for locating libraries in multiarch conventions. Set by
1652 set_multilib_dir based on the compilation options. */
1654 static const char *multiarch_dir
;
1656 /* Structure to keep track of the specs that have been defined so far.
1657 These are accessed using %(specname) in a compiler or link
1662 /* The following 2 fields must be first */
1663 /* to allow EXTRA_SPECS to be initialized */
1664 const char *name
; /* name of the spec. */
1665 const char *ptr
; /* available ptr if no static pointer */
1667 /* The following fields are not initialized */
1668 /* by EXTRA_SPECS */
1669 const char **ptr_spec
; /* pointer to the spec itself. */
1670 struct spec_list
*next
; /* Next spec in linked list. */
1671 int name_len
; /* length of the name */
1672 bool user_p
; /* whether string come from file spec. */
1673 bool alloc_p
; /* whether string was allocated */
1674 const char *default_ptr
; /* The default value of *ptr_spec. */
1677 #define INIT_STATIC_SPEC(NAME,PTR) \
1678 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, false, false, \
1681 /* List of statically defined specs. */
1682 static struct spec_list static_specs
[] =
1684 INIT_STATIC_SPEC ("asm", &asm_spec
),
1685 INIT_STATIC_SPEC ("asm_debug", &asm_debug
),
1686 INIT_STATIC_SPEC ("asm_debug_option", &asm_debug_option
),
1687 INIT_STATIC_SPEC ("asm_final", &asm_final_spec
),
1688 INIT_STATIC_SPEC ("asm_options", &asm_options
),
1689 INIT_STATIC_SPEC ("invoke_as", &invoke_as
),
1690 INIT_STATIC_SPEC ("cpp", &cpp_spec
),
1691 INIT_STATIC_SPEC ("cpp_options", &cpp_options
),
1692 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options
),
1693 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options
),
1694 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp
),
1695 INIT_STATIC_SPEC ("cc1", &cc1_spec
),
1696 INIT_STATIC_SPEC ("cc1_options", &cc1_options
),
1697 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec
),
1698 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec
),
1699 INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec
),
1700 INIT_STATIC_SPEC ("endfile", &endfile_spec
),
1701 INIT_STATIC_SPEC ("link", &link_spec
),
1702 INIT_STATIC_SPEC ("lib", &lib_spec
),
1703 INIT_STATIC_SPEC ("link_gomp", &link_gomp_spec
),
1704 INIT_STATIC_SPEC ("libgcc", &libgcc_spec
),
1705 INIT_STATIC_SPEC ("startfile", &startfile_spec
),
1706 INIT_STATIC_SPEC ("cross_compile", &cross_compile
),
1707 INIT_STATIC_SPEC ("version", &compiler_version
),
1708 INIT_STATIC_SPEC ("multilib", &multilib_select
),
1709 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults
),
1710 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra
),
1711 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches
),
1712 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions
),
1713 INIT_STATIC_SPEC ("multilib_options", &multilib_options
),
1714 INIT_STATIC_SPEC ("multilib_reuse", &multilib_reuse
),
1715 INIT_STATIC_SPEC ("linker", &linker_name_spec
),
1716 INIT_STATIC_SPEC ("linker_plugin_file", &linker_plugin_file_spec
),
1717 INIT_STATIC_SPEC ("lto_wrapper", <o_wrapper_spec
),
1718 INIT_STATIC_SPEC ("lto_gcc", <o_gcc_spec
),
1719 INIT_STATIC_SPEC ("post_link", &post_link_spec
),
1720 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec
),
1721 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix
),
1722 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix
),
1723 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1
),
1724 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec
),
1725 INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec
),
1726 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec
),
1727 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec
),
1728 INIT_STATIC_SPEC ("self_spec", &self_spec
),
1731 #ifdef EXTRA_SPECS /* additional specs needed */
1732 /* Structure to keep track of just the first two args of a spec_list.
1733 That is all that the EXTRA_SPECS macro gives us. */
1736 const char *const name
;
1737 const char *const ptr
;
1740 static const struct spec_list_1 extra_specs_1
[] = { EXTRA_SPECS
};
1741 static struct spec_list
*extra_specs
= (struct spec_list
*) 0;
1744 /* List of dynamically allocates specs that have been defined so far. */
1746 static struct spec_list
*specs
= (struct spec_list
*) 0;
1748 /* List of static spec functions. */
1750 static const struct spec_function static_spec_functions
[] =
1752 { "getenv", getenv_spec_function
},
1753 { "if-exists", if_exists_spec_function
},
1754 { "if-exists-else", if_exists_else_spec_function
},
1755 { "if-exists-then-else", if_exists_then_else_spec_function
},
1756 { "sanitize", sanitize_spec_function
},
1757 { "replace-outfile", replace_outfile_spec_function
},
1758 { "remove-outfile", remove_outfile_spec_function
},
1759 { "version-compare", version_compare_spec_function
},
1760 { "include", include_spec_function
},
1761 { "find-file", find_file_spec_function
},
1762 { "find-plugindir", find_plugindir_spec_function
},
1763 { "print-asm-header", print_asm_header_spec_function
},
1764 { "compare-debug-dump-opt", compare_debug_dump_opt_spec_function
},
1765 { "compare-debug-self-opt", compare_debug_self_opt_spec_function
},
1766 { "pass-through-libs", pass_through_libs_spec_func
},
1767 { "dumps", dumps_spec_func
},
1768 { "gt", greater_than_spec_func
},
1769 { "debug-level-gt", debug_level_greater_than_spec_func
},
1770 { "dwarf-version-gt", dwarf_version_greater_than_spec_func
},
1771 { "fortran-preinclude-file", find_fortran_preinclude_file
},
1772 #ifdef EXTRA_SPEC_FUNCTIONS
1773 EXTRA_SPEC_FUNCTIONS
1778 static int processing_spec_function
;
1780 /* Add appropriate libgcc specs to OBSTACK, taking into account
1781 various permutations of -shared-libgcc, -shared, and such. */
1783 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1785 #ifndef USE_LD_AS_NEEDED
1786 #define USE_LD_AS_NEEDED 0
1790 init_gcc_specs (struct obstack
*obstack
, const char *shared_name
,
1791 const char *static_name
, const char *eh_name
)
1795 #if USE_LD_AS_NEEDED
1796 buf
= concat ("%{static|static-libgcc|static-pie:", static_name
, " ", eh_name
, "}"
1797 "%{!static:%{!static-libgcc:%{!static-pie:"
1798 "%{!shared-libgcc:",
1799 static_name
, " " LD_AS_NEEDED_OPTION
" ",
1800 shared_name
, " " LD_NO_AS_NEEDED_OPTION
1803 shared_name
, "%{!shared: ", static_name
, "}"
1806 buf
= concat ("%{static|static-libgcc:", static_name
, " ", eh_name
, "}"
1807 "%{!static:%{!static-libgcc:"
1809 "%{!shared-libgcc:", static_name
, " ", eh_name
, "}"
1810 "%{shared-libgcc:", shared_name
, " ", static_name
, "}"
1814 "%{shared-libgcc:", shared_name
, "}"
1815 "%{!shared-libgcc:", static_name
, "}"
1818 "%{shared:", shared_name
, "}"
1823 obstack_grow (obstack
, buf
, strlen (buf
));
1826 #endif /* ENABLE_SHARED_LIBGCC */
1828 /* Initialize the specs lookup routines. */
1833 struct spec_list
*next
= (struct spec_list
*) 0;
1834 struct spec_list
*sl
= (struct spec_list
*) 0;
1838 return; /* Already initialized. */
1841 fnotice (stderr
, "Using built-in specs.\n");
1844 extra_specs
= XCNEWVEC (struct spec_list
, ARRAY_SIZE (extra_specs_1
));
1846 for (i
= ARRAY_SIZE (extra_specs_1
) - 1; i
>= 0; i
--)
1848 sl
= &extra_specs
[i
];
1849 sl
->name
= extra_specs_1
[i
].name
;
1850 sl
->ptr
= extra_specs_1
[i
].ptr
;
1852 sl
->name_len
= strlen (sl
->name
);
1853 sl
->ptr_spec
= &sl
->ptr
;
1854 gcc_assert (sl
->ptr_spec
!= NULL
);
1855 sl
->default_ptr
= sl
->ptr
;
1860 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1862 sl
= &static_specs
[i
];
1867 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1868 /* ??? If neither -shared-libgcc nor --static-libgcc was
1869 seen, then we should be making an educated guess. Some proposed
1870 heuristics for ELF include:
1872 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1873 program will be doing dynamic loading, which will likely
1874 need the shared libgcc.
1876 (2) If "-ldl", then it's also a fair bet that we're doing
1879 (3) For each ET_DYN we're linking against (either through -lfoo
1880 or /some/path/foo.so), check to see whether it or one of
1881 its dependencies depends on a shared libgcc.
1885 If the runtime is fixed to look for program headers instead
1886 of calling __register_frame_info at all, for each object,
1887 use the shared libgcc if any EH symbol referenced.
1889 If crtstuff is fixed to not invoke __register_frame_info
1890 automatically, for each object, use the shared libgcc if
1891 any non-empty unwind section found.
1893 Doing any of this probably requires invoking an external program to
1894 do the actual object file scanning. */
1896 const char *p
= libgcc_spec
;
1899 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1900 when given the proper command line arguments. */
1903 if (in_sep
&& *p
== '-' && strncmp (p
, "-lgcc", 5) == 0)
1905 init_gcc_specs (&obstack
,
1907 #ifdef USE_LIBUNWIND_EXCEPTIONS
1913 #ifdef USE_LIBUNWIND_EXCEPTIONS
1914 # ifdef HAVE_LD_STATIC_DYNAMIC
1915 " %{!static:%{!static-pie:" LD_STATIC_OPTION
"}} -lunwind"
1916 " %{!static:%{!static-pie:" LD_DYNAMIC_OPTION
"}}"
1926 else if (in_sep
&& *p
== 'l' && strncmp (p
, "libgcc.a%s", 10) == 0)
1928 /* Ug. We don't know shared library extensions. Hope that
1929 systems that use this form don't do shared libraries. */
1930 init_gcc_specs (&obstack
,
1934 #ifdef USE_LIBUNWIND_EXCEPTIONS
1943 obstack_1grow (&obstack
, *p
);
1944 in_sep
= (*p
== ' ');
1949 obstack_1grow (&obstack
, '\0');
1950 libgcc_spec
= XOBFINISH (&obstack
, const char *);
1953 #ifdef USE_AS_TRADITIONAL_FORMAT
1954 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1956 static const char tf
[] = "--traditional-format ";
1957 obstack_grow (&obstack
, tf
, sizeof (tf
) - 1);
1958 obstack_grow0 (&obstack
, asm_spec
, strlen (asm_spec
));
1959 asm_spec
= XOBFINISH (&obstack
, const char *);
1963 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC || \
1964 defined LINKER_HASH_STYLE
1965 # ifdef LINK_BUILDID_SPEC
1966 /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. */
1967 obstack_grow (&obstack
, LINK_BUILDID_SPEC
, sizeof (LINK_BUILDID_SPEC
) - 1);
1969 # ifdef LINK_EH_SPEC
1970 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1971 obstack_grow (&obstack
, LINK_EH_SPEC
, sizeof (LINK_EH_SPEC
) - 1);
1973 # ifdef LINKER_HASH_STYLE
1974 /* Prepend --hash-style=LINKER_HASH_STYLE to whatever link_spec we had
1977 static const char hash_style
[] = "--hash-style=";
1978 obstack_grow (&obstack
, hash_style
, sizeof (hash_style
) - 1);
1979 obstack_grow (&obstack
, LINKER_HASH_STYLE
, sizeof (LINKER_HASH_STYLE
) - 1);
1980 obstack_1grow (&obstack
, ' ');
1983 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
1984 link_spec
= XOBFINISH (&obstack
, const char *);
1990 /* Update the entry for SPEC in the static_specs table to point to VALUE,
1991 ensuring that we free the previous value if necessary. Set alloc_p for the
1992 entry to ALLOC_P: this determines whether we take ownership of VALUE (i.e.
1993 whether we need to free it later on). */
1995 set_static_spec (const char **spec
, const char *value
, bool alloc_p
)
1997 struct spec_list
*sl
= NULL
;
1999 for (unsigned i
= 0; i
< ARRAY_SIZE (static_specs
); i
++)
2001 if (static_specs
[i
].ptr_spec
== spec
)
2003 sl
= static_specs
+ i
;
2012 const char *old
= *spec
;
2013 free (const_cast <char *> (old
));
2017 sl
->alloc_p
= alloc_p
;
2020 /* Update a static spec to a new string, taking ownership of that
2022 static void set_static_spec_owned (const char **spec
, const char *val
)
2024 return set_static_spec (spec
, val
, true);
2027 /* Update a static spec to point to a new value, but don't take
2028 ownership of (i.e. don't free) that string. */
2029 static void set_static_spec_shared (const char **spec
, const char *val
)
2031 return set_static_spec (spec
, val
, false);
2035 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
2036 removed; If the spec starts with a + then SPEC is added to the end of the
2040 set_spec (const char *name
, const char *spec
, bool user_p
)
2042 struct spec_list
*sl
;
2043 const char *old_spec
;
2044 int name_len
= strlen (name
);
2047 /* If this is the first call, initialize the statically allocated specs. */
2050 struct spec_list
*next
= (struct spec_list
*) 0;
2051 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
2053 sl
= &static_specs
[i
];
2060 /* See if the spec already exists. */
2061 for (sl
= specs
; sl
; sl
= sl
->next
)
2062 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, name
))
2067 /* Not found - make it. */
2068 sl
= XNEW (struct spec_list
);
2069 sl
->name
= xstrdup (name
);
2070 sl
->name_len
= name_len
;
2071 sl
->ptr_spec
= &sl
->ptr
;
2073 *(sl
->ptr_spec
) = "";
2075 sl
->default_ptr
= NULL
;
2079 old_spec
= *(sl
->ptr_spec
);
2080 *(sl
->ptr_spec
) = ((spec
[0] == '+' && ISSPACE ((unsigned char)spec
[1]))
2081 ? concat (old_spec
, spec
+ 1, NULL
)
2086 fnotice (stderr
, "Setting spec %s to '%s'\n\n", name
, *(sl
->ptr_spec
));
2089 /* Free the old spec. */
2090 if (old_spec
&& sl
->alloc_p
)
2091 free (CONST_CAST (char *, old_spec
));
2093 sl
->user_p
= user_p
;
2097 /* Accumulate a command (program name and args), and run it. */
2099 typedef const char *const_char_p
; /* For DEF_VEC_P. */
2101 /* Vector of pointers to arguments in the current line of specifications. */
2102 static vec
<const_char_p
> argbuf
;
2104 /* Likewise, but for the current @file. */
2105 static vec
<const_char_p
> at_file_argbuf
;
2107 /* Whether an @file is currently open. */
2108 static bool in_at_file
= false;
2110 /* Were the options -c, -S or -E passed. */
2111 static int have_c
= 0;
2113 /* Was the option -o passed. */
2114 static int have_o
= 0;
2116 /* Was the option -E passed. */
2117 static int have_E
= 0;
2119 /* Pointer to output file name passed in with -o. */
2120 static const char *output_file
= 0;
2122 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
2123 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
2126 static struct temp_name
{
2127 const char *suffix
; /* suffix associated with the code. */
2128 int length
; /* strlen (suffix). */
2129 int unique
; /* Indicates whether %g or %u/%U was used. */
2130 const char *filename
; /* associated filename. */
2131 int filename_length
; /* strlen (filename). */
2132 struct temp_name
*next
;
2135 /* Number of commands executed so far. */
2137 static int execution_count
;
2139 /* Number of commands that exited with a signal. */
2141 static int signal_count
;
2143 /* Allocate the argument vector. */
2149 at_file_argbuf
.create (10);
2152 /* Clear out the vector of arguments (after a command is executed). */
2157 argbuf
.truncate (0);
2158 at_file_argbuf
.truncate (0);
2161 /* Add one argument to the vector at the end.
2162 This is done when a space is seen or at the end of the line.
2163 If DELETE_ALWAYS is nonzero, the arg is a filename
2164 and the file should be deleted eventually.
2165 If DELETE_FAILURE is nonzero, the arg is a filename
2166 and the file should be deleted if this compilation fails. */
2169 store_arg (const char *arg
, int delete_always
, int delete_failure
)
2172 at_file_argbuf
.safe_push (arg
);
2174 argbuf
.safe_push (arg
);
2176 if (delete_always
|| delete_failure
)
2179 /* If the temporary file we should delete is specified as
2180 part of a joined argument extract the filename. */
2182 && (p
= strrchr (arg
, '=')))
2184 record_temp_file (arg
, delete_always
, delete_failure
);
2188 /* Open a temporary @file into which subsequent arguments will be stored. */
2194 fatal_error (input_location
, "cannot open nested response file");
2199 /* Create a temporary @file name. */
2201 static char *make_at_file (void)
2203 static int fileno
= 0;
2205 const char *base
, *ext
;
2207 if (!save_temps_flag
)
2208 return make_temp_file ("");
2211 if (!(base
&& *base
))
2213 if (!(base
&& *base
))
2216 sprintf (filename
, ".args.%d", fileno
++);
2219 if (base
== dumpdir
&& dumpdir_trailing_dash_added
)
2222 return concat (base
, ext
, NULL
);
2225 /* Close the temporary @file and add @file to the argument list. */
2228 close_at_file (void)
2231 fatal_error (input_location
, "cannot close nonexistent response file");
2235 const unsigned int n_args
= at_file_argbuf
.length ();
2239 char **argv
= (char **) alloca (sizeof (char *) * (n_args
+ 1));
2240 char *temp_file
= make_at_file ();
2241 char *at_argument
= concat ("@", temp_file
, NULL
);
2242 FILE *f
= fopen (temp_file
, "w");
2246 /* Copy the strings over. */
2247 for (i
= 0; i
< n_args
; i
++)
2248 argv
[i
] = CONST_CAST (char *, at_file_argbuf
[i
]);
2251 at_file_argbuf
.truncate (0);
2254 fatal_error (input_location
, "could not open temporary response file %s",
2257 status
= writeargv (argv
, f
);
2260 fatal_error (input_location
,
2261 "could not write to temporary response file %s",
2264 status
= fclose (f
);
2267 fatal_error (input_location
, "could not close temporary response file %s",
2270 store_arg (at_argument
, 0, 0);
2272 record_temp_file (temp_file
, !save_temps_flag
, !save_temps_flag
);
2275 /* Load specs from a file name named FILENAME, replacing occurrences of
2276 various different types of line-endings, \r\n, \n\r and just \r, with
2280 load_specs (const char *filename
)
2284 struct stat statbuf
;
2291 fnotice (stderr
, "Reading specs from %s\n", filename
);
2293 /* Open and stat the file. */
2294 desc
= open (filename
, O_RDONLY
, 0);
2298 /* This leaves DESC open, but the OS will save us. */
2299 fatal_error (input_location
, "cannot read spec file %qs: %m", filename
);
2302 if (stat (filename
, &statbuf
) < 0)
2305 /* Read contents of file into BUFFER. */
2306 buffer
= XNEWVEC (char, statbuf
.st_size
+ 1);
2307 readlen
= read (desc
, buffer
, (unsigned) statbuf
.st_size
);
2310 buffer
[readlen
] = 0;
2313 specs
= XNEWVEC (char, readlen
+ 1);
2315 for (buffer_p
= buffer
; buffer_p
&& *buffer_p
; buffer_p
++)
2321 if (buffer_p
> buffer
&& *(buffer_p
- 1) == '\n') /* \n\r */
2323 else if (*(buffer_p
+ 1) == '\n') /* \r\n */
2337 /* Read compilation specs from a file named FILENAME,
2338 replacing the default ones.
2340 A suffix which starts with `*' is a definition for
2341 one of the machine-specific sub-specs. The "suffix" should be
2342 *asm, *cc1, *cpp, *link, *startfile, etc.
2343 The corresponding spec is stored in asm_spec, etc.,
2344 rather than in the `compilers' vector.
2346 Anything invalid in the file is a fatal error. */
2349 read_specs (const char *filename
, bool main_p
, bool user_p
)
2354 buffer
= load_specs (filename
);
2356 /* Scan BUFFER for specs, putting them in the vector. */
2362 char *in
, *out
, *p1
, *p2
, *p3
;
2364 /* Advance P in BUFFER to the next nonblank nocomment line. */
2365 p
= skip_whitespace (p
);
2369 /* Is this a special command that starts with '%'? */
2370 /* Don't allow this for the main specs file, since it would
2371 encourage people to overwrite it. */
2372 if (*p
== '%' && !main_p
)
2375 while (*p
&& *p
!= '\n')
2381 if (!strncmp (p1
, "%include", sizeof ("%include") - 1)
2382 && (p1
[sizeof "%include" - 1] == ' '
2383 || p1
[sizeof "%include" - 1] == '\t'))
2387 p1
+= sizeof ("%include");
2388 while (*p1
== ' ' || *p1
== '\t')
2391 if (*p1
++ != '<' || p
[-2] != '>')
2392 fatal_error (input_location
,
2393 "specs %%include syntax malformed after "
2395 (long) (p1
- buffer
+ 1));
2398 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
2399 read_specs (new_filename
? new_filename
: p1
, false, user_p
);
2402 else if (!strncmp (p1
, "%include_noerr", sizeof "%include_noerr" - 1)
2403 && (p1
[sizeof "%include_noerr" - 1] == ' '
2404 || p1
[sizeof "%include_noerr" - 1] == '\t'))
2408 p1
+= sizeof "%include_noerr";
2409 while (*p1
== ' ' || *p1
== '\t')
2412 if (*p1
++ != '<' || p
[-2] != '>')
2413 fatal_error (input_location
,
2414 "specs %%include syntax malformed after "
2416 (long) (p1
- buffer
+ 1));
2419 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
2421 read_specs (new_filename
, false, user_p
);
2422 else if (verbose_flag
)
2423 fnotice (stderr
, "could not find specs file %s\n", p1
);
2426 else if (!strncmp (p1
, "%rename", sizeof "%rename" - 1)
2427 && (p1
[sizeof "%rename" - 1] == ' '
2428 || p1
[sizeof "%rename" - 1] == '\t'))
2431 struct spec_list
*sl
;
2432 struct spec_list
*newsl
;
2434 /* Get original name. */
2435 p1
+= sizeof "%rename";
2436 while (*p1
== ' ' || *p1
== '\t')
2439 if (! ISALPHA ((unsigned char) *p1
))
2440 fatal_error (input_location
,
2441 "specs %%rename syntax malformed after "
2443 (long) (p1
- buffer
));
2446 while (*p2
&& !ISSPACE ((unsigned char) *p2
))
2449 if (*p2
!= ' ' && *p2
!= '\t')
2450 fatal_error (input_location
,
2451 "specs %%rename syntax malformed after "
2453 (long) (p2
- buffer
));
2457 while (*p2
== ' ' || *p2
== '\t')
2460 if (! ISALPHA ((unsigned char) *p2
))
2461 fatal_error (input_location
,
2462 "specs %%rename syntax malformed after "
2464 (long) (p2
- buffer
));
2466 /* Get new spec name. */
2468 while (*p3
&& !ISSPACE ((unsigned char) *p3
))
2472 fatal_error (input_location
,
2473 "specs %%rename syntax malformed after "
2475 (long) (p3
- buffer
));
2478 for (sl
= specs
; sl
; sl
= sl
->next
)
2479 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, p1
))
2483 fatal_error (input_location
,
2484 "specs %s spec was not found to be renamed", p1
);
2486 if (strcmp (p1
, p2
) == 0)
2489 for (newsl
= specs
; newsl
; newsl
= newsl
->next
)
2490 if (strcmp (newsl
->name
, p2
) == 0)
2491 fatal_error (input_location
,
2492 "%s: attempt to rename spec %qs to "
2493 "already defined spec %qs",
2498 fnotice (stderr
, "rename spec %s to %s\n", p1
, p2
);
2500 fnotice (stderr
, "spec is '%s'\n\n", *(sl
->ptr_spec
));
2504 set_spec (p2
, *(sl
->ptr_spec
), user_p
);
2506 free (CONST_CAST (char *, *(sl
->ptr_spec
)));
2508 *(sl
->ptr_spec
) = "";
2513 fatal_error (input_location
,
2514 "specs unknown %% command after %ld characters",
2515 (long) (p1
- buffer
));
2518 /* Find the colon that should end the suffix. */
2520 while (*p1
&& *p1
!= ':' && *p1
!= '\n')
2523 /* The colon shouldn't be missing. */
2525 fatal_error (input_location
,
2526 "specs file malformed after %ld characters",
2527 (long) (p1
- buffer
));
2529 /* Skip back over trailing whitespace. */
2531 while (p2
> buffer
&& (p2
[-1] == ' ' || p2
[-1] == '\t'))
2534 /* Copy the suffix to a string. */
2535 suffix
= save_string (p
, p2
- p
);
2536 /* Find the next line. */
2537 p
= skip_whitespace (p1
+ 1);
2539 fatal_error (input_location
,
2540 "specs file malformed after %ld characters",
2541 (long) (p
- buffer
));
2544 /* Find next blank line or end of string. */
2545 while (*p1
&& !(*p1
== '\n' && (p1
[1] == '\n' || p1
[1] == '\0')))
2548 /* Specs end at the blank line and do not include the newline. */
2549 spec
= save_string (p
, p1
- p
);
2552 /* Delete backslash-newline sequences from the spec. */
2557 if (in
[0] == '\\' && in
[1] == '\n')
2559 else if (in
[0] == '#')
2560 while (*in
&& *in
!= '\n')
2568 if (suffix
[0] == '*')
2570 if (! strcmp (suffix
, "*link_command"))
2571 link_command_spec
= spec
;
2574 set_spec (suffix
+ 1, spec
, user_p
);
2580 /* Add this pair to the vector. */
2582 = XRESIZEVEC (struct compiler
, compilers
, n_compilers
+ 2);
2584 compilers
[n_compilers
].suffix
= suffix
;
2585 compilers
[n_compilers
].spec
= spec
;
2587 memset (&compilers
[n_compilers
], 0, sizeof compilers
[n_compilers
]);
2591 link_command_spec
= spec
;
2594 if (link_command_spec
== 0)
2595 fatal_error (input_location
, "spec file has no spec for linking");
2597 XDELETEVEC (buffer
);
2600 /* Record the names of temporary files we tell compilers to write,
2601 and delete them at the end of the run. */
2603 /* This is the common prefix we use to make temp file names.
2604 It is chosen once for each run of this program.
2605 It is substituted into a spec by %g or %j.
2606 Thus, all temp file names contain this prefix.
2607 In practice, all temp file names start with this prefix.
2609 This prefix comes from the envvar TMPDIR if it is defined;
2610 otherwise, from the P_tmpdir macro if that is defined;
2611 otherwise, in /usr/tmp or /tmp;
2612 or finally the current directory if all else fails. */
2614 static const char *temp_filename
;
2616 /* Length of the prefix. */
2618 static int temp_filename_length
;
2620 /* Define the list of temporary files to delete. */
2625 struct temp_file
*next
;
2628 /* Queue of files to delete on success or failure of compilation. */
2629 static struct temp_file
*always_delete_queue
;
2630 /* Queue of files to delete on failure of compilation. */
2631 static struct temp_file
*failure_delete_queue
;
2633 /* Record FILENAME as a file to be deleted automatically.
2634 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2635 otherwise delete it in any case.
2636 FAIL_DELETE nonzero means delete it if a compilation step fails;
2637 otherwise delete it in any case. */
2640 record_temp_file (const char *filename
, int always_delete
, int fail_delete
)
2642 char *const name
= xstrdup (filename
);
2646 struct temp_file
*temp
;
2647 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2648 if (! filename_cmp (name
, temp
->name
))
2654 temp
= XNEW (struct temp_file
);
2655 temp
->next
= always_delete_queue
;
2657 always_delete_queue
= temp
;
2664 struct temp_file
*temp
;
2665 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2666 if (! filename_cmp (name
, temp
->name
))
2672 temp
= XNEW (struct temp_file
);
2673 temp
->next
= failure_delete_queue
;
2675 failure_delete_queue
= temp
;
2681 /* Delete all the temporary files whose names we previously recorded. */
2683 #ifndef DELETE_IF_ORDINARY
2684 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2687 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2688 if (unlink (NAME) < 0) \
2690 error ("%s: %m", (NAME)); \
2695 delete_if_ordinary (const char *name
)
2701 printf ("Delete %s? (y or n) ", name
);
2705 while ((c
= getchar ()) != '\n' && c
!= EOF
)
2708 if (i
== 'y' || i
== 'Y')
2710 DELETE_IF_ORDINARY (name
, st
, verbose_flag
);
2714 delete_temp_files (void)
2716 struct temp_file
*temp
;
2718 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2719 delete_if_ordinary (temp
->name
);
2720 always_delete_queue
= 0;
2723 /* Delete all the files to be deleted on error. */
2726 delete_failure_queue (void)
2728 struct temp_file
*temp
;
2730 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2731 delete_if_ordinary (temp
->name
);
2735 clear_failure_queue (void)
2737 failure_delete_queue
= 0;
2740 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2742 If DO_MULTI is true iterate over the paths twice, first with multilib
2743 suffix then without, otherwise iterate over the paths once without
2744 adding a multilib suffix. When DO_MULTI is true, some attempt is made
2745 to avoid visiting the same path twice, but we could do better. For
2746 instance, /usr/lib/../lib is considered different from /usr/lib.
2747 At least EXTRA_SPACE chars past the end of the path passed to
2748 CALLBACK are available for use by the callback.
2749 CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2751 Returns the value returned by CALLBACK. */
2754 for_each_path (const struct path_prefix
*paths
,
2757 void *(*callback
) (char *, void *),
2758 void *callback_info
)
2760 struct prefix_list
*pl
;
2761 const char *multi_dir
= NULL
;
2762 const char *multi_os_dir
= NULL
;
2763 const char *multiarch_suffix
= NULL
;
2764 const char *multi_suffix
;
2765 const char *just_multi_suffix
;
2768 bool skip_multi_dir
= false;
2769 bool skip_multi_os_dir
= false;
2771 multi_suffix
= machine_suffix
;
2772 just_multi_suffix
= just_machine_suffix
;
2773 if (do_multi
&& multilib_dir
&& strcmp (multilib_dir
, ".") != 0)
2775 multi_dir
= concat (multilib_dir
, dir_separator_str
, NULL
);
2776 multi_suffix
= concat (multi_suffix
, multi_dir
, NULL
);
2777 just_multi_suffix
= concat (just_multi_suffix
, multi_dir
, NULL
);
2779 if (do_multi
&& multilib_os_dir
&& strcmp (multilib_os_dir
, ".") != 0)
2780 multi_os_dir
= concat (multilib_os_dir
, dir_separator_str
, NULL
);
2782 multiarch_suffix
= concat (multiarch_dir
, dir_separator_str
, NULL
);
2786 size_t multi_dir_len
= 0;
2787 size_t multi_os_dir_len
= 0;
2788 size_t multiarch_len
= 0;
2790 size_t just_suffix_len
;
2794 multi_dir_len
= strlen (multi_dir
);
2796 multi_os_dir_len
= strlen (multi_os_dir
);
2797 if (multiarch_suffix
)
2798 multiarch_len
= strlen (multiarch_suffix
);
2799 suffix_len
= strlen (multi_suffix
);
2800 just_suffix_len
= strlen (just_multi_suffix
);
2804 len
= paths
->max_len
+ extra_space
+ 1;
2805 len
+= MAX (MAX (suffix_len
, multi_os_dir_len
), multiarch_len
);
2806 path
= XNEWVEC (char, len
);
2809 for (pl
= paths
->plist
; pl
!= 0; pl
= pl
->next
)
2811 len
= strlen (pl
->prefix
);
2812 memcpy (path
, pl
->prefix
, len
);
2814 /* Look first in MACHINE/VERSION subdirectory. */
2815 if (!skip_multi_dir
)
2817 memcpy (path
+ len
, multi_suffix
, suffix_len
+ 1);
2818 ret
= callback (path
, callback_info
);
2823 /* Some paths are tried with just the machine (ie. target)
2824 subdir. This is used for finding as, ld, etc. */
2826 && pl
->require_machine_suffix
== 2)
2828 memcpy (path
+ len
, just_multi_suffix
, just_suffix_len
+ 1);
2829 ret
= callback (path
, callback_info
);
2834 /* Now try the multiarch path. */
2836 && !pl
->require_machine_suffix
&& multiarch_dir
)
2838 memcpy (path
+ len
, multiarch_suffix
, multiarch_len
+ 1);
2839 ret
= callback (path
, callback_info
);
2844 /* Now try the base path. */
2845 if (!pl
->require_machine_suffix
2846 && !(pl
->os_multilib
? skip_multi_os_dir
: skip_multi_dir
))
2848 const char *this_multi
;
2849 size_t this_multi_len
;
2851 if (pl
->os_multilib
)
2853 this_multi
= multi_os_dir
;
2854 this_multi_len
= multi_os_dir_len
;
2858 this_multi
= multi_dir
;
2859 this_multi_len
= multi_dir_len
;
2863 memcpy (path
+ len
, this_multi
, this_multi_len
+ 1);
2867 ret
= callback (path
, callback_info
);
2875 if (multi_dir
== NULL
&& multi_os_dir
== NULL
)
2878 /* Run through the paths again, this time without multilibs.
2879 Don't repeat any we have already seen. */
2882 free (CONST_CAST (char *, multi_dir
));
2884 free (CONST_CAST (char *, multi_suffix
));
2885 multi_suffix
= machine_suffix
;
2886 free (CONST_CAST (char *, just_multi_suffix
));
2887 just_multi_suffix
= just_machine_suffix
;
2890 skip_multi_dir
= true;
2893 free (CONST_CAST (char *, multi_os_dir
));
2894 multi_os_dir
= NULL
;
2897 skip_multi_os_dir
= true;
2902 free (CONST_CAST (char *, multi_dir
));
2903 free (CONST_CAST (char *, multi_suffix
));
2904 free (CONST_CAST (char *, just_multi_suffix
));
2907 free (CONST_CAST (char *, multi_os_dir
));
2913 /* Callback for build_search_list. Adds path to obstack being built. */
2915 struct add_to_obstack_info
{
2922 add_to_obstack (char *path
, void *data
)
2924 struct add_to_obstack_info
*info
= (struct add_to_obstack_info
*) data
;
2926 if (info
->check_dir
&& !is_directory (path
, false))
2929 if (!info
->first_time
)
2930 obstack_1grow (info
->ob
, PATH_SEPARATOR
);
2932 obstack_grow (info
->ob
, path
, strlen (path
));
2934 info
->first_time
= false;
2938 /* Add or change the value of an environment variable, outputting the
2939 change to standard error if in verbose mode. */
2941 xputenv (const char *string
)
2946 /* Build a list of search directories from PATHS.
2947 PREFIX is a string to prepend to the list.
2948 If CHECK_DIR_P is true we ensure the directory exists.
2949 If DO_MULTI is true, multilib paths are output first, then
2951 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2952 It is also used by the --print-search-dirs flag. */
2955 build_search_list (const struct path_prefix
*paths
, const char *prefix
,
2956 bool check_dir
, bool do_multi
)
2958 struct add_to_obstack_info info
;
2960 info
.ob
= &collect_obstack
;
2961 info
.check_dir
= check_dir
;
2962 info
.first_time
= true;
2964 obstack_grow (&collect_obstack
, prefix
, strlen (prefix
));
2965 obstack_1grow (&collect_obstack
, '=');
2967 for_each_path (paths
, do_multi
, 0, add_to_obstack
, &info
);
2969 obstack_1grow (&collect_obstack
, '\0');
2970 return XOBFINISH (&collect_obstack
, char *);
2973 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2977 putenv_from_prefixes (const struct path_prefix
*paths
, const char *env_var
,
2980 xputenv (build_search_list (paths
, env_var
, true, do_multi
));
2983 /* Check whether NAME can be accessed in MODE. This is like access,
2984 except that it never considers directories to be executable. */
2987 access_check (const char *name
, int mode
)
2993 if (stat (name
, &st
) < 0
2994 || S_ISDIR (st
.st_mode
))
2998 return access (name
, mode
);
3001 /* Callback for find_a_file. Appends the file name to the directory
3002 path. If the resulting file exists in the right mode, return the
3003 full pathname to the file. */
3005 struct file_at_path_info
{
3014 file_at_path (char *path
, void *data
)
3016 struct file_at_path_info
*info
= (struct file_at_path_info
*) data
;
3017 size_t len
= strlen (path
);
3019 memcpy (path
+ len
, info
->name
, info
->name_len
);
3020 len
+= info
->name_len
;
3022 /* Some systems have a suffix for executable files.
3023 So try appending that first. */
3024 if (info
->suffix_len
)
3026 memcpy (path
+ len
, info
->suffix
, info
->suffix_len
+ 1);
3027 if (access_check (path
, info
->mode
) == 0)
3032 if (access_check (path
, info
->mode
) == 0)
3038 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
3039 access to check permissions. If DO_MULTI is true, search multilib
3040 paths then non-multilib paths, otherwise do not search multilib paths.
3041 Return 0 if not found, otherwise return its name, allocated with malloc. */
3044 find_a_file (const struct path_prefix
*pprefix
, const char *name
, int mode
,
3047 struct file_at_path_info info
;
3049 #ifdef DEFAULT_ASSEMBLER
3050 if (! strcmp (name
, "as") && access (DEFAULT_ASSEMBLER
, mode
) == 0)
3051 return xstrdup (DEFAULT_ASSEMBLER
);
3054 #ifdef DEFAULT_LINKER
3055 if (! strcmp (name
, "ld") && access (DEFAULT_LINKER
, mode
) == 0)
3056 return xstrdup (DEFAULT_LINKER
);
3059 /* Determine the filename to execute (special case for absolute paths). */
3061 if (IS_ABSOLUTE_PATH (name
))
3063 if (access (name
, mode
) == 0)
3064 return xstrdup (name
);
3070 info
.suffix
= (mode
& X_OK
) != 0 ? HOST_EXECUTABLE_SUFFIX
: "";
3071 info
.name_len
= strlen (info
.name
);
3072 info
.suffix_len
= strlen (info
.suffix
);
3075 return (char*) for_each_path (pprefix
, do_multi
,
3076 info
.name_len
+ info
.suffix_len
,
3077 file_at_path
, &info
);
3080 /* Ranking of prefixes in the sort list. -B prefixes are put before
3083 enum path_prefix_priority
3085 PREFIX_PRIORITY_B_OPT
,
3086 PREFIX_PRIORITY_LAST
3089 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
3090 order according to PRIORITY. Within each PRIORITY, new entries are
3093 If WARN is nonzero, we will warn if no file is found
3094 through this prefix. WARN should point to an int
3095 which will be set to 1 if this entry is used.
3097 COMPONENT is the value to be passed to update_path.
3099 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
3100 the complete value of machine_suffix.
3101 2 means try both machine_suffix and just_machine_suffix. */
3104 add_prefix (struct path_prefix
*pprefix
, const char *prefix
,
3105 const char *component
, /* enum prefix_priority */ int priority
,
3106 int require_machine_suffix
, int os_multilib
)
3108 struct prefix_list
*pl
, **prev
;
3111 for (prev
= &pprefix
->plist
;
3112 (*prev
) != NULL
&& (*prev
)->priority
<= priority
;
3113 prev
= &(*prev
)->next
)
3116 /* Keep track of the longest prefix. */
3118 prefix
= update_path (prefix
, component
);
3119 len
= strlen (prefix
);
3120 if (len
> pprefix
->max_len
)
3121 pprefix
->max_len
= len
;
3123 pl
= XNEW (struct prefix_list
);
3124 pl
->prefix
= prefix
;
3125 pl
->require_machine_suffix
= require_machine_suffix
;
3126 pl
->priority
= priority
;
3127 pl
->os_multilib
= os_multilib
;
3129 /* Insert after PREV. */
3134 /* Same as add_prefix, but prepending target_system_root to prefix. */
3135 /* The target_system_root prefix has been relocated by gcc_exec_prefix. */
3137 add_sysrooted_prefix (struct path_prefix
*pprefix
, const char *prefix
,
3138 const char *component
,
3139 /* enum prefix_priority */ int priority
,
3140 int require_machine_suffix
, int os_multilib
)
3142 if (!IS_ABSOLUTE_PATH (prefix
))
3143 fatal_error (input_location
, "system path %qs is not absolute", prefix
);
3145 if (target_system_root
)
3147 char *sysroot_no_trailing_dir_separator
= xstrdup (target_system_root
);
3148 size_t sysroot_len
= strlen (target_system_root
);
3151 && target_system_root
[sysroot_len
- 1] == DIR_SEPARATOR
)
3152 sysroot_no_trailing_dir_separator
[sysroot_len
- 1] = '\0';
3154 if (target_sysroot_suffix
)
3155 prefix
= concat (sysroot_no_trailing_dir_separator
,
3156 target_sysroot_suffix
, prefix
, NULL
);
3158 prefix
= concat (sysroot_no_trailing_dir_separator
, prefix
, NULL
);
3160 free (sysroot_no_trailing_dir_separator
);
3162 /* We have to override this because GCC's notion of sysroot
3163 moves along with GCC. */
3167 add_prefix (pprefix
, prefix
, component
, priority
,
3168 require_machine_suffix
, os_multilib
);
3171 /* Same as add_prefix, but prepending target_sysroot_hdrs_suffix to prefix. */
3174 add_sysrooted_hdrs_prefix (struct path_prefix
*pprefix
, const char *prefix
,
3175 const char *component
,
3176 /* enum prefix_priority */ int priority
,
3177 int require_machine_suffix
, int os_multilib
)
3179 if (!IS_ABSOLUTE_PATH (prefix
))
3180 fatal_error (input_location
, "system path %qs is not absolute", prefix
);
3182 if (target_system_root
)
3184 char *sysroot_no_trailing_dir_separator
= xstrdup (target_system_root
);
3185 size_t sysroot_len
= strlen (target_system_root
);
3188 && target_system_root
[sysroot_len
- 1] == DIR_SEPARATOR
)
3189 sysroot_no_trailing_dir_separator
[sysroot_len
- 1] = '\0';
3191 if (target_sysroot_hdrs_suffix
)
3192 prefix
= concat (sysroot_no_trailing_dir_separator
,
3193 target_sysroot_hdrs_suffix
, prefix
, NULL
);
3195 prefix
= concat (sysroot_no_trailing_dir_separator
, prefix
, NULL
);
3197 free (sysroot_no_trailing_dir_separator
);
3199 /* We have to override this because GCC's notion of sysroot
3200 moves along with GCC. */
3204 add_prefix (pprefix
, prefix
, component
, priority
,
3205 require_machine_suffix
, os_multilib
);
3209 /* Execute the command specified by the arguments on the current line of spec.
3210 When using pipes, this includes several piped-together commands
3211 with `|' between them.
3213 Return 0 if successful, -1 if failed. */
3219 int n_commands
; /* # of command. */
3221 struct pex_obj
*pex
;
3224 const char *prog
; /* program name. */
3225 const char **argv
; /* vector of args. */
3229 struct command
*commands
; /* each command buffer with above info. */
3231 gcc_assert (!processing_spec_function
);
3235 string
= find_a_file (&exec_prefixes
,
3236 argbuf
[0], X_OK
, false);
3239 insert_wrapper (wrapper_string
);
3242 /* Count # of piped commands. */
3243 for (n_commands
= 1, i
= 0; argbuf
.iterate (i
, &arg
); i
++)
3244 if (strcmp (arg
, "|") == 0)
3247 /* Get storage for each command. */
3248 commands
= (struct command
*) alloca (n_commands
* sizeof (struct command
));
3250 /* Split argbuf into its separate piped processes,
3251 and record info about each one.
3252 Also search for the programs that are to be run. */
3254 argbuf
.safe_push (0);
3256 commands
[0].prog
= argbuf
[0]; /* first command. */
3257 commands
[0].argv
= argbuf
.address ();
3259 if (!wrapper_string
)
3261 string
= find_a_file (&exec_prefixes
, commands
[0].prog
, X_OK
, false);
3263 commands
[0].argv
[0] = string
;
3266 for (n_commands
= 1, i
= 0; argbuf
.iterate (i
, &arg
); i
++)
3267 if (arg
&& strcmp (arg
, "|") == 0)
3268 { /* each command. */
3269 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
3270 fatal_error (input_location
, "%<-pipe%> not supported");
3272 argbuf
[i
] = 0; /* Termination of command args. */
3273 commands
[n_commands
].prog
= argbuf
[i
+ 1];
3274 commands
[n_commands
].argv
3275 = &(argbuf
.address ())[i
+ 1];
3276 string
= find_a_file (&exec_prefixes
, commands
[n_commands
].prog
,
3279 commands
[n_commands
].argv
[0] = string
;
3283 /* If -v, print what we are about to do, and maybe query. */
3287 /* For help listings, put a blank line between sub-processes. */
3288 if (print_help_list
)
3289 fputc ('\n', stderr
);
3291 /* Print each piped command as a separate line. */
3292 for (i
= 0; i
< n_commands
; i
++)
3294 const char *const *j
;
3296 if (verbose_only_flag
)
3298 for (j
= commands
[i
].argv
; *j
; j
++)
3301 for (p
= *j
; *p
; ++p
)
3302 if (!ISALNUM ((unsigned char) *p
)
3303 && *p
!= '_' && *p
!= '/' && *p
!= '-' && *p
!= '.')
3307 fprintf (stderr
, " \"");
3308 for (p
= *j
; *p
; ++p
)
3310 if (*p
== '"' || *p
== '\\' || *p
== '$')
3311 fputc ('\\', stderr
);
3314 fputc ('"', stderr
);
3316 /* If it's empty, print "". */
3318 fprintf (stderr
, " \"\"");
3320 fprintf (stderr
, " %s", *j
);
3324 for (j
= commands
[i
].argv
; *j
; j
++)
3325 /* If it's empty, print "". */
3327 fprintf (stderr
, " \"\"");
3329 fprintf (stderr
, " %s", *j
);
3331 /* Print a pipe symbol after all but the last command. */
3332 if (i
+ 1 != n_commands
)
3333 fprintf (stderr
, " |");
3334 fprintf (stderr
, "\n");
3337 if (verbose_only_flag
!= 0)
3339 /* verbose_only_flag should act as if the spec was
3340 executed, so increment execution_count before
3341 returning. This prevents spurious warnings about
3342 unused linker input files, etc. */
3347 fnotice (stderr
, "\nGo ahead? (y or n) ");
3351 while (getchar () != '\n')
3354 if (i
!= 'y' && i
!= 'Y')
3359 #ifdef ENABLE_VALGRIND_CHECKING
3360 /* Run the each command through valgrind. To simplify prepending the
3361 path to valgrind and the option "-q" (for quiet operation unless
3362 something triggers), we allocate a separate argv array. */
3364 for (i
= 0; i
< n_commands
; i
++)
3370 for (argc
= 0; commands
[i
].argv
[argc
] != NULL
; argc
++)
3373 argv
= XALLOCAVEC (const char *, argc
+ 3);
3375 argv
[0] = VALGRIND_PATH
;
3377 for (j
= 2; j
< argc
+ 2; j
++)
3378 argv
[j
] = commands
[i
].argv
[j
- 2];
3381 commands
[i
].argv
= argv
;
3382 commands
[i
].prog
= argv
[0];
3386 /* Run each piped subprocess. */
3388 pex
= pex_init (PEX_USE_PIPES
| ((report_times
|| report_times_to_file
)
3389 ? PEX_RECORD_TIMES
: 0),
3390 progname
, temp_filename
);
3392 fatal_error (input_location
, "%<pex_init%> failed: %m");
3394 for (i
= 0; i
< n_commands
; i
++)
3398 const char *string
= commands
[i
].argv
[0];
3400 errmsg
= pex_run (pex
,
3401 ((i
+ 1 == n_commands
? PEX_LAST
: 0)
3402 | (string
== commands
[i
].prog
? PEX_SEARCH
: 0)),
3403 string
, CONST_CAST (char **, commands
[i
].argv
),
3408 fatal_error (input_location
,
3409 err
? G_("cannot execute %qs: %s: %m")
3410 : G_("cannot execute %qs: %s"),
3414 if (i
&& string
!= commands
[i
].prog
)
3415 free (CONST_CAST (char *, string
));
3420 /* Wait for all the subprocesses to finish. */
3424 struct pex_time
*times
= NULL
;
3427 statuses
= (int *) alloca (n_commands
* sizeof (int));
3428 if (!pex_get_status (pex
, n_commands
, statuses
))
3429 fatal_error (input_location
, "failed to get exit status: %m");
3431 if (report_times
|| report_times_to_file
)
3433 times
= (struct pex_time
*) alloca (n_commands
* sizeof (struct pex_time
));
3434 if (!pex_get_times (pex
, n_commands
, times
))
3435 fatal_error (input_location
, "failed to get process times: %m");
3440 for (i
= 0; i
< n_commands
; ++i
)
3442 int status
= statuses
[i
];
3444 if (WIFSIGNALED (status
))
3445 switch (WTERMSIG (status
))
3449 /* SIGQUIT and SIGKILL are not available on MinGW. */
3456 /* The user (or environment) did something to the
3457 inferior. Making this an ICE confuses the user into
3458 thinking there's a compiler bug. Much more likely is
3459 the user or OOM killer nuked it. */
3460 fatal_error (input_location
,
3461 "%s signal terminated program %s",
3462 strsignal (WTERMSIG (status
)),
3468 /* SIGPIPE is a special case. It happens in -pipe mode
3469 when the compiler dies before the preprocessor is
3470 done, or the assembler dies before the compiler is
3471 done. There's generally been an error already, and
3472 this is just fallout. So don't generate another
3473 error unless we would otherwise have succeeded. */
3474 if (signal_count
|| greatest_status
>= MIN_FATAL_STATUS
)
3484 /* The inferior failed to catch the signal. */
3485 internal_error_no_backtrace ("%s signal terminated program %s",
3486 strsignal (WTERMSIG (status
)),
3489 else if (WIFEXITED (status
)
3490 && WEXITSTATUS (status
) >= MIN_FATAL_STATUS
)
3492 /* For ICEs in cc1, cc1obj, cc1plus see if it is
3493 reproducible or not. */
3496 && WEXITSTATUS (status
) == ICE_EXIT_CODE
3498 && (p
= strrchr (commands
[0].argv
[0], DIR_SEPARATOR
))
3499 && ! strncmp (p
+ 1, "cc1", 3))
3500 try_generate_repro (commands
[0].argv
);
3501 if (WEXITSTATUS (status
) > greatest_status
)
3502 greatest_status
= WEXITSTATUS (status
);
3506 if (report_times
|| report_times_to_file
)
3508 struct pex_time
*pt
= ×
[i
];
3511 ut
= ((double) pt
->user_seconds
3512 + (double) pt
->user_microseconds
/ 1.0e6
);
3513 st
= ((double) pt
->system_seconds
3514 + (double) pt
->system_microseconds
/ 1.0e6
);
3519 fnotice (stderr
, "# %s %.2f %.2f\n",
3520 commands
[i
].prog
, ut
, st
);
3522 if (report_times_to_file
)
3525 const char *const *j
;
3527 fprintf (report_times_to_file
, "%g %g", ut
, st
);
3529 for (j
= &commands
[i
].prog
; *j
; j
= &commands
[i
].argv
[++c
])
3532 for (p
= *j
; *p
; ++p
)
3533 if (*p
== '"' || *p
== '\\' || *p
== '$'
3539 fprintf (report_times_to_file
, " \"");
3540 for (p
= *j
; *p
; ++p
)
3542 if (*p
== '"' || *p
== '\\' || *p
== '$')
3543 fputc ('\\', report_times_to_file
);
3544 fputc (*p
, report_times_to_file
);
3546 fputc ('"', report_times_to_file
);
3549 fprintf (report_times_to_file
, " %s", *j
);
3552 fputc ('\n', report_times_to_file
);
3558 if (commands
[0].argv
[0] != commands
[0].prog
)
3559 free (CONST_CAST (char *, commands
[0].argv
[0]));
3565 /* Find all the switches given to us
3566 and make a vector describing them.
3567 The elements of the vector are strings, one per switch given.
3568 If a switch uses following arguments, then the `part1' field
3569 is the switch itself and the `args' field
3570 is a null-terminated vector containing the following arguments.
3571 Bits in the `live_cond' field are:
3572 SWITCH_LIVE to indicate this switch is true in a conditional spec.
3573 SWITCH_FALSE to indicate this switch is overridden by a later switch.
3574 SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
3575 SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored.
3576 SWITCH_KEEP_FOR_GCC to indicate that this switch, otherwise ignored,
3577 should be included in COLLECT_GCC_OPTIONS.
3578 in all do_spec calls afterwards. Used for %<S from self specs.
3579 The `known' field describes whether this is an internal switch.
3580 The `validated' field describes whether any spec has looked at this switch;
3581 if it remains false at the end of the run, the switch must be meaningless.
3582 The `ordering' field is used to temporarily mark switches that have to be
3583 kept in a specific order. */
3585 #define SWITCH_LIVE (1 << 0)
3586 #define SWITCH_FALSE (1 << 1)
3587 #define SWITCH_IGNORE (1 << 2)
3588 #define SWITCH_IGNORE_PERMANENTLY (1 << 3)
3589 #define SWITCH_KEEP_FOR_GCC (1 << 4)
3595 unsigned int live_cond
;
3601 static struct switchstr
*switches
;
3603 static int n_switches
;
3605 static int n_switches_alloc
;
3607 /* Set to zero if -fcompare-debug is disabled, positive if it's
3608 enabled and we're running the first compilation, negative if it's
3609 enabled and we're running the second compilation. For most of the
3610 time, it's in the range -1..1, but it can be temporarily set to 2
3611 or 3 to indicate that the -fcompare-debug flags didn't come from
3612 the command-line, but rather from the GCC_COMPARE_DEBUG environment
3613 variable, until a synthesized -fcompare-debug flag is added to the
3617 /* Set to nonzero if we've seen the -fcompare-debug-second flag. */
3618 int compare_debug_second
;
3620 /* Set to the flags that should be passed to the second compilation in
3621 a -fcompare-debug compilation. */
3622 const char *compare_debug_opt
;
3624 static struct switchstr
*switches_debug_check
[2];
3626 static int n_switches_debug_check
[2];
3628 static int n_switches_alloc_debug_check
[2];
3630 static char *debug_check_temp_file
[2];
3632 /* Language is one of three things:
3634 1) The name of a real programming language.
3635 2) NULL, indicating that no one has figured out
3637 3) '*', indicating that the file should be passed
3642 const char *language
;
3643 struct compiler
*incompiler
;
3648 /* Also a vector of input files specified. */
3650 static struct infile
*infiles
;
3654 static int n_infiles_alloc
;
3656 /* True if undefined environment variables encountered during spec processing
3657 are ok to ignore, typically when we're running for --help or --version. */
3659 static bool spec_undefvar_allowed
;
3661 /* True if multiple input files are being compiled to a single
3664 static bool combine_inputs
;
3666 /* This counts the number of libraries added by lang_specific_driver, so that
3667 we can tell if there were any user supplied any files or libraries. */
3669 static int added_libraries
;
3671 /* And a vector of corresponding output files is made up later. */
3673 const char **outfiles
;
3675 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3677 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
3678 is true if we should look for an executable suffix. DO_OBJ
3679 is true if we should look for an object suffix. */
3682 convert_filename (const char *name
, int do_exe ATTRIBUTE_UNUSED
,
3683 int do_obj ATTRIBUTE_UNUSED
)
3685 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3693 len
= strlen (name
);
3695 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3696 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
3697 if (do_obj
&& len
> 2
3698 && name
[len
- 2] == '.'
3699 && name
[len
- 1] == 'o')
3701 obstack_grow (&obstack
, name
, len
- 2);
3702 obstack_grow0 (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
3703 name
= XOBFINISH (&obstack
, const char *);
3707 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3708 /* If there is no filetype, make it the executable suffix (which includes
3709 the "."). But don't get confused if we have just "-o". */
3710 if (! do_exe
|| TARGET_EXECUTABLE_SUFFIX
[0] == 0 || not_actual_file_p (name
))
3713 for (i
= len
- 1; i
>= 0; i
--)
3714 if (IS_DIR_SEPARATOR (name
[i
]))
3717 for (i
++; i
< len
; i
++)
3721 obstack_grow (&obstack
, name
, len
);
3722 obstack_grow0 (&obstack
, TARGET_EXECUTABLE_SUFFIX
,
3723 strlen (TARGET_EXECUTABLE_SUFFIX
));
3724 name
= XOBFINISH (&obstack
, const char *);
3731 /* Display the command line switches accepted by gcc. */
3735 printf (_("Usage: %s [options] file...\n"), progname
);
3736 fputs (_("Options:\n"), stdout
);
3738 fputs (_(" -pass-exit-codes Exit with highest error code from a phase.\n"), stdout
);
3739 fputs (_(" --help Display this information.\n"), stdout
);
3740 fputs (_(" --target-help Display target specific command line options.\n"), stdout
);
3741 fputs (_(" --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...].\n"), stdout
);
3742 fputs (_(" Display specific types of command line options.\n"), stdout
);
3744 fputs (_(" (Use '-v --help' to display command line options of sub-processes).\n"), stdout
);
3745 fputs (_(" --version Display compiler version information.\n"), stdout
);
3746 fputs (_(" -dumpspecs Display all of the built in spec strings.\n"), stdout
);
3747 fputs (_(" -dumpversion Display the version of the compiler.\n"), stdout
);
3748 fputs (_(" -dumpmachine Display the compiler's target processor.\n"), stdout
);
3749 fputs (_(" -print-search-dirs Display the directories in the compiler's search path.\n"), stdout
);
3750 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library.\n"), stdout
);
3751 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>.\n"), stdout
);
3752 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>.\n"), stdout
);
3754 -print-multiarch Display the target's normalized GNU triplet, used as\n\
3755 a component in the library path.\n"), stdout
);
3756 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc.\n"), stdout
);
3758 -print-multi-lib Display the mapping between command line options and\n\
3759 multiple library search directories.\n"), stdout
);
3760 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries.\n"), stdout
);
3761 fputs (_(" -print-sysroot Display the target libraries directory.\n"), stdout
);
3762 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers.\n"), stdout
);
3763 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler.\n"), stdout
);
3764 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor.\n"), stdout
);
3765 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker.\n"), stdout
);
3766 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler.\n"), stdout
);
3767 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor.\n"), stdout
);
3768 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker.\n"), stdout
);
3769 fputs (_(" -save-temps Do not delete intermediate files.\n"), stdout
);
3770 fputs (_(" -save-temps=<arg> Do not delete intermediate files.\n"), stdout
);
3772 -no-canonical-prefixes Do not canonicalize paths when building relative\n\
3773 prefixes to other gcc components.\n"), stdout
);
3774 fputs (_(" -pipe Use pipes rather than intermediate files.\n"), stdout
);
3775 fputs (_(" -time Time the execution of each subprocess.\n"), stdout
);
3776 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>.\n"), stdout
);
3777 fputs (_(" -std=<standard> Assume that the input sources are for <standard>.\n"), stdout
);
3779 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3780 and libraries.\n"), stdout
);
3781 fputs (_(" -B <directory> Add <directory> to the compiler's search paths.\n"), stdout
);
3782 fputs (_(" -v Display the programs invoked by the compiler.\n"), stdout
);
3783 fputs (_(" -### Like -v but options quoted and commands not executed.\n"), stdout
);
3784 fputs (_(" -E Preprocess only; do not compile, assemble or link.\n"), stdout
);
3785 fputs (_(" -S Compile only; do not assemble or link.\n"), stdout
);
3786 fputs (_(" -c Compile and assemble, but do not link.\n"), stdout
);
3787 fputs (_(" -o <file> Place the output into <file>.\n"), stdout
);
3788 fputs (_(" -pie Create a dynamically linked position independent\n\
3789 executable.\n"), stdout
);
3790 fputs (_(" -shared Create a shared library.\n"), stdout
);
3792 -x <language> Specify the language of the following input files.\n\
3793 Permissible languages include: c c++ assembler none\n\
3794 'none' means revert to the default behavior of\n\
3795 guessing the language based on the file's extension.\n\
3799 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3800 passed on to the various sub-processes invoked by %s. In order to pass\n\
3801 other options on to these processes the -W<letter> options must be used.\n\
3804 /* The rest of the options are displayed by invocations of the various
3809 add_preprocessor_option (const char *option
, int len
)
3811 preprocessor_options
.safe_push (save_string (option
, len
));
3815 add_assembler_option (const char *option
, int len
)
3817 assembler_options
.safe_push (save_string (option
, len
));
3821 add_linker_option (const char *option
, int len
)
3823 linker_options
.safe_push (save_string (option
, len
));
3826 /* Allocate space for an input file in infiles. */
3831 if (n_infiles_alloc
== 0)
3833 n_infiles_alloc
= 16;
3834 infiles
= XNEWVEC (struct infile
, n_infiles_alloc
);
3836 else if (n_infiles_alloc
== n_infiles
)
3838 n_infiles_alloc
*= 2;
3839 infiles
= XRESIZEVEC (struct infile
, infiles
, n_infiles_alloc
);
3843 /* Store an input file with the given NAME and LANGUAGE in
3847 add_infile (const char *name
, const char *language
)
3850 infiles
[n_infiles
].name
= name
;
3851 infiles
[n_infiles
++].language
= language
;
3854 /* Allocate space for a switch in switches. */
3859 if (n_switches_alloc
== 0)
3861 n_switches_alloc
= 16;
3862 switches
= XNEWVEC (struct switchstr
, n_switches_alloc
);
3864 else if (n_switches_alloc
== n_switches
)
3866 n_switches_alloc
*= 2;
3867 switches
= XRESIZEVEC (struct switchstr
, switches
, n_switches_alloc
);
3871 /* Save an option OPT with N_ARGS arguments in array ARGS, marking it
3872 as validated if VALIDATED and KNOWN if it is an internal switch. */
3875 save_switch (const char *opt
, size_t n_args
, const char *const *args
,
3876 bool validated
, bool known
)
3879 switches
[n_switches
].part1
= opt
+ 1;
3881 switches
[n_switches
].args
= 0;
3884 switches
[n_switches
].args
= XNEWVEC (const char *, n_args
+ 1);
3885 memcpy (switches
[n_switches
].args
, args
, n_args
* sizeof (const char *));
3886 switches
[n_switches
].args
[n_args
] = NULL
;
3889 switches
[n_switches
].live_cond
= 0;
3890 switches
[n_switches
].validated
= validated
;
3891 switches
[n_switches
].known
= known
;
3892 switches
[n_switches
].ordering
= 0;
3896 /* Set the SOURCE_DATE_EPOCH environment variable to the current time if it is
3900 set_source_date_epoch_envvar ()
3902 /* Array size is 21 = ceil(log_10(2^64)) + 1 to hold string representations
3903 of 64 bit integers. */
3904 char source_date_epoch
[21];
3909 if (tt
< (time_t) 0 || errno
!= 0)
3912 snprintf (source_date_epoch
, 21, "%llu", (unsigned long long) tt
);
3913 /* Using setenv instead of xputenv because we want the variable to remain
3914 after finalizing so that it's still set in the second run when using
3916 setenv ("SOURCE_DATE_EPOCH", source_date_epoch
, 0);
3919 /* Handle an option DECODED that is unknown to the option-processing
3923 driver_unknown_option_callback (const struct cl_decoded_option
*decoded
)
3925 const char *opt
= decoded
->arg
;
3926 if (opt
[1] == 'W' && opt
[2] == 'n' && opt
[3] == 'o' && opt
[4] == '-'
3927 && !(decoded
->errors
& CL_ERR_NEGATIVE
))
3929 /* Leave unknown -Wno-* options for the compiler proper, to be
3930 diagnosed only if there are warnings. */
3931 save_switch (decoded
->canonical_option
[0],
3932 decoded
->canonical_option_num_elements
- 1,
3933 &decoded
->canonical_option
[1], false, true);
3936 if (decoded
->opt_index
== OPT_SPECIAL_unknown
)
3938 /* Give it a chance to define it a spec file. */
3939 save_switch (decoded
->canonical_option
[0],
3940 decoded
->canonical_option_num_elements
- 1,
3941 &decoded
->canonical_option
[1], false, false);
3948 /* Handle an option DECODED that is not marked as CL_DRIVER.
3949 LANG_MASK will always be CL_DRIVER. */
3952 driver_wrong_lang_callback (const struct cl_decoded_option
*decoded
,
3953 unsigned int lang_mask ATTRIBUTE_UNUSED
)
3955 /* At this point, non-driver options are accepted (and expected to
3956 be passed down by specs) unless marked to be rejected by the
3957 driver. Options to be rejected by the driver but accepted by the
3958 compilers proper are treated just like completely unknown
3960 const struct cl_option
*option
= &cl_options
[decoded
->opt_index
];
3962 if (option
->cl_reject_driver
)
3963 error ("unrecognized command-line option %qs",
3964 decoded
->orig_option_with_args_text
);
3966 save_switch (decoded
->canonical_option
[0],
3967 decoded
->canonical_option_num_elements
- 1,
3968 &decoded
->canonical_option
[1], false, true);
3971 static const char *spec_lang
= 0;
3972 static int last_language_n_infiles
;
3974 /* Parse -foffload option argument. */
3977 handle_foffload_option (const char *arg
)
3979 const char *c
, *cur
, *n
, *next
, *end
;
3982 /* If option argument starts with '-' then no target is specified and we
3983 do not need to parse it. */
3987 end
= strchr (arg
, '=');
3989 end
= strchr (arg
, '\0');
3994 next
= strchr (cur
, ',');
3997 next
= (next
> end
) ? end
: next
;
3999 target
= XNEWVEC (char, next
- cur
+ 1);
4000 memcpy (target
, cur
, next
- cur
);
4001 target
[next
- cur
] = '\0';
4003 /* If 'disable' is passed to the option, stop parsing the option and clean
4004 the list of offload targets. */
4005 if (strcmp (target
, "disable") == 0)
4007 free (offload_targets
);
4008 offload_targets
= xstrdup ("");
4012 /* Check that GCC is configured to support the offload target. */
4013 c
= OFFLOAD_TARGETS
;
4016 n
= strchr (c
, ',');
4018 n
= strchr (c
, '\0');
4020 if (next
- cur
== n
- c
&& strncmp (target
, c
, n
- c
) == 0)
4023 c
= *n
? n
+ 1 : NULL
;
4027 fatal_error (input_location
,
4028 "GCC is not configured to support %s as offload target",
4031 if (!offload_targets
)
4033 offload_targets
= target
;
4038 /* Check that the target hasn't already presented in the list. */
4039 c
= offload_targets
;
4042 n
= strchr (c
, ':');
4044 n
= strchr (c
, '\0');
4046 if (next
- cur
== n
- c
&& strncmp (c
, target
, n
- c
) == 0)
4053 /* If duplicate is not found, append the target to the list. */
4056 size_t offload_targets_len
= strlen (offload_targets
);
4058 = XRESIZEVEC (char, offload_targets
,
4059 offload_targets_len
+ 1 + next
- cur
+ 1);
4060 offload_targets
[offload_targets_len
++] = ':';
4061 memcpy (offload_targets
+ offload_targets_len
, target
, next
- cur
+ 1);
4066 XDELETEVEC (target
);
4070 /* Handle a driver option; arguments and return value as for
4074 driver_handle_option (struct gcc_options
*opts
,
4075 struct gcc_options
*opts_set
,
4076 const struct cl_decoded_option
*decoded
,
4077 unsigned int lang_mask ATTRIBUTE_UNUSED
, int kind
,
4079 const struct cl_option_handlers
*handlers ATTRIBUTE_UNUSED
,
4080 diagnostic_context
*dc
,
4083 size_t opt_index
= decoded
->opt_index
;
4084 const char *arg
= decoded
->arg
;
4085 const char *compare_debug_replacement_opt
;
4086 int value
= decoded
->value
;
4087 bool validated
= false;
4088 bool do_save
= true;
4090 gcc_assert (opts
== &global_options
);
4091 gcc_assert (opts_set
== &global_options_set
);
4092 gcc_assert (kind
== DK_UNSPECIFIED
);
4093 gcc_assert (loc
== UNKNOWN_LOCATION
);
4094 gcc_assert (dc
== global_dc
);
4100 struct spec_list
*sl
;
4102 for (sl
= specs
; sl
; sl
= sl
->next
)
4103 printf ("*%s:\n%s\n\n", sl
->name
, *(sl
->ptr_spec
));
4104 if (link_command_spec
)
4105 printf ("*link_command:\n%s\n\n", link_command_spec
);
4109 case OPT_dumpversion
:
4110 printf ("%s\n", spec_version
);
4113 case OPT_dumpmachine
:
4114 printf ("%s\n", spec_machine
);
4117 case OPT_dumpfullversion
:
4118 printf ("%s\n", BASEVER
);
4124 /* CPP driver cannot obtain switch from cc1_options. */
4126 add_preprocessor_option ("--version", strlen ("--version"));
4127 add_assembler_option ("--version", strlen ("--version"));
4128 add_linker_option ("--version", strlen ("--version"));
4131 case OPT__completion_
:
4133 completion
= decoded
->arg
;
4137 print_help_list
= 1;
4139 /* CPP driver cannot obtain switch from cc1_options. */
4141 add_preprocessor_option ("--help", 6);
4142 add_assembler_option ("--help", 6);
4143 add_linker_option ("--help", 6);
4147 print_subprocess_help
= 2;
4150 case OPT__target_help
:
4151 print_subprocess_help
= 1;
4153 /* CPP driver cannot obtain switch from cc1_options. */
4155 add_preprocessor_option ("--target-help", 13);
4156 add_assembler_option ("--target-help", 13);
4157 add_linker_option ("--target-help", 13);
4160 case OPT__no_sysroot_suffix
:
4161 case OPT_pass_exit_codes
:
4162 case OPT_print_search_dirs
:
4163 case OPT_print_file_name_
:
4164 case OPT_print_prog_name_
:
4165 case OPT_print_multi_lib
:
4166 case OPT_print_multi_directory
:
4167 case OPT_print_sysroot
:
4168 case OPT_print_multi_os_directory
:
4169 case OPT_print_multiarch
:
4170 case OPT_print_sysroot_headers_suffix
:
4173 /* These options set the variables specified in common.opt
4174 automatically, and do not need to be saved for spec
4179 case OPT_print_libgcc_file_name
:
4180 print_file_name
= "libgcc.a";
4184 case OPT_fuse_ld_bfd
:
4188 case OPT_fuse_ld_gold
:
4192 case OPT_fcompare_debug_second
:
4193 compare_debug_second
= 1;
4196 case OPT_fcompare_debug
:
4200 compare_debug_replacement_opt
= "-fcompare-debug=";
4202 goto compare_debug_with_arg
;
4205 compare_debug_replacement_opt
= "-fcompare-debug=-gtoggle";
4207 goto compare_debug_with_arg
;
4214 case OPT_fcompare_debug_
:
4215 compare_debug_replacement_opt
= decoded
->canonical_option
[0];
4216 compare_debug_with_arg
:
4217 gcc_assert (decoded
->canonical_option_num_elements
== 1);
4218 gcc_assert (arg
!= NULL
);
4223 if (compare_debug
< 0)
4224 compare_debug_opt
= NULL
;
4226 compare_debug_opt
= arg
;
4227 save_switch (compare_debug_replacement_opt
, 0, NULL
, validated
, true);
4228 set_source_date_epoch_envvar ();
4231 case OPT_fdiagnostics_color_
:
4232 diagnostic_color_init (dc
, value
);
4235 case OPT_fdiagnostics_urls_
:
4236 diagnostic_urls_init (dc
, value
);
4239 case OPT_fdiagnostics_format_
:
4240 diagnostic_output_format_init (dc
,
4241 (enum diagnostics_output_format
)value
);
4247 /* Pass the rest of this option to the assembler. */
4249 /* Split the argument at commas. */
4251 for (j
= 0; arg
[j
]; j
++)
4254 add_assembler_option (arg
+ prev
, j
- prev
);
4258 /* Record the part after the last comma. */
4259 add_assembler_option (arg
+ prev
, j
- prev
);
4267 /* Pass the rest of this option to the preprocessor. */
4269 /* Split the argument at commas. */
4271 for (j
= 0; arg
[j
]; j
++)
4274 add_preprocessor_option (arg
+ prev
, j
- prev
);
4278 /* Record the part after the last comma. */
4279 add_preprocessor_option (arg
+ prev
, j
- prev
);
4287 /* Split the argument at commas. */
4289 for (j
= 0; arg
[j
]; j
++)
4292 add_infile (save_string (arg
+ prev
, j
- prev
), "*");
4295 /* Record the part after the last comma. */
4296 add_infile (arg
+ prev
, "*");
4302 add_infile (arg
, "*");
4306 case OPT_Xpreprocessor
:
4307 add_preprocessor_option (arg
, strlen (arg
));
4311 case OPT_Xassembler
:
4312 add_assembler_option (arg
, strlen (arg
));
4317 /* POSIX allows separation of -l and the lib arg; canonicalize
4318 by concatenating -l with its arg */
4319 add_infile (concat ("-l", arg
, NULL
), "*");
4324 /* Similarly, canonicalize -L for linkers that may not accept
4325 separate arguments. */
4326 save_switch (concat ("-L", arg
, NULL
), 0, NULL
, validated
, true);
4331 save_switch (concat ("-F", arg
, NULL
), 0, NULL
, validated
, true);
4334 case OPT_save_temps
:
4335 if (!save_temps_flag
)
4336 save_temps_flag
= SAVE_TEMPS_DUMP
;
4340 case OPT_save_temps_
:
4341 if (strcmp (arg
, "cwd") == 0)
4342 save_temps_flag
= SAVE_TEMPS_CWD
;
4343 else if (strcmp (arg
, "obj") == 0
4344 || strcmp (arg
, "object") == 0)
4345 save_temps_flag
= SAVE_TEMPS_OBJ
;
4347 fatal_error (input_location
, "%qs is an unknown %<-save-temps%> option",
4348 decoded
->orig_option_with_args_text
);
4349 save_temps_overrides_dumpdir
= true;
4354 dumpdir
= xstrdup (arg
);
4355 save_temps_overrides_dumpdir
= false;
4360 dumpbase
= xstrdup (arg
);
4363 case OPT_dumpbase_ext
:
4364 free (dumpbase_ext
);
4365 dumpbase_ext
= xstrdup (arg
);
4368 case OPT_no_canonical_prefixes
:
4369 /* Already handled as a special case, so ignored here. */
4375 /* These options set the variables specified in common.opt
4376 automatically, but do need to be saved for spec
4382 struct user_specs
*user
= XNEW (struct user_specs
);
4384 user
->next
= (struct user_specs
*) 0;
4385 user
->filename
= arg
;
4386 if (user_specs_tail
)
4387 user_specs_tail
->next
= user
;
4389 user_specs_head
= user
;
4390 user_specs_tail
= user
;
4396 target_system_root
= arg
;
4397 target_system_root_changed
= 1;
4402 if (report_times_to_file
)
4403 fclose (report_times_to_file
);
4404 report_times_to_file
= fopen (arg
, "a");
4410 This is similar to -v except that there is no execution
4411 of the commands and the echoed arguments are quoted. It
4412 is intended for use in shell scripts to capture the
4413 driver-generated command line. */
4414 verbose_only_flag
++;
4421 size_t len
= strlen (arg
);
4423 /* Catch the case where the user has forgotten to append a
4424 directory separator to the path. Note, they may be using
4425 -B to add an executable name prefix, eg "i386-elf-", in
4426 order to distinguish between multiple installations of
4427 GCC in the same directory. Hence we must check to see
4428 if appending a directory separator actually makes a
4429 valid directory name. */
4430 if (!IS_DIR_SEPARATOR (arg
[len
- 1])
4431 && is_directory (arg
, false))
4433 char *tmp
= XNEWVEC (char, len
+ 2);
4435 tmp
[len
] = DIR_SEPARATOR
;
4440 add_prefix (&exec_prefixes
, arg
, NULL
,
4441 PREFIX_PRIORITY_B_OPT
, 0, 0);
4442 add_prefix (&startfile_prefixes
, arg
, NULL
,
4443 PREFIX_PRIORITY_B_OPT
, 0, 0);
4444 add_prefix (&include_prefixes
, arg
, NULL
,
4445 PREFIX_PRIORITY_B_OPT
, 0, 0);
4456 if (!strcmp (spec_lang
, "none"))
4457 /* Suppress the warning if -xnone comes after the last input
4458 file, because alternate command interfaces like g++ might
4459 find it useful to place -xnone after each input file. */
4462 last_language_n_infiles
= n_infiles
;
4468 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
4469 arg
= convert_filename (arg
, ! have_c
, 0);
4472 /* On some systems, ld cannot handle "-o" without a space. So
4473 split the option from its argument. */
4474 save_switch ("-o", 1, &arg
, validated
, true);
4477 #ifdef ENABLE_DEFAULT_PIE
4479 /* -pie is turned on by default. */
4482 case OPT_static_libgcc
:
4483 case OPT_shared_libgcc
:
4484 case OPT_static_libgfortran
:
4485 case OPT_static_libstdc__
:
4486 /* These are always valid, since gcc.c itself understands the
4487 first two, gfortranspec.c understands -static-libgfortran and
4488 g++spec.c understands -static-libstdc++ */
4497 handle_foffload_option (arg
);
4501 /* Various driver options need no special processing at this
4502 point, having been handled in a prescan above or being
4503 handled by specs. */
4508 save_switch (decoded
->canonical_option
[0],
4509 decoded
->canonical_option_num_elements
- 1,
4510 &decoded
->canonical_option
[1], validated
, true);
4514 /* Return true if F2 is F1 followed by a single suffix, i.e., by a
4515 period and additional characters other than a period. */
4518 adds_single_suffix_p (const char *f2
, const char *f1
)
4520 size_t len
= strlen (f1
);
4522 return (strncmp (f1
, f2
, len
) == 0
4524 && strchr (f2
+ len
+ 1, '.') == NULL
);
4527 /* Put the driver's standard set of option handlers in *HANDLERS. */
4530 set_option_handlers (struct cl_option_handlers
*handlers
)
4532 handlers
->unknown_option_callback
= driver_unknown_option_callback
;
4533 handlers
->wrong_lang_callback
= driver_wrong_lang_callback
;
4534 handlers
->num_handlers
= 3;
4535 handlers
->handlers
[0].handler
= driver_handle_option
;
4536 handlers
->handlers
[0].mask
= CL_DRIVER
;
4537 handlers
->handlers
[1].handler
= common_handle_option
;
4538 handlers
->handlers
[1].mask
= CL_COMMON
;
4539 handlers
->handlers
[2].handler
= target_handle_option
;
4540 handlers
->handlers
[2].mask
= CL_TARGET
;
4544 /* Return the index into infiles for the single non-library
4545 non-lto-wpa input file, -1 if there isn't any, or -2 if there is
4548 single_input_file_index ()
4552 for (int i
= 0; i
< n_infiles
; i
++)
4554 if (infiles
[i
].language
4555 && (infiles
[i
].language
[0] == '*'
4557 && strcmp (infiles
[i
].language
, "lto") == 0)))
4569 /* Create the vector `switches' and its contents.
4570 Store its length in `n_switches'. */
4573 process_command (unsigned int decoded_options_count
,
4574 struct cl_decoded_option
*decoded_options
)
4578 char *tooldir_prefix
, *tooldir_prefix2
;
4579 char *(*get_relative_prefix
) (const char *, const char *,
4580 const char *) = NULL
;
4581 struct cl_option_handlers handlers
;
4584 gcc_exec_prefix
= env
.get ("GCC_EXEC_PREFIX");
4588 added_libraries
= 0;
4590 /* Figure compiler version from version string. */
4592 compiler_version
= temp1
= xstrdup (version_string
);
4594 for (; *temp1
; ++temp1
)
4603 /* Handle any -no-canonical-prefixes flag early, to assign the function
4604 that builds relative prefixes. This function creates default search
4605 paths that are needed later in normal option handling. */
4607 for (j
= 1; j
< decoded_options_count
; j
++)
4609 if (decoded_options
[j
].opt_index
== OPT_no_canonical_prefixes
)
4611 get_relative_prefix
= make_relative_prefix_ignore_links
;
4615 if (! get_relative_prefix
)
4616 get_relative_prefix
= make_relative_prefix
;
4618 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
4619 see if we can create it from the pathname specified in
4620 decoded_options[0].arg. */
4622 gcc_libexec_prefix
= standard_libexec_prefix
;
4624 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
4625 if (!gcc_exec_prefix
)
4627 gcc_exec_prefix
= get_relative_prefix (decoded_options
[0].arg
,
4628 standard_bindir_prefix
,
4629 standard_exec_prefix
);
4630 gcc_libexec_prefix
= get_relative_prefix (decoded_options
[0].arg
,
4631 standard_bindir_prefix
,
4632 standard_libexec_prefix
);
4633 if (gcc_exec_prefix
)
4634 xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix
, NULL
));
4638 /* make_relative_prefix requires a program name, but
4639 GCC_EXEC_PREFIX is typically a directory name with a trailing
4640 / (which is ignored by make_relative_prefix), so append a
4642 char *tmp_prefix
= concat (gcc_exec_prefix
, "gcc", NULL
);
4643 gcc_libexec_prefix
= get_relative_prefix (tmp_prefix
,
4644 standard_exec_prefix
,
4645 standard_libexec_prefix
);
4647 /* The path is unrelocated, so fallback to the original setting. */
4648 if (!gcc_libexec_prefix
)
4649 gcc_libexec_prefix
= standard_libexec_prefix
;
4655 /* From this point onward, gcc_exec_prefix is non-null if the toolchain
4656 is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
4657 or an automatically created GCC_EXEC_PREFIX from
4658 decoded_options[0].arg. */
4660 /* Do language-specific adjustment/addition of flags. */
4661 lang_specific_driver (&decoded_options
, &decoded_options_count
,
4664 if (gcc_exec_prefix
)
4666 int len
= strlen (gcc_exec_prefix
);
4668 if (len
> (int) sizeof ("/lib/gcc/") - 1
4669 && (IS_DIR_SEPARATOR (gcc_exec_prefix
[len
-1])))
4671 temp
= gcc_exec_prefix
+ len
- sizeof ("/lib/gcc/") + 1;
4672 if (IS_DIR_SEPARATOR (*temp
)
4673 && filename_ncmp (temp
+ 1, "lib", 3) == 0
4674 && IS_DIR_SEPARATOR (temp
[4])
4675 && filename_ncmp (temp
+ 5, "gcc", 3) == 0)
4676 len
-= sizeof ("/lib/gcc/") - 1;
4679 set_std_prefix (gcc_exec_prefix
, len
);
4680 add_prefix (&exec_prefixes
, gcc_libexec_prefix
, "GCC",
4681 PREFIX_PRIORITY_LAST
, 0, 0);
4682 add_prefix (&startfile_prefixes
, gcc_exec_prefix
, "GCC",
4683 PREFIX_PRIORITY_LAST
, 0, 0);
4686 /* COMPILER_PATH and LIBRARY_PATH have values
4687 that are lists of directory names with colons. */
4689 temp
= env
.get ("COMPILER_PATH");
4692 const char *startp
, *endp
;
4693 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4695 startp
= endp
= temp
;
4698 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4700 strncpy (nstore
, startp
, endp
- startp
);
4702 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4703 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4705 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4706 nstore
[endp
- startp
+ 1] = 0;
4709 nstore
[endp
- startp
] = 0;
4710 add_prefix (&exec_prefixes
, nstore
, 0,
4711 PREFIX_PRIORITY_LAST
, 0, 0);
4712 add_prefix (&include_prefixes
, nstore
, 0,
4713 PREFIX_PRIORITY_LAST
, 0, 0);
4716 endp
= startp
= endp
+ 1;
4723 temp
= env
.get (LIBRARY_PATH_ENV
);
4724 if (temp
&& *cross_compile
== '0')
4726 const char *startp
, *endp
;
4727 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4729 startp
= endp
= temp
;
4732 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4734 strncpy (nstore
, startp
, endp
- startp
);
4736 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4737 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4739 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4740 nstore
[endp
- startp
+ 1] = 0;
4743 nstore
[endp
- startp
] = 0;
4744 add_prefix (&startfile_prefixes
, nstore
, NULL
,
4745 PREFIX_PRIORITY_LAST
, 0, 1);
4748 endp
= startp
= endp
+ 1;
4755 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
4756 temp
= env
.get ("LPATH");
4757 if (temp
&& *cross_compile
== '0')
4759 const char *startp
, *endp
;
4760 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4762 startp
= endp
= temp
;
4765 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4767 strncpy (nstore
, startp
, endp
- startp
);
4769 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4770 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4772 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4773 nstore
[endp
- startp
+ 1] = 0;
4776 nstore
[endp
- startp
] = 0;
4777 add_prefix (&startfile_prefixes
, nstore
, NULL
,
4778 PREFIX_PRIORITY_LAST
, 0, 1);
4781 endp
= startp
= endp
+ 1;
4788 /* Process the options and store input files and switches in their
4791 last_language_n_infiles
= -1;
4793 set_option_handlers (&handlers
);
4795 for (j
= 1; j
< decoded_options_count
; j
++)
4797 switch (decoded_options
[j
].opt_index
)
4809 for (j
= 1; j
< decoded_options_count
; j
++)
4811 if (decoded_options
[j
].opt_index
== OPT_SPECIAL_input_file
)
4813 const char *arg
= decoded_options
[j
].arg
;
4815 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4816 arg
= convert_filename (arg
, 0, access (arg
, F_OK
));
4818 add_infile (arg
, spec_lang
);
4823 read_cmdline_option (&global_options
, &global_options_set
,
4824 decoded_options
+ j
, UNKNOWN_LOCATION
,
4825 CL_DRIVER
, &handlers
, global_dc
);
4828 /* If the user didn't specify any, default to all configured offload
4830 if (ENABLE_OFFLOADING
&& offload_targets
== NULL
)
4831 handle_foffload_option (OFFLOAD_TARGETS
);
4834 && strcmp (output_file
, "-") != 0
4835 && strcmp (output_file
, HOST_BIT_BUCKET
) != 0)
4838 for (i
= 0; i
< n_infiles
; i
++)
4839 if ((!infiles
[i
].language
|| infiles
[i
].language
[0] != '*')
4840 && canonical_filename_eq (infiles
[i
].name
, output_file
))
4841 fatal_error (input_location
,
4842 "input file %qs is the same as output file",
4846 if (output_file
!= NULL
&& output_file
[0] == '\0')
4847 fatal_error (input_location
, "output filename may not be empty");
4849 /* -dumpdir and -save-temps=* both specify the location of aux/dump
4850 outputs; the one that appears last prevails. When compiling
4851 multiple sources, an explicit dumpbase (minus -ext) may be
4852 combined with an explicit or implicit dumpdir, whereas when
4853 linking, a specified or implied link output name (minus
4854 extension) may be combined with a prevailing -save-temps=* or an
4855 otherwise implied dumpdir, but not override a prevailing
4856 -dumpdir. Primary outputs (e.g., linker output when linking
4857 without -o, or .i, .s or .o outputs when processing multiple
4858 inputs with -E, -S or -c, respectively) are NOT affected by these
4859 -save-temps=/-dump* options, always landing in the current
4860 directory and with the same basename as the input when an output
4861 name is not given, but when they're intermediate outputs, they
4862 are named like other aux outputs, so the options affect their
4865 Here are some examples. There are several more in the
4866 documentation of -o and -dump*, and some quite exhaustive tests
4867 in gcc.misc-tests/outputs.exp.
4869 When compiling any number of sources, no -dump* nor
4870 -save-temps=*, all outputs in cwd without prefix:
4872 # gcc -c b.c -gsplit-dwarf
4873 -> cc1 [-dumpdir ./] -dumpbase b.c -dumpbase-ext .c # b.o b.dwo
4875 # gcc -c b.c d.c -gsplit-dwarf
4876 -> cc1 [-dumpdir ./] -dumpbase b.c -dumpbase-ext .c # b.o b.dwo
4877 && cc1 [-dumpdir ./] -dumpbase d.c -dumpbase-ext .c # d.o d.dwo
4879 When compiling and linking, no -dump* nor -save-temps=*, .o
4880 outputs are temporary, aux outputs land in the dir of the output,
4881 prefixed with the basename of the linker output:
4883 # gcc b.c d.c -o ab -gsplit-dwarf
4884 -> cc1 -dumpdir ab- -dumpbase b.c -dumpbase-ext .c # ab-b.dwo
4885 && cc1 -dumpdir ab- -dumpbase d.c -dumpbase-ext .c # ab-d.dwo
4888 # gcc b.c d.c [-o a.out] -gsplit-dwarf
4889 -> cc1 -dumpdir a- -dumpbase b.c -dumpbase-ext .c # a-b.dwo
4890 && cc1 -dumpdir a- -dumpbase d.c -dumpbase-ext .c # a-d.dwo
4891 && link ... [-o a.out]
4893 When compiling and linking, a prevailing -dumpdir fully overrides
4894 the prefix of aux outputs given by the output name:
4896 # gcc -dumpdir f b.c d.c -gsplit-dwarf [-o [dir/]whatever]
4897 -> cc1 -dumpdir f -dumpbase b.c -dumpbase-ext .c # fb.dwo
4898 && cc1 -dumpdir f -dumpbase d.c -dumpbase-ext .c # fd.dwo
4899 && link ... [-o whatever]
4901 When compiling multiple inputs, an explicit -dumpbase is combined
4902 with -dumpdir, affecting aux outputs, but not the .o outputs:
4904 # gcc -dumpdir f -dumpbase g- b.c d.c -gsplit-dwarf -c
4905 -> cc1 -dumpdir fg- -dumpbase b.c -dumpbase-ext .c # b.o fg-b.dwo
4906 && cc1 -dumpdir fg- -dumpbase d.c -dumpbase-ext .c # d.o fg-d.dwo
4908 When compiling and linking with -save-temps, the .o outputs that
4909 would have been temporary become aux outputs, so they get
4910 affected by -dump* flags:
4912 # gcc -dumpdir f -dumpbase g- -save-temps b.c d.c
4913 -> cc1 -dumpdir fg- -dumpbase b.c -dumpbase-ext .c # fg-b.o
4914 && cc1 -dumpdir fg- -dumpbase d.c -dumpbase-ext .c # fg-d.o
4917 If -save-temps=* prevails over -dumpdir, however, the explicit
4918 -dumpdir is discarded, as if it wasn't there. The basename of
4919 the implicit linker output, a.out or a.exe, becomes a- as the aux
4920 output prefix for all compilations:
4922 # gcc [-dumpdir f] -save-temps=cwd b.c d.c
4923 -> cc1 -dumpdir a- -dumpbase b.c -dumpbase-ext .c # a-b.o
4924 && cc1 -dumpdir a- -dumpbase d.c -dumpbase-ext .c # a-d.o
4927 A single -dumpbase, applying to multiple inputs, overrides the
4928 linker output name, implied or explicit, as the aux output prefix:
4930 # gcc [-dumpdir f] -dumpbase g- -save-temps=cwd b.c d.c
4931 -> cc1 -dumpdir g- -dumpbase b.c -dumpbase-ext .c # g-b.o
4932 && cc1 -dumpdir g- -dumpbase d.c -dumpbase-ext .c # g-d.o
4935 # gcc [-dumpdir f] -dumpbase g- -save-temps=cwd b.c d.c -o dir/h.out
4936 -> cc1 -dumpdir g- -dumpbase b.c -dumpbase-ext .c # g-b.o
4937 && cc1 -dumpdir g- -dumpbase d.c -dumpbase-ext .c # g-d.o
4938 && link -o dir/h.out
4940 Now, if the linker output is NOT overridden as a prefix, but
4941 -save-temps=* overrides implicit or explicit -dumpdir, the
4942 effective dump dir combines the dir selected by the -save-temps=*
4943 option with the basename of the specified or implied link output:
4945 # gcc [-dumpdir f] -save-temps=cwd b.c d.c -o dir/h.out
4946 -> cc1 -dumpdir h- -dumpbase b.c -dumpbase-ext .c # h-b.o
4947 && cc1 -dumpdir h- -dumpbase d.c -dumpbase-ext .c # h-d.o
4948 && link -o dir/h.out
4950 # gcc [-dumpdir f] -save-temps=obj b.c d.c -o dir/h.out
4951 -> cc1 -dumpdir dir/h- -dumpbase b.c -dumpbase-ext .c # dir/h-b.o
4952 && cc1 -dumpdir dir/h- -dumpbase d.c -dumpbase-ext .c # dir/h-d.o
4953 && link -o dir/h.out
4955 But then again, a single -dumpbase applying to multiple inputs
4956 gets used instead of the linker output basename in the combined
4959 # gcc [-dumpdir f] -dumpbase g- -save-temps=obj b.c d.c -o dir/h.out
4960 -> cc1 -dumpdir dir/g- -dumpbase b.c -dumpbase-ext .c # dir/g-b.o
4961 && cc1 -dumpdir dir/g- -dumpbase d.c -dumpbase-ext .c # dir/g-d.o
4962 && link -o dir/h.out
4964 With a single input being compiled, the output basename does NOT
4965 affect the dumpdir prefix.
4967 # gcc -save-temps=obj b.c -gsplit-dwarf -c -o dir/b.o
4968 -> cc1 -dumpdir dir/ -dumpbase b.c -dumpbase-ext .c # dir/b.o dir/b.dwo
4970 but when compiling and linking even a single file, it does:
4972 # gcc -save-temps=obj b.c -o dir/h.out
4973 -> cc1 -dumpdir dir/h- -dumpbase b.c -dumpbase-ext .c # dir/h-b.o
4975 unless an explicit -dumpdir prevails:
4977 # gcc -save-temps[=obj] -dumpdir g- b.c -o dir/h.out
4978 -> cc1 -dumpdir g- -dumpbase b.c -dumpbase-ext .c # g-b.o
4982 bool explicit_dumpdir
= dumpdir
;
4984 if (!save_temps_overrides_dumpdir
&& explicit_dumpdir
)
4989 /* If -save-temps=obj and -o name, create the prefix to use for %b.
4990 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
4991 else if (save_temps_flag
!= SAVE_TEMPS_CWD
&& output_file
!= NULL
)
4995 temp
= lbasename (output_file
);
4996 if (temp
!= output_file
)
4997 dumpdir
= xstrndup (output_file
,
4998 strlen (output_file
) - strlen (temp
));
5006 if (save_temps_flag
)
5007 save_temps_flag
= SAVE_TEMPS_DUMP
;
5009 /* If there is any pathname component in an explicit -dumpbase, it
5010 overrides dumpdir entirely, so discard it right away. Although
5011 the presence of an explicit -dumpdir matters for the driver, it
5012 shouldn't matter for other processes, that get all that's needed
5013 from the -dumpdir and -dumpbase always passed to them. */
5014 if (dumpdir
&& dumpbase
&& lbasename (dumpbase
) != dumpbase
)
5020 /* Check that dumpbase_ext matches the end of dumpbase, drop it
5022 if (dumpbase_ext
&& dumpbase
&& *dumpbase
)
5024 int lendb
= strlen (dumpbase
);
5025 int lendbx
= strlen (dumpbase_ext
);
5027 /* -dumpbase-ext must be a suffix proper; discard it if it
5028 matches all of -dumpbase, as that would make for an empty
5031 || strcmp (dumpbase
+ lendb
- lendbx
, dumpbase_ext
) != 0)
5033 free (dumpbase_ext
);
5034 dumpbase_ext
= NULL
;
5038 /* -dumpbase with multiple sources goes into dumpdir. With a single
5039 source, it does only if linking and if dumpdir was not explicitly
5041 if (dumpbase
&& *dumpbase
5042 && (single_input_file_index () == -2
5043 || (!have_c
&& !explicit_dumpdir
)))
5048 /* We checked that they match above. */
5049 dumpbase
[strlen (dumpbase
) - strlen (dumpbase_ext
)] = '\0';
5052 prefix
= concat (dumpdir
, dumpbase
, "-", NULL
);
5054 prefix
= concat (dumpbase
, "-", NULL
);
5058 free (dumpbase_ext
);
5059 dumpbase
= dumpbase_ext
= NULL
;
5061 dumpdir_trailing_dash_added
= true;
5064 /* If dumpbase was not brought into dumpdir but we're linking, bring
5065 output_file into dumpdir unless dumpdir was explicitly specified.
5066 The test for !explicit_dumpdir is further below, because we want
5067 to use the obase computation for a ghost outbase, passed to
5068 GCC_COLLECT_OPTIONS. */
5069 else if (!have_c
&& (!explicit_dumpdir
|| (dumpbase
&& !*dumpbase
)))
5071 /* If we get here, we know dumpbase was not specified, or it was
5072 specified as an empty string. If it was anything else, it
5073 would have combined with dumpdir above, because the condition
5074 for dumpbase to be used when present is broader than the
5075 condition that gets us here. */
5076 gcc_assert (!dumpbase
|| !*dumpbase
);
5079 char *tofree
= NULL
;
5080 if (!output_file
|| not_actual_file_p (output_file
))
5084 obase
= lbasename (output_file
);
5085 size_t blen
= strlen (obase
), xlen
;
5086 /* Drop the suffix if it's dumpbase_ext, if given,
5087 otherwise .exe or the target executable suffix, or if the
5088 output was explicitly named a.out, but not otherwise. */
5090 ? (blen
> (xlen
= strlen (dumpbase_ext
))
5091 && strcmp ((temp
= (obase
+ blen
- xlen
)),
5093 : ((temp
= strrchr (obase
+ 1, '.'))
5094 && (xlen
= strlen (temp
))
5095 && (strcmp (temp
, ".exe") == 0
5096 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
5097 || strcmp (temp
, TARGET_EXECUTABLE_SUFFIX
) == 0
5099 || strcmp (obase
, "a.out") == 0)))
5101 tofree
= xstrndup (obase
, blen
- xlen
);
5106 /* We wish to save this basename to the -dumpdir passed through
5107 GCC_COLLECT_OPTIONS within maybe_run_linker, for e.g. LTO,
5108 but we do NOT wish to add it to e.g. %b, so we keep
5109 outbase_length as zero. */
5110 gcc_assert (!outbase
);
5113 /* If we're building [dir1/]foo[.exe] out of a single input
5114 [dir2/]foo.c that shares the same basename, dump to
5115 [dir2/]foo.c.* rather than duplicating the basename into
5116 [dir2/]foo-foo.c.*. */
5119 || ((idxin
= single_input_file_index ()) >= 0
5120 && adds_single_suffix_p (lbasename (infiles
[idxin
].name
),
5123 if (obase
== tofree
)
5127 outbase
= xstrdup (obase
);
5130 obase
= tofree
= NULL
;
5136 char *p
= concat (dumpdir
, obase
, "-", NULL
);
5141 dumpdir
= concat (obase
, "-", NULL
);
5143 dumpdir_trailing_dash_added
= true;
5146 obase
= tofree
= NULL
;
5149 if (!explicit_dumpdir
|| dumpbase
)
5151 /* Absent -dumpbase and present -dumpbase-ext have been applied
5152 to the linker output name, so compute fresh defaults for each
5154 free (dumpbase_ext
);
5155 dumpbase_ext
= NULL
;
5159 /* Now, if we're compiling, or if we haven't used the dumpbase
5160 above, then outbase (%B) is derived from dumpbase, if given, or
5161 from the output name, given or implied. We can't precompute
5162 implied output names, but that's ok, since they're derived from
5163 input names. Just make sure we skip this if dumpbase is the
5164 empty string: we want to use input names then, so don't set
5166 if ((dumpbase
|| have_c
)
5167 && !(dumpbase
&& !*dumpbase
))
5169 gcc_assert (!outbase
);
5173 gcc_assert (single_input_file_index () != -2);
5174 /* We do not want lbasename here; dumpbase with dirnames
5175 overrides dumpdir entirely, even if dumpdir is
5178 /* We've already checked above that the suffix matches. */
5179 outbase
= xstrndup (dumpbase
,
5180 strlen (dumpbase
) - strlen (dumpbase_ext
));
5182 outbase
= xstrdup (dumpbase
);
5184 else if (output_file
&& !not_actual_file_p (output_file
))
5186 outbase
= xstrdup (lbasename (output_file
));
5187 char *p
= strrchr (outbase
+ 1, '.');
5193 outbase_length
= strlen (outbase
);
5196 /* If there is any pathname component in an explicit -dumpbase, do
5197 not use dumpdir, but retain it to pass it on to the compiler. */
5199 dumpdir_length
= strlen (dumpdir
);
5203 /* Check that dumpbase_ext, if still present, still matches the end
5204 of dumpbase, if present, and drop it otherwise. We only retained
5205 it above when dumpbase was absent to maybe use it to drop the
5206 extension from output_name before combining it with dumpdir. We
5207 won't deal with -dumpbase-ext when -dumpbase is not explicitly
5208 given, even if just to activate backward-compatible dumpbase:
5209 dropping it on the floor is correct, expected and documented
5210 behavior. Attempting to deal with a -dumpbase-ext that might
5211 match the end of some input filename, or of the combination of
5212 the output basename with the suffix of the input filename,
5213 possible with an intermediate .gk extension for -fcompare-debug,
5214 is just calling for trouble. */
5217 if (!dumpbase
|| !*dumpbase
)
5219 free (dumpbase_ext
);
5220 dumpbase_ext
= NULL
;
5223 gcc_assert (strcmp (dumpbase
+ strlen (dumpbase
)
5224 - strlen (dumpbase_ext
), dumpbase_ext
) == 0);
5227 if (save_temps_flag
&& use_pipes
)
5229 /* -save-temps overrides -pipe, so that temp files are produced */
5230 if (save_temps_flag
)
5231 warning (0, "%<-pipe%> ignored because %<-save-temps%> specified");
5237 const char *gcd
= env
.get ("GCC_COMPARE_DEBUG");
5239 if (gcd
&& gcd
[0] == '-')
5242 compare_debug_opt
= gcd
;
5244 else if (gcd
&& *gcd
&& strcmp (gcd
, "0"))
5247 compare_debug_opt
= "-gtoggle";
5250 else if (compare_debug
< 0)
5253 gcc_assert (!compare_debug_opt
);
5256 /* Set up the search paths. We add directories that we expect to
5257 contain GNU Toolchain components before directories specified by
5258 the machine description so that we will find GNU components (like
5259 the GNU assembler) before those of the host system. */
5261 /* If we don't know where the toolchain has been installed, use the
5262 configured-in locations. */
5263 if (!gcc_exec_prefix
)
5266 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "GCC",
5267 PREFIX_PRIORITY_LAST
, 1, 0);
5268 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "BINUTILS",
5269 PREFIX_PRIORITY_LAST
, 2, 0);
5270 add_prefix (&exec_prefixes
, standard_exec_prefix
, "BINUTILS",
5271 PREFIX_PRIORITY_LAST
, 2, 0);
5273 add_prefix (&startfile_prefixes
, standard_exec_prefix
, "BINUTILS",
5274 PREFIX_PRIORITY_LAST
, 1, 0);
5277 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix
));
5278 tooldir_prefix2
= concat (tooldir_base_prefix
, spec_machine
,
5279 dir_separator_str
, NULL
);
5281 /* Look for tools relative to the location from which the driver is
5282 running, or, if that is not available, the configured prefix. */
5284 = concat (gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
5285 spec_host_machine
, dir_separator_str
, spec_version
,
5286 accel_dir_suffix
, dir_separator_str
, tooldir_prefix2
, NULL
);
5287 free (tooldir_prefix2
);
5289 add_prefix (&exec_prefixes
,
5290 concat (tooldir_prefix
, "bin", dir_separator_str
, NULL
),
5291 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 0);
5292 add_prefix (&startfile_prefixes
,
5293 concat (tooldir_prefix
, "lib", dir_separator_str
, NULL
),
5294 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 1);
5295 free (tooldir_prefix
);
5297 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
5298 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
5299 then consider it to relocate with the rest of the GCC installation
5300 if GCC_EXEC_PREFIX is set.
5301 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
5302 if (target_system_root
&& !target_system_root_changed
&& gcc_exec_prefix
)
5304 char *tmp_prefix
= get_relative_prefix (decoded_options
[0].arg
,
5305 standard_bindir_prefix
,
5306 target_system_root
);
5307 if (tmp_prefix
&& access_check (tmp_prefix
, F_OK
) == 0)
5309 target_system_root
= tmp_prefix
;
5310 target_system_root_changed
= 1;
5315 /* More prefixes are enabled in main, after we read the specs file
5316 and determine whether this is cross-compilation or not. */
5318 if (n_infiles
!= 0 && n_infiles
== last_language_n_infiles
&& spec_lang
!= 0)
5319 warning (0, "%<-x %s%> after last input file has no effect", spec_lang
);
5321 /* Synthesize -fcompare-debug flag from the GCC_COMPARE_DEBUG
5322 environment variable. */
5323 if (compare_debug
== 2 || compare_debug
== 3)
5325 const char *opt
= concat ("-fcompare-debug=", compare_debug_opt
, NULL
);
5326 save_switch (opt
, 0, NULL
, false, true);
5330 /* Ensure we only invoke each subprocess once. */
5332 && (print_subprocess_help
|| print_help_list
|| print_version
))
5334 /* Create a dummy input file, so that we can pass
5335 the help option on to the various sub-processes. */
5336 add_infile ("help-dummy", "c");
5339 /* Decide if undefined variable references are allowed in specs. */
5341 /* -v alone is safe. --version and --help alone or together are safe. Note
5342 that -v would make them unsafe, as they'd then be run for subprocesses as
5343 well, the location of which might depend on variables possibly coming
5344 from self-specs. Note also that the command name is counted in
5345 decoded_options_count. */
5347 unsigned help_version_count
= 0;
5350 help_version_count
++;
5352 if (print_help_list
)
5353 help_version_count
++;
5355 spec_undefvar_allowed
=
5356 ((verbose_flag
&& decoded_options_count
== 2)
5357 || help_version_count
== decoded_options_count
- 1);
5360 switches
[n_switches
].part1
= 0;
5362 infiles
[n_infiles
].name
= 0;
5365 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
5366 and place that in the environment. */
5369 set_collect_gcc_options (void)
5374 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
5376 obstack_grow (&collect_obstack
, "COLLECT_GCC_OPTIONS=",
5377 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
5380 for (i
= 0; (int) i
< n_switches
; i
++)
5382 const char *const *args
;
5385 obstack_grow (&collect_obstack
, " ", 1);
5389 /* Ignore elided switches. */
5390 if ((switches
[i
].live_cond
5391 & (SWITCH_IGNORE
| SWITCH_KEEP_FOR_GCC
))
5395 obstack_grow (&collect_obstack
, "'-", 2);
5396 q
= switches
[i
].part1
;
5397 while ((p
= strchr (q
, '\'')))
5399 obstack_grow (&collect_obstack
, q
, p
- q
);
5400 obstack_grow (&collect_obstack
, "'\\''", 4);
5403 obstack_grow (&collect_obstack
, q
, strlen (q
));
5404 obstack_grow (&collect_obstack
, "'", 1);
5406 for (args
= switches
[i
].args
; args
&& *args
; args
++)
5408 obstack_grow (&collect_obstack
, " '", 2);
5410 while ((p
= strchr (q
, '\'')))
5412 obstack_grow (&collect_obstack
, q
, p
- q
);
5413 obstack_grow (&collect_obstack
, "'\\''", 4);
5416 obstack_grow (&collect_obstack
, q
, strlen (q
));
5417 obstack_grow (&collect_obstack
, "'", 1);
5424 obstack_grow (&collect_obstack
, " ", 1);
5427 obstack_grow (&collect_obstack
, "'-dumpdir' '", 12);
5431 while ((p
= strchr (q
, '\'')))
5433 obstack_grow (&collect_obstack
, q
, p
- q
);
5434 obstack_grow (&collect_obstack
, "'\\''", 4);
5437 obstack_grow (&collect_obstack
, q
, strlen (q
));
5439 obstack_grow (&collect_obstack
, "'", 1);
5442 obstack_grow (&collect_obstack
, "\0", 1);
5443 xputenv (XOBFINISH (&collect_obstack
, char *));
5446 /* Process a spec string, accumulating and running commands. */
5448 /* These variables describe the input file name.
5449 input_file_number is the index on outfiles of this file,
5450 so that the output file name can be stored for later use by %o.
5451 input_basename is the start of the part of the input file
5452 sans all directory names, and basename_length is the number
5453 of characters starting there excluding the suffix .c or whatever. */
5455 static const char *gcc_input_filename
;
5456 static int input_file_number
;
5457 size_t input_filename_length
;
5458 static int basename_length
;
5459 static int suffixed_basename_length
;
5460 static const char *input_basename
;
5461 static const char *input_suffix
;
5462 #ifndef HOST_LACKS_INODE_NUMBERS
5463 static struct stat input_stat
;
5465 static int input_stat_set
;
5467 /* The compiler used to process the current input file. */
5468 static struct compiler
*input_file_compiler
;
5470 /* These are variables used within do_spec and do_spec_1. */
5472 /* Nonzero if an arg has been started and not yet terminated
5473 (with space, tab or newline). */
5474 static int arg_going
;
5476 /* Nonzero means %d or %g has been seen; the next arg to be terminated
5477 is a temporary file name. */
5478 static int delete_this_arg
;
5480 /* Nonzero means %w has been seen; the next arg to be terminated
5481 is the output file name of this compilation. */
5482 static int this_is_output_file
;
5484 /* Nonzero means %s has been seen; the next arg to be terminated
5485 is the name of a library file and we should try the standard
5486 search dirs for it. */
5487 static int this_is_library_file
;
5489 /* Nonzero means %T has been seen; the next arg to be terminated
5490 is the name of a linker script and we should try all of the
5491 standard search dirs for it. If it is found insert a --script
5492 command line switch and then substitute the full path in place,
5493 otherwise generate an error message. */
5494 static int this_is_linker_script
;
5496 /* Nonzero means that the input of this command is coming from a pipe. */
5497 static int input_from_pipe
;
5499 /* Nonnull means substitute this for any suffix when outputting a switches
5501 static const char *suffix_subst
;
5503 /* If there is an argument being accumulated, terminate it and store it. */
5506 end_going_arg (void)
5512 obstack_1grow (&obstack
, 0);
5513 string
= XOBFINISH (&obstack
, const char *);
5514 if (this_is_library_file
)
5515 string
= find_file (string
);
5516 if (this_is_linker_script
)
5518 char * full_script_path
= find_a_file (&startfile_prefixes
, string
, R_OK
, true);
5520 if (full_script_path
== NULL
)
5522 error ("unable to locate default linker script %qs in the library search paths", string
);
5523 /* Script was not found on search path. */
5526 store_arg ("--script", false, false);
5527 string
= full_script_path
;
5529 store_arg (string
, delete_this_arg
, this_is_output_file
);
5530 if (this_is_output_file
)
5531 outfiles
[input_file_number
] = string
;
5537 /* Parse the WRAPPER string which is a comma separated list of the command line
5538 and insert them into the beginning of argbuf. */
5541 insert_wrapper (const char *wrapper
)
5545 char *buf
= xstrdup (wrapper
);
5547 unsigned int old_length
= argbuf
.length ();
5555 while ((p
= strchr (p
, ',')) != NULL
);
5557 argbuf
.safe_grow (old_length
+ n
, true);
5558 memmove (argbuf
.address () + n
,
5560 old_length
* sizeof (const_char_p
));
5574 while ((p
= strchr (p
, ',')) != NULL
);
5575 gcc_assert (i
== n
);
5578 /* Process the spec SPEC and run the commands specified therein.
5579 Returns 0 if the spec is successfully processed; -1 if failed. */
5582 do_spec (const char *spec
)
5586 value
= do_spec_2 (spec
, NULL
);
5588 /* Force out any unfinished command.
5589 If -pipe, this forces out the last command if it ended in `|'. */
5592 if (argbuf
.length () > 0
5593 && !strcmp (argbuf
.last (), "|"))
5596 set_collect_gcc_options ();
5598 if (argbuf
.length () > 0)
5605 /* Process the spec SPEC, with SOFT_MATCHED_PART designating the current value
5606 of a matched * pattern which may be re-injected by way of %*. */
5609 do_spec_2 (const char *spec
, const char *soft_matched_part
)
5615 delete_this_arg
= 0;
5616 this_is_output_file
= 0;
5617 this_is_library_file
= 0;
5618 this_is_linker_script
= 0;
5619 input_from_pipe
= 0;
5620 suffix_subst
= NULL
;
5622 result
= do_spec_1 (spec
, 0, soft_matched_part
);
5629 /* Process the given spec string and add any new options to the end
5630 of the switches/n_switches array. */
5633 do_option_spec (const char *name
, const char *spec
)
5635 unsigned int i
, value_count
, value_len
;
5636 const char *p
, *q
, *value
;
5637 char *tmp_spec
, *tmp_spec_p
;
5639 if (configure_default_options
[0].name
== NULL
)
5642 for (i
= 0; i
< ARRAY_SIZE (configure_default_options
); i
++)
5643 if (strcmp (configure_default_options
[i
].name
, name
) == 0)
5645 if (i
== ARRAY_SIZE (configure_default_options
))
5648 value
= configure_default_options
[i
].value
;
5649 value_len
= strlen (value
);
5651 /* Compute the size of the final spec. */
5654 while ((p
= strstr (p
, "%(VALUE)")) != NULL
)
5660 /* Replace each %(VALUE) by the specified value. */
5661 tmp_spec
= (char *) alloca (strlen (spec
) + 1
5662 + value_count
* (value_len
- strlen ("%(VALUE)")));
5663 tmp_spec_p
= tmp_spec
;
5665 while ((p
= strstr (q
, "%(VALUE)")) != NULL
)
5667 memcpy (tmp_spec_p
, q
, p
- q
);
5668 tmp_spec_p
= tmp_spec_p
+ (p
- q
);
5669 memcpy (tmp_spec_p
, value
, value_len
);
5670 tmp_spec_p
+= value_len
;
5671 q
= p
+ strlen ("%(VALUE)");
5673 strcpy (tmp_spec_p
, q
);
5675 do_self_spec (tmp_spec
);
5678 /* Process the given spec string and add any new options to the end
5679 of the switches/n_switches array. */
5682 do_self_spec (const char *spec
)
5686 do_spec_2 (spec
, NULL
);
5687 do_spec_1 (" ", 0, NULL
);
5689 /* Mark %<S switches processed by do_self_spec to be ignored permanently.
5690 do_self_specs adds the replacements to switches array, so it shouldn't
5691 be processed afterwards. */
5692 for (i
= 0; i
< n_switches
; i
++)
5693 if ((switches
[i
].live_cond
& SWITCH_IGNORE
))
5694 switches
[i
].live_cond
|= SWITCH_IGNORE_PERMANENTLY
;
5696 if (argbuf
.length () > 0)
5698 const char **argbuf_copy
;
5699 struct cl_decoded_option
*decoded_options
;
5700 struct cl_option_handlers handlers
;
5701 unsigned int decoded_options_count
;
5704 /* Create a copy of argbuf with a dummy argv[0] entry for
5705 decode_cmdline_options_to_array. */
5706 argbuf_copy
= XNEWVEC (const char *,
5707 argbuf
.length () + 1);
5708 argbuf_copy
[0] = "";
5709 memcpy (argbuf_copy
+ 1, argbuf
.address (),
5710 argbuf
.length () * sizeof (const char *));
5712 decode_cmdline_options_to_array (argbuf
.length () + 1,
5714 CL_DRIVER
, &decoded_options
,
5715 &decoded_options_count
);
5718 set_option_handlers (&handlers
);
5720 for (j
= 1; j
< decoded_options_count
; j
++)
5722 switch (decoded_options
[j
].opt_index
)
5724 case OPT_SPECIAL_input_file
:
5725 /* Specs should only generate options, not input
5727 if (strcmp (decoded_options
[j
].arg
, "-") != 0)
5728 fatal_error (input_location
,
5729 "switch %qs does not start with %<-%>",
5730 decoded_options
[j
].arg
);
5732 fatal_error (input_location
,
5733 "spec-generated switch is just %<-%>");
5736 case OPT_fcompare_debug_second
:
5737 case OPT_fcompare_debug
:
5738 case OPT_fcompare_debug_
:
5740 /* Avoid duplicate processing of some options from
5741 compare-debug specs; just save them here. */
5742 save_switch (decoded_options
[j
].canonical_option
[0],
5743 (decoded_options
[j
].canonical_option_num_elements
5745 &decoded_options
[j
].canonical_option
[1], false, true);
5749 read_cmdline_option (&global_options
, &global_options_set
,
5750 decoded_options
+ j
, UNKNOWN_LOCATION
,
5751 CL_DRIVER
, &handlers
, global_dc
);
5756 free (decoded_options
);
5759 switches
[n_switches
].part1
= 0;
5763 /* Callback for processing %D and %I specs. */
5765 struct spec_path_info
{
5770 bool separate_options
;
5774 spec_path (char *path
, void *data
)
5776 struct spec_path_info
*info
= (struct spec_path_info
*) data
;
5780 if (info
->omit_relative
&& !IS_ABSOLUTE_PATH (path
))
5783 if (info
->append_len
!= 0)
5785 len
= strlen (path
);
5786 memcpy (path
+ len
, info
->append
, info
->append_len
+ 1);
5789 if (!is_directory (path
, true))
5792 do_spec_1 (info
->option
, 1, NULL
);
5793 if (info
->separate_options
)
5794 do_spec_1 (" ", 0, NULL
);
5796 if (info
->append_len
== 0)
5798 len
= strlen (path
);
5799 save
= path
[len
- 1];
5800 if (IS_DIR_SEPARATOR (path
[len
- 1]))
5801 path
[len
- 1] = '\0';
5804 do_spec_1 (path
, 1, NULL
);
5805 do_spec_1 (" ", 0, NULL
);
5807 /* Must not damage the original path. */
5808 if (info
->append_len
== 0)
5809 path
[len
- 1] = save
;
5814 /* True if we should compile INFILE. */
5817 compile_input_file_p (struct infile
*infile
)
5819 if ((!infile
->language
) || (infile
->language
[0] != '*'))
5820 if (infile
->incompiler
== input_file_compiler
)
5825 /* Process each member of VEC as a spec. */
5828 do_specs_vec (vec
<char_p
> vec
)
5833 FOR_EACH_VEC_ELT (vec
, ix
, opt
)
5835 do_spec_1 (opt
, 1, NULL
);
5836 /* Make each accumulated option a separate argument. */
5837 do_spec_1 (" ", 0, NULL
);
5841 /* Add options passed via -Xassembler or -Wa to COLLECT_AS_OPTIONS. */
5844 putenv_COLLECT_AS_OPTIONS (vec
<char_p
> vec
)
5846 if (vec
.is_empty ())
5849 obstack_init (&collect_obstack
);
5850 obstack_grow (&collect_obstack
, "COLLECT_AS_OPTIONS=",
5851 strlen ("COLLECT_AS_OPTIONS="));
5856 FOR_EACH_VEC_ELT (vec
, ix
, opt
)
5858 obstack_1grow (&collect_obstack
, '\'');
5859 obstack_grow (&collect_obstack
, opt
, strlen (opt
));
5860 obstack_1grow (&collect_obstack
, '\'');
5861 if (ix
< vec
.length () - 1)
5862 obstack_1grow(&collect_obstack
, ' ');
5865 obstack_1grow (&collect_obstack
, '\0');
5866 xputenv (XOBFINISH (&collect_obstack
, char *));
5869 /* Process the sub-spec SPEC as a portion of a larger spec.
5870 This is like processing a whole spec except that we do
5871 not initialize at the beginning and we do not supply a
5872 newline by default at the end.
5873 INSWITCH nonzero means don't process %-sequences in SPEC;
5874 in this case, % is treated as an ordinary character.
5875 This is used while substituting switches.
5876 INSWITCH nonzero also causes SPC not to terminate an argument.
5878 Value is zero unless a line was finished
5879 and the command on that line reported an error. */
5882 do_spec_1 (const char *spec
, int inswitch
, const char *soft_matched_part
)
5884 const char *p
= spec
;
5889 /* If it's an empty string argument to a switch, keep it as is. */
5890 if (inswitch
&& !*p
)
5894 /* If substituting a switch, treat all chars like letters.
5895 Otherwise, NL, SPC, TAB and % are special. */
5896 switch (inswitch
? 'a' : c
)
5901 if (argbuf
.length () > 0
5902 && !strcmp (argbuf
.last (), "|"))
5904 /* A `|' before the newline means use a pipe here,
5905 but only if -pipe was specified.
5906 Otherwise, execute now and don't pass the `|' as an arg. */
5909 input_from_pipe
= 1;
5916 set_collect_gcc_options ();
5918 if (argbuf
.length () > 0)
5924 /* Reinitialize for a new command, and for a new argument. */
5927 delete_this_arg
= 0;
5928 this_is_output_file
= 0;
5929 this_is_library_file
= 0;
5930 this_is_linker_script
= 0;
5931 input_from_pipe
= 0;
5938 obstack_1grow (&obstack
, c
);
5946 /* Reinitialize for a new argument. */
5947 delete_this_arg
= 0;
5948 this_is_output_file
= 0;
5949 this_is_library_file
= 0;
5950 this_is_linker_script
= 0;
5957 fatal_error (input_location
, "spec %qs invalid", spec
);
5960 /* Don't use %b in the linker command. */
5961 gcc_assert (suffixed_basename_length
);
5962 if (!this_is_output_file
&& dumpdir_length
)
5963 obstack_grow (&obstack
, dumpdir
, dumpdir_length
);
5964 if (this_is_output_file
|| !outbase_length
)
5965 obstack_grow (&obstack
, input_basename
, basename_length
);
5967 obstack_grow (&obstack
, outbase
, outbase_length
);
5968 if (compare_debug
< 0)
5969 obstack_grow (&obstack
, ".gk", 3);
5974 /* Don't use %B in the linker command. */
5975 gcc_assert (suffixed_basename_length
);
5976 if (!this_is_output_file
&& dumpdir_length
)
5977 obstack_grow (&obstack
, dumpdir
, dumpdir_length
);
5978 if (this_is_output_file
|| !outbase_length
)
5979 obstack_grow (&obstack
, input_basename
, basename_length
);
5981 obstack_grow (&obstack
, outbase
, outbase_length
);
5982 if (compare_debug
< 0)
5983 obstack_grow (&obstack
, ".gk", 3);
5984 obstack_grow (&obstack
, input_basename
+ basename_length
,
5985 suffixed_basename_length
- basename_length
);
5991 delete_this_arg
= 2;
5994 /* Dump out the directories specified with LIBRARY_PATH,
5995 followed by the absolute directories
5996 that we search for startfiles. */
5999 struct spec_path_info info
;
6002 info
.append_len
= 0;
6003 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
6004 /* Used on systems which record the specified -L dirs
6005 and use them to search for dynamic linking.
6006 Relative directories always come from -B,
6007 and it is better not to use them for searching
6008 at run time. In particular, stage1 loses. */
6009 info
.omit_relative
= true;
6011 info
.omit_relative
= false;
6013 info
.separate_options
= false;
6015 for_each_path (&startfile_prefixes
, true, 0, spec_path
, &info
);
6020 /* %efoo means report an error with `foo' as error message
6021 and don't execute any more commands for this file. */
6025 while (*p
!= 0 && *p
!= '\n')
6027 buf
= (char *) alloca (p
- q
+ 1);
6028 strncpy (buf
, q
, p
- q
);
6030 error ("%s", _(buf
));
6035 /* %nfoo means report a notice with `foo' on stderr. */
6039 while (*p
!= 0 && *p
!= '\n')
6041 buf
= (char *) alloca (p
- q
+ 1);
6042 strncpy (buf
, q
, p
- q
);
6044 inform (UNKNOWN_LOCATION
, "%s", _(buf
));
6054 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
6055 defined, and it is not a directory, and it is
6056 writable, use it. Otherwise, treat this like any
6057 other temporary file. */
6059 if ((!save_temps_flag
)
6060 && (stat (HOST_BIT_BUCKET
, &st
) == 0) && (!S_ISDIR (st
.st_mode
))
6061 && (access (HOST_BIT_BUCKET
, W_OK
) == 0))
6063 obstack_grow (&obstack
, HOST_BIT_BUCKET
,
6064 strlen (HOST_BIT_BUCKET
));
6065 delete_this_arg
= 0;
6070 goto create_temp_file
;
6074 obstack_1grow (&obstack
, '-');
6075 delete_this_arg
= 0;
6078 /* consume suffix */
6079 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
6081 if (p
[0] == '%' && p
[1] == 'O')
6086 goto create_temp_file
;
6090 /* consume suffix */
6091 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
6093 if (p
[0] == '%' && p
[1] == 'O')
6098 goto create_temp_file
;
6104 struct temp_name
*t
;
6106 const char *suffix
= p
;
6107 char *saved_suffix
= NULL
;
6109 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
6111 suffix_length
= p
- suffix
;
6112 if (p
[0] == '%' && p
[1] == 'O')
6115 /* We don't support extra suffix characters after %O. */
6116 if (*p
== '.' || ISALNUM ((unsigned char) *p
))
6117 fatal_error (input_location
,
6118 "spec %qs has invalid %<%%0%c%>", spec
, *p
);
6119 if (suffix_length
== 0)
6120 suffix
= TARGET_OBJECT_SUFFIX
;
6124 = XNEWVEC (char, suffix_length
6125 + strlen (TARGET_OBJECT_SUFFIX
) + 1);
6126 strncpy (saved_suffix
, suffix
, suffix_length
);
6127 strcpy (saved_suffix
+ suffix_length
,
6128 TARGET_OBJECT_SUFFIX
);
6130 suffix_length
+= strlen (TARGET_OBJECT_SUFFIX
);
6133 if (compare_debug
< 0)
6135 suffix
= concat (".gk", suffix
, NULL
);
6139 /* If -save-temps was specified, use that for the
6141 if (save_temps_flag
)
6144 bool adjusted_suffix
= false;
6146 && !outbase_length
&& !basename_length
6147 && !dumpdir_trailing_dash_added
)
6149 adjusted_suffix
= true;
6153 temp_filename_length
6154 = dumpdir_length
+ suffix_length
+ 1;
6156 temp_filename_length
+= outbase_length
;
6158 temp_filename_length
+= basename_length
;
6159 tmp
= (char *) alloca (temp_filename_length
);
6161 memcpy (tmp
, dumpdir
, dumpdir_length
);
6163 memcpy (tmp
+ dumpdir_length
, outbase
,
6165 else if (basename_length
)
6166 memcpy (tmp
+ dumpdir_length
, input_basename
,
6168 memcpy (tmp
+ temp_filename_length
- suffix_length
- 1,
6169 suffix
, suffix_length
);
6170 if (adjusted_suffix
)
6172 adjusted_suffix
= false;
6176 tmp
[temp_filename_length
- 1] = '\0';
6177 temp_filename
= tmp
;
6179 if (filename_cmp (temp_filename
, gcc_input_filename
) != 0)
6181 #ifndef HOST_LACKS_INODE_NUMBERS
6182 struct stat st_temp
;
6184 /* Note, set_input() resets input_stat_set to 0. */
6185 if (input_stat_set
== 0)
6187 input_stat_set
= stat (gcc_input_filename
,
6189 if (input_stat_set
>= 0)
6193 /* If we have the stat for the gcc_input_filename
6194 and we can do the stat for the temp_filename
6195 then the they could still refer to the same
6196 file if st_dev/st_ino's are the same. */
6197 if (input_stat_set
!= 1
6198 || stat (temp_filename
, &st_temp
) < 0
6199 || input_stat
.st_dev
!= st_temp
.st_dev
6200 || input_stat
.st_ino
!= st_temp
.st_ino
)
6202 /* Just compare canonical pathnames. */
6203 char* input_realname
= lrealpath (gcc_input_filename
);
6204 char* temp_realname
= lrealpath (temp_filename
);
6205 bool files_differ
= filename_cmp (input_realname
, temp_realname
);
6206 free (input_realname
);
6207 free (temp_realname
);
6212 = save_string (temp_filename
,
6213 temp_filename_length
- 1);
6214 obstack_grow (&obstack
, temp_filename
,
6215 temp_filename_length
);
6217 delete_this_arg
= 0;
6223 /* See if we already have an association of %g/%u/%U and
6225 for (t
= temp_names
; t
; t
= t
->next
)
6226 if (t
->length
== suffix_length
6227 && strncmp (t
->suffix
, suffix
, suffix_length
) == 0
6228 && t
->unique
== (c
== 'u' || c
== 'U' || c
== 'j'))
6231 /* Make a new association if needed. %u and %j
6233 if (t
== 0 || c
== 'u' || c
== 'j')
6237 t
= XNEW (struct temp_name
);
6238 t
->next
= temp_names
;
6241 t
->length
= suffix_length
;
6244 t
->suffix
= saved_suffix
;
6245 saved_suffix
= NULL
;
6248 t
->suffix
= save_string (suffix
, suffix_length
);
6249 t
->unique
= (c
== 'u' || c
== 'U' || c
== 'j');
6250 temp_filename
= make_temp_file (t
->suffix
);
6251 temp_filename_length
= strlen (temp_filename
);
6252 t
->filename
= temp_filename
;
6253 t
->filename_length
= temp_filename_length
;
6256 free (saved_suffix
);
6258 obstack_grow (&obstack
, t
->filename
, t
->filename_length
);
6259 delete_this_arg
= 1;
6267 /* We are going to expand `%i' into `@FILE', where FILE
6268 is a newly-created temporary filename. The filenames
6269 that would usually be expanded in place of %o will be
6270 written to the temporary file. */
6271 if (at_file_supplied
)
6274 for (i
= 0; (int) i
< n_infiles
; i
++)
6275 if (compile_input_file_p (&infiles
[i
]))
6277 store_arg (infiles
[i
].name
, 0, 0);
6278 infiles
[i
].compiled
= true;
6281 if (at_file_supplied
)
6286 obstack_grow (&obstack
, gcc_input_filename
,
6287 input_filename_length
);
6294 struct spec_path_info info
;
6298 do_spec_1 ("-imultilib", 1, NULL
);
6299 /* Make this a separate argument. */
6300 do_spec_1 (" ", 0, NULL
);
6301 do_spec_1 (multilib_dir
, 1, NULL
);
6302 do_spec_1 (" ", 0, NULL
);
6307 do_spec_1 ("-imultiarch", 1, NULL
);
6308 /* Make this a separate argument. */
6309 do_spec_1 (" ", 0, NULL
);
6310 do_spec_1 (multiarch_dir
, 1, NULL
);
6311 do_spec_1 (" ", 0, NULL
);
6314 if (gcc_exec_prefix
)
6316 do_spec_1 ("-iprefix", 1, NULL
);
6317 /* Make this a separate argument. */
6318 do_spec_1 (" ", 0, NULL
);
6319 do_spec_1 (gcc_exec_prefix
, 1, NULL
);
6320 do_spec_1 (" ", 0, NULL
);
6323 if (target_system_root_changed
||
6324 (target_system_root
&& target_sysroot_hdrs_suffix
))
6326 do_spec_1 ("-isysroot", 1, NULL
);
6327 /* Make this a separate argument. */
6328 do_spec_1 (" ", 0, NULL
);
6329 do_spec_1 (target_system_root
, 1, NULL
);
6330 if (target_sysroot_hdrs_suffix
)
6331 do_spec_1 (target_sysroot_hdrs_suffix
, 1, NULL
);
6332 do_spec_1 (" ", 0, NULL
);
6335 info
.option
= "-isystem";
6336 info
.append
= "include";
6337 info
.append_len
= strlen (info
.append
);
6338 info
.omit_relative
= false;
6339 info
.separate_options
= true;
6341 for_each_path (&include_prefixes
, false, info
.append_len
,
6344 info
.append
= "include-fixed";
6345 if (*sysroot_hdrs_suffix_spec
)
6346 info
.append
= concat (info
.append
, dir_separator_str
,
6347 multilib_dir
, NULL
);
6348 info
.append_len
= strlen (info
.append
);
6349 for_each_path (&include_prefixes
, false, info
.append_len
,
6355 /* We are going to expand `%o' into `@FILE', where FILE
6356 is a newly-created temporary filename. The filenames
6357 that would usually be expanded in place of %o will be
6358 written to the temporary file. */
6359 if (at_file_supplied
)
6362 for (i
= 0; i
< n_infiles
+ lang_specific_extra_outfiles
; i
++)
6364 store_arg (outfiles
[i
], 0, 0);
6366 if (at_file_supplied
)
6371 obstack_grow (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
6376 this_is_library_file
= 1;
6380 this_is_linker_script
= 1;
6384 outfiles
[input_file_number
] = NULL
;
6388 this_is_output_file
= 1;
6393 unsigned int cur_index
= argbuf
.length ();
6394 /* Handle the {...} following the %W. */
6396 fatal_error (input_location
,
6397 "spec %qs has invalid %<%%W%c%>", spec
, *p
);
6398 p
= handle_braces (p
+ 1);
6402 /* If any args were output, mark the last one for deletion
6404 if (argbuf
.length () != cur_index
)
6405 record_temp_file (argbuf
.last (), 0, 1);
6410 /* Handle the {...} following the %@. */
6412 fatal_error (input_location
,
6413 "spec %qs has invalid %<%%@%c%>", spec
, *p
);
6414 if (at_file_supplied
)
6416 p
= handle_braces (p
+ 1);
6417 if (at_file_supplied
)
6423 /* %x{OPTION} records OPTION for %X to output. */
6431 /* Skip past the option value and make a copy. */
6433 fatal_error (input_location
,
6434 "spec %qs has invalid %<%%x%c%>", spec
, *p
);
6437 string
= save_string (p1
+ 1, p
- p1
- 2);
6439 /* See if we already recorded this option. */
6440 FOR_EACH_VEC_ELT (linker_options
, ix
, opt
)
6441 if (! strcmp (string
, opt
))
6447 /* This option is new; add it. */
6448 add_linker_option (string
, strlen (string
));
6453 /* Dump out the options accumulated previously using %x. */
6455 do_specs_vec (linker_options
);
6458 /* Dump out the options accumulated previously using -Wa,. */
6460 do_specs_vec (assembler_options
);
6463 /* Dump out the options accumulated previously using -Wp,. */
6465 do_specs_vec (preprocessor_options
);
6468 /* Here are digits and numbers that just process
6469 a certain constant string as a spec. */
6472 value
= do_spec_1 (cc1_spec
, 0, NULL
);
6478 value
= do_spec_1 (cc1plus_spec
, 0, NULL
);
6484 value
= do_spec_1 (asm_spec
, 0, NULL
);
6490 value
= do_spec_1 (asm_final_spec
, 0, NULL
);
6497 const char *const spec
6498 = (input_file_compiler
->cpp_spec
6499 ? input_file_compiler
->cpp_spec
6501 value
= do_spec_1 (spec
, 0, NULL
);
6508 value
= do_spec_1 (endfile_spec
, 0, NULL
);
6514 value
= do_spec_1 (link_spec
, 0, NULL
);
6520 value
= do_spec_1 (lib_spec
, 0, NULL
);
6526 if (multilib_os_dir
== NULL
)
6527 obstack_1grow (&obstack
, '.');
6529 obstack_grow (&obstack
, multilib_os_dir
,
6530 strlen (multilib_os_dir
));
6534 value
= do_spec_1 (libgcc_spec
, 0, NULL
);
6540 /* We assume there is a directory
6541 separator at the end of this string. */
6542 if (target_system_root
)
6544 obstack_grow (&obstack
, target_system_root
,
6545 strlen (target_system_root
));
6546 if (target_sysroot_suffix
)
6547 obstack_grow (&obstack
, target_sysroot_suffix
,
6548 strlen (target_sysroot_suffix
));
6553 value
= do_spec_1 (startfile_spec
, 0, NULL
);
6558 /* Here we define characters other than letters and digits. */
6561 p
= handle_braces (p
);
6567 p
= handle_spec_function (p
, NULL
, soft_matched_part
);
6573 obstack_1grow (&obstack
, '%');
6580 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '%')
6582 suffix_subst
= save_string (p
- 1, len
+ 1);
6587 /* Henceforth ignore the option(s) matching the pattern
6593 int have_wildcard
= 0;
6598 switch_option
= SWITCH_IGNORE
| SWITCH_KEEP_FOR_GCC
;
6600 switch_option
= SWITCH_IGNORE
;
6602 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '\t')
6605 if (p
[len
-1] == '*')
6608 for (i
= 0; i
< n_switches
; i
++)
6609 if (!strncmp (switches
[i
].part1
, p
, len
- have_wildcard
)
6610 && (have_wildcard
|| switches
[i
].part1
[len
] == '\0'))
6612 switches
[i
].live_cond
|= switch_option
;
6613 /* User switch be validated from validate_all_switches.
6614 when the definition is seen from the spec file.
6615 If not defined anywhere, will be rejected. */
6616 if (switches
[i
].known
)
6617 switches
[i
].validated
= true;
6625 if (soft_matched_part
)
6627 if (soft_matched_part
[0])
6628 do_spec_1 (soft_matched_part
, 1, NULL
);
6629 /* Only insert a space after the substitution if it is at the
6630 end of the current sequence. So if:
6632 "%{foo=*:bar%*}%{foo=*:one%*two}"
6634 matches -foo=hello then it will produce:
6636 barhello onehellotwo
6638 if (*p
== 0 || *p
== '}')
6639 do_spec_1 (" ", 0, NULL
);
6642 /* Catch the case where a spec string contains something like
6643 '%{foo:%*}'. i.e. there is no * in the pattern on the left
6644 hand side of the :. */
6645 error ("spec failure: %<%%*%> has not been initialized by pattern match");
6648 /* Process a string found as the value of a spec given by name.
6649 This feature allows individual machine descriptions
6650 to add and use their own specs. */
6653 const char *name
= p
;
6654 struct spec_list
*sl
;
6657 /* The string after the S/P is the name of a spec that is to be
6659 while (*p
&& *p
!= ')')
6662 /* See if it's in the list. */
6663 for (len
= p
- name
, sl
= specs
; sl
; sl
= sl
->next
)
6664 if (sl
->name_len
== len
&& !strncmp (sl
->name
, name
, len
))
6666 name
= *(sl
->ptr_spec
);
6668 fnotice (stderr
, "Processing spec (%s), which is '%s'\n",
6676 value
= do_spec_1 (name
, 0, NULL
);
6681 /* Discard the closing paren. */
6688 /* End a previous argument, if there is one, then issue an
6696 error ("spec failure: unrecognized spec option %qc", c
);
6702 /* Backslash: treat next character as ordinary. */
6705 /* When adding more cases that previously matched default, make
6706 sure to adjust quote_spec_char_p as well. */
6710 /* Ordinary character: put it into the current argument. */
6711 obstack_1grow (&obstack
, c
);
6715 /* End of string. If we are processing a spec function, we need to
6716 end any pending argument. */
6717 if (processing_spec_function
)
6723 /* Look up a spec function. */
6725 static const struct spec_function
*
6726 lookup_spec_function (const char *name
)
6728 const struct spec_function
*sf
;
6730 for (sf
= static_spec_functions
; sf
->name
!= NULL
; sf
++)
6731 if (strcmp (sf
->name
, name
) == 0)
6737 /* Evaluate a spec function. */
6740 eval_spec_function (const char *func
, const char *args
,
6741 const char *soft_matched_part
)
6743 const struct spec_function
*sf
;
6744 const char *funcval
;
6746 /* Saved spec processing context. */
6747 vec
<const_char_p
> save_argbuf
;
6750 int save_delete_this_arg
;
6751 int save_this_is_output_file
;
6752 int save_this_is_library_file
;
6753 int save_input_from_pipe
;
6754 int save_this_is_linker_script
;
6755 const char *save_suffix_subst
;
6757 int save_growing_size
;
6758 void *save_growing_value
= NULL
;
6760 sf
= lookup_spec_function (func
);
6762 fatal_error (input_location
, "unknown spec function %qs", func
);
6764 /* Push the spec processing context. */
6765 save_argbuf
= argbuf
;
6767 save_arg_going
= arg_going
;
6768 save_delete_this_arg
= delete_this_arg
;
6769 save_this_is_output_file
= this_is_output_file
;
6770 save_this_is_library_file
= this_is_library_file
;
6771 save_this_is_linker_script
= this_is_linker_script
;
6772 save_input_from_pipe
= input_from_pipe
;
6773 save_suffix_subst
= suffix_subst
;
6775 /* If we have some object growing now, finalize it so the args and function
6776 eval proceed from a cleared context. This is needed to prevent the first
6777 constructed arg from mistakenly including the growing value. We'll push
6778 this value back on the obstack once the function evaluation is done, to
6779 restore a consistent processing context for our caller. This is fine as
6780 the address of growing objects isn't guaranteed to remain stable until
6781 they are finalized, and we expect this situation to be rare enough for
6782 the extra copy not to be an issue. */
6783 save_growing_size
= obstack_object_size (&obstack
);
6784 if (save_growing_size
> 0)
6785 save_growing_value
= obstack_finish (&obstack
);
6787 /* Create a new spec processing context, and build the function
6791 if (do_spec_2 (args
, soft_matched_part
) < 0)
6792 fatal_error (input_location
, "error in arguments to spec function %qs",
6795 /* argbuf_index is an index for the next argument to be inserted, and
6796 so contains the count of the args already inserted. */
6798 funcval
= (*sf
->func
) (argbuf
.length (),
6801 /* Pop the spec processing context. */
6803 argbuf
= save_argbuf
;
6805 arg_going
= save_arg_going
;
6806 delete_this_arg
= save_delete_this_arg
;
6807 this_is_output_file
= save_this_is_output_file
;
6808 this_is_library_file
= save_this_is_library_file
;
6809 this_is_linker_script
= save_this_is_linker_script
;
6810 input_from_pipe
= save_input_from_pipe
;
6811 suffix_subst
= save_suffix_subst
;
6813 if (save_growing_size
> 0)
6814 obstack_grow (&obstack
, save_growing_value
, save_growing_size
);
6819 /* Handle a spec function call of the form:
6823 ARGS is processed as a spec in a separate context and split into an
6824 argument vector in the normal fashion. The function returns a string
6825 containing a spec which we then process in the caller's context, or
6826 NULL if no processing is required.
6828 If RETVAL_NONNULL is not NULL, then store a bool whether function
6831 SOFT_MATCHED_PART holds the current value of a matched * pattern, which
6832 may be re-expanded with a %* as part of the function arguments. */
6835 handle_spec_function (const char *p
, bool *retval_nonnull
,
6836 const char *soft_matched_part
)
6839 const char *endp
, *funcval
;
6842 processing_spec_function
++;
6844 /* Get the function name. */
6845 for (endp
= p
; *endp
!= '\0'; endp
++)
6847 if (*endp
== '(') /* ) */
6849 /* Only allow [A-Za-z0-9], -, and _ in function names. */
6850 if (!ISALNUM (*endp
) && !(*endp
== '-' || *endp
== '_'))
6851 fatal_error (input_location
, "malformed spec function name");
6853 if (*endp
!= '(') /* ) */
6854 fatal_error (input_location
, "no arguments for spec function");
6855 func
= save_string (p
, endp
- p
);
6858 /* Get the arguments. */
6859 for (count
= 0; *endp
!= '\0'; endp
++)
6868 else if (*endp
== '(') /* ) */
6873 fatal_error (input_location
, "malformed spec function arguments");
6874 args
= save_string (p
, endp
- p
);
6877 /* p now points to just past the end of the spec function expression. */
6879 funcval
= eval_spec_function (func
, args
, soft_matched_part
);
6880 if (funcval
!= NULL
&& do_spec_1 (funcval
, 0, NULL
) < 0)
6883 *retval_nonnull
= funcval
!= NULL
;
6888 processing_spec_function
--;
6893 /* Inline subroutine of handle_braces. Returns true if the current
6894 input suffix matches the atom bracketed by ATOM and END_ATOM. */
6896 input_suffix_matches (const char *atom
, const char *end_atom
)
6898 return (input_suffix
6899 && !strncmp (input_suffix
, atom
, end_atom
- atom
)
6900 && input_suffix
[end_atom
- atom
] == '\0');
6903 /* Subroutine of handle_braces. Returns true if the current
6904 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
6906 input_spec_matches (const char *atom
, const char *end_atom
)
6908 return (input_file_compiler
6909 && input_file_compiler
->suffix
6910 && input_file_compiler
->suffix
[0] != '\0'
6911 && !strncmp (input_file_compiler
->suffix
+ 1, atom
,
6913 && input_file_compiler
->suffix
[end_atom
- atom
+ 1] == '\0');
6916 /* Subroutine of handle_braces. Returns true if a switch
6917 matching the atom bracketed by ATOM and END_ATOM appeared on the
6920 switch_matches (const char *atom
, const char *end_atom
, int starred
)
6923 int len
= end_atom
- atom
;
6924 int plen
= starred
? len
: -1;
6926 for (i
= 0; i
< n_switches
; i
++)
6927 if (!strncmp (switches
[i
].part1
, atom
, len
)
6928 && (starred
|| switches
[i
].part1
[len
] == '\0')
6929 && check_live_switch (i
, plen
))
6932 /* Check if a switch with separated form matching the atom.
6933 We check -D and -U switches. */
6934 else if (switches
[i
].args
!= 0)
6936 if ((*switches
[i
].part1
== 'D' || *switches
[i
].part1
== 'U')
6937 && *switches
[i
].part1
== atom
[0])
6939 if (!strncmp (switches
[i
].args
[0], &atom
[1], len
- 1)
6940 && (starred
|| (switches
[i
].part1
[1] == '\0'
6941 && switches
[i
].args
[0][len
- 1] == '\0'))
6942 && check_live_switch (i
, (starred
? 1 : -1)))
6950 /* Inline subroutine of handle_braces. Mark all of the switches which
6951 match ATOM (extends to END_ATOM; STARRED indicates whether there
6952 was a star after the atom) for later processing. */
6954 mark_matching_switches (const char *atom
, const char *end_atom
, int starred
)
6957 int len
= end_atom
- atom
;
6958 int plen
= starred
? len
: -1;
6960 for (i
= 0; i
< n_switches
; i
++)
6961 if (!strncmp (switches
[i
].part1
, atom
, len
)
6962 && (starred
|| switches
[i
].part1
[len
] == '\0')
6963 && check_live_switch (i
, plen
))
6964 switches
[i
].ordering
= 1;
6967 /* Inline subroutine of handle_braces. Process all the currently
6968 marked switches through give_switch, and clear the marks. */
6970 process_marked_switches (void)
6974 for (i
= 0; i
< n_switches
; i
++)
6975 if (switches
[i
].ordering
== 1)
6977 switches
[i
].ordering
= 0;
6982 /* Handle a %{ ... } construct. P points just inside the leading {.
6983 Returns a pointer one past the end of the brace block, or 0
6984 if we call do_spec_1 and that returns -1. */
6987 handle_braces (const char *p
)
6989 const char *atom
, *end_atom
;
6990 const char *d_atom
= NULL
, *d_end_atom
= NULL
;
6991 char *esc_buf
= NULL
, *d_esc_buf
= NULL
;
6993 const char *orig
= p
;
7001 bool a_must_be_last
= false;
7002 bool ordered_set
= false;
7003 bool disjunct_set
= false;
7004 bool disj_matched
= false;
7005 bool disj_starred
= true;
7006 bool n_way_choice
= false;
7007 bool n_way_matched
= false;
7009 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7016 /* Scan one "atom" (S in the description above of %{}, possibly
7017 with '!', '.', '@', ',', or '*' modifiers). */
7019 a_is_suffix
= false;
7020 a_is_starred
= false;
7021 a_is_negated
= false;
7022 a_is_spectype
= false;
7026 p
++, a_is_negated
= true;
7029 if (*p
== '%' && p
[1] == ':')
7033 p
= handle_spec_function (p
+ 2, &a_matched
, NULL
);
7038 p
++, a_is_suffix
= true;
7040 p
++, a_is_spectype
= true;
7044 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
7045 || *p
== ',' || *p
== '.' || *p
== '@' || *p
== '\\')
7051 fatal_error (input_location
,
7052 "braced spec %qs ends in escape", orig
);
7064 if (esc_buf
&& esc_buf
!= d_esc_buf
)
7067 ep
= esc_buf
= (char *) xmalloc (end_atom
- atom
- esc
+ 1);
7068 for (ap
= atom
; ap
!= end_atom
; ap
++, ep
++)
7080 p
++, a_is_starred
= 1;
7087 /* Substitute the switch(es) indicated by the current atom. */
7089 if (disjunct_set
|| n_way_choice
|| a_is_negated
|| a_is_suffix
7090 || a_is_spectype
|| atom
== end_atom
)
7093 mark_matching_switches (atom
, end_atom
, a_is_starred
);
7096 process_marked_switches ();
7100 /* Substitute some text if the current atom appears as a switch
7102 disjunct_set
= true;
7106 if (atom
&& atom
== end_atom
)
7108 if (!n_way_choice
|| disj_matched
|| *p
== '|'
7109 || a_is_negated
|| a_is_suffix
|| a_is_spectype
7113 /* An empty term may appear as the last choice of an
7114 N-way choice set; it means "otherwise". */
7115 a_must_be_last
= true;
7116 disj_matched
= !n_way_matched
;
7117 disj_starred
= false;
7121 if ((a_is_suffix
|| a_is_spectype
) && a_is_starred
)
7125 disj_starred
= false;
7127 /* Don't bother testing this atom if we already have a
7129 if (!disj_matched
&& !n_way_matched
)
7132 /* a_matched is already set by handle_spec_function. */;
7133 else if (a_is_suffix
)
7134 a_matched
= input_suffix_matches (atom
, end_atom
);
7135 else if (a_is_spectype
)
7136 a_matched
= input_spec_matches (atom
, end_atom
);
7138 a_matched
= switch_matches (atom
, end_atom
, a_is_starred
);
7140 if (a_matched
!= a_is_negated
)
7142 disj_matched
= true;
7144 d_end_atom
= end_atom
;
7145 d_esc_buf
= esc_buf
;
7152 /* Found the body, that is, the text to substitute if the
7153 current disjunction matches. */
7154 p
= process_brace_body (p
+ 1, d_atom
, d_end_atom
, disj_starred
,
7155 disj_matched
&& !n_way_matched
);
7159 /* If we have an N-way choice, reset state for the next
7163 n_way_choice
= true;
7164 n_way_matched
|= disj_matched
;
7165 disj_matched
= false;
7166 disj_starred
= true;
7167 d_atom
= d_end_atom
= NULL
;
7176 while (*p
++ != '}');
7179 if (d_esc_buf
&& d_esc_buf
!= esc_buf
)
7187 fatal_error (input_location
, "braced spec %qs is invalid at %qc", orig
, *p
);
7192 /* Subroutine of handle_braces. Scan and process a brace substitution body
7193 (X in the description of %{} syntax). P points one past the colon;
7194 ATOM and END_ATOM bracket the first atom which was found to be true
7195 (present) in the current disjunction; STARRED indicates whether all
7196 the atoms in the current disjunction were starred (for syntax validation);
7197 MATCHED indicates whether the disjunction matched or not, and therefore
7198 whether or not the body is to be processed through do_spec_1 or just
7199 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
7203 process_brace_body (const char *p
, const char *atom
, const char *end_atom
,
7204 int starred
, int matched
)
7206 const char *body
, *end_body
;
7207 unsigned int nesting_level
;
7208 bool have_subst
= false;
7210 /* Locate the closing } or ;, honoring nested braces.
7211 Trim trailing whitespace. */
7220 if (!--nesting_level
)
7223 else if (*p
== ';' && nesting_level
== 1)
7225 else if (*p
== '%' && p
[1] == '*' && nesting_level
== 1)
7227 else if (*p
== '\0')
7233 while (end_body
[-1] == ' ' || end_body
[-1] == '\t')
7236 if (have_subst
&& !starred
)
7241 /* Copy the substitution body to permanent storage and execute it.
7242 If have_subst is false, this is a simple matter of running the
7243 body through do_spec_1... */
7244 char *string
= save_string (body
, end_body
- body
);
7247 if (do_spec_1 (string
, 0, NULL
) < 0)
7255 /* ... but if have_subst is true, we have to process the
7256 body once for each matching switch, with %* set to the
7257 variant part of the switch. */
7258 unsigned int hard_match_len
= end_atom
- atom
;
7261 for (i
= 0; i
< n_switches
; i
++)
7262 if (!strncmp (switches
[i
].part1
, atom
, hard_match_len
)
7263 && check_live_switch (i
, hard_match_len
))
7265 if (do_spec_1 (string
, 0,
7266 &switches
[i
].part1
[hard_match_len
]) < 0)
7271 /* Pass any arguments this switch has. */
7273 suffix_subst
= NULL
;
7282 fatal_error (input_location
, "braced spec body %qs is invalid", body
);
7285 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
7286 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
7287 spec, or -1 if either exact match or %* is used.
7289 A -O switch is obsoleted by a later -O switch. A -f, -g, -m, or -W switch
7290 whose value does not begin with "no-" is obsoleted by the same value
7291 with the "no-", similarly for a switch with the "no-" prefix. */
7294 check_live_switch (int switchnum
, int prefix_length
)
7296 const char *name
= switches
[switchnum
].part1
;
7299 /* If we already processed this switch and determined if it was
7300 live or not, return our past determination. */
7301 if (switches
[switchnum
].live_cond
!= 0)
7302 return ((switches
[switchnum
].live_cond
& SWITCH_LIVE
) != 0
7303 && (switches
[switchnum
].live_cond
& SWITCH_FALSE
) == 0
7304 && (switches
[switchnum
].live_cond
& SWITCH_IGNORE_PERMANENTLY
)
7307 /* In the common case of {<at-most-one-letter>*}, a negating
7308 switch would always match, so ignore that case. We will just
7309 send the conflicting switches to the compiler phase. */
7310 if (prefix_length
>= 0 && prefix_length
<= 1)
7313 /* Now search for duplicate in a manner that depends on the name. */
7317 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
7318 if (switches
[i
].part1
[0] == 'O')
7320 switches
[switchnum
].validated
= true;
7321 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
7326 case 'W': case 'f': case 'm': case 'g':
7327 if (! strncmp (name
+ 1, "no-", 3))
7329 /* We have Xno-YYY, search for XYYY. */
7330 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
7331 if (switches
[i
].part1
[0] == name
[0]
7332 && ! strcmp (&switches
[i
].part1
[1], &name
[4]))
7334 /* --specs are validated with the validate_switches mechanism. */
7335 if (switches
[switchnum
].known
)
7336 switches
[switchnum
].validated
= true;
7337 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
7343 /* We have XYYY, search for Xno-YYY. */
7344 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
7345 if (switches
[i
].part1
[0] == name
[0]
7346 && switches
[i
].part1
[1] == 'n'
7347 && switches
[i
].part1
[2] == 'o'
7348 && switches
[i
].part1
[3] == '-'
7349 && !strcmp (&switches
[i
].part1
[4], &name
[1]))
7351 /* --specs are validated with the validate_switches mechanism. */
7352 if (switches
[switchnum
].known
)
7353 switches
[switchnum
].validated
= true;
7354 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
7361 /* Otherwise the switch is live. */
7362 switches
[switchnum
].live_cond
|= SWITCH_LIVE
;
7366 /* Pass a switch to the current accumulating command
7367 in the same form that we received it.
7368 SWITCHNUM identifies the switch; it is an index into
7369 the vector of switches gcc received, which is `switches'.
7370 This cannot fail since it never finishes a command line.
7372 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
7375 give_switch (int switchnum
, int omit_first_word
)
7377 if ((switches
[switchnum
].live_cond
& SWITCH_IGNORE
) != 0)
7380 if (!omit_first_word
)
7382 do_spec_1 ("-", 0, NULL
);
7383 do_spec_1 (switches
[switchnum
].part1
, 1, NULL
);
7386 if (switches
[switchnum
].args
!= 0)
7389 for (p
= switches
[switchnum
].args
; *p
; p
++)
7391 const char *arg
= *p
;
7393 do_spec_1 (" ", 0, NULL
);
7396 unsigned length
= strlen (arg
);
7399 while (length
-- && !IS_DIR_SEPARATOR (arg
[length
]))
7400 if (arg
[length
] == '.')
7402 (CONST_CAST (char *, arg
))[length
] = 0;
7406 do_spec_1 (arg
, 1, NULL
);
7408 (CONST_CAST (char *, arg
))[length
] = '.';
7409 do_spec_1 (suffix_subst
, 1, NULL
);
7412 do_spec_1 (arg
, 1, NULL
);
7416 do_spec_1 (" ", 0, NULL
);
7417 switches
[switchnum
].validated
= true;
7420 /* Print GCC configuration (e.g. version, thread model, target,
7421 configuration_arguments) to a given FILE. */
7424 print_configuration (FILE *file
)
7429 fnotice (file
, "Target: %s\n", spec_machine
);
7430 fnotice (file
, "Configured with: %s\n", configuration_arguments
);
7432 #ifdef THREAD_MODEL_SPEC
7433 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
7434 but there's no point in doing all this processing just to get
7435 thread_model back. */
7436 obstack_init (&obstack
);
7437 do_spec_1 (THREAD_MODEL_SPEC
, 0, thread_model
);
7438 obstack_1grow (&obstack
, '\0');
7439 thrmod
= XOBFINISH (&obstack
, const char *);
7441 thrmod
= thread_model
;
7444 fnotice (file
, "Thread model: %s\n", thrmod
);
7445 fnotice (file
, "Supported LTO compression algorithms: zlib");
7447 fnotice (file
, " zstd");
7449 fnotice (file
, "\n");
7451 /* compiler_version is truncated at the first space when initialized
7452 from version string, so truncate version_string at the first space
7453 before comparing. */
7454 for (n
= 0; version_string
[n
]; n
++)
7455 if (version_string
[n
] == ' ')
7458 if (! strncmp (version_string
, compiler_version
, n
)
7459 && compiler_version
[n
] == 0)
7460 fnotice (file
, "gcc version %s %s\n", version_string
,
7463 fnotice (file
, "gcc driver version %s %sexecuting gcc version %s\n",
7464 version_string
, pkgversion_string
, compiler_version
);
7468 #define RETRY_ICE_ATTEMPTS 3
7470 /* Returns true if FILE1 and FILE2 contain equivalent data, 0 otherwise. */
7473 files_equal_p (char *file1
, char *file2
)
7475 struct stat st1
, st2
;
7478 const int bufsize
= 8192;
7479 char *buf
= XNEWVEC (char, bufsize
);
7481 fd1
= open (file1
, O_RDONLY
);
7482 fd2
= open (file2
, O_RDONLY
);
7484 if (fd1
< 0 || fd2
< 0)
7487 if (fstat (fd1
, &st1
) < 0 || fstat (fd2
, &st2
) < 0)
7490 if (st1
.st_size
!= st2
.st_size
)
7493 for (n
= st1
.st_size
; n
; n
-= len
)
7496 if ((int) len
> bufsize
/ 2)
7499 if (read (fd1
, buf
, len
) != (int) len
7500 || read (fd2
, buf
+ bufsize
/ 2, len
) != (int) len
)
7505 if (memcmp (buf
, buf
+ bufsize
/ 2, len
) != 0)
7522 /* Check that compiler's output doesn't differ across runs.
7523 TEMP_STDOUT_FILES and TEMP_STDERR_FILES are arrays of files, containing
7524 stdout and stderr for each compiler run. Return true if all of
7525 TEMP_STDOUT_FILES and TEMP_STDERR_FILES are equivalent. */
7528 check_repro (char **temp_stdout_files
, char **temp_stderr_files
)
7531 for (i
= 0; i
< RETRY_ICE_ATTEMPTS
- 2; ++i
)
7533 if (!files_equal_p (temp_stdout_files
[i
], temp_stdout_files
[i
+ 1])
7534 || !files_equal_p (temp_stderr_files
[i
], temp_stderr_files
[i
+ 1]))
7536 fnotice (stderr
, "The bug is not reproducible, so it is"
7537 " likely a hardware or OS problem.\n");
7541 return i
== RETRY_ICE_ATTEMPTS
- 2;
7544 enum attempt_status
{
7545 ATTEMPT_STATUS_FAIL_TO_RUN
,
7546 ATTEMPT_STATUS_SUCCESS
,
7551 /* Run compiler with arguments NEW_ARGV to reproduce the ICE, storing stdout
7552 to OUT_TEMP and stderr to ERR_TEMP. If APPEND is TRUE, append to OUT_TEMP
7553 and ERR_TEMP instead of truncating. If EMIT_SYSTEM_INFO is TRUE, also write
7554 GCC configuration into to ERR_TEMP. Return ATTEMPT_STATUS_FAIL_TO_RUN if
7555 compiler failed to run, ATTEMPT_STATUS_ICE if compiled ICE-ed and
7556 ATTEMPT_STATUS_SUCCESS otherwise. */
7558 static enum attempt_status
7559 run_attempt (const char **new_argv
, const char *out_temp
,
7560 const char *err_temp
, int emit_system_info
, int append
)
7563 if (emit_system_info
)
7565 FILE *file_out
= fopen (err_temp
, "a");
7566 print_configuration (file_out
);
7567 fputs ("\n", file_out
);
7573 struct pex_obj
*pex
;
7575 int pex_flags
= PEX_USE_PIPES
| PEX_LAST
;
7576 enum attempt_status status
= ATTEMPT_STATUS_FAIL_TO_RUN
;
7579 pex_flags
|= PEX_STDOUT_APPEND
| PEX_STDERR_APPEND
;
7581 pex
= pex_init (PEX_USE_PIPES
, new_argv
[0], NULL
);
7583 fatal_error (input_location
, "%<pex_init%> failed: %m");
7585 errmsg
= pex_run (pex
, pex_flags
, new_argv
[0],
7586 CONST_CAST2 (char *const *, const char **, &new_argv
[1]),
7587 out_temp
, err_temp
, &err
);
7591 fatal_error (input_location
,
7592 err
? G_ ("cannot execute %qs: %s: %m")
7593 : G_ ("cannot execute %qs: %s"),
7594 new_argv
[0], errmsg
);
7597 if (!pex_get_status (pex
, 1, &exit_status
))
7600 switch (WEXITSTATUS (exit_status
))
7603 status
= ATTEMPT_STATUS_ICE
;
7606 case SUCCESS_EXIT_CODE
:
7607 status
= ATTEMPT_STATUS_SUCCESS
;
7619 /* This routine reads lines from IN file, adds C++ style comments
7620 at the begining of each line and writes result into OUT. */
7623 insert_comments (const char *file_in
, const char *file_out
)
7625 FILE *in
= fopen (file_in
, "rb");
7626 FILE *out
= fopen (file_out
, "wb");
7629 bool add_comment
= true;
7630 while (fgets (line
, sizeof (line
), in
))
7635 add_comment
= strchr (line
, '\n') != NULL
;
7642 /* This routine adds preprocessed source code into the given ERR_FILE.
7643 To do this, it adds "-E" to NEW_ARGV and execute RUN_ATTEMPT routine to
7644 add information in report file. RUN_ATTEMPT should return
7645 ATTEMPT_STATUS_SUCCESS, in other case we cannot generate the report. */
7648 do_report_bug (const char **new_argv
, const int nargs
,
7649 char **out_file
, char **err_file
)
7652 int fd
= open (*out_file
, O_RDWR
| O_APPEND
);
7655 write (fd
, "\n//", 3);
7656 for (i
= 0; i
< nargs
; i
++)
7659 write (fd
, new_argv
[i
], strlen (new_argv
[i
]));
7661 write (fd
, "\n\n", 2);
7663 new_argv
[nargs
] = "-E";
7664 new_argv
[nargs
+ 1] = NULL
;
7666 status
= run_attempt (new_argv
, *out_file
, *err_file
, 0, 1);
7668 if (status
== ATTEMPT_STATUS_SUCCESS
)
7670 fnotice (stderr
, "Preprocessed source stored into %s file,"
7671 " please attach this to your bugreport.\n", *out_file
);
7672 /* Make sure it is not deleted. */
7678 /* Try to reproduce ICE. If bug is reproducible, generate report .err file
7679 containing GCC configuration, backtrace, compiler's command line options
7680 and preprocessed source code. */
7683 try_generate_repro (const char **argv
)
7685 int i
, nargs
, out_arg
= -1, quiet
= 0, attempt
;
7686 const char **new_argv
;
7687 char *temp_files
[RETRY_ICE_ATTEMPTS
* 2];
7688 char **temp_stdout_files
= &temp_files
[0];
7689 char **temp_stderr_files
= &temp_files
[RETRY_ICE_ATTEMPTS
];
7691 if (gcc_input_filename
== NULL
|| ! strcmp (gcc_input_filename
, "-"))
7694 for (nargs
= 0; argv
[nargs
] != NULL
; ++nargs
)
7695 /* Only retry compiler ICEs, not preprocessor ones. */
7696 if (! strcmp (argv
[nargs
], "-E"))
7698 else if (argv
[nargs
][0] == '-' && argv
[nargs
][1] == 'o')
7705 /* If the compiler is going to output any time information,
7706 it might varry between invocations. */
7707 else if (! strcmp (argv
[nargs
], "-quiet"))
7709 else if (! strcmp (argv
[nargs
], "-ftime-report"))
7712 if (out_arg
== -1 || !quiet
)
7715 memset (temp_files
, '\0', sizeof (temp_files
));
7716 new_argv
= XALLOCAVEC (const char *, nargs
+ 4);
7717 memcpy (new_argv
, argv
, (nargs
+ 1) * sizeof (const char *));
7718 new_argv
[nargs
++] = "-frandom-seed=0";
7719 new_argv
[nargs
++] = "-fdump-noaddr";
7720 new_argv
[nargs
] = NULL
;
7721 if (new_argv
[out_arg
][2] == '\0')
7722 new_argv
[out_arg
+ 1] = "-";
7724 new_argv
[out_arg
] = "-o-";
7727 for (attempt
= 0; attempt
< RETRY_ICE_ATTEMPTS
; ++attempt
)
7729 int emit_system_info
= 0;
7731 temp_stdout_files
[attempt
] = make_temp_file (".out");
7732 temp_stderr_files
[attempt
] = make_temp_file (".err");
7734 if (attempt
== RETRY_ICE_ATTEMPTS
- 1)
7737 emit_system_info
= 1;
7740 status
= run_attempt (new_argv
, temp_stdout_files
[attempt
],
7741 temp_stderr_files
[attempt
], emit_system_info
,
7744 if (status
!= ATTEMPT_STATUS_ICE
)
7746 fnotice (stderr
, "The bug is not reproducible, so it is"
7747 " likely a hardware or OS problem.\n");
7752 if (!check_repro (temp_stdout_files
, temp_stderr_files
))
7756 /* Insert commented out backtrace into report file. */
7757 char **stderr_commented
= &temp_stdout_files
[RETRY_ICE_ATTEMPTS
- 1];
7758 insert_comments (temp_stderr_files
[RETRY_ICE_ATTEMPTS
- 1],
7761 /* In final attempt we append compiler options and preprocesssed code to last
7762 generated .out file with configuration and backtrace. */
7763 char **err
= &temp_stderr_files
[RETRY_ICE_ATTEMPTS
- 1];
7764 do_report_bug (new_argv
, nargs
, stderr_commented
, err
);
7768 for (i
= 0; i
< RETRY_ICE_ATTEMPTS
* 2; i
++)
7771 unlink (temp_stdout_files
[i
]);
7772 free (temp_stdout_files
[i
]);
7776 /* Search for a file named NAME trying various prefixes including the
7777 user's -B prefix and some standard ones.
7778 Return the absolute file name found. If nothing is found, return NAME. */
7781 find_file (const char *name
)
7783 char *newname
= find_a_file (&startfile_prefixes
, name
, R_OK
, true);
7784 return newname
? newname
: name
;
7787 /* Determine whether a directory exists. If LINKER, return 0 for
7788 certain fixed names not needed by the linker. */
7791 is_directory (const char *path1
, bool linker
)
7798 /* Ensure the string ends with "/.". The resulting path will be a
7799 directory even if the given path is a symbolic link. */
7800 len1
= strlen (path1
);
7801 path
= (char *) alloca (3 + len1
);
7802 memcpy (path
, path1
, len1
);
7804 if (!IS_DIR_SEPARATOR (cp
[-1]))
7805 *cp
++ = DIR_SEPARATOR
;
7809 /* Exclude directories that the linker is known to search. */
7811 && IS_DIR_SEPARATOR (path
[0])
7813 && filename_ncmp (path
+ 1, "lib", 3) == 0)
7815 && filename_ncmp (path
+ 1, "usr", 3) == 0
7816 && IS_DIR_SEPARATOR (path
[4])
7817 && filename_ncmp (path
+ 5, "lib", 3) == 0)))
7820 return (stat (path
, &st
) >= 0 && S_ISDIR (st
.st_mode
));
7823 /* Set up the various global variables to indicate that we're processing
7824 the input file named FILENAME. */
7827 set_input (const char *filename
)
7831 gcc_input_filename
= filename
;
7832 input_filename_length
= strlen (gcc_input_filename
);
7833 input_basename
= lbasename (gcc_input_filename
);
7835 /* Find a suffix starting with the last period,
7836 and set basename_length to exclude that suffix. */
7837 basename_length
= strlen (input_basename
);
7838 suffixed_basename_length
= basename_length
;
7839 p
= input_basename
+ basename_length
;
7840 while (p
!= input_basename
&& *p
!= '.')
7842 if (*p
== '.' && p
!= input_basename
)
7844 basename_length
= p
- input_basename
;
7845 input_suffix
= p
+ 1;
7850 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
7851 we will need to do a stat on the gcc_input_filename. The
7852 INPUT_STAT_SET signals that the stat is needed. */
7856 /* On fatal signals, delete all the temporary files. */
7859 fatal_signal (int signum
)
7861 signal (signum
, SIG_DFL
);
7862 delete_failure_queue ();
7863 delete_temp_files ();
7864 /* Get the same signal again, this time not handled,
7865 so its normal effect occurs. */
7866 kill (getpid (), signum
);
7869 /* Compare the contents of the two files named CMPFILE[0] and
7870 CMPFILE[1]. Return zero if they're identical, nonzero
7874 compare_files (char *cmpfile
[])
7877 FILE *temp
[2] = { NULL
, NULL
};
7883 void *map
[2] = { NULL
, NULL
};
7885 for (i
= 0; i
< 2; i
++)
7889 if (stat (cmpfile
[i
], &st
) < 0 || !S_ISREG (st
.st_mode
))
7891 error ("%s: could not determine length of compare-debug file %s",
7892 gcc_input_filename
, cmpfile
[i
]);
7897 length
[i
] = st
.st_size
;
7900 if (!ret
&& length
[0] != length
[1])
7902 error ("%s: %<-fcompare-debug%> failure (length)", gcc_input_filename
);
7907 for (i
= 0; i
< 2; i
++)
7909 int fd
= open (cmpfile
[i
], O_RDONLY
);
7912 error ("%s: could not open compare-debug file %s",
7913 gcc_input_filename
, cmpfile
[i
]);
7918 map
[i
] = mmap (NULL
, length
[i
], PROT_READ
, MAP_PRIVATE
, fd
, 0);
7921 if (map
[i
] == (void *) MAP_FAILED
)
7930 if (memcmp (map
[0], map
[1], length
[0]) != 0)
7932 error ("%s: %<-fcompare-debug%> failure", gcc_input_filename
);
7937 for (i
= 0; i
< 2; i
++)
7939 munmap ((caddr_t
) map
[i
], length
[i
]);
7948 for (i
= 0; i
< 2; i
++)
7950 temp
[i
] = fopen (cmpfile
[i
], "r");
7953 error ("%s: could not open compare-debug file %s",
7954 gcc_input_filename
, cmpfile
[i
]);
7960 if (!ret
&& temp
[0] && temp
[1])
7964 c0
= fgetc (temp
[0]);
7965 c1
= fgetc (temp
[1]);
7969 error ("%s: %<-fcompare-debug%> failure",
7970 gcc_input_filename
);
7979 for (i
= 1; i
>= 0; i
--)
7988 driver::driver (bool can_finalize
, bool debug
) :
7989 explicit_link_files (NULL
),
7990 decoded_options (NULL
)
7992 env
.init (can_finalize
, debug
);
7997 XDELETEVEC (explicit_link_files
);
7998 XDELETEVEC (decoded_options
);
8001 /* driver::main is implemented as a series of driver:: method calls. */
8004 driver::main (int argc
, char **argv
)
8008 set_progname (argv
[0]);
8009 expand_at_files (&argc
, &argv
);
8010 decode_argv (argc
, const_cast <const char **> (argv
));
8011 global_initializations ();
8012 build_multilib_strings ();
8014 putenv_COLLECT_AS_OPTIONS (assembler_options
);
8015 putenv_COLLECT_GCC (argv
[0]);
8016 maybe_putenv_COLLECT_LTO_WRAPPER ();
8017 maybe_putenv_OFFLOAD_TARGETS ();
8018 handle_unrecognized_options ();
8022 m_option_proposer
.suggest_completion (completion
);
8026 if (!maybe_print_and_exit ())
8029 early_exit
= prepare_infiles ();
8031 return get_exit_code ();
8033 do_spec_on_infiles ();
8034 maybe_run_linker (argv
[0]);
8036 return get_exit_code ();
8039 /* Locate the final component of argv[0] after any leading path, and set
8040 the program name accordingly. */
8043 driver::set_progname (const char *argv0
) const
8045 const char *p
= argv0
+ strlen (argv0
);
8046 while (p
!= argv0
&& !IS_DIR_SEPARATOR (p
[-1]))
8050 xmalloc_set_program_name (progname
);
8053 /* Expand any @ files within the command-line args,
8054 setting at_file_supplied if any were expanded. */
8057 driver::expand_at_files (int *argc
, char ***argv
) const
8059 char **old_argv
= *argv
;
8061 expandargv (argc
, argv
);
8063 /* Determine if any expansions were made. */
8064 if (*argv
!= old_argv
)
8065 at_file_supplied
= true;
8068 /* Decode the command-line arguments from argc/argv into the
8069 decoded_options array. */
8072 driver::decode_argv (int argc
, const char **argv
)
8074 init_opts_obstack ();
8075 init_options_struct (&global_options
, &global_options_set
);
8077 decode_cmdline_options_to_array (argc
, argv
,
8079 &decoded_options
, &decoded_options_count
);
8082 /* Perform various initializations and setup. */
8085 driver::global_initializations ()
8087 /* Unlock the stdio streams. */
8088 unlock_std_streams ();
8090 gcc_init_libintl ();
8092 diagnostic_initialize (global_dc
, 0);
8093 diagnostic_color_init (global_dc
);
8094 diagnostic_urls_init (global_dc
);
8096 #ifdef GCC_DRIVER_HOST_INITIALIZATION
8097 /* Perform host dependent initialization when needed. */
8098 GCC_DRIVER_HOST_INITIALIZATION
;
8101 if (atexit (delete_temp_files
) != 0)
8102 fatal_error (input_location
, "atexit failed");
8104 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
8105 signal (SIGINT
, fatal_signal
);
8107 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
8108 signal (SIGHUP
, fatal_signal
);
8110 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
8111 signal (SIGTERM
, fatal_signal
);
8113 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
8114 signal (SIGPIPE
, fatal_signal
);
8117 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
8118 receive the signal. A different setting is inheritable */
8119 signal (SIGCHLD
, SIG_DFL
);
8122 /* Parsing and gimplification sometimes need quite large stack.
8123 Increase stack size limits if possible. */
8124 stack_limit_increase (64 * 1024 * 1024);
8126 /* Allocate the argument vector. */
8129 obstack_init (&obstack
);
8132 /* Build multilib_select, et. al from the separate lines that make up each
8133 multilib selection. */
8136 driver::build_multilib_strings () const
8140 const char *const *q
= multilib_raw
;
8143 obstack_init (&multilib_obstack
);
8144 while ((p
= *q
++) != (char *) 0)
8145 obstack_grow (&multilib_obstack
, p
, strlen (p
));
8147 obstack_1grow (&multilib_obstack
, 0);
8148 multilib_select
= XOBFINISH (&multilib_obstack
, const char *);
8150 q
= multilib_matches_raw
;
8151 while ((p
= *q
++) != (char *) 0)
8152 obstack_grow (&multilib_obstack
, p
, strlen (p
));
8154 obstack_1grow (&multilib_obstack
, 0);
8155 multilib_matches
= XOBFINISH (&multilib_obstack
, const char *);
8157 q
= multilib_exclusions_raw
;
8158 while ((p
= *q
++) != (char *) 0)
8159 obstack_grow (&multilib_obstack
, p
, strlen (p
));
8161 obstack_1grow (&multilib_obstack
, 0);
8162 multilib_exclusions
= XOBFINISH (&multilib_obstack
, const char *);
8164 q
= multilib_reuse_raw
;
8165 while ((p
= *q
++) != (char *) 0)
8166 obstack_grow (&multilib_obstack
, p
, strlen (p
));
8168 obstack_1grow (&multilib_obstack
, 0);
8169 multilib_reuse
= XOBFINISH (&multilib_obstack
, const char *);
8172 for (size_t i
= 0; i
< ARRAY_SIZE (multilib_defaults_raw
); i
++)
8175 obstack_1grow (&multilib_obstack
, ' ');
8176 obstack_grow (&multilib_obstack
,
8177 multilib_defaults_raw
[i
],
8178 strlen (multilib_defaults_raw
[i
]));
8182 obstack_1grow (&multilib_obstack
, 0);
8183 multilib_defaults
= XOBFINISH (&multilib_obstack
, const char *);
8187 /* Set up the spec-handling machinery. */
8190 driver::set_up_specs () const
8192 const char *spec_machine_suffix
;
8196 #ifdef INIT_ENVIRONMENT
8197 /* Set up any other necessary machine specific environment variables. */
8198 xputenv (INIT_ENVIRONMENT
);
8201 /* Make a table of what switches there are (switches, n_switches).
8202 Make a table of specified input files (infiles, n_infiles).
8203 Decode switches that are handled locally. */
8205 process_command (decoded_options_count
, decoded_options
);
8207 /* Initialize the vector of specs to just the default.
8208 This means one element containing 0s, as a terminator. */
8210 compilers
= XNEWVAR (struct compiler
, sizeof default_compilers
);
8211 memcpy (compilers
, default_compilers
, sizeof default_compilers
);
8212 n_compilers
= n_default_compilers
;
8214 /* Read specs from a file if there is one. */
8216 machine_suffix
= concat (spec_host_machine
, dir_separator_str
, spec_version
,
8217 accel_dir_suffix
, dir_separator_str
, NULL
);
8218 just_machine_suffix
= concat (spec_machine
, dir_separator_str
, NULL
);
8220 specs_file
= find_a_file (&startfile_prefixes
, "specs", R_OK
, true);
8221 /* Read the specs file unless it is a default one. */
8222 if (specs_file
!= 0 && strcmp (specs_file
, "specs"))
8223 read_specs (specs_file
, true, false);
8227 #ifdef ACCEL_COMPILER
8228 spec_machine_suffix
= machine_suffix
;
8230 spec_machine_suffix
= just_machine_suffix
;
8233 /* We need to check standard_exec_prefix/spec_machine_suffix/specs
8234 for any override of as, ld and libraries. */
8235 specs_file
= (char *) alloca (strlen (standard_exec_prefix
)
8236 + strlen (spec_machine_suffix
) + sizeof ("specs"));
8237 strcpy (specs_file
, standard_exec_prefix
);
8238 strcat (specs_file
, spec_machine_suffix
);
8239 strcat (specs_file
, "specs");
8240 if (access (specs_file
, R_OK
) == 0)
8241 read_specs (specs_file
, true, false);
8243 /* Process any configure-time defaults specified for the command line
8244 options, via OPTION_DEFAULT_SPECS. */
8245 for (i
= 0; i
< ARRAY_SIZE (option_default_specs
); i
++)
8246 do_option_spec (option_default_specs
[i
].name
,
8247 option_default_specs
[i
].spec
);
8249 /* Process DRIVER_SELF_SPECS, adding any new options to the end
8250 of the command line. */
8252 for (i
= 0; i
< ARRAY_SIZE (driver_self_specs
); i
++)
8253 do_self_spec (driver_self_specs
[i
]);
8255 /* If not cross-compiling, look for executables in the standard
8257 if (*cross_compile
== '0')
8259 if (*md_exec_prefix
)
8261 add_prefix (&exec_prefixes
, md_exec_prefix
, "GCC",
8262 PREFIX_PRIORITY_LAST
, 0, 0);
8266 /* Process sysroot_suffix_spec. */
8267 if (*sysroot_suffix_spec
!= 0
8268 && !no_sysroot_suffix
8269 && do_spec_2 (sysroot_suffix_spec
, NULL
) == 0)
8271 if (argbuf
.length () > 1)
8272 error ("spec failure: more than one argument to "
8273 "%<SYSROOT_SUFFIX_SPEC%>");
8274 else if (argbuf
.length () == 1)
8275 target_sysroot_suffix
= xstrdup (argbuf
.last ());
8278 #ifdef HAVE_LD_SYSROOT
8279 /* Pass the --sysroot option to the linker, if it supports that. If
8280 there is a sysroot_suffix_spec, it has already been processed by
8281 this point, so target_system_root really is the system root we
8283 if (target_system_root
)
8285 obstack_grow (&obstack
, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
8286 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
8287 set_spec ("link", XOBFINISH (&obstack
, const char *), false);
8291 /* Process sysroot_hdrs_suffix_spec. */
8292 if (*sysroot_hdrs_suffix_spec
!= 0
8293 && !no_sysroot_suffix
8294 && do_spec_2 (sysroot_hdrs_suffix_spec
, NULL
) == 0)
8296 if (argbuf
.length () > 1)
8297 error ("spec failure: more than one argument "
8298 "to %<SYSROOT_HEADERS_SUFFIX_SPEC%>");
8299 else if (argbuf
.length () == 1)
8300 target_sysroot_hdrs_suffix
= xstrdup (argbuf
.last ());
8303 /* Look for startfiles in the standard places. */
8304 if (*startfile_prefix_spec
!= 0
8305 && do_spec_2 (startfile_prefix_spec
, NULL
) == 0
8306 && do_spec_1 (" ", 0, NULL
) == 0)
8310 FOR_EACH_VEC_ELT (argbuf
, ndx
, arg
)
8311 add_sysrooted_prefix (&startfile_prefixes
, arg
, "BINUTILS",
8312 PREFIX_PRIORITY_LAST
, 0, 1);
8314 /* We should eventually get rid of all these and stick to
8315 startfile_prefix_spec exclusively. */
8316 else if (*cross_compile
== '0' || target_system_root
)
8318 if (*md_startfile_prefix
)
8319 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix
,
8320 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
8322 if (*md_startfile_prefix_1
)
8323 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix_1
,
8324 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
8326 /* If standard_startfile_prefix is relative, base it on
8327 standard_exec_prefix. This lets us move the installed tree
8328 as a unit. If GCC_EXEC_PREFIX is defined, base
8329 standard_startfile_prefix on that as well.
8331 If the prefix is relative, only search it for native compilers;
8332 otherwise we will search a directory containing host libraries. */
8333 if (IS_ABSOLUTE_PATH (standard_startfile_prefix
))
8334 add_sysrooted_prefix (&startfile_prefixes
,
8335 standard_startfile_prefix
, "BINUTILS",
8336 PREFIX_PRIORITY_LAST
, 0, 1);
8337 else if (*cross_compile
== '0')
8339 add_prefix (&startfile_prefixes
,
8340 concat (gcc_exec_prefix
8341 ? gcc_exec_prefix
: standard_exec_prefix
,
8343 standard_startfile_prefix
, NULL
),
8344 NULL
, PREFIX_PRIORITY_LAST
, 0, 1);
8347 /* Sysrooted prefixes are relocated because target_system_root is
8348 also relocated by gcc_exec_prefix. */
8349 if (*standard_startfile_prefix_1
)
8350 add_sysrooted_prefix (&startfile_prefixes
,
8351 standard_startfile_prefix_1
, "BINUTILS",
8352 PREFIX_PRIORITY_LAST
, 0, 1);
8353 if (*standard_startfile_prefix_2
)
8354 add_sysrooted_prefix (&startfile_prefixes
,
8355 standard_startfile_prefix_2
, "BINUTILS",
8356 PREFIX_PRIORITY_LAST
, 0, 1);
8359 /* Process any user specified specs in the order given on the command
8361 for (struct user_specs
*uptr
= user_specs_head
; uptr
; uptr
= uptr
->next
)
8363 char *filename
= find_a_file (&startfile_prefixes
, uptr
->filename
,
8365 read_specs (filename
? filename
: uptr
->filename
, false, true);
8368 /* Process any user self specs. */
8370 struct spec_list
*sl
;
8371 for (sl
= specs
; sl
; sl
= sl
->next
)
8372 if (sl
->name_len
== sizeof "self_spec" - 1
8373 && !strcmp (sl
->name
, "self_spec"))
8374 do_self_spec (*sl
->ptr_spec
);
8379 enum save_temps save
;
8381 if (!compare_debug_second
)
8383 n_switches_debug_check
[1] = n_switches
;
8384 n_switches_alloc_debug_check
[1] = n_switches_alloc
;
8385 switches_debug_check
[1] = XDUPVEC (struct switchstr
, switches
,
8388 do_self_spec ("%:compare-debug-self-opt()");
8389 n_switches_debug_check
[0] = n_switches
;
8390 n_switches_alloc_debug_check
[0] = n_switches_alloc
;
8391 switches_debug_check
[0] = switches
;
8393 n_switches
= n_switches_debug_check
[1];
8394 n_switches_alloc
= n_switches_alloc_debug_check
[1];
8395 switches
= switches_debug_check
[1];
8398 /* Avoid crash when computing %j in this early. */
8399 save
= save_temps_flag
;
8400 save_temps_flag
= SAVE_TEMPS_NONE
;
8402 compare_debug
= -compare_debug
;
8403 do_self_spec ("%:compare-debug-self-opt()");
8405 save_temps_flag
= save
;
8407 if (!compare_debug_second
)
8409 n_switches_debug_check
[1] = n_switches
;
8410 n_switches_alloc_debug_check
[1] = n_switches_alloc
;
8411 switches_debug_check
[1] = switches
;
8412 compare_debug
= -compare_debug
;
8413 n_switches
= n_switches_debug_check
[0];
8414 n_switches_alloc
= n_switches_debug_check
[0];
8415 switches
= switches_debug_check
[0];
8420 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
8421 if (gcc_exec_prefix
)
8422 gcc_exec_prefix
= concat (gcc_exec_prefix
, spec_host_machine
,
8423 dir_separator_str
, spec_version
,
8424 accel_dir_suffix
, dir_separator_str
, NULL
);
8426 /* Now we have the specs.
8427 Set the `valid' bits for switches that match anything in any spec. */
8429 validate_all_switches ();
8431 /* Now that we have the switches and the specs, set
8432 the subdirectory based on the options. */
8433 set_multilib_dir ();
8436 /* Set up to remember the pathname of gcc and any options
8437 needed for collect. We use argv[0] instead of progname because
8438 we need the complete pathname. */
8441 driver::putenv_COLLECT_GCC (const char *argv0
) const
8443 obstack_init (&collect_obstack
);
8444 obstack_grow (&collect_obstack
, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
8445 obstack_grow (&collect_obstack
, argv0
, strlen (argv0
) + 1);
8446 xputenv (XOBFINISH (&collect_obstack
, char *));
8449 /* Set up to remember the pathname of the lto wrapper. */
8452 driver::maybe_putenv_COLLECT_LTO_WRAPPER () const
8454 char *lto_wrapper_file
;
8457 lto_wrapper_file
= NULL
;
8459 lto_wrapper_file
= find_a_file (&exec_prefixes
, "lto-wrapper",
8461 if (lto_wrapper_file
)
8463 lto_wrapper_file
= convert_white_space (lto_wrapper_file
);
8464 set_static_spec_owned (<o_wrapper_spec
, lto_wrapper_file
);
8465 obstack_init (&collect_obstack
);
8466 obstack_grow (&collect_obstack
, "COLLECT_LTO_WRAPPER=",
8467 sizeof ("COLLECT_LTO_WRAPPER=") - 1);
8468 obstack_grow (&collect_obstack
, lto_wrapper_spec
,
8469 strlen (lto_wrapper_spec
) + 1);
8470 xputenv (XOBFINISH (&collect_obstack
, char *));
8475 /* Set up to remember the names of offload targets. */
8478 driver::maybe_putenv_OFFLOAD_TARGETS () const
8480 if (offload_targets
&& offload_targets
[0] != '\0')
8482 obstack_grow (&collect_obstack
, "OFFLOAD_TARGET_NAMES=",
8483 sizeof ("OFFLOAD_TARGET_NAMES=") - 1);
8484 obstack_grow (&collect_obstack
, offload_targets
,
8485 strlen (offload_targets
) + 1);
8486 xputenv (XOBFINISH (&collect_obstack
, char *));
8489 free (offload_targets
);
8490 offload_targets
= NULL
;
8493 /* Reject switches that no pass was interested in. */
8496 driver::handle_unrecognized_options ()
8498 for (size_t i
= 0; (int) i
< n_switches
; i
++)
8499 if (! switches
[i
].validated
)
8501 const char *hint
= m_option_proposer
.suggest_option (switches
[i
].part1
);
8503 error ("unrecognized command-line option %<-%s%>;"
8504 " did you mean %<-%s%>?",
8505 switches
[i
].part1
, hint
);
8507 error ("unrecognized command-line option %<-%s%>",
8512 /* Handle the various -print-* options, returning 0 if the driver
8513 should exit, or nonzero if the driver should continue. */
8516 driver::maybe_print_and_exit () const
8518 if (print_search_dirs
)
8520 printf (_("install: %s%s\n"),
8521 gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
8522 gcc_exec_prefix
? "" : machine_suffix
);
8523 printf (_("programs: %s\n"),
8524 build_search_list (&exec_prefixes
, "", false, false));
8525 printf (_("libraries: %s\n"),
8526 build_search_list (&startfile_prefixes
, "", false, true));
8530 if (print_file_name
)
8532 printf ("%s\n", find_file (print_file_name
));
8536 if (print_prog_name
)
8538 if (use_ld
!= NULL
&& ! strcmp (print_prog_name
, "ld"))
8540 /* Append USE_LD to the default linker. */
8541 #ifdef DEFAULT_LINKER
8543 # ifdef HAVE_HOST_EXECUTABLE_SUFFIX
8544 int len
= (sizeof (DEFAULT_LINKER
)
8545 - sizeof (HOST_EXECUTABLE_SUFFIX
));
8549 char *default_linker
= xstrdup (DEFAULT_LINKER
);
8550 /* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains
8551 HOST_EXECUTABLE_SUFFIX. */
8552 if (! strcmp (&default_linker
[len
], HOST_EXECUTABLE_SUFFIX
))
8554 default_linker
[len
] = '\0';
8555 ld
= concat (default_linker
, use_ld
,
8556 HOST_EXECUTABLE_SUFFIX
, NULL
);
8561 ld
= concat (DEFAULT_LINKER
, use_ld
, NULL
);
8562 if (access (ld
, X_OK
) == 0)
8564 printf ("%s\n", ld
);
8568 print_prog_name
= concat (print_prog_name
, use_ld
, NULL
);
8570 char *newname
= find_a_file (&exec_prefixes
, print_prog_name
, X_OK
, 0);
8571 printf ("%s\n", (newname
? newname
: print_prog_name
));
8575 if (print_multi_lib
)
8577 print_multilib_info ();
8581 if (print_multi_directory
)
8583 if (multilib_dir
== NULL
)
8586 printf ("%s\n", multilib_dir
);
8590 if (print_multiarch
)
8592 if (multiarch_dir
== NULL
)
8595 printf ("%s\n", multiarch_dir
);
8601 if (target_system_root
)
8603 if (target_sysroot_suffix
)
8604 printf ("%s%s\n", target_system_root
, target_sysroot_suffix
);
8606 printf ("%s\n", target_system_root
);
8611 if (print_multi_os_directory
)
8613 if (multilib_os_dir
== NULL
)
8616 printf ("%s\n", multilib_os_dir
);
8620 if (print_sysroot_headers_suffix
)
8622 if (*sysroot_hdrs_suffix_spec
)
8624 printf("%s\n", (target_sysroot_hdrs_suffix
8625 ? target_sysroot_hdrs_suffix
8630 /* The error status indicates that only one set of fixed
8631 headers should be built. */
8632 fatal_error (input_location
,
8633 "not configured with sysroot headers suffix");
8636 if (print_help_list
)
8642 printf (_("\nFor bug reporting instructions, please see:\n"));
8643 printf ("%s.\n", bug_report_url
);
8648 /* We do not exit here. Instead we have created a fake input file
8649 called 'help-dummy' which needs to be compiled, and we pass this
8650 on the various sub-processes, along with the --help switch.
8651 Ensure their output appears after ours. */
8652 fputc ('\n', stdout
);
8658 printf (_("%s %s%s\n"), progname
, pkgversion_string
,
8660 printf ("Copyright %s 2021 Free Software Foundation, Inc.\n",
8662 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
8663 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
8668 /* We do not exit here. We use the same mechanism of --help to print
8669 the version of the sub-processes. */
8670 fputc ('\n', stdout
);
8676 print_configuration (stderr
);
8684 /* Figure out what to do with each input file.
8685 Return true if we need to exit early from "main", false otherwise. */
8688 driver::prepare_infiles ()
8691 int lang_n_infiles
= 0;
8693 if (n_infiles
== added_libraries
)
8694 fatal_error (input_location
, "no input files");
8697 /* Early exit needed from main. */
8700 /* Make a place to record the compiler output file names
8701 that correspond to the input files. */
8704 i
+= lang_specific_extra_outfiles
;
8705 outfiles
= XCNEWVEC (const char *, i
);
8707 /* Record which files were specified explicitly as link input. */
8709 explicit_link_files
= XCNEWVEC (char, n_infiles
);
8711 combine_inputs
= have_o
|| flag_wpa
;
8713 for (i
= 0; (int) i
< n_infiles
; i
++)
8715 const char *name
= infiles
[i
].name
;
8716 struct compiler
*compiler
= lookup_compiler (name
,
8718 infiles
[i
].language
);
8720 if (compiler
&& !(compiler
->combinable
))
8721 combine_inputs
= false;
8723 if (lang_n_infiles
> 0 && compiler
!= input_file_compiler
8724 && infiles
[i
].language
&& infiles
[i
].language
[0] != '*')
8725 infiles
[i
].incompiler
= compiler
;
8729 input_file_compiler
= compiler
;
8730 infiles
[i
].incompiler
= compiler
;
8734 /* Since there is no compiler for this input file, assume it is a
8736 explicit_link_files
[i
] = 1;
8737 infiles
[i
].incompiler
= NULL
;
8739 infiles
[i
].compiled
= false;
8740 infiles
[i
].preprocessed
= false;
8743 if (!combine_inputs
&& have_c
&& have_o
&& lang_n_infiles
> 1)
8744 fatal_error (input_location
,
8745 "cannot specify %<-o%> with %<-c%>, %<-S%> or %<-E%> "
8746 "with multiple files");
8748 /* No early exit needed from main; we can continue. */
8752 /* Run the spec machinery on each input file. */
8755 driver::do_spec_on_infiles () const
8759 for (i
= 0; (int) i
< n_infiles
; i
++)
8761 int this_file_error
= 0;
8763 /* Tell do_spec what to substitute for %i. */
8765 input_file_number
= i
;
8766 set_input (infiles
[i
].name
);
8768 if (infiles
[i
].compiled
)
8771 /* Use the same thing in %o, unless cp->spec says otherwise. */
8773 outfiles
[i
] = gcc_input_filename
;
8775 /* Figure out which compiler from the file's suffix. */
8778 = lookup_compiler (infiles
[i
].name
, input_filename_length
,
8779 infiles
[i
].language
);
8781 if (input_file_compiler
)
8783 /* Ok, we found an applicable compiler. Run its spec. */
8785 if (input_file_compiler
->spec
[0] == '#')
8787 error ("%s: %s compiler not installed on this system",
8788 gcc_input_filename
, &input_file_compiler
->spec
[1]);
8789 this_file_error
= 1;
8797 free (debug_check_temp_file
[0]);
8798 debug_check_temp_file
[0] = NULL
;
8800 free (debug_check_temp_file
[1]);
8801 debug_check_temp_file
[1] = NULL
;
8804 value
= do_spec (input_file_compiler
->spec
);
8805 infiles
[i
].compiled
= true;
8807 this_file_error
= 1;
8808 else if (compare_debug
&& debug_check_temp_file
[0])
8811 inform (UNKNOWN_LOCATION
,
8812 "recompiling with %<-fcompare-debug%>");
8814 compare_debug
= -compare_debug
;
8815 n_switches
= n_switches_debug_check
[1];
8816 n_switches_alloc
= n_switches_alloc_debug_check
[1];
8817 switches
= switches_debug_check
[1];
8819 value
= do_spec (input_file_compiler
->spec
);
8821 compare_debug
= -compare_debug
;
8822 n_switches
= n_switches_debug_check
[0];
8823 n_switches_alloc
= n_switches_alloc_debug_check
[0];
8824 switches
= switches_debug_check
[0];
8828 error ("during %<-fcompare-debug%> recompilation");
8829 this_file_error
= 1;
8832 gcc_assert (debug_check_temp_file
[1]
8833 && filename_cmp (debug_check_temp_file
[0],
8834 debug_check_temp_file
[1]));
8837 inform (UNKNOWN_LOCATION
, "comparing final insns dumps");
8839 if (compare_files (debug_check_temp_file
))
8840 this_file_error
= 1;
8845 free (debug_check_temp_file
[0]);
8846 debug_check_temp_file
[0] = NULL
;
8848 free (debug_check_temp_file
[1]);
8849 debug_check_temp_file
[1] = NULL
;
8854 /* If this file's name does not contain a recognized suffix,
8855 record it as explicit linker input. */
8858 explicit_link_files
[i
] = 1;
8860 /* Clear the delete-on-failure queue, deleting the files in it
8861 if this compilation failed. */
8863 if (this_file_error
)
8865 delete_failure_queue ();
8868 /* If this compilation succeeded, don't delete those files later. */
8869 clear_failure_queue ();
8872 /* Reset the input file name to the first compile/object file name, for use
8873 with %b in LINK_SPEC. We use the first input file that we can find
8874 a compiler to compile it instead of using infiles.language since for
8875 languages other than C we use aliases that we then lookup later. */
8880 for (i
= 0; i
< n_infiles
; i
++)
8881 if (infiles
[i
].incompiler
8882 || (infiles
[i
].language
&& infiles
[i
].language
[0] != '*'))
8884 set_input (infiles
[i
].name
);
8891 /* Make sure INPUT_FILE_NUMBER points to first available open
8893 input_file_number
= n_infiles
;
8894 if (lang_specific_pre_link ())
8899 /* If we have to run the linker, do it now. */
8902 driver::maybe_run_linker (const char *argv0
) const
8905 int linker_was_run
= 0;
8906 int num_linker_inputs
;
8908 /* Determine if there are any linker input files. */
8909 num_linker_inputs
= 0;
8910 for (i
= 0; (int) i
< n_infiles
; i
++)
8911 if (explicit_link_files
[i
] || outfiles
[i
] != NULL
)
8912 num_linker_inputs
++;
8914 /* Arrange for temporary file names created during linking to take
8915 on names related with the linker output rather than with the
8916 inputs when appropriate. */
8917 if (outbase
&& *outbase
)
8921 char *tofree
= dumpdir
;
8922 gcc_checking_assert (strlen (dumpdir
) == dumpdir_length
);
8923 dumpdir
= concat (dumpdir
, outbase
, ".", NULL
);
8927 dumpdir
= concat (outbase
, ".", NULL
);
8928 dumpdir_length
+= strlen (outbase
) + 1;
8929 dumpdir_trailing_dash_added
= true;
8931 else if (dumpdir_trailing_dash_added
)
8933 gcc_assert (dumpdir
[dumpdir_length
- 1] == '-');
8934 dumpdir
[dumpdir_length
- 1] = '.';
8937 if (dumpdir_trailing_dash_added
)
8939 gcc_assert (dumpdir_length
> 0);
8940 gcc_assert (dumpdir
[dumpdir_length
- 1] == '.');
8945 input_basename
= outbase
= NULL
;
8946 outbase_length
= suffixed_basename_length
= basename_length
= 0;
8948 /* Run ld to link all the compiler output files. */
8950 if (num_linker_inputs
> 0 && !seen_error () && print_subprocess_help
< 2)
8952 int tmp
= execution_count
;
8954 detect_jobserver ();
8958 #if HAVE_LTO_PLUGIN > 0
8959 #if HAVE_LTO_PLUGIN == 2
8960 const char *fno_use_linker_plugin
= "fno-use-linker-plugin";
8962 const char *fuse_linker_plugin
= "fuse-linker-plugin";
8966 /* We'll use ld if we can't find collect2. */
8967 if (! strcmp (linker_name_spec
, "collect2"))
8969 char *s
= find_a_file (&exec_prefixes
, "collect2", X_OK
, false);
8971 set_static_spec_shared (&linker_name_spec
, "ld");
8974 #if HAVE_LTO_PLUGIN > 0
8975 #if HAVE_LTO_PLUGIN == 2
8976 if (!switch_matches (fno_use_linker_plugin
,
8977 fno_use_linker_plugin
8978 + strlen (fno_use_linker_plugin
), 0))
8980 if (switch_matches (fuse_linker_plugin
,
8982 + strlen (fuse_linker_plugin
), 0))
8985 char *temp_spec
= find_a_file (&exec_prefixes
,
8986 LTOPLUGINSONAME
, R_OK
,
8989 fatal_error (input_location
,
8990 "%<-fuse-linker-plugin%>, but %s not found",
8992 linker_plugin_file_spec
= convert_white_space (temp_spec
);
8995 set_static_spec_shared (<o_gcc_spec
, argv0
);
8998 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
9000 putenv_from_prefixes (&exec_prefixes
, "COMPILER_PATH", false);
9001 putenv_from_prefixes (&startfile_prefixes
, LIBRARY_PATH_ENV
, true);
9003 if (print_subprocess_help
== 1)
9005 printf (_("\nLinker options\n==============\n\n"));
9006 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
9007 " to the linker.\n\n"));
9010 int value
= do_spec (link_command_spec
);
9013 linker_was_run
= (tmp
!= execution_count
);
9016 /* If options said don't run linker,
9017 complain about input files to be given to the linker. */
9019 if (! linker_was_run
&& !seen_error ())
9020 for (i
= 0; (int) i
< n_infiles
; i
++)
9021 if (explicit_link_files
[i
]
9022 && !(infiles
[i
].language
&& infiles
[i
].language
[0] == '*'))
9024 warning (0, "%s: linker input file unused because linking not done",
9026 if (access (outfiles
[i
], F_OK
) < 0)
9027 /* This is can be an indication the user specifed an errorneous
9028 separated option value, (or used the wrong prefix for an
9030 error ("%s: linker input file not found: %m", outfiles
[i
]);
9034 /* The end of "main". */
9037 driver::final_actions () const
9039 /* Delete some or all of the temporary files we made. */
9042 delete_failure_queue ();
9043 delete_temp_files ();
9045 if (print_help_list
)
9047 printf (("\nFor bug reporting instructions, please see:\n"));
9048 printf ("%s\n", bug_report_url
);
9052 /* Detect whether jobserver is active and working. If not drop
9053 --jobserver-auth from MAKEFLAGS. */
9056 driver::detect_jobserver () const
9058 /* Detect jobserver and drop it if it's not working. */
9059 const char *makeflags
= env
.get ("MAKEFLAGS");
9060 if (makeflags
!= NULL
)
9062 const char *needle
= "--jobserver-auth=";
9063 const char *n
= strstr (makeflags
, needle
);
9070 = (sscanf (n
+ strlen (needle
), "%d,%d", &rfd
, &wfd
) == 2
9073 && is_valid_fd (rfd
)
9074 && is_valid_fd (wfd
));
9076 /* Drop the jobserver if it's not working now. */
9079 unsigned offset
= n
- makeflags
;
9080 char *dup
= xstrdup (makeflags
);
9083 const char *space
= strchr (makeflags
+ offset
, ' ');
9085 strcpy (dup
+ offset
, space
);
9086 xputenv (concat ("MAKEFLAGS=", dup
, NULL
));
9092 /* Determine what the exit code of the driver should be. */
9095 driver::get_exit_code () const
9097 return (signal_count
!= 0 ? 2
9098 : seen_error () ? (pass_exit_codes
? greatest_status
: 1)
9102 /* Find the proper compilation spec for the file name NAME,
9103 whose length is LENGTH. LANGUAGE is the specified language,
9104 or 0 if this file is to be passed to the linker. */
9106 static struct compiler
*
9107 lookup_compiler (const char *name
, size_t length
, const char *language
)
9109 struct compiler
*cp
;
9111 /* If this was specified by the user to be a linker input, indicate that. */
9112 if (language
!= 0 && language
[0] == '*')
9115 /* Otherwise, look for the language, if one is spec'd. */
9118 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
9119 if (cp
->suffix
[0] == '@' && !strcmp (cp
->suffix
+ 1, language
))
9121 if (name
!= NULL
&& strcmp (name
, "-") == 0
9122 && (strcmp (cp
->suffix
, "@c-header") == 0
9123 || strcmp (cp
->suffix
, "@c++-header") == 0)
9125 fatal_error (input_location
,
9126 "cannot use %<-%> as input filename for a "
9127 "precompiled header");
9132 error ("language %s not recognized", language
);
9136 /* Look for a suffix. */
9137 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
9139 if (/* The suffix `-' matches only the file name `-'. */
9140 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
9141 || (strlen (cp
->suffix
) < length
9142 /* See if the suffix matches the end of NAME. */
9143 && !strcmp (cp
->suffix
,
9144 name
+ length
- strlen (cp
->suffix
))
9149 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
9150 /* Look again, but case-insensitively this time. */
9152 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
9154 if (/* The suffix `-' matches only the file name `-'. */
9155 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
9156 || (strlen (cp
->suffix
) < length
9157 /* See if the suffix matches the end of NAME. */
9158 && ((!strcmp (cp
->suffix
,
9159 name
+ length
- strlen (cp
->suffix
))
9160 || !strpbrk (cp
->suffix
, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
9161 && !strcasecmp (cp
->suffix
,
9162 name
+ length
- strlen (cp
->suffix
)))
9168 if (cp
>= compilers
)
9170 if (cp
->spec
[0] != '@')
9171 /* A non-alias entry: return it. */
9174 /* An alias entry maps a suffix to a language.
9175 Search for the language; pass 0 for NAME and LENGTH
9176 to avoid infinite recursion if language not found. */
9177 return lookup_compiler (NULL
, 0, cp
->spec
+ 1);
9183 save_string (const char *s
, int len
)
9185 char *result
= XNEWVEC (char, len
+ 1);
9187 gcc_checking_assert (strlen (s
) >= (unsigned int) len
);
9188 memcpy (result
, s
, len
);
9195 validate_switches_from_spec (const char *spec
, bool user
)
9197 const char *p
= spec
;
9203 || (*p
== 'W' && *++p
== '{')
9204 || (*p
== '@' && *++p
== '{')))
9205 /* We have a switch spec. */
9206 p
= validate_switches (p
+ 1, user
, *p
== '{');
9210 validate_all_switches (void)
9212 struct compiler
*comp
;
9213 struct spec_list
*spec
;
9215 for (comp
= compilers
; comp
->spec
; comp
++)
9216 validate_switches_from_spec (comp
->spec
, false);
9218 /* Look through the linked list of specs read from the specs file. */
9219 for (spec
= specs
; spec
; spec
= spec
->next
)
9220 validate_switches_from_spec (*spec
->ptr_spec
, spec
->user_p
);
9222 validate_switches_from_spec (link_command_spec
, false);
9225 /* Look at the switch-name that comes after START and mark as valid
9226 all supplied switches that match it. If BRACED, handle other
9227 switches after '|' and '&', and specs after ':' until ';' or '}',
9228 going back for more switches after ';'. Without BRACED, handle
9229 only one atom. Return a pointer to whatever follows the handled
9230 items, after the closing brace if BRACED. */
9233 validate_switches (const char *start
, bool user_spec
, bool braced
)
9235 const char *p
= start
;
9239 bool suffix
= false;
9240 bool starred
= false;
9242 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
9251 if (*p
== '.' || *p
== ',')
9255 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
9256 || *p
== ',' || *p
== '.' || *p
== '@')
9261 starred
= true, p
++;
9267 /* Mark all matching switches as valid. */
9268 for (i
= 0; i
< n_switches
; i
++)
9269 if (!strncmp (switches
[i
].part1
, atom
, len
)
9270 && (starred
|| switches
[i
].part1
[len
] == '\0')
9271 && (switches
[i
].known
|| user_spec
))
9272 switches
[i
].validated
= true;
9279 if (*p
&& (p
[-1] == '|' || p
[-1] == '&'))
9282 if (*p
&& p
[-1] == ':')
9284 while (*p
&& *p
!= ';' && *p
!= '}')
9289 if (*p
== '{' || *p
== '<')
9290 p
= validate_switches (p
+1, user_spec
, *p
== '{');
9291 else if (p
[0] == 'W' && p
[1] == '{')
9292 p
= validate_switches (p
+2, user_spec
, true);
9293 else if (p
[0] == '@' && p
[1] == '{')
9294 p
= validate_switches (p
+2, user_spec
, true);
9301 if (*p
&& p
[-1] == ';')
9315 static struct mdswitchstr
*mdswitches
;
9316 static int n_mdswitches
;
9318 /* Check whether a particular argument was used. The first time we
9319 canonicalize the switches to keep only the ones we care about. */
9324 int operator () (const char *p
, int len
);
9331 const char *replace
;
9336 mswitchstr
*mswitches
;
9341 used_arg_t used_arg
;
9344 used_arg_t::operator () (const char *p
, int len
)
9350 struct mswitchstr
*matches
;
9354 /* Break multilib_matches into the component strings of string
9355 and replacement string. */
9356 for (q
= multilib_matches
; *q
!= '\0'; q
++)
9361 = (struct mswitchstr
*) alloca ((sizeof (struct mswitchstr
)) * cnt
);
9363 q
= multilib_matches
;
9372 fatal_error (input_location
, "multilib spec %qs is invalid",
9377 matches
[i
].len
= q
- matches
[i
].str
;
9379 matches
[i
].replace
= ++q
;
9380 while (*q
!= ';' && *q
!= '\0')
9383 goto invalid_matches
;
9386 matches
[i
].rep_len
= q
- matches
[i
].replace
;
9392 /* Now build a list of the replacement string for switches that we care
9393 about. Make sure we allocate at least one entry. This prevents
9394 xmalloc from calling fatal, and prevents us from re-executing this
9397 = XNEWVEC (struct mswitchstr
, n_mdswitches
+ (n_switches
? n_switches
: 1));
9398 for (i
= 0; i
< n_switches
; i
++)
9399 if ((switches
[i
].live_cond
& SWITCH_IGNORE
) == 0)
9401 int xlen
= strlen (switches
[i
].part1
);
9402 for (j
= 0; j
< cnt
; j
++)
9403 if (xlen
== matches
[j
].len
9404 && ! strncmp (switches
[i
].part1
, matches
[j
].str
, xlen
))
9406 mswitches
[n_mswitches
].str
= matches
[j
].replace
;
9407 mswitches
[n_mswitches
].len
= matches
[j
].rep_len
;
9408 mswitches
[n_mswitches
].replace
= (char *) 0;
9409 mswitches
[n_mswitches
].rep_len
= 0;
9415 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
9416 on the command line nor any options mutually incompatible with
9418 for (i
= 0; i
< n_mdswitches
; i
++)
9422 for (q
= multilib_options
; *q
!= '\0'; *q
&& q
++)
9428 while (strncmp (q
, mdswitches
[i
].str
, mdswitches
[i
].len
) != 0
9429 || strchr (" /", q
[mdswitches
[i
].len
]) == NULL
)
9431 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
9438 if (*q
!= ' ' && *q
!= '\0')
9440 while (*r
!= ' ' && *r
!= '\0')
9443 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
9446 if (used_arg (r
, q
- r
))
9451 mswitches
[n_mswitches
].str
= mdswitches
[i
].str
;
9452 mswitches
[n_mswitches
].len
= mdswitches
[i
].len
;
9453 mswitches
[n_mswitches
].replace
= (char *) 0;
9454 mswitches
[n_mswitches
].rep_len
= 0;
9467 for (i
= 0; i
< n_mswitches
; i
++)
9468 if (len
== mswitches
[i
].len
&& ! strncmp (p
, mswitches
[i
].str
, len
))
9474 void used_arg_t::finalize ()
9476 XDELETEVEC (mswitches
);
9483 default_arg (const char *p
, int len
)
9487 for (i
= 0; i
< n_mdswitches
; i
++)
9488 if (len
== mdswitches
[i
].len
&& ! strncmp (p
, mdswitches
[i
].str
, len
))
9494 /* Work out the subdirectory to use based on the options. The format of
9495 multilib_select is a list of elements. Each element is a subdirectory
9496 name followed by a list of options followed by a semicolon. The format
9497 of multilib_exclusions is the same, but without the preceding
9498 directory. First gcc will check the exclusions, if none of the options
9499 beginning with an exclamation point are present, and all of the other
9500 options are present, then we will ignore this completely. Passing
9501 that, gcc will consider each multilib_select in turn using the same
9502 rules for matching the options. If a match is found, that subdirectory
9504 A subdirectory name is optionally followed by a colon and the corresponding
9508 set_multilib_dir (void)
9511 unsigned int this_path_len
;
9512 const char *this_path
, *this_arg
;
9513 const char *start
, *end
;
9515 int ok
, ndfltok
, first
;
9518 start
= multilib_defaults
;
9519 while (*start
== ' ' || *start
== '\t')
9521 while (*start
!= '\0')
9524 while (*start
!= ' ' && *start
!= '\t' && *start
!= '\0')
9526 while (*start
== ' ' || *start
== '\t')
9534 mdswitches
= XNEWVEC (struct mdswitchstr
, n_mdswitches
);
9535 for (start
= multilib_defaults
; *start
!= '\0'; start
= end
+ 1)
9537 while (*start
== ' ' || *start
== '\t')
9543 for (end
= start
+ 1;
9544 *end
!= ' ' && *end
!= '\t' && *end
!= '\0'; end
++)
9547 obstack_grow (&multilib_obstack
, start
, end
- start
);
9548 obstack_1grow (&multilib_obstack
, 0);
9549 mdswitches
[i
].str
= XOBFINISH (&multilib_obstack
, const char *);
9550 mdswitches
[i
++].len
= end
- start
;
9557 p
= multilib_exclusions
;
9560 /* Ignore newlines. */
9567 /* Check the arguments. */
9574 fatal_error (input_location
, "multilib exclusions %qs is invalid",
9575 multilib_exclusions
);
9585 while (*p
!= ' ' && *p
!= ';')
9588 goto invalid_exclusions
;
9592 if (*this_arg
!= '!')
9600 ok
= used_arg (this_arg
, p
- this_arg
);
9615 p
= multilib_select
;
9617 /* Append multilib reuse rules if any. With those rules, we can reuse
9618 one multilib for certain different options sets. */
9619 if (strlen (multilib_reuse
) > 0)
9620 p
= concat (p
, multilib_reuse
, NULL
);
9624 /* Ignore newlines. */
9631 /* Get the initial path. */
9638 fatal_error (input_location
, "multilib select %qs %qs is invalid",
9639 multilib_select
, multilib_reuse
);
9643 this_path_len
= p
- this_path
;
9645 /* Check the arguments. */
9652 goto invalid_select
;
9661 while (*p
!= ' ' && *p
!= ';')
9664 goto invalid_select
;
9668 if (*this_arg
!= '!')
9676 /* If this is a default argument, we can just ignore it.
9677 This is true even if this_arg begins with '!'. Beginning
9678 with '!' does not mean that this argument is necessarily
9679 inappropriate for this library: it merely means that
9680 there is a more specific library which uses this
9681 argument. If this argument is a default, we need not
9682 consider that more specific library. */
9683 ok
= used_arg (this_arg
, p
- this_arg
);
9690 if (default_arg (this_arg
, p
- this_arg
))
9699 if (this_path_len
!= 1
9700 || this_path
[0] != '.')
9702 char *new_multilib_dir
= XNEWVEC (char, this_path_len
+ 1);
9705 strncpy (new_multilib_dir
, this_path
, this_path_len
);
9706 new_multilib_dir
[this_path_len
] = '\0';
9707 q
= strchr (new_multilib_dir
, ':');
9710 multilib_dir
= new_multilib_dir
;
9717 const char *q
= this_path
, *end
= this_path
+ this_path_len
;
9719 while (q
< end
&& *q
!= ':')
9723 const char *q2
= q
+ 1, *ml_end
= end
;
9724 char *new_multilib_os_dir
;
9726 while (q2
< end
&& *q2
!= ':')
9730 if (ml_end
- q
== 1)
9731 multilib_os_dir
= xstrdup (".");
9734 new_multilib_os_dir
= XNEWVEC (char, ml_end
- q
);
9735 memcpy (new_multilib_os_dir
, q
+ 1, ml_end
- q
- 1);
9736 new_multilib_os_dir
[ml_end
- q
- 1] = '\0';
9737 multilib_os_dir
= new_multilib_os_dir
;
9740 if (q2
< end
&& *q2
== ':')
9742 char *new_multiarch_dir
= XNEWVEC (char, end
- q2
);
9743 memcpy (new_multiarch_dir
, q2
+ 1, end
- q2
- 1);
9744 new_multiarch_dir
[end
- q2
- 1] = '\0';
9745 multiarch_dir
= new_multiarch_dir
;
9754 if (multilib_dir
== NULL
&& multilib_os_dir
!= NULL
9755 && strcmp (multilib_os_dir
, ".") == 0)
9757 free (CONST_CAST (char *, multilib_os_dir
));
9758 multilib_os_dir
= NULL
;
9760 else if (multilib_dir
!= NULL
&& multilib_os_dir
== NULL
)
9761 multilib_os_dir
= multilib_dir
;
9764 /* Print out the multiple library subdirectory selection
9765 information. This prints out a series of lines. Each line looks
9766 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
9767 required. Only the desired options are printed out, the negative
9768 matches. The options are print without a leading dash. There are
9769 no spaces to make it easy to use the information in the shell.
9770 Each subdirectory is printed only once. This assumes the ordering
9771 generated by the genmultilib script. Also, we leave out ones that match
9775 print_multilib_info (void)
9777 const char *p
= multilib_select
;
9778 const char *last_path
= 0, *this_path
;
9781 unsigned int last_path_len
= 0;
9786 /* Ignore newlines. */
9793 /* Get the initial path. */
9800 fatal_error (input_location
,
9801 "multilib select %qs is invalid", multilib_select
);
9807 /* When --disable-multilib was used but target defines
9808 MULTILIB_OSDIRNAMES, entries starting with .: (and not starting
9809 with .:: for multiarch configurations) are there just to find
9810 multilib_os_dir, so skip them from output. */
9811 if (this_path
[0] == '.' && this_path
[1] == ':' && this_path
[2] != ':')
9814 /* Check for matches with the multilib_exclusions. We don't bother
9815 with the '!' in either list. If any of the exclusion rules match
9816 all of its options with the select rule, we skip it. */
9818 const char *e
= multilib_exclusions
;
9819 const char *this_arg
;
9824 /* Ignore newlines. */
9831 /* Check the arguments. */
9840 fatal_error (input_location
,
9841 "multilib exclusion %qs is invalid",
9842 multilib_exclusions
);
9853 while (*e
!= ' ' && *e
!= ';')
9856 goto invalid_exclusion
;
9864 int len
= e
- this_arg
;
9867 goto invalid_select
;
9871 while (*q
!= ' ' && *q
!= ';')
9874 goto invalid_select
;
9878 if (! strncmp (arg
, this_arg
,
9879 (len
< q
- arg
) ? q
- arg
: len
)
9880 || default_arg (this_arg
, e
- this_arg
))
9910 /* If this is a duplicate, skip it. */
9911 skip
= (last_path
!= 0
9912 && (unsigned int) (p
- this_path
) == last_path_len
9913 && ! filename_ncmp (last_path
, this_path
, last_path_len
));
9915 last_path
= this_path
;
9916 last_path_len
= p
- this_path
;
9919 /* If all required arguments are default arguments, and no default
9920 arguments appear in the ! argument list, then we can skip it.
9921 We will already have printed a directory identical to this one
9922 which does not require that default argument. */
9926 bool default_arg_ok
= false;
9934 goto invalid_select
;
9945 while (*q
!= ' ' && *q
!= ';')
9948 goto invalid_select
;
9952 if (default_arg (arg
, q
- arg
))
9954 /* Stop checking if any default arguments appeared in not
9958 default_arg_ok
= false;
9962 default_arg_ok
= true;
9966 /* Stop checking if any required argument is not provided by
9967 default arguments. */
9968 default_arg_ok
= false;
9976 /* Make sure all default argument is OK for this multi-lib set. */
9987 for (p1
= last_path
; p1
< p
&& *p1
!= ':'; p1
++)
9998 goto invalid_select
;
10006 use_arg
= *p
!= '!';
10011 while (*p
!= ' ' && *p
!= ';')
10014 goto invalid_select
;
10026 /* If there are extra options, print them now. */
10027 if (multilib_extra
&& *multilib_extra
)
10029 int print_at
= TRUE
;
10032 for (q
= multilib_extra
; *q
!= '\0'; q
++)
10053 /* getenv built-in spec function.
10055 Returns the value of the environment variable given by its first argument,
10056 concatenated with the second argument. If the variable is not defined, a
10057 fatal error is issued unless such undefs are internally allowed, in which
10058 case the variable name prefixed by a '/' is used as the variable value.
10060 The leading '/' allows using the result at a spot where a full path would
10061 normally be expected and when the actual value doesn't really matter since
10062 undef vars are allowed. */
10064 static const char *
10065 getenv_spec_function (int argc
, const char **argv
)
10068 const char *varname
;
10078 value
= env
.get (varname
);
10080 /* If the variable isn't defined and this is allowed, craft our expected
10081 return value. Assume variable names used in specs strings don't contain
10082 any active spec character so don't need escaping. */
10083 if (!value
&& spec_undefvar_allowed
)
10085 result
= XNEWVAR (char, strlen(varname
) + 2);
10086 sprintf (result
, "/%s", varname
);
10091 fatal_error (input_location
,
10092 "environment variable %qs not defined", varname
);
10094 /* We have to escape every character of the environment variable so
10095 they are not interpreted as active spec characters. A
10096 particularly painful case is when we are reading a variable
10097 holding a windows path complete with \ separators. */
10098 len
= strlen (value
) * 2 + strlen (argv
[1]) + 1;
10099 result
= XNEWVAR (char, len
);
10100 for (ptr
= result
; *value
; ptr
+= 2)
10106 strcpy (ptr
, argv
[1]);
10111 /* if-exists built-in spec function.
10113 Checks to see if the file specified by the absolute pathname in
10114 ARGS exists. Returns that pathname if found.
10116 The usual use for this function is to check for a library file
10117 (whose name has been expanded with %s). */
10119 static const char *
10120 if_exists_spec_function (int argc
, const char **argv
)
10122 /* Must have only one argument. */
10123 if (argc
== 1 && IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
10129 /* if-exists-else built-in spec function.
10131 This is like if-exists, but takes an additional argument which
10132 is returned if the first argument does not exist. */
10134 static const char *
10135 if_exists_else_spec_function (int argc
, const char **argv
)
10137 /* Must have exactly two arguments. */
10141 if (IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
10147 /* if-exists-then-else built-in spec function.
10149 Checks to see if the file specified by the absolute pathname in
10150 the first arg exists. Returns the second arg if so, otherwise returns
10151 the third arg if it is present. */
10153 static const char *
10154 if_exists_then_else_spec_function (int argc
, const char **argv
)
10157 /* Must have two or three arguments. */
10158 if (argc
!= 2 && argc
!= 3)
10161 if (IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
10170 /* sanitize built-in spec function.
10172 This returns non-NULL, if sanitizing address, thread or
10173 any of the undefined behavior sanitizers. */
10175 static const char *
10176 sanitize_spec_function (int argc
, const char **argv
)
10181 if (strcmp (argv
[0], "address") == 0)
10182 return (flag_sanitize
& SANITIZE_USER_ADDRESS
) ? "" : NULL
;
10183 if (strcmp (argv
[0], "hwaddress") == 0)
10184 return (flag_sanitize
& SANITIZE_USER_HWADDRESS
) ? "" : NULL
;
10185 if (strcmp (argv
[0], "kernel-address") == 0)
10186 return (flag_sanitize
& SANITIZE_KERNEL_ADDRESS
) ? "" : NULL
;
10187 if (strcmp (argv
[0], "kernel-hwaddress") == 0)
10188 return (flag_sanitize
& SANITIZE_KERNEL_HWADDRESS
) ? "" : NULL
;
10189 if (strcmp (argv
[0], "thread") == 0)
10190 return (flag_sanitize
& SANITIZE_THREAD
) ? "" : NULL
;
10191 if (strcmp (argv
[0], "undefined") == 0)
10192 return ((flag_sanitize
10193 & (SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
))
10194 && !flag_sanitize_undefined_trap_on_error
) ? "" : NULL
;
10195 if (strcmp (argv
[0], "leak") == 0)
10196 return ((flag_sanitize
10197 & (SANITIZE_ADDRESS
| SANITIZE_LEAK
| SANITIZE_THREAD
))
10198 == SANITIZE_LEAK
) ? "" : NULL
;
10202 /* replace-outfile built-in spec function.
10204 This looks for the first argument in the outfiles array's name and
10205 replaces it with the second argument. */
10207 static const char *
10208 replace_outfile_spec_function (int argc
, const char **argv
)
10211 /* Must have exactly two arguments. */
10215 for (i
= 0; i
< n_infiles
; i
++)
10217 if (outfiles
[i
] && !filename_cmp (outfiles
[i
], argv
[0]))
10218 outfiles
[i
] = xstrdup (argv
[1]);
10223 /* remove-outfile built-in spec function.
10225 * This looks for the first argument in the outfiles array's name and
10228 static const char *
10229 remove_outfile_spec_function (int argc
, const char **argv
)
10232 /* Must have exactly one argument. */
10236 for (i
= 0; i
< n_infiles
; i
++)
10238 if (outfiles
[i
] && !filename_cmp (outfiles
[i
], argv
[0]))
10239 outfiles
[i
] = NULL
;
10244 /* Given two version numbers, compares the two numbers.
10245 A version number must match the regular expression
10246 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
10249 compare_version_strings (const char *v1
, const char *v2
)
10254 if (regcomp (&r
, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
10255 REG_EXTENDED
| REG_NOSUB
) != 0)
10257 rresult
= regexec (&r
, v1
, 0, NULL
, 0);
10258 if (rresult
== REG_NOMATCH
)
10259 fatal_error (input_location
, "invalid version number %qs", v1
);
10260 else if (rresult
!= 0)
10262 rresult
= regexec (&r
, v2
, 0, NULL
, 0);
10263 if (rresult
== REG_NOMATCH
)
10264 fatal_error (input_location
, "invalid version number %qs", v2
);
10265 else if (rresult
!= 0)
10268 return strverscmp (v1
, v2
);
10272 /* version_compare built-in spec function.
10274 This takes an argument of the following form:
10276 <comparison-op> <arg1> [<arg2>] <switch> <result>
10278 and produces "result" if the comparison evaluates to true,
10279 and nothing if it doesn't.
10281 The supported <comparison-op> values are:
10283 >= true if switch is a later (or same) version than arg1
10285 < true if switch is an earlier version than arg1
10287 >< true if switch is arg1 or later, and earlier than arg2
10288 <> true if switch is earlier than arg1 or is arg2 or later
10290 If the switch is not present, the condition is false unless
10291 the first character of the <comparison-op> is '!'.
10294 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
10295 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
10297 static const char *
10298 version_compare_spec_function (int argc
, const char **argv
)
10302 const char *switch_value
= NULL
;
10307 fatal_error (input_location
, "too few arguments to %%:version-compare");
10308 if (argv
[0][0] == '\0')
10310 if ((argv
[0][1] == '<' || argv
[0][1] == '>') && argv
[0][0] != '!')
10312 if (argc
!= nargs
+ 3)
10313 fatal_error (input_location
, "too many arguments to %%:version-compare");
10315 switch_len
= strlen (argv
[nargs
+ 1]);
10316 for (i
= 0; i
< n_switches
; i
++)
10317 if (!strncmp (switches
[i
].part1
, argv
[nargs
+ 1], switch_len
)
10318 && check_live_switch (i
, switch_len
))
10319 switch_value
= switches
[i
].part1
+ switch_len
;
10321 if (switch_value
== NULL
)
10322 comp1
= comp2
= -1;
10325 comp1
= compare_version_strings (switch_value
, argv
[1]);
10327 comp2
= compare_version_strings (switch_value
, argv
[2]);
10329 comp2
= -1; /* This value unused. */
10332 switch (argv
[0][0] << 8 | argv
[0][1])
10334 case '>' << 8 | '=':
10335 result
= comp1
>= 0;
10337 case '!' << 8 | '<':
10338 result
= comp1
>= 0 || switch_value
== NULL
;
10341 result
= comp1
< 0;
10343 case '!' << 8 | '>':
10344 result
= comp1
< 0 || switch_value
== NULL
;
10346 case '>' << 8 | '<':
10347 result
= comp1
>= 0 && comp2
< 0;
10349 case '<' << 8 | '>':
10350 result
= comp1
< 0 || comp2
>= 0;
10354 fatal_error (input_location
,
10355 "unknown operator %qs in %%:version-compare", argv
[0]);
10360 return argv
[nargs
+ 2];
10363 /* %:include builtin spec function. This differs from %include in that it
10364 can be nested inside a spec, and thus be conditionalized. It takes
10365 one argument, the filename, and looks for it in the startfile path.
10366 The result is always NULL, i.e. an empty expansion. */
10368 static const char *
10369 include_spec_function (int argc
, const char **argv
)
10376 file
= find_a_file (&startfile_prefixes
, argv
[0], R_OK
, true);
10377 read_specs (file
? file
: argv
[0], false, false);
10382 /* %:find-file spec function. This function replaces its argument by
10383 the file found through find_file, that is the -print-file-name gcc
10385 static const char *
10386 find_file_spec_function (int argc
, const char **argv
)
10393 file
= find_file (argv
[0]);
10398 /* %:find-plugindir spec function. This function replaces its argument
10399 by the -iplugindir=<dir> option. `dir' is found through find_file, that
10400 is the -print-file-name gcc program option. */
10401 static const char *
10402 find_plugindir_spec_function (int argc
, const char **argv ATTRIBUTE_UNUSED
)
10404 const char *option
;
10409 option
= concat ("-iplugindir=", find_file ("plugin"), NULL
);
10414 /* %:print-asm-header spec function. Print a banner to say that the
10415 following output is from the assembler. */
10417 static const char *
10418 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED
,
10419 const char **argv ATTRIBUTE_UNUSED
)
10421 printf (_("Assembler options\n=================\n\n"));
10422 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
10427 /* Get a random number for -frandom-seed */
10429 static unsigned HOST_WIDE_INT
10430 get_random_number (void)
10432 unsigned HOST_WIDE_INT ret
= 0;
10435 fd
= open ("/dev/urandom", O_RDONLY
);
10438 read (fd
, &ret
, sizeof (HOST_WIDE_INT
));
10444 /* Get some more or less random data. */
10445 #ifdef HAVE_GETTIMEOFDAY
10449 gettimeofday (&tv
, NULL
);
10450 ret
= tv
.tv_sec
* 1000 + tv
.tv_usec
/ 1000;
10454 time_t now
= time (NULL
);
10456 if (now
!= (time_t)-1)
10457 ret
= (unsigned) now
;
10461 return ret
^ getpid ();
10464 /* %:compare-debug-dump-opt spec function. Save the last argument,
10465 expected to be the last -fdump-final-insns option, or generate a
10468 static const char *
10469 compare_debug_dump_opt_spec_function (int arg
,
10470 const char **argv ATTRIBUTE_UNUSED
)
10475 static char random_seed
[HOST_BITS_PER_WIDE_INT
/ 4 + 3];
10478 fatal_error (input_location
,
10479 "too many arguments to %%:compare-debug-dump-opt");
10481 do_spec_2 ("%{fdump-final-insns=*:%*}", NULL
);
10482 do_spec_1 (" ", 0, NULL
);
10484 if (argbuf
.length () > 0
10485 && strcmp (argv
[argbuf
.length () - 1], ".") != 0)
10487 if (!compare_debug
)
10490 name
= xstrdup (argv
[argbuf
.length () - 1]);
10495 if (argbuf
.length () > 0)
10496 do_spec_2 ("%B.gkd", NULL
);
10497 else if (!compare_debug
)
10500 do_spec_2 ("%{!save-temps*:%g.gkd}%{save-temps*:%B.gkd}", NULL
);
10502 do_spec_1 (" ", 0, NULL
);
10504 gcc_assert (argbuf
.length () > 0);
10506 name
= xstrdup (argbuf
.last ());
10508 char *arg
= quote_spec (xstrdup (name
));
10509 ret
= concat ("-fdump-final-insns=", arg
, NULL
);
10513 which
= compare_debug
< 0;
10514 debug_check_temp_file
[which
] = name
;
10518 unsigned HOST_WIDE_INT value
= get_random_number ();
10520 sprintf (random_seed
, HOST_WIDE_INT_PRINT_HEX
, value
);
10526 ret
= concat ("%{!frandom-seed=*:-frandom-seed=", random_seed
, "} ",
10537 /* %:compare-debug-self-opt spec function. Expands to the options
10538 that are to be passed in the second compilation of
10541 static const char *
10542 compare_debug_self_opt_spec_function (int arg
,
10543 const char **argv ATTRIBUTE_UNUSED
)
10546 fatal_error (input_location
,
10547 "too many arguments to %%:compare-debug-self-opt");
10549 if (compare_debug
>= 0)
10553 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
10554 %<fdump-final-insns=* -w -S -o %j \
10555 %{!fcompare-debug-second:-fcompare-debug-second} \
10556 ", compare_debug_opt
, NULL
);
10559 /* %:pass-through-libs spec function. Finds all -l options and input
10560 file names in the lib spec passed to it, and makes a list of them
10561 prepended with the plugin option to cause them to be passed through
10562 to the final link after all the new object files have been added. */
10565 pass_through_libs_spec_func (int argc
, const char **argv
)
10567 char *prepended
= xstrdup (" ");
10569 /* Shlemiel the painter's algorithm. Innately horrible, but at least
10570 we know that there will never be more than a handful of strings to
10571 concat, and it's only once per run, so it's not worth optimising. */
10572 for (n
= 0; n
< argc
; n
++)
10574 char *old
= prepended
;
10575 /* Anything that isn't an option is a full path to an output
10576 file; pass it through if it ends in '.a'. Among options,
10578 if (argv
[n
][0] == '-' && argv
[n
][1] == 'l')
10580 const char *lopt
= argv
[n
] + 2;
10581 /* Handle both joined and non-joined -l options. If for any
10582 reason there's a trailing -l with no joined or following
10583 arg just discard it. */
10584 if (!*lopt
&& ++n
>= argc
)
10588 prepended
= concat (prepended
, "-plugin-opt=-pass-through=-l",
10591 else if (!strcmp (".a", argv
[n
] + strlen (argv
[n
]) - 2))
10593 prepended
= concat (prepended
, "-plugin-opt=-pass-through=",
10594 argv
[n
], " ", NULL
);
10596 if (prepended
!= old
)
10603 not_actual_file_p (const char *name
)
10605 return (strcmp (name
, "-") == 0
10606 || strcmp (name
, HOST_BIT_BUCKET
) == 0);
10609 /* %:dumps spec function. Take an optional argument that overrides
10610 the default extension for -dumpbase and -dumpbase-ext.
10611 Return -dumpdir, -dumpbase and -dumpbase-ext, if needed. */
10613 dumps_spec_func (int argc
, const char **argv ATTRIBUTE_UNUSED
)
10615 const char *ext
= dumpbase_ext
;
10618 char *args
[3] = { NULL
, NULL
, NULL
};
10621 /* Do not compute a default for -dumpbase-ext when -dumpbase was
10622 given explicitly. */
10623 if (dumpbase
&& *dumpbase
&& !ext
)
10628 /* Do not override the explicitly-specified -dumpbase-ext with
10629 the specs-provided overrider. */
10633 else if (argc
!= 0)
10634 fatal_error (input_location
, "too many arguments for %%:dumps");
10638 p
= quote_spec_arg (xstrdup (dumpdir
));
10639 args
[nargs
++] = concat (" -dumpdir ", p
, NULL
);
10644 ext
= input_basename
+ basename_length
;
10646 /* Use the precomputed outbase, or compute dumpbase from
10647 input_basename, just like %b would. */
10650 if (dumpbase
&& *dumpbase
)
10652 base
= xstrdup (dumpbase
);
10653 p
= base
+ outbase_length
;
10654 gcc_checking_assert (strncmp (base
, outbase
, outbase_length
) == 0);
10655 gcc_checking_assert (strcmp (p
, ext
) == 0);
10657 else if (outbase_length
)
10659 base
= xstrndup (outbase
, outbase_length
);
10664 base
= xstrndup (input_basename
, suffixed_basename_length
);
10665 p
= base
+ basename_length
;
10668 if (compare_debug
< 0 || !p
|| strcmp (p
, ext
) != 0)
10674 if (compare_debug
< 0)
10679 p
= concat (base
, gk
, ext
, NULL
);
10685 base
= quote_spec_arg (base
);
10686 args
[nargs
++] = concat (" -dumpbase ", base
, NULL
);
10691 p
= quote_spec_arg (xstrdup (ext
));
10692 args
[nargs
++] = concat (" -dumpbase-ext ", p
, NULL
);
10696 const char *ret
= concat (args
[0], args
[1], args
[2], NULL
);
10698 free (args
[--nargs
]);
10703 /* Returns "" if ARGV[ARGC - 2] is greater than ARGV[ARGC-1].
10704 Otherwise, return NULL. */
10706 static const char *
10707 greater_than_spec_func (int argc
, const char **argv
)
10714 gcc_assert (argc
>= 2);
10716 long arg
= strtol (argv
[argc
- 2], &converted
, 10);
10717 gcc_assert (converted
!= argv
[argc
- 2]);
10719 long lim
= strtol (argv
[argc
- 1], &converted
, 10);
10720 gcc_assert (converted
!= argv
[argc
- 1]);
10728 /* Returns "" if debug_info_level is greater than ARGV[ARGC-1].
10729 Otherwise, return NULL. */
10731 static const char *
10732 debug_level_greater_than_spec_func (int argc
, const char **argv
)
10737 fatal_error (input_location
,
10738 "wrong number of arguments to %%:debug-level-gt");
10740 long arg
= strtol (argv
[0], &converted
, 10);
10741 gcc_assert (converted
!= argv
[0]);
10743 if (debug_info_level
> arg
)
10749 /* Returns "" if dwarf_version is greater than ARGV[ARGC-1].
10750 Otherwise, return NULL. */
10752 static const char *
10753 dwarf_version_greater_than_spec_func (int argc
, const char **argv
)
10758 fatal_error (input_location
,
10759 "wrong number of arguments to %%:dwarf-version-gt");
10761 long arg
= strtol (argv
[0], &converted
, 10);
10762 gcc_assert (converted
!= argv
[0]);
10764 if (dwarf_version
> arg
)
10771 path_prefix_reset (path_prefix
*prefix
)
10773 struct prefix_list
*iter
, *next
;
10774 iter
= prefix
->plist
;
10778 free (const_cast <char *> (iter
->prefix
));
10783 prefix
->max_len
= 0;
10786 /* The function takes 3 arguments: OPTION name, file name and location
10787 where we search for Fortran modules.
10788 When the FILE is found by find_file, return OPTION=path_to_file. */
10790 static const char *
10791 find_fortran_preinclude_file (int argc
, const char **argv
)
10793 char *result
= NULL
;
10797 struct path_prefix prefixes
= { 0, 0, "preinclude" };
10799 /* Search first for 'finclude' folder location for a header file
10800 installed by the compiler (similar to omp_lib.h). */
10801 add_prefix (&prefixes
, argv
[2], NULL
, 0, 0, 0);
10802 #ifdef TOOL_INCLUDE_DIR
10803 /* Then search: <prefix>/<target>/<include>/finclude */
10804 add_prefix (&prefixes
, TOOL_INCLUDE_DIR
"/finclude/",
10807 #ifdef NATIVE_SYSTEM_HEADER_DIR
10808 /* Then search: <sysroot>/usr/include/finclude/<multilib> */
10809 add_sysrooted_hdrs_prefix (&prefixes
, NATIVE_SYSTEM_HEADER_DIR
"/finclude/",
10813 const char *path
= find_a_file (&include_prefixes
, argv
[1], R_OK
, false);
10815 result
= concat (argv
[0], path
, NULL
);
10818 path
= find_a_file (&prefixes
, argv
[1], R_OK
, false);
10820 result
= concat (argv
[0], path
, NULL
);
10823 path_prefix_reset (&prefixes
);
10827 /* If any character in ORIG fits QUOTE_P (_, P), reallocate the string
10828 so as to precede every one of them with a backslash. Return the
10829 original string or the reallocated one. */
10831 static inline char *
10832 quote_string (char *orig
, bool (*quote_p
)(char, void *), void *p
)
10834 int len
, number_of_space
= 0;
10836 for (len
= 0; orig
[len
]; len
++)
10837 if (quote_p (orig
[len
], p
))
10840 if (number_of_space
)
10842 char *new_spec
= (char *) xmalloc (len
+ number_of_space
+ 1);
10844 for (j
= 0, k
= 0; j
<= len
; j
++, k
++)
10846 if (quote_p (orig
[j
], p
))
10847 new_spec
[k
++] = '\\';
10848 new_spec
[k
] = orig
[j
];
10857 /* Return true iff C is any of the characters convert_white_space
10861 whitespace_to_convert_p (char c
, void *)
10863 return (c
== ' ' || c
== '\t');
10866 /* Insert backslash before spaces in ORIG (usually a file path), to
10867 avoid being broken by spec parser.
10869 This function is needed as do_spec_1 treats white space (' ' and '\t')
10870 as the end of an argument. But in case of -plugin /usr/gcc install/xxx.so,
10871 the file name should be treated as a single argument rather than being
10872 broken into multiple. Solution is to insert '\\' before the space in a
10875 This function converts and only converts all occurrence of ' '
10876 to '\\' + ' ' and '\t' to '\\' + '\t'. For example:
10878 "a b" -> "a\\ \\ b"
10880 "a\\ b" -> "a\\\\ b"
10882 orig: input null-terminating string that was allocated by xalloc. The
10883 memory it points to might be freed in this function. Behavior undefined
10884 if ORIG wasn't xalloced or was freed already at entry.
10886 Return: ORIG if no conversion needed. Otherwise a newly allocated string
10887 that was converted from ORIG. */
10890 convert_white_space (char *orig
)
10892 return quote_string (orig
, whitespace_to_convert_p
, NULL
);
10895 /* Return true iff C matches any of the spec active characters. */
10897 quote_spec_char_p (char c
, void *)
10914 /* Like convert_white_space, but deactivate all active spec chars by
10917 static inline char *
10918 quote_spec (char *orig
)
10920 return quote_string (orig
, quote_spec_char_p
, NULL
);
10923 /* Like quote_spec, but also turn an empty string into the spec for an
10926 static inline char *
10927 quote_spec_arg (char *orig
)
10932 return xstrdup ("%\"");
10935 return quote_spec (orig
);
10938 /* Restore all state within gcc.c to the initial state, so that the driver
10939 code can be safely re-run in-process.
10941 Many const char * variables are referenced by static specs (see
10942 INIT_STATIC_SPEC above). These variables are restored to their default
10943 values by a simple loop over the static specs.
10945 For other variables, we directly restore them all to their initial
10946 values (often implicitly 0).
10948 Free the various obstacks in this file, along with "opts_obstack"
10951 This function also restores any environment variables that were changed. */
10954 driver::finalize ()
10957 diagnostic_finish (global_dc
);
10960 at_file_supplied
= 0;
10961 print_help_list
= 0;
10963 verbose_only_flag
= 0;
10964 print_subprocess_help
= 0;
10966 report_times_to_file
= NULL
;
10967 target_system_root
= DEFAULT_TARGET_SYSTEM_ROOT
;
10968 target_system_root_changed
= 0;
10969 target_sysroot_suffix
= 0;
10970 target_sysroot_hdrs_suffix
= 0;
10971 save_temps_flag
= SAVE_TEMPS_NONE
;
10972 save_temps_overrides_dumpdir
= false;
10973 dumpdir_trailing_dash_added
= false;
10976 free (dumpbase_ext
);
10978 dumpdir
= dumpbase
= dumpbase_ext
= outbase
= NULL
;
10979 dumpdir_length
= outbase_length
= 0;
10980 spec_machine
= DEFAULT_TARGET_MACHINE
;
10981 greatest_status
= 1;
10983 obstack_free (&obstack
, NULL
);
10984 obstack_free (&opts_obstack
, NULL
); /* in opts.c */
10985 obstack_free (&collect_obstack
, NULL
);
10987 link_command_spec
= LINK_COMMAND_SPEC
;
10989 obstack_free (&multilib_obstack
, NULL
);
10991 user_specs_head
= NULL
;
10992 user_specs_tail
= NULL
;
10994 /* Within the "compilers" vec, the fields "suffix" and "spec" were
10995 statically allocated for the default compilers, but dynamically
10996 allocated for additional compilers. Delete them for the latter. */
10997 for (int i
= n_default_compilers
; i
< n_compilers
; i
++)
10999 free (const_cast <char *> (compilers
[i
].suffix
));
11000 free (const_cast <char *> (compilers
[i
].spec
));
11002 XDELETEVEC (compilers
);
11006 linker_options
.truncate (0);
11007 assembler_options
.truncate (0);
11008 preprocessor_options
.truncate (0);
11010 path_prefix_reset (&exec_prefixes
);
11011 path_prefix_reset (&startfile_prefixes
);
11012 path_prefix_reset (&include_prefixes
);
11014 machine_suffix
= 0;
11015 just_machine_suffix
= 0;
11016 gcc_exec_prefix
= 0;
11017 gcc_libexec_prefix
= 0;
11018 set_static_spec_shared (&md_exec_prefix
, MD_EXEC_PREFIX
);
11019 set_static_spec_shared (&md_startfile_prefix
, MD_STARTFILE_PREFIX
);
11020 set_static_spec_shared (&md_startfile_prefix_1
, MD_STARTFILE_PREFIX_1
);
11022 multilib_os_dir
= 0;
11025 /* Free any specs dynamically-allocated by set_spec.
11026 These will be at the head of the list, before the
11027 statically-allocated ones. */
11030 while (specs
!= static_specs
)
11032 spec_list
*next
= specs
->next
;
11033 free (const_cast <char *> (specs
->name
));
11039 for (unsigned i
= 0; i
< ARRAY_SIZE (static_specs
); i
++)
11041 spec_list
*sl
= &static_specs
[i
];
11044 free (const_cast <char *> (*(sl
->ptr_spec
)));
11045 sl
->alloc_p
= false;
11047 *(sl
->ptr_spec
) = sl
->default_ptr
;
11050 extra_specs
= NULL
;
11053 processing_spec_function
= 0;
11061 execution_count
= 0;
11064 temp_filename
= NULL
;
11065 temp_filename_length
= 0;
11066 always_delete_queue
= NULL
;
11067 failure_delete_queue
= NULL
;
11069 XDELETEVEC (switches
);
11072 n_switches_alloc
= 0;
11075 compare_debug_second
= 0;
11076 compare_debug_opt
= NULL
;
11077 for (int i
= 0; i
< 2; i
++)
11079 switches_debug_check
[i
] = NULL
;
11080 n_switches_debug_check
[i
] = 0;
11081 n_switches_alloc_debug_check
[i
] = 0;
11082 debug_check_temp_file
[i
] = NULL
;
11085 XDELETEVEC (infiles
);
11088 n_infiles_alloc
= 0;
11090 combine_inputs
= false;
11091 added_libraries
= 0;
11092 XDELETEVEC (outfiles
);
11095 last_language_n_infiles
= 0;
11096 gcc_input_filename
= NULL
;
11097 input_file_number
= 0;
11098 input_filename_length
= 0;
11099 basename_length
= 0;
11100 suffixed_basename_length
= 0;
11101 input_basename
= NULL
;
11102 input_suffix
= NULL
;
11103 /* We don't need to purge "input_stat", just to unset "input_stat_set". */
11104 input_stat_set
= 0;
11105 input_file_compiler
= NULL
;
11107 delete_this_arg
= 0;
11108 this_is_output_file
= 0;
11109 this_is_library_file
= 0;
11110 this_is_linker_script
= 0;
11111 input_from_pipe
= 0;
11112 suffix_subst
= NULL
;
11117 used_arg
.finalize ();
11121 Targets can provide configure-time default options in
11122 OPTION_DEFAULT_SPECS. The jit needs to access these, but
11123 they are expressed in the spec language.
11125 Run just enough of the driver to be able to expand these
11126 specs, and then call the callback CB on each
11127 such option. The options strings are *without* a leading
11128 '-' character e.g. ("march=x86-64"). Finally, clean up. */
11131 driver_get_configure_time_options (void (*cb
) (const char *option
,
11137 obstack_init (&obstack
);
11138 init_opts_obstack ();
11141 for (i
= 0; i
< ARRAY_SIZE (option_default_specs
); i
++)
11142 do_option_spec (option_default_specs
[i
].name
,
11143 option_default_specs
[i
].spec
);
11145 for (i
= 0; (int) i
< n_switches
; i
++)
11147 gcc_assert (switches
[i
].part1
);
11148 (*cb
) (switches
[i
].part1
, user_data
);
11151 obstack_free (&opts_obstack
, NULL
);
11152 obstack_free (&obstack
, NULL
);