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
;
4814 const char *p
= strrchr (arg
, '@');
4818 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4819 arg
= convert_filename (arg
, 0, access (arg
, F_OK
));
4821 /* For LTO static archive support we handle input file
4822 specifications that are composed of a filename and
4823 an offset like FNAME@OFFSET. */
4826 && sscanf (p
, "@%li%n", &offset
, &consumed
) >= 1
4827 && strlen (p
) == (unsigned int)consumed
)
4829 fname
= (char *)xmalloc (p
- arg
+ 1);
4830 memcpy (fname
, arg
, p
- arg
);
4831 fname
[p
- arg
] = '\0';
4832 /* Only accept non-stdin and existing FNAME parts, otherwise
4833 try with the full name. */
4834 if (strcmp (fname
, "-") == 0 || access (fname
, F_OK
) < 0)
4837 fname
= xstrdup (arg
);
4841 fname
= xstrdup (arg
);
4843 if (strcmp (fname
, "-") != 0 && access (fname
, F_OK
) < 0)
4845 bool resp
= fname
[0] == '@' && access (fname
+ 1, F_OK
) < 0;
4846 error ("%s: %m", fname
+ resp
);
4849 add_infile (arg
, spec_lang
);
4855 read_cmdline_option (&global_options
, &global_options_set
,
4856 decoded_options
+ j
, UNKNOWN_LOCATION
,
4857 CL_DRIVER
, &handlers
, global_dc
);
4860 /* If the user didn't specify any, default to all configured offload
4862 if (ENABLE_OFFLOADING
&& offload_targets
== NULL
)
4863 handle_foffload_option (OFFLOAD_TARGETS
);
4866 && strcmp (output_file
, "-") != 0
4867 && strcmp (output_file
, HOST_BIT_BUCKET
) != 0)
4870 for (i
= 0; i
< n_infiles
; i
++)
4871 if ((!infiles
[i
].language
|| infiles
[i
].language
[0] != '*')
4872 && canonical_filename_eq (infiles
[i
].name
, output_file
))
4873 fatal_error (input_location
,
4874 "input file %qs is the same as output file",
4878 if (output_file
!= NULL
&& output_file
[0] == '\0')
4879 fatal_error (input_location
, "output filename may not be empty");
4881 /* -dumpdir and -save-temps=* both specify the location of aux/dump
4882 outputs; the one that appears last prevails. When compiling
4883 multiple sources, an explicit dumpbase (minus -ext) may be
4884 combined with an explicit or implicit dumpdir, whereas when
4885 linking, a specified or implied link output name (minus
4886 extension) may be combined with a prevailing -save-temps=* or an
4887 otherwise implied dumpdir, but not override a prevailing
4888 -dumpdir. Primary outputs (e.g., linker output when linking
4889 without -o, or .i, .s or .o outputs when processing multiple
4890 inputs with -E, -S or -c, respectively) are NOT affected by these
4891 -save-temps=/-dump* options, always landing in the current
4892 directory and with the same basename as the input when an output
4893 name is not given, but when they're intermediate outputs, they
4894 are named like other aux outputs, so the options affect their
4897 Here are some examples. There are several more in the
4898 documentation of -o and -dump*, and some quite exhaustive tests
4899 in gcc.misc-tests/outputs.exp.
4901 When compiling any number of sources, no -dump* nor
4902 -save-temps=*, all outputs in cwd without prefix:
4904 # gcc -c b.c -gsplit-dwarf
4905 -> cc1 [-dumpdir ./] -dumpbase b.c -dumpbase-ext .c # b.o b.dwo
4907 # gcc -c b.c d.c -gsplit-dwarf
4908 -> cc1 [-dumpdir ./] -dumpbase b.c -dumpbase-ext .c # b.o b.dwo
4909 && cc1 [-dumpdir ./] -dumpbase d.c -dumpbase-ext .c # d.o d.dwo
4911 When compiling and linking, no -dump* nor -save-temps=*, .o
4912 outputs are temporary, aux outputs land in the dir of the output,
4913 prefixed with the basename of the linker output:
4915 # gcc b.c d.c -o ab -gsplit-dwarf
4916 -> cc1 -dumpdir ab- -dumpbase b.c -dumpbase-ext .c # ab-b.dwo
4917 && cc1 -dumpdir ab- -dumpbase d.c -dumpbase-ext .c # ab-d.dwo
4920 # gcc b.c d.c [-o a.out] -gsplit-dwarf
4921 -> cc1 -dumpdir a- -dumpbase b.c -dumpbase-ext .c # a-b.dwo
4922 && cc1 -dumpdir a- -dumpbase d.c -dumpbase-ext .c # a-d.dwo
4923 && link ... [-o a.out]
4925 When compiling and linking, a prevailing -dumpdir fully overrides
4926 the prefix of aux outputs given by the output name:
4928 # gcc -dumpdir f b.c d.c -gsplit-dwarf [-o [dir/]whatever]
4929 -> cc1 -dumpdir f -dumpbase b.c -dumpbase-ext .c # fb.dwo
4930 && cc1 -dumpdir f -dumpbase d.c -dumpbase-ext .c # fd.dwo
4931 && link ... [-o whatever]
4933 When compiling multiple inputs, an explicit -dumpbase is combined
4934 with -dumpdir, affecting aux outputs, but not the .o outputs:
4936 # gcc -dumpdir f -dumpbase g- b.c d.c -gsplit-dwarf -c
4937 -> cc1 -dumpdir fg- -dumpbase b.c -dumpbase-ext .c # b.o fg-b.dwo
4938 && cc1 -dumpdir fg- -dumpbase d.c -dumpbase-ext .c # d.o fg-d.dwo
4940 When compiling and linking with -save-temps, the .o outputs that
4941 would have been temporary become aux outputs, so they get
4942 affected by -dump* flags:
4944 # gcc -dumpdir f -dumpbase g- -save-temps b.c d.c
4945 -> cc1 -dumpdir fg- -dumpbase b.c -dumpbase-ext .c # fg-b.o
4946 && cc1 -dumpdir fg- -dumpbase d.c -dumpbase-ext .c # fg-d.o
4949 If -save-temps=* prevails over -dumpdir, however, the explicit
4950 -dumpdir is discarded, as if it wasn't there. The basename of
4951 the implicit linker output, a.out or a.exe, becomes a- as the aux
4952 output prefix for all compilations:
4954 # gcc [-dumpdir f] -save-temps=cwd b.c d.c
4955 -> cc1 -dumpdir a- -dumpbase b.c -dumpbase-ext .c # a-b.o
4956 && cc1 -dumpdir a- -dumpbase d.c -dumpbase-ext .c # a-d.o
4959 A single -dumpbase, applying to multiple inputs, overrides the
4960 linker output name, implied or explicit, as the aux output prefix:
4962 # gcc [-dumpdir f] -dumpbase g- -save-temps=cwd b.c d.c
4963 -> cc1 -dumpdir g- -dumpbase b.c -dumpbase-ext .c # g-b.o
4964 && cc1 -dumpdir g- -dumpbase d.c -dumpbase-ext .c # g-d.o
4967 # gcc [-dumpdir f] -dumpbase g- -save-temps=cwd b.c d.c -o dir/h.out
4968 -> cc1 -dumpdir g- -dumpbase b.c -dumpbase-ext .c # g-b.o
4969 && cc1 -dumpdir g- -dumpbase d.c -dumpbase-ext .c # g-d.o
4970 && link -o dir/h.out
4972 Now, if the linker output is NOT overridden as a prefix, but
4973 -save-temps=* overrides implicit or explicit -dumpdir, the
4974 effective dump dir combines the dir selected by the -save-temps=*
4975 option with the basename of the specified or implied link output:
4977 # gcc [-dumpdir f] -save-temps=cwd b.c d.c -o dir/h.out
4978 -> cc1 -dumpdir h- -dumpbase b.c -dumpbase-ext .c # h-b.o
4979 && cc1 -dumpdir h- -dumpbase d.c -dumpbase-ext .c # h-d.o
4980 && link -o dir/h.out
4982 # gcc [-dumpdir f] -save-temps=obj b.c d.c -o dir/h.out
4983 -> cc1 -dumpdir dir/h- -dumpbase b.c -dumpbase-ext .c # dir/h-b.o
4984 && cc1 -dumpdir dir/h- -dumpbase d.c -dumpbase-ext .c # dir/h-d.o
4985 && link -o dir/h.out
4987 But then again, a single -dumpbase applying to multiple inputs
4988 gets used instead of the linker output basename in the combined
4991 # gcc [-dumpdir f] -dumpbase g- -save-temps=obj b.c d.c -o dir/h.out
4992 -> cc1 -dumpdir dir/g- -dumpbase b.c -dumpbase-ext .c # dir/g-b.o
4993 && cc1 -dumpdir dir/g- -dumpbase d.c -dumpbase-ext .c # dir/g-d.o
4994 && link -o dir/h.out
4996 With a single input being compiled, the output basename does NOT
4997 affect the dumpdir prefix.
4999 # gcc -save-temps=obj b.c -gsplit-dwarf -c -o dir/b.o
5000 -> cc1 -dumpdir dir/ -dumpbase b.c -dumpbase-ext .c # dir/b.o dir/b.dwo
5002 but when compiling and linking even a single file, it does:
5004 # gcc -save-temps=obj b.c -o dir/h.out
5005 -> cc1 -dumpdir dir/h- -dumpbase b.c -dumpbase-ext .c # dir/h-b.o
5007 unless an explicit -dumpdir prevails:
5009 # gcc -save-temps[=obj] -dumpdir g- b.c -o dir/h.out
5010 -> cc1 -dumpdir g- -dumpbase b.c -dumpbase-ext .c # g-b.o
5014 bool explicit_dumpdir
= dumpdir
;
5016 if (!save_temps_overrides_dumpdir
&& explicit_dumpdir
)
5021 /* If -save-temps=obj and -o name, create the prefix to use for %b.
5022 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
5023 else if (save_temps_flag
!= SAVE_TEMPS_CWD
&& output_file
!= NULL
)
5027 temp
= lbasename (output_file
);
5028 if (temp
!= output_file
)
5029 dumpdir
= xstrndup (output_file
,
5030 strlen (output_file
) - strlen (temp
));
5038 if (save_temps_flag
)
5039 save_temps_flag
= SAVE_TEMPS_DUMP
;
5041 /* If there is any pathname component in an explicit -dumpbase, it
5042 overrides dumpdir entirely, so discard it right away. Although
5043 the presence of an explicit -dumpdir matters for the driver, it
5044 shouldn't matter for other processes, that get all that's needed
5045 from the -dumpdir and -dumpbase always passed to them. */
5046 if (dumpdir
&& dumpbase
&& lbasename (dumpbase
) != dumpbase
)
5052 /* Check that dumpbase_ext matches the end of dumpbase, drop it
5054 if (dumpbase_ext
&& dumpbase
&& *dumpbase
)
5056 int lendb
= strlen (dumpbase
);
5057 int lendbx
= strlen (dumpbase_ext
);
5059 /* -dumpbase-ext must be a suffix proper; discard it if it
5060 matches all of -dumpbase, as that would make for an empty
5063 || strcmp (dumpbase
+ lendb
- lendbx
, dumpbase_ext
) != 0)
5065 free (dumpbase_ext
);
5066 dumpbase_ext
= NULL
;
5070 /* -dumpbase with multiple sources goes into dumpdir. With a single
5071 source, it does only if linking and if dumpdir was not explicitly
5073 if (dumpbase
&& *dumpbase
5074 && (single_input_file_index () == -2
5075 || (!have_c
&& !explicit_dumpdir
)))
5080 /* We checked that they match above. */
5081 dumpbase
[strlen (dumpbase
) - strlen (dumpbase_ext
)] = '\0';
5084 prefix
= concat (dumpdir
, dumpbase
, "-", NULL
);
5086 prefix
= concat (dumpbase
, "-", NULL
);
5090 free (dumpbase_ext
);
5091 dumpbase
= dumpbase_ext
= NULL
;
5093 dumpdir_trailing_dash_added
= true;
5096 /* If dumpbase was not brought into dumpdir but we're linking, bring
5097 output_file into dumpdir unless dumpdir was explicitly specified.
5098 The test for !explicit_dumpdir is further below, because we want
5099 to use the obase computation for a ghost outbase, passed to
5100 GCC_COLLECT_OPTIONS. */
5101 else if (!have_c
&& (!explicit_dumpdir
|| (dumpbase
&& !*dumpbase
)))
5103 /* If we get here, we know dumpbase was not specified, or it was
5104 specified as an empty string. If it was anything else, it
5105 would have combined with dumpdir above, because the condition
5106 for dumpbase to be used when present is broader than the
5107 condition that gets us here. */
5108 gcc_assert (!dumpbase
|| !*dumpbase
);
5111 char *tofree
= NULL
;
5112 if (!output_file
|| not_actual_file_p (output_file
))
5116 obase
= lbasename (output_file
);
5117 size_t blen
= strlen (obase
), xlen
;
5118 /* Drop the suffix if it's dumpbase_ext, if given,
5119 otherwise .exe or the target executable suffix, or if the
5120 output was explicitly named a.out, but not otherwise. */
5122 ? (blen
> (xlen
= strlen (dumpbase_ext
))
5123 && strcmp ((temp
= (obase
+ blen
- xlen
)),
5125 : ((temp
= strrchr (obase
+ 1, '.'))
5126 && (xlen
= strlen (temp
))
5127 && (strcmp (temp
, ".exe") == 0
5128 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
5129 || strcmp (temp
, TARGET_EXECUTABLE_SUFFIX
) == 0
5131 || strcmp (obase
, "a.out") == 0)))
5133 tofree
= xstrndup (obase
, blen
- xlen
);
5138 /* We wish to save this basename to the -dumpdir passed through
5139 GCC_COLLECT_OPTIONS within maybe_run_linker, for e.g. LTO,
5140 but we do NOT wish to add it to e.g. %b, so we keep
5141 outbase_length as zero. */
5142 gcc_assert (!outbase
);
5145 /* If we're building [dir1/]foo[.exe] out of a single input
5146 [dir2/]foo.c that shares the same basename, dump to
5147 [dir2/]foo.c.* rather than duplicating the basename into
5148 [dir2/]foo-foo.c.*. */
5151 || ((idxin
= single_input_file_index ()) >= 0
5152 && adds_single_suffix_p (lbasename (infiles
[idxin
].name
),
5155 if (obase
== tofree
)
5159 outbase
= xstrdup (obase
);
5162 obase
= tofree
= NULL
;
5168 char *p
= concat (dumpdir
, obase
, "-", NULL
);
5173 dumpdir
= concat (obase
, "-", NULL
);
5175 dumpdir_trailing_dash_added
= true;
5178 obase
= tofree
= NULL
;
5181 if (!explicit_dumpdir
|| dumpbase
)
5183 /* Absent -dumpbase and present -dumpbase-ext have been applied
5184 to the linker output name, so compute fresh defaults for each
5186 free (dumpbase_ext
);
5187 dumpbase_ext
= NULL
;
5191 /* Now, if we're compiling, or if we haven't used the dumpbase
5192 above, then outbase (%B) is derived from dumpbase, if given, or
5193 from the output name, given or implied. We can't precompute
5194 implied output names, but that's ok, since they're derived from
5195 input names. Just make sure we skip this if dumpbase is the
5196 empty string: we want to use input names then, so don't set
5198 if ((dumpbase
|| have_c
)
5199 && !(dumpbase
&& !*dumpbase
))
5201 gcc_assert (!outbase
);
5205 gcc_assert (single_input_file_index () != -2);
5206 /* We do not want lbasename here; dumpbase with dirnames
5207 overrides dumpdir entirely, even if dumpdir is
5210 /* We've already checked above that the suffix matches. */
5211 outbase
= xstrndup (dumpbase
,
5212 strlen (dumpbase
) - strlen (dumpbase_ext
));
5214 outbase
= xstrdup (dumpbase
);
5216 else if (output_file
&& !not_actual_file_p (output_file
))
5218 outbase
= xstrdup (lbasename (output_file
));
5219 char *p
= strrchr (outbase
+ 1, '.');
5225 outbase_length
= strlen (outbase
);
5228 /* If there is any pathname component in an explicit -dumpbase, do
5229 not use dumpdir, but retain it to pass it on to the compiler. */
5231 dumpdir_length
= strlen (dumpdir
);
5235 /* Check that dumpbase_ext, if still present, still matches the end
5236 of dumpbase, if present, and drop it otherwise. We only retained
5237 it above when dumpbase was absent to maybe use it to drop the
5238 extension from output_name before combining it with dumpdir. We
5239 won't deal with -dumpbase-ext when -dumpbase is not explicitly
5240 given, even if just to activate backward-compatible dumpbase:
5241 dropping it on the floor is correct, expected and documented
5242 behavior. Attempting to deal with a -dumpbase-ext that might
5243 match the end of some input filename, or of the combination of
5244 the output basename with the suffix of the input filename,
5245 possible with an intermediate .gk extension for -fcompare-debug,
5246 is just calling for trouble. */
5249 if (!dumpbase
|| !*dumpbase
)
5251 free (dumpbase_ext
);
5252 dumpbase_ext
= NULL
;
5255 gcc_assert (strcmp (dumpbase
+ strlen (dumpbase
)
5256 - strlen (dumpbase_ext
), dumpbase_ext
) == 0);
5259 if (save_temps_flag
&& use_pipes
)
5261 /* -save-temps overrides -pipe, so that temp files are produced */
5262 if (save_temps_flag
)
5263 warning (0, "%<-pipe%> ignored because %<-save-temps%> specified");
5269 const char *gcd
= env
.get ("GCC_COMPARE_DEBUG");
5271 if (gcd
&& gcd
[0] == '-')
5274 compare_debug_opt
= gcd
;
5276 else if (gcd
&& *gcd
&& strcmp (gcd
, "0"))
5279 compare_debug_opt
= "-gtoggle";
5282 else if (compare_debug
< 0)
5285 gcc_assert (!compare_debug_opt
);
5288 /* Set up the search paths. We add directories that we expect to
5289 contain GNU Toolchain components before directories specified by
5290 the machine description so that we will find GNU components (like
5291 the GNU assembler) before those of the host system. */
5293 /* If we don't know where the toolchain has been installed, use the
5294 configured-in locations. */
5295 if (!gcc_exec_prefix
)
5298 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "GCC",
5299 PREFIX_PRIORITY_LAST
, 1, 0);
5300 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "BINUTILS",
5301 PREFIX_PRIORITY_LAST
, 2, 0);
5302 add_prefix (&exec_prefixes
, standard_exec_prefix
, "BINUTILS",
5303 PREFIX_PRIORITY_LAST
, 2, 0);
5305 add_prefix (&startfile_prefixes
, standard_exec_prefix
, "BINUTILS",
5306 PREFIX_PRIORITY_LAST
, 1, 0);
5309 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix
));
5310 tooldir_prefix2
= concat (tooldir_base_prefix
, spec_machine
,
5311 dir_separator_str
, NULL
);
5313 /* Look for tools relative to the location from which the driver is
5314 running, or, if that is not available, the configured prefix. */
5316 = concat (gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
5317 spec_host_machine
, dir_separator_str
, spec_version
,
5318 accel_dir_suffix
, dir_separator_str
, tooldir_prefix2
, NULL
);
5319 free (tooldir_prefix2
);
5321 add_prefix (&exec_prefixes
,
5322 concat (tooldir_prefix
, "bin", dir_separator_str
, NULL
),
5323 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 0);
5324 add_prefix (&startfile_prefixes
,
5325 concat (tooldir_prefix
, "lib", dir_separator_str
, NULL
),
5326 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 1);
5327 free (tooldir_prefix
);
5329 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
5330 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
5331 then consider it to relocate with the rest of the GCC installation
5332 if GCC_EXEC_PREFIX is set.
5333 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
5334 if (target_system_root
&& !target_system_root_changed
&& gcc_exec_prefix
)
5336 char *tmp_prefix
= get_relative_prefix (decoded_options
[0].arg
,
5337 standard_bindir_prefix
,
5338 target_system_root
);
5339 if (tmp_prefix
&& access_check (tmp_prefix
, F_OK
) == 0)
5341 target_system_root
= tmp_prefix
;
5342 target_system_root_changed
= 1;
5347 /* More prefixes are enabled in main, after we read the specs file
5348 and determine whether this is cross-compilation or not. */
5350 if (n_infiles
!= 0 && n_infiles
== last_language_n_infiles
&& spec_lang
!= 0)
5351 warning (0, "%<-x %s%> after last input file has no effect", spec_lang
);
5353 /* Synthesize -fcompare-debug flag from the GCC_COMPARE_DEBUG
5354 environment variable. */
5355 if (compare_debug
== 2 || compare_debug
== 3)
5357 const char *opt
= concat ("-fcompare-debug=", compare_debug_opt
, NULL
);
5358 save_switch (opt
, 0, NULL
, false, true);
5362 /* Ensure we only invoke each subprocess once. */
5364 && (print_subprocess_help
|| print_help_list
|| print_version
))
5366 /* Create a dummy input file, so that we can pass
5367 the help option on to the various sub-processes. */
5368 add_infile ("help-dummy", "c");
5371 /* Decide if undefined variable references are allowed in specs. */
5373 /* -v alone is safe. --version and --help alone or together are safe. Note
5374 that -v would make them unsafe, as they'd then be run for subprocesses as
5375 well, the location of which might depend on variables possibly coming
5376 from self-specs. Note also that the command name is counted in
5377 decoded_options_count. */
5379 unsigned help_version_count
= 0;
5382 help_version_count
++;
5384 if (print_help_list
)
5385 help_version_count
++;
5387 spec_undefvar_allowed
=
5388 ((verbose_flag
&& decoded_options_count
== 2)
5389 || help_version_count
== decoded_options_count
- 1);
5392 switches
[n_switches
].part1
= 0;
5394 infiles
[n_infiles
].name
= 0;
5397 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
5398 and place that in the environment. */
5401 set_collect_gcc_options (void)
5406 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
5408 obstack_grow (&collect_obstack
, "COLLECT_GCC_OPTIONS=",
5409 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
5412 for (i
= 0; (int) i
< n_switches
; i
++)
5414 const char *const *args
;
5417 obstack_grow (&collect_obstack
, " ", 1);
5421 /* Ignore elided switches. */
5422 if ((switches
[i
].live_cond
5423 & (SWITCH_IGNORE
| SWITCH_KEEP_FOR_GCC
))
5427 obstack_grow (&collect_obstack
, "'-", 2);
5428 q
= switches
[i
].part1
;
5429 while ((p
= strchr (q
, '\'')))
5431 obstack_grow (&collect_obstack
, q
, p
- q
);
5432 obstack_grow (&collect_obstack
, "'\\''", 4);
5435 obstack_grow (&collect_obstack
, q
, strlen (q
));
5436 obstack_grow (&collect_obstack
, "'", 1);
5438 for (args
= switches
[i
].args
; args
&& *args
; args
++)
5440 obstack_grow (&collect_obstack
, " '", 2);
5442 while ((p
= strchr (q
, '\'')))
5444 obstack_grow (&collect_obstack
, q
, p
- q
);
5445 obstack_grow (&collect_obstack
, "'\\''", 4);
5448 obstack_grow (&collect_obstack
, q
, strlen (q
));
5449 obstack_grow (&collect_obstack
, "'", 1);
5456 obstack_grow (&collect_obstack
, " ", 1);
5459 obstack_grow (&collect_obstack
, "'-dumpdir' '", 12);
5463 while ((p
= strchr (q
, '\'')))
5465 obstack_grow (&collect_obstack
, q
, p
- q
);
5466 obstack_grow (&collect_obstack
, "'\\''", 4);
5469 obstack_grow (&collect_obstack
, q
, strlen (q
));
5471 obstack_grow (&collect_obstack
, "'", 1);
5474 obstack_grow (&collect_obstack
, "\0", 1);
5475 xputenv (XOBFINISH (&collect_obstack
, char *));
5478 /* Process a spec string, accumulating and running commands. */
5480 /* These variables describe the input file name.
5481 input_file_number is the index on outfiles of this file,
5482 so that the output file name can be stored for later use by %o.
5483 input_basename is the start of the part of the input file
5484 sans all directory names, and basename_length is the number
5485 of characters starting there excluding the suffix .c or whatever. */
5487 static const char *gcc_input_filename
;
5488 static int input_file_number
;
5489 size_t input_filename_length
;
5490 static int basename_length
;
5491 static int suffixed_basename_length
;
5492 static const char *input_basename
;
5493 static const char *input_suffix
;
5494 #ifndef HOST_LACKS_INODE_NUMBERS
5495 static struct stat input_stat
;
5497 static int input_stat_set
;
5499 /* The compiler used to process the current input file. */
5500 static struct compiler
*input_file_compiler
;
5502 /* These are variables used within do_spec and do_spec_1. */
5504 /* Nonzero if an arg has been started and not yet terminated
5505 (with space, tab or newline). */
5506 static int arg_going
;
5508 /* Nonzero means %d or %g has been seen; the next arg to be terminated
5509 is a temporary file name. */
5510 static int delete_this_arg
;
5512 /* Nonzero means %w has been seen; the next arg to be terminated
5513 is the output file name of this compilation. */
5514 static int this_is_output_file
;
5516 /* Nonzero means %s has been seen; the next arg to be terminated
5517 is the name of a library file and we should try the standard
5518 search dirs for it. */
5519 static int this_is_library_file
;
5521 /* Nonzero means %T has been seen; the next arg to be terminated
5522 is the name of a linker script and we should try all of the
5523 standard search dirs for it. If it is found insert a --script
5524 command line switch and then substitute the full path in place,
5525 otherwise generate an error message. */
5526 static int this_is_linker_script
;
5528 /* Nonzero means that the input of this command is coming from a pipe. */
5529 static int input_from_pipe
;
5531 /* Nonnull means substitute this for any suffix when outputting a switches
5533 static const char *suffix_subst
;
5535 /* If there is an argument being accumulated, terminate it and store it. */
5538 end_going_arg (void)
5544 obstack_1grow (&obstack
, 0);
5545 string
= XOBFINISH (&obstack
, const char *);
5546 if (this_is_library_file
)
5547 string
= find_file (string
);
5548 if (this_is_linker_script
)
5550 char * full_script_path
= find_a_file (&startfile_prefixes
, string
, R_OK
, true);
5552 if (full_script_path
== NULL
)
5554 error ("unable to locate default linker script %qs in the library search paths", string
);
5555 /* Script was not found on search path. */
5558 store_arg ("--script", false, false);
5559 string
= full_script_path
;
5561 store_arg (string
, delete_this_arg
, this_is_output_file
);
5562 if (this_is_output_file
)
5563 outfiles
[input_file_number
] = string
;
5569 /* Parse the WRAPPER string which is a comma separated list of the command line
5570 and insert them into the beginning of argbuf. */
5573 insert_wrapper (const char *wrapper
)
5577 char *buf
= xstrdup (wrapper
);
5579 unsigned int old_length
= argbuf
.length ();
5587 while ((p
= strchr (p
, ',')) != NULL
);
5589 argbuf
.safe_grow (old_length
+ n
, true);
5590 memmove (argbuf
.address () + n
,
5592 old_length
* sizeof (const_char_p
));
5606 while ((p
= strchr (p
, ',')) != NULL
);
5607 gcc_assert (i
== n
);
5610 /* Process the spec SPEC and run the commands specified therein.
5611 Returns 0 if the spec is successfully processed; -1 if failed. */
5614 do_spec (const char *spec
)
5618 value
= do_spec_2 (spec
, NULL
);
5620 /* Force out any unfinished command.
5621 If -pipe, this forces out the last command if it ended in `|'. */
5624 if (argbuf
.length () > 0
5625 && !strcmp (argbuf
.last (), "|"))
5628 set_collect_gcc_options ();
5630 if (argbuf
.length () > 0)
5637 /* Process the spec SPEC, with SOFT_MATCHED_PART designating the current value
5638 of a matched * pattern which may be re-injected by way of %*. */
5641 do_spec_2 (const char *spec
, const char *soft_matched_part
)
5647 delete_this_arg
= 0;
5648 this_is_output_file
= 0;
5649 this_is_library_file
= 0;
5650 this_is_linker_script
= 0;
5651 input_from_pipe
= 0;
5652 suffix_subst
= NULL
;
5654 result
= do_spec_1 (spec
, 0, soft_matched_part
);
5661 /* Process the given spec string and add any new options to the end
5662 of the switches/n_switches array. */
5665 do_option_spec (const char *name
, const char *spec
)
5667 unsigned int i
, value_count
, value_len
;
5668 const char *p
, *q
, *value
;
5669 char *tmp_spec
, *tmp_spec_p
;
5671 if (configure_default_options
[0].name
== NULL
)
5674 for (i
= 0; i
< ARRAY_SIZE (configure_default_options
); i
++)
5675 if (strcmp (configure_default_options
[i
].name
, name
) == 0)
5677 if (i
== ARRAY_SIZE (configure_default_options
))
5680 value
= configure_default_options
[i
].value
;
5681 value_len
= strlen (value
);
5683 /* Compute the size of the final spec. */
5686 while ((p
= strstr (p
, "%(VALUE)")) != NULL
)
5692 /* Replace each %(VALUE) by the specified value. */
5693 tmp_spec
= (char *) alloca (strlen (spec
) + 1
5694 + value_count
* (value_len
- strlen ("%(VALUE)")));
5695 tmp_spec_p
= tmp_spec
;
5697 while ((p
= strstr (q
, "%(VALUE)")) != NULL
)
5699 memcpy (tmp_spec_p
, q
, p
- q
);
5700 tmp_spec_p
= tmp_spec_p
+ (p
- q
);
5701 memcpy (tmp_spec_p
, value
, value_len
);
5702 tmp_spec_p
+= value_len
;
5703 q
= p
+ strlen ("%(VALUE)");
5705 strcpy (tmp_spec_p
, q
);
5707 do_self_spec (tmp_spec
);
5710 /* Process the given spec string and add any new options to the end
5711 of the switches/n_switches array. */
5714 do_self_spec (const char *spec
)
5718 do_spec_2 (spec
, NULL
);
5719 do_spec_1 (" ", 0, NULL
);
5721 /* Mark %<S switches processed by do_self_spec to be ignored permanently.
5722 do_self_specs adds the replacements to switches array, so it shouldn't
5723 be processed afterwards. */
5724 for (i
= 0; i
< n_switches
; i
++)
5725 if ((switches
[i
].live_cond
& SWITCH_IGNORE
))
5726 switches
[i
].live_cond
|= SWITCH_IGNORE_PERMANENTLY
;
5728 if (argbuf
.length () > 0)
5730 const char **argbuf_copy
;
5731 struct cl_decoded_option
*decoded_options
;
5732 struct cl_option_handlers handlers
;
5733 unsigned int decoded_options_count
;
5736 /* Create a copy of argbuf with a dummy argv[0] entry for
5737 decode_cmdline_options_to_array. */
5738 argbuf_copy
= XNEWVEC (const char *,
5739 argbuf
.length () + 1);
5740 argbuf_copy
[0] = "";
5741 memcpy (argbuf_copy
+ 1, argbuf
.address (),
5742 argbuf
.length () * sizeof (const char *));
5744 decode_cmdline_options_to_array (argbuf
.length () + 1,
5746 CL_DRIVER
, &decoded_options
,
5747 &decoded_options_count
);
5750 set_option_handlers (&handlers
);
5752 for (j
= 1; j
< decoded_options_count
; j
++)
5754 switch (decoded_options
[j
].opt_index
)
5756 case OPT_SPECIAL_input_file
:
5757 /* Specs should only generate options, not input
5759 if (strcmp (decoded_options
[j
].arg
, "-") != 0)
5760 fatal_error (input_location
,
5761 "switch %qs does not start with %<-%>",
5762 decoded_options
[j
].arg
);
5764 fatal_error (input_location
,
5765 "spec-generated switch is just %<-%>");
5768 case OPT_fcompare_debug_second
:
5769 case OPT_fcompare_debug
:
5770 case OPT_fcompare_debug_
:
5772 /* Avoid duplicate processing of some options from
5773 compare-debug specs; just save them here. */
5774 save_switch (decoded_options
[j
].canonical_option
[0],
5775 (decoded_options
[j
].canonical_option_num_elements
5777 &decoded_options
[j
].canonical_option
[1], false, true);
5781 read_cmdline_option (&global_options
, &global_options_set
,
5782 decoded_options
+ j
, UNKNOWN_LOCATION
,
5783 CL_DRIVER
, &handlers
, global_dc
);
5788 free (decoded_options
);
5791 switches
[n_switches
].part1
= 0;
5795 /* Callback for processing %D and %I specs. */
5797 struct spec_path_info
{
5802 bool separate_options
;
5806 spec_path (char *path
, void *data
)
5808 struct spec_path_info
*info
= (struct spec_path_info
*) data
;
5812 if (info
->omit_relative
&& !IS_ABSOLUTE_PATH (path
))
5815 if (info
->append_len
!= 0)
5817 len
= strlen (path
);
5818 memcpy (path
+ len
, info
->append
, info
->append_len
+ 1);
5821 if (!is_directory (path
, true))
5824 do_spec_1 (info
->option
, 1, NULL
);
5825 if (info
->separate_options
)
5826 do_spec_1 (" ", 0, NULL
);
5828 if (info
->append_len
== 0)
5830 len
= strlen (path
);
5831 save
= path
[len
- 1];
5832 if (IS_DIR_SEPARATOR (path
[len
- 1]))
5833 path
[len
- 1] = '\0';
5836 do_spec_1 (path
, 1, NULL
);
5837 do_spec_1 (" ", 0, NULL
);
5839 /* Must not damage the original path. */
5840 if (info
->append_len
== 0)
5841 path
[len
- 1] = save
;
5846 /* True if we should compile INFILE. */
5849 compile_input_file_p (struct infile
*infile
)
5851 if ((!infile
->language
) || (infile
->language
[0] != '*'))
5852 if (infile
->incompiler
== input_file_compiler
)
5857 /* Process each member of VEC as a spec. */
5860 do_specs_vec (vec
<char_p
> vec
)
5865 FOR_EACH_VEC_ELT (vec
, ix
, opt
)
5867 do_spec_1 (opt
, 1, NULL
);
5868 /* Make each accumulated option a separate argument. */
5869 do_spec_1 (" ", 0, NULL
);
5873 /* Add options passed via -Xassembler or -Wa to COLLECT_AS_OPTIONS. */
5876 putenv_COLLECT_AS_OPTIONS (vec
<char_p
> vec
)
5878 if (vec
.is_empty ())
5881 obstack_init (&collect_obstack
);
5882 obstack_grow (&collect_obstack
, "COLLECT_AS_OPTIONS=",
5883 strlen ("COLLECT_AS_OPTIONS="));
5888 FOR_EACH_VEC_ELT (vec
, ix
, opt
)
5890 obstack_1grow (&collect_obstack
, '\'');
5891 obstack_grow (&collect_obstack
, opt
, strlen (opt
));
5892 obstack_1grow (&collect_obstack
, '\'');
5893 if (ix
< vec
.length () - 1)
5894 obstack_1grow(&collect_obstack
, ' ');
5897 obstack_1grow (&collect_obstack
, '\0');
5898 xputenv (XOBFINISH (&collect_obstack
, char *));
5901 /* Process the sub-spec SPEC as a portion of a larger spec.
5902 This is like processing a whole spec except that we do
5903 not initialize at the beginning and we do not supply a
5904 newline by default at the end.
5905 INSWITCH nonzero means don't process %-sequences in SPEC;
5906 in this case, % is treated as an ordinary character.
5907 This is used while substituting switches.
5908 INSWITCH nonzero also causes SPC not to terminate an argument.
5910 Value is zero unless a line was finished
5911 and the command on that line reported an error. */
5914 do_spec_1 (const char *spec
, int inswitch
, const char *soft_matched_part
)
5916 const char *p
= spec
;
5921 /* If it's an empty string argument to a switch, keep it as is. */
5922 if (inswitch
&& !*p
)
5926 /* If substituting a switch, treat all chars like letters.
5927 Otherwise, NL, SPC, TAB and % are special. */
5928 switch (inswitch
? 'a' : c
)
5933 if (argbuf
.length () > 0
5934 && !strcmp (argbuf
.last (), "|"))
5936 /* A `|' before the newline means use a pipe here,
5937 but only if -pipe was specified.
5938 Otherwise, execute now and don't pass the `|' as an arg. */
5941 input_from_pipe
= 1;
5948 set_collect_gcc_options ();
5950 if (argbuf
.length () > 0)
5956 /* Reinitialize for a new command, and for a new argument. */
5959 delete_this_arg
= 0;
5960 this_is_output_file
= 0;
5961 this_is_library_file
= 0;
5962 this_is_linker_script
= 0;
5963 input_from_pipe
= 0;
5970 obstack_1grow (&obstack
, c
);
5978 /* Reinitialize for a new argument. */
5979 delete_this_arg
= 0;
5980 this_is_output_file
= 0;
5981 this_is_library_file
= 0;
5982 this_is_linker_script
= 0;
5989 fatal_error (input_location
, "spec %qs invalid", spec
);
5992 /* Don't use %b in the linker command. */
5993 gcc_assert (suffixed_basename_length
);
5994 if (!this_is_output_file
&& dumpdir_length
)
5995 obstack_grow (&obstack
, dumpdir
, dumpdir_length
);
5996 if (this_is_output_file
|| !outbase_length
)
5997 obstack_grow (&obstack
, input_basename
, basename_length
);
5999 obstack_grow (&obstack
, outbase
, outbase_length
);
6000 if (compare_debug
< 0)
6001 obstack_grow (&obstack
, ".gk", 3);
6006 /* Don't use %B in the linker command. */
6007 gcc_assert (suffixed_basename_length
);
6008 if (!this_is_output_file
&& dumpdir_length
)
6009 obstack_grow (&obstack
, dumpdir
, dumpdir_length
);
6010 if (this_is_output_file
|| !outbase_length
)
6011 obstack_grow (&obstack
, input_basename
, basename_length
);
6013 obstack_grow (&obstack
, outbase
, outbase_length
);
6014 if (compare_debug
< 0)
6015 obstack_grow (&obstack
, ".gk", 3);
6016 obstack_grow (&obstack
, input_basename
+ basename_length
,
6017 suffixed_basename_length
- basename_length
);
6023 delete_this_arg
= 2;
6026 /* Dump out the directories specified with LIBRARY_PATH,
6027 followed by the absolute directories
6028 that we search for startfiles. */
6031 struct spec_path_info info
;
6034 info
.append_len
= 0;
6035 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
6036 /* Used on systems which record the specified -L dirs
6037 and use them to search for dynamic linking.
6038 Relative directories always come from -B,
6039 and it is better not to use them for searching
6040 at run time. In particular, stage1 loses. */
6041 info
.omit_relative
= true;
6043 info
.omit_relative
= false;
6045 info
.separate_options
= false;
6047 for_each_path (&startfile_prefixes
, true, 0, spec_path
, &info
);
6052 /* %efoo means report an error with `foo' as error message
6053 and don't execute any more commands for this file. */
6057 while (*p
!= 0 && *p
!= '\n')
6059 buf
= (char *) alloca (p
- q
+ 1);
6060 strncpy (buf
, q
, p
- q
);
6062 error ("%s", _(buf
));
6067 /* %nfoo means report a notice with `foo' on stderr. */
6071 while (*p
!= 0 && *p
!= '\n')
6073 buf
= (char *) alloca (p
- q
+ 1);
6074 strncpy (buf
, q
, p
- q
);
6076 inform (UNKNOWN_LOCATION
, "%s", _(buf
));
6086 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
6087 defined, and it is not a directory, and it is
6088 writable, use it. Otherwise, treat this like any
6089 other temporary file. */
6091 if ((!save_temps_flag
)
6092 && (stat (HOST_BIT_BUCKET
, &st
) == 0) && (!S_ISDIR (st
.st_mode
))
6093 && (access (HOST_BIT_BUCKET
, W_OK
) == 0))
6095 obstack_grow (&obstack
, HOST_BIT_BUCKET
,
6096 strlen (HOST_BIT_BUCKET
));
6097 delete_this_arg
= 0;
6102 goto create_temp_file
;
6106 obstack_1grow (&obstack
, '-');
6107 delete_this_arg
= 0;
6110 /* consume suffix */
6111 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
6113 if (p
[0] == '%' && p
[1] == 'O')
6118 goto create_temp_file
;
6122 /* consume suffix */
6123 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
6125 if (p
[0] == '%' && p
[1] == 'O')
6130 goto create_temp_file
;
6136 struct temp_name
*t
;
6138 const char *suffix
= p
;
6139 char *saved_suffix
= NULL
;
6141 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
6143 suffix_length
= p
- suffix
;
6144 if (p
[0] == '%' && p
[1] == 'O')
6147 /* We don't support extra suffix characters after %O. */
6148 if (*p
== '.' || ISALNUM ((unsigned char) *p
))
6149 fatal_error (input_location
,
6150 "spec %qs has invalid %<%%0%c%>", spec
, *p
);
6151 if (suffix_length
== 0)
6152 suffix
= TARGET_OBJECT_SUFFIX
;
6156 = XNEWVEC (char, suffix_length
6157 + strlen (TARGET_OBJECT_SUFFIX
) + 1);
6158 strncpy (saved_suffix
, suffix
, suffix_length
);
6159 strcpy (saved_suffix
+ suffix_length
,
6160 TARGET_OBJECT_SUFFIX
);
6162 suffix_length
+= strlen (TARGET_OBJECT_SUFFIX
);
6165 if (compare_debug
< 0)
6167 suffix
= concat (".gk", suffix
, NULL
);
6171 /* If -save-temps was specified, use that for the
6173 if (save_temps_flag
)
6176 bool adjusted_suffix
= false;
6178 && !outbase_length
&& !basename_length
6179 && !dumpdir_trailing_dash_added
)
6181 adjusted_suffix
= true;
6185 temp_filename_length
6186 = dumpdir_length
+ suffix_length
+ 1;
6188 temp_filename_length
+= outbase_length
;
6190 temp_filename_length
+= basename_length
;
6191 tmp
= (char *) alloca (temp_filename_length
);
6193 memcpy (tmp
, dumpdir
, dumpdir_length
);
6195 memcpy (tmp
+ dumpdir_length
, outbase
,
6197 else if (basename_length
)
6198 memcpy (tmp
+ dumpdir_length
, input_basename
,
6200 memcpy (tmp
+ temp_filename_length
- suffix_length
- 1,
6201 suffix
, suffix_length
);
6202 if (adjusted_suffix
)
6204 adjusted_suffix
= false;
6208 tmp
[temp_filename_length
- 1] = '\0';
6209 temp_filename
= tmp
;
6211 if (filename_cmp (temp_filename
, gcc_input_filename
) != 0)
6213 #ifndef HOST_LACKS_INODE_NUMBERS
6214 struct stat st_temp
;
6216 /* Note, set_input() resets input_stat_set to 0. */
6217 if (input_stat_set
== 0)
6219 input_stat_set
= stat (gcc_input_filename
,
6221 if (input_stat_set
>= 0)
6225 /* If we have the stat for the gcc_input_filename
6226 and we can do the stat for the temp_filename
6227 then the they could still refer to the same
6228 file if st_dev/st_ino's are the same. */
6229 if (input_stat_set
!= 1
6230 || stat (temp_filename
, &st_temp
) < 0
6231 || input_stat
.st_dev
!= st_temp
.st_dev
6232 || input_stat
.st_ino
!= st_temp
.st_ino
)
6234 /* Just compare canonical pathnames. */
6235 char* input_realname
= lrealpath (gcc_input_filename
);
6236 char* temp_realname
= lrealpath (temp_filename
);
6237 bool files_differ
= filename_cmp (input_realname
, temp_realname
);
6238 free (input_realname
);
6239 free (temp_realname
);
6244 = save_string (temp_filename
,
6245 temp_filename_length
- 1);
6246 obstack_grow (&obstack
, temp_filename
,
6247 temp_filename_length
);
6249 delete_this_arg
= 0;
6255 /* See if we already have an association of %g/%u/%U and
6257 for (t
= temp_names
; t
; t
= t
->next
)
6258 if (t
->length
== suffix_length
6259 && strncmp (t
->suffix
, suffix
, suffix_length
) == 0
6260 && t
->unique
== (c
== 'u' || c
== 'U' || c
== 'j'))
6263 /* Make a new association if needed. %u and %j
6265 if (t
== 0 || c
== 'u' || c
== 'j')
6269 t
= XNEW (struct temp_name
);
6270 t
->next
= temp_names
;
6273 t
->length
= suffix_length
;
6276 t
->suffix
= saved_suffix
;
6277 saved_suffix
= NULL
;
6280 t
->suffix
= save_string (suffix
, suffix_length
);
6281 t
->unique
= (c
== 'u' || c
== 'U' || c
== 'j');
6282 temp_filename
= make_temp_file (t
->suffix
);
6283 temp_filename_length
= strlen (temp_filename
);
6284 t
->filename
= temp_filename
;
6285 t
->filename_length
= temp_filename_length
;
6288 free (saved_suffix
);
6290 obstack_grow (&obstack
, t
->filename
, t
->filename_length
);
6291 delete_this_arg
= 1;
6299 /* We are going to expand `%i' into `@FILE', where FILE
6300 is a newly-created temporary filename. The filenames
6301 that would usually be expanded in place of %o will be
6302 written to the temporary file. */
6303 if (at_file_supplied
)
6306 for (i
= 0; (int) i
< n_infiles
; i
++)
6307 if (compile_input_file_p (&infiles
[i
]))
6309 store_arg (infiles
[i
].name
, 0, 0);
6310 infiles
[i
].compiled
= true;
6313 if (at_file_supplied
)
6318 obstack_grow (&obstack
, gcc_input_filename
,
6319 input_filename_length
);
6326 struct spec_path_info info
;
6330 do_spec_1 ("-imultilib", 1, NULL
);
6331 /* Make this a separate argument. */
6332 do_spec_1 (" ", 0, NULL
);
6333 do_spec_1 (multilib_dir
, 1, NULL
);
6334 do_spec_1 (" ", 0, NULL
);
6339 do_spec_1 ("-imultiarch", 1, NULL
);
6340 /* Make this a separate argument. */
6341 do_spec_1 (" ", 0, NULL
);
6342 do_spec_1 (multiarch_dir
, 1, NULL
);
6343 do_spec_1 (" ", 0, NULL
);
6346 if (gcc_exec_prefix
)
6348 do_spec_1 ("-iprefix", 1, NULL
);
6349 /* Make this a separate argument. */
6350 do_spec_1 (" ", 0, NULL
);
6351 do_spec_1 (gcc_exec_prefix
, 1, NULL
);
6352 do_spec_1 (" ", 0, NULL
);
6355 if (target_system_root_changed
||
6356 (target_system_root
&& target_sysroot_hdrs_suffix
))
6358 do_spec_1 ("-isysroot", 1, NULL
);
6359 /* Make this a separate argument. */
6360 do_spec_1 (" ", 0, NULL
);
6361 do_spec_1 (target_system_root
, 1, NULL
);
6362 if (target_sysroot_hdrs_suffix
)
6363 do_spec_1 (target_sysroot_hdrs_suffix
, 1, NULL
);
6364 do_spec_1 (" ", 0, NULL
);
6367 info
.option
= "-isystem";
6368 info
.append
= "include";
6369 info
.append_len
= strlen (info
.append
);
6370 info
.omit_relative
= false;
6371 info
.separate_options
= true;
6373 for_each_path (&include_prefixes
, false, info
.append_len
,
6376 info
.append
= "include-fixed";
6377 if (*sysroot_hdrs_suffix_spec
)
6378 info
.append
= concat (info
.append
, dir_separator_str
,
6379 multilib_dir
, NULL
);
6380 info
.append_len
= strlen (info
.append
);
6381 for_each_path (&include_prefixes
, false, info
.append_len
,
6387 /* We are going to expand `%o' into `@FILE', where FILE
6388 is a newly-created temporary filename. The filenames
6389 that would usually be expanded in place of %o will be
6390 written to the temporary file. */
6391 if (at_file_supplied
)
6394 for (i
= 0; i
< n_infiles
+ lang_specific_extra_outfiles
; i
++)
6396 store_arg (outfiles
[i
], 0, 0);
6398 if (at_file_supplied
)
6403 obstack_grow (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
6408 this_is_library_file
= 1;
6412 this_is_linker_script
= 1;
6416 outfiles
[input_file_number
] = NULL
;
6420 this_is_output_file
= 1;
6425 unsigned int cur_index
= argbuf
.length ();
6426 /* Handle the {...} following the %W. */
6428 fatal_error (input_location
,
6429 "spec %qs has invalid %<%%W%c%>", spec
, *p
);
6430 p
= handle_braces (p
+ 1);
6434 /* If any args were output, mark the last one for deletion
6436 if (argbuf
.length () != cur_index
)
6437 record_temp_file (argbuf
.last (), 0, 1);
6442 /* Handle the {...} following the %@. */
6444 fatal_error (input_location
,
6445 "spec %qs has invalid %<%%@%c%>", spec
, *p
);
6446 if (at_file_supplied
)
6448 p
= handle_braces (p
+ 1);
6449 if (at_file_supplied
)
6455 /* %x{OPTION} records OPTION for %X to output. */
6463 /* Skip past the option value and make a copy. */
6465 fatal_error (input_location
,
6466 "spec %qs has invalid %<%%x%c%>", spec
, *p
);
6469 string
= save_string (p1
+ 1, p
- p1
- 2);
6471 /* See if we already recorded this option. */
6472 FOR_EACH_VEC_ELT (linker_options
, ix
, opt
)
6473 if (! strcmp (string
, opt
))
6479 /* This option is new; add it. */
6480 add_linker_option (string
, strlen (string
));
6485 /* Dump out the options accumulated previously using %x. */
6487 do_specs_vec (linker_options
);
6490 /* Dump out the options accumulated previously using -Wa,. */
6492 do_specs_vec (assembler_options
);
6495 /* Dump out the options accumulated previously using -Wp,. */
6497 do_specs_vec (preprocessor_options
);
6500 /* Here are digits and numbers that just process
6501 a certain constant string as a spec. */
6504 value
= do_spec_1 (cc1_spec
, 0, NULL
);
6510 value
= do_spec_1 (cc1plus_spec
, 0, NULL
);
6516 value
= do_spec_1 (asm_spec
, 0, NULL
);
6522 value
= do_spec_1 (asm_final_spec
, 0, NULL
);
6529 const char *const spec
6530 = (input_file_compiler
->cpp_spec
6531 ? input_file_compiler
->cpp_spec
6533 value
= do_spec_1 (spec
, 0, NULL
);
6540 value
= do_spec_1 (endfile_spec
, 0, NULL
);
6546 value
= do_spec_1 (link_spec
, 0, NULL
);
6552 value
= do_spec_1 (lib_spec
, 0, NULL
);
6558 if (multilib_os_dir
== NULL
)
6559 obstack_1grow (&obstack
, '.');
6561 obstack_grow (&obstack
, multilib_os_dir
,
6562 strlen (multilib_os_dir
));
6566 value
= do_spec_1 (libgcc_spec
, 0, NULL
);
6572 /* We assume there is a directory
6573 separator at the end of this string. */
6574 if (target_system_root
)
6576 obstack_grow (&obstack
, target_system_root
,
6577 strlen (target_system_root
));
6578 if (target_sysroot_suffix
)
6579 obstack_grow (&obstack
, target_sysroot_suffix
,
6580 strlen (target_sysroot_suffix
));
6585 value
= do_spec_1 (startfile_spec
, 0, NULL
);
6590 /* Here we define characters other than letters and digits. */
6593 p
= handle_braces (p
);
6599 p
= handle_spec_function (p
, NULL
, soft_matched_part
);
6605 obstack_1grow (&obstack
, '%');
6612 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '%')
6614 suffix_subst
= save_string (p
- 1, len
+ 1);
6619 /* Henceforth ignore the option(s) matching the pattern
6625 int have_wildcard
= 0;
6630 switch_option
= SWITCH_IGNORE
| SWITCH_KEEP_FOR_GCC
;
6632 switch_option
= SWITCH_IGNORE
;
6634 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '\t')
6637 if (p
[len
-1] == '*')
6640 for (i
= 0; i
< n_switches
; i
++)
6641 if (!strncmp (switches
[i
].part1
, p
, len
- have_wildcard
)
6642 && (have_wildcard
|| switches
[i
].part1
[len
] == '\0'))
6644 switches
[i
].live_cond
|= switch_option
;
6645 /* User switch be validated from validate_all_switches.
6646 when the definition is seen from the spec file.
6647 If not defined anywhere, will be rejected. */
6648 if (switches
[i
].known
)
6649 switches
[i
].validated
= true;
6657 if (soft_matched_part
)
6659 if (soft_matched_part
[0])
6660 do_spec_1 (soft_matched_part
, 1, NULL
);
6661 /* Only insert a space after the substitution if it is at the
6662 end of the current sequence. So if:
6664 "%{foo=*:bar%*}%{foo=*:one%*two}"
6666 matches -foo=hello then it will produce:
6668 barhello onehellotwo
6670 if (*p
== 0 || *p
== '}')
6671 do_spec_1 (" ", 0, NULL
);
6674 /* Catch the case where a spec string contains something like
6675 '%{foo:%*}'. i.e. there is no * in the pattern on the left
6676 hand side of the :. */
6677 error ("spec failure: %<%%*%> has not been initialized by pattern match");
6680 /* Process a string found as the value of a spec given by name.
6681 This feature allows individual machine descriptions
6682 to add and use their own specs. */
6685 const char *name
= p
;
6686 struct spec_list
*sl
;
6689 /* The string after the S/P is the name of a spec that is to be
6691 while (*p
&& *p
!= ')')
6694 /* See if it's in the list. */
6695 for (len
= p
- name
, sl
= specs
; sl
; sl
= sl
->next
)
6696 if (sl
->name_len
== len
&& !strncmp (sl
->name
, name
, len
))
6698 name
= *(sl
->ptr_spec
);
6700 fnotice (stderr
, "Processing spec (%s), which is '%s'\n",
6708 value
= do_spec_1 (name
, 0, NULL
);
6713 /* Discard the closing paren. */
6720 /* End a previous argument, if there is one, then issue an
6728 error ("spec failure: unrecognized spec option %qc", c
);
6734 /* Backslash: treat next character as ordinary. */
6737 /* When adding more cases that previously matched default, make
6738 sure to adjust quote_spec_char_p as well. */
6742 /* Ordinary character: put it into the current argument. */
6743 obstack_1grow (&obstack
, c
);
6747 /* End of string. If we are processing a spec function, we need to
6748 end any pending argument. */
6749 if (processing_spec_function
)
6755 /* Look up a spec function. */
6757 static const struct spec_function
*
6758 lookup_spec_function (const char *name
)
6760 const struct spec_function
*sf
;
6762 for (sf
= static_spec_functions
; sf
->name
!= NULL
; sf
++)
6763 if (strcmp (sf
->name
, name
) == 0)
6769 /* Evaluate a spec function. */
6772 eval_spec_function (const char *func
, const char *args
,
6773 const char *soft_matched_part
)
6775 const struct spec_function
*sf
;
6776 const char *funcval
;
6778 /* Saved spec processing context. */
6779 vec
<const_char_p
> save_argbuf
;
6782 int save_delete_this_arg
;
6783 int save_this_is_output_file
;
6784 int save_this_is_library_file
;
6785 int save_input_from_pipe
;
6786 int save_this_is_linker_script
;
6787 const char *save_suffix_subst
;
6789 int save_growing_size
;
6790 void *save_growing_value
= NULL
;
6792 sf
= lookup_spec_function (func
);
6794 fatal_error (input_location
, "unknown spec function %qs", func
);
6796 /* Push the spec processing context. */
6797 save_argbuf
= argbuf
;
6799 save_arg_going
= arg_going
;
6800 save_delete_this_arg
= delete_this_arg
;
6801 save_this_is_output_file
= this_is_output_file
;
6802 save_this_is_library_file
= this_is_library_file
;
6803 save_this_is_linker_script
= this_is_linker_script
;
6804 save_input_from_pipe
= input_from_pipe
;
6805 save_suffix_subst
= suffix_subst
;
6807 /* If we have some object growing now, finalize it so the args and function
6808 eval proceed from a cleared context. This is needed to prevent the first
6809 constructed arg from mistakenly including the growing value. We'll push
6810 this value back on the obstack once the function evaluation is done, to
6811 restore a consistent processing context for our caller. This is fine as
6812 the address of growing objects isn't guaranteed to remain stable until
6813 they are finalized, and we expect this situation to be rare enough for
6814 the extra copy not to be an issue. */
6815 save_growing_size
= obstack_object_size (&obstack
);
6816 if (save_growing_size
> 0)
6817 save_growing_value
= obstack_finish (&obstack
);
6819 /* Create a new spec processing context, and build the function
6823 if (do_spec_2 (args
, soft_matched_part
) < 0)
6824 fatal_error (input_location
, "error in arguments to spec function %qs",
6827 /* argbuf_index is an index for the next argument to be inserted, and
6828 so contains the count of the args already inserted. */
6830 funcval
= (*sf
->func
) (argbuf
.length (),
6833 /* Pop the spec processing context. */
6835 argbuf
= save_argbuf
;
6837 arg_going
= save_arg_going
;
6838 delete_this_arg
= save_delete_this_arg
;
6839 this_is_output_file
= save_this_is_output_file
;
6840 this_is_library_file
= save_this_is_library_file
;
6841 this_is_linker_script
= save_this_is_linker_script
;
6842 input_from_pipe
= save_input_from_pipe
;
6843 suffix_subst
= save_suffix_subst
;
6845 if (save_growing_size
> 0)
6846 obstack_grow (&obstack
, save_growing_value
, save_growing_size
);
6851 /* Handle a spec function call of the form:
6855 ARGS is processed as a spec in a separate context and split into an
6856 argument vector in the normal fashion. The function returns a string
6857 containing a spec which we then process in the caller's context, or
6858 NULL if no processing is required.
6860 If RETVAL_NONNULL is not NULL, then store a bool whether function
6863 SOFT_MATCHED_PART holds the current value of a matched * pattern, which
6864 may be re-expanded with a %* as part of the function arguments. */
6867 handle_spec_function (const char *p
, bool *retval_nonnull
,
6868 const char *soft_matched_part
)
6871 const char *endp
, *funcval
;
6874 processing_spec_function
++;
6876 /* Get the function name. */
6877 for (endp
= p
; *endp
!= '\0'; endp
++)
6879 if (*endp
== '(') /* ) */
6881 /* Only allow [A-Za-z0-9], -, and _ in function names. */
6882 if (!ISALNUM (*endp
) && !(*endp
== '-' || *endp
== '_'))
6883 fatal_error (input_location
, "malformed spec function name");
6885 if (*endp
!= '(') /* ) */
6886 fatal_error (input_location
, "no arguments for spec function");
6887 func
= save_string (p
, endp
- p
);
6890 /* Get the arguments. */
6891 for (count
= 0; *endp
!= '\0'; endp
++)
6900 else if (*endp
== '(') /* ) */
6905 fatal_error (input_location
, "malformed spec function arguments");
6906 args
= save_string (p
, endp
- p
);
6909 /* p now points to just past the end of the spec function expression. */
6911 funcval
= eval_spec_function (func
, args
, soft_matched_part
);
6912 if (funcval
!= NULL
&& do_spec_1 (funcval
, 0, NULL
) < 0)
6915 *retval_nonnull
= funcval
!= NULL
;
6920 processing_spec_function
--;
6925 /* Inline subroutine of handle_braces. Returns true if the current
6926 input suffix matches the atom bracketed by ATOM and END_ATOM. */
6928 input_suffix_matches (const char *atom
, const char *end_atom
)
6930 return (input_suffix
6931 && !strncmp (input_suffix
, atom
, end_atom
- atom
)
6932 && input_suffix
[end_atom
- atom
] == '\0');
6935 /* Subroutine of handle_braces. Returns true if the current
6936 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
6938 input_spec_matches (const char *atom
, const char *end_atom
)
6940 return (input_file_compiler
6941 && input_file_compiler
->suffix
6942 && input_file_compiler
->suffix
[0] != '\0'
6943 && !strncmp (input_file_compiler
->suffix
+ 1, atom
,
6945 && input_file_compiler
->suffix
[end_atom
- atom
+ 1] == '\0');
6948 /* Subroutine of handle_braces. Returns true if a switch
6949 matching the atom bracketed by ATOM and END_ATOM appeared on the
6952 switch_matches (const char *atom
, const char *end_atom
, int starred
)
6955 int len
= end_atom
- atom
;
6956 int plen
= starred
? len
: -1;
6958 for (i
= 0; i
< n_switches
; i
++)
6959 if (!strncmp (switches
[i
].part1
, atom
, len
)
6960 && (starred
|| switches
[i
].part1
[len
] == '\0')
6961 && check_live_switch (i
, plen
))
6964 /* Check if a switch with separated form matching the atom.
6965 We check -D and -U switches. */
6966 else if (switches
[i
].args
!= 0)
6968 if ((*switches
[i
].part1
== 'D' || *switches
[i
].part1
== 'U')
6969 && *switches
[i
].part1
== atom
[0])
6971 if (!strncmp (switches
[i
].args
[0], &atom
[1], len
- 1)
6972 && (starred
|| (switches
[i
].part1
[1] == '\0'
6973 && switches
[i
].args
[0][len
- 1] == '\0'))
6974 && check_live_switch (i
, (starred
? 1 : -1)))
6982 /* Inline subroutine of handle_braces. Mark all of the switches which
6983 match ATOM (extends to END_ATOM; STARRED indicates whether there
6984 was a star after the atom) for later processing. */
6986 mark_matching_switches (const char *atom
, const char *end_atom
, int starred
)
6989 int len
= end_atom
- atom
;
6990 int plen
= starred
? len
: -1;
6992 for (i
= 0; i
< n_switches
; i
++)
6993 if (!strncmp (switches
[i
].part1
, atom
, len
)
6994 && (starred
|| switches
[i
].part1
[len
] == '\0')
6995 && check_live_switch (i
, plen
))
6996 switches
[i
].ordering
= 1;
6999 /* Inline subroutine of handle_braces. Process all the currently
7000 marked switches through give_switch, and clear the marks. */
7002 process_marked_switches (void)
7006 for (i
= 0; i
< n_switches
; i
++)
7007 if (switches
[i
].ordering
== 1)
7009 switches
[i
].ordering
= 0;
7014 /* Handle a %{ ... } construct. P points just inside the leading {.
7015 Returns a pointer one past the end of the brace block, or 0
7016 if we call do_spec_1 and that returns -1. */
7019 handle_braces (const char *p
)
7021 const char *atom
, *end_atom
;
7022 const char *d_atom
= NULL
, *d_end_atom
= NULL
;
7023 char *esc_buf
= NULL
, *d_esc_buf
= NULL
;
7025 const char *orig
= p
;
7033 bool a_must_be_last
= false;
7034 bool ordered_set
= false;
7035 bool disjunct_set
= false;
7036 bool disj_matched
= false;
7037 bool disj_starred
= true;
7038 bool n_way_choice
= false;
7039 bool n_way_matched
= false;
7041 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7048 /* Scan one "atom" (S in the description above of %{}, possibly
7049 with '!', '.', '@', ',', or '*' modifiers). */
7051 a_is_suffix
= false;
7052 a_is_starred
= false;
7053 a_is_negated
= false;
7054 a_is_spectype
= false;
7058 p
++, a_is_negated
= true;
7061 if (*p
== '%' && p
[1] == ':')
7065 p
= handle_spec_function (p
+ 2, &a_matched
, NULL
);
7070 p
++, a_is_suffix
= true;
7072 p
++, a_is_spectype
= true;
7076 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
7077 || *p
== ',' || *p
== '.' || *p
== '@' || *p
== '\\')
7083 fatal_error (input_location
,
7084 "braced spec %qs ends in escape", orig
);
7096 if (esc_buf
&& esc_buf
!= d_esc_buf
)
7099 ep
= esc_buf
= (char *) xmalloc (end_atom
- atom
- esc
+ 1);
7100 for (ap
= atom
; ap
!= end_atom
; ap
++, ep
++)
7112 p
++, a_is_starred
= 1;
7119 /* Substitute the switch(es) indicated by the current atom. */
7121 if (disjunct_set
|| n_way_choice
|| a_is_negated
|| a_is_suffix
7122 || a_is_spectype
|| atom
== end_atom
)
7125 mark_matching_switches (atom
, end_atom
, a_is_starred
);
7128 process_marked_switches ();
7132 /* Substitute some text if the current atom appears as a switch
7134 disjunct_set
= true;
7138 if (atom
&& atom
== end_atom
)
7140 if (!n_way_choice
|| disj_matched
|| *p
== '|'
7141 || a_is_negated
|| a_is_suffix
|| a_is_spectype
7145 /* An empty term may appear as the last choice of an
7146 N-way choice set; it means "otherwise". */
7147 a_must_be_last
= true;
7148 disj_matched
= !n_way_matched
;
7149 disj_starred
= false;
7153 if ((a_is_suffix
|| a_is_spectype
) && a_is_starred
)
7157 disj_starred
= false;
7159 /* Don't bother testing this atom if we already have a
7161 if (!disj_matched
&& !n_way_matched
)
7164 /* a_matched is already set by handle_spec_function. */;
7165 else if (a_is_suffix
)
7166 a_matched
= input_suffix_matches (atom
, end_atom
);
7167 else if (a_is_spectype
)
7168 a_matched
= input_spec_matches (atom
, end_atom
);
7170 a_matched
= switch_matches (atom
, end_atom
, a_is_starred
);
7172 if (a_matched
!= a_is_negated
)
7174 disj_matched
= true;
7176 d_end_atom
= end_atom
;
7177 d_esc_buf
= esc_buf
;
7184 /* Found the body, that is, the text to substitute if the
7185 current disjunction matches. */
7186 p
= process_brace_body (p
+ 1, d_atom
, d_end_atom
, disj_starred
,
7187 disj_matched
&& !n_way_matched
);
7191 /* If we have an N-way choice, reset state for the next
7195 n_way_choice
= true;
7196 n_way_matched
|= disj_matched
;
7197 disj_matched
= false;
7198 disj_starred
= true;
7199 d_atom
= d_end_atom
= NULL
;
7208 while (*p
++ != '}');
7211 if (d_esc_buf
&& d_esc_buf
!= esc_buf
)
7219 fatal_error (input_location
, "braced spec %qs is invalid at %qc", orig
, *p
);
7224 /* Subroutine of handle_braces. Scan and process a brace substitution body
7225 (X in the description of %{} syntax). P points one past the colon;
7226 ATOM and END_ATOM bracket the first atom which was found to be true
7227 (present) in the current disjunction; STARRED indicates whether all
7228 the atoms in the current disjunction were starred (for syntax validation);
7229 MATCHED indicates whether the disjunction matched or not, and therefore
7230 whether or not the body is to be processed through do_spec_1 or just
7231 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
7235 process_brace_body (const char *p
, const char *atom
, const char *end_atom
,
7236 int starred
, int matched
)
7238 const char *body
, *end_body
;
7239 unsigned int nesting_level
;
7240 bool have_subst
= false;
7242 /* Locate the closing } or ;, honoring nested braces.
7243 Trim trailing whitespace. */
7252 if (!--nesting_level
)
7255 else if (*p
== ';' && nesting_level
== 1)
7257 else if (*p
== '%' && p
[1] == '*' && nesting_level
== 1)
7259 else if (*p
== '\0')
7265 while (end_body
[-1] == ' ' || end_body
[-1] == '\t')
7268 if (have_subst
&& !starred
)
7273 /* Copy the substitution body to permanent storage and execute it.
7274 If have_subst is false, this is a simple matter of running the
7275 body through do_spec_1... */
7276 char *string
= save_string (body
, end_body
- body
);
7279 if (do_spec_1 (string
, 0, NULL
) < 0)
7287 /* ... but if have_subst is true, we have to process the
7288 body once for each matching switch, with %* set to the
7289 variant part of the switch. */
7290 unsigned int hard_match_len
= end_atom
- atom
;
7293 for (i
= 0; i
< n_switches
; i
++)
7294 if (!strncmp (switches
[i
].part1
, atom
, hard_match_len
)
7295 && check_live_switch (i
, hard_match_len
))
7297 if (do_spec_1 (string
, 0,
7298 &switches
[i
].part1
[hard_match_len
]) < 0)
7303 /* Pass any arguments this switch has. */
7305 suffix_subst
= NULL
;
7314 fatal_error (input_location
, "braced spec body %qs is invalid", body
);
7317 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
7318 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
7319 spec, or -1 if either exact match or %* is used.
7321 A -O switch is obsoleted by a later -O switch. A -f, -g, -m, or -W switch
7322 whose value does not begin with "no-" is obsoleted by the same value
7323 with the "no-", similarly for a switch with the "no-" prefix. */
7326 check_live_switch (int switchnum
, int prefix_length
)
7328 const char *name
= switches
[switchnum
].part1
;
7331 /* If we already processed this switch and determined if it was
7332 live or not, return our past determination. */
7333 if (switches
[switchnum
].live_cond
!= 0)
7334 return ((switches
[switchnum
].live_cond
& SWITCH_LIVE
) != 0
7335 && (switches
[switchnum
].live_cond
& SWITCH_FALSE
) == 0
7336 && (switches
[switchnum
].live_cond
& SWITCH_IGNORE_PERMANENTLY
)
7339 /* In the common case of {<at-most-one-letter>*}, a negating
7340 switch would always match, so ignore that case. We will just
7341 send the conflicting switches to the compiler phase. */
7342 if (prefix_length
>= 0 && prefix_length
<= 1)
7345 /* Now search for duplicate in a manner that depends on the name. */
7349 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
7350 if (switches
[i
].part1
[0] == 'O')
7352 switches
[switchnum
].validated
= true;
7353 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
7358 case 'W': case 'f': case 'm': case 'g':
7359 if (! strncmp (name
+ 1, "no-", 3))
7361 /* We have Xno-YYY, search for XYYY. */
7362 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
7363 if (switches
[i
].part1
[0] == name
[0]
7364 && ! strcmp (&switches
[i
].part1
[1], &name
[4]))
7366 /* --specs are validated with the validate_switches mechanism. */
7367 if (switches
[switchnum
].known
)
7368 switches
[switchnum
].validated
= true;
7369 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
7375 /* We have XYYY, search for Xno-YYY. */
7376 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
7377 if (switches
[i
].part1
[0] == name
[0]
7378 && switches
[i
].part1
[1] == 'n'
7379 && switches
[i
].part1
[2] == 'o'
7380 && switches
[i
].part1
[3] == '-'
7381 && !strcmp (&switches
[i
].part1
[4], &name
[1]))
7383 /* --specs are validated with the validate_switches mechanism. */
7384 if (switches
[switchnum
].known
)
7385 switches
[switchnum
].validated
= true;
7386 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
7393 /* Otherwise the switch is live. */
7394 switches
[switchnum
].live_cond
|= SWITCH_LIVE
;
7398 /* Pass a switch to the current accumulating command
7399 in the same form that we received it.
7400 SWITCHNUM identifies the switch; it is an index into
7401 the vector of switches gcc received, which is `switches'.
7402 This cannot fail since it never finishes a command line.
7404 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
7407 give_switch (int switchnum
, int omit_first_word
)
7409 if ((switches
[switchnum
].live_cond
& SWITCH_IGNORE
) != 0)
7412 if (!omit_first_word
)
7414 do_spec_1 ("-", 0, NULL
);
7415 do_spec_1 (switches
[switchnum
].part1
, 1, NULL
);
7418 if (switches
[switchnum
].args
!= 0)
7421 for (p
= switches
[switchnum
].args
; *p
; p
++)
7423 const char *arg
= *p
;
7425 do_spec_1 (" ", 0, NULL
);
7428 unsigned length
= strlen (arg
);
7431 while (length
-- && !IS_DIR_SEPARATOR (arg
[length
]))
7432 if (arg
[length
] == '.')
7434 (CONST_CAST (char *, arg
))[length
] = 0;
7438 do_spec_1 (arg
, 1, NULL
);
7440 (CONST_CAST (char *, arg
))[length
] = '.';
7441 do_spec_1 (suffix_subst
, 1, NULL
);
7444 do_spec_1 (arg
, 1, NULL
);
7448 do_spec_1 (" ", 0, NULL
);
7449 switches
[switchnum
].validated
= true;
7452 /* Print GCC configuration (e.g. version, thread model, target,
7453 configuration_arguments) to a given FILE. */
7456 print_configuration (FILE *file
)
7461 fnotice (file
, "Target: %s\n", spec_machine
);
7462 fnotice (file
, "Configured with: %s\n", configuration_arguments
);
7464 #ifdef THREAD_MODEL_SPEC
7465 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
7466 but there's no point in doing all this processing just to get
7467 thread_model back. */
7468 obstack_init (&obstack
);
7469 do_spec_1 (THREAD_MODEL_SPEC
, 0, thread_model
);
7470 obstack_1grow (&obstack
, '\0');
7471 thrmod
= XOBFINISH (&obstack
, const char *);
7473 thrmod
= thread_model
;
7476 fnotice (file
, "Thread model: %s\n", thrmod
);
7477 fnotice (file
, "Supported LTO compression algorithms: zlib");
7479 fnotice (file
, " zstd");
7481 fnotice (file
, "\n");
7483 /* compiler_version is truncated at the first space when initialized
7484 from version string, so truncate version_string at the first space
7485 before comparing. */
7486 for (n
= 0; version_string
[n
]; n
++)
7487 if (version_string
[n
] == ' ')
7490 if (! strncmp (version_string
, compiler_version
, n
)
7491 && compiler_version
[n
] == 0)
7492 fnotice (file
, "gcc version %s %s\n", version_string
,
7495 fnotice (file
, "gcc driver version %s %sexecuting gcc version %s\n",
7496 version_string
, pkgversion_string
, compiler_version
);
7500 #define RETRY_ICE_ATTEMPTS 3
7502 /* Returns true if FILE1 and FILE2 contain equivalent data, 0 otherwise. */
7505 files_equal_p (char *file1
, char *file2
)
7507 struct stat st1
, st2
;
7510 const int bufsize
= 8192;
7511 char *buf
= XNEWVEC (char, bufsize
);
7513 fd1
= open (file1
, O_RDONLY
);
7514 fd2
= open (file2
, O_RDONLY
);
7516 if (fd1
< 0 || fd2
< 0)
7519 if (fstat (fd1
, &st1
) < 0 || fstat (fd2
, &st2
) < 0)
7522 if (st1
.st_size
!= st2
.st_size
)
7525 for (n
= st1
.st_size
; n
; n
-= len
)
7528 if ((int) len
> bufsize
/ 2)
7531 if (read (fd1
, buf
, len
) != (int) len
7532 || read (fd2
, buf
+ bufsize
/ 2, len
) != (int) len
)
7537 if (memcmp (buf
, buf
+ bufsize
/ 2, len
) != 0)
7554 /* Check that compiler's output doesn't differ across runs.
7555 TEMP_STDOUT_FILES and TEMP_STDERR_FILES are arrays of files, containing
7556 stdout and stderr for each compiler run. Return true if all of
7557 TEMP_STDOUT_FILES and TEMP_STDERR_FILES are equivalent. */
7560 check_repro (char **temp_stdout_files
, char **temp_stderr_files
)
7563 for (i
= 0; i
< RETRY_ICE_ATTEMPTS
- 2; ++i
)
7565 if (!files_equal_p (temp_stdout_files
[i
], temp_stdout_files
[i
+ 1])
7566 || !files_equal_p (temp_stderr_files
[i
], temp_stderr_files
[i
+ 1]))
7568 fnotice (stderr
, "The bug is not reproducible, so it is"
7569 " likely a hardware or OS problem.\n");
7573 return i
== RETRY_ICE_ATTEMPTS
- 2;
7576 enum attempt_status
{
7577 ATTEMPT_STATUS_FAIL_TO_RUN
,
7578 ATTEMPT_STATUS_SUCCESS
,
7583 /* Run compiler with arguments NEW_ARGV to reproduce the ICE, storing stdout
7584 to OUT_TEMP and stderr to ERR_TEMP. If APPEND is TRUE, append to OUT_TEMP
7585 and ERR_TEMP instead of truncating. If EMIT_SYSTEM_INFO is TRUE, also write
7586 GCC configuration into to ERR_TEMP. Return ATTEMPT_STATUS_FAIL_TO_RUN if
7587 compiler failed to run, ATTEMPT_STATUS_ICE if compiled ICE-ed and
7588 ATTEMPT_STATUS_SUCCESS otherwise. */
7590 static enum attempt_status
7591 run_attempt (const char **new_argv
, const char *out_temp
,
7592 const char *err_temp
, int emit_system_info
, int append
)
7595 if (emit_system_info
)
7597 FILE *file_out
= fopen (err_temp
, "a");
7598 print_configuration (file_out
);
7599 fputs ("\n", file_out
);
7605 struct pex_obj
*pex
;
7607 int pex_flags
= PEX_USE_PIPES
| PEX_LAST
;
7608 enum attempt_status status
= ATTEMPT_STATUS_FAIL_TO_RUN
;
7611 pex_flags
|= PEX_STDOUT_APPEND
| PEX_STDERR_APPEND
;
7613 pex
= pex_init (PEX_USE_PIPES
, new_argv
[0], NULL
);
7615 fatal_error (input_location
, "%<pex_init%> failed: %m");
7617 errmsg
= pex_run (pex
, pex_flags
, new_argv
[0],
7618 CONST_CAST2 (char *const *, const char **, &new_argv
[1]),
7619 out_temp
, err_temp
, &err
);
7623 fatal_error (input_location
,
7624 err
? G_ ("cannot execute %qs: %s: %m")
7625 : G_ ("cannot execute %qs: %s"),
7626 new_argv
[0], errmsg
);
7629 if (!pex_get_status (pex
, 1, &exit_status
))
7632 switch (WEXITSTATUS (exit_status
))
7635 status
= ATTEMPT_STATUS_ICE
;
7638 case SUCCESS_EXIT_CODE
:
7639 status
= ATTEMPT_STATUS_SUCCESS
;
7651 /* This routine reads lines from IN file, adds C++ style comments
7652 at the begining of each line and writes result into OUT. */
7655 insert_comments (const char *file_in
, const char *file_out
)
7657 FILE *in
= fopen (file_in
, "rb");
7658 FILE *out
= fopen (file_out
, "wb");
7661 bool add_comment
= true;
7662 while (fgets (line
, sizeof (line
), in
))
7667 add_comment
= strchr (line
, '\n') != NULL
;
7674 /* This routine adds preprocessed source code into the given ERR_FILE.
7675 To do this, it adds "-E" to NEW_ARGV and execute RUN_ATTEMPT routine to
7676 add information in report file. RUN_ATTEMPT should return
7677 ATTEMPT_STATUS_SUCCESS, in other case we cannot generate the report. */
7680 do_report_bug (const char **new_argv
, const int nargs
,
7681 char **out_file
, char **err_file
)
7684 int fd
= open (*out_file
, O_RDWR
| O_APPEND
);
7687 write (fd
, "\n//", 3);
7688 for (i
= 0; i
< nargs
; i
++)
7691 write (fd
, new_argv
[i
], strlen (new_argv
[i
]));
7693 write (fd
, "\n\n", 2);
7695 new_argv
[nargs
] = "-E";
7696 new_argv
[nargs
+ 1] = NULL
;
7698 status
= run_attempt (new_argv
, *out_file
, *err_file
, 0, 1);
7700 if (status
== ATTEMPT_STATUS_SUCCESS
)
7702 fnotice (stderr
, "Preprocessed source stored into %s file,"
7703 " please attach this to your bugreport.\n", *out_file
);
7704 /* Make sure it is not deleted. */
7710 /* Try to reproduce ICE. If bug is reproducible, generate report .err file
7711 containing GCC configuration, backtrace, compiler's command line options
7712 and preprocessed source code. */
7715 try_generate_repro (const char **argv
)
7717 int i
, nargs
, out_arg
= -1, quiet
= 0, attempt
;
7718 const char **new_argv
;
7719 char *temp_files
[RETRY_ICE_ATTEMPTS
* 2];
7720 char **temp_stdout_files
= &temp_files
[0];
7721 char **temp_stderr_files
= &temp_files
[RETRY_ICE_ATTEMPTS
];
7723 if (gcc_input_filename
== NULL
|| ! strcmp (gcc_input_filename
, "-"))
7726 for (nargs
= 0; argv
[nargs
] != NULL
; ++nargs
)
7727 /* Only retry compiler ICEs, not preprocessor ones. */
7728 if (! strcmp (argv
[nargs
], "-E"))
7730 else if (argv
[nargs
][0] == '-' && argv
[nargs
][1] == 'o')
7737 /* If the compiler is going to output any time information,
7738 it might varry between invocations. */
7739 else if (! strcmp (argv
[nargs
], "-quiet"))
7741 else if (! strcmp (argv
[nargs
], "-ftime-report"))
7744 if (out_arg
== -1 || !quiet
)
7747 memset (temp_files
, '\0', sizeof (temp_files
));
7748 new_argv
= XALLOCAVEC (const char *, nargs
+ 4);
7749 memcpy (new_argv
, argv
, (nargs
+ 1) * sizeof (const char *));
7750 new_argv
[nargs
++] = "-frandom-seed=0";
7751 new_argv
[nargs
++] = "-fdump-noaddr";
7752 new_argv
[nargs
] = NULL
;
7753 if (new_argv
[out_arg
][2] == '\0')
7754 new_argv
[out_arg
+ 1] = "-";
7756 new_argv
[out_arg
] = "-o-";
7759 for (attempt
= 0; attempt
< RETRY_ICE_ATTEMPTS
; ++attempt
)
7761 int emit_system_info
= 0;
7763 temp_stdout_files
[attempt
] = make_temp_file (".out");
7764 temp_stderr_files
[attempt
] = make_temp_file (".err");
7766 if (attempt
== RETRY_ICE_ATTEMPTS
- 1)
7769 emit_system_info
= 1;
7772 status
= run_attempt (new_argv
, temp_stdout_files
[attempt
],
7773 temp_stderr_files
[attempt
], emit_system_info
,
7776 if (status
!= ATTEMPT_STATUS_ICE
)
7778 fnotice (stderr
, "The bug is not reproducible, so it is"
7779 " likely a hardware or OS problem.\n");
7784 if (!check_repro (temp_stdout_files
, temp_stderr_files
))
7788 /* Insert commented out backtrace into report file. */
7789 char **stderr_commented
= &temp_stdout_files
[RETRY_ICE_ATTEMPTS
- 1];
7790 insert_comments (temp_stderr_files
[RETRY_ICE_ATTEMPTS
- 1],
7793 /* In final attempt we append compiler options and preprocesssed code to last
7794 generated .out file with configuration and backtrace. */
7795 char **err
= &temp_stderr_files
[RETRY_ICE_ATTEMPTS
- 1];
7796 do_report_bug (new_argv
, nargs
, stderr_commented
, err
);
7800 for (i
= 0; i
< RETRY_ICE_ATTEMPTS
* 2; i
++)
7803 unlink (temp_stdout_files
[i
]);
7804 free (temp_stdout_files
[i
]);
7808 /* Search for a file named NAME trying various prefixes including the
7809 user's -B prefix and some standard ones.
7810 Return the absolute file name found. If nothing is found, return NAME. */
7813 find_file (const char *name
)
7815 char *newname
= find_a_file (&startfile_prefixes
, name
, R_OK
, true);
7816 return newname
? newname
: name
;
7819 /* Determine whether a directory exists. If LINKER, return 0 for
7820 certain fixed names not needed by the linker. */
7823 is_directory (const char *path1
, bool linker
)
7830 /* Ensure the string ends with "/.". The resulting path will be a
7831 directory even if the given path is a symbolic link. */
7832 len1
= strlen (path1
);
7833 path
= (char *) alloca (3 + len1
);
7834 memcpy (path
, path1
, len1
);
7836 if (!IS_DIR_SEPARATOR (cp
[-1]))
7837 *cp
++ = DIR_SEPARATOR
;
7841 /* Exclude directories that the linker is known to search. */
7843 && IS_DIR_SEPARATOR (path
[0])
7845 && filename_ncmp (path
+ 1, "lib", 3) == 0)
7847 && filename_ncmp (path
+ 1, "usr", 3) == 0
7848 && IS_DIR_SEPARATOR (path
[4])
7849 && filename_ncmp (path
+ 5, "lib", 3) == 0)))
7852 return (stat (path
, &st
) >= 0 && S_ISDIR (st
.st_mode
));
7855 /* Set up the various global variables to indicate that we're processing
7856 the input file named FILENAME. */
7859 set_input (const char *filename
)
7863 gcc_input_filename
= filename
;
7864 input_filename_length
= strlen (gcc_input_filename
);
7865 input_basename
= lbasename (gcc_input_filename
);
7867 /* Find a suffix starting with the last period,
7868 and set basename_length to exclude that suffix. */
7869 basename_length
= strlen (input_basename
);
7870 suffixed_basename_length
= basename_length
;
7871 p
= input_basename
+ basename_length
;
7872 while (p
!= input_basename
&& *p
!= '.')
7874 if (*p
== '.' && p
!= input_basename
)
7876 basename_length
= p
- input_basename
;
7877 input_suffix
= p
+ 1;
7882 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
7883 we will need to do a stat on the gcc_input_filename. The
7884 INPUT_STAT_SET signals that the stat is needed. */
7888 /* On fatal signals, delete all the temporary files. */
7891 fatal_signal (int signum
)
7893 signal (signum
, SIG_DFL
);
7894 delete_failure_queue ();
7895 delete_temp_files ();
7896 /* Get the same signal again, this time not handled,
7897 so its normal effect occurs. */
7898 kill (getpid (), signum
);
7901 /* Compare the contents of the two files named CMPFILE[0] and
7902 CMPFILE[1]. Return zero if they're identical, nonzero
7906 compare_files (char *cmpfile
[])
7909 FILE *temp
[2] = { NULL
, NULL
};
7915 void *map
[2] = { NULL
, NULL
};
7917 for (i
= 0; i
< 2; i
++)
7921 if (stat (cmpfile
[i
], &st
) < 0 || !S_ISREG (st
.st_mode
))
7923 error ("%s: could not determine length of compare-debug file %s",
7924 gcc_input_filename
, cmpfile
[i
]);
7929 length
[i
] = st
.st_size
;
7932 if (!ret
&& length
[0] != length
[1])
7934 error ("%s: %<-fcompare-debug%> failure (length)", gcc_input_filename
);
7939 for (i
= 0; i
< 2; i
++)
7941 int fd
= open (cmpfile
[i
], O_RDONLY
);
7944 error ("%s: could not open compare-debug file %s",
7945 gcc_input_filename
, cmpfile
[i
]);
7950 map
[i
] = mmap (NULL
, length
[i
], PROT_READ
, MAP_PRIVATE
, fd
, 0);
7953 if (map
[i
] == (void *) MAP_FAILED
)
7962 if (memcmp (map
[0], map
[1], length
[0]) != 0)
7964 error ("%s: %<-fcompare-debug%> failure", gcc_input_filename
);
7969 for (i
= 0; i
< 2; i
++)
7971 munmap ((caddr_t
) map
[i
], length
[i
]);
7980 for (i
= 0; i
< 2; i
++)
7982 temp
[i
] = fopen (cmpfile
[i
], "r");
7985 error ("%s: could not open compare-debug file %s",
7986 gcc_input_filename
, cmpfile
[i
]);
7992 if (!ret
&& temp
[0] && temp
[1])
7996 c0
= fgetc (temp
[0]);
7997 c1
= fgetc (temp
[1]);
8001 error ("%s: %<-fcompare-debug%> failure",
8002 gcc_input_filename
);
8011 for (i
= 1; i
>= 0; i
--)
8020 driver::driver (bool can_finalize
, bool debug
) :
8021 explicit_link_files (NULL
),
8022 decoded_options (NULL
)
8024 env
.init (can_finalize
, debug
);
8029 XDELETEVEC (explicit_link_files
);
8030 XDELETEVEC (decoded_options
);
8033 /* driver::main is implemented as a series of driver:: method calls. */
8036 driver::main (int argc
, char **argv
)
8040 set_progname (argv
[0]);
8041 expand_at_files (&argc
, &argv
);
8042 decode_argv (argc
, const_cast <const char **> (argv
));
8043 global_initializations ();
8044 build_multilib_strings ();
8046 putenv_COLLECT_AS_OPTIONS (assembler_options
);
8047 putenv_COLLECT_GCC (argv
[0]);
8048 maybe_putenv_COLLECT_LTO_WRAPPER ();
8049 maybe_putenv_OFFLOAD_TARGETS ();
8050 handle_unrecognized_options ();
8054 m_option_proposer
.suggest_completion (completion
);
8058 if (!maybe_print_and_exit ())
8061 early_exit
= prepare_infiles ();
8063 return get_exit_code ();
8065 do_spec_on_infiles ();
8066 maybe_run_linker (argv
[0]);
8068 return get_exit_code ();
8071 /* Locate the final component of argv[0] after any leading path, and set
8072 the program name accordingly. */
8075 driver::set_progname (const char *argv0
) const
8077 const char *p
= argv0
+ strlen (argv0
);
8078 while (p
!= argv0
&& !IS_DIR_SEPARATOR (p
[-1]))
8082 xmalloc_set_program_name (progname
);
8085 /* Expand any @ files within the command-line args,
8086 setting at_file_supplied if any were expanded. */
8089 driver::expand_at_files (int *argc
, char ***argv
) const
8091 char **old_argv
= *argv
;
8093 expandargv (argc
, argv
);
8095 /* Determine if any expansions were made. */
8096 if (*argv
!= old_argv
)
8097 at_file_supplied
= true;
8100 /* Decode the command-line arguments from argc/argv into the
8101 decoded_options array. */
8104 driver::decode_argv (int argc
, const char **argv
)
8106 init_opts_obstack ();
8107 init_options_struct (&global_options
, &global_options_set
);
8109 decode_cmdline_options_to_array (argc
, argv
,
8111 &decoded_options
, &decoded_options_count
);
8114 /* Perform various initializations and setup. */
8117 driver::global_initializations ()
8119 /* Unlock the stdio streams. */
8120 unlock_std_streams ();
8122 gcc_init_libintl ();
8124 diagnostic_initialize (global_dc
, 0);
8125 diagnostic_color_init (global_dc
);
8126 diagnostic_urls_init (global_dc
);
8128 #ifdef GCC_DRIVER_HOST_INITIALIZATION
8129 /* Perform host dependent initialization when needed. */
8130 GCC_DRIVER_HOST_INITIALIZATION
;
8133 if (atexit (delete_temp_files
) != 0)
8134 fatal_error (input_location
, "atexit failed");
8136 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
8137 signal (SIGINT
, fatal_signal
);
8139 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
8140 signal (SIGHUP
, fatal_signal
);
8142 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
8143 signal (SIGTERM
, fatal_signal
);
8145 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
8146 signal (SIGPIPE
, fatal_signal
);
8149 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
8150 receive the signal. A different setting is inheritable */
8151 signal (SIGCHLD
, SIG_DFL
);
8154 /* Parsing and gimplification sometimes need quite large stack.
8155 Increase stack size limits if possible. */
8156 stack_limit_increase (64 * 1024 * 1024);
8158 /* Allocate the argument vector. */
8161 obstack_init (&obstack
);
8164 /* Build multilib_select, et. al from the separate lines that make up each
8165 multilib selection. */
8168 driver::build_multilib_strings () const
8172 const char *const *q
= multilib_raw
;
8175 obstack_init (&multilib_obstack
);
8176 while ((p
= *q
++) != (char *) 0)
8177 obstack_grow (&multilib_obstack
, p
, strlen (p
));
8179 obstack_1grow (&multilib_obstack
, 0);
8180 multilib_select
= XOBFINISH (&multilib_obstack
, const char *);
8182 q
= multilib_matches_raw
;
8183 while ((p
= *q
++) != (char *) 0)
8184 obstack_grow (&multilib_obstack
, p
, strlen (p
));
8186 obstack_1grow (&multilib_obstack
, 0);
8187 multilib_matches
= XOBFINISH (&multilib_obstack
, const char *);
8189 q
= multilib_exclusions_raw
;
8190 while ((p
= *q
++) != (char *) 0)
8191 obstack_grow (&multilib_obstack
, p
, strlen (p
));
8193 obstack_1grow (&multilib_obstack
, 0);
8194 multilib_exclusions
= XOBFINISH (&multilib_obstack
, const char *);
8196 q
= multilib_reuse_raw
;
8197 while ((p
= *q
++) != (char *) 0)
8198 obstack_grow (&multilib_obstack
, p
, strlen (p
));
8200 obstack_1grow (&multilib_obstack
, 0);
8201 multilib_reuse
= XOBFINISH (&multilib_obstack
, const char *);
8204 for (size_t i
= 0; i
< ARRAY_SIZE (multilib_defaults_raw
); i
++)
8207 obstack_1grow (&multilib_obstack
, ' ');
8208 obstack_grow (&multilib_obstack
,
8209 multilib_defaults_raw
[i
],
8210 strlen (multilib_defaults_raw
[i
]));
8214 obstack_1grow (&multilib_obstack
, 0);
8215 multilib_defaults
= XOBFINISH (&multilib_obstack
, const char *);
8219 /* Set up the spec-handling machinery. */
8222 driver::set_up_specs () const
8224 const char *spec_machine_suffix
;
8228 #ifdef INIT_ENVIRONMENT
8229 /* Set up any other necessary machine specific environment variables. */
8230 xputenv (INIT_ENVIRONMENT
);
8233 /* Make a table of what switches there are (switches, n_switches).
8234 Make a table of specified input files (infiles, n_infiles).
8235 Decode switches that are handled locally. */
8237 process_command (decoded_options_count
, decoded_options
);
8239 /* Initialize the vector of specs to just the default.
8240 This means one element containing 0s, as a terminator. */
8242 compilers
= XNEWVAR (struct compiler
, sizeof default_compilers
);
8243 memcpy (compilers
, default_compilers
, sizeof default_compilers
);
8244 n_compilers
= n_default_compilers
;
8246 /* Read specs from a file if there is one. */
8248 machine_suffix
= concat (spec_host_machine
, dir_separator_str
, spec_version
,
8249 accel_dir_suffix
, dir_separator_str
, NULL
);
8250 just_machine_suffix
= concat (spec_machine
, dir_separator_str
, NULL
);
8252 specs_file
= find_a_file (&startfile_prefixes
, "specs", R_OK
, true);
8253 /* Read the specs file unless it is a default one. */
8254 if (specs_file
!= 0 && strcmp (specs_file
, "specs"))
8255 read_specs (specs_file
, true, false);
8259 #ifdef ACCEL_COMPILER
8260 spec_machine_suffix
= machine_suffix
;
8262 spec_machine_suffix
= just_machine_suffix
;
8265 /* We need to check standard_exec_prefix/spec_machine_suffix/specs
8266 for any override of as, ld and libraries. */
8267 specs_file
= (char *) alloca (strlen (standard_exec_prefix
)
8268 + strlen (spec_machine_suffix
) + sizeof ("specs"));
8269 strcpy (specs_file
, standard_exec_prefix
);
8270 strcat (specs_file
, spec_machine_suffix
);
8271 strcat (specs_file
, "specs");
8272 if (access (specs_file
, R_OK
) == 0)
8273 read_specs (specs_file
, true, false);
8275 /* Process any configure-time defaults specified for the command line
8276 options, via OPTION_DEFAULT_SPECS. */
8277 for (i
= 0; i
< ARRAY_SIZE (option_default_specs
); i
++)
8278 do_option_spec (option_default_specs
[i
].name
,
8279 option_default_specs
[i
].spec
);
8281 /* Process DRIVER_SELF_SPECS, adding any new options to the end
8282 of the command line. */
8284 for (i
= 0; i
< ARRAY_SIZE (driver_self_specs
); i
++)
8285 do_self_spec (driver_self_specs
[i
]);
8287 /* If not cross-compiling, look for executables in the standard
8289 if (*cross_compile
== '0')
8291 if (*md_exec_prefix
)
8293 add_prefix (&exec_prefixes
, md_exec_prefix
, "GCC",
8294 PREFIX_PRIORITY_LAST
, 0, 0);
8298 /* Process sysroot_suffix_spec. */
8299 if (*sysroot_suffix_spec
!= 0
8300 && !no_sysroot_suffix
8301 && do_spec_2 (sysroot_suffix_spec
, NULL
) == 0)
8303 if (argbuf
.length () > 1)
8304 error ("spec failure: more than one argument to "
8305 "%<SYSROOT_SUFFIX_SPEC%>");
8306 else if (argbuf
.length () == 1)
8307 target_sysroot_suffix
= xstrdup (argbuf
.last ());
8310 #ifdef HAVE_LD_SYSROOT
8311 /* Pass the --sysroot option to the linker, if it supports that. If
8312 there is a sysroot_suffix_spec, it has already been processed by
8313 this point, so target_system_root really is the system root we
8315 if (target_system_root
)
8317 obstack_grow (&obstack
, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
8318 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
8319 set_spec ("link", XOBFINISH (&obstack
, const char *), false);
8323 /* Process sysroot_hdrs_suffix_spec. */
8324 if (*sysroot_hdrs_suffix_spec
!= 0
8325 && !no_sysroot_suffix
8326 && do_spec_2 (sysroot_hdrs_suffix_spec
, NULL
) == 0)
8328 if (argbuf
.length () > 1)
8329 error ("spec failure: more than one argument "
8330 "to %<SYSROOT_HEADERS_SUFFIX_SPEC%>");
8331 else if (argbuf
.length () == 1)
8332 target_sysroot_hdrs_suffix
= xstrdup (argbuf
.last ());
8335 /* Look for startfiles in the standard places. */
8336 if (*startfile_prefix_spec
!= 0
8337 && do_spec_2 (startfile_prefix_spec
, NULL
) == 0
8338 && do_spec_1 (" ", 0, NULL
) == 0)
8342 FOR_EACH_VEC_ELT (argbuf
, ndx
, arg
)
8343 add_sysrooted_prefix (&startfile_prefixes
, arg
, "BINUTILS",
8344 PREFIX_PRIORITY_LAST
, 0, 1);
8346 /* We should eventually get rid of all these and stick to
8347 startfile_prefix_spec exclusively. */
8348 else if (*cross_compile
== '0' || target_system_root
)
8350 if (*md_startfile_prefix
)
8351 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix
,
8352 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
8354 if (*md_startfile_prefix_1
)
8355 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix_1
,
8356 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
8358 /* If standard_startfile_prefix is relative, base it on
8359 standard_exec_prefix. This lets us move the installed tree
8360 as a unit. If GCC_EXEC_PREFIX is defined, base
8361 standard_startfile_prefix on that as well.
8363 If the prefix is relative, only search it for native compilers;
8364 otherwise we will search a directory containing host libraries. */
8365 if (IS_ABSOLUTE_PATH (standard_startfile_prefix
))
8366 add_sysrooted_prefix (&startfile_prefixes
,
8367 standard_startfile_prefix
, "BINUTILS",
8368 PREFIX_PRIORITY_LAST
, 0, 1);
8369 else if (*cross_compile
== '0')
8371 add_prefix (&startfile_prefixes
,
8372 concat (gcc_exec_prefix
8373 ? gcc_exec_prefix
: standard_exec_prefix
,
8375 standard_startfile_prefix
, NULL
),
8376 NULL
, PREFIX_PRIORITY_LAST
, 0, 1);
8379 /* Sysrooted prefixes are relocated because target_system_root is
8380 also relocated by gcc_exec_prefix. */
8381 if (*standard_startfile_prefix_1
)
8382 add_sysrooted_prefix (&startfile_prefixes
,
8383 standard_startfile_prefix_1
, "BINUTILS",
8384 PREFIX_PRIORITY_LAST
, 0, 1);
8385 if (*standard_startfile_prefix_2
)
8386 add_sysrooted_prefix (&startfile_prefixes
,
8387 standard_startfile_prefix_2
, "BINUTILS",
8388 PREFIX_PRIORITY_LAST
, 0, 1);
8391 /* Process any user specified specs in the order given on the command
8393 for (struct user_specs
*uptr
= user_specs_head
; uptr
; uptr
= uptr
->next
)
8395 char *filename
= find_a_file (&startfile_prefixes
, uptr
->filename
,
8397 read_specs (filename
? filename
: uptr
->filename
, false, true);
8400 /* Process any user self specs. */
8402 struct spec_list
*sl
;
8403 for (sl
= specs
; sl
; sl
= sl
->next
)
8404 if (sl
->name_len
== sizeof "self_spec" - 1
8405 && !strcmp (sl
->name
, "self_spec"))
8406 do_self_spec (*sl
->ptr_spec
);
8411 enum save_temps save
;
8413 if (!compare_debug_second
)
8415 n_switches_debug_check
[1] = n_switches
;
8416 n_switches_alloc_debug_check
[1] = n_switches_alloc
;
8417 switches_debug_check
[1] = XDUPVEC (struct switchstr
, switches
,
8420 do_self_spec ("%:compare-debug-self-opt()");
8421 n_switches_debug_check
[0] = n_switches
;
8422 n_switches_alloc_debug_check
[0] = n_switches_alloc
;
8423 switches_debug_check
[0] = switches
;
8425 n_switches
= n_switches_debug_check
[1];
8426 n_switches_alloc
= n_switches_alloc_debug_check
[1];
8427 switches
= switches_debug_check
[1];
8430 /* Avoid crash when computing %j in this early. */
8431 save
= save_temps_flag
;
8432 save_temps_flag
= SAVE_TEMPS_NONE
;
8434 compare_debug
= -compare_debug
;
8435 do_self_spec ("%:compare-debug-self-opt()");
8437 save_temps_flag
= save
;
8439 if (!compare_debug_second
)
8441 n_switches_debug_check
[1] = n_switches
;
8442 n_switches_alloc_debug_check
[1] = n_switches_alloc
;
8443 switches_debug_check
[1] = switches
;
8444 compare_debug
= -compare_debug
;
8445 n_switches
= n_switches_debug_check
[0];
8446 n_switches_alloc
= n_switches_debug_check
[0];
8447 switches
= switches_debug_check
[0];
8452 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
8453 if (gcc_exec_prefix
)
8454 gcc_exec_prefix
= concat (gcc_exec_prefix
, spec_host_machine
,
8455 dir_separator_str
, spec_version
,
8456 accel_dir_suffix
, dir_separator_str
, NULL
);
8458 /* Now we have the specs.
8459 Set the `valid' bits for switches that match anything in any spec. */
8461 validate_all_switches ();
8463 /* Now that we have the switches and the specs, set
8464 the subdirectory based on the options. */
8465 set_multilib_dir ();
8468 /* Set up to remember the pathname of gcc and any options
8469 needed for collect. We use argv[0] instead of progname because
8470 we need the complete pathname. */
8473 driver::putenv_COLLECT_GCC (const char *argv0
) const
8475 obstack_init (&collect_obstack
);
8476 obstack_grow (&collect_obstack
, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
8477 obstack_grow (&collect_obstack
, argv0
, strlen (argv0
) + 1);
8478 xputenv (XOBFINISH (&collect_obstack
, char *));
8481 /* Set up to remember the pathname of the lto wrapper. */
8484 driver::maybe_putenv_COLLECT_LTO_WRAPPER () const
8486 char *lto_wrapper_file
;
8489 lto_wrapper_file
= NULL
;
8491 lto_wrapper_file
= find_a_file (&exec_prefixes
, "lto-wrapper",
8493 if (lto_wrapper_file
)
8495 lto_wrapper_file
= convert_white_space (lto_wrapper_file
);
8496 set_static_spec_owned (<o_wrapper_spec
, lto_wrapper_file
);
8497 obstack_init (&collect_obstack
);
8498 obstack_grow (&collect_obstack
, "COLLECT_LTO_WRAPPER=",
8499 sizeof ("COLLECT_LTO_WRAPPER=") - 1);
8500 obstack_grow (&collect_obstack
, lto_wrapper_spec
,
8501 strlen (lto_wrapper_spec
) + 1);
8502 xputenv (XOBFINISH (&collect_obstack
, char *));
8507 /* Set up to remember the names of offload targets. */
8510 driver::maybe_putenv_OFFLOAD_TARGETS () const
8512 if (offload_targets
&& offload_targets
[0] != '\0')
8514 obstack_grow (&collect_obstack
, "OFFLOAD_TARGET_NAMES=",
8515 sizeof ("OFFLOAD_TARGET_NAMES=") - 1);
8516 obstack_grow (&collect_obstack
, offload_targets
,
8517 strlen (offload_targets
) + 1);
8518 xputenv (XOBFINISH (&collect_obstack
, char *));
8521 free (offload_targets
);
8522 offload_targets
= NULL
;
8525 /* Reject switches that no pass was interested in. */
8528 driver::handle_unrecognized_options ()
8530 for (size_t i
= 0; (int) i
< n_switches
; i
++)
8531 if (! switches
[i
].validated
)
8533 const char *hint
= m_option_proposer
.suggest_option (switches
[i
].part1
);
8535 error ("unrecognized command-line option %<-%s%>;"
8536 " did you mean %<-%s%>?",
8537 switches
[i
].part1
, hint
);
8539 error ("unrecognized command-line option %<-%s%>",
8544 /* Handle the various -print-* options, returning 0 if the driver
8545 should exit, or nonzero if the driver should continue. */
8548 driver::maybe_print_and_exit () const
8550 if (print_search_dirs
)
8552 printf (_("install: %s%s\n"),
8553 gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
8554 gcc_exec_prefix
? "" : machine_suffix
);
8555 printf (_("programs: %s\n"),
8556 build_search_list (&exec_prefixes
, "", false, false));
8557 printf (_("libraries: %s\n"),
8558 build_search_list (&startfile_prefixes
, "", false, true));
8562 if (print_file_name
)
8564 printf ("%s\n", find_file (print_file_name
));
8568 if (print_prog_name
)
8570 if (use_ld
!= NULL
&& ! strcmp (print_prog_name
, "ld"))
8572 /* Append USE_LD to the default linker. */
8573 #ifdef DEFAULT_LINKER
8575 # ifdef HAVE_HOST_EXECUTABLE_SUFFIX
8576 int len
= (sizeof (DEFAULT_LINKER
)
8577 - sizeof (HOST_EXECUTABLE_SUFFIX
));
8581 char *default_linker
= xstrdup (DEFAULT_LINKER
);
8582 /* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains
8583 HOST_EXECUTABLE_SUFFIX. */
8584 if (! strcmp (&default_linker
[len
], HOST_EXECUTABLE_SUFFIX
))
8586 default_linker
[len
] = '\0';
8587 ld
= concat (default_linker
, use_ld
,
8588 HOST_EXECUTABLE_SUFFIX
, NULL
);
8593 ld
= concat (DEFAULT_LINKER
, use_ld
, NULL
);
8594 if (access (ld
, X_OK
) == 0)
8596 printf ("%s\n", ld
);
8600 print_prog_name
= concat (print_prog_name
, use_ld
, NULL
);
8602 char *newname
= find_a_file (&exec_prefixes
, print_prog_name
, X_OK
, 0);
8603 printf ("%s\n", (newname
? newname
: print_prog_name
));
8607 if (print_multi_lib
)
8609 print_multilib_info ();
8613 if (print_multi_directory
)
8615 if (multilib_dir
== NULL
)
8618 printf ("%s\n", multilib_dir
);
8622 if (print_multiarch
)
8624 if (multiarch_dir
== NULL
)
8627 printf ("%s\n", multiarch_dir
);
8633 if (target_system_root
)
8635 if (target_sysroot_suffix
)
8636 printf ("%s%s\n", target_system_root
, target_sysroot_suffix
);
8638 printf ("%s\n", target_system_root
);
8643 if (print_multi_os_directory
)
8645 if (multilib_os_dir
== NULL
)
8648 printf ("%s\n", multilib_os_dir
);
8652 if (print_sysroot_headers_suffix
)
8654 if (*sysroot_hdrs_suffix_spec
)
8656 printf("%s\n", (target_sysroot_hdrs_suffix
8657 ? target_sysroot_hdrs_suffix
8662 /* The error status indicates that only one set of fixed
8663 headers should be built. */
8664 fatal_error (input_location
,
8665 "not configured with sysroot headers suffix");
8668 if (print_help_list
)
8674 printf (_("\nFor bug reporting instructions, please see:\n"));
8675 printf ("%s.\n", bug_report_url
);
8680 /* We do not exit here. Instead we have created a fake input file
8681 called 'help-dummy' which needs to be compiled, and we pass this
8682 on the various sub-processes, along with the --help switch.
8683 Ensure their output appears after ours. */
8684 fputc ('\n', stdout
);
8690 printf (_("%s %s%s\n"), progname
, pkgversion_string
,
8692 printf ("Copyright %s 2021 Free Software Foundation, Inc.\n",
8694 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
8695 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
8700 /* We do not exit here. We use the same mechanism of --help to print
8701 the version of the sub-processes. */
8702 fputc ('\n', stdout
);
8708 print_configuration (stderr
);
8716 /* Figure out what to do with each input file.
8717 Return true if we need to exit early from "main", false otherwise. */
8720 driver::prepare_infiles ()
8723 int lang_n_infiles
= 0;
8725 if (n_infiles
== added_libraries
)
8726 fatal_error (input_location
, "no input files");
8729 /* Early exit needed from main. */
8732 /* Make a place to record the compiler output file names
8733 that correspond to the input files. */
8736 i
+= lang_specific_extra_outfiles
;
8737 outfiles
= XCNEWVEC (const char *, i
);
8739 /* Record which files were specified explicitly as link input. */
8741 explicit_link_files
= XCNEWVEC (char, n_infiles
);
8743 combine_inputs
= have_o
|| flag_wpa
;
8745 for (i
= 0; (int) i
< n_infiles
; i
++)
8747 const char *name
= infiles
[i
].name
;
8748 struct compiler
*compiler
= lookup_compiler (name
,
8750 infiles
[i
].language
);
8752 if (compiler
&& !(compiler
->combinable
))
8753 combine_inputs
= false;
8755 if (lang_n_infiles
> 0 && compiler
!= input_file_compiler
8756 && infiles
[i
].language
&& infiles
[i
].language
[0] != '*')
8757 infiles
[i
].incompiler
= compiler
;
8761 input_file_compiler
= compiler
;
8762 infiles
[i
].incompiler
= compiler
;
8766 /* Since there is no compiler for this input file, assume it is a
8768 explicit_link_files
[i
] = 1;
8769 infiles
[i
].incompiler
= NULL
;
8771 infiles
[i
].compiled
= false;
8772 infiles
[i
].preprocessed
= false;
8775 if (!combine_inputs
&& have_c
&& have_o
&& lang_n_infiles
> 1)
8776 fatal_error (input_location
,
8777 "cannot specify %<-o%> with %<-c%>, %<-S%> or %<-E%> "
8778 "with multiple files");
8780 /* No early exit needed from main; we can continue. */
8784 /* Run the spec machinery on each input file. */
8787 driver::do_spec_on_infiles () const
8791 for (i
= 0; (int) i
< n_infiles
; i
++)
8793 int this_file_error
= 0;
8795 /* Tell do_spec what to substitute for %i. */
8797 input_file_number
= i
;
8798 set_input (infiles
[i
].name
);
8800 if (infiles
[i
].compiled
)
8803 /* Use the same thing in %o, unless cp->spec says otherwise. */
8805 outfiles
[i
] = gcc_input_filename
;
8807 /* Figure out which compiler from the file's suffix. */
8810 = lookup_compiler (infiles
[i
].name
, input_filename_length
,
8811 infiles
[i
].language
);
8813 if (input_file_compiler
)
8815 /* Ok, we found an applicable compiler. Run its spec. */
8817 if (input_file_compiler
->spec
[0] == '#')
8819 error ("%s: %s compiler not installed on this system",
8820 gcc_input_filename
, &input_file_compiler
->spec
[1]);
8821 this_file_error
= 1;
8829 free (debug_check_temp_file
[0]);
8830 debug_check_temp_file
[0] = NULL
;
8832 free (debug_check_temp_file
[1]);
8833 debug_check_temp_file
[1] = NULL
;
8836 value
= do_spec (input_file_compiler
->spec
);
8837 infiles
[i
].compiled
= true;
8839 this_file_error
= 1;
8840 else if (compare_debug
&& debug_check_temp_file
[0])
8843 inform (UNKNOWN_LOCATION
,
8844 "recompiling with %<-fcompare-debug%>");
8846 compare_debug
= -compare_debug
;
8847 n_switches
= n_switches_debug_check
[1];
8848 n_switches_alloc
= n_switches_alloc_debug_check
[1];
8849 switches
= switches_debug_check
[1];
8851 value
= do_spec (input_file_compiler
->spec
);
8853 compare_debug
= -compare_debug
;
8854 n_switches
= n_switches_debug_check
[0];
8855 n_switches_alloc
= n_switches_alloc_debug_check
[0];
8856 switches
= switches_debug_check
[0];
8860 error ("during %<-fcompare-debug%> recompilation");
8861 this_file_error
= 1;
8864 gcc_assert (debug_check_temp_file
[1]
8865 && filename_cmp (debug_check_temp_file
[0],
8866 debug_check_temp_file
[1]));
8869 inform (UNKNOWN_LOCATION
, "comparing final insns dumps");
8871 if (compare_files (debug_check_temp_file
))
8872 this_file_error
= 1;
8877 free (debug_check_temp_file
[0]);
8878 debug_check_temp_file
[0] = NULL
;
8880 free (debug_check_temp_file
[1]);
8881 debug_check_temp_file
[1] = NULL
;
8886 /* If this file's name does not contain a recognized suffix,
8887 record it as explicit linker input. */
8890 explicit_link_files
[i
] = 1;
8892 /* Clear the delete-on-failure queue, deleting the files in it
8893 if this compilation failed. */
8895 if (this_file_error
)
8897 delete_failure_queue ();
8900 /* If this compilation succeeded, don't delete those files later. */
8901 clear_failure_queue ();
8904 /* Reset the input file name to the first compile/object file name, for use
8905 with %b in LINK_SPEC. We use the first input file that we can find
8906 a compiler to compile it instead of using infiles.language since for
8907 languages other than C we use aliases that we then lookup later. */
8912 for (i
= 0; i
< n_infiles
; i
++)
8913 if (infiles
[i
].incompiler
8914 || (infiles
[i
].language
&& infiles
[i
].language
[0] != '*'))
8916 set_input (infiles
[i
].name
);
8923 /* Make sure INPUT_FILE_NUMBER points to first available open
8925 input_file_number
= n_infiles
;
8926 if (lang_specific_pre_link ())
8931 /* If we have to run the linker, do it now. */
8934 driver::maybe_run_linker (const char *argv0
) const
8937 int linker_was_run
= 0;
8938 int num_linker_inputs
;
8940 /* Determine if there are any linker input files. */
8941 num_linker_inputs
= 0;
8942 for (i
= 0; (int) i
< n_infiles
; i
++)
8943 if (explicit_link_files
[i
] || outfiles
[i
] != NULL
)
8944 num_linker_inputs
++;
8946 /* Arrange for temporary file names created during linking to take
8947 on names related with the linker output rather than with the
8948 inputs when appropriate. */
8949 if (outbase
&& *outbase
)
8953 char *tofree
= dumpdir
;
8954 gcc_checking_assert (strlen (dumpdir
) == dumpdir_length
);
8955 dumpdir
= concat (dumpdir
, outbase
, ".", NULL
);
8959 dumpdir
= concat (outbase
, ".", NULL
);
8960 dumpdir_length
+= strlen (outbase
) + 1;
8961 dumpdir_trailing_dash_added
= true;
8963 else if (dumpdir_trailing_dash_added
)
8965 gcc_assert (dumpdir
[dumpdir_length
- 1] == '-');
8966 dumpdir
[dumpdir_length
- 1] = '.';
8969 if (dumpdir_trailing_dash_added
)
8971 gcc_assert (dumpdir_length
> 0);
8972 gcc_assert (dumpdir
[dumpdir_length
- 1] == '.');
8977 input_basename
= outbase
= NULL
;
8978 outbase_length
= suffixed_basename_length
= basename_length
= 0;
8980 /* Run ld to link all the compiler output files. */
8982 if (num_linker_inputs
> 0 && !seen_error () && print_subprocess_help
< 2)
8984 int tmp
= execution_count
;
8986 detect_jobserver ();
8990 #if HAVE_LTO_PLUGIN > 0
8991 #if HAVE_LTO_PLUGIN == 2
8992 const char *fno_use_linker_plugin
= "fno-use-linker-plugin";
8994 const char *fuse_linker_plugin
= "fuse-linker-plugin";
8998 /* We'll use ld if we can't find collect2. */
8999 if (! strcmp (linker_name_spec
, "collect2"))
9001 char *s
= find_a_file (&exec_prefixes
, "collect2", X_OK
, false);
9003 set_static_spec_shared (&linker_name_spec
, "ld");
9006 #if HAVE_LTO_PLUGIN > 0
9007 #if HAVE_LTO_PLUGIN == 2
9008 if (!switch_matches (fno_use_linker_plugin
,
9009 fno_use_linker_plugin
9010 + strlen (fno_use_linker_plugin
), 0))
9012 if (switch_matches (fuse_linker_plugin
,
9014 + strlen (fuse_linker_plugin
), 0))
9017 char *temp_spec
= find_a_file (&exec_prefixes
,
9018 LTOPLUGINSONAME
, R_OK
,
9021 fatal_error (input_location
,
9022 "%<-fuse-linker-plugin%>, but %s not found",
9024 linker_plugin_file_spec
= convert_white_space (temp_spec
);
9027 set_static_spec_shared (<o_gcc_spec
, argv0
);
9030 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
9032 putenv_from_prefixes (&exec_prefixes
, "COMPILER_PATH", false);
9033 putenv_from_prefixes (&startfile_prefixes
, LIBRARY_PATH_ENV
, true);
9035 if (print_subprocess_help
== 1)
9037 printf (_("\nLinker options\n==============\n\n"));
9038 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
9039 " to the linker.\n\n"));
9042 int value
= do_spec (link_command_spec
);
9045 linker_was_run
= (tmp
!= execution_count
);
9048 /* If options said don't run linker,
9049 complain about input files to be given to the linker. */
9051 if (! linker_was_run
&& !seen_error ())
9052 for (i
= 0; (int) i
< n_infiles
; i
++)
9053 if (explicit_link_files
[i
]
9054 && !(infiles
[i
].language
&& infiles
[i
].language
[0] == '*'))
9055 warning (0, "%s: linker input file unused because linking not done",
9059 /* The end of "main". */
9062 driver::final_actions () const
9064 /* Delete some or all of the temporary files we made. */
9067 delete_failure_queue ();
9068 delete_temp_files ();
9070 if (print_help_list
)
9072 printf (("\nFor bug reporting instructions, please see:\n"));
9073 printf ("%s\n", bug_report_url
);
9077 /* Detect whether jobserver is active and working. If not drop
9078 --jobserver-auth from MAKEFLAGS. */
9081 driver::detect_jobserver () const
9083 /* Detect jobserver and drop it if it's not working. */
9084 const char *makeflags
= env
.get ("MAKEFLAGS");
9085 if (makeflags
!= NULL
)
9087 const char *needle
= "--jobserver-auth=";
9088 const char *n
= strstr (makeflags
, needle
);
9095 = (sscanf (n
+ strlen (needle
), "%d,%d", &rfd
, &wfd
) == 2
9098 && is_valid_fd (rfd
)
9099 && is_valid_fd (wfd
));
9101 /* Drop the jobserver if it's not working now. */
9104 unsigned offset
= n
- makeflags
;
9105 char *dup
= xstrdup (makeflags
);
9108 const char *space
= strchr (makeflags
+ offset
, ' ');
9110 strcpy (dup
+ offset
, space
);
9111 xputenv (concat ("MAKEFLAGS=", dup
, NULL
));
9117 /* Determine what the exit code of the driver should be. */
9120 driver::get_exit_code () const
9122 return (signal_count
!= 0 ? 2
9123 : seen_error () ? (pass_exit_codes
? greatest_status
: 1)
9127 /* Find the proper compilation spec for the file name NAME,
9128 whose length is LENGTH. LANGUAGE is the specified language,
9129 or 0 if this file is to be passed to the linker. */
9131 static struct compiler
*
9132 lookup_compiler (const char *name
, size_t length
, const char *language
)
9134 struct compiler
*cp
;
9136 /* If this was specified by the user to be a linker input, indicate that. */
9137 if (language
!= 0 && language
[0] == '*')
9140 /* Otherwise, look for the language, if one is spec'd. */
9143 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
9144 if (cp
->suffix
[0] == '@' && !strcmp (cp
->suffix
+ 1, language
))
9146 if (name
!= NULL
&& strcmp (name
, "-") == 0
9147 && (strcmp (cp
->suffix
, "@c-header") == 0
9148 || strcmp (cp
->suffix
, "@c++-header") == 0)
9150 fatal_error (input_location
,
9151 "cannot use %<-%> as input filename for a "
9152 "precompiled header");
9157 error ("language %s not recognized", language
);
9161 /* Look for a suffix. */
9162 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
9164 if (/* The suffix `-' matches only the file name `-'. */
9165 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
9166 || (strlen (cp
->suffix
) < length
9167 /* See if the suffix matches the end of NAME. */
9168 && !strcmp (cp
->suffix
,
9169 name
+ length
- strlen (cp
->suffix
))
9174 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
9175 /* Look again, but case-insensitively this time. */
9177 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
9179 if (/* The suffix `-' matches only the file name `-'. */
9180 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
9181 || (strlen (cp
->suffix
) < length
9182 /* See if the suffix matches the end of NAME. */
9183 && ((!strcmp (cp
->suffix
,
9184 name
+ length
- strlen (cp
->suffix
))
9185 || !strpbrk (cp
->suffix
, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
9186 && !strcasecmp (cp
->suffix
,
9187 name
+ length
- strlen (cp
->suffix
)))
9193 if (cp
>= compilers
)
9195 if (cp
->spec
[0] != '@')
9196 /* A non-alias entry: return it. */
9199 /* An alias entry maps a suffix to a language.
9200 Search for the language; pass 0 for NAME and LENGTH
9201 to avoid infinite recursion if language not found. */
9202 return lookup_compiler (NULL
, 0, cp
->spec
+ 1);
9208 save_string (const char *s
, int len
)
9210 char *result
= XNEWVEC (char, len
+ 1);
9212 gcc_checking_assert (strlen (s
) >= (unsigned int) len
);
9213 memcpy (result
, s
, len
);
9220 validate_switches_from_spec (const char *spec
, bool user
)
9222 const char *p
= spec
;
9228 || (*p
== 'W' && *++p
== '{')
9229 || (*p
== '@' && *++p
== '{')))
9230 /* We have a switch spec. */
9231 p
= validate_switches (p
+ 1, user
, *p
== '{');
9235 validate_all_switches (void)
9237 struct compiler
*comp
;
9238 struct spec_list
*spec
;
9240 for (comp
= compilers
; comp
->spec
; comp
++)
9241 validate_switches_from_spec (comp
->spec
, false);
9243 /* Look through the linked list of specs read from the specs file. */
9244 for (spec
= specs
; spec
; spec
= spec
->next
)
9245 validate_switches_from_spec (*spec
->ptr_spec
, spec
->user_p
);
9247 validate_switches_from_spec (link_command_spec
, false);
9250 /* Look at the switch-name that comes after START and mark as valid
9251 all supplied switches that match it. If BRACED, handle other
9252 switches after '|' and '&', and specs after ':' until ';' or '}',
9253 going back for more switches after ';'. Without BRACED, handle
9254 only one atom. Return a pointer to whatever follows the handled
9255 items, after the closing brace if BRACED. */
9258 validate_switches (const char *start
, bool user_spec
, bool braced
)
9260 const char *p
= start
;
9264 bool suffix
= false;
9265 bool starred
= false;
9267 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
9276 if (*p
== '.' || *p
== ',')
9280 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
9281 || *p
== ',' || *p
== '.' || *p
== '@')
9286 starred
= true, p
++;
9292 /* Mark all matching switches as valid. */
9293 for (i
= 0; i
< n_switches
; i
++)
9294 if (!strncmp (switches
[i
].part1
, atom
, len
)
9295 && (starred
|| switches
[i
].part1
[len
] == '\0')
9296 && (switches
[i
].known
|| user_spec
))
9297 switches
[i
].validated
= true;
9304 if (*p
&& (p
[-1] == '|' || p
[-1] == '&'))
9307 if (*p
&& p
[-1] == ':')
9309 while (*p
&& *p
!= ';' && *p
!= '}')
9314 if (*p
== '{' || *p
== '<')
9315 p
= validate_switches (p
+1, user_spec
, *p
== '{');
9316 else if (p
[0] == 'W' && p
[1] == '{')
9317 p
= validate_switches (p
+2, user_spec
, true);
9318 else if (p
[0] == '@' && p
[1] == '{')
9319 p
= validate_switches (p
+2, user_spec
, true);
9326 if (*p
&& p
[-1] == ';')
9340 static struct mdswitchstr
*mdswitches
;
9341 static int n_mdswitches
;
9343 /* Check whether a particular argument was used. The first time we
9344 canonicalize the switches to keep only the ones we care about. */
9349 int operator () (const char *p
, int len
);
9356 const char *replace
;
9361 mswitchstr
*mswitches
;
9366 used_arg_t used_arg
;
9369 used_arg_t::operator () (const char *p
, int len
)
9375 struct mswitchstr
*matches
;
9379 /* Break multilib_matches into the component strings of string
9380 and replacement string. */
9381 for (q
= multilib_matches
; *q
!= '\0'; q
++)
9386 = (struct mswitchstr
*) alloca ((sizeof (struct mswitchstr
)) * cnt
);
9388 q
= multilib_matches
;
9397 fatal_error (input_location
, "multilib spec %qs is invalid",
9402 matches
[i
].len
= q
- matches
[i
].str
;
9404 matches
[i
].replace
= ++q
;
9405 while (*q
!= ';' && *q
!= '\0')
9408 goto invalid_matches
;
9411 matches
[i
].rep_len
= q
- matches
[i
].replace
;
9417 /* Now build a list of the replacement string for switches that we care
9418 about. Make sure we allocate at least one entry. This prevents
9419 xmalloc from calling fatal, and prevents us from re-executing this
9422 = XNEWVEC (struct mswitchstr
, n_mdswitches
+ (n_switches
? n_switches
: 1));
9423 for (i
= 0; i
< n_switches
; i
++)
9424 if ((switches
[i
].live_cond
& SWITCH_IGNORE
) == 0)
9426 int xlen
= strlen (switches
[i
].part1
);
9427 for (j
= 0; j
< cnt
; j
++)
9428 if (xlen
== matches
[j
].len
9429 && ! strncmp (switches
[i
].part1
, matches
[j
].str
, xlen
))
9431 mswitches
[n_mswitches
].str
= matches
[j
].replace
;
9432 mswitches
[n_mswitches
].len
= matches
[j
].rep_len
;
9433 mswitches
[n_mswitches
].replace
= (char *) 0;
9434 mswitches
[n_mswitches
].rep_len
= 0;
9440 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
9441 on the command line nor any options mutually incompatible with
9443 for (i
= 0; i
< n_mdswitches
; i
++)
9447 for (q
= multilib_options
; *q
!= '\0'; *q
&& q
++)
9453 while (strncmp (q
, mdswitches
[i
].str
, mdswitches
[i
].len
) != 0
9454 || strchr (" /", q
[mdswitches
[i
].len
]) == NULL
)
9456 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
9463 if (*q
!= ' ' && *q
!= '\0')
9465 while (*r
!= ' ' && *r
!= '\0')
9468 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
9471 if (used_arg (r
, q
- r
))
9476 mswitches
[n_mswitches
].str
= mdswitches
[i
].str
;
9477 mswitches
[n_mswitches
].len
= mdswitches
[i
].len
;
9478 mswitches
[n_mswitches
].replace
= (char *) 0;
9479 mswitches
[n_mswitches
].rep_len
= 0;
9492 for (i
= 0; i
< n_mswitches
; i
++)
9493 if (len
== mswitches
[i
].len
&& ! strncmp (p
, mswitches
[i
].str
, len
))
9499 void used_arg_t::finalize ()
9501 XDELETEVEC (mswitches
);
9508 default_arg (const char *p
, int len
)
9512 for (i
= 0; i
< n_mdswitches
; i
++)
9513 if (len
== mdswitches
[i
].len
&& ! strncmp (p
, mdswitches
[i
].str
, len
))
9519 /* Work out the subdirectory to use based on the options. The format of
9520 multilib_select is a list of elements. Each element is a subdirectory
9521 name followed by a list of options followed by a semicolon. The format
9522 of multilib_exclusions is the same, but without the preceding
9523 directory. First gcc will check the exclusions, if none of the options
9524 beginning with an exclamation point are present, and all of the other
9525 options are present, then we will ignore this completely. Passing
9526 that, gcc will consider each multilib_select in turn using the same
9527 rules for matching the options. If a match is found, that subdirectory
9529 A subdirectory name is optionally followed by a colon and the corresponding
9533 set_multilib_dir (void)
9536 unsigned int this_path_len
;
9537 const char *this_path
, *this_arg
;
9538 const char *start
, *end
;
9540 int ok
, ndfltok
, first
;
9543 start
= multilib_defaults
;
9544 while (*start
== ' ' || *start
== '\t')
9546 while (*start
!= '\0')
9549 while (*start
!= ' ' && *start
!= '\t' && *start
!= '\0')
9551 while (*start
== ' ' || *start
== '\t')
9559 mdswitches
= XNEWVEC (struct mdswitchstr
, n_mdswitches
);
9560 for (start
= multilib_defaults
; *start
!= '\0'; start
= end
+ 1)
9562 while (*start
== ' ' || *start
== '\t')
9568 for (end
= start
+ 1;
9569 *end
!= ' ' && *end
!= '\t' && *end
!= '\0'; end
++)
9572 obstack_grow (&multilib_obstack
, start
, end
- start
);
9573 obstack_1grow (&multilib_obstack
, 0);
9574 mdswitches
[i
].str
= XOBFINISH (&multilib_obstack
, const char *);
9575 mdswitches
[i
++].len
= end
- start
;
9582 p
= multilib_exclusions
;
9585 /* Ignore newlines. */
9592 /* Check the arguments. */
9599 fatal_error (input_location
, "multilib exclusions %qs is invalid",
9600 multilib_exclusions
);
9610 while (*p
!= ' ' && *p
!= ';')
9613 goto invalid_exclusions
;
9617 if (*this_arg
!= '!')
9625 ok
= used_arg (this_arg
, p
- this_arg
);
9640 p
= multilib_select
;
9642 /* Append multilib reuse rules if any. With those rules, we can reuse
9643 one multilib for certain different options sets. */
9644 if (strlen (multilib_reuse
) > 0)
9645 p
= concat (p
, multilib_reuse
, NULL
);
9649 /* Ignore newlines. */
9656 /* Get the initial path. */
9663 fatal_error (input_location
, "multilib select %qs %qs is invalid",
9664 multilib_select
, multilib_reuse
);
9668 this_path_len
= p
- this_path
;
9670 /* Check the arguments. */
9677 goto invalid_select
;
9686 while (*p
!= ' ' && *p
!= ';')
9689 goto invalid_select
;
9693 if (*this_arg
!= '!')
9701 /* If this is a default argument, we can just ignore it.
9702 This is true even if this_arg begins with '!'. Beginning
9703 with '!' does not mean that this argument is necessarily
9704 inappropriate for this library: it merely means that
9705 there is a more specific library which uses this
9706 argument. If this argument is a default, we need not
9707 consider that more specific library. */
9708 ok
= used_arg (this_arg
, p
- this_arg
);
9715 if (default_arg (this_arg
, p
- this_arg
))
9724 if (this_path_len
!= 1
9725 || this_path
[0] != '.')
9727 char *new_multilib_dir
= XNEWVEC (char, this_path_len
+ 1);
9730 strncpy (new_multilib_dir
, this_path
, this_path_len
);
9731 new_multilib_dir
[this_path_len
] = '\0';
9732 q
= strchr (new_multilib_dir
, ':');
9735 multilib_dir
= new_multilib_dir
;
9742 const char *q
= this_path
, *end
= this_path
+ this_path_len
;
9744 while (q
< end
&& *q
!= ':')
9748 const char *q2
= q
+ 1, *ml_end
= end
;
9749 char *new_multilib_os_dir
;
9751 while (q2
< end
&& *q2
!= ':')
9755 if (ml_end
- q
== 1)
9756 multilib_os_dir
= xstrdup (".");
9759 new_multilib_os_dir
= XNEWVEC (char, ml_end
- q
);
9760 memcpy (new_multilib_os_dir
, q
+ 1, ml_end
- q
- 1);
9761 new_multilib_os_dir
[ml_end
- q
- 1] = '\0';
9762 multilib_os_dir
= new_multilib_os_dir
;
9765 if (q2
< end
&& *q2
== ':')
9767 char *new_multiarch_dir
= XNEWVEC (char, end
- q2
);
9768 memcpy (new_multiarch_dir
, q2
+ 1, end
- q2
- 1);
9769 new_multiarch_dir
[end
- q2
- 1] = '\0';
9770 multiarch_dir
= new_multiarch_dir
;
9779 if (multilib_dir
== NULL
&& multilib_os_dir
!= NULL
9780 && strcmp (multilib_os_dir
, ".") == 0)
9782 free (CONST_CAST (char *, multilib_os_dir
));
9783 multilib_os_dir
= NULL
;
9785 else if (multilib_dir
!= NULL
&& multilib_os_dir
== NULL
)
9786 multilib_os_dir
= multilib_dir
;
9789 /* Print out the multiple library subdirectory selection
9790 information. This prints out a series of lines. Each line looks
9791 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
9792 required. Only the desired options are printed out, the negative
9793 matches. The options are print without a leading dash. There are
9794 no spaces to make it easy to use the information in the shell.
9795 Each subdirectory is printed only once. This assumes the ordering
9796 generated by the genmultilib script. Also, we leave out ones that match
9800 print_multilib_info (void)
9802 const char *p
= multilib_select
;
9803 const char *last_path
= 0, *this_path
;
9806 unsigned int last_path_len
= 0;
9811 /* Ignore newlines. */
9818 /* Get the initial path. */
9825 fatal_error (input_location
,
9826 "multilib select %qs is invalid", multilib_select
);
9832 /* When --disable-multilib was used but target defines
9833 MULTILIB_OSDIRNAMES, entries starting with .: (and not starting
9834 with .:: for multiarch configurations) are there just to find
9835 multilib_os_dir, so skip them from output. */
9836 if (this_path
[0] == '.' && this_path
[1] == ':' && this_path
[2] != ':')
9839 /* Check for matches with the multilib_exclusions. We don't bother
9840 with the '!' in either list. If any of the exclusion rules match
9841 all of its options with the select rule, we skip it. */
9843 const char *e
= multilib_exclusions
;
9844 const char *this_arg
;
9849 /* Ignore newlines. */
9856 /* Check the arguments. */
9865 fatal_error (input_location
,
9866 "multilib exclusion %qs is invalid",
9867 multilib_exclusions
);
9878 while (*e
!= ' ' && *e
!= ';')
9881 goto invalid_exclusion
;
9889 int len
= e
- this_arg
;
9892 goto invalid_select
;
9896 while (*q
!= ' ' && *q
!= ';')
9899 goto invalid_select
;
9903 if (! strncmp (arg
, this_arg
,
9904 (len
< q
- arg
) ? q
- arg
: len
)
9905 || default_arg (this_arg
, e
- this_arg
))
9935 /* If this is a duplicate, skip it. */
9936 skip
= (last_path
!= 0
9937 && (unsigned int) (p
- this_path
) == last_path_len
9938 && ! filename_ncmp (last_path
, this_path
, last_path_len
));
9940 last_path
= this_path
;
9941 last_path_len
= p
- this_path
;
9944 /* If this directory requires any default arguments, we can skip
9945 it. We will already have printed a directory identical to
9946 this one which does not require that default argument. */
9957 goto invalid_select
;
9968 while (*q
!= ' ' && *q
!= ';')
9971 goto invalid_select
;
9975 if (default_arg (arg
, q
- arg
))
9977 /* Stop checking if any default arguments appeared in not
9997 for (p1
= last_path
; p1
< p
&& *p1
!= ':'; p1
++)
10008 goto invalid_select
;
10016 use_arg
= *p
!= '!';
10021 while (*p
!= ' ' && *p
!= ';')
10024 goto invalid_select
;
10036 /* If there are extra options, print them now. */
10037 if (multilib_extra
&& *multilib_extra
)
10039 int print_at
= TRUE
;
10042 for (q
= multilib_extra
; *q
!= '\0'; q
++)
10063 /* getenv built-in spec function.
10065 Returns the value of the environment variable given by its first argument,
10066 concatenated with the second argument. If the variable is not defined, a
10067 fatal error is issued unless such undefs are internally allowed, in which
10068 case the variable name prefixed by a '/' is used as the variable value.
10070 The leading '/' allows using the result at a spot where a full path would
10071 normally be expected and when the actual value doesn't really matter since
10072 undef vars are allowed. */
10074 static const char *
10075 getenv_spec_function (int argc
, const char **argv
)
10078 const char *varname
;
10088 value
= env
.get (varname
);
10090 /* If the variable isn't defined and this is allowed, craft our expected
10091 return value. Assume variable names used in specs strings don't contain
10092 any active spec character so don't need escaping. */
10093 if (!value
&& spec_undefvar_allowed
)
10095 result
= XNEWVAR (char, strlen(varname
) + 2);
10096 sprintf (result
, "/%s", varname
);
10101 fatal_error (input_location
,
10102 "environment variable %qs not defined", varname
);
10104 /* We have to escape every character of the environment variable so
10105 they are not interpreted as active spec characters. A
10106 particularly painful case is when we are reading a variable
10107 holding a windows path complete with \ separators. */
10108 len
= strlen (value
) * 2 + strlen (argv
[1]) + 1;
10109 result
= XNEWVAR (char, len
);
10110 for (ptr
= result
; *value
; ptr
+= 2)
10116 strcpy (ptr
, argv
[1]);
10121 /* if-exists built-in spec function.
10123 Checks to see if the file specified by the absolute pathname in
10124 ARGS exists. Returns that pathname if found.
10126 The usual use for this function is to check for a library file
10127 (whose name has been expanded with %s). */
10129 static const char *
10130 if_exists_spec_function (int argc
, const char **argv
)
10132 /* Must have only one argument. */
10133 if (argc
== 1 && IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
10139 /* if-exists-else built-in spec function.
10141 This is like if-exists, but takes an additional argument which
10142 is returned if the first argument does not exist. */
10144 static const char *
10145 if_exists_else_spec_function (int argc
, const char **argv
)
10147 /* Must have exactly two arguments. */
10151 if (IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
10157 /* if-exists-then-else built-in spec function.
10159 Checks to see if the file specified by the absolute pathname in
10160 the first arg exists. Returns the second arg if so, otherwise returns
10161 the third arg if it is present. */
10163 static const char *
10164 if_exists_then_else_spec_function (int argc
, const char **argv
)
10167 /* Must have two or three arguments. */
10168 if (argc
!= 2 && argc
!= 3)
10171 if (IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
10180 /* sanitize built-in spec function.
10182 This returns non-NULL, if sanitizing address, thread or
10183 any of the undefined behavior sanitizers. */
10185 static const char *
10186 sanitize_spec_function (int argc
, const char **argv
)
10191 if (strcmp (argv
[0], "address") == 0)
10192 return (flag_sanitize
& SANITIZE_USER_ADDRESS
) ? "" : NULL
;
10193 if (strcmp (argv
[0], "hwaddress") == 0)
10194 return (flag_sanitize
& SANITIZE_USER_HWADDRESS
) ? "" : NULL
;
10195 if (strcmp (argv
[0], "kernel-address") == 0)
10196 return (flag_sanitize
& SANITIZE_KERNEL_ADDRESS
) ? "" : NULL
;
10197 if (strcmp (argv
[0], "kernel-hwaddress") == 0)
10198 return (flag_sanitize
& SANITIZE_KERNEL_HWADDRESS
) ? "" : NULL
;
10199 if (strcmp (argv
[0], "thread") == 0)
10200 return (flag_sanitize
& SANITIZE_THREAD
) ? "" : NULL
;
10201 if (strcmp (argv
[0], "undefined") == 0)
10202 return ((flag_sanitize
10203 & (SANITIZE_UNDEFINED
| SANITIZE_UNDEFINED_NONDEFAULT
))
10204 && !flag_sanitize_undefined_trap_on_error
) ? "" : NULL
;
10205 if (strcmp (argv
[0], "leak") == 0)
10206 return ((flag_sanitize
10207 & (SANITIZE_ADDRESS
| SANITIZE_LEAK
| SANITIZE_THREAD
))
10208 == SANITIZE_LEAK
) ? "" : NULL
;
10212 /* replace-outfile built-in spec function.
10214 This looks for the first argument in the outfiles array's name and
10215 replaces it with the second argument. */
10217 static const char *
10218 replace_outfile_spec_function (int argc
, const char **argv
)
10221 /* Must have exactly two arguments. */
10225 for (i
= 0; i
< n_infiles
; i
++)
10227 if (outfiles
[i
] && !filename_cmp (outfiles
[i
], argv
[0]))
10228 outfiles
[i
] = xstrdup (argv
[1]);
10233 /* remove-outfile built-in spec function.
10235 * This looks for the first argument in the outfiles array's name and
10238 static const char *
10239 remove_outfile_spec_function (int argc
, const char **argv
)
10242 /* Must have exactly one argument. */
10246 for (i
= 0; i
< n_infiles
; i
++)
10248 if (outfiles
[i
] && !filename_cmp (outfiles
[i
], argv
[0]))
10249 outfiles
[i
] = NULL
;
10254 /* Given two version numbers, compares the two numbers.
10255 A version number must match the regular expression
10256 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
10259 compare_version_strings (const char *v1
, const char *v2
)
10264 if (regcomp (&r
, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
10265 REG_EXTENDED
| REG_NOSUB
) != 0)
10267 rresult
= regexec (&r
, v1
, 0, NULL
, 0);
10268 if (rresult
== REG_NOMATCH
)
10269 fatal_error (input_location
, "invalid version number %qs", v1
);
10270 else if (rresult
!= 0)
10272 rresult
= regexec (&r
, v2
, 0, NULL
, 0);
10273 if (rresult
== REG_NOMATCH
)
10274 fatal_error (input_location
, "invalid version number %qs", v2
);
10275 else if (rresult
!= 0)
10278 return strverscmp (v1
, v2
);
10282 /* version_compare built-in spec function.
10284 This takes an argument of the following form:
10286 <comparison-op> <arg1> [<arg2>] <switch> <result>
10288 and produces "result" if the comparison evaluates to true,
10289 and nothing if it doesn't.
10291 The supported <comparison-op> values are:
10293 >= true if switch is a later (or same) version than arg1
10295 < true if switch is an earlier version than arg1
10297 >< true if switch is arg1 or later, and earlier than arg2
10298 <> true if switch is earlier than arg1 or is arg2 or later
10300 If the switch is not present, the condition is false unless
10301 the first character of the <comparison-op> is '!'.
10304 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
10305 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
10307 static const char *
10308 version_compare_spec_function (int argc
, const char **argv
)
10312 const char *switch_value
= NULL
;
10317 fatal_error (input_location
, "too few arguments to %%:version-compare");
10318 if (argv
[0][0] == '\0')
10320 if ((argv
[0][1] == '<' || argv
[0][1] == '>') && argv
[0][0] != '!')
10322 if (argc
!= nargs
+ 3)
10323 fatal_error (input_location
, "too many arguments to %%:version-compare");
10325 switch_len
= strlen (argv
[nargs
+ 1]);
10326 for (i
= 0; i
< n_switches
; i
++)
10327 if (!strncmp (switches
[i
].part1
, argv
[nargs
+ 1], switch_len
)
10328 && check_live_switch (i
, switch_len
))
10329 switch_value
= switches
[i
].part1
+ switch_len
;
10331 if (switch_value
== NULL
)
10332 comp1
= comp2
= -1;
10335 comp1
= compare_version_strings (switch_value
, argv
[1]);
10337 comp2
= compare_version_strings (switch_value
, argv
[2]);
10339 comp2
= -1; /* This value unused. */
10342 switch (argv
[0][0] << 8 | argv
[0][1])
10344 case '>' << 8 | '=':
10345 result
= comp1
>= 0;
10347 case '!' << 8 | '<':
10348 result
= comp1
>= 0 || switch_value
== NULL
;
10351 result
= comp1
< 0;
10353 case '!' << 8 | '>':
10354 result
= comp1
< 0 || switch_value
== NULL
;
10356 case '>' << 8 | '<':
10357 result
= comp1
>= 0 && comp2
< 0;
10359 case '<' << 8 | '>':
10360 result
= comp1
< 0 || comp2
>= 0;
10364 fatal_error (input_location
,
10365 "unknown operator %qs in %%:version-compare", argv
[0]);
10370 return argv
[nargs
+ 2];
10373 /* %:include builtin spec function. This differs from %include in that it
10374 can be nested inside a spec, and thus be conditionalized. It takes
10375 one argument, the filename, and looks for it in the startfile path.
10376 The result is always NULL, i.e. an empty expansion. */
10378 static const char *
10379 include_spec_function (int argc
, const char **argv
)
10386 file
= find_a_file (&startfile_prefixes
, argv
[0], R_OK
, true);
10387 read_specs (file
? file
: argv
[0], false, false);
10392 /* %:find-file spec function. This function replaces its argument by
10393 the file found through find_file, that is the -print-file-name gcc
10395 static const char *
10396 find_file_spec_function (int argc
, const char **argv
)
10403 file
= find_file (argv
[0]);
10408 /* %:find-plugindir spec function. This function replaces its argument
10409 by the -iplugindir=<dir> option. `dir' is found through find_file, that
10410 is the -print-file-name gcc program option. */
10411 static const char *
10412 find_plugindir_spec_function (int argc
, const char **argv ATTRIBUTE_UNUSED
)
10414 const char *option
;
10419 option
= concat ("-iplugindir=", find_file ("plugin"), NULL
);
10424 /* %:print-asm-header spec function. Print a banner to say that the
10425 following output is from the assembler. */
10427 static const char *
10428 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED
,
10429 const char **argv ATTRIBUTE_UNUSED
)
10431 printf (_("Assembler options\n=================\n\n"));
10432 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
10437 /* Get a random number for -frandom-seed */
10439 static unsigned HOST_WIDE_INT
10440 get_random_number (void)
10442 unsigned HOST_WIDE_INT ret
= 0;
10445 fd
= open ("/dev/urandom", O_RDONLY
);
10448 read (fd
, &ret
, sizeof (HOST_WIDE_INT
));
10454 /* Get some more or less random data. */
10455 #ifdef HAVE_GETTIMEOFDAY
10459 gettimeofday (&tv
, NULL
);
10460 ret
= tv
.tv_sec
* 1000 + tv
.tv_usec
/ 1000;
10464 time_t now
= time (NULL
);
10466 if (now
!= (time_t)-1)
10467 ret
= (unsigned) now
;
10471 return ret
^ getpid ();
10474 /* %:compare-debug-dump-opt spec function. Save the last argument,
10475 expected to be the last -fdump-final-insns option, or generate a
10478 static const char *
10479 compare_debug_dump_opt_spec_function (int arg
,
10480 const char **argv ATTRIBUTE_UNUSED
)
10485 static char random_seed
[HOST_BITS_PER_WIDE_INT
/ 4 + 3];
10488 fatal_error (input_location
,
10489 "too many arguments to %%:compare-debug-dump-opt");
10491 do_spec_2 ("%{fdump-final-insns=*:%*}", NULL
);
10492 do_spec_1 (" ", 0, NULL
);
10494 if (argbuf
.length () > 0
10495 && strcmp (argv
[argbuf
.length () - 1], ".") != 0)
10497 if (!compare_debug
)
10500 name
= xstrdup (argv
[argbuf
.length () - 1]);
10505 if (argbuf
.length () > 0)
10506 do_spec_2 ("%B.gkd", NULL
);
10507 else if (!compare_debug
)
10510 do_spec_2 ("%{!save-temps*:%g.gkd}%{save-temps*:%B.gkd}", NULL
);
10512 do_spec_1 (" ", 0, NULL
);
10514 gcc_assert (argbuf
.length () > 0);
10516 name
= xstrdup (argbuf
.last ());
10518 char *arg
= quote_spec (xstrdup (name
));
10519 ret
= concat ("-fdump-final-insns=", arg
, NULL
);
10523 which
= compare_debug
< 0;
10524 debug_check_temp_file
[which
] = name
;
10528 unsigned HOST_WIDE_INT value
= get_random_number ();
10530 sprintf (random_seed
, HOST_WIDE_INT_PRINT_HEX
, value
);
10536 ret
= concat ("%{!frandom-seed=*:-frandom-seed=", random_seed
, "} ",
10547 /* %:compare-debug-self-opt spec function. Expands to the options
10548 that are to be passed in the second compilation of
10551 static const char *
10552 compare_debug_self_opt_spec_function (int arg
,
10553 const char **argv ATTRIBUTE_UNUSED
)
10556 fatal_error (input_location
,
10557 "too many arguments to %%:compare-debug-self-opt");
10559 if (compare_debug
>= 0)
10563 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
10564 %<fdump-final-insns=* -w -S -o %j \
10565 %{!fcompare-debug-second:-fcompare-debug-second} \
10566 ", compare_debug_opt
, NULL
);
10569 /* %:pass-through-libs spec function. Finds all -l options and input
10570 file names in the lib spec passed to it, and makes a list of them
10571 prepended with the plugin option to cause them to be passed through
10572 to the final link after all the new object files have been added. */
10575 pass_through_libs_spec_func (int argc
, const char **argv
)
10577 char *prepended
= xstrdup (" ");
10579 /* Shlemiel the painter's algorithm. Innately horrible, but at least
10580 we know that there will never be more than a handful of strings to
10581 concat, and it's only once per run, so it's not worth optimising. */
10582 for (n
= 0; n
< argc
; n
++)
10584 char *old
= prepended
;
10585 /* Anything that isn't an option is a full path to an output
10586 file; pass it through if it ends in '.a'. Among options,
10588 if (argv
[n
][0] == '-' && argv
[n
][1] == 'l')
10590 const char *lopt
= argv
[n
] + 2;
10591 /* Handle both joined and non-joined -l options. If for any
10592 reason there's a trailing -l with no joined or following
10593 arg just discard it. */
10594 if (!*lopt
&& ++n
>= argc
)
10598 prepended
= concat (prepended
, "-plugin-opt=-pass-through=-l",
10601 else if (!strcmp (".a", argv
[n
] + strlen (argv
[n
]) - 2))
10603 prepended
= concat (prepended
, "-plugin-opt=-pass-through=",
10604 argv
[n
], " ", NULL
);
10606 if (prepended
!= old
)
10613 not_actual_file_p (const char *name
)
10615 return (strcmp (name
, "-") == 0
10616 || strcmp (name
, HOST_BIT_BUCKET
) == 0);
10619 /* %:dumps spec function. Take an optional argument that overrides
10620 the default extension for -dumpbase and -dumpbase-ext.
10621 Return -dumpdir, -dumpbase and -dumpbase-ext, if needed. */
10623 dumps_spec_func (int argc
, const char **argv ATTRIBUTE_UNUSED
)
10625 const char *ext
= dumpbase_ext
;
10628 char *args
[3] = { NULL
, NULL
, NULL
};
10631 /* Do not compute a default for -dumpbase-ext when -dumpbase was
10632 given explicitly. */
10633 if (dumpbase
&& *dumpbase
&& !ext
)
10638 /* Do not override the explicitly-specified -dumpbase-ext with
10639 the specs-provided overrider. */
10643 else if (argc
!= 0)
10644 fatal_error (input_location
, "too many arguments for %%:dumps");
10648 p
= quote_spec_arg (xstrdup (dumpdir
));
10649 args
[nargs
++] = concat (" -dumpdir ", p
, NULL
);
10654 ext
= input_basename
+ basename_length
;
10656 /* Use the precomputed outbase, or compute dumpbase from
10657 input_basename, just like %b would. */
10660 if (dumpbase
&& *dumpbase
)
10662 base
= xstrdup (dumpbase
);
10663 p
= base
+ outbase_length
;
10664 gcc_checking_assert (strncmp (base
, outbase
, outbase_length
) == 0);
10665 gcc_checking_assert (strcmp (p
, ext
) == 0);
10667 else if (outbase_length
)
10669 base
= xstrndup (outbase
, outbase_length
);
10674 base
= xstrndup (input_basename
, suffixed_basename_length
);
10675 p
= base
+ basename_length
;
10678 if (compare_debug
< 0 || !p
|| strcmp (p
, ext
) != 0)
10684 if (compare_debug
< 0)
10689 p
= concat (base
, gk
, ext
, NULL
);
10695 base
= quote_spec_arg (base
);
10696 args
[nargs
++] = concat (" -dumpbase ", base
, NULL
);
10701 p
= quote_spec_arg (xstrdup (ext
));
10702 args
[nargs
++] = concat (" -dumpbase-ext ", p
, NULL
);
10706 const char *ret
= concat (args
[0], args
[1], args
[2], NULL
);
10708 free (args
[--nargs
]);
10713 /* Returns "" if ARGV[ARGC - 2] is greater than ARGV[ARGC-1].
10714 Otherwise, return NULL. */
10716 static const char *
10717 greater_than_spec_func (int argc
, const char **argv
)
10724 gcc_assert (argc
>= 2);
10726 long arg
= strtol (argv
[argc
- 2], &converted
, 10);
10727 gcc_assert (converted
!= argv
[argc
- 2]);
10729 long lim
= strtol (argv
[argc
- 1], &converted
, 10);
10730 gcc_assert (converted
!= argv
[argc
- 1]);
10738 /* Returns "" if debug_info_level is greater than ARGV[ARGC-1].
10739 Otherwise, return NULL. */
10741 static const char *
10742 debug_level_greater_than_spec_func (int argc
, const char **argv
)
10747 fatal_error (input_location
,
10748 "wrong number of arguments to %%:debug-level-gt");
10750 long arg
= strtol (argv
[0], &converted
, 10);
10751 gcc_assert (converted
!= argv
[0]);
10753 if (debug_info_level
> arg
)
10759 /* Returns "" if dwarf_version is greater than ARGV[ARGC-1].
10760 Otherwise, return NULL. */
10762 static const char *
10763 dwarf_version_greater_than_spec_func (int argc
, const char **argv
)
10768 fatal_error (input_location
,
10769 "wrong number of arguments to %%:dwarf-version-gt");
10771 long arg
= strtol (argv
[0], &converted
, 10);
10772 gcc_assert (converted
!= argv
[0]);
10774 if (dwarf_version
> arg
)
10781 path_prefix_reset (path_prefix
*prefix
)
10783 struct prefix_list
*iter
, *next
;
10784 iter
= prefix
->plist
;
10788 free (const_cast <char *> (iter
->prefix
));
10793 prefix
->max_len
= 0;
10796 /* The function takes 3 arguments: OPTION name, file name and location
10797 where we search for Fortran modules.
10798 When the FILE is found by find_file, return OPTION=path_to_file. */
10800 static const char *
10801 find_fortran_preinclude_file (int argc
, const char **argv
)
10803 char *result
= NULL
;
10807 struct path_prefix prefixes
= { 0, 0, "preinclude" };
10809 /* Search first for 'finclude' folder location for a header file
10810 installed by the compiler (similar to omp_lib.h). */
10811 add_prefix (&prefixes
, argv
[2], NULL
, 0, 0, 0);
10812 #ifdef TOOL_INCLUDE_DIR
10813 /* Then search: <prefix>/<target>/<include>/finclude */
10814 add_prefix (&prefixes
, TOOL_INCLUDE_DIR
"/finclude/",
10817 #ifdef NATIVE_SYSTEM_HEADER_DIR
10818 /* Then search: <sysroot>/usr/include/finclude/<multilib> */
10819 add_sysrooted_hdrs_prefix (&prefixes
, NATIVE_SYSTEM_HEADER_DIR
"/finclude/",
10823 const char *path
= find_a_file (&include_prefixes
, argv
[1], R_OK
, false);
10825 result
= concat (argv
[0], path
, NULL
);
10828 path
= find_a_file (&prefixes
, argv
[1], R_OK
, false);
10830 result
= concat (argv
[0], path
, NULL
);
10833 path_prefix_reset (&prefixes
);
10837 /* If any character in ORIG fits QUOTE_P (_, P), reallocate the string
10838 so as to precede every one of them with a backslash. Return the
10839 original string or the reallocated one. */
10841 static inline char *
10842 quote_string (char *orig
, bool (*quote_p
)(char, void *), void *p
)
10844 int len
, number_of_space
= 0;
10846 for (len
= 0; orig
[len
]; len
++)
10847 if (quote_p (orig
[len
], p
))
10850 if (number_of_space
)
10852 char *new_spec
= (char *) xmalloc (len
+ number_of_space
+ 1);
10854 for (j
= 0, k
= 0; j
<= len
; j
++, k
++)
10856 if (quote_p (orig
[j
], p
))
10857 new_spec
[k
++] = '\\';
10858 new_spec
[k
] = orig
[j
];
10867 /* Return true iff C is any of the characters convert_white_space
10871 whitespace_to_convert_p (char c
, void *)
10873 return (c
== ' ' || c
== '\t');
10876 /* Insert backslash before spaces in ORIG (usually a file path), to
10877 avoid being broken by spec parser.
10879 This function is needed as do_spec_1 treats white space (' ' and '\t')
10880 as the end of an argument. But in case of -plugin /usr/gcc install/xxx.so,
10881 the file name should be treated as a single argument rather than being
10882 broken into multiple. Solution is to insert '\\' before the space in a
10885 This function converts and only converts all occurrence of ' '
10886 to '\\' + ' ' and '\t' to '\\' + '\t'. For example:
10888 "a b" -> "a\\ \\ b"
10890 "a\\ b" -> "a\\\\ b"
10892 orig: input null-terminating string that was allocated by xalloc. The
10893 memory it points to might be freed in this function. Behavior undefined
10894 if ORIG wasn't xalloced or was freed already at entry.
10896 Return: ORIG if no conversion needed. Otherwise a newly allocated string
10897 that was converted from ORIG. */
10900 convert_white_space (char *orig
)
10902 return quote_string (orig
, whitespace_to_convert_p
, NULL
);
10905 /* Return true iff C matches any of the spec active characters. */
10907 quote_spec_char_p (char c
, void *)
10924 /* Like convert_white_space, but deactivate all active spec chars by
10927 static inline char *
10928 quote_spec (char *orig
)
10930 return quote_string (orig
, quote_spec_char_p
, NULL
);
10933 /* Like quote_spec, but also turn an empty string into the spec for an
10936 static inline char *
10937 quote_spec_arg (char *orig
)
10942 return xstrdup ("%\"");
10945 return quote_spec (orig
);
10948 /* Restore all state within gcc.c to the initial state, so that the driver
10949 code can be safely re-run in-process.
10951 Many const char * variables are referenced by static specs (see
10952 INIT_STATIC_SPEC above). These variables are restored to their default
10953 values by a simple loop over the static specs.
10955 For other variables, we directly restore them all to their initial
10956 values (often implicitly 0).
10958 Free the various obstacks in this file, along with "opts_obstack"
10961 This function also restores any environment variables that were changed. */
10964 driver::finalize ()
10967 diagnostic_finish (global_dc
);
10970 at_file_supplied
= 0;
10971 print_help_list
= 0;
10973 verbose_only_flag
= 0;
10974 print_subprocess_help
= 0;
10976 report_times_to_file
= NULL
;
10977 target_system_root
= DEFAULT_TARGET_SYSTEM_ROOT
;
10978 target_system_root_changed
= 0;
10979 target_sysroot_suffix
= 0;
10980 target_sysroot_hdrs_suffix
= 0;
10981 save_temps_flag
= SAVE_TEMPS_NONE
;
10982 save_temps_overrides_dumpdir
= false;
10983 dumpdir_trailing_dash_added
= false;
10986 free (dumpbase_ext
);
10988 dumpdir
= dumpbase
= dumpbase_ext
= outbase
= NULL
;
10989 dumpdir_length
= outbase_length
= 0;
10990 spec_machine
= DEFAULT_TARGET_MACHINE
;
10991 greatest_status
= 1;
10993 obstack_free (&obstack
, NULL
);
10994 obstack_free (&opts_obstack
, NULL
); /* in opts.c */
10995 obstack_free (&collect_obstack
, NULL
);
10997 link_command_spec
= LINK_COMMAND_SPEC
;
10999 obstack_free (&multilib_obstack
, NULL
);
11001 user_specs_head
= NULL
;
11002 user_specs_tail
= NULL
;
11004 /* Within the "compilers" vec, the fields "suffix" and "spec" were
11005 statically allocated for the default compilers, but dynamically
11006 allocated for additional compilers. Delete them for the latter. */
11007 for (int i
= n_default_compilers
; i
< n_compilers
; i
++)
11009 free (const_cast <char *> (compilers
[i
].suffix
));
11010 free (const_cast <char *> (compilers
[i
].spec
));
11012 XDELETEVEC (compilers
);
11016 linker_options
.truncate (0);
11017 assembler_options
.truncate (0);
11018 preprocessor_options
.truncate (0);
11020 path_prefix_reset (&exec_prefixes
);
11021 path_prefix_reset (&startfile_prefixes
);
11022 path_prefix_reset (&include_prefixes
);
11024 machine_suffix
= 0;
11025 just_machine_suffix
= 0;
11026 gcc_exec_prefix
= 0;
11027 gcc_libexec_prefix
= 0;
11028 set_static_spec_shared (&md_exec_prefix
, MD_EXEC_PREFIX
);
11029 set_static_spec_shared (&md_startfile_prefix
, MD_STARTFILE_PREFIX
);
11030 set_static_spec_shared (&md_startfile_prefix_1
, MD_STARTFILE_PREFIX_1
);
11032 multilib_os_dir
= 0;
11035 /* Free any specs dynamically-allocated by set_spec.
11036 These will be at the head of the list, before the
11037 statically-allocated ones. */
11040 while (specs
!= static_specs
)
11042 spec_list
*next
= specs
->next
;
11043 free (const_cast <char *> (specs
->name
));
11049 for (unsigned i
= 0; i
< ARRAY_SIZE (static_specs
); i
++)
11051 spec_list
*sl
= &static_specs
[i
];
11054 free (const_cast <char *> (*(sl
->ptr_spec
)));
11055 sl
->alloc_p
= false;
11057 *(sl
->ptr_spec
) = sl
->default_ptr
;
11060 extra_specs
= NULL
;
11063 processing_spec_function
= 0;
11071 execution_count
= 0;
11074 temp_filename
= NULL
;
11075 temp_filename_length
= 0;
11076 always_delete_queue
= NULL
;
11077 failure_delete_queue
= NULL
;
11079 XDELETEVEC (switches
);
11082 n_switches_alloc
= 0;
11085 compare_debug_second
= 0;
11086 compare_debug_opt
= NULL
;
11087 for (int i
= 0; i
< 2; i
++)
11089 switches_debug_check
[i
] = NULL
;
11090 n_switches_debug_check
[i
] = 0;
11091 n_switches_alloc_debug_check
[i
] = 0;
11092 debug_check_temp_file
[i
] = NULL
;
11095 XDELETEVEC (infiles
);
11098 n_infiles_alloc
= 0;
11100 combine_inputs
= false;
11101 added_libraries
= 0;
11102 XDELETEVEC (outfiles
);
11105 last_language_n_infiles
= 0;
11106 gcc_input_filename
= NULL
;
11107 input_file_number
= 0;
11108 input_filename_length
= 0;
11109 basename_length
= 0;
11110 suffixed_basename_length
= 0;
11111 input_basename
= NULL
;
11112 input_suffix
= NULL
;
11113 /* We don't need to purge "input_stat", just to unset "input_stat_set". */
11114 input_stat_set
= 0;
11115 input_file_compiler
= NULL
;
11117 delete_this_arg
= 0;
11118 this_is_output_file
= 0;
11119 this_is_library_file
= 0;
11120 this_is_linker_script
= 0;
11121 input_from_pipe
= 0;
11122 suffix_subst
= NULL
;
11127 used_arg
.finalize ();
11131 Targets can provide configure-time default options in
11132 OPTION_DEFAULT_SPECS. The jit needs to access these, but
11133 they are expressed in the spec language.
11135 Run just enough of the driver to be able to expand these
11136 specs, and then call the callback CB on each
11137 such option. The options strings are *without* a leading
11138 '-' character e.g. ("march=x86-64"). Finally, clean up. */
11141 driver_get_configure_time_options (void (*cb
) (const char *option
,
11147 obstack_init (&obstack
);
11148 init_opts_obstack ();
11151 for (i
= 0; i
< ARRAY_SIZE (option_default_specs
); i
++)
11152 do_option_spec (option_default_specs
[i
].name
,
11153 option_default_specs
[i
].spec
);
11155 for (i
= 0; (int) i
< n_switches
; i
++)
11157 gcc_assert (switches
[i
].part1
);
11158 (*cb
) (switches
[i
].part1
, user_data
);
11161 obstack_free (&opts_obstack
, NULL
);
11162 obstack_free (&obstack
, NULL
);