1 /* Compiler driver program that can handle many languages.
2 Copyright (C) 1987-2016 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 */
40 #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 /* FIXME: when autoconf is fixed, remove the host check - dj */
174 #if defined(TARGET_EXECUTABLE_SUFFIX) && defined(HOST_EXECUTABLE_SUFFIX)
175 #define HAVE_TARGET_EXECUTABLE_SUFFIX
178 /* By default there is no special suffix for host executables. */
179 #ifdef HOST_EXECUTABLE_SUFFIX
180 #define HAVE_HOST_EXECUTABLE_SUFFIX
182 #define HOST_EXECUTABLE_SUFFIX ""
185 /* By default, the suffix for target object files is ".o". */
186 #ifdef TARGET_OBJECT_SUFFIX
187 #define HAVE_TARGET_OBJECT_SUFFIX
189 #define TARGET_OBJECT_SUFFIX ".o"
192 static const char dir_separator_str
[] = { DIR_SEPARATOR
, 0 };
194 /* Most every one is fine with LIBRARY_PATH. For some, it conflicts. */
195 #ifndef LIBRARY_PATH_ENV
196 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
199 /* If a stage of compilation returns an exit status >= 1,
200 compilation of that file ceases. */
202 #define MIN_FATAL_STATUS 1
204 /* Flag set by cppspec.c to 1. */
207 /* Flag set to nonzero if an @file argument has been supplied to gcc. */
208 static bool at_file_supplied
;
210 /* Definition of string containing the arguments given to configure. */
211 #include "configargs.h"
213 /* Flag saying to print the command line options understood by gcc and its
216 static int print_help_list
;
218 /* Flag saying to print the version of gcc and its sub-processes. */
220 static int print_version
;
222 /* Flag indicating whether we should ONLY print the command and
223 arguments (like verbose_flag) without executing the command.
224 Displayed arguments are quoted so that the generated command
225 line is suitable for execution. This is intended for use in
226 shell scripts to capture the driver-generated command line. */
227 static int verbose_only_flag
;
229 /* Flag indicating how to print command line options of sub-processes. */
231 static int print_subprocess_help
;
233 /* Linker suffix passed to -fuse-ld=... */
234 static const char *use_ld
;
236 /* Whether we should report subprocess execution times to a file. */
238 FILE *report_times_to_file
= NULL
;
240 /* Nonzero means place this string before uses of /, so that include
241 and library files can be found in an alternate location. */
243 #ifdef TARGET_SYSTEM_ROOT
244 #define DEFAULT_TARGET_SYSTEM_ROOT (TARGET_SYSTEM_ROOT)
246 #define DEFAULT_TARGET_SYSTEM_ROOT (0)
248 static const char *target_system_root
= DEFAULT_TARGET_SYSTEM_ROOT
;
250 /* Nonzero means pass the updated target_system_root to the compiler. */
252 static int target_system_root_changed
;
254 /* Nonzero means append this string to target_system_root. */
256 static const char *target_sysroot_suffix
= 0;
258 /* Nonzero means append this string to target_system_root for headers. */
260 static const char *target_sysroot_hdrs_suffix
= 0;
262 /* Nonzero means write "temp" files in source directory
263 and use the source file's name in them, and don't delete them. */
265 static enum save_temps
{
266 SAVE_TEMPS_NONE
, /* no -save-temps */
267 SAVE_TEMPS_CWD
, /* -save-temps in current directory */
268 SAVE_TEMPS_OBJ
/* -save-temps in object directory */
271 /* Output file to use to get the object directory for -save-temps=obj */
272 static char *save_temps_prefix
= 0;
273 static size_t save_temps_length
= 0;
275 /* The compiler version. */
277 static const char *compiler_version
;
279 /* The target version. */
281 static const char *const spec_version
= DEFAULT_TARGET_VERSION
;
283 /* The target machine. */
285 static const char *spec_machine
= DEFAULT_TARGET_MACHINE
;
286 static const char *spec_host_machine
= DEFAULT_REAL_TARGET_MACHINE
;
288 /* List of offload targets. Separated by colon. Empty string for
289 -foffload=disable. */
291 static char *offload_targets
= NULL
;
293 /* Nonzero if cross-compiling.
294 When -b is used, the value comes from the `specs' file. */
296 #ifdef CROSS_DIRECTORY_STRUCTURE
297 static const char *cross_compile
= "1";
299 static const char *cross_compile
= "0";
302 /* Greatest exit code of sub-processes that has been encountered up to
304 static int greatest_status
= 1;
306 /* This is the obstack which we use to allocate many strings. */
308 static struct obstack obstack
;
310 /* This is the obstack to build an environment variable to pass to
311 collect2 that describes all of the relevant switches of what to
312 pass the compiler in building the list of pointers to constructors
315 static struct obstack collect_obstack
;
317 /* Forward declaration for prototypes. */
321 static void init_spec (void);
322 static void store_arg (const char *, int, int);
323 static void insert_wrapper (const char *);
324 static char *load_specs (const char *);
325 static void read_specs (const char *, bool, bool);
326 static void set_spec (const char *, const char *, bool);
327 static struct compiler
*lookup_compiler (const char *, size_t, const char *);
328 static char *build_search_list (const struct path_prefix
*, const char *,
330 static void xputenv (const char *);
331 static void putenv_from_prefixes (const struct path_prefix
*, const char *,
333 static int access_check (const char *, int);
334 static char *find_a_file (const struct path_prefix
*, const char *, int, bool);
335 static void add_prefix (struct path_prefix
*, const char *, const char *,
337 static void add_sysrooted_prefix (struct path_prefix
*, const char *,
338 const char *, int, int, int);
339 static char *skip_whitespace (char *);
340 static void delete_if_ordinary (const char *);
341 static void delete_temp_files (void);
342 static void delete_failure_queue (void);
343 static void clear_failure_queue (void);
344 static int check_live_switch (int, int);
345 static const char *handle_braces (const char *);
346 static inline bool input_suffix_matches (const char *, const char *);
347 static inline bool switch_matches (const char *, const char *, int);
348 static inline void mark_matching_switches (const char *, const char *, int);
349 static inline void process_marked_switches (void);
350 static const char *process_brace_body (const char *, const char *, const char *, int, int);
351 static const struct spec_function
*lookup_spec_function (const char *);
352 static const char *eval_spec_function (const char *, const char *);
353 static const char *handle_spec_function (const char *, bool *);
354 static char *save_string (const char *, int);
355 static void set_collect_gcc_options (void);
356 static int do_spec_1 (const char *, int, const char *);
357 static int do_spec_2 (const char *);
358 static void do_option_spec (const char *, const char *);
359 static void do_self_spec (const char *);
360 static const char *find_file (const char *);
361 static int is_directory (const char *, bool);
362 static const char *validate_switches (const char *, bool);
363 static void validate_all_switches (void);
364 static inline void validate_switches_from_spec (const char *, bool);
365 static void give_switch (int, int);
366 static int default_arg (const char *, int);
367 static void set_multilib_dir (void);
368 static void print_multilib_info (void);
369 static void perror_with_name (const char *);
370 static void display_help (void);
371 static void add_preprocessor_option (const char *, int);
372 static void add_assembler_option (const char *, int);
373 static void add_linker_option (const char *, int);
374 static void process_command (unsigned int, struct cl_decoded_option
*);
375 static int execute (void);
376 static void alloc_args (void);
377 static void clear_args (void);
378 static void fatal_signal (int);
379 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
380 static void init_gcc_specs (struct obstack
*, const char *, const char *,
383 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
384 static const char *convert_filename (const char *, int, int);
387 static void try_generate_repro (const char **argv
);
388 static const char *getenv_spec_function (int, const char **);
389 static const char *if_exists_spec_function (int, const char **);
390 static const char *if_exists_else_spec_function (int, const char **);
391 static const char *sanitize_spec_function (int, const char **);
392 static const char *replace_outfile_spec_function (int, const char **);
393 static const char *remove_outfile_spec_function (int, const char **);
394 static const char *version_compare_spec_function (int, const char **);
395 static const char *include_spec_function (int, const char **);
396 static const char *find_file_spec_function (int, const char **);
397 static const char *find_plugindir_spec_function (int, const char **);
398 static const char *print_asm_header_spec_function (int, const char **);
399 static const char *compare_debug_dump_opt_spec_function (int, const char **);
400 static const char *compare_debug_self_opt_spec_function (int, const char **);
401 static const char *compare_debug_auxbase_opt_spec_function (int, const char **);
402 static const char *pass_through_libs_spec_func (int, const char **);
403 static const char *replace_extension_spec_func (int, const char **);
404 static const char *greater_than_spec_func (int, const char **);
405 static char *convert_white_space (char *);
407 /* The Specs Language
409 Specs are strings containing lines, each of which (if not blank)
410 is made up of a program name, and arguments separated by spaces.
411 The program name must be exact and start from root, since no path
412 is searched and it is unreliable to depend on the current working directory.
413 Redirection of input or output is not supported; the subprograms must
414 accept filenames saying what files to read and write.
416 In addition, the specs can contain %-sequences to substitute variable text
417 or for conditional text. Here is a table of all defined %-sequences.
418 Note that spaces are not generated automatically around the results of
419 expanding these sequences; therefore, you can concatenate them together
420 or with constant text in a single argument.
422 %% substitute one % into the program name or argument.
423 %i substitute the name of the input file being processed.
424 %b substitute the basename of the input file being processed.
425 This is the substring up to (and not including) the last period
426 and not including the directory unless -save-temps was specified
427 to put temporaries in a different location.
428 %B same as %b, but include the file suffix (text after the last period).
430 substitute a file name that has suffix SUFFIX and is chosen
431 once per compilation, and mark the argument a la %d. To reduce
432 exposure to denial-of-service attacks, the file name is now
433 chosen in a way that is hard to predict even when previously
434 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
435 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
436 the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
437 had been pre-processed. Previously, %g was simply substituted
438 with a file name chosen once per compilation, without regard
439 to any appended suffix (which was therefore treated just like
440 ordinary text), making such attacks more likely to succeed.
442 like %g, but if -pipe is in effect, expands simply to "-".
444 like %g, but if -pipe is in effect, expands to nothing. (We have both
445 %| and %m to accommodate differences between system assemblers; see
446 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
448 like %g, but generates a new temporary file name even if %uSUFFIX
451 substitutes the last file name generated with %uSUFFIX, generating a
452 new one if there is no such last file name. In the absence of any
453 %uSUFFIX, this is just like %gSUFFIX, except they don't share
454 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
455 would involve the generation of two distinct file names, one
456 for each `%g.s' and another for each `%U.s'. Previously, %U was
457 simply substituted with a file name chosen for the previous %u,
458 without regard to any appended suffix.
460 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
461 writable, and if save-temps is off; otherwise, substitute the name
462 of a temporary file, just like %u. This temporary file is not
463 meant for communication between processes, but rather as a junk
466 substitutes .SUFFIX for the suffixes of a matched switch's args when
467 it is subsequently output with %*. SUFFIX is terminated by the next
469 %d marks the argument containing or following the %d as a
470 temporary file name, so that file will be deleted if GCC exits
471 successfully. Unlike %g, this contributes no text to the argument.
472 %w marks the argument containing or following the %w as the
473 "output file" of this compilation. This puts the argument
474 into the sequence of arguments that %o will substitute later.
475 %V indicates that this compilation produces no "output file".
477 like %{...} but mark last argument supplied within
478 as a file to be deleted on failure.
479 %o substitutes the names of all the output files, with spaces
480 automatically placed around them. You should write spaces
481 around the %o as well or the results are undefined.
482 %o is for use in the specs for running the linker.
483 Input files whose names have no recognized suffix are not compiled
484 at all, but they are included among the output files, so they will
486 %O substitutes the suffix for object files. Note that this is
487 handled specially when it immediately follows %g, %u, or %U
488 (with or without a suffix argument) because of the need for
489 those to form complete file names. The handling is such that
490 %O is treated exactly as if it had already been substituted,
491 except that %g, %u, and %U do not currently support additional
492 SUFFIX characters following %O as they would following, for
494 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
495 (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
496 and -B options) and -imultilib as necessary.
497 %s current argument is the name of a library or startup file of some sort.
498 Search for that file in a standard list of directories
499 and substitute the full name found.
500 %eSTR Print STR as an error message. STR is terminated by a newline.
501 Use this when inconsistent options are detected.
502 %nSTR Print STR as a notice. STR is terminated by a newline.
503 %x{OPTION} Accumulate an option for %X.
504 %X Output the accumulated linker options specified by compilations.
505 %Y Output the accumulated assembler options specified by compilations.
506 %Z Output the accumulated preprocessor options specified by compilations.
507 %a process ASM_SPEC as a spec.
508 This allows config.h to specify part of the spec for running as.
509 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
510 used here. This can be used to run a post-processor after the
511 assembler has done its job.
512 %D Dump out a -L option for each directory in startfile_prefixes.
513 If multilib_dir is set, extra entries are generated with it affixed.
514 %l process LINK_SPEC as a spec.
515 %L process LIB_SPEC as a spec.
516 %M Output multilib_os_dir.
517 %G process LIBGCC_SPEC as a spec.
518 %R Output the concatenation of target_system_root and
519 target_sysroot_suffix.
520 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
521 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
522 %C process CPP_SPEC as a spec.
523 %1 process CC1_SPEC as a spec.
524 %2 process CC1PLUS_SPEC as a spec.
525 %* substitute the variable part of a matched option. (See below.)
526 Note that each comma in the substituted string is replaced by
527 a single space. A space is appended after the last substition
528 unless there is more text in current sequence.
529 %<S remove all occurrences of -S from the command line.
530 Note - this command is position dependent. % commands in the
531 spec string before this one will see -S, % commands in the
532 spec string after this one will not.
533 %>S Similar to "%<S", but keep it in the GCC command line.
534 %<S* remove all occurrences of all switches beginning with -S from the
537 Call the named function FUNCTION, passing it ARGS. ARGS is
538 first processed as a nested spec string, then split into an
539 argument vector in the usual fashion. The function returns
540 a string which is processed as if it had appeared literally
541 as part of the current spec.
542 %{S} substitutes the -S switch, if that switch was given to GCC.
543 If that switch was not specified, this substitutes nothing.
544 Here S is a metasyntactic variable.
545 %{S*} substitutes all the switches specified to GCC whose names start
546 with -S. This is used for -o, -I, etc; switches that take
547 arguments. GCC considers `-o foo' as being one switch whose
548 name starts with `o'. %{o*} would substitute this text,
549 including the space; thus, two arguments would be generated.
550 %{S*&T*} likewise, but preserve order of S and T options (the order
551 of S and T in the spec is not significant). Can be any number
552 of ampersand-separated variables; for each the wild card is
553 optional. Useful for CPP as %{D*&U*&A*}.
555 %{S:X} substitutes X, if the -S switch was given to GCC.
556 %{!S:X} substitutes X, if the -S switch was NOT given to GCC.
557 %{S*:X} substitutes X if one or more switches whose names start
558 with -S was given to GCC. Normally X is substituted only
559 once, no matter how many such switches appeared. However,
560 if %* appears somewhere in X, then X will be substituted
561 once for each matching switch, with the %* replaced by the
562 part of that switch that matched the '*'. A space will be
563 appended after the last substition unless there is more
564 text in current sequence.
565 %{.S:X} substitutes X, if processing a file with suffix S.
566 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
567 %{,S:X} substitutes X, if processing a file which will use spec S.
568 %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
570 %{S|T:X} substitutes X if either -S or -T was given to GCC. This may be
571 combined with '!', '.', ',', and '*' as above binding stronger
573 If %* appears in X, all of the alternatives must be starred, and
574 only the first matching alternative is substituted.
575 %{%:function(args):X}
576 Call function named FUNCTION with args ARGS. If the function
577 returns non-NULL, then X is substituted, if it returns
578 NULL, it isn't substituted.
579 %{S:X; if S was given to GCC, substitutes X;
580 T:Y; else if T was given to GCC, substitutes Y;
581 :D} else substitutes D. There can be as many clauses as you need.
582 This may be combined with '.', '!', ',', '|', and '*' as above.
584 %(Spec) processes a specification defined in a specs file as *Spec:
586 The conditional text X in a %{S:X} or similar construct may contain
587 other nested % constructs or spaces, or even newlines. They are
588 processed as usual, as described above. Trailing white space in X is
589 ignored. White space may also appear anywhere on the left side of the
590 colon in these constructs, except between . or * and the corresponding
593 The -O, -f, -g, -m, and -W switches are handled specifically in these
594 constructs. If another value of -O or the negated form of a -f, -m, or
595 -W switch is found later in the command line, the earlier switch
596 value is ignored, except with {S*} where S is just one letter; this
597 passes all matching options.
599 The character | at the beginning of the predicate text is used to indicate
600 that a command should be piped to the following command, but only if -pipe
603 Note that it is built into GCC which switches take arguments and which
604 do not. You might think it would be useful to generalize this to
605 allow each compiler's spec to say which switches take arguments. But
606 this cannot be done in a consistent fashion. GCC cannot even decide
607 which input files have been specified without knowing which switches
608 take arguments, and it must know which input files to compile in order
609 to tell which compilers to run.
611 GCC also knows implicitly that arguments starting in `-l' are to be
612 treated as compiler output files, and passed to the linker in their
613 proper position among the other output files. */
615 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
617 /* config.h can define ASM_SPEC to provide extra args to the assembler
618 or extra switch-translations. */
623 /* config.h can define ASM_FINAL_SPEC to run a post processor after
624 the assembler has run. */
625 #ifndef ASM_FINAL_SPEC
626 #define ASM_FINAL_SPEC \
628 objcopy --extract-dwo \
629 %{c:%{o*:%*}%{!o*:%b%O}}%{!c:%U%O} \
630 %{c:%{o*:%:replace-extension(%{o*:%*} .dwo)}%{!o*:%b.dwo}}%{!c:%b.dwo} \n\
631 objcopy --strip-dwo \
632 %{c:%{o*:%*}%{!o*:%b%O}}%{!c:%U%O} \
636 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
637 or extra switch-translations. */
642 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
643 or extra switch-translations. */
648 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
649 or extra switch-translations. */
651 #define CC1PLUS_SPEC ""
654 /* config.h can define LINK_SPEC to provide extra args to the linker
655 or extra switch-translations. */
660 /* config.h can define LIB_SPEC to override the default libraries. */
662 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
665 /* When using -fsplit-stack we need to wrap pthread_create, in order
666 to initialize the stack guard. We always use wrapping, rather than
667 shared library ordering, and we keep the wrapper function in
668 libgcc. This is not yet a real spec, though it could become one;
669 it is currently just stuffed into LINK_SPEC. FIXME: This wrapping
670 only works with GNU ld and gold. */
671 #ifdef HAVE_GOLD_NON_DEFAULT_SPLIT_STACK
672 #define STACK_SPLIT_SPEC " %{fsplit-stack: -fuse-ld=gold --wrap=pthread_create}"
674 #define STACK_SPLIT_SPEC " %{fsplit-stack: --wrap=pthread_create}"
678 #define STATIC_LIBASAN_LIBS \
679 " %{static-libasan:%:include(libsanitizer.spec)%(link_libasan)}"
680 #ifdef LIBASAN_EARLY_SPEC
681 #define LIBASAN_SPEC STATIC_LIBASAN_LIBS
682 #elif defined(HAVE_LD_STATIC_DYNAMIC)
683 #define LIBASAN_SPEC "%{static-libasan:" LD_STATIC_OPTION \
684 "} -lasan %{static-libasan:" LD_DYNAMIC_OPTION "}" \
687 #define LIBASAN_SPEC "-lasan" STATIC_LIBASAN_LIBS
691 #ifndef LIBASAN_EARLY_SPEC
692 #define LIBASAN_EARLY_SPEC ""
696 #define STATIC_LIBTSAN_LIBS \
697 " %{static-libtsan:%:include(libsanitizer.spec)%(link_libtsan)}"
698 #ifdef LIBTSAN_EARLY_SPEC
699 #define LIBTSAN_SPEC STATIC_LIBTSAN_LIBS
700 #elif defined(HAVE_LD_STATIC_DYNAMIC)
701 #define LIBTSAN_SPEC "%{static-libtsan:" LD_STATIC_OPTION \
702 "} -ltsan %{static-libtsan:" LD_DYNAMIC_OPTION "}" \
705 #define LIBTSAN_SPEC "-ltsan" STATIC_LIBTSAN_LIBS
709 #ifndef LIBTSAN_EARLY_SPEC
710 #define LIBTSAN_EARLY_SPEC ""
714 #define STATIC_LIBLSAN_LIBS \
715 " %{static-liblsan:%:include(libsanitizer.spec)%(link_liblsan)}"
716 #ifdef LIBLSAN_EARLY_SPEC
717 #define LIBLSAN_SPEC STATIC_LIBLSAN_LIBS
718 #elif defined(HAVE_LD_STATIC_DYNAMIC)
719 #define LIBLSAN_SPEC "%{static-liblsan:" LD_STATIC_OPTION \
720 "} -llsan %{static-liblsan:" LD_DYNAMIC_OPTION "}" \
723 #define LIBLSAN_SPEC "-llsan" STATIC_LIBLSAN_LIBS
727 #ifndef LIBLSAN_EARLY_SPEC
728 #define LIBLSAN_EARLY_SPEC ""
731 #ifndef LIBUBSAN_SPEC
732 #define STATIC_LIBUBSAN_LIBS \
733 " %{static-libubsan:%:include(libsanitizer.spec)%(link_libubsan)}"
734 #ifdef HAVE_LD_STATIC_DYNAMIC
735 #define LIBUBSAN_SPEC "%{static-libubsan:" LD_STATIC_OPTION \
736 "} -lubsan %{static-libubsan:" LD_DYNAMIC_OPTION "}" \
739 #define LIBUBSAN_SPEC "-lubsan" STATIC_LIBUBSAN_LIBS
743 /* Linker options for compressed debug sections. */
744 #if HAVE_LD_COMPRESS_DEBUG == 0
745 /* No linker support. */
746 #define LINK_COMPRESS_DEBUG_SPEC \
747 " %{gz*:%e-gz is not supported in this configuration} "
748 #elif HAVE_LD_COMPRESS_DEBUG == 1
749 /* GNU style on input, GNU ld options. Reject, not useful. */
750 #define LINK_COMPRESS_DEBUG_SPEC \
751 " %{gz*:%e-gz is not supported in this configuration} "
752 #elif HAVE_LD_COMPRESS_DEBUG == 2
753 /* GNU style, GNU gold options. */
754 #define LINK_COMPRESS_DEBUG_SPEC \
755 " %{gz|gz=zlib-gnu:" LD_COMPRESS_DEBUG_OPTION "=zlib}" \
756 " %{gz=none:" LD_COMPRESS_DEBUG_OPTION "=none}" \
757 " %{gz=zlib:%e-gz=zlib is not supported in this configuration} "
758 #elif HAVE_LD_COMPRESS_DEBUG == 3
759 /* ELF gABI style. */
760 #define LINK_COMPRESS_DEBUG_SPEC \
761 " %{gz|gz=zlib:" LD_COMPRESS_DEBUG_OPTION "=zlib}" \
762 " %{gz=none:" LD_COMPRESS_DEBUG_OPTION "=none}" \
763 " %{gz=zlib-gnu:" LD_COMPRESS_DEBUG_OPTION "=zlib-gnu} "
765 #error Unknown value for HAVE_LD_COMPRESS_DEBUG.
768 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
771 #if defined(REAL_LIBGCC_SPEC)
772 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
773 #elif defined(LINK_LIBGCC_SPECIAL_1)
774 /* Have gcc do the search for libgcc.a. */
775 #define LIBGCC_SPEC "libgcc.a%s"
777 #define LIBGCC_SPEC "-lgcc"
781 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
782 #ifndef STARTFILE_SPEC
783 #define STARTFILE_SPEC \
784 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
787 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
789 #define ENDFILE_SPEC ""
793 #define LINKER_NAME "collect2"
796 #ifdef HAVE_AS_DEBUG_PREFIX_MAP
797 #define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
802 /* Assembler options for compressed debug sections. */
803 #if HAVE_LD_COMPRESS_DEBUG < 2
804 /* Reject if the linker cannot write compressed debug sections. */
805 #define ASM_COMPRESS_DEBUG_SPEC \
806 " %{gz*:%e-gz is not supported in this configuration} "
807 #else /* HAVE_LD_COMPRESS_DEBUG >= 2 */
808 #if HAVE_AS_COMPRESS_DEBUG == 0
809 /* No assembler support. Ignore silently. */
810 #define ASM_COMPRESS_DEBUG_SPEC \
812 #elif HAVE_AS_COMPRESS_DEBUG == 1
813 /* GNU style, GNU as options. */
814 #define ASM_COMPRESS_DEBUG_SPEC \
815 " %{gz|gz=zlib-gnu:" AS_COMPRESS_DEBUG_OPTION "}" \
816 " %{gz=none:" AS_NO_COMPRESS_DEBUG_OPTION "}" \
817 " %{gz=zlib:%e-gz=zlib is not supported in this configuration} "
818 #elif HAVE_AS_COMPRESS_DEBUG == 2
819 /* ELF gABI style. */
820 #define ASM_COMPRESS_DEBUG_SPEC \
821 " %{gz|gz=zlib:" AS_COMPRESS_DEBUG_OPTION "=zlib}" \
822 " %{gz=none:" AS_COMPRESS_DEBUG_OPTION "=none}" \
823 " %{gz=zlib-gnu:" AS_COMPRESS_DEBUG_OPTION "=zlib-gnu} "
825 #error Unknown value for HAVE_AS_COMPRESS_DEBUG.
827 #endif /* HAVE_LD_COMPRESS_DEBUG >= 2 */
829 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
831 #ifndef ASM_DEBUG_SPEC
832 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
833 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
834 # define ASM_DEBUG_SPEC \
835 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
836 ? "%{!g0:%{gdwarf*:--gdwarf2}%{!gdwarf*:%{g*:--gstabs}}}" ASM_MAP \
837 : "%{!g0:%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}}" ASM_MAP)
839 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
840 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gstabs}}" ASM_MAP
842 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
843 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gdwarf2}}" ASM_MAP
847 #ifndef ASM_DEBUG_SPEC
848 # define ASM_DEBUG_SPEC ""
851 /* Here is the spec for running the linker, after compiling all files. */
853 /* This is overridable by the target in case they need to specify the
854 -lgcc and -lc order specially, yet not require them to override all
855 of LINK_COMMAND_SPEC. */
856 #ifndef LINK_GCC_C_SEQUENCE_SPEC
857 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
860 #ifndef LINK_SSP_SPEC
861 #ifdef TARGET_LIBC_PROVIDES_SSP
862 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all" \
863 "|fstack-protector-strong|fstack-protector-explicit:}"
865 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all" \
866 "|fstack-protector-strong|fstack-protector-explicit" \
867 ":-lssp_nonshared -lssp}"
871 #ifdef ENABLE_DEFAULT_PIE
872 #define NO_PIE_SPEC "no-pie|static"
873 #define PIE_SPEC NO_PIE_SPEC "|r|shared:;"
874 #define NO_FPIE1_SPEC "fno-pie"
875 #define FPIE1_SPEC NO_FPIE1_SPEC ":;"
876 #define NO_FPIE2_SPEC "fno-PIE"
877 #define FPIE2_SPEC NO_FPIE2_SPEC ":;"
878 #define NO_FPIE_SPEC NO_FPIE1_SPEC "|" NO_FPIE2_SPEC
879 #define FPIE_SPEC NO_FPIE_SPEC ":;"
880 #define NO_FPIC1_SPEC "fno-pic"
881 #define FPIC1_SPEC NO_FPIC1_SPEC ":;"
882 #define NO_FPIC2_SPEC "fno-PIC"
883 #define FPIC2_SPEC NO_FPIC2_SPEC ":;"
884 #define NO_FPIC_SPEC NO_FPIC1_SPEC "|" NO_FPIC2_SPEC
885 #define FPIC_SPEC NO_FPIC_SPEC ":;"
886 #define NO_FPIE1_AND_FPIC1_SPEC NO_FPIE1_SPEC "|" NO_FPIC1_SPEC
887 #define FPIE1_OR_FPIC1_SPEC NO_FPIE1_AND_FPIC1_SPEC ":;"
888 #define NO_FPIE2_AND_FPIC2_SPEC NO_FPIE2_SPEC "|" NO_FPIC2_SPEC
889 #define FPIE2_OR_FPIC2_SPEC NO_FPIE2_AND_FPIC2_SPEC ":;"
890 #define NO_FPIE_AND_FPIC_SPEC NO_FPIE_SPEC "|" NO_FPIC_SPEC
891 #define FPIE_OR_FPIC_SPEC NO_FPIE_AND_FPIC_SPEC ":;"
893 #define PIE_SPEC "pie"
894 #define NO_PIE_SPEC PIE_SPEC "|r|shared:;"
895 #define FPIE1_SPEC "fpie"
896 #define NO_FPIE1_SPEC FPIE1_SPEC ":;"
897 #define FPIE2_SPEC "fPIE"
898 #define NO_FPIE2_SPEC FPIE2_SPEC ":;"
899 #define FPIE_SPEC FPIE1_SPEC "|" FPIE2_SPEC
900 #define NO_FPIE_SPEC FPIE_SPEC ":;"
901 #define FPIC1_SPEC "fpic"
902 #define NO_FPIC1_SPEC FPIC1_SPEC ":;"
903 #define FPIC2_SPEC "fPIC"
904 #define NO_FPIC2_SPEC FPIC2_SPEC ":;"
905 #define FPIC_SPEC FPIC1_SPEC "|" FPIC2_SPEC
906 #define NO_FPIC_SPEC FPIC_SPEC ":;"
907 #define FPIE1_OR_FPIC1_SPEC FPIE1_SPEC "|" FPIC1_SPEC
908 #define NO_FPIE1_AND_FPIC1_SPEC FPIE1_OR_FPIC1_SPEC ":;"
909 #define FPIE2_OR_FPIC2_SPEC FPIE2_SPEC "|" FPIC2_SPEC
910 #define NO_FPIE2_AND_FPIC2_SPEC FPIE1_OR_FPIC2_SPEC ":;"
911 #define FPIE_OR_FPIC_SPEC FPIE_SPEC "|" FPIC_SPEC
912 #define NO_FPIE_AND_FPIC_SPEC FPIE_OR_FPIC_SPEC ":;"
915 #ifndef LINK_PIE_SPEC
918 #define LD_PIE_SPEC "-pie"
921 #define LD_PIE_SPEC ""
923 #define LINK_PIE_SPEC "%{no-pie:} " "%{" PIE_SPEC ":" LD_PIE_SPEC "} "
926 #ifndef LINK_BUILDID_SPEC
927 # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
928 # define LINK_BUILDID_SPEC "%{!r:--build-id} "
932 /* Conditional to test whether the LTO plugin is used or not.
933 FIXME: For slim LTO we will need to enable plugin unconditionally. This
934 still cause problems with PLUGIN_LD != LD and when plugin is built but
935 not useable. For GCC 4.6 we don't support slim LTO and thus we can enable
936 plugin only when LTO is enabled. We still honor explicit
937 -fuse-linker-plugin if the linker used understands -plugin. */
939 /* The linker has some plugin support. */
940 #if HAVE_LTO_PLUGIN > 0
941 /* The linker used has full plugin support, use LTO plugin by default. */
942 #if HAVE_LTO_PLUGIN == 2
943 #define PLUGIN_COND "!fno-use-linker-plugin:%{!fno-lto"
944 #define PLUGIN_COND_CLOSE "}"
946 /* The linker used has limited plugin support, use LTO plugin with explicit
947 -fuse-linker-plugin. */
948 #define PLUGIN_COND "fuse-linker-plugin"
949 #define PLUGIN_COND_CLOSE ""
951 #define LINK_PLUGIN_SPEC \
953 -plugin %(linker_plugin_file) \
954 -plugin-opt=%(lto_wrapper) \
955 -plugin-opt=-fresolution=%u.res \
956 %{!nostdlib:%{!nodefaultlibs:%:pass-through-libs(%(link_gcc_c_sequence))}} \
959 /* The linker used doesn't support -plugin, reject -fuse-linker-plugin. */
960 #define LINK_PLUGIN_SPEC "%{fuse-linker-plugin:\
961 %e-fuse-linker-plugin is not supported in this configuration}"
964 /* Linker command line options for -fsanitize= early on the command line. */
965 #ifndef SANITIZER_EARLY_SPEC
966 #define SANITIZER_EARLY_SPEC "\
967 %{!nostdlib:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_EARLY_SPEC "} \
968 %{%:sanitize(thread):" LIBTSAN_EARLY_SPEC "} \
969 %{%:sanitize(leak):" LIBLSAN_EARLY_SPEC "}}}"
972 /* Linker command line options for -fsanitize= late on the command line. */
973 #ifndef SANITIZER_SPEC
974 #define SANITIZER_SPEC "\
975 %{!nostdlib:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_SPEC "\
976 %{static:%ecannot specify -static with -fsanitize=address}}\
977 %{%:sanitize(thread):" LIBTSAN_SPEC "\
978 %{static:%ecannot specify -static with -fsanitize=thread}}\
979 %{%:sanitize(undefined):" LIBUBSAN_SPEC "}\
980 %{%:sanitize(leak):" LIBLSAN_SPEC "}}}"
983 #ifndef POST_LINK_SPEC
984 #define POST_LINK_SPEC ""
987 /* This is the spec to use, once the code for creating the vtable
988 verification runtime library, libvtv.so, has been created. Currently
989 the vtable verification runtime functions are in libstdc++, so we use
990 the spec just below this one. */
991 #ifndef VTABLE_VERIFICATION_SPEC
992 #if ENABLE_VTABLE_VERIFY
993 #define VTABLE_VERIFICATION_SPEC "\
994 %{!nostdlib:%{fvtable-verify=std: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}\
995 %{fvtable-verify=preinit: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}}"
997 #define VTABLE_VERIFICATION_SPEC "\
998 %{fvtable-verify=none:} \
999 %{fvtable-verify=std: \
1000 %e-fvtable-verify=std is not supported in this configuration} \
1001 %{fvtable-verify=preinit: \
1002 %e-fvtable-verify=preinit is not supported in this configuration}"
1007 #define CHKP_SPEC ""
1010 /* -u* was put back because both BSD and SysV seem to support it. */
1011 /* %{static:} simply prevents an error message if the target machine
1012 doesn't handle -static. */
1013 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
1014 scripts which exist in user specified directories, or in standard
1016 /* We pass any -flto flags on to the linker, which is expected
1017 to understand them. In practice, this means it had better be collect2. */
1018 /* %{e*} includes -export-dynamic; see comment in common.opt. */
1019 #ifndef LINK_COMMAND_SPEC
1020 #define LINK_COMMAND_SPEC "\
1021 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
1024 "%{flto|flto=*:%<fcompare-debug*} \
1025 %{flto} %{fno-lto} %{flto=*} %l " LINK_PIE_SPEC \
1026 "%{fuse-ld=*:-fuse-ld=%*} " LINK_COMPRESS_DEBUG_SPEC \
1027 "%X %{o*} %{e*} %{N} %{n} %{r}\
1028 %{s} %{t} %{u*} %{z} %{Z} %{!nostdlib:%{!nostartfiles:%S}} \
1029 %{static:} %{L*} %(mfwrap) %(link_libgcc) " \
1030 VTABLE_VERIFICATION_SPEC " " SANITIZER_EARLY_SPEC " %o " CHKP_SPEC " \
1031 %{fopenacc|fopenmp|%:gt(%{ftree-parallelize-loops=*:%*} 1):\
1032 %:include(libgomp.spec)%(link_gomp)}\
1033 %{fcilkplus:%:include(libcilkrts.spec)%(link_cilkrts)}\
1034 %{fgnu-tm:%:include(libitm.spec)%(link_itm)}\
1035 %(mflib) " STACK_SPLIT_SPEC "\
1036 %{fprofile-arcs|fprofile-generate*|coverage:-lgcov} " SANITIZER_SPEC " \
1037 %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\
1038 %{!nostdlib:%{!nostartfiles:%E}} %{T*} \n%(post_link) }}}}}}"
1041 #ifndef LINK_LIBGCC_SPEC
1042 /* Generate -L options for startfile prefix list. */
1043 # define LINK_LIBGCC_SPEC "%D"
1046 #ifndef STARTFILE_PREFIX_SPEC
1047 # define STARTFILE_PREFIX_SPEC ""
1050 #ifndef SYSROOT_SPEC
1051 # define SYSROOT_SPEC "--sysroot=%R"
1054 #ifndef SYSROOT_SUFFIX_SPEC
1055 # define SYSROOT_SUFFIX_SPEC ""
1058 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
1059 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
1062 static const char *asm_debug
= ASM_DEBUG_SPEC
;
1063 static const char *cpp_spec
= CPP_SPEC
;
1064 static const char *cc1_spec
= CC1_SPEC
;
1065 static const char *cc1plus_spec
= CC1PLUS_SPEC
;
1066 static const char *link_gcc_c_sequence_spec
= LINK_GCC_C_SEQUENCE_SPEC
;
1067 static const char *link_ssp_spec
= LINK_SSP_SPEC
;
1068 static const char *asm_spec
= ASM_SPEC
;
1069 static const char *asm_final_spec
= ASM_FINAL_SPEC
;
1070 static const char *link_spec
= LINK_SPEC
;
1071 static const char *lib_spec
= LIB_SPEC
;
1072 static const char *link_gomp_spec
= "";
1073 static const char *libgcc_spec
= LIBGCC_SPEC
;
1074 static const char *endfile_spec
= ENDFILE_SPEC
;
1075 static const char *startfile_spec
= STARTFILE_SPEC
;
1076 static const char *linker_name_spec
= LINKER_NAME
;
1077 static const char *linker_plugin_file_spec
= "";
1078 static const char *lto_wrapper_spec
= "";
1079 static const char *lto_gcc_spec
= "";
1080 static const char *post_link_spec
= POST_LINK_SPEC
;
1081 static const char *link_command_spec
= LINK_COMMAND_SPEC
;
1082 static const char *link_libgcc_spec
= LINK_LIBGCC_SPEC
;
1083 static const char *startfile_prefix_spec
= STARTFILE_PREFIX_SPEC
;
1084 static const char *sysroot_spec
= SYSROOT_SPEC
;
1085 static const char *sysroot_suffix_spec
= SYSROOT_SUFFIX_SPEC
;
1086 static const char *sysroot_hdrs_suffix_spec
= SYSROOT_HEADERS_SUFFIX_SPEC
;
1087 static const char *self_spec
= "";
1089 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
1090 There should be no need to override these in target dependent files,
1091 but we need to copy them to the specs file so that newer versions
1092 of the GCC driver can correctly drive older tool chains with the
1093 appropriate -B options. */
1095 /* When cpplib handles traditional preprocessing, get rid of this, and
1096 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
1097 that we default the front end language better. */
1098 static const char *trad_capable_cpp
=
1099 "cc1 -E %{traditional|traditional-cpp:-traditional-cpp}";
1101 /* We don't wrap .d files in %W{} since a missing .d file, and
1102 therefore no dependency entry, confuses make into thinking a .o
1103 file that happens to exist is up-to-date. */
1104 static const char *cpp_unique_options
=
1105 "%{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\
1106 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
1107 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
1108 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
1109 %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
1110 %{remap} %{g3|ggdb3|gstabs3|gcoff3|gxcoff3|gvms3:-dD}\
1111 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
1112 %{H} %C %{D*&U*&A*} %{i*} %Z %i\
1115 /* This contains cpp options which are common with cc1_options and are passed
1116 only when preprocessing only to avoid duplication. We pass the cc1 spec
1117 options to the preprocessor so that it the cc1 spec may manipulate
1118 options used to set target flags. Those special target flags settings may
1119 in turn cause preprocessor symbols to be defined specially. */
1120 static const char *cpp_options
=
1121 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
1122 %{f*} %{g*:%{!g0:%{g*} %{!fno-working-directory:-fworking-directory}}} %{O*}\
1123 %{undef} %{save-temps*:-fpch-preprocess}";
1125 /* This contains cpp options which are not passed when the preprocessor
1126 output will be used by another program. */
1127 static const char *cpp_debug_options
= "%{d*}";
1129 /* NB: This is shared amongst all front-ends, except for Ada. */
1130 static const char *cc1_options
=
1131 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
1132 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
1133 %1 %{!Q:-quiet} %{!dumpbase:-dumpbase %B} %{d*} %{m*} %{aux-info*}\
1134 %{fcompare-debug-second:%:compare-debug-auxbase-opt(%b)} \
1135 %{!fcompare-debug-second:%{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}}%{!c:%{!S:-auxbase %b}} \
1136 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
1137 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
1138 %{Qn:-fno-ident} %{Qy:} %{-help:--help}\
1139 %{-target-help:--target-help}\
1140 %{-version:--version}\
1141 %{-help=*:--help=%*}\
1142 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
1143 %{fsyntax-only:-o %j} %{-param*}\
1144 %{coverage:-fprofile-arcs -ftest-coverage}";
1146 static const char *asm_options
=
1147 "%{-target-help:%:print-asm-header()} "
1149 /* If GNU AS is used, then convert -w (no warnings), -I, and -v
1150 to the assembler equivalents. */
1151 "%{v} %{w:-W} %{I*} "
1153 ASM_COMPRESS_DEBUG_SPEC
1154 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
1156 static const char *invoke_as
=
1157 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1159 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
1160 %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
1164 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
1165 %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
1169 /* Some compilers have limits on line lengths, and the multilib_select
1170 and/or multilib_matches strings can be very long, so we build them at
1172 static struct obstack multilib_obstack
;
1173 static const char *multilib_select
;
1174 static const char *multilib_matches
;
1175 static const char *multilib_defaults
;
1176 static const char *multilib_exclusions
;
1177 static const char *multilib_reuse
;
1179 /* Check whether a particular argument is a default argument. */
1181 #ifndef MULTILIB_DEFAULTS
1182 #define MULTILIB_DEFAULTS { "" }
1185 static const char *const multilib_defaults_raw
[] = MULTILIB_DEFAULTS
;
1187 #ifndef DRIVER_SELF_SPECS
1188 #define DRIVER_SELF_SPECS ""
1191 /* Linking to libgomp implies pthreads. This is particularly important
1192 for targets that use different start files and suchlike. */
1193 #ifndef GOMP_SELF_SPECS
1194 #define GOMP_SELF_SPECS \
1195 "%{fopenacc|fopenmp|%:gt(%{ftree-parallelize-loops=*:%*} 1): " \
1199 /* Likewise for -fgnu-tm. */
1200 #ifndef GTM_SELF_SPECS
1201 #define GTM_SELF_SPECS "%{fgnu-tm: -pthread}"
1204 /* Likewise for -fcilkplus. */
1205 #ifndef CILK_SELF_SPECS
1206 #define CILK_SELF_SPECS "%{fcilkplus: -pthread}"
1209 static const char *const driver_self_specs
[] = {
1210 "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
1211 DRIVER_SELF_SPECS
, CONFIGURE_SPECS
, GOMP_SELF_SPECS
, GTM_SELF_SPECS
,
1215 #ifndef OPTION_DEFAULT_SPECS
1216 #define OPTION_DEFAULT_SPECS { "", "" }
1225 static const struct default_spec
1226 option_default_specs
[] = { OPTION_DEFAULT_SPECS
};
1230 struct user_specs
*next
;
1231 const char *filename
;
1234 static struct user_specs
*user_specs_head
, *user_specs_tail
;
1237 /* Record the mapping from file suffixes for compilation specs. */
1241 const char *suffix
; /* Use this compiler for input files
1242 whose names end in this suffix. */
1244 const char *spec
; /* To use this compiler, run this spec. */
1246 const char *cpp_spec
; /* If non-NULL, substitute this spec
1247 for `%C', rather than the usual
1249 const int combinable
; /* If nonzero, compiler can deal with
1250 multiple source files at once (IMA). */
1251 const int needs_preprocessing
; /* If nonzero, source files need to
1252 be run through a preprocessor. */
1255 /* Pointer to a vector of `struct compiler' that gives the spec for
1256 compiling a file, based on its suffix.
1257 A file that does not end in any of these suffixes will be passed
1258 unchanged to the loader and nothing else will be done to it.
1260 An entry containing two 0s is used to terminate the vector.
1262 If multiple entries match a file, the last matching one is used. */
1264 static struct compiler
*compilers
;
1266 /* Number of entries in `compilers', not counting the null terminator. */
1268 static int n_compilers
;
1270 /* The default list of file name suffixes and their compilation specs. */
1272 static const struct compiler default_compilers
[] =
1274 /* Add lists of suffixes of known languages here. If those languages
1275 were not present when we built the driver, we will hit these copies
1276 and be given a more meaningful error than "file not used since
1277 linking is not done". */
1278 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0},
1279 {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
1280 {".mii", "#Objective-C++", 0, 0, 0},
1281 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
1282 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
1283 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
1284 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
1285 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
1286 {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
1287 {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
1288 {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
1289 {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
1290 {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
1291 {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
1292 {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
1293 {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
1294 {".r", "#Ratfor", 0, 0, 0},
1295 {".p", "#Pascal", 0, 0, 0}, {".pas", "#Pascal", 0, 0, 0},
1296 {".java", "#Java", 0, 0, 0}, {".class", "#Java", 0, 0, 0},
1297 {".zip", "#Java", 0, 0, 0}, {".jar", "#Java", 0, 0, 0},
1298 {".go", "#Go", 0, 1, 0},
1299 /* Next come the entries for C. */
1300 {".c", "@c", 0, 0, 1},
1302 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1303 external preprocessor if -save-temps is given. */
1304 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1307 %eGNU C no longer supports -traditional without -E}\
1308 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1309 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1310 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1312 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1313 cc1 %(cpp_unique_options) %(cc1_options)}}}\
1314 %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 1},
1316 "%{!E:%e-E or -x required when input is from standard input}\
1317 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
1318 {".h", "@c-header", 0, 0, 0},
1320 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1321 external preprocessor if -save-temps is given. */
1322 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1324 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1325 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1326 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1328 %{!fsyntax-only:-o %g.s \
1329 %{!fdump-ada-spec*:%{!o*:--output-pch=%i.gch}\
1330 %W{o*:--output-pch=%*}}%V}}\
1331 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1332 cc1 %(cpp_unique_options) %(cc1_options)\
1333 %{!fsyntax-only:-o %g.s \
1334 %{!fdump-ada-spec*:%{!o*:--output-pch=%i.gch}\
1335 %W{o*:--output-pch=%*}}%V}}}}}}}", 0, 0, 0},
1336 {".i", "@cpp-output", 0, 0, 0},
1338 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 0},
1339 {".s", "@assembler", 0, 0, 0},
1341 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 0, 0},
1342 {".sx", "@assembler-with-cpp", 0, 0, 0},
1343 {".S", "@assembler-with-cpp", 0, 0, 0},
1344 {"@assembler-with-cpp",
1345 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1346 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1347 %{E|M|MM:%(cpp_debug_options)}\
1348 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1349 as %(asm_debug) %(asm_options) %|.s %A }}}}"
1351 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1352 %{E|M|MM:%(cpp_debug_options)}\
1353 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1354 as %(asm_debug) %(asm_options) %m.s %A }}}}"
1359 /* Mark end of table. */
1363 /* Number of elements in default_compilers, not counting the terminator. */
1365 static const int n_default_compilers
= ARRAY_SIZE (default_compilers
) - 1;
1367 typedef char *char_p
; /* For DEF_VEC_P. */
1369 /* A vector of options to give to the linker.
1370 These options are accumulated by %x,
1371 and substituted into the linker command with %X. */
1372 static vec
<char_p
> linker_options
;
1374 /* A vector of options to give to the assembler.
1375 These options are accumulated by -Wa,
1376 and substituted into the assembler command with %Y. */
1377 static vec
<char_p
> assembler_options
;
1379 /* A vector of options to give to the preprocessor.
1380 These options are accumulated by -Wp,
1381 and substituted into the preprocessor command with %Z. */
1382 static vec
<char_p
> preprocessor_options
;
1385 skip_whitespace (char *p
)
1389 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1390 be considered whitespace. */
1391 if (p
[0] == '\n' && p
[1] == '\n' && p
[2] == '\n')
1393 else if (*p
== '\n' || *p
== ' ' || *p
== '\t')
1407 /* Structures to keep track of prefixes to try when looking for files. */
1411 const char *prefix
; /* String to prepend to the path. */
1412 struct prefix_list
*next
; /* Next in linked list. */
1413 int require_machine_suffix
; /* Don't use without machine_suffix. */
1414 /* 2 means try both machine_suffix and just_machine_suffix. */
1415 int priority
; /* Sort key - priority within list. */
1416 int os_multilib
; /* 1 if OS multilib scheme should be used,
1417 0 for GCC multilib scheme. */
1422 struct prefix_list
*plist
; /* List of prefixes to try */
1423 int max_len
; /* Max length of a prefix in PLIST */
1424 const char *name
; /* Name of this list (used in config stuff) */
1427 /* List of prefixes to try when looking for executables. */
1429 static struct path_prefix exec_prefixes
= { 0, 0, "exec" };
1431 /* List of prefixes to try when looking for startup (crt0) files. */
1433 static struct path_prefix startfile_prefixes
= { 0, 0, "startfile" };
1435 /* List of prefixes to try when looking for include files. */
1437 static struct path_prefix include_prefixes
= { 0, 0, "include" };
1439 /* Suffix to attach to directories searched for commands.
1440 This looks like `MACHINE/VERSION/'. */
1442 static const char *machine_suffix
= 0;
1444 /* Suffix to attach to directories searched for commands.
1445 This is just `MACHINE/'. */
1447 static const char *just_machine_suffix
= 0;
1449 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1451 static const char *gcc_exec_prefix
;
1453 /* Adjusted value of standard_libexec_prefix. */
1455 static const char *gcc_libexec_prefix
;
1457 /* Default prefixes to attach to command names. */
1459 #ifndef STANDARD_STARTFILE_PREFIX_1
1460 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1462 #ifndef STANDARD_STARTFILE_PREFIX_2
1463 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1466 #ifdef CROSS_DIRECTORY_STRUCTURE /* Don't use these prefixes for a cross compiler. */
1467 #undef MD_EXEC_PREFIX
1468 #undef MD_STARTFILE_PREFIX
1469 #undef MD_STARTFILE_PREFIX_1
1472 /* If no prefixes defined, use the null string, which will disable them. */
1473 #ifndef MD_EXEC_PREFIX
1474 #define MD_EXEC_PREFIX ""
1476 #ifndef MD_STARTFILE_PREFIX
1477 #define MD_STARTFILE_PREFIX ""
1479 #ifndef MD_STARTFILE_PREFIX_1
1480 #define MD_STARTFILE_PREFIX_1 ""
1483 /* These directories are locations set at configure-time based on the
1484 --prefix option provided to configure. Their initializers are
1485 defined in Makefile.in. These paths are not *directly* used when
1486 gcc_exec_prefix is set because, in that case, we know where the
1487 compiler has been installed, and use paths relative to that
1488 location instead. */
1489 static const char *const standard_exec_prefix
= STANDARD_EXEC_PREFIX
;
1490 static const char *const standard_libexec_prefix
= STANDARD_LIBEXEC_PREFIX
;
1491 static const char *const standard_bindir_prefix
= STANDARD_BINDIR_PREFIX
;
1492 static const char *const standard_startfile_prefix
= STANDARD_STARTFILE_PREFIX
;
1494 /* For native compilers, these are well-known paths containing
1495 components that may be provided by the system. For cross
1496 compilers, these paths are not used. */
1497 static const char *md_exec_prefix
= MD_EXEC_PREFIX
;
1498 static const char *md_startfile_prefix
= MD_STARTFILE_PREFIX
;
1499 static const char *md_startfile_prefix_1
= MD_STARTFILE_PREFIX_1
;
1500 static const char *const standard_startfile_prefix_1
1501 = STANDARD_STARTFILE_PREFIX_1
;
1502 static const char *const standard_startfile_prefix_2
1503 = STANDARD_STARTFILE_PREFIX_2
;
1505 /* A relative path to be used in finding the location of tools
1506 relative to the driver. */
1507 static const char *const tooldir_base_prefix
= TOOLDIR_BASE_PREFIX
;
1509 /* A prefix to be used when this is an accelerator compiler. */
1510 static const char *const accel_dir_suffix
= ACCEL_DIR_SUFFIX
;
1512 /* Subdirectory to use for locating libraries. Set by
1513 set_multilib_dir based on the compilation options. */
1515 static const char *multilib_dir
;
1517 /* Subdirectory to use for locating libraries in OS conventions. Set by
1518 set_multilib_dir based on the compilation options. */
1520 static const char *multilib_os_dir
;
1522 /* Subdirectory to use for locating libraries in multiarch conventions. Set by
1523 set_multilib_dir based on the compilation options. */
1525 static const char *multiarch_dir
;
1527 /* Structure to keep track of the specs that have been defined so far.
1528 These are accessed using %(specname) in a compiler or link
1533 /* The following 2 fields must be first */
1534 /* to allow EXTRA_SPECS to be initialized */
1535 const char *name
; /* name of the spec. */
1536 const char *ptr
; /* available ptr if no static pointer */
1538 /* The following fields are not initialized */
1539 /* by EXTRA_SPECS */
1540 const char **ptr_spec
; /* pointer to the spec itself. */
1541 struct spec_list
*next
; /* Next spec in linked list. */
1542 int name_len
; /* length of the name */
1543 bool user_p
; /* whether string come from file spec. */
1544 bool alloc_p
; /* whether string was allocated */
1545 const char *default_ptr
; /* The default value of *ptr_spec. */
1548 #define INIT_STATIC_SPEC(NAME,PTR) \
1549 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, false, false, \
1552 /* List of statically defined specs. */
1553 static struct spec_list static_specs
[] =
1555 INIT_STATIC_SPEC ("asm", &asm_spec
),
1556 INIT_STATIC_SPEC ("asm_debug", &asm_debug
),
1557 INIT_STATIC_SPEC ("asm_final", &asm_final_spec
),
1558 INIT_STATIC_SPEC ("asm_options", &asm_options
),
1559 INIT_STATIC_SPEC ("invoke_as", &invoke_as
),
1560 INIT_STATIC_SPEC ("cpp", &cpp_spec
),
1561 INIT_STATIC_SPEC ("cpp_options", &cpp_options
),
1562 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options
),
1563 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options
),
1564 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp
),
1565 INIT_STATIC_SPEC ("cc1", &cc1_spec
),
1566 INIT_STATIC_SPEC ("cc1_options", &cc1_options
),
1567 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec
),
1568 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec
),
1569 INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec
),
1570 INIT_STATIC_SPEC ("endfile", &endfile_spec
),
1571 INIT_STATIC_SPEC ("link", &link_spec
),
1572 INIT_STATIC_SPEC ("lib", &lib_spec
),
1573 INIT_STATIC_SPEC ("link_gomp", &link_gomp_spec
),
1574 INIT_STATIC_SPEC ("libgcc", &libgcc_spec
),
1575 INIT_STATIC_SPEC ("startfile", &startfile_spec
),
1576 INIT_STATIC_SPEC ("cross_compile", &cross_compile
),
1577 INIT_STATIC_SPEC ("version", &compiler_version
),
1578 INIT_STATIC_SPEC ("multilib", &multilib_select
),
1579 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults
),
1580 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra
),
1581 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches
),
1582 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions
),
1583 INIT_STATIC_SPEC ("multilib_options", &multilib_options
),
1584 INIT_STATIC_SPEC ("multilib_reuse", &multilib_reuse
),
1585 INIT_STATIC_SPEC ("linker", &linker_name_spec
),
1586 INIT_STATIC_SPEC ("linker_plugin_file", &linker_plugin_file_spec
),
1587 INIT_STATIC_SPEC ("lto_wrapper", <o_wrapper_spec
),
1588 INIT_STATIC_SPEC ("lto_gcc", <o_gcc_spec
),
1589 INIT_STATIC_SPEC ("post_link", &post_link_spec
),
1590 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec
),
1591 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix
),
1592 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix
),
1593 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1
),
1594 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec
),
1595 INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec
),
1596 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec
),
1597 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec
),
1598 INIT_STATIC_SPEC ("self_spec", &self_spec
),
1601 #ifdef EXTRA_SPECS /* additional specs needed */
1602 /* Structure to keep track of just the first two args of a spec_list.
1603 That is all that the EXTRA_SPECS macro gives us. */
1606 const char *const name
;
1607 const char *const ptr
;
1610 static const struct spec_list_1 extra_specs_1
[] = { EXTRA_SPECS
};
1611 static struct spec_list
*extra_specs
= (struct spec_list
*) 0;
1614 /* List of dynamically allocates specs that have been defined so far. */
1616 static struct spec_list
*specs
= (struct spec_list
*) 0;
1618 /* List of static spec functions. */
1620 static const struct spec_function static_spec_functions
[] =
1622 { "getenv", getenv_spec_function
},
1623 { "if-exists", if_exists_spec_function
},
1624 { "if-exists-else", if_exists_else_spec_function
},
1625 { "sanitize", sanitize_spec_function
},
1626 { "replace-outfile", replace_outfile_spec_function
},
1627 { "remove-outfile", remove_outfile_spec_function
},
1628 { "version-compare", version_compare_spec_function
},
1629 { "include", include_spec_function
},
1630 { "find-file", find_file_spec_function
},
1631 { "find-plugindir", find_plugindir_spec_function
},
1632 { "print-asm-header", print_asm_header_spec_function
},
1633 { "compare-debug-dump-opt", compare_debug_dump_opt_spec_function
},
1634 { "compare-debug-self-opt", compare_debug_self_opt_spec_function
},
1635 { "compare-debug-auxbase-opt", compare_debug_auxbase_opt_spec_function
},
1636 { "pass-through-libs", pass_through_libs_spec_func
},
1637 { "replace-extension", replace_extension_spec_func
},
1638 { "gt", greater_than_spec_func
},
1639 #ifdef EXTRA_SPEC_FUNCTIONS
1640 EXTRA_SPEC_FUNCTIONS
1645 static int processing_spec_function
;
1647 /* Add appropriate libgcc specs to OBSTACK, taking into account
1648 various permutations of -shared-libgcc, -shared, and such. */
1650 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1652 #ifndef USE_LD_AS_NEEDED
1653 #define USE_LD_AS_NEEDED 0
1657 init_gcc_specs (struct obstack
*obstack
, const char *shared_name
,
1658 const char *static_name
, const char *eh_name
)
1662 buf
= concat ("%{static|static-libgcc:", static_name
, " ", eh_name
, "}"
1663 "%{!static:%{!static-libgcc:"
1664 #if USE_LD_AS_NEEDED
1665 "%{!shared-libgcc:",
1666 static_name
, " " LD_AS_NEEDED_OPTION
" ",
1667 shared_name
, " " LD_NO_AS_NEEDED_OPTION
1670 shared_name
, "%{!shared: ", static_name
, "}"
1674 "%{!shared-libgcc:", static_name
, " ", eh_name
, "}"
1675 "%{shared-libgcc:", shared_name
, " ", static_name
, "}"
1679 "%{shared-libgcc:", shared_name
, "}"
1680 "%{!shared-libgcc:", static_name
, "}"
1683 "%{shared:", shared_name
, "}"
1688 obstack_grow (obstack
, buf
, strlen (buf
));
1691 #endif /* ENABLE_SHARED_LIBGCC */
1693 /* Initialize the specs lookup routines. */
1698 struct spec_list
*next
= (struct spec_list
*) 0;
1699 struct spec_list
*sl
= (struct spec_list
*) 0;
1703 return; /* Already initialized. */
1706 fnotice (stderr
, "Using built-in specs.\n");
1709 extra_specs
= XCNEWVEC (struct spec_list
, ARRAY_SIZE (extra_specs_1
));
1711 for (i
= ARRAY_SIZE (extra_specs_1
) - 1; i
>= 0; i
--)
1713 sl
= &extra_specs
[i
];
1714 sl
->name
= extra_specs_1
[i
].name
;
1715 sl
->ptr
= extra_specs_1
[i
].ptr
;
1717 sl
->name_len
= strlen (sl
->name
);
1718 sl
->ptr_spec
= &sl
->ptr
;
1719 gcc_assert (sl
->ptr_spec
!= NULL
);
1720 sl
->default_ptr
= sl
->ptr
;
1725 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1727 sl
= &static_specs
[i
];
1732 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1733 /* ??? If neither -shared-libgcc nor --static-libgcc was
1734 seen, then we should be making an educated guess. Some proposed
1735 heuristics for ELF include:
1737 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1738 program will be doing dynamic loading, which will likely
1739 need the shared libgcc.
1741 (2) If "-ldl", then it's also a fair bet that we're doing
1744 (3) For each ET_DYN we're linking against (either through -lfoo
1745 or /some/path/foo.so), check to see whether it or one of
1746 its dependencies depends on a shared libgcc.
1750 If the runtime is fixed to look for program headers instead
1751 of calling __register_frame_info at all, for each object,
1752 use the shared libgcc if any EH symbol referenced.
1754 If crtstuff is fixed to not invoke __register_frame_info
1755 automatically, for each object, use the shared libgcc if
1756 any non-empty unwind section found.
1758 Doing any of this probably requires invoking an external program to
1759 do the actual object file scanning. */
1761 const char *p
= libgcc_spec
;
1764 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1765 when given the proper command line arguments. */
1768 if (in_sep
&& *p
== '-' && strncmp (p
, "-lgcc", 5) == 0)
1770 init_gcc_specs (&obstack
,
1772 #ifdef USE_LIBUNWIND_EXCEPTIONS
1778 #ifdef USE_LIBUNWIND_EXCEPTIONS
1779 # ifdef HAVE_LD_STATIC_DYNAMIC
1780 " %{!static:" LD_STATIC_OPTION
"} -lunwind"
1781 " %{!static:" LD_DYNAMIC_OPTION
"}"
1791 else if (in_sep
&& *p
== 'l' && strncmp (p
, "libgcc.a%s", 10) == 0)
1793 /* Ug. We don't know shared library extensions. Hope that
1794 systems that use this form don't do shared libraries. */
1795 init_gcc_specs (&obstack
,
1799 #ifdef USE_LIBUNWIND_EXCEPTIONS
1808 obstack_1grow (&obstack
, *p
);
1809 in_sep
= (*p
== ' ');
1814 obstack_1grow (&obstack
, '\0');
1815 libgcc_spec
= XOBFINISH (&obstack
, const char *);
1818 #ifdef USE_AS_TRADITIONAL_FORMAT
1819 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1821 static const char tf
[] = "--traditional-format ";
1822 obstack_grow (&obstack
, tf
, sizeof (tf
) - 1);
1823 obstack_grow0 (&obstack
, asm_spec
, strlen (asm_spec
));
1824 asm_spec
= XOBFINISH (&obstack
, const char *);
1828 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC || \
1829 defined LINKER_HASH_STYLE
1830 # ifdef LINK_BUILDID_SPEC
1831 /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. */
1832 obstack_grow (&obstack
, LINK_BUILDID_SPEC
, sizeof (LINK_BUILDID_SPEC
) - 1);
1834 # ifdef LINK_EH_SPEC
1835 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1836 obstack_grow (&obstack
, LINK_EH_SPEC
, sizeof (LINK_EH_SPEC
) - 1);
1838 # ifdef LINKER_HASH_STYLE
1839 /* Prepend --hash-style=LINKER_HASH_STYLE to whatever link_spec we had
1842 static const char hash_style
[] = "--hash-style=";
1843 obstack_grow (&obstack
, hash_style
, sizeof (hash_style
) - 1);
1844 obstack_grow (&obstack
, LINKER_HASH_STYLE
, sizeof (LINKER_HASH_STYLE
) - 1);
1845 obstack_1grow (&obstack
, ' ');
1848 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
1849 link_spec
= XOBFINISH (&obstack
, const char *);
1855 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1856 removed; If the spec starts with a + then SPEC is added to the end of the
1860 set_spec (const char *name
, const char *spec
, bool user_p
)
1862 struct spec_list
*sl
;
1863 const char *old_spec
;
1864 int name_len
= strlen (name
);
1867 /* If this is the first call, initialize the statically allocated specs. */
1870 struct spec_list
*next
= (struct spec_list
*) 0;
1871 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1873 sl
= &static_specs
[i
];
1880 /* See if the spec already exists. */
1881 for (sl
= specs
; sl
; sl
= sl
->next
)
1882 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, name
))
1887 /* Not found - make it. */
1888 sl
= XNEW (struct spec_list
);
1889 sl
->name
= xstrdup (name
);
1890 sl
->name_len
= name_len
;
1891 sl
->ptr_spec
= &sl
->ptr
;
1893 *(sl
->ptr_spec
) = "";
1895 sl
->default_ptr
= NULL
;
1899 old_spec
= *(sl
->ptr_spec
);
1900 *(sl
->ptr_spec
) = ((spec
[0] == '+' && ISSPACE ((unsigned char)spec
[1]))
1901 ? concat (old_spec
, spec
+ 1, NULL
)
1906 fnotice (stderr
, "Setting spec %s to '%s'\n\n", name
, *(sl
->ptr_spec
));
1909 /* Free the old spec. */
1910 if (old_spec
&& sl
->alloc_p
)
1911 free (CONST_CAST (char *, old_spec
));
1913 sl
->user_p
= user_p
;
1917 /* Accumulate a command (program name and args), and run it. */
1919 typedef const char *const_char_p
; /* For DEF_VEC_P. */
1921 /* Vector of pointers to arguments in the current line of specifications. */
1923 static vec
<const_char_p
> argbuf
;
1925 /* Were the options -c, -S or -E passed. */
1926 static int have_c
= 0;
1928 /* Was the option -o passed. */
1929 static int have_o
= 0;
1931 /* Pointer to output file name passed in with -o. */
1932 static const char *output_file
= 0;
1934 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1935 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
1938 static struct temp_name
{
1939 const char *suffix
; /* suffix associated with the code. */
1940 int length
; /* strlen (suffix). */
1941 int unique
; /* Indicates whether %g or %u/%U was used. */
1942 const char *filename
; /* associated filename. */
1943 int filename_length
; /* strlen (filename). */
1944 struct temp_name
*next
;
1947 /* Number of commands executed so far. */
1949 static int execution_count
;
1951 /* Number of commands that exited with a signal. */
1953 static int signal_count
;
1955 /* Allocate the argument vector. */
1963 /* Clear out the vector of arguments (after a command is executed). */
1968 argbuf
.truncate (0);
1971 /* Add one argument to the vector at the end.
1972 This is done when a space is seen or at the end of the line.
1973 If DELETE_ALWAYS is nonzero, the arg is a filename
1974 and the file should be deleted eventually.
1975 If DELETE_FAILURE is nonzero, the arg is a filename
1976 and the file should be deleted if this compilation fails. */
1979 store_arg (const char *arg
, int delete_always
, int delete_failure
)
1981 argbuf
.safe_push (arg
);
1983 if (delete_always
|| delete_failure
)
1986 /* If the temporary file we should delete is specified as
1987 part of a joined argument extract the filename. */
1989 && (p
= strrchr (arg
, '=')))
1991 record_temp_file (arg
, delete_always
, delete_failure
);
1995 /* Load specs from a file name named FILENAME, replacing occurrences of
1996 various different types of line-endings, \r\n, \n\r and just \r, with
2000 load_specs (const char *filename
)
2004 struct stat statbuf
;
2011 fnotice (stderr
, "Reading specs from %s\n", filename
);
2013 /* Open and stat the file. */
2014 desc
= open (filename
, O_RDONLY
, 0);
2016 pfatal_with_name (filename
);
2017 if (stat (filename
, &statbuf
) < 0)
2018 pfatal_with_name (filename
);
2020 /* Read contents of file into BUFFER. */
2021 buffer
= XNEWVEC (char, statbuf
.st_size
+ 1);
2022 readlen
= read (desc
, buffer
, (unsigned) statbuf
.st_size
);
2024 pfatal_with_name (filename
);
2025 buffer
[readlen
] = 0;
2028 specs
= XNEWVEC (char, readlen
+ 1);
2030 for (buffer_p
= buffer
; buffer_p
&& *buffer_p
; buffer_p
++)
2036 if (buffer_p
> buffer
&& *(buffer_p
- 1) == '\n') /* \n\r */
2038 else if (*(buffer_p
+ 1) == '\n') /* \r\n */
2052 /* Read compilation specs from a file named FILENAME,
2053 replacing the default ones.
2055 A suffix which starts with `*' is a definition for
2056 one of the machine-specific sub-specs. The "suffix" should be
2057 *asm, *cc1, *cpp, *link, *startfile, etc.
2058 The corresponding spec is stored in asm_spec, etc.,
2059 rather than in the `compilers' vector.
2061 Anything invalid in the file is a fatal error. */
2064 read_specs (const char *filename
, bool main_p
, bool user_p
)
2069 buffer
= load_specs (filename
);
2071 /* Scan BUFFER for specs, putting them in the vector. */
2077 char *in
, *out
, *p1
, *p2
, *p3
;
2079 /* Advance P in BUFFER to the next nonblank nocomment line. */
2080 p
= skip_whitespace (p
);
2084 /* Is this a special command that starts with '%'? */
2085 /* Don't allow this for the main specs file, since it would
2086 encourage people to overwrite it. */
2087 if (*p
== '%' && !main_p
)
2090 while (*p
&& *p
!= '\n')
2096 if (!strncmp (p1
, "%include", sizeof ("%include") - 1)
2097 && (p1
[sizeof "%include" - 1] == ' '
2098 || p1
[sizeof "%include" - 1] == '\t'))
2102 p1
+= sizeof ("%include");
2103 while (*p1
== ' ' || *p1
== '\t')
2106 if (*p1
++ != '<' || p
[-2] != '>')
2107 fatal_error (input_location
,
2108 "specs %%include syntax malformed after "
2110 (long) (p1
- buffer
+ 1));
2113 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
2114 read_specs (new_filename
? new_filename
: p1
, false, user_p
);
2117 else if (!strncmp (p1
, "%include_noerr", sizeof "%include_noerr" - 1)
2118 && (p1
[sizeof "%include_noerr" - 1] == ' '
2119 || p1
[sizeof "%include_noerr" - 1] == '\t'))
2123 p1
+= sizeof "%include_noerr";
2124 while (*p1
== ' ' || *p1
== '\t')
2127 if (*p1
++ != '<' || p
[-2] != '>')
2128 fatal_error (input_location
,
2129 "specs %%include syntax malformed after "
2131 (long) (p1
- buffer
+ 1));
2134 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
2136 read_specs (new_filename
, false, user_p
);
2137 else if (verbose_flag
)
2138 fnotice (stderr
, "could not find specs file %s\n", p1
);
2141 else if (!strncmp (p1
, "%rename", sizeof "%rename" - 1)
2142 && (p1
[sizeof "%rename" - 1] == ' '
2143 || p1
[sizeof "%rename" - 1] == '\t'))
2146 struct spec_list
*sl
;
2147 struct spec_list
*newsl
;
2149 /* Get original name. */
2150 p1
+= sizeof "%rename";
2151 while (*p1
== ' ' || *p1
== '\t')
2154 if (! ISALPHA ((unsigned char) *p1
))
2155 fatal_error (input_location
,
2156 "specs %%rename syntax malformed after "
2158 (long) (p1
- buffer
));
2161 while (*p2
&& !ISSPACE ((unsigned char) *p2
))
2164 if (*p2
!= ' ' && *p2
!= '\t')
2165 fatal_error (input_location
,
2166 "specs %%rename syntax malformed after "
2168 (long) (p2
- buffer
));
2172 while (*p2
== ' ' || *p2
== '\t')
2175 if (! ISALPHA ((unsigned char) *p2
))
2176 fatal_error (input_location
,
2177 "specs %%rename syntax malformed after "
2179 (long) (p2
- buffer
));
2181 /* Get new spec name. */
2183 while (*p3
&& !ISSPACE ((unsigned char) *p3
))
2187 fatal_error (input_location
,
2188 "specs %%rename syntax malformed after "
2190 (long) (p3
- buffer
));
2193 for (sl
= specs
; sl
; sl
= sl
->next
)
2194 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, p1
))
2198 fatal_error (input_location
,
2199 "specs %s spec was not found to be renamed", p1
);
2201 if (strcmp (p1
, p2
) == 0)
2204 for (newsl
= specs
; newsl
; newsl
= newsl
->next
)
2205 if (strcmp (newsl
->name
, p2
) == 0)
2206 fatal_error (input_location
,
2207 "%s: attempt to rename spec %qs to "
2208 "already defined spec %qs",
2213 fnotice (stderr
, "rename spec %s to %s\n", p1
, p2
);
2215 fnotice (stderr
, "spec is '%s'\n\n", *(sl
->ptr_spec
));
2219 set_spec (p2
, *(sl
->ptr_spec
), user_p
);
2221 free (CONST_CAST (char *, *(sl
->ptr_spec
)));
2223 *(sl
->ptr_spec
) = "";
2228 fatal_error (input_location
,
2229 "specs unknown %% command after %ld characters",
2230 (long) (p1
- buffer
));
2233 /* Find the colon that should end the suffix. */
2235 while (*p1
&& *p1
!= ':' && *p1
!= '\n')
2238 /* The colon shouldn't be missing. */
2240 fatal_error (input_location
,
2241 "specs file malformed after %ld characters",
2242 (long) (p1
- buffer
));
2244 /* Skip back over trailing whitespace. */
2246 while (p2
> buffer
&& (p2
[-1] == ' ' || p2
[-1] == '\t'))
2249 /* Copy the suffix to a string. */
2250 suffix
= save_string (p
, p2
- p
);
2251 /* Find the next line. */
2252 p
= skip_whitespace (p1
+ 1);
2254 fatal_error (input_location
,
2255 "specs file malformed after %ld characters",
2256 (long) (p
- buffer
));
2259 /* Find next blank line or end of string. */
2260 while (*p1
&& !(*p1
== '\n' && (p1
[1] == '\n' || p1
[1] == '\0')))
2263 /* Specs end at the blank line and do not include the newline. */
2264 spec
= save_string (p
, p1
- p
);
2267 /* Delete backslash-newline sequences from the spec. */
2272 if (in
[0] == '\\' && in
[1] == '\n')
2274 else if (in
[0] == '#')
2275 while (*in
&& *in
!= '\n')
2283 if (suffix
[0] == '*')
2285 if (! strcmp (suffix
, "*link_command"))
2286 link_command_spec
= spec
;
2289 set_spec (suffix
+ 1, spec
, user_p
);
2295 /* Add this pair to the vector. */
2297 = XRESIZEVEC (struct compiler
, compilers
, n_compilers
+ 2);
2299 compilers
[n_compilers
].suffix
= suffix
;
2300 compilers
[n_compilers
].spec
= spec
;
2302 memset (&compilers
[n_compilers
], 0, sizeof compilers
[n_compilers
]);
2306 link_command_spec
= spec
;
2309 if (link_command_spec
== 0)
2310 fatal_error (input_location
, "spec file has no spec for linking");
2312 XDELETEVEC (buffer
);
2315 /* Record the names of temporary files we tell compilers to write,
2316 and delete them at the end of the run. */
2318 /* This is the common prefix we use to make temp file names.
2319 It is chosen once for each run of this program.
2320 It is substituted into a spec by %g or %j.
2321 Thus, all temp file names contain this prefix.
2322 In practice, all temp file names start with this prefix.
2324 This prefix comes from the envvar TMPDIR if it is defined;
2325 otherwise, from the P_tmpdir macro if that is defined;
2326 otherwise, in /usr/tmp or /tmp;
2327 or finally the current directory if all else fails. */
2329 static const char *temp_filename
;
2331 /* Length of the prefix. */
2333 static int temp_filename_length
;
2335 /* Define the list of temporary files to delete. */
2340 struct temp_file
*next
;
2343 /* Queue of files to delete on success or failure of compilation. */
2344 static struct temp_file
*always_delete_queue
;
2345 /* Queue of files to delete on failure of compilation. */
2346 static struct temp_file
*failure_delete_queue
;
2348 /* Record FILENAME as a file to be deleted automatically.
2349 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2350 otherwise delete it in any case.
2351 FAIL_DELETE nonzero means delete it if a compilation step fails;
2352 otherwise delete it in any case. */
2355 record_temp_file (const char *filename
, int always_delete
, int fail_delete
)
2357 char *const name
= xstrdup (filename
);
2361 struct temp_file
*temp
;
2362 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2363 if (! filename_cmp (name
, temp
->name
))
2369 temp
= XNEW (struct temp_file
);
2370 temp
->next
= always_delete_queue
;
2372 always_delete_queue
= temp
;
2379 struct temp_file
*temp
;
2380 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2381 if (! filename_cmp (name
, temp
->name
))
2387 temp
= XNEW (struct temp_file
);
2388 temp
->next
= failure_delete_queue
;
2390 failure_delete_queue
= temp
;
2396 /* Delete all the temporary files whose names we previously recorded. */
2398 #ifndef DELETE_IF_ORDINARY
2399 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2402 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2403 if (unlink (NAME) < 0) \
2405 perror_with_name (NAME); \
2410 delete_if_ordinary (const char *name
)
2416 printf ("Delete %s? (y or n) ", name
);
2420 while ((c
= getchar ()) != '\n' && c
!= EOF
)
2423 if (i
== 'y' || i
== 'Y')
2425 DELETE_IF_ORDINARY (name
, st
, verbose_flag
);
2429 delete_temp_files (void)
2431 struct temp_file
*temp
;
2433 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2434 delete_if_ordinary (temp
->name
);
2435 always_delete_queue
= 0;
2438 /* Delete all the files to be deleted on error. */
2441 delete_failure_queue (void)
2443 struct temp_file
*temp
;
2445 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2446 delete_if_ordinary (temp
->name
);
2450 clear_failure_queue (void)
2452 failure_delete_queue
= 0;
2455 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2457 If DO_MULTI is true iterate over the paths twice, first with multilib
2458 suffix then without, otherwise iterate over the paths once without
2459 adding a multilib suffix. When DO_MULTI is true, some attempt is made
2460 to avoid visiting the same path twice, but we could do better. For
2461 instance, /usr/lib/../lib is considered different from /usr/lib.
2462 At least EXTRA_SPACE chars past the end of the path passed to
2463 CALLBACK are available for use by the callback.
2464 CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2466 Returns the value returned by CALLBACK. */
2469 for_each_path (const struct path_prefix
*paths
,
2472 void *(*callback
) (char *, void *),
2473 void *callback_info
)
2475 struct prefix_list
*pl
;
2476 const char *multi_dir
= NULL
;
2477 const char *multi_os_dir
= NULL
;
2478 const char *multiarch_suffix
= NULL
;
2479 const char *multi_suffix
;
2480 const char *just_multi_suffix
;
2483 bool skip_multi_dir
= false;
2484 bool skip_multi_os_dir
= false;
2486 multi_suffix
= machine_suffix
;
2487 just_multi_suffix
= just_machine_suffix
;
2488 if (do_multi
&& multilib_dir
&& strcmp (multilib_dir
, ".") != 0)
2490 multi_dir
= concat (multilib_dir
, dir_separator_str
, NULL
);
2491 multi_suffix
= concat (multi_suffix
, multi_dir
, NULL
);
2492 just_multi_suffix
= concat (just_multi_suffix
, multi_dir
, NULL
);
2494 if (do_multi
&& multilib_os_dir
&& strcmp (multilib_os_dir
, ".") != 0)
2495 multi_os_dir
= concat (multilib_os_dir
, dir_separator_str
, NULL
);
2497 multiarch_suffix
= concat (multiarch_dir
, dir_separator_str
, NULL
);
2501 size_t multi_dir_len
= 0;
2502 size_t multi_os_dir_len
= 0;
2503 size_t multiarch_len
= 0;
2505 size_t just_suffix_len
;
2509 multi_dir_len
= strlen (multi_dir
);
2511 multi_os_dir_len
= strlen (multi_os_dir
);
2512 if (multiarch_suffix
)
2513 multiarch_len
= strlen (multiarch_suffix
);
2514 suffix_len
= strlen (multi_suffix
);
2515 just_suffix_len
= strlen (just_multi_suffix
);
2519 len
= paths
->max_len
+ extra_space
+ 1;
2520 len
+= MAX (MAX (suffix_len
, multi_os_dir_len
), multiarch_len
);
2521 path
= XNEWVEC (char, len
);
2524 for (pl
= paths
->plist
; pl
!= 0; pl
= pl
->next
)
2526 len
= strlen (pl
->prefix
);
2527 memcpy (path
, pl
->prefix
, len
);
2529 /* Look first in MACHINE/VERSION subdirectory. */
2530 if (!skip_multi_dir
)
2532 memcpy (path
+ len
, multi_suffix
, suffix_len
+ 1);
2533 ret
= callback (path
, callback_info
);
2538 /* Some paths are tried with just the machine (ie. target)
2539 subdir. This is used for finding as, ld, etc. */
2541 && pl
->require_machine_suffix
== 2)
2543 memcpy (path
+ len
, just_multi_suffix
, just_suffix_len
+ 1);
2544 ret
= callback (path
, callback_info
);
2549 /* Now try the multiarch path. */
2551 && !pl
->require_machine_suffix
&& multiarch_dir
)
2553 memcpy (path
+ len
, multiarch_suffix
, multiarch_len
+ 1);
2554 ret
= callback (path
, callback_info
);
2559 /* Now try the base path. */
2560 if (!pl
->require_machine_suffix
2561 && !(pl
->os_multilib
? skip_multi_os_dir
: skip_multi_dir
))
2563 const char *this_multi
;
2564 size_t this_multi_len
;
2566 if (pl
->os_multilib
)
2568 this_multi
= multi_os_dir
;
2569 this_multi_len
= multi_os_dir_len
;
2573 this_multi
= multi_dir
;
2574 this_multi_len
= multi_dir_len
;
2578 memcpy (path
+ len
, this_multi
, this_multi_len
+ 1);
2582 ret
= callback (path
, callback_info
);
2590 if (multi_dir
== NULL
&& multi_os_dir
== NULL
)
2593 /* Run through the paths again, this time without multilibs.
2594 Don't repeat any we have already seen. */
2597 free (CONST_CAST (char *, multi_dir
));
2599 free (CONST_CAST (char *, multi_suffix
));
2600 multi_suffix
= machine_suffix
;
2601 free (CONST_CAST (char *, just_multi_suffix
));
2602 just_multi_suffix
= just_machine_suffix
;
2605 skip_multi_dir
= true;
2608 free (CONST_CAST (char *, multi_os_dir
));
2609 multi_os_dir
= NULL
;
2612 skip_multi_os_dir
= true;
2617 free (CONST_CAST (char *, multi_dir
));
2618 free (CONST_CAST (char *, multi_suffix
));
2619 free (CONST_CAST (char *, just_multi_suffix
));
2622 free (CONST_CAST (char *, multi_os_dir
));
2628 /* Callback for build_search_list. Adds path to obstack being built. */
2630 struct add_to_obstack_info
{
2637 add_to_obstack (char *path
, void *data
)
2639 struct add_to_obstack_info
*info
= (struct add_to_obstack_info
*) data
;
2641 if (info
->check_dir
&& !is_directory (path
, false))
2644 if (!info
->first_time
)
2645 obstack_1grow (info
->ob
, PATH_SEPARATOR
);
2647 obstack_grow (info
->ob
, path
, strlen (path
));
2649 info
->first_time
= false;
2653 /* Add or change the value of an environment variable, outputting the
2654 change to standard error if in verbose mode. */
2656 xputenv (const char *string
)
2661 /* Build a list of search directories from PATHS.
2662 PREFIX is a string to prepend to the list.
2663 If CHECK_DIR_P is true we ensure the directory exists.
2664 If DO_MULTI is true, multilib paths are output first, then
2666 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2667 It is also used by the --print-search-dirs flag. */
2670 build_search_list (const struct path_prefix
*paths
, const char *prefix
,
2671 bool check_dir
, bool do_multi
)
2673 struct add_to_obstack_info info
;
2675 info
.ob
= &collect_obstack
;
2676 info
.check_dir
= check_dir
;
2677 info
.first_time
= true;
2679 obstack_grow (&collect_obstack
, prefix
, strlen (prefix
));
2680 obstack_1grow (&collect_obstack
, '=');
2682 for_each_path (paths
, do_multi
, 0, add_to_obstack
, &info
);
2684 obstack_1grow (&collect_obstack
, '\0');
2685 return XOBFINISH (&collect_obstack
, char *);
2688 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2692 putenv_from_prefixes (const struct path_prefix
*paths
, const char *env_var
,
2695 xputenv (build_search_list (paths
, env_var
, true, do_multi
));
2698 /* Check whether NAME can be accessed in MODE. This is like access,
2699 except that it never considers directories to be executable. */
2702 access_check (const char *name
, int mode
)
2708 if (stat (name
, &st
) < 0
2709 || S_ISDIR (st
.st_mode
))
2713 return access (name
, mode
);
2716 /* Callback for find_a_file. Appends the file name to the directory
2717 path. If the resulting file exists in the right mode, return the
2718 full pathname to the file. */
2720 struct file_at_path_info
{
2729 file_at_path (char *path
, void *data
)
2731 struct file_at_path_info
*info
= (struct file_at_path_info
*) data
;
2732 size_t len
= strlen (path
);
2734 memcpy (path
+ len
, info
->name
, info
->name_len
);
2735 len
+= info
->name_len
;
2737 /* Some systems have a suffix for executable files.
2738 So try appending that first. */
2739 if (info
->suffix_len
)
2741 memcpy (path
+ len
, info
->suffix
, info
->suffix_len
+ 1);
2742 if (access_check (path
, info
->mode
) == 0)
2747 if (access_check (path
, info
->mode
) == 0)
2753 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2754 access to check permissions. If DO_MULTI is true, search multilib
2755 paths then non-multilib paths, otherwise do not search multilib paths.
2756 Return 0 if not found, otherwise return its name, allocated with malloc. */
2759 find_a_file (const struct path_prefix
*pprefix
, const char *name
, int mode
,
2762 struct file_at_path_info info
;
2764 #ifdef DEFAULT_ASSEMBLER
2765 if (! strcmp (name
, "as") && access (DEFAULT_ASSEMBLER
, mode
) == 0)
2766 return xstrdup (DEFAULT_ASSEMBLER
);
2769 #ifdef DEFAULT_LINKER
2770 if (! strcmp (name
, "ld") && access (DEFAULT_LINKER
, mode
) == 0)
2771 return xstrdup (DEFAULT_LINKER
);
2774 /* Determine the filename to execute (special case for absolute paths). */
2776 if (IS_ABSOLUTE_PATH (name
))
2778 if (access (name
, mode
) == 0)
2779 return xstrdup (name
);
2785 info
.suffix
= (mode
& X_OK
) != 0 ? HOST_EXECUTABLE_SUFFIX
: "";
2786 info
.name_len
= strlen (info
.name
);
2787 info
.suffix_len
= strlen (info
.suffix
);
2790 return (char*) for_each_path (pprefix
, do_multi
,
2791 info
.name_len
+ info
.suffix_len
,
2792 file_at_path
, &info
);
2795 /* Ranking of prefixes in the sort list. -B prefixes are put before
2798 enum path_prefix_priority
2800 PREFIX_PRIORITY_B_OPT
,
2801 PREFIX_PRIORITY_LAST
2804 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
2805 order according to PRIORITY. Within each PRIORITY, new entries are
2808 If WARN is nonzero, we will warn if no file is found
2809 through this prefix. WARN should point to an int
2810 which will be set to 1 if this entry is used.
2812 COMPONENT is the value to be passed to update_path.
2814 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2815 the complete value of machine_suffix.
2816 2 means try both machine_suffix and just_machine_suffix. */
2819 add_prefix (struct path_prefix
*pprefix
, const char *prefix
,
2820 const char *component
, /* enum prefix_priority */ int priority
,
2821 int require_machine_suffix
, int os_multilib
)
2823 struct prefix_list
*pl
, **prev
;
2826 for (prev
= &pprefix
->plist
;
2827 (*prev
) != NULL
&& (*prev
)->priority
<= priority
;
2828 prev
= &(*prev
)->next
)
2831 /* Keep track of the longest prefix. */
2833 prefix
= update_path (prefix
, component
);
2834 len
= strlen (prefix
);
2835 if (len
> pprefix
->max_len
)
2836 pprefix
->max_len
= len
;
2838 pl
= XNEW (struct prefix_list
);
2839 pl
->prefix
= prefix
;
2840 pl
->require_machine_suffix
= require_machine_suffix
;
2841 pl
->priority
= priority
;
2842 pl
->os_multilib
= os_multilib
;
2844 /* Insert after PREV. */
2849 /* Same as add_prefix, but prepending target_system_root to prefix. */
2850 /* The target_system_root prefix has been relocated by gcc_exec_prefix. */
2852 add_sysrooted_prefix (struct path_prefix
*pprefix
, const char *prefix
,
2853 const char *component
,
2854 /* enum prefix_priority */ int priority
,
2855 int require_machine_suffix
, int os_multilib
)
2857 if (!IS_ABSOLUTE_PATH (prefix
))
2858 fatal_error (input_location
, "system path %qs is not absolute", prefix
);
2860 if (target_system_root
)
2862 char *sysroot_no_trailing_dir_separator
= xstrdup (target_system_root
);
2863 size_t sysroot_len
= strlen (target_system_root
);
2866 && target_system_root
[sysroot_len
- 1] == DIR_SEPARATOR
)
2867 sysroot_no_trailing_dir_separator
[sysroot_len
- 1] = '\0';
2869 if (target_sysroot_suffix
)
2870 prefix
= concat (sysroot_no_trailing_dir_separator
,
2871 target_sysroot_suffix
, prefix
, NULL
);
2873 prefix
= concat (sysroot_no_trailing_dir_separator
, prefix
, NULL
);
2875 free (sysroot_no_trailing_dir_separator
);
2877 /* We have to override this because GCC's notion of sysroot
2878 moves along with GCC. */
2882 add_prefix (pprefix
, prefix
, component
, priority
,
2883 require_machine_suffix
, os_multilib
);
2886 /* Execute the command specified by the arguments on the current line of spec.
2887 When using pipes, this includes several piped-together commands
2888 with `|' between them.
2890 Return 0 if successful, -1 if failed. */
2896 int n_commands
; /* # of command. */
2898 struct pex_obj
*pex
;
2901 const char *prog
; /* program name. */
2902 const char **argv
; /* vector of args. */
2906 struct command
*commands
; /* each command buffer with above info. */
2908 gcc_assert (!processing_spec_function
);
2912 string
= find_a_file (&exec_prefixes
,
2913 argbuf
[0], X_OK
, false);
2916 insert_wrapper (wrapper_string
);
2919 /* Count # of piped commands. */
2920 for (n_commands
= 1, i
= 0; argbuf
.iterate (i
, &arg
); i
++)
2921 if (strcmp (arg
, "|") == 0)
2924 /* Get storage for each command. */
2925 commands
= (struct command
*) alloca (n_commands
* sizeof (struct command
));
2927 /* Split argbuf into its separate piped processes,
2928 and record info about each one.
2929 Also search for the programs that are to be run. */
2931 argbuf
.safe_push (0);
2933 commands
[0].prog
= argbuf
[0]; /* first command. */
2934 commands
[0].argv
= argbuf
.address ();
2936 if (!wrapper_string
)
2938 string
= find_a_file (&exec_prefixes
, commands
[0].prog
, X_OK
, false);
2939 commands
[0].argv
[0] = (string
) ? string
: commands
[0].argv
[0];
2942 for (n_commands
= 1, i
= 0; argbuf
.iterate (i
, &arg
); i
++)
2943 if (arg
&& strcmp (arg
, "|") == 0)
2944 { /* each command. */
2945 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2946 fatal_error (input_location
, "-pipe not supported");
2948 argbuf
[i
] = 0; /* Termination of
2950 commands
[n_commands
].prog
= argbuf
[i
+ 1];
2951 commands
[n_commands
].argv
2952 = &(argbuf
.address ())[i
+ 1];
2953 string
= find_a_file (&exec_prefixes
, commands
[n_commands
].prog
,
2956 commands
[n_commands
].argv
[0] = string
;
2960 /* If -v, print what we are about to do, and maybe query. */
2964 /* For help listings, put a blank line between sub-processes. */
2965 if (print_help_list
)
2966 fputc ('\n', stderr
);
2968 /* Print each piped command as a separate line. */
2969 for (i
= 0; i
< n_commands
; i
++)
2971 const char *const *j
;
2973 if (verbose_only_flag
)
2975 for (j
= commands
[i
].argv
; *j
; j
++)
2978 for (p
= *j
; *p
; ++p
)
2979 if (!ISALNUM ((unsigned char) *p
)
2980 && *p
!= '_' && *p
!= '/' && *p
!= '-' && *p
!= '.')
2984 fprintf (stderr
, " \"");
2985 for (p
= *j
; *p
; ++p
)
2987 if (*p
== '"' || *p
== '\\' || *p
== '$')
2988 fputc ('\\', stderr
);
2991 fputc ('"', stderr
);
2993 /* If it's empty, print "". */
2995 fprintf (stderr
, " \"\"");
2997 fprintf (stderr
, " %s", *j
);
3001 for (j
= commands
[i
].argv
; *j
; j
++)
3002 /* If it's empty, print "". */
3004 fprintf (stderr
, " \"\"");
3006 fprintf (stderr
, " %s", *j
);
3008 /* Print a pipe symbol after all but the last command. */
3009 if (i
+ 1 != n_commands
)
3010 fprintf (stderr
, " |");
3011 fprintf (stderr
, "\n");
3014 if (verbose_only_flag
!= 0)
3016 /* verbose_only_flag should act as if the spec was
3017 executed, so increment execution_count before
3018 returning. This prevents spurious warnings about
3019 unused linker input files, etc. */
3024 fnotice (stderr
, "\nGo ahead? (y or n) ");
3028 while (getchar () != '\n')
3031 if (i
!= 'y' && i
!= 'Y')
3036 #ifdef ENABLE_VALGRIND_CHECKING
3037 /* Run the each command through valgrind. To simplify prepending the
3038 path to valgrind and the option "-q" (for quiet operation unless
3039 something triggers), we allocate a separate argv array. */
3041 for (i
= 0; i
< n_commands
; i
++)
3047 for (argc
= 0; commands
[i
].argv
[argc
] != NULL
; argc
++)
3050 argv
= XALLOCAVEC (const char *, argc
+ 3);
3052 argv
[0] = VALGRIND_PATH
;
3054 for (j
= 2; j
< argc
+ 2; j
++)
3055 argv
[j
] = commands
[i
].argv
[j
- 2];
3058 commands
[i
].argv
= argv
;
3059 commands
[i
].prog
= argv
[0];
3063 /* Run each piped subprocess. */
3065 pex
= pex_init (PEX_USE_PIPES
| ((report_times
|| report_times_to_file
)
3066 ? PEX_RECORD_TIMES
: 0),
3067 progname
, temp_filename
);
3069 fatal_error (input_location
, "pex_init failed: %m");
3071 for (i
= 0; i
< n_commands
; i
++)
3075 const char *string
= commands
[i
].argv
[0];
3077 errmsg
= pex_run (pex
,
3078 ((i
+ 1 == n_commands
? PEX_LAST
: 0)
3079 | (string
== commands
[i
].prog
? PEX_SEARCH
: 0)),
3080 string
, CONST_CAST (char **, commands
[i
].argv
),
3085 fatal_error (input_location
, errmsg
);
3089 pfatal_with_name (errmsg
);
3093 if (i
&& string
!= commands
[i
].prog
)
3094 free (CONST_CAST (char *, string
));
3099 /* Wait for all the subprocesses to finish. */
3103 struct pex_time
*times
= NULL
;
3106 statuses
= (int *) alloca (n_commands
* sizeof (int));
3107 if (!pex_get_status (pex
, n_commands
, statuses
))
3108 fatal_error (input_location
, "failed to get exit status: %m");
3110 if (report_times
|| report_times_to_file
)
3112 times
= (struct pex_time
*) alloca (n_commands
* sizeof (struct pex_time
));
3113 if (!pex_get_times (pex
, n_commands
, times
))
3114 fatal_error (input_location
, "failed to get process times: %m");
3119 for (i
= 0; i
< n_commands
; ++i
)
3121 int status
= statuses
[i
];
3123 if (WIFSIGNALED (status
))
3126 /* SIGPIPE is a special case. It happens in -pipe mode
3127 when the compiler dies before the preprocessor is done,
3128 or the assembler dies before the compiler is done.
3129 There's generally been an error already, and this is
3130 just fallout. So don't generate another error unless
3131 we would otherwise have succeeded. */
3132 if (WTERMSIG (status
) == SIGPIPE
3133 && (signal_count
|| greatest_status
>= MIN_FATAL_STATUS
))
3140 internal_error_no_backtrace ("%s (program %s)",
3141 strsignal (WTERMSIG (status
)),
3144 else if (WIFEXITED (status
)
3145 && WEXITSTATUS (status
) >= MIN_FATAL_STATUS
)
3147 /* For ICEs in cc1, cc1obj, cc1plus see if it is
3148 reproducible or not. */
3151 && WEXITSTATUS (status
) == ICE_EXIT_CODE
3153 && (p
= strrchr (commands
[0].argv
[0], DIR_SEPARATOR
))
3154 && ! strncmp (p
+ 1, "cc1", 3))
3155 try_generate_repro (commands
[0].argv
);
3156 if (WEXITSTATUS (status
) > greatest_status
)
3157 greatest_status
= WEXITSTATUS (status
);
3161 if (report_times
|| report_times_to_file
)
3163 struct pex_time
*pt
= ×
[i
];
3166 ut
= ((double) pt
->user_seconds
3167 + (double) pt
->user_microseconds
/ 1.0e6
);
3168 st
= ((double) pt
->system_seconds
3169 + (double) pt
->system_microseconds
/ 1.0e6
);
3174 fnotice (stderr
, "# %s %.2f %.2f\n",
3175 commands
[i
].prog
, ut
, st
);
3177 if (report_times_to_file
)
3180 const char *const *j
;
3182 fprintf (report_times_to_file
, "%g %g", ut
, st
);
3184 for (j
= &commands
[i
].prog
; *j
; j
= &commands
[i
].argv
[++c
])
3187 for (p
= *j
; *p
; ++p
)
3188 if (*p
== '"' || *p
== '\\' || *p
== '$'
3194 fprintf (report_times_to_file
, " \"");
3195 for (p
= *j
; *p
; ++p
)
3197 if (*p
== '"' || *p
== '\\' || *p
== '$')
3198 fputc ('\\', report_times_to_file
);
3199 fputc (*p
, report_times_to_file
);
3201 fputc ('"', report_times_to_file
);
3204 fprintf (report_times_to_file
, " %s", *j
);
3207 fputc ('\n', report_times_to_file
);
3213 if (commands
[0].argv
[0] != commands
[0].prog
)
3214 free (CONST_CAST (char *, commands
[0].argv
[0]));
3220 /* Find all the switches given to us
3221 and make a vector describing them.
3222 The elements of the vector are strings, one per switch given.
3223 If a switch uses following arguments, then the `part1' field
3224 is the switch itself and the `args' field
3225 is a null-terminated vector containing the following arguments.
3226 Bits in the `live_cond' field are:
3227 SWITCH_LIVE to indicate this switch is true in a conditional spec.
3228 SWITCH_FALSE to indicate this switch is overridden by a later switch.
3229 SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
3230 SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored.
3231 SWITCH_KEEP_FOR_GCC to indicate that this switch, otherwise ignored,
3232 should be included in COLLECT_GCC_OPTIONS.
3233 in all do_spec calls afterwards. Used for %<S from self specs.
3234 The `known' field describes whether this is an internal switch.
3235 The `validated' field describes whether any spec has looked at this switch;
3236 if it remains false at the end of the run, the switch must be meaningless.
3237 The `ordering' field is used to temporarily mark switches that have to be
3238 kept in a specific order. */
3240 #define SWITCH_LIVE (1 << 0)
3241 #define SWITCH_FALSE (1 << 1)
3242 #define SWITCH_IGNORE (1 << 2)
3243 #define SWITCH_IGNORE_PERMANENTLY (1 << 3)
3244 #define SWITCH_KEEP_FOR_GCC (1 << 4)
3250 unsigned int live_cond
;
3256 static struct switchstr
*switches
;
3258 static int n_switches
;
3260 static int n_switches_alloc
;
3262 /* Set to zero if -fcompare-debug is disabled, positive if it's
3263 enabled and we're running the first compilation, negative if it's
3264 enabled and we're running the second compilation. For most of the
3265 time, it's in the range -1..1, but it can be temporarily set to 2
3266 or 3 to indicate that the -fcompare-debug flags didn't come from
3267 the command-line, but rather from the GCC_COMPARE_DEBUG environment
3268 variable, until a synthesized -fcompare-debug flag is added to the
3272 /* Set to nonzero if we've seen the -fcompare-debug-second flag. */
3273 int compare_debug_second
;
3275 /* Set to the flags that should be passed to the second compilation in
3276 a -fcompare-debug compilation. */
3277 const char *compare_debug_opt
;
3279 static struct switchstr
*switches_debug_check
[2];
3281 static int n_switches_debug_check
[2];
3283 static int n_switches_alloc_debug_check
[2];
3285 static char *debug_check_temp_file
[2];
3287 /* Language is one of three things:
3289 1) The name of a real programming language.
3290 2) NULL, indicating that no one has figured out
3292 3) '*', indicating that the file should be passed
3297 const char *language
;
3298 struct compiler
*incompiler
;
3303 /* Also a vector of input files specified. */
3305 static struct infile
*infiles
;
3309 static int n_infiles_alloc
;
3311 /* True if undefined environment variables encountered during spec processing
3312 are ok to ignore, typically when we're running for --help or --version. */
3314 static bool spec_undefvar_allowed
;
3316 /* True if multiple input files are being compiled to a single
3319 static bool combine_inputs
;
3321 /* This counts the number of libraries added by lang_specific_driver, so that
3322 we can tell if there were any user supplied any files or libraries. */
3324 static int added_libraries
;
3326 /* And a vector of corresponding output files is made up later. */
3328 const char **outfiles
;
3330 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3332 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
3333 is true if we should look for an executable suffix. DO_OBJ
3334 is true if we should look for an object suffix. */
3337 convert_filename (const char *name
, int do_exe ATTRIBUTE_UNUSED
,
3338 int do_obj ATTRIBUTE_UNUSED
)
3340 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3348 len
= strlen (name
);
3350 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3351 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
3352 if (do_obj
&& len
> 2
3353 && name
[len
- 2] == '.'
3354 && name
[len
- 1] == 'o')
3356 obstack_grow (&obstack
, name
, len
- 2);
3357 obstack_grow0 (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
3358 name
= XOBFINISH (&obstack
, const char *);
3362 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3363 /* If there is no filetype, make it the executable suffix (which includes
3364 the "."). But don't get confused if we have just "-o". */
3365 if (! do_exe
|| TARGET_EXECUTABLE_SUFFIX
[0] == 0 || (len
== 2 && name
[0] == '-'))
3368 for (i
= len
- 1; i
>= 0; i
--)
3369 if (IS_DIR_SEPARATOR (name
[i
]))
3372 for (i
++; i
< len
; i
++)
3376 obstack_grow (&obstack
, name
, len
);
3377 obstack_grow0 (&obstack
, TARGET_EXECUTABLE_SUFFIX
,
3378 strlen (TARGET_EXECUTABLE_SUFFIX
));
3379 name
= XOBFINISH (&obstack
, const char *);
3386 /* Display the command line switches accepted by gcc. */
3390 printf (_("Usage: %s [options] file...\n"), progname
);
3391 fputs (_("Options:\n"), stdout
);
3393 fputs (_(" -pass-exit-codes Exit with highest error code from a phase.\n"), stdout
);
3394 fputs (_(" --help Display this information.\n"), stdout
);
3395 fputs (_(" --target-help Display target specific command line options.\n"), stdout
);
3396 fputs (_(" --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...].\n"), stdout
);
3397 fputs (_(" Display specific types of command line options.\n"), stdout
);
3399 fputs (_(" (Use '-v --help' to display command line options of sub-processes).\n"), stdout
);
3400 fputs (_(" --version Display compiler version information.\n"), stdout
);
3401 fputs (_(" -dumpspecs Display all of the built in spec strings.\n"), stdout
);
3402 fputs (_(" -dumpversion Display the version of the compiler.\n"), stdout
);
3403 fputs (_(" -dumpmachine Display the compiler's target processor.\n"), stdout
);
3404 fputs (_(" -print-search-dirs Display the directories in the compiler's search path.\n"), stdout
);
3405 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library.\n"), stdout
);
3406 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>.\n"), stdout
);
3407 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>.\n"), stdout
);
3409 -print-multiarch Display the target's normalized GNU triplet, used as\n\
3410 a component in the library path.\n"), stdout
);
3411 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc.\n"), stdout
);
3413 -print-multi-lib Display the mapping between command line options and\n\
3414 multiple library search directories.\n"), stdout
);
3415 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries.\n"), stdout
);
3416 fputs (_(" -print-sysroot Display the target libraries directory.\n"), stdout
);
3417 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers.\n"), stdout
);
3418 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler.\n"), stdout
);
3419 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor.\n"), stdout
);
3420 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker.\n"), stdout
);
3421 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler.\n"), stdout
);
3422 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor.\n"), stdout
);
3423 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker.\n"), stdout
);
3424 fputs (_(" -save-temps Do not delete intermediate files.\n"), stdout
);
3425 fputs (_(" -save-temps=<arg> Do not delete intermediate files.\n"), stdout
);
3427 -no-canonical-prefixes Do not canonicalize paths when building relative\n\
3428 prefixes to other gcc components.\n"), stdout
);
3429 fputs (_(" -pipe Use pipes rather than intermediate files.\n"), stdout
);
3430 fputs (_(" -time Time the execution of each subprocess.\n"), stdout
);
3431 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>.\n"), stdout
);
3432 fputs (_(" -std=<standard> Assume that the input sources are for <standard>.\n"), stdout
);
3434 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3435 and libraries.\n"), stdout
);
3436 fputs (_(" -B <directory> Add <directory> to the compiler's search paths.\n"), stdout
);
3437 fputs (_(" -v Display the programs invoked by the compiler.\n"), stdout
);
3438 fputs (_(" -### Like -v but options quoted and commands not executed.\n"), stdout
);
3439 fputs (_(" -E Preprocess only; do not compile, assemble or link.\n"), stdout
);
3440 fputs (_(" -S Compile only; do not assemble or link.\n"), stdout
);
3441 fputs (_(" -c Compile and assemble, but do not link.\n"), stdout
);
3442 fputs (_(" -o <file> Place the output into <file>.\n"), stdout
);
3443 fputs (_(" -pie Create a position independent executable.\n"), stdout
);
3444 fputs (_(" -shared Create a shared library.\n"), stdout
);
3446 -x <language> Specify the language of the following input files.\n\
3447 Permissible languages include: c c++ assembler none\n\
3448 'none' means revert to the default behavior of\n\
3449 guessing the language based on the file's extension.\n\
3453 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3454 passed on to the various sub-processes invoked by %s. In order to pass\n\
3455 other options on to these processes the -W<letter> options must be used.\n\
3458 /* The rest of the options are displayed by invocations of the various
3463 add_preprocessor_option (const char *option
, int len
)
3465 preprocessor_options
.safe_push (save_string (option
, len
));
3469 add_assembler_option (const char *option
, int len
)
3471 assembler_options
.safe_push (save_string (option
, len
));
3475 add_linker_option (const char *option
, int len
)
3477 linker_options
.safe_push (save_string (option
, len
));
3480 /* Allocate space for an input file in infiles. */
3485 if (n_infiles_alloc
== 0)
3487 n_infiles_alloc
= 16;
3488 infiles
= XNEWVEC (struct infile
, n_infiles_alloc
);
3490 else if (n_infiles_alloc
== n_infiles
)
3492 n_infiles_alloc
*= 2;
3493 infiles
= XRESIZEVEC (struct infile
, infiles
, n_infiles_alloc
);
3497 /* Store an input file with the given NAME and LANGUAGE in
3501 add_infile (const char *name
, const char *language
)
3504 infiles
[n_infiles
].name
= name
;
3505 infiles
[n_infiles
++].language
= language
;
3508 /* Allocate space for a switch in switches. */
3513 if (n_switches_alloc
== 0)
3515 n_switches_alloc
= 16;
3516 switches
= XNEWVEC (struct switchstr
, n_switches_alloc
);
3518 else if (n_switches_alloc
== n_switches
)
3520 n_switches_alloc
*= 2;
3521 switches
= XRESIZEVEC (struct switchstr
, switches
, n_switches_alloc
);
3525 /* Save an option OPT with N_ARGS arguments in array ARGS, marking it
3526 as validated if VALIDATED and KNOWN if it is an internal switch. */
3529 save_switch (const char *opt
, size_t n_args
, const char *const *args
,
3530 bool validated
, bool known
)
3533 switches
[n_switches
].part1
= opt
+ 1;
3535 switches
[n_switches
].args
= 0;
3538 switches
[n_switches
].args
= XNEWVEC (const char *, n_args
+ 1);
3539 memcpy (switches
[n_switches
].args
, args
, n_args
* sizeof (const char *));
3540 switches
[n_switches
].args
[n_args
] = NULL
;
3543 switches
[n_switches
].live_cond
= 0;
3544 switches
[n_switches
].validated
= validated
;
3545 switches
[n_switches
].known
= known
;
3546 switches
[n_switches
].ordering
= 0;
3550 /* Handle an option DECODED that is unknown to the option-processing
3554 driver_unknown_option_callback (const struct cl_decoded_option
*decoded
)
3556 const char *opt
= decoded
->arg
;
3557 if (opt
[1] == 'W' && opt
[2] == 'n' && opt
[3] == 'o' && opt
[4] == '-'
3558 && !(decoded
->errors
& CL_ERR_NEGATIVE
))
3560 /* Leave unknown -Wno-* options for the compiler proper, to be
3561 diagnosed only if there are warnings. */
3562 save_switch (decoded
->canonical_option
[0],
3563 decoded
->canonical_option_num_elements
- 1,
3564 &decoded
->canonical_option
[1], false, true);
3567 if (decoded
->opt_index
== OPT_SPECIAL_unknown
)
3569 /* Give it a chance to define it a spec file. */
3570 save_switch (decoded
->canonical_option
[0],
3571 decoded
->canonical_option_num_elements
- 1,
3572 &decoded
->canonical_option
[1], false, false);
3579 /* Handle an option DECODED that is not marked as CL_DRIVER.
3580 LANG_MASK will always be CL_DRIVER. */
3583 driver_wrong_lang_callback (const struct cl_decoded_option
*decoded
,
3584 unsigned int lang_mask ATTRIBUTE_UNUSED
)
3586 /* At this point, non-driver options are accepted (and expected to
3587 be passed down by specs) unless marked to be rejected by the
3588 driver. Options to be rejected by the driver but accepted by the
3589 compilers proper are treated just like completely unknown
3591 const struct cl_option
*option
= &cl_options
[decoded
->opt_index
];
3593 if (option
->cl_reject_driver
)
3594 error ("unrecognized command line option %qs",
3595 decoded
->orig_option_with_args_text
);
3597 save_switch (decoded
->canonical_option
[0],
3598 decoded
->canonical_option_num_elements
- 1,
3599 &decoded
->canonical_option
[1], false, true);
3602 static const char *spec_lang
= 0;
3603 static int last_language_n_infiles
;
3605 /* Parse -foffload option argument. */
3608 handle_foffload_option (const char *arg
)
3610 const char *c
, *cur
, *n
, *next
, *end
;
3613 /* If option argument starts with '-' then no target is specified and we
3614 do not need to parse it. */
3618 end
= strchr (arg
, '=');
3620 end
= strchr (arg
, '\0');
3625 next
= strchr (cur
, ',');
3628 next
= (next
> end
) ? end
: next
;
3630 target
= XNEWVEC (char, next
- cur
+ 1);
3631 memcpy (target
, cur
, next
- cur
);
3632 target
[next
- cur
] = '\0';
3634 /* If 'disable' is passed to the option, stop parsing the option and clean
3635 the list of offload targets. */
3636 if (strcmp (target
, "disable") == 0)
3638 free (offload_targets
);
3639 offload_targets
= xstrdup ("");
3643 /* Check that GCC is configured to support the offload target. */
3644 c
= OFFLOAD_TARGETS
;
3647 n
= strchr (c
, ',');
3649 n
= strchr (c
, '\0');
3651 if (next
- cur
== n
- c
&& strncmp (target
, c
, n
- c
) == 0)
3654 c
= *n
? n
+ 1 : NULL
;
3658 fatal_error (input_location
,
3659 "GCC is not configured to support %s as offload target",
3662 if (!offload_targets
)
3664 offload_targets
= target
;
3669 /* Check that the target hasn't already presented in the list. */
3670 c
= offload_targets
;
3673 n
= strchr (c
, ':');
3675 n
= strchr (c
, '\0');
3677 if (next
- cur
== n
- c
&& strncmp (c
, target
, n
- c
) == 0)
3684 /* If duplicate is not found, append the target to the list. */
3687 size_t offload_targets_len
= strlen (offload_targets
);
3689 = XRESIZEVEC (char, offload_targets
,
3690 offload_targets_len
+ 1 + next
- cur
+ 1);
3691 offload_targets
[offload_targets_len
++] = ':';
3692 memcpy (offload_targets
+ offload_targets_len
, target
, next
- cur
+ 1);
3697 XDELETEVEC (target
);
3701 /* Handle a driver option; arguments and return value as for
3705 driver_handle_option (struct gcc_options
*opts
,
3706 struct gcc_options
*opts_set
,
3707 const struct cl_decoded_option
*decoded
,
3708 unsigned int lang_mask ATTRIBUTE_UNUSED
, int kind
,
3710 const struct cl_option_handlers
*handlers ATTRIBUTE_UNUSED
,
3711 diagnostic_context
*dc
)
3713 size_t opt_index
= decoded
->opt_index
;
3714 const char *arg
= decoded
->arg
;
3715 const char *compare_debug_replacement_opt
;
3716 int value
= decoded
->value
;
3717 bool validated
= false;
3718 bool do_save
= true;
3720 gcc_assert (opts
== &global_options
);
3721 gcc_assert (opts_set
== &global_options_set
);
3722 gcc_assert (kind
== DK_UNSPECIFIED
);
3723 gcc_assert (loc
== UNKNOWN_LOCATION
);
3724 gcc_assert (dc
== global_dc
);
3730 struct spec_list
*sl
;
3732 for (sl
= specs
; sl
; sl
= sl
->next
)
3733 printf ("*%s:\n%s\n\n", sl
->name
, *(sl
->ptr_spec
));
3734 if (link_command_spec
)
3735 printf ("*link_command:\n%s\n\n", link_command_spec
);
3739 case OPT_dumpversion
:
3740 printf ("%s\n", spec_version
);
3743 case OPT_dumpmachine
:
3744 printf ("%s\n", spec_machine
);
3750 /* CPP driver cannot obtain switch from cc1_options. */
3752 add_preprocessor_option ("--version", strlen ("--version"));
3753 add_assembler_option ("--version", strlen ("--version"));
3754 add_linker_option ("--version", strlen ("--version"));
3758 print_help_list
= 1;
3760 /* CPP driver cannot obtain switch from cc1_options. */
3762 add_preprocessor_option ("--help", 6);
3763 add_assembler_option ("--help", 6);
3764 add_linker_option ("--help", 6);
3768 print_subprocess_help
= 2;
3771 case OPT__target_help
:
3772 print_subprocess_help
= 1;
3774 /* CPP driver cannot obtain switch from cc1_options. */
3776 add_preprocessor_option ("--target-help", 13);
3777 add_assembler_option ("--target-help", 13);
3778 add_linker_option ("--target-help", 13);
3781 case OPT__no_sysroot_suffix
:
3782 case OPT_pass_exit_codes
:
3783 case OPT_print_search_dirs
:
3784 case OPT_print_file_name_
:
3785 case OPT_print_prog_name_
:
3786 case OPT_print_multi_lib
:
3787 case OPT_print_multi_directory
:
3788 case OPT_print_sysroot
:
3789 case OPT_print_multi_os_directory
:
3790 case OPT_print_multiarch
:
3791 case OPT_print_sysroot_headers_suffix
:
3794 /* These options set the variables specified in common.opt
3795 automatically, and do not need to be saved for spec
3800 case OPT_print_libgcc_file_name
:
3801 print_file_name
= "libgcc.a";
3805 case OPT_fuse_ld_bfd
:
3809 case OPT_fuse_ld_gold
:
3813 case OPT_fcompare_debug_second
:
3814 compare_debug_second
= 1;
3817 case OPT_fcompare_debug
:
3821 compare_debug_replacement_opt
= "-fcompare-debug=";
3823 goto compare_debug_with_arg
;
3826 compare_debug_replacement_opt
= "-fcompare-debug=-gtoggle";
3828 goto compare_debug_with_arg
;
3835 case OPT_fcompare_debug_
:
3836 compare_debug_replacement_opt
= decoded
->canonical_option
[0];
3837 compare_debug_with_arg
:
3838 gcc_assert (decoded
->canonical_option_num_elements
== 1);
3839 gcc_assert (arg
!= NULL
);
3844 if (compare_debug
< 0)
3845 compare_debug_opt
= NULL
;
3847 compare_debug_opt
= arg
;
3848 save_switch (compare_debug_replacement_opt
, 0, NULL
, validated
, true);
3851 case OPT_fdiagnostics_color_
:
3852 diagnostic_color_init (dc
, value
);
3858 /* Pass the rest of this option to the assembler. */
3860 /* Split the argument at commas. */
3862 for (j
= 0; arg
[j
]; j
++)
3865 add_assembler_option (arg
+ prev
, j
- prev
);
3869 /* Record the part after the last comma. */
3870 add_assembler_option (arg
+ prev
, j
- prev
);
3878 /* Pass the rest of this option to the preprocessor. */
3880 /* Split the argument at commas. */
3882 for (j
= 0; arg
[j
]; j
++)
3885 add_preprocessor_option (arg
+ prev
, j
- prev
);
3889 /* Record the part after the last comma. */
3890 add_preprocessor_option (arg
+ prev
, j
- prev
);
3898 /* Split the argument at commas. */
3900 for (j
= 0; arg
[j
]; j
++)
3903 add_infile (save_string (arg
+ prev
, j
- prev
), "*");
3906 /* Record the part after the last comma. */
3907 add_infile (arg
+ prev
, "*");
3913 add_infile (arg
, "*");
3917 case OPT_Xpreprocessor
:
3918 add_preprocessor_option (arg
, strlen (arg
));
3922 case OPT_Xassembler
:
3923 add_assembler_option (arg
, strlen (arg
));
3928 /* POSIX allows separation of -l and the lib arg; canonicalize
3929 by concatenating -l with its arg */
3930 add_infile (concat ("-l", arg
, NULL
), "*");
3935 /* Similarly, canonicalize -L for linkers that may not accept
3936 separate arguments. */
3937 save_switch (concat ("-L", arg
, NULL
), 0, NULL
, validated
, true);
3942 save_switch (concat ("-F", arg
, NULL
), 0, NULL
, validated
, true);
3945 case OPT_save_temps
:
3946 save_temps_flag
= SAVE_TEMPS_CWD
;
3950 case OPT_save_temps_
:
3951 if (strcmp (arg
, "cwd") == 0)
3952 save_temps_flag
= SAVE_TEMPS_CWD
;
3953 else if (strcmp (arg
, "obj") == 0
3954 || strcmp (arg
, "object") == 0)
3955 save_temps_flag
= SAVE_TEMPS_OBJ
;
3957 fatal_error (input_location
, "%qs is an unknown -save-temps option",
3958 decoded
->orig_option_with_args_text
);
3961 case OPT_no_canonical_prefixes
:
3962 /* Already handled as a special case, so ignored here. */
3968 /* These options set the variables specified in common.opt
3969 automatically, but do need to be saved for spec
3975 struct user_specs
*user
= XNEW (struct user_specs
);
3977 user
->next
= (struct user_specs
*) 0;
3978 user
->filename
= arg
;
3979 if (user_specs_tail
)
3980 user_specs_tail
->next
= user
;
3982 user_specs_head
= user
;
3983 user_specs_tail
= user
;
3989 target_system_root
= arg
;
3990 target_system_root_changed
= 1;
3995 if (report_times_to_file
)
3996 fclose (report_times_to_file
);
3997 report_times_to_file
= fopen (arg
, "a");
4003 This is similar to -v except that there is no execution
4004 of the commands and the echoed arguments are quoted. It
4005 is intended for use in shell scripts to capture the
4006 driver-generated command line. */
4007 verbose_only_flag
++;
4014 size_t len
= strlen (arg
);
4016 /* Catch the case where the user has forgotten to append a
4017 directory separator to the path. Note, they may be using
4018 -B to add an executable name prefix, eg "i386-elf-", in
4019 order to distinguish between multiple installations of
4020 GCC in the same directory. Hence we must check to see
4021 if appending a directory separator actually makes a
4022 valid directory name. */
4023 if (!IS_DIR_SEPARATOR (arg
[len
- 1])
4024 && is_directory (arg
, false))
4026 char *tmp
= XNEWVEC (char, len
+ 2);
4028 tmp
[len
] = DIR_SEPARATOR
;
4033 add_prefix (&exec_prefixes
, arg
, NULL
,
4034 PREFIX_PRIORITY_B_OPT
, 0, 0);
4035 add_prefix (&startfile_prefixes
, arg
, NULL
,
4036 PREFIX_PRIORITY_B_OPT
, 0, 0);
4037 add_prefix (&include_prefixes
, arg
, NULL
,
4038 PREFIX_PRIORITY_B_OPT
, 0, 0);
4045 if (!strcmp (spec_lang
, "none"))
4046 /* Suppress the warning if -xnone comes after the last input
4047 file, because alternate command interfaces like g++ might
4048 find it useful to place -xnone after each input file. */
4051 last_language_n_infiles
= n_infiles
;
4057 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
4058 arg
= convert_filename (arg
, ! have_c
, 0);
4061 /* Save the output name in case -save-temps=obj was used. */
4062 save_temps_prefix
= xstrdup (arg
);
4063 /* On some systems, ld cannot handle "-o" without a space. So
4064 split the option from its argument. */
4065 save_switch ("-o", 1, &arg
, validated
, true);
4068 #ifdef ENABLE_DEFAULT_PIE
4070 /* -pie is turned on by default. */
4073 case OPT_static_libgcc
:
4074 case OPT_shared_libgcc
:
4075 case OPT_static_libgfortran
:
4076 case OPT_static_libstdc__
:
4077 /* These are always valid, since gcc.c itself understands the
4078 first two, gfortranspec.c understands -static-libgfortran and
4079 g++spec.c understands -static-libstdc++ */
4088 handle_foffload_option (arg
);
4092 /* Various driver options need no special processing at this
4093 point, having been handled in a prescan above or being
4094 handled by specs. */
4099 save_switch (decoded
->canonical_option
[0],
4100 decoded
->canonical_option_num_elements
- 1,
4101 &decoded
->canonical_option
[1], validated
, true);
4105 /* Put the driver's standard set of option handlers in *HANDLERS. */
4108 set_option_handlers (struct cl_option_handlers
*handlers
)
4110 handlers
->unknown_option_callback
= driver_unknown_option_callback
;
4111 handlers
->wrong_lang_callback
= driver_wrong_lang_callback
;
4112 handlers
->num_handlers
= 3;
4113 handlers
->handlers
[0].handler
= driver_handle_option
;
4114 handlers
->handlers
[0].mask
= CL_DRIVER
;
4115 handlers
->handlers
[1].handler
= common_handle_option
;
4116 handlers
->handlers
[1].mask
= CL_COMMON
;
4117 handlers
->handlers
[2].handler
= target_handle_option
;
4118 handlers
->handlers
[2].mask
= CL_TARGET
;
4121 /* Create the vector `switches' and its contents.
4122 Store its length in `n_switches'. */
4125 process_command (unsigned int decoded_options_count
,
4126 struct cl_decoded_option
*decoded_options
)
4130 char *tooldir_prefix
, *tooldir_prefix2
;
4131 char *(*get_relative_prefix
) (const char *, const char *,
4132 const char *) = NULL
;
4133 struct cl_option_handlers handlers
;
4136 gcc_exec_prefix
= env
.get ("GCC_EXEC_PREFIX");
4140 added_libraries
= 0;
4142 /* Figure compiler version from version string. */
4144 compiler_version
= temp1
= xstrdup (version_string
);
4146 for (; *temp1
; ++temp1
)
4155 /* Handle any -no-canonical-prefixes flag early, to assign the function
4156 that builds relative prefixes. This function creates default search
4157 paths that are needed later in normal option handling. */
4159 for (j
= 1; j
< decoded_options_count
; j
++)
4161 if (decoded_options
[j
].opt_index
== OPT_no_canonical_prefixes
)
4163 get_relative_prefix
= make_relative_prefix_ignore_links
;
4167 if (! get_relative_prefix
)
4168 get_relative_prefix
= make_relative_prefix
;
4170 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
4171 see if we can create it from the pathname specified in
4172 decoded_options[0].arg. */
4174 gcc_libexec_prefix
= standard_libexec_prefix
;
4176 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
4177 if (!gcc_exec_prefix
)
4179 gcc_exec_prefix
= get_relative_prefix (decoded_options
[0].arg
,
4180 standard_bindir_prefix
,
4181 standard_exec_prefix
);
4182 gcc_libexec_prefix
= get_relative_prefix (decoded_options
[0].arg
,
4183 standard_bindir_prefix
,
4184 standard_libexec_prefix
);
4185 if (gcc_exec_prefix
)
4186 xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix
, NULL
));
4190 /* make_relative_prefix requires a program name, but
4191 GCC_EXEC_PREFIX is typically a directory name with a trailing
4192 / (which is ignored by make_relative_prefix), so append a
4194 char *tmp_prefix
= concat (gcc_exec_prefix
, "gcc", NULL
);
4195 gcc_libexec_prefix
= get_relative_prefix (tmp_prefix
,
4196 standard_exec_prefix
,
4197 standard_libexec_prefix
);
4199 /* The path is unrelocated, so fallback to the original setting. */
4200 if (!gcc_libexec_prefix
)
4201 gcc_libexec_prefix
= standard_libexec_prefix
;
4207 /* From this point onward, gcc_exec_prefix is non-null if the toolchain
4208 is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
4209 or an automatically created GCC_EXEC_PREFIX from
4210 decoded_options[0].arg. */
4212 /* Do language-specific adjustment/addition of flags. */
4213 lang_specific_driver (&decoded_options
, &decoded_options_count
,
4216 if (gcc_exec_prefix
)
4218 int len
= strlen (gcc_exec_prefix
);
4220 if (len
> (int) sizeof ("/lib/gcc/") - 1
4221 && (IS_DIR_SEPARATOR (gcc_exec_prefix
[len
-1])))
4223 temp
= gcc_exec_prefix
+ len
- sizeof ("/lib/gcc/") + 1;
4224 if (IS_DIR_SEPARATOR (*temp
)
4225 && filename_ncmp (temp
+ 1, "lib", 3) == 0
4226 && IS_DIR_SEPARATOR (temp
[4])
4227 && filename_ncmp (temp
+ 5, "gcc", 3) == 0)
4228 len
-= sizeof ("/lib/gcc/") - 1;
4231 set_std_prefix (gcc_exec_prefix
, len
);
4232 add_prefix (&exec_prefixes
, gcc_libexec_prefix
, "GCC",
4233 PREFIX_PRIORITY_LAST
, 0, 0);
4234 add_prefix (&startfile_prefixes
, gcc_exec_prefix
, "GCC",
4235 PREFIX_PRIORITY_LAST
, 0, 0);
4238 /* COMPILER_PATH and LIBRARY_PATH have values
4239 that are lists of directory names with colons. */
4241 temp
= env
.get ("COMPILER_PATH");
4244 const char *startp
, *endp
;
4245 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4247 startp
= endp
= temp
;
4250 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4252 strncpy (nstore
, startp
, endp
- startp
);
4254 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4255 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4257 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4258 nstore
[endp
- startp
+ 1] = 0;
4261 nstore
[endp
- startp
] = 0;
4262 add_prefix (&exec_prefixes
, nstore
, 0,
4263 PREFIX_PRIORITY_LAST
, 0, 0);
4264 add_prefix (&include_prefixes
, nstore
, 0,
4265 PREFIX_PRIORITY_LAST
, 0, 0);
4268 endp
= startp
= endp
+ 1;
4275 temp
= env
.get (LIBRARY_PATH_ENV
);
4276 if (temp
&& *cross_compile
== '0')
4278 const char *startp
, *endp
;
4279 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4281 startp
= endp
= temp
;
4284 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4286 strncpy (nstore
, startp
, endp
- startp
);
4288 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4289 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4291 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4292 nstore
[endp
- startp
+ 1] = 0;
4295 nstore
[endp
- startp
] = 0;
4296 add_prefix (&startfile_prefixes
, nstore
, NULL
,
4297 PREFIX_PRIORITY_LAST
, 0, 1);
4300 endp
= startp
= endp
+ 1;
4307 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
4308 temp
= env
.get ("LPATH");
4309 if (temp
&& *cross_compile
== '0')
4311 const char *startp
, *endp
;
4312 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4314 startp
= endp
= temp
;
4317 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4319 strncpy (nstore
, startp
, endp
- startp
);
4321 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4322 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4324 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4325 nstore
[endp
- startp
+ 1] = 0;
4328 nstore
[endp
- startp
] = 0;
4329 add_prefix (&startfile_prefixes
, nstore
, NULL
,
4330 PREFIX_PRIORITY_LAST
, 0, 1);
4333 endp
= startp
= endp
+ 1;
4340 /* Process the options and store input files and switches in their
4343 last_language_n_infiles
= -1;
4345 set_option_handlers (&handlers
);
4347 for (j
= 1; j
< decoded_options_count
; j
++)
4349 switch (decoded_options
[j
].opt_index
)
4361 for (j
= 1; j
< decoded_options_count
; j
++)
4363 if (decoded_options
[j
].opt_index
== OPT_SPECIAL_input_file
)
4365 const char *arg
= decoded_options
[j
].arg
;
4366 const char *p
= strrchr (arg
, '@');
4370 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4371 arg
= convert_filename (arg
, 0, access (arg
, F_OK
));
4373 /* For LTO static archive support we handle input file
4374 specifications that are composed of a filename and
4375 an offset like FNAME@OFFSET. */
4378 && sscanf (p
, "@%li%n", &offset
, &consumed
) >= 1
4379 && strlen (p
) == (unsigned int)consumed
)
4381 fname
= (char *)xmalloc (p
- arg
+ 1);
4382 memcpy (fname
, arg
, p
- arg
);
4383 fname
[p
- arg
] = '\0';
4384 /* Only accept non-stdin and existing FNAME parts, otherwise
4385 try with the full name. */
4386 if (strcmp (fname
, "-") == 0 || access (fname
, F_OK
) < 0)
4389 fname
= xstrdup (arg
);
4393 fname
= xstrdup (arg
);
4395 if (strcmp (fname
, "-") != 0 && access (fname
, F_OK
) < 0)
4396 perror_with_name (fname
);
4398 add_infile (arg
, spec_lang
);
4404 read_cmdline_option (&global_options
, &global_options_set
,
4405 decoded_options
+ j
, UNKNOWN_LOCATION
,
4406 CL_DRIVER
, &handlers
, global_dc
);
4409 /* If the user didn't specify any, default to all configured offload
4411 if (ENABLE_OFFLOADING
&& offload_targets
== NULL
)
4412 handle_foffload_option (OFFLOAD_TARGETS
);
4415 && strcmp (output_file
, "-") != 0
4416 && strcmp (output_file
, HOST_BIT_BUCKET
) != 0)
4419 for (i
= 0; i
< n_infiles
; i
++)
4420 if ((!infiles
[i
].language
|| infiles
[i
].language
[0] != '*')
4421 && canonical_filename_eq (infiles
[i
].name
, output_file
))
4422 fatal_error (input_location
,
4423 "input file %qs is the same as output file",
4427 /* If -save-temps=obj and -o name, create the prefix to use for %b.
4428 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
4429 if (save_temps_flag
== SAVE_TEMPS_OBJ
&& save_temps_prefix
!= NULL
)
4431 save_temps_length
= strlen (save_temps_prefix
);
4432 temp
= strrchr (lbasename (save_temps_prefix
), '.');
4435 save_temps_length
-= strlen (temp
);
4436 save_temps_prefix
[save_temps_length
] = '\0';
4440 else if (save_temps_prefix
!= NULL
)
4442 free (save_temps_prefix
);
4443 save_temps_prefix
= NULL
;
4446 if (save_temps_flag
&& use_pipes
)
4448 /* -save-temps overrides -pipe, so that temp files are produced */
4449 if (save_temps_flag
)
4450 warning (0, "-pipe ignored because -save-temps specified");
4456 const char *gcd
= env
.get ("GCC_COMPARE_DEBUG");
4458 if (gcd
&& gcd
[0] == '-')
4461 compare_debug_opt
= gcd
;
4463 else if (gcd
&& *gcd
&& strcmp (gcd
, "0"))
4466 compare_debug_opt
= "-gtoggle";
4469 else if (compare_debug
< 0)
4472 gcc_assert (!compare_debug_opt
);
4475 /* Set up the search paths. We add directories that we expect to
4476 contain GNU Toolchain components before directories specified by
4477 the machine description so that we will find GNU components (like
4478 the GNU assembler) before those of the host system. */
4480 /* If we don't know where the toolchain has been installed, use the
4481 configured-in locations. */
4482 if (!gcc_exec_prefix
)
4485 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "GCC",
4486 PREFIX_PRIORITY_LAST
, 1, 0);
4487 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "BINUTILS",
4488 PREFIX_PRIORITY_LAST
, 2, 0);
4489 add_prefix (&exec_prefixes
, standard_exec_prefix
, "BINUTILS",
4490 PREFIX_PRIORITY_LAST
, 2, 0);
4492 add_prefix (&startfile_prefixes
, standard_exec_prefix
, "BINUTILS",
4493 PREFIX_PRIORITY_LAST
, 1, 0);
4496 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix
));
4497 tooldir_prefix2
= concat (tooldir_base_prefix
, spec_machine
,
4498 dir_separator_str
, NULL
);
4500 /* Look for tools relative to the location from which the driver is
4501 running, or, if that is not available, the configured prefix. */
4503 = concat (gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
4504 spec_host_machine
, dir_separator_str
, spec_version
,
4505 accel_dir_suffix
, dir_separator_str
, tooldir_prefix2
, NULL
);
4506 free (tooldir_prefix2
);
4508 add_prefix (&exec_prefixes
,
4509 concat (tooldir_prefix
, "bin", dir_separator_str
, NULL
),
4510 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 0);
4511 add_prefix (&startfile_prefixes
,
4512 concat (tooldir_prefix
, "lib", dir_separator_str
, NULL
),
4513 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 1);
4514 free (tooldir_prefix
);
4516 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
4517 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
4518 then consider it to relocate with the rest of the GCC installation
4519 if GCC_EXEC_PREFIX is set.
4520 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
4521 if (target_system_root
&& !target_system_root_changed
&& gcc_exec_prefix
)
4523 char *tmp_prefix
= get_relative_prefix (decoded_options
[0].arg
,
4524 standard_bindir_prefix
,
4525 target_system_root
);
4526 if (tmp_prefix
&& access_check (tmp_prefix
, F_OK
) == 0)
4528 target_system_root
= tmp_prefix
;
4529 target_system_root_changed
= 1;
4534 /* More prefixes are enabled in main, after we read the specs file
4535 and determine whether this is cross-compilation or not. */
4537 if (n_infiles
== last_language_n_infiles
&& spec_lang
!= 0)
4538 warning (0, "%<-x %s%> after last input file has no effect", spec_lang
);
4540 /* Synthesize -fcompare-debug flag from the GCC_COMPARE_DEBUG
4541 environment variable. */
4542 if (compare_debug
== 2 || compare_debug
== 3)
4544 const char *opt
= concat ("-fcompare-debug=", compare_debug_opt
, NULL
);
4545 save_switch (opt
, 0, NULL
, false, true);
4549 /* Ensure we only invoke each subprocess once. */
4550 if (print_subprocess_help
|| print_help_list
|| print_version
)
4554 /* Create a dummy input file, so that we can pass
4555 the help option on to the various sub-processes. */
4556 add_infile ("help-dummy", "c");
4559 /* Decide if undefined variable references are allowed in specs. */
4561 /* --version and --help alone or together are safe. Note that -v would
4562 make them unsafe, as they'd then be run for subprocesses as well, the
4563 location of which might depend on variables possibly coming from
4566 Count the number of options we have for which undefined variables
4567 are harmless for sure, and check that nothing else is set. */
4569 unsigned n_varsafe_options
= 0;
4572 n_varsafe_options
++;
4574 if (print_help_list
)
4575 n_varsafe_options
++;
4577 spec_undefvar_allowed
= (n_varsafe_options
== decoded_options_count
- 1);
4580 switches
[n_switches
].part1
= 0;
4582 infiles
[n_infiles
].name
= 0;
4585 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4586 and place that in the environment. */
4589 set_collect_gcc_options (void)
4594 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4596 obstack_grow (&collect_obstack
, "COLLECT_GCC_OPTIONS=",
4597 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4600 for (i
= 0; (int) i
< n_switches
; i
++)
4602 const char *const *args
;
4605 obstack_grow (&collect_obstack
, " ", 1);
4609 /* Ignore elided switches. */
4610 if ((switches
[i
].live_cond
4611 & (SWITCH_IGNORE
| SWITCH_KEEP_FOR_GCC
))
4615 obstack_grow (&collect_obstack
, "'-", 2);
4616 q
= switches
[i
].part1
;
4617 while ((p
= strchr (q
, '\'')))
4619 obstack_grow (&collect_obstack
, q
, p
- q
);
4620 obstack_grow (&collect_obstack
, "'\\''", 4);
4623 obstack_grow (&collect_obstack
, q
, strlen (q
));
4624 obstack_grow (&collect_obstack
, "'", 1);
4626 for (args
= switches
[i
].args
; args
&& *args
; args
++)
4628 obstack_grow (&collect_obstack
, " '", 2);
4630 while ((p
= strchr (q
, '\'')))
4632 obstack_grow (&collect_obstack
, q
, p
- q
);
4633 obstack_grow (&collect_obstack
, "'\\''", 4);
4636 obstack_grow (&collect_obstack
, q
, strlen (q
));
4637 obstack_grow (&collect_obstack
, "'", 1);
4640 obstack_grow (&collect_obstack
, "\0", 1);
4641 xputenv (XOBFINISH (&collect_obstack
, char *));
4644 /* Process a spec string, accumulating and running commands. */
4646 /* These variables describe the input file name.
4647 input_file_number is the index on outfiles of this file,
4648 so that the output file name can be stored for later use by %o.
4649 input_basename is the start of the part of the input file
4650 sans all directory names, and basename_length is the number
4651 of characters starting there excluding the suffix .c or whatever. */
4653 static const char *gcc_input_filename
;
4654 static int input_file_number
;
4655 size_t input_filename_length
;
4656 static int basename_length
;
4657 static int suffixed_basename_length
;
4658 static const char *input_basename
;
4659 static const char *input_suffix
;
4660 #ifndef HOST_LACKS_INODE_NUMBERS
4661 static struct stat input_stat
;
4663 static int input_stat_set
;
4665 /* The compiler used to process the current input file. */
4666 static struct compiler
*input_file_compiler
;
4668 /* These are variables used within do_spec and do_spec_1. */
4670 /* Nonzero if an arg has been started and not yet terminated
4671 (with space, tab or newline). */
4672 static int arg_going
;
4674 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4675 is a temporary file name. */
4676 static int delete_this_arg
;
4678 /* Nonzero means %w has been seen; the next arg to be terminated
4679 is the output file name of this compilation. */
4680 static int this_is_output_file
;
4682 /* Nonzero means %s has been seen; the next arg to be terminated
4683 is the name of a library file and we should try the standard
4684 search dirs for it. */
4685 static int this_is_library_file
;
4687 /* Nonzero means %T has been seen; the next arg to be terminated
4688 is the name of a linker script and we should try all of the
4689 standard search dirs for it. If it is found insert a --script
4690 command line switch and then substitute the full path in place,
4691 otherwise generate an error message. */
4692 static int this_is_linker_script
;
4694 /* Nonzero means that the input of this command is coming from a pipe. */
4695 static int input_from_pipe
;
4697 /* Nonnull means substitute this for any suffix when outputting a switches
4699 static const char *suffix_subst
;
4701 /* If there is an argument being accumulated, terminate it and store it. */
4704 end_going_arg (void)
4710 obstack_1grow (&obstack
, 0);
4711 string
= XOBFINISH (&obstack
, const char *);
4712 if (this_is_library_file
)
4713 string
= find_file (string
);
4714 if (this_is_linker_script
)
4716 char * full_script_path
= find_a_file (&startfile_prefixes
, string
, R_OK
, true);
4718 if (full_script_path
== NULL
)
4720 error ("unable to locate default linker script %qs in the library search paths", string
);
4721 /* Script was not found on search path. */
4724 store_arg ("--script", false, false);
4725 string
= full_script_path
;
4727 store_arg (string
, delete_this_arg
, this_is_output_file
);
4728 if (this_is_output_file
)
4729 outfiles
[input_file_number
] = string
;
4735 /* Parse the WRAPPER string which is a comma separated list of the command line
4736 and insert them into the beginning of argbuf. */
4739 insert_wrapper (const char *wrapper
)
4743 char *buf
= xstrdup (wrapper
);
4745 unsigned int old_length
= argbuf
.length ();
4753 while ((p
= strchr (p
, ',')) != NULL
);
4755 argbuf
.safe_grow (old_length
+ n
);
4756 memmove (argbuf
.address () + n
,
4758 old_length
* sizeof (const_char_p
));
4772 while ((p
= strchr (p
, ',')) != NULL
);
4773 gcc_assert (i
== n
);
4776 /* Process the spec SPEC and run the commands specified therein.
4777 Returns 0 if the spec is successfully processed; -1 if failed. */
4780 do_spec (const char *spec
)
4784 value
= do_spec_2 (spec
);
4786 /* Force out any unfinished command.
4787 If -pipe, this forces out the last command if it ended in `|'. */
4790 if (argbuf
.length () > 0
4791 && !strcmp (argbuf
.last (), "|"))
4794 set_collect_gcc_options ();
4796 if (argbuf
.length () > 0)
4804 do_spec_2 (const char *spec
)
4810 delete_this_arg
= 0;
4811 this_is_output_file
= 0;
4812 this_is_library_file
= 0;
4813 this_is_linker_script
= 0;
4814 input_from_pipe
= 0;
4815 suffix_subst
= NULL
;
4817 result
= do_spec_1 (spec
, 0, NULL
);
4825 /* Process the given spec string and add any new options to the end
4826 of the switches/n_switches array. */
4829 do_option_spec (const char *name
, const char *spec
)
4831 unsigned int i
, value_count
, value_len
;
4832 const char *p
, *q
, *value
;
4833 char *tmp_spec
, *tmp_spec_p
;
4835 if (configure_default_options
[0].name
== NULL
)
4838 for (i
= 0; i
< ARRAY_SIZE (configure_default_options
); i
++)
4839 if (strcmp (configure_default_options
[i
].name
, name
) == 0)
4841 if (i
== ARRAY_SIZE (configure_default_options
))
4844 value
= configure_default_options
[i
].value
;
4845 value_len
= strlen (value
);
4847 /* Compute the size of the final spec. */
4850 while ((p
= strstr (p
, "%(VALUE)")) != NULL
)
4856 /* Replace each %(VALUE) by the specified value. */
4857 tmp_spec
= (char *) alloca (strlen (spec
) + 1
4858 + value_count
* (value_len
- strlen ("%(VALUE)")));
4859 tmp_spec_p
= tmp_spec
;
4861 while ((p
= strstr (q
, "%(VALUE)")) != NULL
)
4863 memcpy (tmp_spec_p
, q
, p
- q
);
4864 tmp_spec_p
= tmp_spec_p
+ (p
- q
);
4865 memcpy (tmp_spec_p
, value
, value_len
);
4866 tmp_spec_p
+= value_len
;
4867 q
= p
+ strlen ("%(VALUE)");
4869 strcpy (tmp_spec_p
, q
);
4871 do_self_spec (tmp_spec
);
4874 /* Process the given spec string and add any new options to the end
4875 of the switches/n_switches array. */
4878 do_self_spec (const char *spec
)
4883 do_spec_1 (" ", 0, NULL
);
4885 /* Mark %<S switches processed by do_self_spec to be ignored permanently.
4886 do_self_specs adds the replacements to switches array, so it shouldn't
4887 be processed afterwards. */
4888 for (i
= 0; i
< n_switches
; i
++)
4889 if ((switches
[i
].live_cond
& SWITCH_IGNORE
))
4890 switches
[i
].live_cond
|= SWITCH_IGNORE_PERMANENTLY
;
4892 if (argbuf
.length () > 0)
4894 const char **argbuf_copy
;
4895 struct cl_decoded_option
*decoded_options
;
4896 struct cl_option_handlers handlers
;
4897 unsigned int decoded_options_count
;
4900 /* Create a copy of argbuf with a dummy argv[0] entry for
4901 decode_cmdline_options_to_array. */
4902 argbuf_copy
= XNEWVEC (const char *,
4903 argbuf
.length () + 1);
4904 argbuf_copy
[0] = "";
4905 memcpy (argbuf_copy
+ 1, argbuf
.address (),
4906 argbuf
.length () * sizeof (const char *));
4908 decode_cmdline_options_to_array (argbuf
.length () + 1,
4910 CL_DRIVER
, &decoded_options
,
4911 &decoded_options_count
);
4914 set_option_handlers (&handlers
);
4916 for (j
= 1; j
< decoded_options_count
; j
++)
4918 switch (decoded_options
[j
].opt_index
)
4920 case OPT_SPECIAL_input_file
:
4921 /* Specs should only generate options, not input
4923 if (strcmp (decoded_options
[j
].arg
, "-") != 0)
4924 fatal_error (input_location
,
4925 "switch %qs does not start with %<-%>",
4926 decoded_options
[j
].arg
);
4928 fatal_error (input_location
,
4929 "spec-generated switch is just %<-%>");
4932 case OPT_fcompare_debug_second
:
4933 case OPT_fcompare_debug
:
4934 case OPT_fcompare_debug_
:
4936 /* Avoid duplicate processing of some options from
4937 compare-debug specs; just save them here. */
4938 save_switch (decoded_options
[j
].canonical_option
[0],
4939 (decoded_options
[j
].canonical_option_num_elements
4941 &decoded_options
[j
].canonical_option
[1], false, true);
4945 read_cmdline_option (&global_options
, &global_options_set
,
4946 decoded_options
+ j
, UNKNOWN_LOCATION
,
4947 CL_DRIVER
, &handlers
, global_dc
);
4952 free (decoded_options
);
4955 switches
[n_switches
].part1
= 0;
4959 /* Callback for processing %D and %I specs. */
4961 struct spec_path_info
{
4966 bool separate_options
;
4970 spec_path (char *path
, void *data
)
4972 struct spec_path_info
*info
= (struct spec_path_info
*) data
;
4976 if (info
->omit_relative
&& !IS_ABSOLUTE_PATH (path
))
4979 if (info
->append_len
!= 0)
4981 len
= strlen (path
);
4982 memcpy (path
+ len
, info
->append
, info
->append_len
+ 1);
4985 if (!is_directory (path
, true))
4988 do_spec_1 (info
->option
, 1, NULL
);
4989 if (info
->separate_options
)
4990 do_spec_1 (" ", 0, NULL
);
4992 if (info
->append_len
== 0)
4994 len
= strlen (path
);
4995 save
= path
[len
- 1];
4996 if (IS_DIR_SEPARATOR (path
[len
- 1]))
4997 path
[len
- 1] = '\0';
5000 do_spec_1 (path
, 1, NULL
);
5001 do_spec_1 (" ", 0, NULL
);
5003 /* Must not damage the original path. */
5004 if (info
->append_len
== 0)
5005 path
[len
- 1] = save
;
5010 /* Create a temporary FILE with the contents of ARGV. Add @FILE to the
5014 create_at_file (char **argv
)
5016 char *temp_file
= make_temp_file ("");
5017 char *at_argument
= concat ("@", temp_file
, NULL
);
5018 FILE *f
= fopen (temp_file
, "w");
5022 fatal_error (input_location
, "could not open temporary response file %s",
5025 status
= writeargv (argv
, f
);
5028 fatal_error (input_location
,
5029 "could not write to temporary response file %s",
5032 status
= fclose (f
);
5035 fatal_error (input_location
, "could not close temporary response file %s",
5038 store_arg (at_argument
, 0, 0);
5040 record_temp_file (temp_file
, !save_temps_flag
, !save_temps_flag
);
5043 /* True if we should compile INFILE. */
5046 compile_input_file_p (struct infile
*infile
)
5048 if ((!infile
->language
) || (infile
->language
[0] != '*'))
5049 if (infile
->incompiler
== input_file_compiler
)
5054 /* Process each member of VEC as a spec. */
5057 do_specs_vec (vec
<char_p
> vec
)
5062 FOR_EACH_VEC_ELT (vec
, ix
, opt
)
5064 do_spec_1 (opt
, 1, NULL
);
5065 /* Make each accumulated option a separate argument. */
5066 do_spec_1 (" ", 0, NULL
);
5070 /* Process the sub-spec SPEC as a portion of a larger spec.
5071 This is like processing a whole spec except that we do
5072 not initialize at the beginning and we do not supply a
5073 newline by default at the end.
5074 INSWITCH nonzero means don't process %-sequences in SPEC;
5075 in this case, % is treated as an ordinary character.
5076 This is used while substituting switches.
5077 INSWITCH nonzero also causes SPC not to terminate an argument.
5079 Value is zero unless a line was finished
5080 and the command on that line reported an error. */
5083 do_spec_1 (const char *spec
, int inswitch
, const char *soft_matched_part
)
5085 const char *p
= spec
;
5090 /* If it's an empty string argument to a switch, keep it as is. */
5091 if (inswitch
&& !*p
)
5095 /* If substituting a switch, treat all chars like letters.
5096 Otherwise, NL, SPC, TAB and % are special. */
5097 switch (inswitch
? 'a' : c
)
5102 if (argbuf
.length () > 0
5103 && !strcmp (argbuf
.last (), "|"))
5105 /* A `|' before the newline means use a pipe here,
5106 but only if -pipe was specified.
5107 Otherwise, execute now and don't pass the `|' as an arg. */
5110 input_from_pipe
= 1;
5117 set_collect_gcc_options ();
5119 if (argbuf
.length () > 0)
5125 /* Reinitialize for a new command, and for a new argument. */
5128 delete_this_arg
= 0;
5129 this_is_output_file
= 0;
5130 this_is_library_file
= 0;
5131 this_is_linker_script
= 0;
5132 input_from_pipe
= 0;
5139 obstack_1grow (&obstack
, c
);
5147 /* Reinitialize for a new argument. */
5148 delete_this_arg
= 0;
5149 this_is_output_file
= 0;
5150 this_is_library_file
= 0;
5151 this_is_linker_script
= 0;
5158 fatal_error (input_location
, "spec %qs invalid", spec
);
5161 if (save_temps_length
)
5162 obstack_grow (&obstack
, save_temps_prefix
, save_temps_length
);
5164 obstack_grow (&obstack
, input_basename
, basename_length
);
5165 if (compare_debug
< 0)
5166 obstack_grow (&obstack
, ".gk", 3);
5171 if (save_temps_length
)
5172 obstack_grow (&obstack
, save_temps_prefix
, save_temps_length
);
5174 obstack_grow (&obstack
, input_basename
, suffixed_basename_length
);
5175 if (compare_debug
< 0)
5176 obstack_grow (&obstack
, ".gk", 3);
5181 delete_this_arg
= 2;
5184 /* Dump out the directories specified with LIBRARY_PATH,
5185 followed by the absolute directories
5186 that we search for startfiles. */
5189 struct spec_path_info info
;
5192 info
.append_len
= 0;
5193 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
5194 /* Used on systems which record the specified -L dirs
5195 and use them to search for dynamic linking.
5196 Relative directories always come from -B,
5197 and it is better not to use them for searching
5198 at run time. In particular, stage1 loses. */
5199 info
.omit_relative
= true;
5201 info
.omit_relative
= false;
5203 info
.separate_options
= false;
5205 for_each_path (&startfile_prefixes
, true, 0, spec_path
, &info
);
5210 /* %efoo means report an error with `foo' as error message
5211 and don't execute any more commands for this file. */
5215 while (*p
!= 0 && *p
!= '\n')
5217 buf
= (char *) alloca (p
- q
+ 1);
5218 strncpy (buf
, q
, p
- q
);
5220 error ("%s", _(buf
));
5225 /* %nfoo means report a notice with `foo' on stderr. */
5229 while (*p
!= 0 && *p
!= '\n')
5231 buf
= (char *) alloca (p
- q
+ 1);
5232 strncpy (buf
, q
, p
- q
);
5234 inform (0, "%s", _(buf
));
5244 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
5245 defined, and it is not a directory, and it is
5246 writable, use it. Otherwise, treat this like any
5247 other temporary file. */
5249 if ((!save_temps_flag
)
5250 && (stat (HOST_BIT_BUCKET
, &st
) == 0) && (!S_ISDIR (st
.st_mode
))
5251 && (access (HOST_BIT_BUCKET
, W_OK
) == 0))
5253 obstack_grow (&obstack
, HOST_BIT_BUCKET
,
5254 strlen (HOST_BIT_BUCKET
));
5255 delete_this_arg
= 0;
5260 goto create_temp_file
;
5264 obstack_1grow (&obstack
, '-');
5265 delete_this_arg
= 0;
5268 /* consume suffix */
5269 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
5271 if (p
[0] == '%' && p
[1] == 'O')
5276 goto create_temp_file
;
5280 /* consume suffix */
5281 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
5283 if (p
[0] == '%' && p
[1] == 'O')
5288 goto create_temp_file
;
5294 struct temp_name
*t
;
5296 const char *suffix
= p
;
5297 char *saved_suffix
= NULL
;
5299 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
5301 suffix_length
= p
- suffix
;
5302 if (p
[0] == '%' && p
[1] == 'O')
5305 /* We don't support extra suffix characters after %O. */
5306 if (*p
== '.' || ISALNUM ((unsigned char) *p
))
5307 fatal_error (input_location
,
5308 "spec %qs has invalid %<%%0%c%>", spec
, *p
);
5309 if (suffix_length
== 0)
5310 suffix
= TARGET_OBJECT_SUFFIX
;
5314 = XNEWVEC (char, suffix_length
5315 + strlen (TARGET_OBJECT_SUFFIX
) + 1);
5316 strncpy (saved_suffix
, suffix
, suffix_length
);
5317 strcpy (saved_suffix
+ suffix_length
,
5318 TARGET_OBJECT_SUFFIX
);
5320 suffix_length
+= strlen (TARGET_OBJECT_SUFFIX
);
5323 if (compare_debug
< 0)
5325 suffix
= concat (".gk", suffix
, NULL
);
5329 /* If -save-temps=obj and -o were specified, use that for the
5331 if (save_temps_length
)
5334 temp_filename_length
5335 = save_temps_length
+ suffix_length
+ 1;
5336 tmp
= (char *) alloca (temp_filename_length
);
5337 memcpy (tmp
, save_temps_prefix
, save_temps_length
);
5338 memcpy (tmp
+ save_temps_length
, suffix
, suffix_length
);
5339 tmp
[save_temps_length
+ suffix_length
] = '\0';
5340 temp_filename
= save_string (tmp
, save_temps_length
5342 obstack_grow (&obstack
, temp_filename
,
5343 temp_filename_length
);
5345 delete_this_arg
= 0;
5349 /* If the gcc_input_filename has the same suffix specified
5350 for the %g, %u, or %U, and -save-temps is specified,
5351 we could end up using that file as an intermediate
5352 thus clobbering the user's source file (.e.g.,
5353 gcc -save-temps foo.s would clobber foo.s with the
5354 output of cpp0). So check for this condition and
5355 generate a temp file as the intermediate. */
5357 if (save_temps_flag
)
5360 temp_filename_length
= basename_length
+ suffix_length
+ 1;
5361 tmp
= (char *) alloca (temp_filename_length
);
5362 memcpy (tmp
, input_basename
, basename_length
);
5363 memcpy (tmp
+ basename_length
, suffix
, suffix_length
);
5364 tmp
[basename_length
+ suffix_length
] = '\0';
5365 temp_filename
= tmp
;
5367 if (filename_cmp (temp_filename
, gcc_input_filename
) != 0)
5369 #ifndef HOST_LACKS_INODE_NUMBERS
5370 struct stat st_temp
;
5372 /* Note, set_input() resets input_stat_set to 0. */
5373 if (input_stat_set
== 0)
5375 input_stat_set
= stat (gcc_input_filename
,
5377 if (input_stat_set
>= 0)
5381 /* If we have the stat for the gcc_input_filename
5382 and we can do the stat for the temp_filename
5383 then the they could still refer to the same
5384 file if st_dev/st_ino's are the same. */
5385 if (input_stat_set
!= 1
5386 || stat (temp_filename
, &st_temp
) < 0
5387 || input_stat
.st_dev
!= st_temp
.st_dev
5388 || input_stat
.st_ino
!= st_temp
.st_ino
)
5390 /* Just compare canonical pathnames. */
5391 char* input_realname
= lrealpath (gcc_input_filename
);
5392 char* temp_realname
= lrealpath (temp_filename
);
5393 bool files_differ
= filename_cmp (input_realname
, temp_realname
);
5394 free (input_realname
);
5395 free (temp_realname
);
5399 temp_filename
= save_string (temp_filename
,
5400 temp_filename_length
+ 1);
5401 obstack_grow (&obstack
, temp_filename
,
5402 temp_filename_length
);
5404 delete_this_arg
= 0;
5410 /* See if we already have an association of %g/%u/%U and
5412 for (t
= temp_names
; t
; t
= t
->next
)
5413 if (t
->length
== suffix_length
5414 && strncmp (t
->suffix
, suffix
, suffix_length
) == 0
5415 && t
->unique
== (c
== 'u' || c
== 'U' || c
== 'j'))
5418 /* Make a new association if needed. %u and %j
5420 if (t
== 0 || c
== 'u' || c
== 'j')
5424 t
= XNEW (struct temp_name
);
5425 t
->next
= temp_names
;
5428 t
->length
= suffix_length
;
5431 t
->suffix
= saved_suffix
;
5432 saved_suffix
= NULL
;
5435 t
->suffix
= save_string (suffix
, suffix_length
);
5436 t
->unique
= (c
== 'u' || c
== 'U' || c
== 'j');
5437 temp_filename
= make_temp_file (t
->suffix
);
5438 temp_filename_length
= strlen (temp_filename
);
5439 t
->filename
= temp_filename
;
5440 t
->filename_length
= temp_filename_length
;
5443 free (saved_suffix
);
5445 obstack_grow (&obstack
, t
->filename
, t
->filename_length
);
5446 delete_this_arg
= 1;
5454 if (at_file_supplied
)
5456 /* We are going to expand `%i' to `@FILE', where FILE
5457 is a newly-created temporary filename. The filenames
5458 that would usually be expanded in place of %o will be
5459 written to the temporary file. */
5464 for (i
= 0; i
< n_infiles
; i
++)
5465 if (compile_input_file_p (&infiles
[i
]))
5468 argv
= (char **) alloca (sizeof (char *) * (n_files
+ 1));
5470 /* Copy the strings over. */
5471 for (i
= 0, j
= 0; i
< n_infiles
; i
++)
5472 if (compile_input_file_p (&infiles
[i
]))
5474 argv
[j
] = CONST_CAST (char *, infiles
[i
].name
);
5475 infiles
[i
].compiled
= true;
5480 create_at_file (argv
);
5483 for (i
= 0; (int) i
< n_infiles
; i
++)
5484 if (compile_input_file_p (&infiles
[i
]))
5486 store_arg (infiles
[i
].name
, 0, 0);
5487 infiles
[i
].compiled
= true;
5492 obstack_grow (&obstack
, gcc_input_filename
,
5493 input_filename_length
);
5500 struct spec_path_info info
;
5504 do_spec_1 ("-imultilib", 1, NULL
);
5505 /* Make this a separate argument. */
5506 do_spec_1 (" ", 0, NULL
);
5507 do_spec_1 (multilib_dir
, 1, NULL
);
5508 do_spec_1 (" ", 0, NULL
);
5513 do_spec_1 ("-imultiarch", 1, NULL
);
5514 /* Make this a separate argument. */
5515 do_spec_1 (" ", 0, NULL
);
5516 do_spec_1 (multiarch_dir
, 1, NULL
);
5517 do_spec_1 (" ", 0, NULL
);
5520 if (gcc_exec_prefix
)
5522 do_spec_1 ("-iprefix", 1, NULL
);
5523 /* Make this a separate argument. */
5524 do_spec_1 (" ", 0, NULL
);
5525 do_spec_1 (gcc_exec_prefix
, 1, NULL
);
5526 do_spec_1 (" ", 0, NULL
);
5529 if (target_system_root_changed
||
5530 (target_system_root
&& target_sysroot_hdrs_suffix
))
5532 do_spec_1 ("-isysroot", 1, NULL
);
5533 /* Make this a separate argument. */
5534 do_spec_1 (" ", 0, NULL
);
5535 do_spec_1 (target_system_root
, 1, NULL
);
5536 if (target_sysroot_hdrs_suffix
)
5537 do_spec_1 (target_sysroot_hdrs_suffix
, 1, NULL
);
5538 do_spec_1 (" ", 0, NULL
);
5541 info
.option
= "-isystem";
5542 info
.append
= "include";
5543 info
.append_len
= strlen (info
.append
);
5544 info
.omit_relative
= false;
5545 info
.separate_options
= true;
5547 for_each_path (&include_prefixes
, false, info
.append_len
,
5550 info
.append
= "include-fixed";
5551 if (*sysroot_hdrs_suffix_spec
)
5552 info
.append
= concat (info
.append
, dir_separator_str
,
5553 multilib_dir
, NULL
);
5554 info
.append_len
= strlen (info
.append
);
5555 for_each_path (&include_prefixes
, false, info
.append_len
,
5562 int max
= n_infiles
;
5563 max
+= lang_specific_extra_outfiles
;
5565 if (HAVE_GNU_LD
&& at_file_supplied
)
5567 /* We are going to expand `%o' to `@FILE', where FILE
5568 is a newly-created temporary filename. The filenames
5569 that would usually be expanded in place of %o will be
5570 written to the temporary file. */
5575 /* Convert OUTFILES into a form suitable for writeargv. */
5577 /* Determine how many are non-NULL. */
5578 for (n_files
= 0, i
= 0; i
< max
; i
++)
5579 n_files
+= outfiles
[i
] != NULL
;
5581 argv
= (char **) alloca (sizeof (char *) * (n_files
+ 1));
5583 /* Copy the strings over. */
5584 for (i
= 0, j
= 0; i
< max
; i
++)
5587 argv
[j
] = CONST_CAST (char *, outfiles
[i
]);
5592 create_at_file (argv
);
5595 for (i
= 0; i
< max
; i
++)
5597 store_arg (outfiles
[i
], 0, 0);
5602 obstack_grow (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
5607 this_is_library_file
= 1;
5611 this_is_linker_script
= 1;
5615 outfiles
[input_file_number
] = NULL
;
5619 this_is_output_file
= 1;
5624 unsigned int cur_index
= argbuf
.length ();
5625 /* Handle the {...} following the %W. */
5627 fatal_error (input_location
,
5628 "spec %qs has invalid %<%%W%c%>", spec
, *p
);
5629 p
= handle_braces (p
+ 1);
5633 /* If any args were output, mark the last one for deletion
5635 if (argbuf
.length () != cur_index
)
5636 record_temp_file (argbuf
.last (), 0, 1);
5640 /* %x{OPTION} records OPTION for %X to output. */
5648 /* Skip past the option value and make a copy. */
5650 fatal_error (input_location
,
5651 "spec %qs has invalid %<%%x%c%>", spec
, *p
);
5654 string
= save_string (p1
+ 1, p
- p1
- 2);
5656 /* See if we already recorded this option. */
5657 FOR_EACH_VEC_ELT (linker_options
, ix
, opt
)
5658 if (! strcmp (string
, opt
))
5664 /* This option is new; add it. */
5665 add_linker_option (string
, strlen (string
));
5670 /* Dump out the options accumulated previously using %x. */
5672 do_specs_vec (linker_options
);
5675 /* Dump out the options accumulated previously using -Wa,. */
5677 do_specs_vec (assembler_options
);
5680 /* Dump out the options accumulated previously using -Wp,. */
5682 do_specs_vec (preprocessor_options
);
5685 /* Here are digits and numbers that just process
5686 a certain constant string as a spec. */
5689 value
= do_spec_1 (cc1_spec
, 0, NULL
);
5695 value
= do_spec_1 (cc1plus_spec
, 0, NULL
);
5701 value
= do_spec_1 (asm_spec
, 0, NULL
);
5707 value
= do_spec_1 (asm_final_spec
, 0, NULL
);
5714 const char *const spec
5715 = (input_file_compiler
->cpp_spec
5716 ? input_file_compiler
->cpp_spec
5718 value
= do_spec_1 (spec
, 0, NULL
);
5725 value
= do_spec_1 (endfile_spec
, 0, NULL
);
5731 value
= do_spec_1 (link_spec
, 0, NULL
);
5737 value
= do_spec_1 (lib_spec
, 0, NULL
);
5743 if (multilib_os_dir
== NULL
)
5744 obstack_1grow (&obstack
, '.');
5746 obstack_grow (&obstack
, multilib_os_dir
,
5747 strlen (multilib_os_dir
));
5751 value
= do_spec_1 (libgcc_spec
, 0, NULL
);
5757 /* We assume there is a directory
5758 separator at the end of this string. */
5759 if (target_system_root
)
5761 obstack_grow (&obstack
, target_system_root
,
5762 strlen (target_system_root
));
5763 if (target_sysroot_suffix
)
5764 obstack_grow (&obstack
, target_sysroot_suffix
,
5765 strlen (target_sysroot_suffix
));
5770 value
= do_spec_1 (startfile_spec
, 0, NULL
);
5775 /* Here we define characters other than letters and digits. */
5778 p
= handle_braces (p
);
5784 p
= handle_spec_function (p
, NULL
);
5790 obstack_1grow (&obstack
, '%');
5797 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '%')
5799 suffix_subst
= save_string (p
- 1, len
+ 1);
5804 /* Henceforth ignore the option(s) matching the pattern
5810 int have_wildcard
= 0;
5815 switch_option
= SWITCH_IGNORE
| SWITCH_KEEP_FOR_GCC
;
5817 switch_option
= SWITCH_IGNORE
;
5819 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '\t')
5822 if (p
[len
-1] == '*')
5825 for (i
= 0; i
< n_switches
; i
++)
5826 if (!strncmp (switches
[i
].part1
, p
, len
- have_wildcard
)
5827 && (have_wildcard
|| switches
[i
].part1
[len
] == '\0'))
5829 switches
[i
].live_cond
|= switch_option
;
5830 /* User switch be validated from validate_all_switches.
5831 when the definition is seen from the spec file.
5832 If not defined anywhere, will be rejected. */
5833 if (switches
[i
].known
)
5834 switches
[i
].validated
= true;
5842 if (soft_matched_part
)
5844 if (soft_matched_part
[0])
5845 do_spec_1 (soft_matched_part
, 1, NULL
);
5846 /* Only insert a space after the substitution if it is at the
5847 end of the current sequence. So if:
5849 "%{foo=*:bar%*}%{foo=*:one%*two}"
5851 matches -foo=hello then it will produce:
5853 barhello onehellotwo
5855 if (*p
== 0 || *p
== '}')
5856 do_spec_1 (" ", 0, NULL
);
5859 /* Catch the case where a spec string contains something like
5860 '%{foo:%*}'. i.e. there is no * in the pattern on the left
5861 hand side of the :. */
5862 error ("spec failure: %<%%*%> has not been initialized by pattern match");
5865 /* Process a string found as the value of a spec given by name.
5866 This feature allows individual machine descriptions
5867 to add and use their own specs. */
5870 const char *name
= p
;
5871 struct spec_list
*sl
;
5874 /* The string after the S/P is the name of a spec that is to be
5876 while (*p
&& *p
!= ')')
5879 /* See if it's in the list. */
5880 for (len
= p
- name
, sl
= specs
; sl
; sl
= sl
->next
)
5881 if (sl
->name_len
== len
&& !strncmp (sl
->name
, name
, len
))
5883 name
= *(sl
->ptr_spec
);
5885 fnotice (stderr
, "Processing spec (%s), which is '%s'\n",
5893 value
= do_spec_1 (name
, 0, NULL
);
5898 /* Discard the closing paren. */
5905 error ("spec failure: unrecognized spec option %qc", c
);
5911 /* Backslash: treat next character as ordinary. */
5916 /* Ordinary character: put it into the current argument. */
5917 obstack_1grow (&obstack
, c
);
5921 /* End of string. If we are processing a spec function, we need to
5922 end any pending argument. */
5923 if (processing_spec_function
)
5929 /* Look up a spec function. */
5931 static const struct spec_function
*
5932 lookup_spec_function (const char *name
)
5934 const struct spec_function
*sf
;
5936 for (sf
= static_spec_functions
; sf
->name
!= NULL
; sf
++)
5937 if (strcmp (sf
->name
, name
) == 0)
5943 /* Evaluate a spec function. */
5946 eval_spec_function (const char *func
, const char *args
)
5948 const struct spec_function
*sf
;
5949 const char *funcval
;
5951 /* Saved spec processing context. */
5952 vec
<const_char_p
> save_argbuf
;
5955 int save_delete_this_arg
;
5956 int save_this_is_output_file
;
5957 int save_this_is_library_file
;
5958 int save_input_from_pipe
;
5959 int save_this_is_linker_script
;
5960 const char *save_suffix_subst
;
5962 int save_growing_size
;
5963 void *save_growing_value
= NULL
;
5965 sf
= lookup_spec_function (func
);
5967 fatal_error (input_location
, "unknown spec function %qs", func
);
5969 /* Push the spec processing context. */
5970 save_argbuf
= argbuf
;
5972 save_arg_going
= arg_going
;
5973 save_delete_this_arg
= delete_this_arg
;
5974 save_this_is_output_file
= this_is_output_file
;
5975 save_this_is_library_file
= this_is_library_file
;
5976 save_this_is_linker_script
= this_is_linker_script
;
5977 save_input_from_pipe
= input_from_pipe
;
5978 save_suffix_subst
= suffix_subst
;
5980 /* If we have some object growing now, finalize it so the args and function
5981 eval proceed from a cleared context. This is needed to prevent the first
5982 constructed arg from mistakenly including the growing value. We'll push
5983 this value back on the obstack once the function evaluation is done, to
5984 restore a consistent processing context for our caller. This is fine as
5985 the address of growing objects isn't guaranteed to remain stable until
5986 they are finalized, and we expect this situation to be rare enough for
5987 the extra copy not to be an issue. */
5988 save_growing_size
= obstack_object_size (&obstack
);
5989 if (save_growing_size
> 0)
5990 save_growing_value
= obstack_finish (&obstack
);
5992 /* Create a new spec processing context, and build the function
5996 if (do_spec_2 (args
) < 0)
5997 fatal_error (input_location
, "error in args to spec function %qs", func
);
5999 /* argbuf_index is an index for the next argument to be inserted, and
6000 so contains the count of the args already inserted. */
6002 funcval
= (*sf
->func
) (argbuf
.length (),
6005 /* Pop the spec processing context. */
6007 argbuf
= save_argbuf
;
6009 arg_going
= save_arg_going
;
6010 delete_this_arg
= save_delete_this_arg
;
6011 this_is_output_file
= save_this_is_output_file
;
6012 this_is_library_file
= save_this_is_library_file
;
6013 this_is_linker_script
= save_this_is_linker_script
;
6014 input_from_pipe
= save_input_from_pipe
;
6015 suffix_subst
= save_suffix_subst
;
6017 if (save_growing_size
> 0)
6018 obstack_grow (&obstack
, save_growing_value
, save_growing_size
);
6023 /* Handle a spec function call of the form:
6027 ARGS is processed as a spec in a separate context and split into an
6028 argument vector in the normal fashion. The function returns a string
6029 containing a spec which we then process in the caller's context, or
6030 NULL if no processing is required.
6032 If RETVAL_NONNULL is not NULL, then store a bool whether function
6033 returned non-NULL. */
6036 handle_spec_function (const char *p
, bool *retval_nonnull
)
6039 const char *endp
, *funcval
;
6042 processing_spec_function
++;
6044 /* Get the function name. */
6045 for (endp
= p
; *endp
!= '\0'; endp
++)
6047 if (*endp
== '(') /* ) */
6049 /* Only allow [A-Za-z0-9], -, and _ in function names. */
6050 if (!ISALNUM (*endp
) && !(*endp
== '-' || *endp
== '_'))
6051 fatal_error (input_location
, "malformed spec function name");
6053 if (*endp
!= '(') /* ) */
6054 fatal_error (input_location
, "no arguments for spec function");
6055 func
= save_string (p
, endp
- p
);
6058 /* Get the arguments. */
6059 for (count
= 0; *endp
!= '\0'; endp
++)
6068 else if (*endp
== '(') /* ) */
6073 fatal_error (input_location
, "malformed spec function arguments");
6074 args
= save_string (p
, endp
- p
);
6077 /* p now points to just past the end of the spec function expression. */
6079 funcval
= eval_spec_function (func
, args
);
6080 if (funcval
!= NULL
&& do_spec_1 (funcval
, 0, NULL
) < 0)
6083 *retval_nonnull
= funcval
!= NULL
;
6088 processing_spec_function
--;
6093 /* Inline subroutine of handle_braces. Returns true if the current
6094 input suffix matches the atom bracketed by ATOM and END_ATOM. */
6096 input_suffix_matches (const char *atom
, const char *end_atom
)
6098 return (input_suffix
6099 && !strncmp (input_suffix
, atom
, end_atom
- atom
)
6100 && input_suffix
[end_atom
- atom
] == '\0');
6103 /* Subroutine of handle_braces. Returns true if the current
6104 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
6106 input_spec_matches (const char *atom
, const char *end_atom
)
6108 return (input_file_compiler
6109 && input_file_compiler
->suffix
6110 && input_file_compiler
->suffix
[0] != '\0'
6111 && !strncmp (input_file_compiler
->suffix
+ 1, atom
,
6113 && input_file_compiler
->suffix
[end_atom
- atom
+ 1] == '\0');
6116 /* Subroutine of handle_braces. Returns true if a switch
6117 matching the atom bracketed by ATOM and END_ATOM appeared on the
6120 switch_matches (const char *atom
, const char *end_atom
, int starred
)
6123 int len
= end_atom
- atom
;
6124 int plen
= starred
? len
: -1;
6126 for (i
= 0; i
< n_switches
; i
++)
6127 if (!strncmp (switches
[i
].part1
, atom
, len
)
6128 && (starred
|| switches
[i
].part1
[len
] == '\0')
6129 && check_live_switch (i
, plen
))
6132 /* Check if a switch with separated form matching the atom.
6133 We check -D and -U switches. */
6134 else if (switches
[i
].args
!= 0)
6136 if ((*switches
[i
].part1
== 'D' || *switches
[i
].part1
== 'U')
6137 && *switches
[i
].part1
== atom
[0])
6139 if (!strncmp (switches
[i
].args
[0], &atom
[1], len
- 1)
6140 && (starred
|| (switches
[i
].part1
[1] == '\0'
6141 && switches
[i
].args
[0][len
- 1] == '\0'))
6142 && check_live_switch (i
, (starred
? 1 : -1)))
6150 /* Inline subroutine of handle_braces. Mark all of the switches which
6151 match ATOM (extends to END_ATOM; STARRED indicates whether there
6152 was a star after the atom) for later processing. */
6154 mark_matching_switches (const char *atom
, const char *end_atom
, int starred
)
6157 int len
= end_atom
- atom
;
6158 int plen
= starred
? len
: -1;
6160 for (i
= 0; i
< n_switches
; i
++)
6161 if (!strncmp (switches
[i
].part1
, atom
, len
)
6162 && (starred
|| switches
[i
].part1
[len
] == '\0')
6163 && check_live_switch (i
, plen
))
6164 switches
[i
].ordering
= 1;
6167 /* Inline subroutine of handle_braces. Process all the currently
6168 marked switches through give_switch, and clear the marks. */
6170 process_marked_switches (void)
6174 for (i
= 0; i
< n_switches
; i
++)
6175 if (switches
[i
].ordering
== 1)
6177 switches
[i
].ordering
= 0;
6182 /* Handle a %{ ... } construct. P points just inside the leading {.
6183 Returns a pointer one past the end of the brace block, or 0
6184 if we call do_spec_1 and that returns -1. */
6187 handle_braces (const char *p
)
6189 const char *atom
, *end_atom
;
6190 const char *d_atom
= NULL
, *d_end_atom
= NULL
;
6191 const char *orig
= p
;
6199 bool a_must_be_last
= false;
6200 bool ordered_set
= false;
6201 bool disjunct_set
= false;
6202 bool disj_matched
= false;
6203 bool disj_starred
= true;
6204 bool n_way_choice
= false;
6205 bool n_way_matched
= false;
6207 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
6214 /* Scan one "atom" (S in the description above of %{}, possibly
6215 with '!', '.', '@', ',', or '*' modifiers). */
6217 a_is_suffix
= false;
6218 a_is_starred
= false;
6219 a_is_negated
= false;
6220 a_is_spectype
= false;
6224 p
++, a_is_negated
= true;
6227 if (*p
== '%' && p
[1] == ':')
6231 p
= handle_spec_function (p
+ 2, &a_matched
);
6236 p
++, a_is_suffix
= true;
6238 p
++, a_is_spectype
= true;
6241 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
6242 || *p
== ',' || *p
== '.' || *p
== '@')
6247 p
++, a_is_starred
= 1;
6254 /* Substitute the switch(es) indicated by the current atom. */
6256 if (disjunct_set
|| n_way_choice
|| a_is_negated
|| a_is_suffix
6257 || a_is_spectype
|| atom
== end_atom
)
6260 mark_matching_switches (atom
, end_atom
, a_is_starred
);
6263 process_marked_switches ();
6267 /* Substitute some text if the current atom appears as a switch
6269 disjunct_set
= true;
6273 if (atom
&& atom
== end_atom
)
6275 if (!n_way_choice
|| disj_matched
|| *p
== '|'
6276 || a_is_negated
|| a_is_suffix
|| a_is_spectype
6280 /* An empty term may appear as the last choice of an
6281 N-way choice set; it means "otherwise". */
6282 a_must_be_last
= true;
6283 disj_matched
= !n_way_matched
;
6284 disj_starred
= false;
6288 if ((a_is_suffix
|| a_is_spectype
) && a_is_starred
)
6292 disj_starred
= false;
6294 /* Don't bother testing this atom if we already have a
6296 if (!disj_matched
&& !n_way_matched
)
6299 /* a_matched is already set by handle_spec_function. */;
6300 else if (a_is_suffix
)
6301 a_matched
= input_suffix_matches (atom
, end_atom
);
6302 else if (a_is_spectype
)
6303 a_matched
= input_spec_matches (atom
, end_atom
);
6305 a_matched
= switch_matches (atom
, end_atom
, a_is_starred
);
6307 if (a_matched
!= a_is_negated
)
6309 disj_matched
= true;
6311 d_end_atom
= end_atom
;
6318 /* Found the body, that is, the text to substitute if the
6319 current disjunction matches. */
6320 p
= process_brace_body (p
+ 1, d_atom
, d_end_atom
, disj_starred
,
6321 disj_matched
&& !n_way_matched
);
6325 /* If we have an N-way choice, reset state for the next
6329 n_way_choice
= true;
6330 n_way_matched
|= disj_matched
;
6331 disj_matched
= false;
6332 disj_starred
= true;
6333 d_atom
= d_end_atom
= NULL
;
6342 while (*p
++ != '}');
6347 fatal_error (input_location
, "braced spec %qs is invalid at %qc", orig
, *p
);
6352 /* Subroutine of handle_braces. Scan and process a brace substitution body
6353 (X in the description of %{} syntax). P points one past the colon;
6354 ATOM and END_ATOM bracket the first atom which was found to be true
6355 (present) in the current disjunction; STARRED indicates whether all
6356 the atoms in the current disjunction were starred (for syntax validation);
6357 MATCHED indicates whether the disjunction matched or not, and therefore
6358 whether or not the body is to be processed through do_spec_1 or just
6359 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
6363 process_brace_body (const char *p
, const char *atom
, const char *end_atom
,
6364 int starred
, int matched
)
6366 const char *body
, *end_body
;
6367 unsigned int nesting_level
;
6368 bool have_subst
= false;
6370 /* Locate the closing } or ;, honoring nested braces.
6371 Trim trailing whitespace. */
6380 if (!--nesting_level
)
6383 else if (*p
== ';' && nesting_level
== 1)
6385 else if (*p
== '%' && p
[1] == '*' && nesting_level
== 1)
6387 else if (*p
== '\0')
6393 while (end_body
[-1] == ' ' || end_body
[-1] == '\t')
6396 if (have_subst
&& !starred
)
6401 /* Copy the substitution body to permanent storage and execute it.
6402 If have_subst is false, this is a simple matter of running the
6403 body through do_spec_1... */
6404 char *string
= save_string (body
, end_body
- body
);
6407 if (do_spec_1 (string
, 0, NULL
) < 0)
6415 /* ... but if have_subst is true, we have to process the
6416 body once for each matching switch, with %* set to the
6417 variant part of the switch. */
6418 unsigned int hard_match_len
= end_atom
- atom
;
6421 for (i
= 0; i
< n_switches
; i
++)
6422 if (!strncmp (switches
[i
].part1
, atom
, hard_match_len
)
6423 && check_live_switch (i
, hard_match_len
))
6425 if (do_spec_1 (string
, 0,
6426 &switches
[i
].part1
[hard_match_len
]) < 0)
6431 /* Pass any arguments this switch has. */
6433 suffix_subst
= NULL
;
6442 fatal_error (input_location
, "braced spec body %qs is invalid", body
);
6445 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
6446 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
6447 spec, or -1 if either exact match or %* is used.
6449 A -O switch is obsoleted by a later -O switch. A -f, -g, -m, or -W switch
6450 whose value does not begin with "no-" is obsoleted by the same value
6451 with the "no-", similarly for a switch with the "no-" prefix. */
6454 check_live_switch (int switchnum
, int prefix_length
)
6456 const char *name
= switches
[switchnum
].part1
;
6459 /* If we already processed this switch and determined if it was
6460 live or not, return our past determination. */
6461 if (switches
[switchnum
].live_cond
!= 0)
6462 return ((switches
[switchnum
].live_cond
& SWITCH_LIVE
) != 0
6463 && (switches
[switchnum
].live_cond
& SWITCH_FALSE
) == 0
6464 && (switches
[switchnum
].live_cond
& SWITCH_IGNORE_PERMANENTLY
)
6467 /* In the common case of {<at-most-one-letter>*}, a negating
6468 switch would always match, so ignore that case. We will just
6469 send the conflicting switches to the compiler phase. */
6470 if (prefix_length
>= 0 && prefix_length
<= 1)
6473 /* Now search for duplicate in a manner that depends on the name. */
6477 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
6478 if (switches
[i
].part1
[0] == 'O')
6480 switches
[switchnum
].validated
= true;
6481 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
6486 case 'W': case 'f': case 'm': case 'g':
6487 if (! strncmp (name
+ 1, "no-", 3))
6489 /* We have Xno-YYY, search for XYYY. */
6490 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
6491 if (switches
[i
].part1
[0] == name
[0]
6492 && ! strcmp (&switches
[i
].part1
[1], &name
[4]))
6494 /* --specs are validated with the validate_switches mechanism. */
6495 if (switches
[switchnum
].known
)
6496 switches
[switchnum
].validated
= true;
6497 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
6503 /* We have XYYY, search for Xno-YYY. */
6504 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
6505 if (switches
[i
].part1
[0] == name
[0]
6506 && switches
[i
].part1
[1] == 'n'
6507 && switches
[i
].part1
[2] == 'o'
6508 && switches
[i
].part1
[3] == '-'
6509 && !strcmp (&switches
[i
].part1
[4], &name
[1]))
6511 /* --specs are validated with the validate_switches mechanism. */
6512 if (switches
[switchnum
].known
)
6513 switches
[switchnum
].validated
= true;
6514 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
6521 /* Otherwise the switch is live. */
6522 switches
[switchnum
].live_cond
|= SWITCH_LIVE
;
6526 /* Pass a switch to the current accumulating command
6527 in the same form that we received it.
6528 SWITCHNUM identifies the switch; it is an index into
6529 the vector of switches gcc received, which is `switches'.
6530 This cannot fail since it never finishes a command line.
6532 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
6535 give_switch (int switchnum
, int omit_first_word
)
6537 if ((switches
[switchnum
].live_cond
& SWITCH_IGNORE
) != 0)
6540 if (!omit_first_word
)
6542 do_spec_1 ("-", 0, NULL
);
6543 do_spec_1 (switches
[switchnum
].part1
, 1, NULL
);
6546 if (switches
[switchnum
].args
!= 0)
6549 for (p
= switches
[switchnum
].args
; *p
; p
++)
6551 const char *arg
= *p
;
6553 do_spec_1 (" ", 0, NULL
);
6556 unsigned length
= strlen (arg
);
6559 while (length
-- && !IS_DIR_SEPARATOR (arg
[length
]))
6560 if (arg
[length
] == '.')
6562 (CONST_CAST (char *, arg
))[length
] = 0;
6566 do_spec_1 (arg
, 1, NULL
);
6568 (CONST_CAST (char *, arg
))[length
] = '.';
6569 do_spec_1 (suffix_subst
, 1, NULL
);
6572 do_spec_1 (arg
, 1, NULL
);
6576 do_spec_1 (" ", 0, NULL
);
6577 switches
[switchnum
].validated
= true;
6580 /* Print GCC configuration (e.g. version, thread model, target,
6581 configuration_arguments) to a given FILE. */
6584 print_configuration (FILE *file
)
6589 fnotice (file
, "Target: %s\n", spec_machine
);
6590 fnotice (file
, "Configured with: %s\n", configuration_arguments
);
6592 #ifdef THREAD_MODEL_SPEC
6593 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
6594 but there's no point in doing all this processing just to get
6595 thread_model back. */
6596 obstack_init (&obstack
);
6597 do_spec_1 (THREAD_MODEL_SPEC
, 0, thread_model
);
6598 obstack_1grow (&obstack
, '\0');
6599 thrmod
= XOBFINISH (&obstack
, const char *);
6601 thrmod
= thread_model
;
6604 fnotice (file
, "Thread model: %s\n", thrmod
);
6606 /* compiler_version is truncated at the first space when initialized
6607 from version string, so truncate version_string at the first space
6608 before comparing. */
6609 for (n
= 0; version_string
[n
]; n
++)
6610 if (version_string
[n
] == ' ')
6613 if (! strncmp (version_string
, compiler_version
, n
)
6614 && compiler_version
[n
] == 0)
6615 fnotice (file
, "gcc version %s %s\n", version_string
,
6618 fnotice (file
, "gcc driver version %s %sexecuting gcc version %s\n",
6619 version_string
, pkgversion_string
, compiler_version
);
6623 #define RETRY_ICE_ATTEMPTS 3
6625 /* Returns true if FILE1 and FILE2 contain equivalent data, 0 otherwise. */
6628 files_equal_p (char *file1
, char *file2
)
6630 struct stat st1
, st2
;
6633 const int bufsize
= 8192;
6634 char *buf
= XNEWVEC (char, bufsize
);
6636 fd1
= open (file1
, O_RDONLY
);
6637 fd2
= open (file2
, O_RDONLY
);
6639 if (fd1
< 0 || fd2
< 0)
6642 if (fstat (fd1
, &st1
) < 0 || fstat (fd2
, &st2
) < 0)
6645 if (st1
.st_size
!= st2
.st_size
)
6648 for (n
= st1
.st_size
; n
; n
-= len
)
6651 if ((int) len
> bufsize
/ 2)
6654 if (read (fd1
, buf
, len
) != (int) len
6655 || read (fd2
, buf
+ bufsize
/ 2, len
) != (int) len
)
6660 if (memcmp (buf
, buf
+ bufsize
/ 2, len
) != 0)
6677 /* Check that compiler's output doesn't differ across runs.
6678 TEMP_STDOUT_FILES and TEMP_STDERR_FILES are arrays of files, containing
6679 stdout and stderr for each compiler run. Return true if all of
6680 TEMP_STDOUT_FILES and TEMP_STDERR_FILES are equivalent. */
6683 check_repro (char **temp_stdout_files
, char **temp_stderr_files
)
6686 for (i
= 0; i
< RETRY_ICE_ATTEMPTS
- 2; ++i
)
6688 if (!files_equal_p (temp_stdout_files
[i
], temp_stdout_files
[i
+ 1])
6689 || !files_equal_p (temp_stderr_files
[i
], temp_stderr_files
[i
+ 1]))
6691 fnotice (stderr
, "The bug is not reproducible, so it is"
6692 " likely a hardware or OS problem.\n");
6696 return i
== RETRY_ICE_ATTEMPTS
- 2;
6699 enum attempt_status
{
6700 ATTEMPT_STATUS_FAIL_TO_RUN
,
6701 ATTEMPT_STATUS_SUCCESS
,
6706 /* Run compiler with arguments NEW_ARGV to reproduce the ICE, storing stdout
6707 to OUT_TEMP and stderr to ERR_TEMP. If APPEND is TRUE, append to OUT_TEMP
6708 and ERR_TEMP instead of truncating. If EMIT_SYSTEM_INFO is TRUE, also write
6709 GCC configuration into to ERR_TEMP. Return ATTEMPT_STATUS_FAIL_TO_RUN if
6710 compiler failed to run, ATTEMPT_STATUS_ICE if compiled ICE-ed and
6711 ATTEMPT_STATUS_SUCCESS otherwise. */
6713 static enum attempt_status
6714 run_attempt (const char **new_argv
, const char *out_temp
,
6715 const char *err_temp
, int emit_system_info
, int append
)
6718 if (emit_system_info
)
6720 FILE *file_out
= fopen (err_temp
, "a");
6721 print_configuration (file_out
);
6722 fputs ("\n", file_out
);
6728 struct pex_obj
*pex
;
6730 int pex_flags
= PEX_USE_PIPES
| PEX_LAST
;
6731 enum attempt_status status
= ATTEMPT_STATUS_FAIL_TO_RUN
;
6734 pex_flags
|= PEX_STDOUT_APPEND
| PEX_STDERR_APPEND
;
6736 pex
= pex_init (PEX_USE_PIPES
, new_argv
[0], NULL
);
6738 fatal_error (input_location
, "pex_init failed: %m");
6740 errmsg
= pex_run (pex
, pex_flags
, new_argv
[0],
6741 CONST_CAST2 (char *const *, const char **, &new_argv
[1]), out_temp
,
6746 fatal_error (input_location
, errmsg
);
6750 pfatal_with_name (errmsg
);
6754 if (!pex_get_status (pex
, 1, &exit_status
))
6757 switch (WEXITSTATUS (exit_status
))
6760 status
= ATTEMPT_STATUS_ICE
;
6763 case SUCCESS_EXIT_CODE
:
6764 status
= ATTEMPT_STATUS_SUCCESS
;
6776 /* This routine reads lines from IN file, adds C++ style comments
6777 at the begining of each line and writes result into OUT. */
6780 insert_comments (const char *file_in
, const char *file_out
)
6782 FILE *in
= fopen (file_in
, "rb");
6783 FILE *out
= fopen (file_out
, "wb");
6786 bool add_comment
= true;
6787 while (fgets (line
, sizeof (line
), in
))
6792 add_comment
= strchr (line
, '\n') != NULL
;
6799 /* This routine adds preprocessed source code into the given ERR_FILE.
6800 To do this, it adds "-E" to NEW_ARGV and execute RUN_ATTEMPT routine to
6801 add information in report file. RUN_ATTEMPT should return
6802 ATTEMPT_STATUS_SUCCESS, in other case we cannot generate the report. */
6805 do_report_bug (const char **new_argv
, const int nargs
,
6806 char **out_file
, char **err_file
)
6809 int fd
= open (*out_file
, O_RDWR
| O_APPEND
);
6812 write (fd
, "\n//", 3);
6813 for (i
= 0; i
< nargs
; i
++)
6816 write (fd
, new_argv
[i
], strlen (new_argv
[i
]));
6818 write (fd
, "\n\n", 2);
6820 new_argv
[nargs
] = "-E";
6821 new_argv
[nargs
+ 1] = NULL
;
6823 status
= run_attempt (new_argv
, *out_file
, *err_file
, 0, 1);
6825 if (status
== ATTEMPT_STATUS_SUCCESS
)
6827 fnotice (stderr
, "Preprocessed source stored into %s file,"
6828 " please attach this to your bugreport.\n", *out_file
);
6829 /* Make sure it is not deleted. */
6835 /* Try to reproduce ICE. If bug is reproducible, generate report .err file
6836 containing GCC configuration, backtrace, compiler's command line options
6837 and preprocessed source code. */
6840 try_generate_repro (const char **argv
)
6842 int i
, nargs
, out_arg
= -1, quiet
= 0, attempt
;
6843 const char **new_argv
;
6844 char *temp_files
[RETRY_ICE_ATTEMPTS
* 2];
6845 char **temp_stdout_files
= &temp_files
[0];
6846 char **temp_stderr_files
= &temp_files
[RETRY_ICE_ATTEMPTS
];
6848 if (gcc_input_filename
== NULL
|| ! strcmp (gcc_input_filename
, "-"))
6851 for (nargs
= 0; argv
[nargs
] != NULL
; ++nargs
)
6852 /* Only retry compiler ICEs, not preprocessor ones. */
6853 if (! strcmp (argv
[nargs
], "-E"))
6855 else if (argv
[nargs
][0] == '-' && argv
[nargs
][1] == 'o')
6862 /* If the compiler is going to output any time information,
6863 it might varry between invocations. */
6864 else if (! strcmp (argv
[nargs
], "-quiet"))
6866 else if (! strcmp (argv
[nargs
], "-ftime-report"))
6869 if (out_arg
== -1 || !quiet
)
6872 memset (temp_files
, '\0', sizeof (temp_files
));
6873 new_argv
= XALLOCAVEC (const char *, nargs
+ 4);
6874 memcpy (new_argv
, argv
, (nargs
+ 1) * sizeof (const char *));
6875 new_argv
[nargs
++] = "-frandom-seed=0";
6876 new_argv
[nargs
++] = "-fdump-noaddr";
6877 new_argv
[nargs
] = NULL
;
6878 if (new_argv
[out_arg
][2] == '\0')
6879 new_argv
[out_arg
+ 1] = "-";
6881 new_argv
[out_arg
] = "-o-";
6884 for (attempt
= 0; attempt
< RETRY_ICE_ATTEMPTS
; ++attempt
)
6886 int emit_system_info
= 0;
6888 temp_stdout_files
[attempt
] = make_temp_file (".out");
6889 temp_stderr_files
[attempt
] = make_temp_file (".err");
6891 if (attempt
== RETRY_ICE_ATTEMPTS
- 1)
6894 emit_system_info
= 1;
6897 status
= run_attempt (new_argv
, temp_stdout_files
[attempt
],
6898 temp_stderr_files
[attempt
], emit_system_info
,
6901 if (status
!= ATTEMPT_STATUS_ICE
)
6903 fnotice (stderr
, "The bug is not reproducible, so it is"
6904 " likely a hardware or OS problem.\n");
6909 if (!check_repro (temp_stdout_files
, temp_stderr_files
))
6913 /* Insert commented out backtrace into report file. */
6914 char **stderr_commented
= &temp_stdout_files
[RETRY_ICE_ATTEMPTS
- 1];
6915 insert_comments (temp_stderr_files
[RETRY_ICE_ATTEMPTS
- 1],
6918 /* In final attempt we append compiler options and preprocesssed code to last
6919 generated .out file with configuration and backtrace. */
6920 char **output
= &temp_stdout_files
[RETRY_ICE_ATTEMPTS
- 1];
6921 do_report_bug (new_argv
, nargs
, stderr_commented
, output
);
6925 for (i
= 0; i
< RETRY_ICE_ATTEMPTS
* 2; i
++)
6928 unlink (temp_stdout_files
[i
]);
6929 free (temp_stdout_files
[i
]);
6933 /* Search for a file named NAME trying various prefixes including the
6934 user's -B prefix and some standard ones.
6935 Return the absolute file name found. If nothing is found, return NAME. */
6938 find_file (const char *name
)
6940 char *newname
= find_a_file (&startfile_prefixes
, name
, R_OK
, true);
6941 return newname
? newname
: name
;
6944 /* Determine whether a directory exists. If LINKER, return 0 for
6945 certain fixed names not needed by the linker. */
6948 is_directory (const char *path1
, bool linker
)
6955 /* Ensure the string ends with "/.". The resulting path will be a
6956 directory even if the given path is a symbolic link. */
6957 len1
= strlen (path1
);
6958 path
= (char *) alloca (3 + len1
);
6959 memcpy (path
, path1
, len1
);
6961 if (!IS_DIR_SEPARATOR (cp
[-1]))
6962 *cp
++ = DIR_SEPARATOR
;
6966 /* Exclude directories that the linker is known to search. */
6968 && IS_DIR_SEPARATOR (path
[0])
6970 && filename_ncmp (path
+ 1, "lib", 3) == 0)
6972 && filename_ncmp (path
+ 1, "usr", 3) == 0
6973 && IS_DIR_SEPARATOR (path
[4])
6974 && filename_ncmp (path
+ 5, "lib", 3) == 0)))
6977 return (stat (path
, &st
) >= 0 && S_ISDIR (st
.st_mode
));
6980 /* Set up the various global variables to indicate that we're processing
6981 the input file named FILENAME. */
6984 set_input (const char *filename
)
6988 gcc_input_filename
= filename
;
6989 input_filename_length
= strlen (gcc_input_filename
);
6990 input_basename
= lbasename (gcc_input_filename
);
6992 /* Find a suffix starting with the last period,
6993 and set basename_length to exclude that suffix. */
6994 basename_length
= strlen (input_basename
);
6995 suffixed_basename_length
= basename_length
;
6996 p
= input_basename
+ basename_length
;
6997 while (p
!= input_basename
&& *p
!= '.')
6999 if (*p
== '.' && p
!= input_basename
)
7001 basename_length
= p
- input_basename
;
7002 input_suffix
= p
+ 1;
7007 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
7008 we will need to do a stat on the gcc_input_filename. The
7009 INPUT_STAT_SET signals that the stat is needed. */
7013 /* On fatal signals, delete all the temporary files. */
7016 fatal_signal (int signum
)
7018 signal (signum
, SIG_DFL
);
7019 delete_failure_queue ();
7020 delete_temp_files ();
7021 /* Get the same signal again, this time not handled,
7022 so its normal effect occurs. */
7023 kill (getpid (), signum
);
7026 /* Compare the contents of the two files named CMPFILE[0] and
7027 CMPFILE[1]. Return zero if they're identical, nonzero
7031 compare_files (char *cmpfile
[])
7034 FILE *temp
[2] = { NULL
, NULL
};
7040 void *map
[2] = { NULL
, NULL
};
7042 for (i
= 0; i
< 2; i
++)
7046 if (stat (cmpfile
[i
], &st
) < 0 || !S_ISREG (st
.st_mode
))
7048 error ("%s: could not determine length of compare-debug file %s",
7049 gcc_input_filename
, cmpfile
[i
]);
7054 length
[i
] = st
.st_size
;
7057 if (!ret
&& length
[0] != length
[1])
7059 error ("%s: -fcompare-debug failure (length)", gcc_input_filename
);
7064 for (i
= 0; i
< 2; i
++)
7066 int fd
= open (cmpfile
[i
], O_RDONLY
);
7069 error ("%s: could not open compare-debug file %s",
7070 gcc_input_filename
, cmpfile
[i
]);
7075 map
[i
] = mmap (NULL
, length
[i
], PROT_READ
, MAP_PRIVATE
, fd
, 0);
7078 if (map
[i
] == (void *) MAP_FAILED
)
7087 if (memcmp (map
[0], map
[1], length
[0]) != 0)
7089 error ("%s: -fcompare-debug failure", gcc_input_filename
);
7094 for (i
= 0; i
< 2; i
++)
7096 munmap ((caddr_t
) map
[i
], length
[i
]);
7105 for (i
= 0; i
< 2; i
++)
7107 temp
[i
] = fopen (cmpfile
[i
], "r");
7110 error ("%s: could not open compare-debug file %s",
7111 gcc_input_filename
, cmpfile
[i
]);
7117 if (!ret
&& temp
[0] && temp
[1])
7121 c0
= fgetc (temp
[0]);
7122 c1
= fgetc (temp
[1]);
7126 error ("%s: -fcompare-debug failure",
7127 gcc_input_filename
);
7136 for (i
= 1; i
>= 0; i
--)
7145 driver::driver (bool can_finalize
, bool debug
) :
7146 explicit_link_files (NULL
),
7147 decoded_options (NULL
),
7148 m_option_suggestions (NULL
)
7150 env
.init (can_finalize
, debug
);
7155 XDELETEVEC (explicit_link_files
);
7156 XDELETEVEC (decoded_options
);
7157 if (m_option_suggestions
)
7161 FOR_EACH_VEC_ELT (*m_option_suggestions
, i
, str
)
7163 delete m_option_suggestions
;
7167 /* driver::main is implemented as a series of driver:: method calls. */
7170 driver::main (int argc
, char **argv
)
7174 set_progname (argv
[0]);
7175 expand_at_files (&argc
, &argv
);
7176 decode_argv (argc
, const_cast <const char **> (argv
));
7177 global_initializations ();
7178 build_multilib_strings ();
7180 putenv_COLLECT_GCC (argv
[0]);
7181 maybe_putenv_COLLECT_LTO_WRAPPER ();
7182 maybe_putenv_OFFLOAD_TARGETS ();
7183 handle_unrecognized_options ();
7185 if (!maybe_print_and_exit ())
7188 early_exit
= prepare_infiles ();
7190 return get_exit_code ();
7192 do_spec_on_infiles ();
7193 maybe_run_linker (argv
[0]);
7195 return get_exit_code ();
7198 /* Locate the final component of argv[0] after any leading path, and set
7199 the program name accordingly. */
7202 driver::set_progname (const char *argv0
) const
7204 const char *p
= argv0
+ strlen (argv0
);
7205 while (p
!= argv0
&& !IS_DIR_SEPARATOR (p
[-1]))
7209 xmalloc_set_program_name (progname
);
7212 /* Expand any @ files within the command-line args,
7213 setting at_file_supplied if any were expanded. */
7216 driver::expand_at_files (int *argc
, char ***argv
) const
7218 char **old_argv
= *argv
;
7220 expandargv (argc
, argv
);
7222 /* Determine if any expansions were made. */
7223 if (*argv
!= old_argv
)
7224 at_file_supplied
= true;
7227 /* Decode the command-line arguments from argc/argv into the
7228 decoded_options array. */
7231 driver::decode_argv (int argc
, const char **argv
)
7233 /* Register the language-independent parameters. */
7234 global_init_params ();
7237 init_opts_obstack ();
7238 init_options_struct (&global_options
, &global_options_set
);
7240 decode_cmdline_options_to_array (argc
, argv
,
7242 &decoded_options
, &decoded_options_count
);
7245 /* Perform various initializations and setup. */
7248 driver::global_initializations ()
7250 /* Unlock the stdio streams. */
7251 unlock_std_streams ();
7253 gcc_init_libintl ();
7255 diagnostic_initialize (global_dc
, 0);
7256 diagnostic_color_init (global_dc
);
7258 #ifdef GCC_DRIVER_HOST_INITIALIZATION
7259 /* Perform host dependent initialization when needed. */
7260 GCC_DRIVER_HOST_INITIALIZATION
;
7263 if (atexit (delete_temp_files
) != 0)
7264 fatal_error (input_location
, "atexit failed");
7266 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
7267 signal (SIGINT
, fatal_signal
);
7269 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
7270 signal (SIGHUP
, fatal_signal
);
7272 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
7273 signal (SIGTERM
, fatal_signal
);
7275 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
7276 signal (SIGPIPE
, fatal_signal
);
7279 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
7280 receive the signal. A different setting is inheritable */
7281 signal (SIGCHLD
, SIG_DFL
);
7284 /* Parsing and gimplification sometimes need quite large stack.
7285 Increase stack size limits if possible. */
7286 stack_limit_increase (64 * 1024 * 1024);
7288 /* Allocate the argument vector. */
7291 obstack_init (&obstack
);
7294 /* Build multilib_select, et. al from the separate lines that make up each
7295 multilib selection. */
7298 driver::build_multilib_strings () const
7302 const char *const *q
= multilib_raw
;
7305 obstack_init (&multilib_obstack
);
7306 while ((p
= *q
++) != (char *) 0)
7307 obstack_grow (&multilib_obstack
, p
, strlen (p
));
7309 obstack_1grow (&multilib_obstack
, 0);
7310 multilib_select
= XOBFINISH (&multilib_obstack
, const char *);
7312 q
= multilib_matches_raw
;
7313 while ((p
= *q
++) != (char *) 0)
7314 obstack_grow (&multilib_obstack
, p
, strlen (p
));
7316 obstack_1grow (&multilib_obstack
, 0);
7317 multilib_matches
= XOBFINISH (&multilib_obstack
, const char *);
7319 q
= multilib_exclusions_raw
;
7320 while ((p
= *q
++) != (char *) 0)
7321 obstack_grow (&multilib_obstack
, p
, strlen (p
));
7323 obstack_1grow (&multilib_obstack
, 0);
7324 multilib_exclusions
= XOBFINISH (&multilib_obstack
, const char *);
7326 q
= multilib_reuse_raw
;
7327 while ((p
= *q
++) != (char *) 0)
7328 obstack_grow (&multilib_obstack
, p
, strlen (p
));
7330 obstack_1grow (&multilib_obstack
, 0);
7331 multilib_reuse
= XOBFINISH (&multilib_obstack
, const char *);
7334 for (size_t i
= 0; i
< ARRAY_SIZE (multilib_defaults_raw
); i
++)
7337 obstack_1grow (&multilib_obstack
, ' ');
7338 obstack_grow (&multilib_obstack
,
7339 multilib_defaults_raw
[i
],
7340 strlen (multilib_defaults_raw
[i
]));
7344 obstack_1grow (&multilib_obstack
, 0);
7345 multilib_defaults
= XOBFINISH (&multilib_obstack
, const char *);
7349 /* Set up the spec-handling machinery. */
7352 driver::set_up_specs () const
7354 const char *spec_machine_suffix
;
7358 #ifdef INIT_ENVIRONMENT
7359 /* Set up any other necessary machine specific environment variables. */
7360 xputenv (INIT_ENVIRONMENT
);
7363 /* Make a table of what switches there are (switches, n_switches).
7364 Make a table of specified input files (infiles, n_infiles).
7365 Decode switches that are handled locally. */
7367 process_command (decoded_options_count
, decoded_options
);
7369 /* Initialize the vector of specs to just the default.
7370 This means one element containing 0s, as a terminator. */
7372 compilers
= XNEWVAR (struct compiler
, sizeof default_compilers
);
7373 memcpy (compilers
, default_compilers
, sizeof default_compilers
);
7374 n_compilers
= n_default_compilers
;
7376 /* Read specs from a file if there is one. */
7378 machine_suffix
= concat (spec_host_machine
, dir_separator_str
, spec_version
,
7379 accel_dir_suffix
, dir_separator_str
, NULL
);
7380 just_machine_suffix
= concat (spec_machine
, dir_separator_str
, NULL
);
7382 specs_file
= find_a_file (&startfile_prefixes
, "specs", R_OK
, true);
7383 /* Read the specs file unless it is a default one. */
7384 if (specs_file
!= 0 && strcmp (specs_file
, "specs"))
7385 read_specs (specs_file
, true, false);
7389 #ifdef ACCEL_COMPILER
7390 spec_machine_suffix
= machine_suffix
;
7392 spec_machine_suffix
= just_machine_suffix
;
7395 /* We need to check standard_exec_prefix/spec_machine_suffix/specs
7396 for any override of as, ld and libraries. */
7397 specs_file
= (char *) alloca (strlen (standard_exec_prefix
)
7398 + strlen (spec_machine_suffix
) + sizeof ("specs"));
7399 strcpy (specs_file
, standard_exec_prefix
);
7400 strcat (specs_file
, spec_machine_suffix
);
7401 strcat (specs_file
, "specs");
7402 if (access (specs_file
, R_OK
) == 0)
7403 read_specs (specs_file
, true, false);
7405 /* Process any configure-time defaults specified for the command line
7406 options, via OPTION_DEFAULT_SPECS. */
7407 for (i
= 0; i
< ARRAY_SIZE (option_default_specs
); i
++)
7408 do_option_spec (option_default_specs
[i
].name
,
7409 option_default_specs
[i
].spec
);
7411 /* Process DRIVER_SELF_SPECS, adding any new options to the end
7412 of the command line. */
7414 for (i
= 0; i
< ARRAY_SIZE (driver_self_specs
); i
++)
7415 do_self_spec (driver_self_specs
[i
]);
7417 /* If not cross-compiling, look for executables in the standard
7419 if (*cross_compile
== '0')
7421 if (*md_exec_prefix
)
7423 add_prefix (&exec_prefixes
, md_exec_prefix
, "GCC",
7424 PREFIX_PRIORITY_LAST
, 0, 0);
7428 /* Process sysroot_suffix_spec. */
7429 if (*sysroot_suffix_spec
!= 0
7430 && !no_sysroot_suffix
7431 && do_spec_2 (sysroot_suffix_spec
) == 0)
7433 if (argbuf
.length () > 1)
7434 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
7435 else if (argbuf
.length () == 1)
7436 target_sysroot_suffix
= xstrdup (argbuf
.last ());
7439 #ifdef HAVE_LD_SYSROOT
7440 /* Pass the --sysroot option to the linker, if it supports that. If
7441 there is a sysroot_suffix_spec, it has already been processed by
7442 this point, so target_system_root really is the system root we
7444 if (target_system_root
)
7446 obstack_grow (&obstack
, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
7447 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
7448 set_spec ("link", XOBFINISH (&obstack
, const char *), false);
7452 /* Process sysroot_hdrs_suffix_spec. */
7453 if (*sysroot_hdrs_suffix_spec
!= 0
7454 && !no_sysroot_suffix
7455 && do_spec_2 (sysroot_hdrs_suffix_spec
) == 0)
7457 if (argbuf
.length () > 1)
7458 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
7459 else if (argbuf
.length () == 1)
7460 target_sysroot_hdrs_suffix
= xstrdup (argbuf
.last ());
7463 /* Look for startfiles in the standard places. */
7464 if (*startfile_prefix_spec
!= 0
7465 && do_spec_2 (startfile_prefix_spec
) == 0
7466 && do_spec_1 (" ", 0, NULL
) == 0)
7470 FOR_EACH_VEC_ELT (argbuf
, ndx
, arg
)
7471 add_sysrooted_prefix (&startfile_prefixes
, arg
, "BINUTILS",
7472 PREFIX_PRIORITY_LAST
, 0, 1);
7474 /* We should eventually get rid of all these and stick to
7475 startfile_prefix_spec exclusively. */
7476 else if (*cross_compile
== '0' || target_system_root
)
7478 if (*md_startfile_prefix
)
7479 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix
,
7480 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
7482 if (*md_startfile_prefix_1
)
7483 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix_1
,
7484 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
7486 /* If standard_startfile_prefix is relative, base it on
7487 standard_exec_prefix. This lets us move the installed tree
7488 as a unit. If GCC_EXEC_PREFIX is defined, base
7489 standard_startfile_prefix on that as well.
7491 If the prefix is relative, only search it for native compilers;
7492 otherwise we will search a directory containing host libraries. */
7493 if (IS_ABSOLUTE_PATH (standard_startfile_prefix
))
7494 add_sysrooted_prefix (&startfile_prefixes
,
7495 standard_startfile_prefix
, "BINUTILS",
7496 PREFIX_PRIORITY_LAST
, 0, 1);
7497 else if (*cross_compile
== '0')
7499 add_prefix (&startfile_prefixes
,
7500 concat (gcc_exec_prefix
7501 ? gcc_exec_prefix
: standard_exec_prefix
,
7503 standard_startfile_prefix
, NULL
),
7504 NULL
, PREFIX_PRIORITY_LAST
, 0, 1);
7507 /* Sysrooted prefixes are relocated because target_system_root is
7508 also relocated by gcc_exec_prefix. */
7509 if (*standard_startfile_prefix_1
)
7510 add_sysrooted_prefix (&startfile_prefixes
,
7511 standard_startfile_prefix_1
, "BINUTILS",
7512 PREFIX_PRIORITY_LAST
, 0, 1);
7513 if (*standard_startfile_prefix_2
)
7514 add_sysrooted_prefix (&startfile_prefixes
,
7515 standard_startfile_prefix_2
, "BINUTILS",
7516 PREFIX_PRIORITY_LAST
, 0, 1);
7519 /* Process any user specified specs in the order given on the command
7521 for (struct user_specs
*uptr
= user_specs_head
; uptr
; uptr
= uptr
->next
)
7523 char *filename
= find_a_file (&startfile_prefixes
, uptr
->filename
,
7525 read_specs (filename
? filename
: uptr
->filename
, false, true);
7528 /* Process any user self specs. */
7530 struct spec_list
*sl
;
7531 for (sl
= specs
; sl
; sl
= sl
->next
)
7532 if (sl
->name_len
== sizeof "self_spec" - 1
7533 && !strcmp (sl
->name
, "self_spec"))
7534 do_self_spec (*sl
->ptr_spec
);
7539 enum save_temps save
;
7541 if (!compare_debug_second
)
7543 n_switches_debug_check
[1] = n_switches
;
7544 n_switches_alloc_debug_check
[1] = n_switches_alloc
;
7545 switches_debug_check
[1] = XDUPVEC (struct switchstr
, switches
,
7548 do_self_spec ("%:compare-debug-self-opt()");
7549 n_switches_debug_check
[0] = n_switches
;
7550 n_switches_alloc_debug_check
[0] = n_switches_alloc
;
7551 switches_debug_check
[0] = switches
;
7553 n_switches
= n_switches_debug_check
[1];
7554 n_switches_alloc
= n_switches_alloc_debug_check
[1];
7555 switches
= switches_debug_check
[1];
7558 /* Avoid crash when computing %j in this early. */
7559 save
= save_temps_flag
;
7560 save_temps_flag
= SAVE_TEMPS_NONE
;
7562 compare_debug
= -compare_debug
;
7563 do_self_spec ("%:compare-debug-self-opt()");
7565 save_temps_flag
= save
;
7567 if (!compare_debug_second
)
7569 n_switches_debug_check
[1] = n_switches
;
7570 n_switches_alloc_debug_check
[1] = n_switches_alloc
;
7571 switches_debug_check
[1] = switches
;
7572 compare_debug
= -compare_debug
;
7573 n_switches
= n_switches_debug_check
[0];
7574 n_switches_alloc
= n_switches_debug_check
[0];
7575 switches
= switches_debug_check
[0];
7580 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
7581 if (gcc_exec_prefix
)
7582 gcc_exec_prefix
= concat (gcc_exec_prefix
, spec_host_machine
,
7583 dir_separator_str
, spec_version
,
7584 accel_dir_suffix
, dir_separator_str
, NULL
);
7586 /* Now we have the specs.
7587 Set the `valid' bits for switches that match anything in any spec. */
7589 validate_all_switches ();
7591 /* Now that we have the switches and the specs, set
7592 the subdirectory based on the options. */
7593 set_multilib_dir ();
7596 /* Set up to remember the pathname of gcc and any options
7597 needed for collect. We use argv[0] instead of progname because
7598 we need the complete pathname. */
7601 driver::putenv_COLLECT_GCC (const char *argv0
) const
7603 obstack_init (&collect_obstack
);
7604 obstack_grow (&collect_obstack
, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
7605 obstack_grow (&collect_obstack
, argv0
, strlen (argv0
) + 1);
7606 xputenv (XOBFINISH (&collect_obstack
, char *));
7609 /* Set up to remember the pathname of the lto wrapper. */
7612 driver::maybe_putenv_COLLECT_LTO_WRAPPER () const
7614 char *lto_wrapper_file
;
7617 lto_wrapper_file
= NULL
;
7619 lto_wrapper_file
= find_a_file (&exec_prefixes
, "lto-wrapper",
7621 if (lto_wrapper_file
)
7623 lto_wrapper_file
= convert_white_space (lto_wrapper_file
);
7624 lto_wrapper_spec
= lto_wrapper_file
;
7625 obstack_init (&collect_obstack
);
7626 obstack_grow (&collect_obstack
, "COLLECT_LTO_WRAPPER=",
7627 sizeof ("COLLECT_LTO_WRAPPER=") - 1);
7628 obstack_grow (&collect_obstack
, lto_wrapper_spec
,
7629 strlen (lto_wrapper_spec
) + 1);
7630 xputenv (XOBFINISH (&collect_obstack
, char *));
7635 /* Set up to remember the names of offload targets. */
7638 driver::maybe_putenv_OFFLOAD_TARGETS () const
7640 if (offload_targets
&& offload_targets
[0] != '\0')
7642 obstack_grow (&collect_obstack
, "OFFLOAD_TARGET_NAMES=",
7643 sizeof ("OFFLOAD_TARGET_NAMES=") - 1);
7644 obstack_grow (&collect_obstack
, offload_targets
,
7645 strlen (offload_targets
) + 1);
7646 xputenv (XOBFINISH (&collect_obstack
, char *));
7649 free (offload_targets
);
7650 offload_targets
= NULL
;
7653 /* Helper function for driver::suggest_option. Populate
7654 m_option_suggestions with candidate strings for misspelled options.
7655 The strings will be freed by the driver's dtor. */
7658 driver::build_option_suggestions (void)
7660 gcc_assert (m_option_suggestions
== NULL
);
7661 m_option_suggestions
= new auto_vec
<char *> ();
7663 /* We build a vec of m_option_suggestions, using add_misspelling_candidates
7664 to add copies of strings, without a leading dash. */
7666 for (unsigned int i
= 0; i
< cl_options_count
; i
++)
7668 const struct cl_option
*option
= &cl_options
[i
];
7669 const char *opt_text
= option
->opt_text
;
7673 if (option
->var_type
== CLVC_ENUM
)
7675 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
7676 for (unsigned j
= 0; e
->values
[j
].arg
!= NULL
; j
++)
7678 char *with_arg
= concat (opt_text
, e
->values
[j
].arg
, NULL
);
7679 add_misspelling_candidates (m_option_suggestions
, with_arg
);
7684 add_misspelling_candidates (m_option_suggestions
, opt_text
);
7687 case OPT_fsanitize_
:
7688 case OPT_fsanitize_recover_
:
7689 /* -fsanitize= and -fsanitize-recover= can take
7690 a comma-separated list of arguments. Given that combinations
7691 are supported, we can't add all potential candidates to the
7692 vec, but if we at least add them individually without commas,
7693 we should do a better job e.g. correcting
7696 "-fsanitize=address"
7697 rather than to "-Wframe-address" (PR driver/69265). */
7699 for (int j
= 0; sanitizer_opts
[j
].name
!= NULL
; ++j
)
7701 /* Get one arg at a time e.g. "-fsanitize=address". */
7702 char *with_arg
= concat (opt_text
,
7703 sanitizer_opts
[j
].name
,
7705 /* Add with_arg and all of its variant spellings e.g.
7706 "-fno-sanitize=address" to candidates (albeit without
7708 add_misspelling_candidates (m_option_suggestions
, with_arg
);
7717 /* Helper function for driver::handle_unrecognized_options.
7719 Given an unrecognized option BAD_OPT (without the leading dash),
7720 locate the closest reasonable matching option (again, without the
7721 leading dash), or NULL.
7723 The returned string is owned by the driver instance. */
7726 driver::suggest_option (const char *bad_opt
)
7728 /* Lazily populate m_option_suggestions. */
7729 if (!m_option_suggestions
)
7730 build_option_suggestions ();
7731 gcc_assert (m_option_suggestions
);
7733 /* "m_option_suggestions" is now populated. Use it. */
7734 return find_closest_string
7736 (auto_vec
<const char *> *) m_option_suggestions
);
7739 /* Reject switches that no pass was interested in. */
7742 driver::handle_unrecognized_options ()
7744 for (size_t i
= 0; (int) i
< n_switches
; i
++)
7745 if (! switches
[i
].validated
)
7747 const char *hint
= suggest_option (switches
[i
].part1
);
7749 error ("unrecognized command line option %<-%s%>;"
7750 " did you mean %<-%s%>?",
7751 switches
[i
].part1
, hint
);
7753 error ("unrecognized command line option %<-%s%>",
7758 /* Handle the various -print-* options, returning 0 if the driver
7759 should exit, or nonzero if the driver should continue. */
7762 driver::maybe_print_and_exit () const
7764 if (print_search_dirs
)
7766 printf (_("install: %s%s\n"),
7767 gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
7768 gcc_exec_prefix
? "" : machine_suffix
);
7769 printf (_("programs: %s\n"),
7770 build_search_list (&exec_prefixes
, "", false, false));
7771 printf (_("libraries: %s\n"),
7772 build_search_list (&startfile_prefixes
, "", false, true));
7776 if (print_file_name
)
7778 printf ("%s\n", find_file (print_file_name
));
7782 if (print_prog_name
)
7784 if (use_ld
!= NULL
&& ! strcmp (print_prog_name
, "ld"))
7786 /* Append USE_LD to the default linker. */
7787 #ifdef DEFAULT_LINKER
7789 # ifdef HAVE_HOST_EXECUTABLE_SUFFIX
7790 int len
= (sizeof (DEFAULT_LINKER
)
7791 - sizeof (HOST_EXECUTABLE_SUFFIX
));
7795 char *default_linker
= xstrdup (DEFAULT_LINKER
);
7796 /* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains
7797 HOST_EXECUTABLE_SUFFIX. */
7798 if (! strcmp (&default_linker
[len
], HOST_EXECUTABLE_SUFFIX
))
7800 default_linker
[len
] = '\0';
7801 ld
= concat (default_linker
, use_ld
,
7802 HOST_EXECUTABLE_SUFFIX
, NULL
);
7807 ld
= concat (DEFAULT_LINKER
, use_ld
, NULL
);
7808 if (access (ld
, X_OK
) == 0)
7810 printf ("%s\n", ld
);
7814 print_prog_name
= concat (print_prog_name
, use_ld
, NULL
);
7816 char *newname
= find_a_file (&exec_prefixes
, print_prog_name
, X_OK
, 0);
7817 printf ("%s\n", (newname
? newname
: print_prog_name
));
7821 if (print_multi_lib
)
7823 print_multilib_info ();
7827 if (print_multi_directory
)
7829 if (multilib_dir
== NULL
)
7832 printf ("%s\n", multilib_dir
);
7836 if (print_multiarch
)
7838 if (multiarch_dir
== NULL
)
7841 printf ("%s\n", multiarch_dir
);
7847 if (target_system_root
)
7849 if (target_sysroot_suffix
)
7850 printf ("%s%s\n", target_system_root
, target_sysroot_suffix
);
7852 printf ("%s\n", target_system_root
);
7857 if (print_multi_os_directory
)
7859 if (multilib_os_dir
== NULL
)
7862 printf ("%s\n", multilib_os_dir
);
7866 if (print_sysroot_headers_suffix
)
7868 if (*sysroot_hdrs_suffix_spec
)
7870 printf("%s\n", (target_sysroot_hdrs_suffix
7871 ? target_sysroot_hdrs_suffix
7876 /* The error status indicates that only one set of fixed
7877 headers should be built. */
7878 fatal_error (input_location
,
7879 "not configured with sysroot headers suffix");
7882 if (print_help_list
)
7888 printf (_("\nFor bug reporting instructions, please see:\n"));
7889 printf ("%s.\n", bug_report_url
);
7894 /* We do not exit here. Instead we have created a fake input file
7895 called 'help-dummy' which needs to be compiled, and we pass this
7896 on the various sub-processes, along with the --help switch.
7897 Ensure their output appears after ours. */
7898 fputc ('\n', stdout
);
7904 printf (_("%s %s%s\n"), progname
, pkgversion_string
,
7906 printf ("Copyright %s 2016 Free Software Foundation, Inc.\n",
7908 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
7909 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
7914 /* We do not exit here. We use the same mechanism of --help to print
7915 the version of the sub-processes. */
7916 fputc ('\n', stdout
);
7922 print_configuration (stderr
);
7930 /* Figure out what to do with each input file.
7931 Return true if we need to exit early from "main", false otherwise. */
7934 driver::prepare_infiles ()
7937 int lang_n_infiles
= 0;
7939 if (n_infiles
== added_libraries
)
7940 fatal_error (input_location
, "no input files");
7943 /* Early exit needed from main. */
7946 /* Make a place to record the compiler output file names
7947 that correspond to the input files. */
7950 i
+= lang_specific_extra_outfiles
;
7951 outfiles
= XCNEWVEC (const char *, i
);
7953 /* Record which files were specified explicitly as link input. */
7955 explicit_link_files
= XCNEWVEC (char, n_infiles
);
7957 combine_inputs
= have_o
|| flag_wpa
;
7959 for (i
= 0; (int) i
< n_infiles
; i
++)
7961 const char *name
= infiles
[i
].name
;
7962 struct compiler
*compiler
= lookup_compiler (name
,
7964 infiles
[i
].language
);
7966 if (compiler
&& !(compiler
->combinable
))
7967 combine_inputs
= false;
7969 if (lang_n_infiles
> 0 && compiler
!= input_file_compiler
7970 && infiles
[i
].language
&& infiles
[i
].language
[0] != '*')
7971 infiles
[i
].incompiler
= compiler
;
7975 input_file_compiler
= compiler
;
7976 infiles
[i
].incompiler
= compiler
;
7980 /* Since there is no compiler for this input file, assume it is a
7982 explicit_link_files
[i
] = 1;
7983 infiles
[i
].incompiler
= NULL
;
7985 infiles
[i
].compiled
= false;
7986 infiles
[i
].preprocessed
= false;
7989 if (!combine_inputs
&& have_c
&& have_o
&& lang_n_infiles
> 1)
7990 fatal_error (input_location
,
7991 "cannot specify -o with -c, -S or -E with multiple files");
7993 /* No early exit needed from main; we can continue. */
7997 /* Run the spec machinery on each input file. */
8000 driver::do_spec_on_infiles () const
8004 for (i
= 0; (int) i
< n_infiles
; i
++)
8006 int this_file_error
= 0;
8008 /* Tell do_spec what to substitute for %i. */
8010 input_file_number
= i
;
8011 set_input (infiles
[i
].name
);
8013 if (infiles
[i
].compiled
)
8016 /* Use the same thing in %o, unless cp->spec says otherwise. */
8018 outfiles
[i
] = gcc_input_filename
;
8020 /* Figure out which compiler from the file's suffix. */
8023 = lookup_compiler (infiles
[i
].name
, input_filename_length
,
8024 infiles
[i
].language
);
8026 if (input_file_compiler
)
8028 /* Ok, we found an applicable compiler. Run its spec. */
8030 if (input_file_compiler
->spec
[0] == '#')
8032 error ("%s: %s compiler not installed on this system",
8033 gcc_input_filename
, &input_file_compiler
->spec
[1]);
8034 this_file_error
= 1;
8042 free (debug_check_temp_file
[0]);
8043 debug_check_temp_file
[0] = NULL
;
8045 free (debug_check_temp_file
[1]);
8046 debug_check_temp_file
[1] = NULL
;
8049 value
= do_spec (input_file_compiler
->spec
);
8050 infiles
[i
].compiled
= true;
8052 this_file_error
= 1;
8053 else if (compare_debug
&& debug_check_temp_file
[0])
8056 inform (0, "recompiling with -fcompare-debug");
8058 compare_debug
= -compare_debug
;
8059 n_switches
= n_switches_debug_check
[1];
8060 n_switches_alloc
= n_switches_alloc_debug_check
[1];
8061 switches
= switches_debug_check
[1];
8063 value
= do_spec (input_file_compiler
->spec
);
8065 compare_debug
= -compare_debug
;
8066 n_switches
= n_switches_debug_check
[0];
8067 n_switches_alloc
= n_switches_alloc_debug_check
[0];
8068 switches
= switches_debug_check
[0];
8072 error ("during -fcompare-debug recompilation");
8073 this_file_error
= 1;
8076 gcc_assert (debug_check_temp_file
[1]
8077 && filename_cmp (debug_check_temp_file
[0],
8078 debug_check_temp_file
[1]));
8081 inform (0, "comparing final insns dumps");
8083 if (compare_files (debug_check_temp_file
))
8084 this_file_error
= 1;
8089 free (debug_check_temp_file
[0]);
8090 debug_check_temp_file
[0] = NULL
;
8092 free (debug_check_temp_file
[1]);
8093 debug_check_temp_file
[1] = NULL
;
8098 /* If this file's name does not contain a recognized suffix,
8099 record it as explicit linker input. */
8102 explicit_link_files
[i
] = 1;
8104 /* Clear the delete-on-failure queue, deleting the files in it
8105 if this compilation failed. */
8107 if (this_file_error
)
8109 delete_failure_queue ();
8112 /* If this compilation succeeded, don't delete those files later. */
8113 clear_failure_queue ();
8116 /* Reset the input file name to the first compile/object file name, for use
8117 with %b in LINK_SPEC. We use the first input file that we can find
8118 a compiler to compile it instead of using infiles.language since for
8119 languages other than C we use aliases that we then lookup later. */
8124 for (i
= 0; i
< n_infiles
; i
++)
8125 if (infiles
[i
].incompiler
8126 || (infiles
[i
].language
&& infiles
[i
].language
[0] != '*'))
8128 set_input (infiles
[i
].name
);
8135 /* Make sure INPUT_FILE_NUMBER points to first available open
8137 input_file_number
= n_infiles
;
8138 if (lang_specific_pre_link ())
8143 /* If we have to run the linker, do it now. */
8146 driver::maybe_run_linker (const char *argv0
) const
8149 int linker_was_run
= 0;
8150 int num_linker_inputs
;
8152 /* Determine if there are any linker input files. */
8153 num_linker_inputs
= 0;
8154 for (i
= 0; (int) i
< n_infiles
; i
++)
8155 if (explicit_link_files
[i
] || outfiles
[i
] != NULL
)
8156 num_linker_inputs
++;
8158 /* Run ld to link all the compiler output files. */
8160 if (num_linker_inputs
> 0 && !seen_error () && print_subprocess_help
< 2)
8162 int tmp
= execution_count
;
8166 #if HAVE_LTO_PLUGIN > 0
8167 #if HAVE_LTO_PLUGIN == 2
8168 const char *fno_use_linker_plugin
= "fno-use-linker-plugin";
8170 const char *fuse_linker_plugin
= "fuse-linker-plugin";
8174 /* We'll use ld if we can't find collect2. */
8175 if (! strcmp (linker_name_spec
, "collect2"))
8177 char *s
= find_a_file (&exec_prefixes
, "collect2", X_OK
, false);
8179 linker_name_spec
= "ld";
8182 #if HAVE_LTO_PLUGIN > 0
8183 #if HAVE_LTO_PLUGIN == 2
8184 if (!switch_matches (fno_use_linker_plugin
,
8185 fno_use_linker_plugin
8186 + strlen (fno_use_linker_plugin
), 0))
8188 if (switch_matches (fuse_linker_plugin
,
8190 + strlen (fuse_linker_plugin
), 0))
8193 char *temp_spec
= find_a_file (&exec_prefixes
,
8194 LTOPLUGINSONAME
, R_OK
,
8197 fatal_error (input_location
,
8198 "-fuse-linker-plugin, but %s not found",
8200 linker_plugin_file_spec
= convert_white_space (temp_spec
);
8203 lto_gcc_spec
= argv0
;
8206 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
8208 putenv_from_prefixes (&exec_prefixes
, "COMPILER_PATH", false);
8209 putenv_from_prefixes (&startfile_prefixes
, LIBRARY_PATH_ENV
, true);
8211 if (print_subprocess_help
== 1)
8213 printf (_("\nLinker options\n==============\n\n"));
8214 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
8215 " to the linker.\n\n"));
8218 int value
= do_spec (link_command_spec
);
8221 linker_was_run
= (tmp
!= execution_count
);
8224 /* If options said don't run linker,
8225 complain about input files to be given to the linker. */
8227 if (! linker_was_run
&& !seen_error ())
8228 for (i
= 0; (int) i
< n_infiles
; i
++)
8229 if (explicit_link_files
[i
]
8230 && !(infiles
[i
].language
&& infiles
[i
].language
[0] == '*'))
8231 warning (0, "%s: linker input file unused because linking not done",
8235 /* The end of "main". */
8238 driver::final_actions () const
8240 /* Delete some or all of the temporary files we made. */
8243 delete_failure_queue ();
8244 delete_temp_files ();
8246 if (print_help_list
)
8248 printf (("\nFor bug reporting instructions, please see:\n"));
8249 printf ("%s\n", bug_report_url
);
8253 /* Determine what the exit code of the driver should be. */
8256 driver::get_exit_code () const
8258 return (signal_count
!= 0 ? 2
8259 : seen_error () ? (pass_exit_codes
? greatest_status
: 1)
8263 /* Find the proper compilation spec for the file name NAME,
8264 whose length is LENGTH. LANGUAGE is the specified language,
8265 or 0 if this file is to be passed to the linker. */
8267 static struct compiler
*
8268 lookup_compiler (const char *name
, size_t length
, const char *language
)
8270 struct compiler
*cp
;
8272 /* If this was specified by the user to be a linker input, indicate that. */
8273 if (language
!= 0 && language
[0] == '*')
8276 /* Otherwise, look for the language, if one is spec'd. */
8279 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
8280 if (cp
->suffix
[0] == '@' && !strcmp (cp
->suffix
+ 1, language
))
8283 error ("language %s not recognized", language
);
8287 /* Look for a suffix. */
8288 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
8290 if (/* The suffix `-' matches only the file name `-'. */
8291 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
8292 || (strlen (cp
->suffix
) < length
8293 /* See if the suffix matches the end of NAME. */
8294 && !strcmp (cp
->suffix
,
8295 name
+ length
- strlen (cp
->suffix
))
8300 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
8301 /* Look again, but case-insensitively this time. */
8303 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
8305 if (/* The suffix `-' matches only the file name `-'. */
8306 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
8307 || (strlen (cp
->suffix
) < length
8308 /* See if the suffix matches the end of NAME. */
8309 && ((!strcmp (cp
->suffix
,
8310 name
+ length
- strlen (cp
->suffix
))
8311 || !strpbrk (cp
->suffix
, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
8312 && !strcasecmp (cp
->suffix
,
8313 name
+ length
- strlen (cp
->suffix
)))
8319 if (cp
>= compilers
)
8321 if (cp
->spec
[0] != '@')
8322 /* A non-alias entry: return it. */
8325 /* An alias entry maps a suffix to a language.
8326 Search for the language; pass 0 for NAME and LENGTH
8327 to avoid infinite recursion if language not found. */
8328 return lookup_compiler (NULL
, 0, cp
->spec
+ 1);
8334 save_string (const char *s
, int len
)
8336 char *result
= XNEWVEC (char, len
+ 1);
8338 memcpy (result
, s
, len
);
8344 pfatal_with_name (const char *name
)
8346 perror_with_name (name
);
8347 delete_temp_files ();
8352 perror_with_name (const char *name
)
8354 error ("%s: %m", name
);
8358 validate_switches_from_spec (const char *spec
, bool user
)
8360 const char *p
= spec
;
8363 if (c
== '%' && (*p
== '{' || *p
== '<' || (*p
== 'W' && *++p
== '{')))
8364 /* We have a switch spec. */
8365 p
= validate_switches (p
+ 1, user
);
8369 validate_all_switches (void)
8371 struct compiler
*comp
;
8372 struct spec_list
*spec
;
8374 for (comp
= compilers
; comp
->spec
; comp
++)
8375 validate_switches_from_spec (comp
->spec
, false);
8377 /* Look through the linked list of specs read from the specs file. */
8378 for (spec
= specs
; spec
; spec
= spec
->next
)
8379 validate_switches_from_spec (*spec
->ptr_spec
, spec
->user_p
);
8381 validate_switches_from_spec (link_command_spec
, false);
8384 /* Look at the switch-name that comes after START
8385 and mark as valid all supplied switches that match it. */
8388 validate_switches (const char *start
, bool user_spec
)
8390 const char *p
= start
;
8394 bool suffix
= false;
8395 bool starred
= false;
8397 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
8406 if (*p
== '.' || *p
== ',')
8410 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
8411 || *p
== ',' || *p
== '.' || *p
== '@')
8416 starred
= true, p
++;
8422 /* Mark all matching switches as valid. */
8423 for (i
= 0; i
< n_switches
; i
++)
8424 if (!strncmp (switches
[i
].part1
, atom
, len
)
8425 && (starred
|| switches
[i
].part1
[len
] == '\0')
8426 && (switches
[i
].known
|| user_spec
))
8427 switches
[i
].validated
= true;
8431 if (*p
&& (p
[-1] == '|' || p
[-1] == '&'))
8434 if (*p
&& p
[-1] == ':')
8436 while (*p
&& *p
!= ';' && *p
!= '}')
8441 if (*p
== '{' || *p
== '<')
8442 p
= validate_switches (p
+1, user_spec
);
8443 else if (p
[0] == 'W' && p
[1] == '{')
8444 p
= validate_switches (p
+2, user_spec
);
8451 if (*p
&& p
[-1] == ';')
8465 static struct mdswitchstr
*mdswitches
;
8466 static int n_mdswitches
;
8468 /* Check whether a particular argument was used. The first time we
8469 canonicalize the switches to keep only the ones we care about. */
8474 int operator () (const char *p
, int len
);
8481 const char *replace
;
8486 mswitchstr
*mswitches
;
8491 used_arg_t used_arg
;
8494 used_arg_t::operator () (const char *p
, int len
)
8500 struct mswitchstr
*matches
;
8504 /* Break multilib_matches into the component strings of string
8505 and replacement string. */
8506 for (q
= multilib_matches
; *q
!= '\0'; q
++)
8511 = (struct mswitchstr
*) alloca ((sizeof (struct mswitchstr
)) * cnt
);
8513 q
= multilib_matches
;
8522 fatal_error (input_location
, "multilib spec %qs is invalid",
8527 matches
[i
].len
= q
- matches
[i
].str
;
8529 matches
[i
].replace
= ++q
;
8530 while (*q
!= ';' && *q
!= '\0')
8533 goto invalid_matches
;
8536 matches
[i
].rep_len
= q
- matches
[i
].replace
;
8542 /* Now build a list of the replacement string for switches that we care
8543 about. Make sure we allocate at least one entry. This prevents
8544 xmalloc from calling fatal, and prevents us from re-executing this
8547 = XNEWVEC (struct mswitchstr
, n_mdswitches
+ (n_switches
? n_switches
: 1));
8548 for (i
= 0; i
< n_switches
; i
++)
8549 if ((switches
[i
].live_cond
& SWITCH_IGNORE
) == 0)
8551 int xlen
= strlen (switches
[i
].part1
);
8552 for (j
= 0; j
< cnt
; j
++)
8553 if (xlen
== matches
[j
].len
8554 && ! strncmp (switches
[i
].part1
, matches
[j
].str
, xlen
))
8556 mswitches
[n_mswitches
].str
= matches
[j
].replace
;
8557 mswitches
[n_mswitches
].len
= matches
[j
].rep_len
;
8558 mswitches
[n_mswitches
].replace
= (char *) 0;
8559 mswitches
[n_mswitches
].rep_len
= 0;
8565 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
8566 on the command line nor any options mutually incompatible with
8568 for (i
= 0; i
< n_mdswitches
; i
++)
8572 for (q
= multilib_options
; *q
!= '\0'; *q
&& q
++)
8578 while (strncmp (q
, mdswitches
[i
].str
, mdswitches
[i
].len
) != 0
8579 || strchr (" /", q
[mdswitches
[i
].len
]) == NULL
)
8581 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
8588 if (*q
!= ' ' && *q
!= '\0')
8590 while (*r
!= ' ' && *r
!= '\0')
8593 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
8596 if (used_arg (r
, q
- r
))
8601 mswitches
[n_mswitches
].str
= mdswitches
[i
].str
;
8602 mswitches
[n_mswitches
].len
= mdswitches
[i
].len
;
8603 mswitches
[n_mswitches
].replace
= (char *) 0;
8604 mswitches
[n_mswitches
].rep_len
= 0;
8617 for (i
= 0; i
< n_mswitches
; i
++)
8618 if (len
== mswitches
[i
].len
&& ! strncmp (p
, mswitches
[i
].str
, len
))
8624 void used_arg_t::finalize ()
8626 XDELETEVEC (mswitches
);
8633 default_arg (const char *p
, int len
)
8637 for (i
= 0; i
< n_mdswitches
; i
++)
8638 if (len
== mdswitches
[i
].len
&& ! strncmp (p
, mdswitches
[i
].str
, len
))
8644 /* Work out the subdirectory to use based on the options. The format of
8645 multilib_select is a list of elements. Each element is a subdirectory
8646 name followed by a list of options followed by a semicolon. The format
8647 of multilib_exclusions is the same, but without the preceding
8648 directory. First gcc will check the exclusions, if none of the options
8649 beginning with an exclamation point are present, and all of the other
8650 options are present, then we will ignore this completely. Passing
8651 that, gcc will consider each multilib_select in turn using the same
8652 rules for matching the options. If a match is found, that subdirectory
8654 A subdirectory name is optionally followed by a colon and the corresponding
8658 set_multilib_dir (void)
8661 unsigned int this_path_len
;
8662 const char *this_path
, *this_arg
;
8663 const char *start
, *end
;
8665 int ok
, ndfltok
, first
;
8668 start
= multilib_defaults
;
8669 while (*start
== ' ' || *start
== '\t')
8671 while (*start
!= '\0')
8674 while (*start
!= ' ' && *start
!= '\t' && *start
!= '\0')
8676 while (*start
== ' ' || *start
== '\t')
8684 mdswitches
= XNEWVEC (struct mdswitchstr
, n_mdswitches
);
8685 for (start
= multilib_defaults
; *start
!= '\0'; start
= end
+ 1)
8687 while (*start
== ' ' || *start
== '\t')
8693 for (end
= start
+ 1;
8694 *end
!= ' ' && *end
!= '\t' && *end
!= '\0'; end
++)
8697 obstack_grow (&multilib_obstack
, start
, end
- start
);
8698 obstack_1grow (&multilib_obstack
, 0);
8699 mdswitches
[i
].str
= XOBFINISH (&multilib_obstack
, const char *);
8700 mdswitches
[i
++].len
= end
- start
;
8707 p
= multilib_exclusions
;
8710 /* Ignore newlines. */
8717 /* Check the arguments. */
8724 fatal_error (input_location
, "multilib exclusions %qs is invalid",
8725 multilib_exclusions
);
8735 while (*p
!= ' ' && *p
!= ';')
8738 goto invalid_exclusions
;
8742 if (*this_arg
!= '!')
8750 ok
= used_arg (this_arg
, p
- this_arg
);
8765 p
= multilib_select
;
8767 /* Append multilib reuse rules if any. With those rules, we can reuse
8768 one multilib for certain different options sets. */
8769 if (strlen (multilib_reuse
) > 0)
8770 p
= concat (p
, multilib_reuse
, NULL
);
8774 /* Ignore newlines. */
8781 /* Get the initial path. */
8788 fatal_error (input_location
, "multilib select %qs %qs is invalid",
8789 multilib_select
, multilib_reuse
);
8793 this_path_len
= p
- this_path
;
8795 /* Check the arguments. */
8802 goto invalid_select
;
8811 while (*p
!= ' ' && *p
!= ';')
8814 goto invalid_select
;
8818 if (*this_arg
!= '!')
8826 /* If this is a default argument, we can just ignore it.
8827 This is true even if this_arg begins with '!'. Beginning
8828 with '!' does not mean that this argument is necessarily
8829 inappropriate for this library: it merely means that
8830 there is a more specific library which uses this
8831 argument. If this argument is a default, we need not
8832 consider that more specific library. */
8833 ok
= used_arg (this_arg
, p
- this_arg
);
8840 if (default_arg (this_arg
, p
- this_arg
))
8849 if (this_path_len
!= 1
8850 || this_path
[0] != '.')
8852 char *new_multilib_dir
= XNEWVEC (char, this_path_len
+ 1);
8855 strncpy (new_multilib_dir
, this_path
, this_path_len
);
8856 new_multilib_dir
[this_path_len
] = '\0';
8857 q
= strchr (new_multilib_dir
, ':');
8860 multilib_dir
= new_multilib_dir
;
8867 const char *q
= this_path
, *end
= this_path
+ this_path_len
;
8869 while (q
< end
&& *q
!= ':')
8873 const char *q2
= q
+ 1, *ml_end
= end
;
8874 char *new_multilib_os_dir
;
8876 while (q2
< end
&& *q2
!= ':')
8880 if (ml_end
- q
== 1)
8881 multilib_os_dir
= xstrdup (".");
8884 new_multilib_os_dir
= XNEWVEC (char, ml_end
- q
);
8885 memcpy (new_multilib_os_dir
, q
+ 1, ml_end
- q
- 1);
8886 new_multilib_os_dir
[ml_end
- q
- 1] = '\0';
8887 multilib_os_dir
= new_multilib_os_dir
;
8890 if (q2
< end
&& *q2
== ':')
8892 char *new_multiarch_dir
= XNEWVEC (char, end
- q2
);
8893 memcpy (new_multiarch_dir
, q2
+ 1, end
- q2
- 1);
8894 new_multiarch_dir
[end
- q2
- 1] = '\0';
8895 multiarch_dir
= new_multiarch_dir
;
8904 if (multilib_dir
== NULL
&& multilib_os_dir
!= NULL
8905 && strcmp (multilib_os_dir
, ".") == 0)
8907 free (CONST_CAST (char *, multilib_os_dir
));
8908 multilib_os_dir
= NULL
;
8910 else if (multilib_dir
!= NULL
&& multilib_os_dir
== NULL
)
8911 multilib_os_dir
= multilib_dir
;
8914 /* Print out the multiple library subdirectory selection
8915 information. This prints out a series of lines. Each line looks
8916 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
8917 required. Only the desired options are printed out, the negative
8918 matches. The options are print without a leading dash. There are
8919 no spaces to make it easy to use the information in the shell.
8920 Each subdirectory is printed only once. This assumes the ordering
8921 generated by the genmultilib script. Also, we leave out ones that match
8925 print_multilib_info (void)
8927 const char *p
= multilib_select
;
8928 const char *last_path
= 0, *this_path
;
8930 unsigned int last_path_len
= 0;
8935 /* Ignore newlines. */
8942 /* Get the initial path. */
8949 fatal_error (input_location
,
8950 "multilib select %qs is invalid", multilib_select
);
8956 /* When --disable-multilib was used but target defines
8957 MULTILIB_OSDIRNAMES, entries starting with .: (and not starting
8958 with .:: for multiarch configurations) are there just to find
8959 multilib_os_dir, so skip them from output. */
8960 if (this_path
[0] == '.' && this_path
[1] == ':' && this_path
[2] != ':')
8963 /* Check for matches with the multilib_exclusions. We don't bother
8964 with the '!' in either list. If any of the exclusion rules match
8965 all of its options with the select rule, we skip it. */
8967 const char *e
= multilib_exclusions
;
8968 const char *this_arg
;
8973 /* Ignore newlines. */
8980 /* Check the arguments. */
8989 fatal_error (input_location
,
8990 "multilib exclusion %qs is invalid",
8991 multilib_exclusions
);
9002 while (*e
!= ' ' && *e
!= ';')
9005 goto invalid_exclusion
;
9013 int len
= e
- this_arg
;
9016 goto invalid_select
;
9020 while (*q
!= ' ' && *q
!= ';')
9023 goto invalid_select
;
9027 if (! strncmp (arg
, this_arg
,
9028 (len
< q
- arg
) ? q
- arg
: len
)
9029 || default_arg (this_arg
, e
- this_arg
))
9059 /* If this is a duplicate, skip it. */
9060 skip
= (last_path
!= 0
9061 && (unsigned int) (p
- this_path
) == last_path_len
9062 && ! filename_ncmp (last_path
, this_path
, last_path_len
));
9064 last_path
= this_path
;
9065 last_path_len
= p
- this_path
;
9068 /* If this directory requires any default arguments, we can skip
9069 it. We will already have printed a directory identical to
9070 this one which does not require that default argument. */
9081 goto invalid_select
;
9088 while (*q
!= ' ' && *q
!= ';')
9091 goto invalid_select
;
9096 && default_arg (arg
, q
- arg
))
9111 for (p1
= last_path
; p1
< p
&& *p1
!= ':'; p1
++)
9122 goto invalid_select
;
9130 use_arg
= *p
!= '!';
9135 while (*p
!= ' ' && *p
!= ';')
9138 goto invalid_select
;
9150 /* If there are extra options, print them now. */
9151 if (multilib_extra
&& *multilib_extra
)
9153 int print_at
= TRUE
;
9156 for (q
= multilib_extra
; *q
!= '\0'; q
++)
9177 /* getenv built-in spec function.
9179 Returns the value of the environment variable given by its first argument,
9180 concatenated with the second argument. If the variable is not defined, a
9181 fatal error is issued unless such undefs are internally allowed, in which
9182 case the variable name is used as the variable value. */
9185 getenv_spec_function (int argc
, const char **argv
)
9188 const char *varname
;
9198 value
= env
.get (varname
);
9200 if (!value
&& spec_undefvar_allowed
)
9204 fatal_error (input_location
,
9205 "environment variable %qs not defined", varname
);
9207 /* We have to escape every character of the environment variable so
9208 they are not interpreted as active spec characters. A
9209 particularly painful case is when we are reading a variable
9210 holding a windows path complete with \ separators. */
9211 len
= strlen (value
) * 2 + strlen (argv
[1]) + 1;
9212 result
= XNEWVAR (char, len
);
9213 for (ptr
= result
; *value
; ptr
+= 2)
9219 strcpy (ptr
, argv
[1]);
9224 /* if-exists built-in spec function.
9226 Checks to see if the file specified by the absolute pathname in
9227 ARGS exists. Returns that pathname if found.
9229 The usual use for this function is to check for a library file
9230 (whose name has been expanded with %s). */
9233 if_exists_spec_function (int argc
, const char **argv
)
9235 /* Must have only one argument. */
9236 if (argc
== 1 && IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
9242 /* if-exists-else built-in spec function.
9244 This is like if-exists, but takes an additional argument which
9245 is returned if the first argument does not exist. */
9248 if_exists_else_spec_function (int argc
, const char **argv
)
9250 /* Must have exactly two arguments. */
9254 if (IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
9260 /* sanitize built-in spec function.
9262 This returns non-NULL, if sanitizing address, thread or
9263 any of the undefined behavior sanitizers. */
9266 sanitize_spec_function (int argc
, const char **argv
)
9271 if (strcmp (argv
[0], "address") == 0)
9272 return (flag_sanitize
& SANITIZE_USER_ADDRESS
) ? "" : NULL
;
9273 if (strcmp (argv
[0], "kernel-address") == 0)
9274 return (flag_sanitize
& SANITIZE_KERNEL_ADDRESS
) ? "" : NULL
;
9275 if (strcmp (argv
[0], "thread") == 0)
9276 return (flag_sanitize
& SANITIZE_THREAD
) ? "" : NULL
;
9277 if (strcmp (argv
[0], "undefined") == 0)
9278 return ((flag_sanitize
& (SANITIZE_UNDEFINED
| SANITIZE_NONDEFAULT
))
9279 && !flag_sanitize_undefined_trap_on_error
) ? "" : NULL
;
9280 if (strcmp (argv
[0], "leak") == 0)
9281 return ((flag_sanitize
9282 & (SANITIZE_ADDRESS
| SANITIZE_LEAK
| SANITIZE_THREAD
))
9283 == SANITIZE_LEAK
) ? "" : NULL
;
9287 /* replace-outfile built-in spec function.
9289 This looks for the first argument in the outfiles array's name and
9290 replaces it with the second argument. */
9293 replace_outfile_spec_function (int argc
, const char **argv
)
9296 /* Must have exactly two arguments. */
9300 for (i
= 0; i
< n_infiles
; i
++)
9302 if (outfiles
[i
] && !filename_cmp (outfiles
[i
], argv
[0]))
9303 outfiles
[i
] = xstrdup (argv
[1]);
9308 /* remove-outfile built-in spec function.
9310 * This looks for the first argument in the outfiles array's name and
9314 remove_outfile_spec_function (int argc
, const char **argv
)
9317 /* Must have exactly one argument. */
9321 for (i
= 0; i
< n_infiles
; i
++)
9323 if (outfiles
[i
] && !filename_cmp (outfiles
[i
], argv
[0]))
9329 /* Given two version numbers, compares the two numbers.
9330 A version number must match the regular expression
9331 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
9334 compare_version_strings (const char *v1
, const char *v2
)
9339 if (regcomp (&r
, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
9340 REG_EXTENDED
| REG_NOSUB
) != 0)
9342 rresult
= regexec (&r
, v1
, 0, NULL
, 0);
9343 if (rresult
== REG_NOMATCH
)
9344 fatal_error (input_location
, "invalid version number %qs", v1
);
9345 else if (rresult
!= 0)
9347 rresult
= regexec (&r
, v2
, 0, NULL
, 0);
9348 if (rresult
== REG_NOMATCH
)
9349 fatal_error (input_location
, "invalid version number %qs", v2
);
9350 else if (rresult
!= 0)
9353 return strverscmp (v1
, v2
);
9357 /* version_compare built-in spec function.
9359 This takes an argument of the following form:
9361 <comparison-op> <arg1> [<arg2>] <switch> <result>
9363 and produces "result" if the comparison evaluates to true,
9364 and nothing if it doesn't.
9366 The supported <comparison-op> values are:
9368 >= true if switch is a later (or same) version than arg1
9370 < true if switch is an earlier version than arg1
9372 >< true if switch is arg1 or later, and earlier than arg2
9373 <> true if switch is earlier than arg1 or is arg2 or later
9375 If the switch is not present, the condition is false unless
9376 the first character of the <comparison-op> is '!'.
9379 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
9380 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
9383 version_compare_spec_function (int argc
, const char **argv
)
9387 const char *switch_value
= NULL
;
9392 fatal_error (input_location
, "too few arguments to %%:version-compare");
9393 if (argv
[0][0] == '\0')
9395 if ((argv
[0][1] == '<' || argv
[0][1] == '>') && argv
[0][0] != '!')
9397 if (argc
!= nargs
+ 3)
9398 fatal_error (input_location
, "too many arguments to %%:version-compare");
9400 switch_len
= strlen (argv
[nargs
+ 1]);
9401 for (i
= 0; i
< n_switches
; i
++)
9402 if (!strncmp (switches
[i
].part1
, argv
[nargs
+ 1], switch_len
)
9403 && check_live_switch (i
, switch_len
))
9404 switch_value
= switches
[i
].part1
+ switch_len
;
9406 if (switch_value
== NULL
)
9410 comp1
= compare_version_strings (switch_value
, argv
[1]);
9412 comp2
= compare_version_strings (switch_value
, argv
[2]);
9414 comp2
= -1; /* This value unused. */
9417 switch (argv
[0][0] << 8 | argv
[0][1])
9419 case '>' << 8 | '=':
9420 result
= comp1
>= 0;
9422 case '!' << 8 | '<':
9423 result
= comp1
>= 0 || switch_value
== NULL
;
9428 case '!' << 8 | '>':
9429 result
= comp1
< 0 || switch_value
== NULL
;
9431 case '>' << 8 | '<':
9432 result
= comp1
>= 0 && comp2
< 0;
9434 case '<' << 8 | '>':
9435 result
= comp1
< 0 || comp2
>= 0;
9439 fatal_error (input_location
,
9440 "unknown operator %qs in %%:version-compare", argv
[0]);
9445 return argv
[nargs
+ 2];
9448 /* %:include builtin spec function. This differs from %include in that it
9449 can be nested inside a spec, and thus be conditionalized. It takes
9450 one argument, the filename, and looks for it in the startfile path.
9451 The result is always NULL, i.e. an empty expansion. */
9454 include_spec_function (int argc
, const char **argv
)
9461 file
= find_a_file (&startfile_prefixes
, argv
[0], R_OK
, true);
9462 read_specs (file
? file
: argv
[0], false, false);
9467 /* %:find-file spec function. This function replaces its argument by
9468 the file found through find_file, that is the -print-file-name gcc
9471 find_file_spec_function (int argc
, const char **argv
)
9478 file
= find_file (argv
[0]);
9483 /* %:find-plugindir spec function. This function replaces its argument
9484 by the -iplugindir=<dir> option. `dir' is found through find_file, that
9485 is the -print-file-name gcc program option. */
9487 find_plugindir_spec_function (int argc
, const char **argv ATTRIBUTE_UNUSED
)
9494 option
= concat ("-iplugindir=", find_file ("plugin"), NULL
);
9499 /* %:print-asm-header spec function. Print a banner to say that the
9500 following output is from the assembler. */
9503 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED
,
9504 const char **argv ATTRIBUTE_UNUSED
)
9506 printf (_("Assembler options\n=================\n\n"));
9507 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
9512 /* Get a random number for -frandom-seed */
9514 static unsigned HOST_WIDE_INT
9515 get_random_number (void)
9517 unsigned HOST_WIDE_INT ret
= 0;
9520 fd
= open ("/dev/urandom", O_RDONLY
);
9523 read (fd
, &ret
, sizeof (HOST_WIDE_INT
));
9529 /* Get some more or less random data. */
9530 #ifdef HAVE_GETTIMEOFDAY
9534 gettimeofday (&tv
, NULL
);
9535 ret
= tv
.tv_sec
* 1000 + tv
.tv_usec
/ 1000;
9539 time_t now
= time (NULL
);
9541 if (now
!= (time_t)-1)
9542 ret
= (unsigned) now
;
9546 return ret
^ getpid ();
9549 /* %:compare-debug-dump-opt spec function. Save the last argument,
9550 expected to be the last -fdump-final-insns option, or generate a
9554 compare_debug_dump_opt_spec_function (int arg
,
9555 const char **argv ATTRIBUTE_UNUSED
)
9560 static char random_seed
[HOST_BITS_PER_WIDE_INT
/ 4 + 3];
9563 fatal_error (input_location
,
9564 "too many arguments to %%:compare-debug-dump-opt");
9566 do_spec_2 ("%{fdump-final-insns=*:%*}");
9567 do_spec_1 (" ", 0, NULL
);
9569 if (argbuf
.length () > 0
9570 && strcmp (argv
[argbuf
.length () - 1], "."))
9575 name
= xstrdup (argv
[argbuf
.length () - 1]);
9580 const char *ext
= NULL
;
9582 if (argbuf
.length () > 0)
9584 do_spec_2 ("%{o*:%*}%{!o:%{!S:%b%O}%{S:%b.s}}");
9587 else if (!compare_debug
)
9590 do_spec_2 ("%g.gkd");
9592 do_spec_1 (" ", 0, NULL
);
9594 gcc_assert (argbuf
.length () > 0);
9596 name
= concat (argbuf
.last (), ext
, NULL
);
9598 ret
= concat ("-fdump-final-insns=", name
, NULL
);
9601 which
= compare_debug
< 0;
9602 debug_check_temp_file
[which
] = name
;
9606 unsigned HOST_WIDE_INT value
= get_random_number ();
9608 sprintf (random_seed
, HOST_WIDE_INT_PRINT_HEX
, value
);
9614 ret
= concat ("%{!frandom-seed=*:-frandom-seed=", random_seed
, "} ",
9625 static const char *debug_auxbase_opt
;
9627 /* %:compare-debug-self-opt spec function. Expands to the options
9628 that are to be passed in the second compilation of
9632 compare_debug_self_opt_spec_function (int arg
,
9633 const char **argv ATTRIBUTE_UNUSED
)
9636 fatal_error (input_location
,
9637 "too many arguments to %%:compare-debug-self-opt");
9639 if (compare_debug
>= 0)
9642 do_spec_2 ("%{c|S:%{o*:%*}}");
9643 do_spec_1 (" ", 0, NULL
);
9645 if (argbuf
.length () > 0)
9646 debug_auxbase_opt
= concat ("-auxbase-strip ",
9650 debug_auxbase_opt
= NULL
;
9653 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
9654 %<fdump-final-insns=* -w -S -o %j \
9655 %{!fcompare-debug-second:-fcompare-debug-second} \
9656 ", compare_debug_opt
, NULL
);
9659 /* %:compare-debug-auxbase-opt spec function. Expands to the auxbase
9660 options that are to be passed in the second compilation of
9661 compare-debug. It expects, as an argument, the basename of the
9662 current input file name, with the .gk suffix appended to it. */
9665 compare_debug_auxbase_opt_spec_function (int arg
,
9672 fatal_error (input_location
,
9673 "too few arguments to %%:compare-debug-auxbase-opt");
9676 fatal_error (input_location
,
9677 "too many arguments to %%:compare-debug-auxbase-opt");
9679 if (compare_debug
>= 0)
9682 len
= strlen (argv
[0]);
9683 if (len
< 3 || strcmp (argv
[0] + len
- 3, ".gk") != 0)
9684 fatal_error (input_location
, "argument to %%:compare-debug-auxbase-opt "
9685 "does not end in .gk");
9687 if (debug_auxbase_opt
)
9688 return debug_auxbase_opt
;
9690 #define OPT "-auxbase "
9693 name
= (char*) xmalloc (sizeof (OPT
) + len
);
9694 memcpy (name
, OPT
, sizeof (OPT
) - 1);
9695 memcpy (name
+ sizeof (OPT
) - 1, argv
[0], len
);
9696 name
[sizeof (OPT
) - 1 + len
] = '\0';
9703 /* %:pass-through-libs spec function. Finds all -l options and input
9704 file names in the lib spec passed to it, and makes a list of them
9705 prepended with the plugin option to cause them to be passed through
9706 to the final link after all the new object files have been added. */
9709 pass_through_libs_spec_func (int argc
, const char **argv
)
9711 char *prepended
= xstrdup (" ");
9713 /* Shlemiel the painter's algorithm. Innately horrible, but at least
9714 we know that there will never be more than a handful of strings to
9715 concat, and it's only once per run, so it's not worth optimising. */
9716 for (n
= 0; n
< argc
; n
++)
9718 char *old
= prepended
;
9719 /* Anything that isn't an option is a full path to an output
9720 file; pass it through if it ends in '.a'. Among options,
9722 if (argv
[n
][0] == '-' && argv
[n
][1] == 'l')
9724 const char *lopt
= argv
[n
] + 2;
9725 /* Handle both joined and non-joined -l options. If for any
9726 reason there's a trailing -l with no joined or following
9727 arg just discard it. */
9728 if (!*lopt
&& ++n
>= argc
)
9732 prepended
= concat (prepended
, "-plugin-opt=-pass-through=-l",
9735 else if (!strcmp (".a", argv
[n
] + strlen (argv
[n
]) - 2))
9737 prepended
= concat (prepended
, "-plugin-opt=-pass-through=",
9738 argv
[n
], " ", NULL
);
9740 if (prepended
!= old
)
9746 /* %:replace-extension spec function. Replaces the extension of the
9747 first argument with the second argument. */
9750 replace_extension_spec_func (int argc
, const char **argv
)
9758 fatal_error (input_location
, "too few arguments to %%:replace-extension");
9760 name
= xstrdup (argv
[0]);
9762 for (i
= strlen (name
) - 1; i
>= 0; i
--)
9763 if (IS_DIR_SEPARATOR (name
[i
]))
9766 p
= strrchr (name
+ i
+ 1, '.');
9770 result
= concat (name
, argv
[1], NULL
);
9776 /* Returns "" if ARGV[ARGC - 2] is greater than ARGV[ARGC-1].
9777 Otherwise, return NULL. */
9780 greater_than_spec_func (int argc
, const char **argv
)
9787 gcc_assert (argc
>= 2);
9789 long arg
= strtol (argv
[argc
- 2], &converted
, 10);
9790 gcc_assert (converted
!= argv
[argc
- 2]);
9792 long lim
= strtol (argv
[argc
- 1], &converted
, 10);
9793 gcc_assert (converted
!= argv
[argc
- 1]);
9801 /* Insert backslash before spaces in ORIG (usually a file path), to
9802 avoid being broken by spec parser.
9804 This function is needed as do_spec_1 treats white space (' ' and '\t')
9805 as the end of an argument. But in case of -plugin /usr/gcc install/xxx.so,
9806 the file name should be treated as a single argument rather than being
9807 broken into multiple. Solution is to insert '\\' before the space in a
9810 This function converts and only converts all occurrence of ' '
9811 to '\\' + ' ' and '\t' to '\\' + '\t'. For example:
9815 "a\\ b" -> "a\\\\ b"
9817 orig: input null-terminating string that was allocated by xalloc. The
9818 memory it points to might be freed in this function. Behavior undefined
9819 if ORIG wasn't xalloced or was freed already at entry.
9821 Return: ORIG if no conversion needed. Otherwise a newly allocated string
9822 that was converted from ORIG. */
9825 convert_white_space (char *orig
)
9827 int len
, number_of_space
= 0;
9829 for (len
= 0; orig
[len
]; len
++)
9830 if (orig
[len
] == ' ' || orig
[len
] == '\t') number_of_space
++;
9832 if (number_of_space
)
9834 char *new_spec
= (char *) xmalloc (len
+ number_of_space
+ 1);
9836 for (j
= 0, k
= 0; j
<= len
; j
++, k
++)
9838 if (orig
[j
] == ' ' || orig
[j
] == '\t')
9839 new_spec
[k
++] = '\\';
9840 new_spec
[k
] = orig
[j
];
9850 path_prefix_reset (path_prefix
*prefix
)
9852 struct prefix_list
*iter
, *next
;
9853 iter
= prefix
->plist
;
9857 free (const_cast <char *> (iter
->prefix
));
9862 prefix
->max_len
= 0;
9865 /* Restore all state within gcc.c to the initial state, so that the driver
9866 code can be safely re-run in-process.
9868 Many const char * variables are referenced by static specs (see
9869 INIT_STATIC_SPEC above). These variables are restored to their default
9870 values by a simple loop over the static specs.
9872 For other variables, we directly restore them all to their initial
9873 values (often implicitly 0).
9875 Free the various obstacks in this file, along with "opts_obstack"
9878 This function also restores any environment variables that were changed. */
9884 params_c_finalize ();
9885 diagnostic_finish (global_dc
);
9888 at_file_supplied
= 0;
9889 print_help_list
= 0;
9891 verbose_only_flag
= 0;
9892 print_subprocess_help
= 0;
9894 report_times_to_file
= NULL
;
9895 target_system_root
= DEFAULT_TARGET_SYSTEM_ROOT
;
9896 target_system_root_changed
= 0;
9897 target_sysroot_suffix
= 0;
9898 target_sysroot_hdrs_suffix
= 0;
9899 save_temps_flag
= SAVE_TEMPS_NONE
;
9900 save_temps_prefix
= 0;
9901 save_temps_length
= 0;
9902 spec_machine
= DEFAULT_TARGET_MACHINE
;
9903 greatest_status
= 1;
9905 finalize_options_struct (&global_options
);
9906 finalize_options_struct (&global_options_set
);
9908 obstack_free (&obstack
, NULL
);
9909 obstack_free (&opts_obstack
, NULL
); /* in opts.c */
9910 obstack_free (&collect_obstack
, NULL
);
9912 link_command_spec
= LINK_COMMAND_SPEC
;
9914 obstack_free (&multilib_obstack
, NULL
);
9916 user_specs_head
= NULL
;
9917 user_specs_tail
= NULL
;
9919 /* Within the "compilers" vec, the fields "suffix" and "spec" were
9920 statically allocated for the default compilers, but dynamically
9921 allocated for additional compilers. Delete them for the latter. */
9922 for (int i
= n_default_compilers
; i
< n_compilers
; i
++)
9924 free (const_cast <char *> (compilers
[i
].suffix
));
9925 free (const_cast <char *> (compilers
[i
].spec
));
9927 XDELETEVEC (compilers
);
9931 linker_options
.truncate (0);
9932 assembler_options
.truncate (0);
9933 preprocessor_options
.truncate (0);
9935 path_prefix_reset (&exec_prefixes
);
9936 path_prefix_reset (&startfile_prefixes
);
9937 path_prefix_reset (&include_prefixes
);
9940 just_machine_suffix
= 0;
9941 gcc_exec_prefix
= 0;
9942 gcc_libexec_prefix
= 0;
9943 md_exec_prefix
= MD_EXEC_PREFIX
;
9944 md_startfile_prefix
= MD_STARTFILE_PREFIX
;
9945 md_startfile_prefix_1
= MD_STARTFILE_PREFIX_1
;
9947 multilib_os_dir
= 0;
9950 /* Free any specs dynamically-allocated by set_spec.
9951 These will be at the head of the list, before the
9952 statically-allocated ones. */
9955 while (specs
!= static_specs
)
9957 spec_list
*next
= specs
->next
;
9958 free (const_cast <char *> (specs
->name
));
9964 for (unsigned i
= 0; i
< ARRAY_SIZE (static_specs
); i
++)
9966 spec_list
*sl
= &static_specs
[i
];
9970 free (const_cast <char *> (*(sl
->ptr_spec
)));
9971 sl
->alloc_p
= false;
9973 *(sl
->ptr_spec
) = sl
->default_ptr
;
9979 processing_spec_function
= 0;
9981 argbuf
.truncate (0);
9987 execution_count
= 0;
9990 temp_filename
= NULL
;
9991 temp_filename_length
= 0;
9992 always_delete_queue
= NULL
;
9993 failure_delete_queue
= NULL
;
9995 XDELETEVEC (switches
);
9998 n_switches_alloc
= 0;
10001 compare_debug_second
= 0;
10002 compare_debug_opt
= NULL
;
10003 for (int i
= 0; i
< 2; i
++)
10005 switches_debug_check
[i
] = NULL
;
10006 n_switches_debug_check
[i
] = 0;
10007 n_switches_alloc_debug_check
[i
] = 0;
10008 debug_check_temp_file
[i
] = NULL
;
10011 XDELETEVEC (infiles
);
10014 n_infiles_alloc
= 0;
10016 combine_inputs
= false;
10017 added_libraries
= 0;
10018 XDELETEVEC (outfiles
);
10021 last_language_n_infiles
= 0;
10022 gcc_input_filename
= NULL
;
10023 input_file_number
= 0;
10024 input_filename_length
= 0;
10025 basename_length
= 0;
10026 suffixed_basename_length
= 0;
10027 input_basename
= NULL
;
10028 input_suffix
= NULL
;
10029 /* We don't need to purge "input_stat", just to unset "input_stat_set". */
10030 input_stat_set
= 0;
10031 input_file_compiler
= NULL
;
10033 delete_this_arg
= 0;
10034 this_is_output_file
= 0;
10035 this_is_library_file
= 0;
10036 this_is_linker_script
= 0;
10037 input_from_pipe
= 0;
10038 suffix_subst
= NULL
;
10043 debug_auxbase_opt
= NULL
;
10045 used_arg
.finalize ();
10049 Targets can provide configure-time default options in
10050 OPTION_DEFAULT_SPECS. The jit needs to access these, but
10051 they are expressed in the spec language.
10053 Run just enough of the driver to be able to expand these
10054 specs, and then call the callback CB on each
10055 such option. The options strings are *without* a leading
10056 '-' character e.g. ("march=x86-64"). Finally, clean up. */
10059 driver_get_configure_time_options (void (*cb
) (const char *option
,
10065 obstack_init (&obstack
);
10066 init_opts_obstack ();
10069 for (i
= 0; i
< ARRAY_SIZE (option_default_specs
); i
++)
10070 do_option_spec (option_default_specs
[i
].name
,
10071 option_default_specs
[i
].spec
);
10073 for (i
= 0; (int) i
< n_switches
; i
++)
10075 gcc_assert (switches
[i
].part1
);
10076 (*cb
) (switches
[i
].part1
, user_data
);
10079 obstack_free (&opts_obstack
, NULL
);
10080 obstack_free (&obstack
, NULL
);