1 /* Compiler driver program that can handle many languages.
2 Copyright (C) 1987-2015 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"
48 /* Manage the manipulation of env vars.
50 We poison "getenv" and "putenv", so that all enviroment-handling is
51 done through this class. Note that poisoning happens in the
52 preprocessor at the identifier level, and doesn't distinguish between
56 Hence we need to use "get" for the accessor method, not "getenv". */
61 void init (bool can_restore
, bool debug
);
62 const char *get (const char *name
);
63 void xput (const char *string
);
78 /* The singleton instance of class env_manager. */
80 static env_manager env
;
82 /* Initializer for class env_manager.
84 We can't do this as a constructor since we have a statically
85 allocated instance ("env" above). */
88 env_manager::init (bool can_restore
, bool debug
)
90 m_can_restore
= can_restore
;
94 /* Get the value of NAME within the environment. Essentially
95 a wrapper for ::getenv, but adding logging, and the possibility
96 of caching results. */
99 env_manager::get (const char *name
)
101 const char *result
= ::getenv (name
);
103 fprintf (stderr
, "env_manager::getenv (%s) -> %s\n", name
, result
);
107 /* Put the given KEY=VALUE entry STRING into the environment.
108 If the env_manager was initialized with CAN_RESTORE set, then
109 also record the old value of KEY within the environment, so that it
110 can be later restored. */
113 env_manager::xput (const char *string
)
116 fprintf (stderr
, "env_manager::xput (%s)\n", string
);
118 fnotice (stderr
, "%s\n", string
);
122 char *equals
= strchr (const_cast <char *> (string
), '=');
126 kv
.m_key
= xstrndup (string
, equals
- string
);
127 const char *cur_value
= ::getenv (kv
.m_key
);
129 fprintf (stderr
, "saving old value: %s\n",cur_value
);
130 kv
.m_value
= cur_value
? xstrdup (cur_value
) : NULL
;
131 m_keys
.safe_push (kv
);
134 ::putenv (CONST_CAST (char *, string
));
137 /* Undo any xputenv changes made since last restore.
138 Can only be called if the env_manager was initialized with
139 CAN_RESTORE enabled. */
142 env_manager::restore ()
147 gcc_assert (m_can_restore
);
149 FOR_EACH_VEC_ELT_REVERSE (m_keys
, i
, item
)
152 printf ("restoring saved key: %s value: %s\n", item
->m_key
, item
->m_value
);
154 ::setenv (item
->m_key
, item
->m_value
, 1);
156 ::unsetenv (item
->m_key
);
158 free (item
->m_value
);
164 /* Forbid other uses of getenv and putenv. */
165 #if (GCC_VERSION >= 3000)
166 #pragma GCC poison getenv putenv
171 /* By default there is no special suffix for target executables. */
172 /* FIXME: when autoconf is fixed, remove the host check - dj */
173 #if defined(TARGET_EXECUTABLE_SUFFIX) && defined(HOST_EXECUTABLE_SUFFIX)
174 #define HAVE_TARGET_EXECUTABLE_SUFFIX
177 /* By default there is no special suffix for host executables. */
178 #ifdef HOST_EXECUTABLE_SUFFIX
179 #define HAVE_HOST_EXECUTABLE_SUFFIX
181 #define HOST_EXECUTABLE_SUFFIX ""
184 /* By default, the suffix for target object files is ".o". */
185 #ifdef TARGET_OBJECT_SUFFIX
186 #define HAVE_TARGET_OBJECT_SUFFIX
188 #define TARGET_OBJECT_SUFFIX ".o"
191 static const char dir_separator_str
[] = { DIR_SEPARATOR
, 0 };
193 /* Most every one is fine with LIBRARY_PATH. For some, it conflicts. */
194 #ifndef LIBRARY_PATH_ENV
195 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
198 /* If a stage of compilation returns an exit status >= 1,
199 compilation of that file ceases. */
201 #define MIN_FATAL_STATUS 1
203 /* Flag set by cppspec.c to 1. */
206 /* Flag set to nonzero if an @file argument has been supplied to gcc. */
207 static bool at_file_supplied
;
209 /* Definition of string containing the arguments given to configure. */
210 #include "configargs.h"
212 /* Flag saying to print the command line options understood by gcc and its
215 static int print_help_list
;
217 /* Flag saying to print the version of gcc and its sub-processes. */
219 static int print_version
;
221 /* Flag indicating whether we should ONLY print the command and
222 arguments (like verbose_flag) without executing the command.
223 Displayed arguments are quoted so that the generated command
224 line is suitable for execution. This is intended for use in
225 shell scripts to capture the driver-generated command line. */
226 static int verbose_only_flag
;
228 /* Flag indicating how to print command line options of sub-processes. */
230 static int print_subprocess_help
;
232 /* Linker suffix passed to -fuse-ld=... */
233 static const char *use_ld
;
235 /* Whether we should report subprocess execution times to a file. */
237 FILE *report_times_to_file
= NULL
;
239 /* Nonzero means place this string before uses of /, so that include
240 and library files can be found in an alternate location. */
242 #ifdef TARGET_SYSTEM_ROOT
243 #define DEFAULT_TARGET_SYSTEM_ROOT (TARGET_SYSTEM_ROOT)
245 #define DEFAULT_TARGET_SYSTEM_ROOT (0)
247 static const char *target_system_root
= DEFAULT_TARGET_SYSTEM_ROOT
;
249 /* Nonzero means pass the updated target_system_root to the compiler. */
251 static int target_system_root_changed
;
253 /* Nonzero means append this string to target_system_root. */
255 static const char *target_sysroot_suffix
= 0;
257 /* Nonzero means append this string to target_system_root for headers. */
259 static const char *target_sysroot_hdrs_suffix
= 0;
261 /* Nonzero means write "temp" files in source directory
262 and use the source file's name in them, and don't delete them. */
264 static enum save_temps
{
265 SAVE_TEMPS_NONE
, /* no -save-temps */
266 SAVE_TEMPS_CWD
, /* -save-temps in current directory */
267 SAVE_TEMPS_OBJ
/* -save-temps in object directory */
270 /* Output file to use to get the object directory for -save-temps=obj */
271 static char *save_temps_prefix
= 0;
272 static size_t save_temps_length
= 0;
274 /* The compiler version. */
276 static const char *compiler_version
;
278 /* The target version. */
280 static const char *const spec_version
= DEFAULT_TARGET_VERSION
;
282 /* The target machine. */
284 static const char *spec_machine
= DEFAULT_TARGET_MACHINE
;
285 static const char *spec_host_machine
= DEFAULT_REAL_TARGET_MACHINE
;
287 /* List of offload targets. Separated by colon. Empty string for
288 -foffload=disable. */
290 static char *offload_targets
= NULL
;
292 /* Nonzero if cross-compiling.
293 When -b is used, the value comes from the `specs' file. */
295 #ifdef CROSS_DIRECTORY_STRUCTURE
296 static const char *cross_compile
= "1";
298 static const char *cross_compile
= "0";
301 /* Greatest exit code of sub-processes that has been encountered up to
303 static int greatest_status
= 1;
305 /* This is the obstack which we use to allocate many strings. */
307 static struct obstack obstack
;
309 /* This is the obstack to build an environment variable to pass to
310 collect2 that describes all of the relevant switches of what to
311 pass the compiler in building the list of pointers to constructors
314 static struct obstack collect_obstack
;
316 /* Forward declaration for prototypes. */
320 static void init_spec (void);
321 static void store_arg (const char *, int, int);
322 static void insert_wrapper (const char *);
323 static char *load_specs (const char *);
324 static void read_specs (const char *, bool, bool);
325 static void set_spec (const char *, const char *, bool);
326 static struct compiler
*lookup_compiler (const char *, size_t, const char *);
327 static char *build_search_list (const struct path_prefix
*, const char *,
329 static void xputenv (const char *);
330 static void putenv_from_prefixes (const struct path_prefix
*, const char *,
332 static int access_check (const char *, int);
333 static char *find_a_file (const struct path_prefix
*, const char *, int, bool);
334 static void add_prefix (struct path_prefix
*, const char *, const char *,
336 static void add_sysrooted_prefix (struct path_prefix
*, const char *,
337 const char *, int, int, int);
338 static char *skip_whitespace (char *);
339 static void delete_if_ordinary (const char *);
340 static void delete_temp_files (void);
341 static void delete_failure_queue (void);
342 static void clear_failure_queue (void);
343 static int check_live_switch (int, int);
344 static const char *handle_braces (const char *);
345 static inline bool input_suffix_matches (const char *, const char *);
346 static inline bool switch_matches (const char *, const char *, int);
347 static inline void mark_matching_switches (const char *, const char *, int);
348 static inline void process_marked_switches (void);
349 static const char *process_brace_body (const char *, const char *, const char *, int, int);
350 static const struct spec_function
*lookup_spec_function (const char *);
351 static const char *eval_spec_function (const char *, const char *);
352 static const char *handle_spec_function (const char *, bool *);
353 static char *save_string (const char *, int);
354 static void set_collect_gcc_options (void);
355 static int do_spec_1 (const char *, int, const char *);
356 static int do_spec_2 (const char *);
357 static void do_option_spec (const char *, const char *);
358 static void do_self_spec (const char *);
359 static const char *find_file (const char *);
360 static int is_directory (const char *, bool);
361 static const char *validate_switches (const char *, bool);
362 static void validate_all_switches (void);
363 static inline void validate_switches_from_spec (const char *, bool);
364 static void give_switch (int, int);
365 static int default_arg (const char *, int);
366 static void set_multilib_dir (void);
367 static void print_multilib_info (void);
368 static void perror_with_name (const char *);
369 static void display_help (void);
370 static void add_preprocessor_option (const char *, int);
371 static void add_assembler_option (const char *, int);
372 static void add_linker_option (const char *, int);
373 static void process_command (unsigned int, struct cl_decoded_option
*);
374 static int execute (void);
375 static void alloc_args (void);
376 static void clear_args (void);
377 static void fatal_signal (int);
378 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
379 static void init_gcc_specs (struct obstack
*, const char *, const char *,
382 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
383 static const char *convert_filename (const char *, int, int);
386 static void try_generate_repro (const char **argv
);
387 static const char *getenv_spec_function (int, const char **);
388 static const char *if_exists_spec_function (int, const char **);
389 static const char *if_exists_else_spec_function (int, const char **);
390 static const char *sanitize_spec_function (int, const char **);
391 static const char *replace_outfile_spec_function (int, const char **);
392 static const char *remove_outfile_spec_function (int, const char **);
393 static const char *version_compare_spec_function (int, const char **);
394 static const char *include_spec_function (int, const char **);
395 static const char *find_file_spec_function (int, const char **);
396 static const char *find_plugindir_spec_function (int, const char **);
397 static const char *print_asm_header_spec_function (int, const char **);
398 static const char *compare_debug_dump_opt_spec_function (int, const char **);
399 static const char *compare_debug_self_opt_spec_function (int, const char **);
400 static const char *compare_debug_auxbase_opt_spec_function (int, const char **);
401 static const char *pass_through_libs_spec_func (int, const char **);
402 static const char *replace_extension_spec_func (int, const char **);
403 static const char *greater_than_spec_func (int, const char **);
404 static char *convert_white_space (char *);
406 /* The Specs Language
408 Specs are strings containing lines, each of which (if not blank)
409 is made up of a program name, and arguments separated by spaces.
410 The program name must be exact and start from root, since no path
411 is searched and it is unreliable to depend on the current working directory.
412 Redirection of input or output is not supported; the subprograms must
413 accept filenames saying what files to read and write.
415 In addition, the specs can contain %-sequences to substitute variable text
416 or for conditional text. Here is a table of all defined %-sequences.
417 Note that spaces are not generated automatically around the results of
418 expanding these sequences; therefore, you can concatenate them together
419 or with constant text in a single argument.
421 %% substitute one % into the program name or argument.
422 %i substitute the name of the input file being processed.
423 %b substitute the basename of the input file being processed.
424 This is the substring up to (and not including) the last period
425 and not including the directory unless -save-temps was specified
426 to put temporaries in a different location.
427 %B same as %b, but include the file suffix (text after the last period).
429 substitute a file name that has suffix SUFFIX and is chosen
430 once per compilation, and mark the argument a la %d. To reduce
431 exposure to denial-of-service attacks, the file name is now
432 chosen in a way that is hard to predict even when previously
433 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
434 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
435 the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
436 had been pre-processed. Previously, %g was simply substituted
437 with a file name chosen once per compilation, without regard
438 to any appended suffix (which was therefore treated just like
439 ordinary text), making such attacks more likely to succeed.
441 like %g, but if -pipe is in effect, expands simply to "-".
443 like %g, but if -pipe is in effect, expands to nothing. (We have both
444 %| and %m to accommodate differences between system assemblers; see
445 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
447 like %g, but generates a new temporary file name even if %uSUFFIX
450 substitutes the last file name generated with %uSUFFIX, generating a
451 new one if there is no such last file name. In the absence of any
452 %uSUFFIX, this is just like %gSUFFIX, except they don't share
453 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
454 would involve the generation of two distinct file names, one
455 for each `%g.s' and another for each `%U.s'. Previously, %U was
456 simply substituted with a file name chosen for the previous %u,
457 without regard to any appended suffix.
459 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
460 writable, and if save-temps is off; otherwise, substitute the name
461 of a temporary file, just like %u. This temporary file is not
462 meant for communication between processes, but rather as a junk
465 substitutes .SUFFIX for the suffixes of a matched switch's args when
466 it is subsequently output with %*. SUFFIX is terminated by the next
468 %d marks the argument containing or following the %d as a
469 temporary file name, so that file will be deleted if GCC exits
470 successfully. Unlike %g, this contributes no text to the argument.
471 %w marks the argument containing or following the %w as the
472 "output file" of this compilation. This puts the argument
473 into the sequence of arguments that %o will substitute later.
474 %V indicates that this compilation produces no "output file".
476 like %{...} but mark last argument supplied within
477 as a file to be deleted on failure.
478 %o substitutes the names of all the output files, with spaces
479 automatically placed around them. You should write spaces
480 around the %o as well or the results are undefined.
481 %o is for use in the specs for running the linker.
482 Input files whose names have no recognized suffix are not compiled
483 at all, but they are included among the output files, so they will
485 %O substitutes the suffix for object files. Note that this is
486 handled specially when it immediately follows %g, %u, or %U
487 (with or without a suffix argument) because of the need for
488 those to form complete file names. The handling is such that
489 %O is treated exactly as if it had already been substituted,
490 except that %g, %u, and %U do not currently support additional
491 SUFFIX characters following %O as they would following, for
493 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
494 (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
495 and -B options) and -imultilib as necessary.
496 %s current argument is the name of a library or startup file of some sort.
497 Search for that file in a standard list of directories
498 and substitute the full name found.
499 %eSTR Print STR as an error message. STR is terminated by a newline.
500 Use this when inconsistent options are detected.
501 %nSTR Print STR as a notice. STR is terminated by a newline.
502 %x{OPTION} Accumulate an option for %X.
503 %X Output the accumulated linker options specified by compilations.
504 %Y Output the accumulated assembler options specified by compilations.
505 %Z Output the accumulated preprocessor options specified by compilations.
506 %a process ASM_SPEC as a spec.
507 This allows config.h to specify part of the spec for running as.
508 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
509 used here. This can be used to run a post-processor after the
510 assembler has done its job.
511 %D Dump out a -L option for each directory in startfile_prefixes.
512 If multilib_dir is set, extra entries are generated with it affixed.
513 %l process LINK_SPEC as a spec.
514 %L process LIB_SPEC as a spec.
515 %M Output multilib_os_dir.
516 %G process LIBGCC_SPEC as a spec.
517 %R Output the concatenation of target_system_root and
518 target_sysroot_suffix.
519 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
520 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
521 %C process CPP_SPEC as a spec.
522 %1 process CC1_SPEC as a spec.
523 %2 process CC1PLUS_SPEC as a spec.
524 %* substitute the variable part of a matched option. (See below.)
525 Note that each comma in the substituted string is replaced by
526 a single space. A space is appended after the last substition
527 unless there is more text in current sequence.
528 %<S remove all occurrences of -S from the command line.
529 Note - this command is position dependent. % commands in the
530 spec string before this one will see -S, % commands in the
531 spec string after this one will not.
532 %>S Similar to "%<S", but keep it in the GCC command line.
533 %<S* remove all occurrences of all switches beginning with -S from the
536 Call the named function FUNCTION, passing it ARGS. ARGS is
537 first processed as a nested spec string, then split into an
538 argument vector in the usual fashion. The function returns
539 a string which is processed as if it had appeared literally
540 as part of the current spec.
541 %{S} substitutes the -S switch, if that switch was given to GCC.
542 If that switch was not specified, this substitutes nothing.
543 Here S is a metasyntactic variable.
544 %{S*} substitutes all the switches specified to GCC whose names start
545 with -S. This is used for -o, -I, etc; switches that take
546 arguments. GCC considers `-o foo' as being one switch whose
547 name starts with `o'. %{o*} would substitute this text,
548 including the space; thus, two arguments would be generated.
549 %{S*&T*} likewise, but preserve order of S and T options (the order
550 of S and T in the spec is not significant). Can be any number
551 of ampersand-separated variables; for each the wild card is
552 optional. Useful for CPP as %{D*&U*&A*}.
554 %{S:X} substitutes X, if the -S switch was given to GCC.
555 %{!S:X} substitutes X, if the -S switch was NOT given to GCC.
556 %{S*:X} substitutes X if one or more switches whose names start
557 with -S was given to GCC. Normally X is substituted only
558 once, no matter how many such switches appeared. However,
559 if %* appears somewhere in X, then X will be substituted
560 once for each matching switch, with the %* replaced by the
561 part of that switch that matched the '*'. A space will be
562 appended after the last substition unless there is more
563 text in current sequence.
564 %{.S:X} substitutes X, if processing a file with suffix S.
565 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
566 %{,S:X} substitutes X, if processing a file which will use spec S.
567 %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
569 %{S|T:X} substitutes X if either -S or -T was given to GCC. This may be
570 combined with '!', '.', ',', and '*' as above binding stronger
572 If %* appears in X, all of the alternatives must be starred, and
573 only the first matching alternative is substituted.
574 %{%:function(args):X}
575 Call function named FUNCTION with args ARGS. If the function
576 returns non-NULL, then X is substituted, if it returns
577 NULL, it isn't substituted.
578 %{S:X; if S was given to GCC, substitutes X;
579 T:Y; else if T was given to GCC, substitutes Y;
580 :D} else substitutes D. There can be as many clauses as you need.
581 This may be combined with '.', '!', ',', '|', and '*' as above.
583 %(Spec) processes a specification defined in a specs file as *Spec:
585 The conditional text X in a %{S:X} or similar construct may contain
586 other nested % constructs or spaces, or even newlines. They are
587 processed as usual, as described above. Trailing white space in X is
588 ignored. White space may also appear anywhere on the left side of the
589 colon in these constructs, except between . or * and the corresponding
592 The -O, -f, -g, -m, and -W switches are handled specifically in these
593 constructs. If another value of -O or the negated form of a -f, -m, or
594 -W switch is found later in the command line, the earlier switch
595 value is ignored, except with {S*} where S is just one letter; this
596 passes all matching options.
598 The character | at the beginning of the predicate text is used to indicate
599 that a command should be piped to the following command, but only if -pipe
602 Note that it is built into GCC which switches take arguments and which
603 do not. You might think it would be useful to generalize this to
604 allow each compiler's spec to say which switches take arguments. But
605 this cannot be done in a consistent fashion. GCC cannot even decide
606 which input files have been specified without knowing which switches
607 take arguments, and it must know which input files to compile in order
608 to tell which compilers to run.
610 GCC also knows implicitly that arguments starting in `-l' are to be
611 treated as compiler output files, and passed to the linker in their
612 proper position among the other output files. */
614 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
616 /* config.h can define ASM_SPEC to provide extra args to the assembler
617 or extra switch-translations. */
622 /* config.h can define ASM_FINAL_SPEC to run a post processor after
623 the assembler has run. */
624 #ifndef ASM_FINAL_SPEC
625 #define ASM_FINAL_SPEC \
627 objcopy --extract-dwo \
628 %{c:%{o*:%*}%{!o*:%b%O}}%{!c:%U%O} \
629 %{c:%{o*:%:replace-extension(%{o*:%*} .dwo)}%{!o*:%b.dwo}}%{!c:%b.dwo} \n\
630 objcopy --strip-dwo \
631 %{c:%{o*:%*}%{!o*:%b%O}}%{!c:%U%O} \
635 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
636 or extra switch-translations. */
641 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
642 or extra switch-translations. */
647 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
648 or extra switch-translations. */
650 #define CC1PLUS_SPEC ""
653 /* config.h can define LINK_SPEC to provide extra args to the linker
654 or extra switch-translations. */
659 /* config.h can define LIB_SPEC to override the default libraries. */
661 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
664 /* When using -fsplit-stack we need to wrap pthread_create, in order
665 to initialize the stack guard. We always use wrapping, rather than
666 shared library ordering, and we keep the wrapper function in
667 libgcc. This is not yet a real spec, though it could become one;
668 it is currently just stuffed into LINK_SPEC. FIXME: This wrapping
669 only works with GNU ld and gold. */
670 #ifdef HAVE_GOLD_NON_DEFAULT_SPLIT_STACK
671 #define STACK_SPLIT_SPEC " %{fsplit-stack: -fuse-ld=gold --wrap=pthread_create}"
673 #define STACK_SPLIT_SPEC " %{fsplit-stack: --wrap=pthread_create}"
677 #define STATIC_LIBASAN_LIBS \
678 " %{static-libasan:%:include(libsanitizer.spec)%(link_libasan)}"
679 #ifdef LIBASAN_EARLY_SPEC
680 #define LIBASAN_SPEC STATIC_LIBASAN_LIBS
681 #elif defined(HAVE_LD_STATIC_DYNAMIC)
682 #define LIBASAN_SPEC "%{static-libasan:" LD_STATIC_OPTION \
683 "} -lasan %{static-libasan:" LD_DYNAMIC_OPTION "}" \
686 #define LIBASAN_SPEC "-lasan" STATIC_LIBASAN_LIBS
690 #ifndef LIBASAN_EARLY_SPEC
691 #define LIBASAN_EARLY_SPEC ""
695 #define STATIC_LIBTSAN_LIBS \
696 " %{static-libtsan:%:include(libsanitizer.spec)%(link_libtsan)}"
697 #ifdef LIBTSAN_EARLY_SPEC
698 #define LIBTSAN_SPEC STATIC_LIBTSAN_LIBS
699 #elif defined(HAVE_LD_STATIC_DYNAMIC)
700 #define LIBTSAN_SPEC "%{static-libtsan:" LD_STATIC_OPTION \
701 "} -ltsan %{static-libtsan:" LD_DYNAMIC_OPTION "}" \
704 #define LIBTSAN_SPEC "-ltsan" STATIC_LIBTSAN_LIBS
708 #ifndef LIBTSAN_EARLY_SPEC
709 #define LIBTSAN_EARLY_SPEC ""
713 #define STATIC_LIBLSAN_LIBS \
714 " %{static-liblsan:%:include(libsanitizer.spec)%(link_liblsan)}"
715 #ifdef LIBLSAN_EARLY_SPEC
716 #define LIBLSAN_SPEC STATIC_LIBLSAN_LIBS
717 #elif defined(HAVE_LD_STATIC_DYNAMIC)
718 #define LIBLSAN_SPEC "%{static-liblsan:" LD_STATIC_OPTION \
719 "} -llsan %{static-liblsan:" LD_DYNAMIC_OPTION "}" \
722 #define LIBLSAN_SPEC "-llsan" STATIC_LIBLSAN_LIBS
726 #ifndef LIBLSAN_EARLY_SPEC
727 #define LIBLSAN_EARLY_SPEC ""
730 #ifndef LIBUBSAN_SPEC
731 #define STATIC_LIBUBSAN_LIBS \
732 " %{static-libubsan:%:include(libsanitizer.spec)%(link_libubsan)}"
733 #ifdef HAVE_LD_STATIC_DYNAMIC
734 #define LIBUBSAN_SPEC "%{static-libubsan:" LD_STATIC_OPTION \
735 "} -lubsan %{static-libubsan:" LD_DYNAMIC_OPTION "}" \
738 #define LIBUBSAN_SPEC "-lubsan" STATIC_LIBUBSAN_LIBS
742 /* Linker options for compressed debug sections. */
743 #if HAVE_LD_COMPRESS_DEBUG == 0
744 /* No linker support. */
745 #define LINK_COMPRESS_DEBUG_SPEC \
746 " %{gz*:%e-gz is not supported in this configuration} "
747 #elif HAVE_LD_COMPRESS_DEBUG == 1
748 /* GNU style on input, GNU ld options. Reject, not useful. */
749 #define LINK_COMPRESS_DEBUG_SPEC \
750 " %{gz*:%e-gz is not supported in this configuration} "
751 #elif HAVE_LD_COMPRESS_DEBUG == 2
752 /* GNU style, GNU gold options. */
753 #define LINK_COMPRESS_DEBUG_SPEC \
754 " %{gz|gz=zlib-gnu:" LD_COMPRESS_DEBUG_OPTION "=zlib}" \
755 " %{gz=none:" LD_COMPRESS_DEBUG_OPTION "=none}" \
756 " %{gz=zlib:%e-gz=zlib is not supported in this configuration} "
757 #elif HAVE_LD_COMPRESS_DEBUG == 3
758 /* ELF gABI style. */
759 #define LINK_COMPRESS_DEBUG_SPEC \
760 " %{gz|gz=zlib:" LD_COMPRESS_DEBUG_OPTION "=zlib}" \
761 " %{gz=none:" LD_COMPRESS_DEBUG_OPTION "=none}" \
762 " %{gz=zlib-gnu:" LD_COMPRESS_DEBUG_OPTION "=zlib-gnu} "
764 #error Unknown value for HAVE_LD_COMPRESS_DEBUG.
767 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
770 #if defined(REAL_LIBGCC_SPEC)
771 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
772 #elif defined(LINK_LIBGCC_SPECIAL_1)
773 /* Have gcc do the search for libgcc.a. */
774 #define LIBGCC_SPEC "libgcc.a%s"
776 #define LIBGCC_SPEC "-lgcc"
780 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
781 #ifndef STARTFILE_SPEC
782 #define STARTFILE_SPEC \
783 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
786 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
788 #define ENDFILE_SPEC ""
792 #define LINKER_NAME "collect2"
795 #ifdef HAVE_AS_DEBUG_PREFIX_MAP
796 #define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
801 /* Assembler options for compressed debug sections. */
802 #if HAVE_LD_COMPRESS_DEBUG < 2
803 /* Reject if the linker cannot write compressed debug sections. */
804 #define ASM_COMPRESS_DEBUG_SPEC \
805 " %{gz*:%e-gz is not supported in this configuration} "
806 #else /* HAVE_LD_COMPRESS_DEBUG >= 2 */
807 #if HAVE_AS_COMPRESS_DEBUG == 0
808 /* No assembler support. Ignore silently. */
809 #define ASM_COMPRESS_DEBUG_SPEC \
811 #elif HAVE_AS_COMPRESS_DEBUG == 1
812 /* GNU style, GNU as options. */
813 #define ASM_COMPRESS_DEBUG_SPEC \
814 " %{gz|gz=zlib-gnu:" AS_COMPRESS_DEBUG_OPTION "}" \
815 " %{gz=none:" AS_NO_COMPRESS_DEBUG_OPTION "}" \
816 " %{gz=zlib:%e-gz=zlib is not supported in this configuration} "
817 #elif HAVE_AS_COMPRESS_DEBUG == 2
818 /* ELF gABI style. */
819 #define ASM_COMPRESS_DEBUG_SPEC \
820 " %{gz|gz=zlib:" AS_COMPRESS_DEBUG_OPTION "=zlib}" \
821 " %{gz=none:" AS_COMPRESS_DEBUG_OPTION "=none}" \
822 " %{gz=zlib-gnu:" AS_COMPRESS_DEBUG_OPTION "=zlib-gnu} "
824 #error Unknown value for HAVE_AS_COMPRESS_DEBUG.
826 #endif /* HAVE_LD_COMPRESS_DEBUG >= 2 */
828 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
830 #ifndef ASM_DEBUG_SPEC
831 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
832 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
833 # define ASM_DEBUG_SPEC \
834 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
835 ? "%{!g0:%{gdwarf*:--gdwarf2}%{!gdwarf*:%{g*:--gstabs}}}" ASM_MAP \
836 : "%{!g0:%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}}" ASM_MAP)
838 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
839 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gstabs}}" ASM_MAP
841 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
842 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gdwarf2}}" ASM_MAP
846 #ifndef ASM_DEBUG_SPEC
847 # define ASM_DEBUG_SPEC ""
850 /* Here is the spec for running the linker, after compiling all files. */
852 /* This is overridable by the target in case they need to specify the
853 -lgcc and -lc order specially, yet not require them to override all
854 of LINK_COMMAND_SPEC. */
855 #ifndef LINK_GCC_C_SEQUENCE_SPEC
856 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
859 #ifndef LINK_SSP_SPEC
860 #ifdef TARGET_LIBC_PROVIDES_SSP
861 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all" \
862 "|fstack-protector-strong|fstack-protector-explicit:}"
864 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all" \
865 "|fstack-protector-strong|fstack-protector-explicit" \
866 ":-lssp_nonshared -lssp}"
870 #ifdef ENABLE_DEFAULT_PIE
871 #define NO_PIE_SPEC "no-pie|static"
872 #define PIE_SPEC NO_PIE_SPEC "|r|shared:;"
873 #define NO_FPIE1_SPEC "fno-pie"
874 #define FPIE1_SPEC NO_FPIE1_SPEC ":;"
875 #define NO_FPIE2_SPEC "fno-PIE"
876 #define FPIE2_SPEC NO_FPIE2_SPEC ":;"
877 #define NO_FPIE_SPEC NO_FPIE1_SPEC "|" NO_FPIE2_SPEC
878 #define FPIE_SPEC NO_FPIE_SPEC ":;"
879 #define NO_FPIC1_SPEC "fno-pic"
880 #define FPIC1_SPEC NO_FPIC1_SPEC ":;"
881 #define NO_FPIC2_SPEC "fno-PIC"
882 #define FPIC2_SPEC NO_FPIC2_SPEC ":;"
883 #define NO_FPIC_SPEC NO_FPIC1_SPEC "|" NO_FPIC2_SPEC
884 #define FPIC_SPEC NO_FPIC_SPEC ":;"
885 #define NO_FPIE1_AND_FPIC1_SPEC NO_FPIE1_SPEC "|" NO_FPIC1_SPEC
886 #define FPIE1_OR_FPIC1_SPEC NO_FPIE1_AND_FPIC1_SPEC ":;"
887 #define NO_FPIE2_AND_FPIC2_SPEC NO_FPIE2_SPEC "|" NO_FPIC2_SPEC
888 #define FPIE2_OR_FPIC2_SPEC NO_FPIE2_AND_FPIC2_SPEC ":;"
889 #define NO_FPIE_AND_FPIC_SPEC NO_FPIE_SPEC "|" NO_FPIC_SPEC
890 #define FPIE_OR_FPIC_SPEC NO_FPIE_AND_FPIC_SPEC ":;"
892 #define PIE_SPEC "pie"
893 #define NO_PIE_SPEC PIE_SPEC "|r|shared:;"
894 #define FPIE1_SPEC "fpie"
895 #define NO_FPIE1_SPEC FPIE1_SPEC ":;"
896 #define FPIE2_SPEC "fPIE"
897 #define NO_FPIE2_SPEC FPIE2_SPEC ":;"
898 #define FPIE_SPEC FPIE1_SPEC "|" FPIE2_SPEC
899 #define NO_FPIE_SPEC FPIE_SPEC ":;"
900 #define FPIC1_SPEC "fpic"
901 #define NO_FPIC1_SPEC FPIC1_SPEC ":;"
902 #define FPIC2_SPEC "fPIC"
903 #define NO_FPIC2_SPEC FPIC2_SPEC ":;"
904 #define FPIC_SPEC FPIC1_SPEC "|" FPIC2_SPEC
905 #define NO_FPIC_SPEC FPIC_SPEC ":;"
906 #define FPIE1_OR_FPIC1_SPEC FPIE1_SPEC "|" FPIC1_SPEC
907 #define NO_FPIE1_AND_FPIC1_SPEC FPIE1_OR_FPIC1_SPEC ":;"
908 #define FPIE2_OR_FPIC2_SPEC FPIE2_SPEC "|" FPIC2_SPEC
909 #define NO_FPIE2_AND_FPIC2_SPEC FPIE1_OR_FPIC2_SPEC ":;"
910 #define FPIE_OR_FPIC_SPEC FPIE_SPEC "|" FPIC_SPEC
911 #define NO_FPIE_AND_FPIC_SPEC FPIE_OR_FPIC_SPEC ":;"
914 #ifndef LINK_PIE_SPEC
917 #define LD_PIE_SPEC "-pie"
920 #define LD_PIE_SPEC ""
922 #define LINK_PIE_SPEC "%{no-pie:} " "%{" PIE_SPEC ":" LD_PIE_SPEC "} "
925 #ifndef LINK_BUILDID_SPEC
926 # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
927 # define LINK_BUILDID_SPEC "%{!r:--build-id} "
931 /* Conditional to test whether the LTO plugin is used or not.
932 FIXME: For slim LTO we will need to enable plugin unconditionally. This
933 still cause problems with PLUGIN_LD != LD and when plugin is built but
934 not useable. For GCC 4.6 we don't support slim LTO and thus we can enable
935 plugin only when LTO is enabled. We still honor explicit
936 -fuse-linker-plugin if the linker used understands -plugin. */
938 /* The linker has some plugin support. */
939 #if HAVE_LTO_PLUGIN > 0
940 /* The linker used has full plugin support, use LTO plugin by default. */
941 #if HAVE_LTO_PLUGIN == 2
942 #define PLUGIN_COND "!fno-use-linker-plugin:%{!fno-lto"
943 #define PLUGIN_COND_CLOSE "}"
945 /* The linker used has limited plugin support, use LTO plugin with explicit
946 -fuse-linker-plugin. */
947 #define PLUGIN_COND "fuse-linker-plugin"
948 #define PLUGIN_COND_CLOSE ""
950 #define LINK_PLUGIN_SPEC \
952 -plugin %(linker_plugin_file) \
953 -plugin-opt=%(lto_wrapper) \
954 -plugin-opt=-fresolution=%u.res \
955 %{!nostdlib:%{!nodefaultlibs:%:pass-through-libs(%(link_gcc_c_sequence))}} \
958 /* The linker used doesn't support -plugin, reject -fuse-linker-plugin. */
959 #define LINK_PLUGIN_SPEC "%{fuse-linker-plugin:\
960 %e-fuse-linker-plugin is not supported in this configuration}"
963 /* Linker command line options for -fsanitize= early on the command line. */
964 #ifndef SANITIZER_EARLY_SPEC
965 #define SANITIZER_EARLY_SPEC "\
966 %{!nostdlib:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_EARLY_SPEC "} \
967 %{%:sanitize(thread):" LIBTSAN_EARLY_SPEC "} \
968 %{%:sanitize(leak):" LIBLSAN_EARLY_SPEC "}}}"
971 /* Linker command line options for -fsanitize= late on the command line. */
972 #ifndef SANITIZER_SPEC
973 #define SANITIZER_SPEC "\
974 %{!nostdlib:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_SPEC "\
975 %{static:%ecannot specify -static with -fsanitize=address}}\
976 %{%:sanitize(thread):" LIBTSAN_SPEC "\
977 %{static:%ecannot specify -static with -fsanitize=thread}}\
978 %{%:sanitize(undefined):" LIBUBSAN_SPEC "}\
979 %{%:sanitize(leak):" LIBLSAN_SPEC "}}}"
982 /* This is the spec to use, once the code for creating the vtable
983 verification runtime library, libvtv.so, has been created. Currently
984 the vtable verification runtime functions are in libstdc++, so we use
985 the spec just below this one. */
986 #ifndef VTABLE_VERIFICATION_SPEC
987 #define VTABLE_VERIFICATION_SPEC "\
988 %{!nostdlib:%{fvtable-verify=std: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}\
989 %{fvtable-verify=preinit: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}}"
996 /* -u* was put back because both BSD and SysV seem to support it. */
997 /* %{static:} simply prevents an error message if the target machine
998 doesn't handle -static. */
999 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
1000 scripts which exist in user specified directories, or in standard
1002 /* We pass any -flto flags on to the linker, which is expected
1003 to understand them. In practice, this means it had better be collect2. */
1004 /* %{e*} includes -export-dynamic; see comment in common.opt. */
1005 #ifndef LINK_COMMAND_SPEC
1006 #define LINK_COMMAND_SPEC "\
1007 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
1010 "%{flto|flto=*:%<fcompare-debug*} \
1011 %{flto} %{fno-lto} %{flto=*} %l " LINK_PIE_SPEC \
1012 "%{fuse-ld=*:-fuse-ld=%*} " LINK_COMPRESS_DEBUG_SPEC \
1013 "%X %{o*} %{e*} %{N} %{n} %{r}\
1014 %{s} %{t} %{u*} %{z} %{Z} %{!nostdlib:%{!nostartfiles:%S}} " VTABLE_VERIFICATION_SPEC " \
1015 %{static:} %{L*} %(mfwrap) %(link_libgcc) " SANITIZER_EARLY_SPEC " %o\
1017 %{fopenacc|fopenmp|%:gt(%{ftree-parallelize-loops=*} 1):\
1018 %:include(libgomp.spec)%(link_gomp)}\
1019 %{fcilkplus:%:include(libcilkrts.spec)%(link_cilkrts)}\
1020 %{fgnu-tm:%:include(libitm.spec)%(link_itm)}\
1021 %(mflib) " STACK_SPLIT_SPEC "\
1022 %{fprofile-arcs|fprofile-generate*|coverage:-lgcov} " SANITIZER_SPEC " \
1023 %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\
1024 %{!nostdlib:%{!nostartfiles:%E}} %{T*} }}}}}}"
1027 #ifndef LINK_LIBGCC_SPEC
1028 /* Generate -L options for startfile prefix list. */
1029 # define LINK_LIBGCC_SPEC "%D"
1032 #ifndef STARTFILE_PREFIX_SPEC
1033 # define STARTFILE_PREFIX_SPEC ""
1036 #ifndef SYSROOT_SPEC
1037 # define SYSROOT_SPEC "--sysroot=%R"
1040 #ifndef SYSROOT_SUFFIX_SPEC
1041 # define SYSROOT_SUFFIX_SPEC ""
1044 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
1045 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
1048 static const char *asm_debug
= ASM_DEBUG_SPEC
;
1049 static const char *cpp_spec
= CPP_SPEC
;
1050 static const char *cc1_spec
= CC1_SPEC
;
1051 static const char *cc1plus_spec
= CC1PLUS_SPEC
;
1052 static const char *link_gcc_c_sequence_spec
= LINK_GCC_C_SEQUENCE_SPEC
;
1053 static const char *link_ssp_spec
= LINK_SSP_SPEC
;
1054 static const char *asm_spec
= ASM_SPEC
;
1055 static const char *asm_final_spec
= ASM_FINAL_SPEC
;
1056 static const char *link_spec
= LINK_SPEC
;
1057 static const char *lib_spec
= LIB_SPEC
;
1058 static const char *link_gomp_spec
= "";
1059 static const char *libgcc_spec
= LIBGCC_SPEC
;
1060 static const char *endfile_spec
= ENDFILE_SPEC
;
1061 static const char *startfile_spec
= STARTFILE_SPEC
;
1062 static const char *linker_name_spec
= LINKER_NAME
;
1063 static const char *linker_plugin_file_spec
= "";
1064 static const char *lto_wrapper_spec
= "";
1065 static const char *lto_gcc_spec
= "";
1066 static const char *link_command_spec
= LINK_COMMAND_SPEC
;
1067 static const char *link_libgcc_spec
= LINK_LIBGCC_SPEC
;
1068 static const char *startfile_prefix_spec
= STARTFILE_PREFIX_SPEC
;
1069 static const char *sysroot_spec
= SYSROOT_SPEC
;
1070 static const char *sysroot_suffix_spec
= SYSROOT_SUFFIX_SPEC
;
1071 static const char *sysroot_hdrs_suffix_spec
= SYSROOT_HEADERS_SUFFIX_SPEC
;
1072 static const char *self_spec
= "";
1074 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
1075 There should be no need to override these in target dependent files,
1076 but we need to copy them to the specs file so that newer versions
1077 of the GCC driver can correctly drive older tool chains with the
1078 appropriate -B options. */
1080 /* When cpplib handles traditional preprocessing, get rid of this, and
1081 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
1082 that we default the front end language better. */
1083 static const char *trad_capable_cpp
=
1084 "cc1 -E %{traditional|traditional-cpp:-traditional-cpp}";
1086 /* We don't wrap .d files in %W{} since a missing .d file, and
1087 therefore no dependency entry, confuses make into thinking a .o
1088 file that happens to exist is up-to-date. */
1089 static const char *cpp_unique_options
=
1090 "%{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\
1091 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
1092 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
1093 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
1094 %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
1095 %{remap} %{g3|ggdb3|gstabs3|gcoff3|gxcoff3|gvms3:-dD}\
1096 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
1097 %{H} %C %{D*&U*&A*} %{i*} %Z %i\
1100 /* This contains cpp options which are common with cc1_options and are passed
1101 only when preprocessing only to avoid duplication. We pass the cc1 spec
1102 options to the preprocessor so that it the cc1 spec may manipulate
1103 options used to set target flags. Those special target flags settings may
1104 in turn cause preprocessor symbols to be defined specially. */
1105 static const char *cpp_options
=
1106 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
1107 %{f*} %{g*:%{!g0:%{g*} %{!fno-working-directory:-fworking-directory}}} %{O*}\
1108 %{undef} %{save-temps*:-fpch-preprocess}";
1110 /* This contains cpp options which are not passed when the preprocessor
1111 output will be used by another program. */
1112 static const char *cpp_debug_options
= "%{d*}";
1114 /* NB: This is shared amongst all front-ends, except for Ada. */
1115 static const char *cc1_options
=
1116 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
1117 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
1118 %1 %{!Q:-quiet} %{!dumpbase:-dumpbase %B} %{d*} %{m*} %{aux-info*}\
1119 %{fcompare-debug-second:%:compare-debug-auxbase-opt(%b)} \
1120 %{!fcompare-debug-second:%{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}}%{!c:%{!S:-auxbase %b}} \
1121 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
1122 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
1123 %{Qn:-fno-ident} %{Qy:} %{-help:--help}\
1124 %{-target-help:--target-help}\
1125 %{-version:--version}\
1126 %{-help=*:--help=%*}\
1127 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
1128 %{fsyntax-only:-o %j} %{-param*}\
1129 %{coverage:-fprofile-arcs -ftest-coverage}";
1131 static const char *asm_options
=
1132 "%{-target-help:%:print-asm-header()} "
1134 /* If GNU AS is used, then convert -w (no warnings), -I, and -v
1135 to the assembler equivalents. */
1136 "%{v} %{w:-W} %{I*} "
1138 ASM_COMPRESS_DEBUG_SPEC
1139 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
1141 static const char *invoke_as
=
1142 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1144 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
1145 %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
1149 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
1150 %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
1154 /* Some compilers have limits on line lengths, and the multilib_select
1155 and/or multilib_matches strings can be very long, so we build them at
1157 static struct obstack multilib_obstack
;
1158 static const char *multilib_select
;
1159 static const char *multilib_matches
;
1160 static const char *multilib_defaults
;
1161 static const char *multilib_exclusions
;
1162 static const char *multilib_reuse
;
1164 /* Check whether a particular argument is a default argument. */
1166 #ifndef MULTILIB_DEFAULTS
1167 #define MULTILIB_DEFAULTS { "" }
1170 static const char *const multilib_defaults_raw
[] = MULTILIB_DEFAULTS
;
1172 #ifndef DRIVER_SELF_SPECS
1173 #define DRIVER_SELF_SPECS ""
1176 /* Linking to libgomp implies pthreads. This is particularly important
1177 for targets that use different start files and suchlike. */
1178 #ifndef GOMP_SELF_SPECS
1179 #define GOMP_SELF_SPECS \
1180 "%{fopenacc|fopenmp|%:gt(%{ftree-parallelize-loops=*} 1): " \
1184 /* Likewise for -fgnu-tm. */
1185 #ifndef GTM_SELF_SPECS
1186 #define GTM_SELF_SPECS "%{fgnu-tm: -pthread}"
1189 /* Likewise for -fcilkplus. */
1190 #ifndef CILK_SELF_SPECS
1191 #define CILK_SELF_SPECS "%{fcilkplus: -pthread}"
1194 static const char *const driver_self_specs
[] = {
1195 "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
1196 DRIVER_SELF_SPECS
, CONFIGURE_SPECS
, GOMP_SELF_SPECS
, GTM_SELF_SPECS
,
1200 #ifndef OPTION_DEFAULT_SPECS
1201 #define OPTION_DEFAULT_SPECS { "", "" }
1210 static const struct default_spec
1211 option_default_specs
[] = { OPTION_DEFAULT_SPECS
};
1215 struct user_specs
*next
;
1216 const char *filename
;
1219 static struct user_specs
*user_specs_head
, *user_specs_tail
;
1222 /* Record the mapping from file suffixes for compilation specs. */
1226 const char *suffix
; /* Use this compiler for input files
1227 whose names end in this suffix. */
1229 const char *spec
; /* To use this compiler, run this spec. */
1231 const char *cpp_spec
; /* If non-NULL, substitute this spec
1232 for `%C', rather than the usual
1234 const int combinable
; /* If nonzero, compiler can deal with
1235 multiple source files at once (IMA). */
1236 const int needs_preprocessing
; /* If nonzero, source files need to
1237 be run through a preprocessor. */
1240 /* Pointer to a vector of `struct compiler' that gives the spec for
1241 compiling a file, based on its suffix.
1242 A file that does not end in any of these suffixes will be passed
1243 unchanged to the loader and nothing else will be done to it.
1245 An entry containing two 0s is used to terminate the vector.
1247 If multiple entries match a file, the last matching one is used. */
1249 static struct compiler
*compilers
;
1251 /* Number of entries in `compilers', not counting the null terminator. */
1253 static int n_compilers
;
1255 /* The default list of file name suffixes and their compilation specs. */
1257 static const struct compiler default_compilers
[] =
1259 /* Add lists of suffixes of known languages here. If those languages
1260 were not present when we built the driver, we will hit these copies
1261 and be given a more meaningful error than "file not used since
1262 linking is not done". */
1263 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0},
1264 {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
1265 {".mii", "#Objective-C++", 0, 0, 0},
1266 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
1267 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
1268 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
1269 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
1270 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
1271 {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
1272 {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
1273 {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
1274 {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
1275 {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
1276 {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
1277 {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
1278 {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
1279 {".r", "#Ratfor", 0, 0, 0},
1280 {".p", "#Pascal", 0, 0, 0}, {".pas", "#Pascal", 0, 0, 0},
1281 {".java", "#Java", 0, 0, 0}, {".class", "#Java", 0, 0, 0},
1282 {".zip", "#Java", 0, 0, 0}, {".jar", "#Java", 0, 0, 0},
1283 {".go", "#Go", 0, 1, 0},
1284 /* Next come the entries for C. */
1285 {".c", "@c", 0, 0, 1},
1287 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1288 external preprocessor if -save-temps is given. */
1289 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1292 %eGNU C no longer supports -traditional without -E}\
1293 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1294 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1295 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1297 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1298 cc1 %(cpp_unique_options) %(cc1_options)}}}\
1299 %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 1},
1301 "%{!E:%e-E or -x required when input is from standard input}\
1302 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
1303 {".h", "@c-header", 0, 0, 0},
1305 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1306 external preprocessor if -save-temps is given. */
1307 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1309 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1310 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1311 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1313 %{!fsyntax-only:-o %g.s \
1314 %{!fdump-ada-spec*:%{!o*:--output-pch=%i.gch}\
1315 %W{o*:--output-pch=%*}}%V}}\
1316 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1317 cc1 %(cpp_unique_options) %(cc1_options)\
1318 %{!fsyntax-only:-o %g.s \
1319 %{!fdump-ada-spec*:%{!o*:--output-pch=%i.gch}\
1320 %W{o*:--output-pch=%*}}%V}}}}}}}", 0, 0, 0},
1321 {".i", "@cpp-output", 0, 0, 0},
1323 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 0},
1324 {".s", "@assembler", 0, 0, 0},
1326 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 0, 0},
1327 {".sx", "@assembler-with-cpp", 0, 0, 0},
1328 {".S", "@assembler-with-cpp", 0, 0, 0},
1329 {"@assembler-with-cpp",
1330 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1331 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1332 %{E|M|MM:%(cpp_debug_options)}\
1333 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1334 as %(asm_debug) %(asm_options) %|.s %A }}}}"
1336 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1337 %{E|M|MM:%(cpp_debug_options)}\
1338 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1339 as %(asm_debug) %(asm_options) %m.s %A }}}}"
1344 /* Mark end of table. */
1348 /* Number of elements in default_compilers, not counting the terminator. */
1350 static const int n_default_compilers
= ARRAY_SIZE (default_compilers
) - 1;
1352 typedef char *char_p
; /* For DEF_VEC_P. */
1354 /* A vector of options to give to the linker.
1355 These options are accumulated by %x,
1356 and substituted into the linker command with %X. */
1357 static vec
<char_p
> linker_options
;
1359 /* A vector of options to give to the assembler.
1360 These options are accumulated by -Wa,
1361 and substituted into the assembler command with %Y. */
1362 static vec
<char_p
> assembler_options
;
1364 /* A vector of options to give to the preprocessor.
1365 These options are accumulated by -Wp,
1366 and substituted into the preprocessor command with %Z. */
1367 static vec
<char_p
> preprocessor_options
;
1370 skip_whitespace (char *p
)
1374 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1375 be considered whitespace. */
1376 if (p
[0] == '\n' && p
[1] == '\n' && p
[2] == '\n')
1378 else if (*p
== '\n' || *p
== ' ' || *p
== '\t')
1392 /* Structures to keep track of prefixes to try when looking for files. */
1396 const char *prefix
; /* String to prepend to the path. */
1397 struct prefix_list
*next
; /* Next in linked list. */
1398 int require_machine_suffix
; /* Don't use without machine_suffix. */
1399 /* 2 means try both machine_suffix and just_machine_suffix. */
1400 int priority
; /* Sort key - priority within list. */
1401 int os_multilib
; /* 1 if OS multilib scheme should be used,
1402 0 for GCC multilib scheme. */
1407 struct prefix_list
*plist
; /* List of prefixes to try */
1408 int max_len
; /* Max length of a prefix in PLIST */
1409 const char *name
; /* Name of this list (used in config stuff) */
1412 /* List of prefixes to try when looking for executables. */
1414 static struct path_prefix exec_prefixes
= { 0, 0, "exec" };
1416 /* List of prefixes to try when looking for startup (crt0) files. */
1418 static struct path_prefix startfile_prefixes
= { 0, 0, "startfile" };
1420 /* List of prefixes to try when looking for include files. */
1422 static struct path_prefix include_prefixes
= { 0, 0, "include" };
1424 /* Suffix to attach to directories searched for commands.
1425 This looks like `MACHINE/VERSION/'. */
1427 static const char *machine_suffix
= 0;
1429 /* Suffix to attach to directories searched for commands.
1430 This is just `MACHINE/'. */
1432 static const char *just_machine_suffix
= 0;
1434 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1436 static const char *gcc_exec_prefix
;
1438 /* Adjusted value of standard_libexec_prefix. */
1440 static const char *gcc_libexec_prefix
;
1442 /* Default prefixes to attach to command names. */
1444 #ifndef STANDARD_STARTFILE_PREFIX_1
1445 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1447 #ifndef STANDARD_STARTFILE_PREFIX_2
1448 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1451 #ifdef CROSS_DIRECTORY_STRUCTURE /* Don't use these prefixes for a cross compiler. */
1452 #undef MD_EXEC_PREFIX
1453 #undef MD_STARTFILE_PREFIX
1454 #undef MD_STARTFILE_PREFIX_1
1457 /* If no prefixes defined, use the null string, which will disable them. */
1458 #ifndef MD_EXEC_PREFIX
1459 #define MD_EXEC_PREFIX ""
1461 #ifndef MD_STARTFILE_PREFIX
1462 #define MD_STARTFILE_PREFIX ""
1464 #ifndef MD_STARTFILE_PREFIX_1
1465 #define MD_STARTFILE_PREFIX_1 ""
1468 /* These directories are locations set at configure-time based on the
1469 --prefix option provided to configure. Their initializers are
1470 defined in Makefile.in. These paths are not *directly* used when
1471 gcc_exec_prefix is set because, in that case, we know where the
1472 compiler has been installed, and use paths relative to that
1473 location instead. */
1474 static const char *const standard_exec_prefix
= STANDARD_EXEC_PREFIX
;
1475 static const char *const standard_libexec_prefix
= STANDARD_LIBEXEC_PREFIX
;
1476 static const char *const standard_bindir_prefix
= STANDARD_BINDIR_PREFIX
;
1477 static const char *const standard_startfile_prefix
= STANDARD_STARTFILE_PREFIX
;
1479 /* For native compilers, these are well-known paths containing
1480 components that may be provided by the system. For cross
1481 compilers, these paths are not used. */
1482 static const char *md_exec_prefix
= MD_EXEC_PREFIX
;
1483 static const char *md_startfile_prefix
= MD_STARTFILE_PREFIX
;
1484 static const char *md_startfile_prefix_1
= MD_STARTFILE_PREFIX_1
;
1485 static const char *const standard_startfile_prefix_1
1486 = STANDARD_STARTFILE_PREFIX_1
;
1487 static const char *const standard_startfile_prefix_2
1488 = STANDARD_STARTFILE_PREFIX_2
;
1490 /* A relative path to be used in finding the location of tools
1491 relative to the driver. */
1492 static const char *const tooldir_base_prefix
= TOOLDIR_BASE_PREFIX
;
1494 /* A prefix to be used when this is an accelerator compiler. */
1495 static const char *const accel_dir_suffix
= ACCEL_DIR_SUFFIX
;
1497 /* Subdirectory to use for locating libraries. Set by
1498 set_multilib_dir based on the compilation options. */
1500 static const char *multilib_dir
;
1502 /* Subdirectory to use for locating libraries in OS conventions. Set by
1503 set_multilib_dir based on the compilation options. */
1505 static const char *multilib_os_dir
;
1507 /* Subdirectory to use for locating libraries in multiarch conventions. Set by
1508 set_multilib_dir based on the compilation options. */
1510 static const char *multiarch_dir
;
1512 /* Structure to keep track of the specs that have been defined so far.
1513 These are accessed using %(specname) in a compiler or link
1518 /* The following 2 fields must be first */
1519 /* to allow EXTRA_SPECS to be initialized */
1520 const char *name
; /* name of the spec. */
1521 const char *ptr
; /* available ptr if no static pointer */
1523 /* The following fields are not initialized */
1524 /* by EXTRA_SPECS */
1525 const char **ptr_spec
; /* pointer to the spec itself. */
1526 struct spec_list
*next
; /* Next spec in linked list. */
1527 int name_len
; /* length of the name */
1528 bool user_p
; /* whether string come from file spec. */
1529 bool alloc_p
; /* whether string was allocated */
1530 const char *default_ptr
; /* The default value of *ptr_spec. */
1533 #define INIT_STATIC_SPEC(NAME,PTR) \
1534 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, false, false, \
1537 /* List of statically defined specs. */
1538 static struct spec_list static_specs
[] =
1540 INIT_STATIC_SPEC ("asm", &asm_spec
),
1541 INIT_STATIC_SPEC ("asm_debug", &asm_debug
),
1542 INIT_STATIC_SPEC ("asm_final", &asm_final_spec
),
1543 INIT_STATIC_SPEC ("asm_options", &asm_options
),
1544 INIT_STATIC_SPEC ("invoke_as", &invoke_as
),
1545 INIT_STATIC_SPEC ("cpp", &cpp_spec
),
1546 INIT_STATIC_SPEC ("cpp_options", &cpp_options
),
1547 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options
),
1548 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options
),
1549 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp
),
1550 INIT_STATIC_SPEC ("cc1", &cc1_spec
),
1551 INIT_STATIC_SPEC ("cc1_options", &cc1_options
),
1552 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec
),
1553 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec
),
1554 INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec
),
1555 INIT_STATIC_SPEC ("endfile", &endfile_spec
),
1556 INIT_STATIC_SPEC ("link", &link_spec
),
1557 INIT_STATIC_SPEC ("lib", &lib_spec
),
1558 INIT_STATIC_SPEC ("link_gomp", &link_gomp_spec
),
1559 INIT_STATIC_SPEC ("libgcc", &libgcc_spec
),
1560 INIT_STATIC_SPEC ("startfile", &startfile_spec
),
1561 INIT_STATIC_SPEC ("cross_compile", &cross_compile
),
1562 INIT_STATIC_SPEC ("version", &compiler_version
),
1563 INIT_STATIC_SPEC ("multilib", &multilib_select
),
1564 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults
),
1565 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra
),
1566 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches
),
1567 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions
),
1568 INIT_STATIC_SPEC ("multilib_options", &multilib_options
),
1569 INIT_STATIC_SPEC ("multilib_reuse", &multilib_reuse
),
1570 INIT_STATIC_SPEC ("linker", &linker_name_spec
),
1571 INIT_STATIC_SPEC ("linker_plugin_file", &linker_plugin_file_spec
),
1572 INIT_STATIC_SPEC ("lto_wrapper", <o_wrapper_spec
),
1573 INIT_STATIC_SPEC ("lto_gcc", <o_gcc_spec
),
1574 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec
),
1575 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix
),
1576 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix
),
1577 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1
),
1578 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec
),
1579 INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec
),
1580 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec
),
1581 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec
),
1582 INIT_STATIC_SPEC ("self_spec", &self_spec
),
1585 #ifdef EXTRA_SPECS /* additional specs needed */
1586 /* Structure to keep track of just the first two args of a spec_list.
1587 That is all that the EXTRA_SPECS macro gives us. */
1590 const char *const name
;
1591 const char *const ptr
;
1594 static const struct spec_list_1 extra_specs_1
[] = { EXTRA_SPECS
};
1595 static struct spec_list
*extra_specs
= (struct spec_list
*) 0;
1598 /* List of dynamically allocates specs that have been defined so far. */
1600 static struct spec_list
*specs
= (struct spec_list
*) 0;
1602 /* List of static spec functions. */
1604 static const struct spec_function static_spec_functions
[] =
1606 { "getenv", getenv_spec_function
},
1607 { "if-exists", if_exists_spec_function
},
1608 { "if-exists-else", if_exists_else_spec_function
},
1609 { "sanitize", sanitize_spec_function
},
1610 { "replace-outfile", replace_outfile_spec_function
},
1611 { "remove-outfile", remove_outfile_spec_function
},
1612 { "version-compare", version_compare_spec_function
},
1613 { "include", include_spec_function
},
1614 { "find-file", find_file_spec_function
},
1615 { "find-plugindir", find_plugindir_spec_function
},
1616 { "print-asm-header", print_asm_header_spec_function
},
1617 { "compare-debug-dump-opt", compare_debug_dump_opt_spec_function
},
1618 { "compare-debug-self-opt", compare_debug_self_opt_spec_function
},
1619 { "compare-debug-auxbase-opt", compare_debug_auxbase_opt_spec_function
},
1620 { "pass-through-libs", pass_through_libs_spec_func
},
1621 { "replace-extension", replace_extension_spec_func
},
1622 { "gt", greater_than_spec_func
},
1623 #ifdef EXTRA_SPEC_FUNCTIONS
1624 EXTRA_SPEC_FUNCTIONS
1629 static int processing_spec_function
;
1631 /* Add appropriate libgcc specs to OBSTACK, taking into account
1632 various permutations of -shared-libgcc, -shared, and such. */
1634 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1636 #ifndef USE_LD_AS_NEEDED
1637 #define USE_LD_AS_NEEDED 0
1641 init_gcc_specs (struct obstack
*obstack
, const char *shared_name
,
1642 const char *static_name
, const char *eh_name
)
1646 buf
= concat ("%{static|static-libgcc:", static_name
, " ", eh_name
, "}"
1647 "%{!static:%{!static-libgcc:"
1648 #if USE_LD_AS_NEEDED
1649 "%{!shared-libgcc:",
1650 static_name
, " " LD_AS_NEEDED_OPTION
" ",
1651 shared_name
, " " LD_NO_AS_NEEDED_OPTION
1654 shared_name
, "%{!shared: ", static_name
, "}"
1658 "%{!shared-libgcc:", static_name
, " ", eh_name
, "}"
1659 "%{shared-libgcc:", shared_name
, " ", static_name
, "}"
1663 "%{shared-libgcc:", shared_name
, "}"
1664 "%{!shared-libgcc:", static_name
, "}"
1667 "%{shared:", shared_name
, "}"
1672 obstack_grow (obstack
, buf
, strlen (buf
));
1675 #endif /* ENABLE_SHARED_LIBGCC */
1677 /* Initialize the specs lookup routines. */
1682 struct spec_list
*next
= (struct spec_list
*) 0;
1683 struct spec_list
*sl
= (struct spec_list
*) 0;
1687 return; /* Already initialized. */
1690 fnotice (stderr
, "Using built-in specs.\n");
1693 extra_specs
= XCNEWVEC (struct spec_list
, ARRAY_SIZE (extra_specs_1
));
1695 for (i
= ARRAY_SIZE (extra_specs_1
) - 1; i
>= 0; i
--)
1697 sl
= &extra_specs
[i
];
1698 sl
->name
= extra_specs_1
[i
].name
;
1699 sl
->ptr
= extra_specs_1
[i
].ptr
;
1701 sl
->name_len
= strlen (sl
->name
);
1702 sl
->ptr_spec
= &sl
->ptr
;
1703 gcc_assert (sl
->ptr_spec
!= NULL
);
1704 sl
->default_ptr
= sl
->ptr
;
1709 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1711 sl
= &static_specs
[i
];
1716 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1717 /* ??? If neither -shared-libgcc nor --static-libgcc was
1718 seen, then we should be making an educated guess. Some proposed
1719 heuristics for ELF include:
1721 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1722 program will be doing dynamic loading, which will likely
1723 need the shared libgcc.
1725 (2) If "-ldl", then it's also a fair bet that we're doing
1728 (3) For each ET_DYN we're linking against (either through -lfoo
1729 or /some/path/foo.so), check to see whether it or one of
1730 its dependencies depends on a shared libgcc.
1734 If the runtime is fixed to look for program headers instead
1735 of calling __register_frame_info at all, for each object,
1736 use the shared libgcc if any EH symbol referenced.
1738 If crtstuff is fixed to not invoke __register_frame_info
1739 automatically, for each object, use the shared libgcc if
1740 any non-empty unwind section found.
1742 Doing any of this probably requires invoking an external program to
1743 do the actual object file scanning. */
1745 const char *p
= libgcc_spec
;
1748 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1749 when given the proper command line arguments. */
1752 if (in_sep
&& *p
== '-' && strncmp (p
, "-lgcc", 5) == 0)
1754 init_gcc_specs (&obstack
,
1756 #ifdef USE_LIBUNWIND_EXCEPTIONS
1762 #ifdef USE_LIBUNWIND_EXCEPTIONS
1763 # ifdef HAVE_LD_STATIC_DYNAMIC
1764 " %{!static:" LD_STATIC_OPTION
"} -lunwind"
1765 " %{!static:" LD_DYNAMIC_OPTION
"}"
1775 else if (in_sep
&& *p
== 'l' && strncmp (p
, "libgcc.a%s", 10) == 0)
1777 /* Ug. We don't know shared library extensions. Hope that
1778 systems that use this form don't do shared libraries. */
1779 init_gcc_specs (&obstack
,
1783 #ifdef USE_LIBUNWIND_EXCEPTIONS
1792 obstack_1grow (&obstack
, *p
);
1793 in_sep
= (*p
== ' ');
1798 obstack_1grow (&obstack
, '\0');
1799 libgcc_spec
= XOBFINISH (&obstack
, const char *);
1802 #ifdef USE_AS_TRADITIONAL_FORMAT
1803 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1805 static const char tf
[] = "--traditional-format ";
1806 obstack_grow (&obstack
, tf
, sizeof (tf
) - 1);
1807 obstack_grow0 (&obstack
, asm_spec
, strlen (asm_spec
));
1808 asm_spec
= XOBFINISH (&obstack
, const char *);
1812 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC || \
1813 defined LINKER_HASH_STYLE
1814 # ifdef LINK_BUILDID_SPEC
1815 /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. */
1816 obstack_grow (&obstack
, LINK_BUILDID_SPEC
, sizeof (LINK_BUILDID_SPEC
) - 1);
1818 # ifdef LINK_EH_SPEC
1819 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1820 obstack_grow (&obstack
, LINK_EH_SPEC
, sizeof (LINK_EH_SPEC
) - 1);
1822 # ifdef LINKER_HASH_STYLE
1823 /* Prepend --hash-style=LINKER_HASH_STYLE to whatever link_spec we had
1826 static const char hash_style
[] = "--hash-style=";
1827 obstack_grow (&obstack
, hash_style
, sizeof (hash_style
) - 1);
1828 obstack_grow (&obstack
, LINKER_HASH_STYLE
, sizeof (LINKER_HASH_STYLE
) - 1);
1829 obstack_1grow (&obstack
, ' ');
1832 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
1833 link_spec
= XOBFINISH (&obstack
, const char *);
1839 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1840 removed; If the spec starts with a + then SPEC is added to the end of the
1844 set_spec (const char *name
, const char *spec
, bool user_p
)
1846 struct spec_list
*sl
;
1847 const char *old_spec
;
1848 int name_len
= strlen (name
);
1851 /* If this is the first call, initialize the statically allocated specs. */
1854 struct spec_list
*next
= (struct spec_list
*) 0;
1855 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1857 sl
= &static_specs
[i
];
1864 /* See if the spec already exists. */
1865 for (sl
= specs
; sl
; sl
= sl
->next
)
1866 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, name
))
1871 /* Not found - make it. */
1872 sl
= XNEW (struct spec_list
);
1873 sl
->name
= xstrdup (name
);
1874 sl
->name_len
= name_len
;
1875 sl
->ptr_spec
= &sl
->ptr
;
1877 *(sl
->ptr_spec
) = "";
1879 sl
->default_ptr
= NULL
;
1883 old_spec
= *(sl
->ptr_spec
);
1884 *(sl
->ptr_spec
) = ((spec
[0] == '+' && ISSPACE ((unsigned char)spec
[1]))
1885 ? concat (old_spec
, spec
+ 1, NULL
)
1890 fnotice (stderr
, "Setting spec %s to '%s'\n\n", name
, *(sl
->ptr_spec
));
1893 /* Free the old spec. */
1894 if (old_spec
&& sl
->alloc_p
)
1895 free (CONST_CAST (char *, old_spec
));
1897 sl
->user_p
= user_p
;
1901 /* Accumulate a command (program name and args), and run it. */
1903 typedef const char *const_char_p
; /* For DEF_VEC_P. */
1905 /* Vector of pointers to arguments in the current line of specifications. */
1907 static vec
<const_char_p
> argbuf
;
1909 /* Were the options -c, -S or -E passed. */
1910 static int have_c
= 0;
1912 /* Was the option -o passed. */
1913 static int have_o
= 0;
1915 /* Pointer to output file name passed in with -o. */
1916 static const char *output_file
= 0;
1918 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1919 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
1922 static struct temp_name
{
1923 const char *suffix
; /* suffix associated with the code. */
1924 int length
; /* strlen (suffix). */
1925 int unique
; /* Indicates whether %g or %u/%U was used. */
1926 const char *filename
; /* associated filename. */
1927 int filename_length
; /* strlen (filename). */
1928 struct temp_name
*next
;
1931 /* Number of commands executed so far. */
1933 static int execution_count
;
1935 /* Number of commands that exited with a signal. */
1937 static int signal_count
;
1939 /* Allocate the argument vector. */
1947 /* Clear out the vector of arguments (after a command is executed). */
1952 argbuf
.truncate (0);
1955 /* Add one argument to the vector at the end.
1956 This is done when a space is seen or at the end of the line.
1957 If DELETE_ALWAYS is nonzero, the arg is a filename
1958 and the file should be deleted eventually.
1959 If DELETE_FAILURE is nonzero, the arg is a filename
1960 and the file should be deleted if this compilation fails. */
1963 store_arg (const char *arg
, int delete_always
, int delete_failure
)
1965 argbuf
.safe_push (arg
);
1967 if (delete_always
|| delete_failure
)
1970 /* If the temporary file we should delete is specified as
1971 part of a joined argument extract the filename. */
1973 && (p
= strrchr (arg
, '=')))
1975 record_temp_file (arg
, delete_always
, delete_failure
);
1979 /* Load specs from a file name named FILENAME, replacing occurrences of
1980 various different types of line-endings, \r\n, \n\r and just \r, with
1984 load_specs (const char *filename
)
1988 struct stat statbuf
;
1995 fnotice (stderr
, "Reading specs from %s\n", filename
);
1997 /* Open and stat the file. */
1998 desc
= open (filename
, O_RDONLY
, 0);
2000 pfatal_with_name (filename
);
2001 if (stat (filename
, &statbuf
) < 0)
2002 pfatal_with_name (filename
);
2004 /* Read contents of file into BUFFER. */
2005 buffer
= XNEWVEC (char, statbuf
.st_size
+ 1);
2006 readlen
= read (desc
, buffer
, (unsigned) statbuf
.st_size
);
2008 pfatal_with_name (filename
);
2009 buffer
[readlen
] = 0;
2012 specs
= XNEWVEC (char, readlen
+ 1);
2014 for (buffer_p
= buffer
; buffer_p
&& *buffer_p
; buffer_p
++)
2020 if (buffer_p
> buffer
&& *(buffer_p
- 1) == '\n') /* \n\r */
2022 else if (*(buffer_p
+ 1) == '\n') /* \r\n */
2036 /* Read compilation specs from a file named FILENAME,
2037 replacing the default ones.
2039 A suffix which starts with `*' is a definition for
2040 one of the machine-specific sub-specs. The "suffix" should be
2041 *asm, *cc1, *cpp, *link, *startfile, etc.
2042 The corresponding spec is stored in asm_spec, etc.,
2043 rather than in the `compilers' vector.
2045 Anything invalid in the file is a fatal error. */
2048 read_specs (const char *filename
, bool main_p
, bool user_p
)
2053 buffer
= load_specs (filename
);
2055 /* Scan BUFFER for specs, putting them in the vector. */
2061 char *in
, *out
, *p1
, *p2
, *p3
;
2063 /* Advance P in BUFFER to the next nonblank nocomment line. */
2064 p
= skip_whitespace (p
);
2068 /* Is this a special command that starts with '%'? */
2069 /* Don't allow this for the main specs file, since it would
2070 encourage people to overwrite it. */
2071 if (*p
== '%' && !main_p
)
2074 while (*p
&& *p
!= '\n')
2080 if (!strncmp (p1
, "%include", sizeof ("%include") - 1)
2081 && (p1
[sizeof "%include" - 1] == ' '
2082 || p1
[sizeof "%include" - 1] == '\t'))
2086 p1
+= sizeof ("%include");
2087 while (*p1
== ' ' || *p1
== '\t')
2090 if (*p1
++ != '<' || p
[-2] != '>')
2091 fatal_error (input_location
,
2092 "specs %%include syntax malformed after "
2094 (long) (p1
- buffer
+ 1));
2097 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
2098 read_specs (new_filename
? new_filename
: p1
, false, user_p
);
2101 else if (!strncmp (p1
, "%include_noerr", sizeof "%include_noerr" - 1)
2102 && (p1
[sizeof "%include_noerr" - 1] == ' '
2103 || p1
[sizeof "%include_noerr" - 1] == '\t'))
2107 p1
+= sizeof "%include_noerr";
2108 while (*p1
== ' ' || *p1
== '\t')
2111 if (*p1
++ != '<' || p
[-2] != '>')
2112 fatal_error (input_location
,
2113 "specs %%include syntax malformed after "
2115 (long) (p1
- buffer
+ 1));
2118 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
2120 read_specs (new_filename
, false, user_p
);
2121 else if (verbose_flag
)
2122 fnotice (stderr
, "could not find specs file %s\n", p1
);
2125 else if (!strncmp (p1
, "%rename", sizeof "%rename" - 1)
2126 && (p1
[sizeof "%rename" - 1] == ' '
2127 || p1
[sizeof "%rename" - 1] == '\t'))
2130 struct spec_list
*sl
;
2131 struct spec_list
*newsl
;
2133 /* Get original name. */
2134 p1
+= sizeof "%rename";
2135 while (*p1
== ' ' || *p1
== '\t')
2138 if (! ISALPHA ((unsigned char) *p1
))
2139 fatal_error (input_location
,
2140 "specs %%rename syntax malformed after "
2142 (long) (p1
- buffer
));
2145 while (*p2
&& !ISSPACE ((unsigned char) *p2
))
2148 if (*p2
!= ' ' && *p2
!= '\t')
2149 fatal_error (input_location
,
2150 "specs %%rename syntax malformed after "
2152 (long) (p2
- buffer
));
2156 while (*p2
== ' ' || *p2
== '\t')
2159 if (! ISALPHA ((unsigned char) *p2
))
2160 fatal_error (input_location
,
2161 "specs %%rename syntax malformed after "
2163 (long) (p2
- buffer
));
2165 /* Get new spec name. */
2167 while (*p3
&& !ISSPACE ((unsigned char) *p3
))
2171 fatal_error (input_location
,
2172 "specs %%rename syntax malformed after "
2174 (long) (p3
- buffer
));
2177 for (sl
= specs
; sl
; sl
= sl
->next
)
2178 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, p1
))
2182 fatal_error (input_location
,
2183 "specs %s spec was not found to be renamed", p1
);
2185 if (strcmp (p1
, p2
) == 0)
2188 for (newsl
= specs
; newsl
; newsl
= newsl
->next
)
2189 if (strcmp (newsl
->name
, p2
) == 0)
2190 fatal_error (input_location
,
2191 "%s: attempt to rename spec %qs to "
2192 "already defined spec %qs",
2197 fnotice (stderr
, "rename spec %s to %s\n", p1
, p2
);
2199 fnotice (stderr
, "spec is '%s'\n\n", *(sl
->ptr_spec
));
2203 set_spec (p2
, *(sl
->ptr_spec
), user_p
);
2205 free (CONST_CAST (char *, *(sl
->ptr_spec
)));
2207 *(sl
->ptr_spec
) = "";
2212 fatal_error (input_location
,
2213 "specs unknown %% command after %ld characters",
2214 (long) (p1
- buffer
));
2217 /* Find the colon that should end the suffix. */
2219 while (*p1
&& *p1
!= ':' && *p1
!= '\n')
2222 /* The colon shouldn't be missing. */
2224 fatal_error (input_location
,
2225 "specs file malformed after %ld characters",
2226 (long) (p1
- buffer
));
2228 /* Skip back over trailing whitespace. */
2230 while (p2
> buffer
&& (p2
[-1] == ' ' || p2
[-1] == '\t'))
2233 /* Copy the suffix to a string. */
2234 suffix
= save_string (p
, p2
- p
);
2235 /* Find the next line. */
2236 p
= skip_whitespace (p1
+ 1);
2238 fatal_error (input_location
,
2239 "specs file malformed after %ld characters",
2240 (long) (p
- buffer
));
2243 /* Find next blank line or end of string. */
2244 while (*p1
&& !(*p1
== '\n' && (p1
[1] == '\n' || p1
[1] == '\0')))
2247 /* Specs end at the blank line and do not include the newline. */
2248 spec
= save_string (p
, p1
- p
);
2251 /* Delete backslash-newline sequences from the spec. */
2256 if (in
[0] == '\\' && in
[1] == '\n')
2258 else if (in
[0] == '#')
2259 while (*in
&& *in
!= '\n')
2267 if (suffix
[0] == '*')
2269 if (! strcmp (suffix
, "*link_command"))
2270 link_command_spec
= spec
;
2273 set_spec (suffix
+ 1, spec
, user_p
);
2279 /* Add this pair to the vector. */
2281 = XRESIZEVEC (struct compiler
, compilers
, n_compilers
+ 2);
2283 compilers
[n_compilers
].suffix
= suffix
;
2284 compilers
[n_compilers
].spec
= spec
;
2286 memset (&compilers
[n_compilers
], 0, sizeof compilers
[n_compilers
]);
2290 link_command_spec
= spec
;
2293 if (link_command_spec
== 0)
2294 fatal_error (input_location
, "spec file has no spec for linking");
2296 XDELETEVEC (buffer
);
2299 /* Record the names of temporary files we tell compilers to write,
2300 and delete them at the end of the run. */
2302 /* This is the common prefix we use to make temp file names.
2303 It is chosen once for each run of this program.
2304 It is substituted into a spec by %g or %j.
2305 Thus, all temp file names contain this prefix.
2306 In practice, all temp file names start with this prefix.
2308 This prefix comes from the envvar TMPDIR if it is defined;
2309 otherwise, from the P_tmpdir macro if that is defined;
2310 otherwise, in /usr/tmp or /tmp;
2311 or finally the current directory if all else fails. */
2313 static const char *temp_filename
;
2315 /* Length of the prefix. */
2317 static int temp_filename_length
;
2319 /* Define the list of temporary files to delete. */
2324 struct temp_file
*next
;
2327 /* Queue of files to delete on success or failure of compilation. */
2328 static struct temp_file
*always_delete_queue
;
2329 /* Queue of files to delete on failure of compilation. */
2330 static struct temp_file
*failure_delete_queue
;
2332 /* Record FILENAME as a file to be deleted automatically.
2333 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2334 otherwise delete it in any case.
2335 FAIL_DELETE nonzero means delete it if a compilation step fails;
2336 otherwise delete it in any case. */
2339 record_temp_file (const char *filename
, int always_delete
, int fail_delete
)
2341 char *const name
= xstrdup (filename
);
2345 struct temp_file
*temp
;
2346 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2347 if (! filename_cmp (name
, temp
->name
))
2353 temp
= XNEW (struct temp_file
);
2354 temp
->next
= always_delete_queue
;
2356 always_delete_queue
= temp
;
2363 struct temp_file
*temp
;
2364 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2365 if (! filename_cmp (name
, temp
->name
))
2371 temp
= XNEW (struct temp_file
);
2372 temp
->next
= failure_delete_queue
;
2374 failure_delete_queue
= temp
;
2380 /* Delete all the temporary files whose names we previously recorded. */
2382 #ifndef DELETE_IF_ORDINARY
2383 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2386 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2387 if (unlink (NAME) < 0) \
2389 perror_with_name (NAME); \
2394 delete_if_ordinary (const char *name
)
2400 printf ("Delete %s? (y or n) ", name
);
2404 while ((c
= getchar ()) != '\n' && c
!= EOF
)
2407 if (i
== 'y' || i
== 'Y')
2409 DELETE_IF_ORDINARY (name
, st
, verbose_flag
);
2413 delete_temp_files (void)
2415 struct temp_file
*temp
;
2417 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2418 delete_if_ordinary (temp
->name
);
2419 always_delete_queue
= 0;
2422 /* Delete all the files to be deleted on error. */
2425 delete_failure_queue (void)
2427 struct temp_file
*temp
;
2429 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2430 delete_if_ordinary (temp
->name
);
2434 clear_failure_queue (void)
2436 failure_delete_queue
= 0;
2439 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2441 If DO_MULTI is true iterate over the paths twice, first with multilib
2442 suffix then without, otherwise iterate over the paths once without
2443 adding a multilib suffix. When DO_MULTI is true, some attempt is made
2444 to avoid visiting the same path twice, but we could do better. For
2445 instance, /usr/lib/../lib is considered different from /usr/lib.
2446 At least EXTRA_SPACE chars past the end of the path passed to
2447 CALLBACK are available for use by the callback.
2448 CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2450 Returns the value returned by CALLBACK. */
2453 for_each_path (const struct path_prefix
*paths
,
2456 void *(*callback
) (char *, void *),
2457 void *callback_info
)
2459 struct prefix_list
*pl
;
2460 const char *multi_dir
= NULL
;
2461 const char *multi_os_dir
= NULL
;
2462 const char *multiarch_suffix
= NULL
;
2463 const char *multi_suffix
;
2464 const char *just_multi_suffix
;
2467 bool skip_multi_dir
= false;
2468 bool skip_multi_os_dir
= false;
2470 multi_suffix
= machine_suffix
;
2471 just_multi_suffix
= just_machine_suffix
;
2472 if (do_multi
&& multilib_dir
&& strcmp (multilib_dir
, ".") != 0)
2474 multi_dir
= concat (multilib_dir
, dir_separator_str
, NULL
);
2475 multi_suffix
= concat (multi_suffix
, multi_dir
, NULL
);
2476 just_multi_suffix
= concat (just_multi_suffix
, multi_dir
, NULL
);
2478 if (do_multi
&& multilib_os_dir
&& strcmp (multilib_os_dir
, ".") != 0)
2479 multi_os_dir
= concat (multilib_os_dir
, dir_separator_str
, NULL
);
2481 multiarch_suffix
= concat (multiarch_dir
, dir_separator_str
, NULL
);
2485 size_t multi_dir_len
= 0;
2486 size_t multi_os_dir_len
= 0;
2487 size_t multiarch_len
= 0;
2489 size_t just_suffix_len
;
2493 multi_dir_len
= strlen (multi_dir
);
2495 multi_os_dir_len
= strlen (multi_os_dir
);
2496 if (multiarch_suffix
)
2497 multiarch_len
= strlen (multiarch_suffix
);
2498 suffix_len
= strlen (multi_suffix
);
2499 just_suffix_len
= strlen (just_multi_suffix
);
2503 len
= paths
->max_len
+ extra_space
+ 1;
2504 len
+= MAX (MAX (suffix_len
, multi_os_dir_len
), multiarch_len
);
2505 path
= XNEWVEC (char, len
);
2508 for (pl
= paths
->plist
; pl
!= 0; pl
= pl
->next
)
2510 len
= strlen (pl
->prefix
);
2511 memcpy (path
, pl
->prefix
, len
);
2513 /* Look first in MACHINE/VERSION subdirectory. */
2514 if (!skip_multi_dir
)
2516 memcpy (path
+ len
, multi_suffix
, suffix_len
+ 1);
2517 ret
= callback (path
, callback_info
);
2522 /* Some paths are tried with just the machine (ie. target)
2523 subdir. This is used for finding as, ld, etc. */
2525 && pl
->require_machine_suffix
== 2)
2527 memcpy (path
+ len
, just_multi_suffix
, just_suffix_len
+ 1);
2528 ret
= callback (path
, callback_info
);
2533 /* Now try the multiarch path. */
2535 && !pl
->require_machine_suffix
&& multiarch_dir
)
2537 memcpy (path
+ len
, multiarch_suffix
, multiarch_len
+ 1);
2538 ret
= callback (path
, callback_info
);
2543 /* Now try the base path. */
2544 if (!pl
->require_machine_suffix
2545 && !(pl
->os_multilib
? skip_multi_os_dir
: skip_multi_dir
))
2547 const char *this_multi
;
2548 size_t this_multi_len
;
2550 if (pl
->os_multilib
)
2552 this_multi
= multi_os_dir
;
2553 this_multi_len
= multi_os_dir_len
;
2557 this_multi
= multi_dir
;
2558 this_multi_len
= multi_dir_len
;
2562 memcpy (path
+ len
, this_multi
, this_multi_len
+ 1);
2566 ret
= callback (path
, callback_info
);
2574 if (multi_dir
== NULL
&& multi_os_dir
== NULL
)
2577 /* Run through the paths again, this time without multilibs.
2578 Don't repeat any we have already seen. */
2581 free (CONST_CAST (char *, multi_dir
));
2583 free (CONST_CAST (char *, multi_suffix
));
2584 multi_suffix
= machine_suffix
;
2585 free (CONST_CAST (char *, just_multi_suffix
));
2586 just_multi_suffix
= just_machine_suffix
;
2589 skip_multi_dir
= true;
2592 free (CONST_CAST (char *, multi_os_dir
));
2593 multi_os_dir
= NULL
;
2596 skip_multi_os_dir
= true;
2601 free (CONST_CAST (char *, multi_dir
));
2602 free (CONST_CAST (char *, multi_suffix
));
2603 free (CONST_CAST (char *, just_multi_suffix
));
2606 free (CONST_CAST (char *, multi_os_dir
));
2612 /* Callback for build_search_list. Adds path to obstack being built. */
2614 struct add_to_obstack_info
{
2621 add_to_obstack (char *path
, void *data
)
2623 struct add_to_obstack_info
*info
= (struct add_to_obstack_info
*) data
;
2625 if (info
->check_dir
&& !is_directory (path
, false))
2628 if (!info
->first_time
)
2629 obstack_1grow (info
->ob
, PATH_SEPARATOR
);
2631 obstack_grow (info
->ob
, path
, strlen (path
));
2633 info
->first_time
= false;
2637 /* Add or change the value of an environment variable, outputting the
2638 change to standard error if in verbose mode. */
2640 xputenv (const char *string
)
2645 /* Build a list of search directories from PATHS.
2646 PREFIX is a string to prepend to the list.
2647 If CHECK_DIR_P is true we ensure the directory exists.
2648 If DO_MULTI is true, multilib paths are output first, then
2650 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2651 It is also used by the --print-search-dirs flag. */
2654 build_search_list (const struct path_prefix
*paths
, const char *prefix
,
2655 bool check_dir
, bool do_multi
)
2657 struct add_to_obstack_info info
;
2659 info
.ob
= &collect_obstack
;
2660 info
.check_dir
= check_dir
;
2661 info
.first_time
= true;
2663 obstack_grow (&collect_obstack
, prefix
, strlen (prefix
));
2664 obstack_1grow (&collect_obstack
, '=');
2666 for_each_path (paths
, do_multi
, 0, add_to_obstack
, &info
);
2668 obstack_1grow (&collect_obstack
, '\0');
2669 return XOBFINISH (&collect_obstack
, char *);
2672 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2676 putenv_from_prefixes (const struct path_prefix
*paths
, const char *env_var
,
2679 xputenv (build_search_list (paths
, env_var
, true, do_multi
));
2682 /* Check whether NAME can be accessed in MODE. This is like access,
2683 except that it never considers directories to be executable. */
2686 access_check (const char *name
, int mode
)
2692 if (stat (name
, &st
) < 0
2693 || S_ISDIR (st
.st_mode
))
2697 return access (name
, mode
);
2700 /* Callback for find_a_file. Appends the file name to the directory
2701 path. If the resulting file exists in the right mode, return the
2702 full pathname to the file. */
2704 struct file_at_path_info
{
2713 file_at_path (char *path
, void *data
)
2715 struct file_at_path_info
*info
= (struct file_at_path_info
*) data
;
2716 size_t len
= strlen (path
);
2718 memcpy (path
+ len
, info
->name
, info
->name_len
);
2719 len
+= info
->name_len
;
2721 /* Some systems have a suffix for executable files.
2722 So try appending that first. */
2723 if (info
->suffix_len
)
2725 memcpy (path
+ len
, info
->suffix
, info
->suffix_len
+ 1);
2726 if (access_check (path
, info
->mode
) == 0)
2731 if (access_check (path
, info
->mode
) == 0)
2737 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2738 access to check permissions. If DO_MULTI is true, search multilib
2739 paths then non-multilib paths, otherwise do not search multilib paths.
2740 Return 0 if not found, otherwise return its name, allocated with malloc. */
2743 find_a_file (const struct path_prefix
*pprefix
, const char *name
, int mode
,
2746 struct file_at_path_info info
;
2748 #ifdef DEFAULT_ASSEMBLER
2749 if (! strcmp (name
, "as") && access (DEFAULT_ASSEMBLER
, mode
) == 0)
2750 return xstrdup (DEFAULT_ASSEMBLER
);
2753 #ifdef DEFAULT_LINKER
2754 if (! strcmp (name
, "ld") && access (DEFAULT_LINKER
, mode
) == 0)
2755 return xstrdup (DEFAULT_LINKER
);
2758 /* Determine the filename to execute (special case for absolute paths). */
2760 if (IS_ABSOLUTE_PATH (name
))
2762 if (access (name
, mode
) == 0)
2763 return xstrdup (name
);
2769 info
.suffix
= (mode
& X_OK
) != 0 ? HOST_EXECUTABLE_SUFFIX
: "";
2770 info
.name_len
= strlen (info
.name
);
2771 info
.suffix_len
= strlen (info
.suffix
);
2774 return (char*) for_each_path (pprefix
, do_multi
,
2775 info
.name_len
+ info
.suffix_len
,
2776 file_at_path
, &info
);
2779 /* Ranking of prefixes in the sort list. -B prefixes are put before
2782 enum path_prefix_priority
2784 PREFIX_PRIORITY_B_OPT
,
2785 PREFIX_PRIORITY_LAST
2788 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
2789 order according to PRIORITY. Within each PRIORITY, new entries are
2792 If WARN is nonzero, we will warn if no file is found
2793 through this prefix. WARN should point to an int
2794 which will be set to 1 if this entry is used.
2796 COMPONENT is the value to be passed to update_path.
2798 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2799 the complete value of machine_suffix.
2800 2 means try both machine_suffix and just_machine_suffix. */
2803 add_prefix (struct path_prefix
*pprefix
, const char *prefix
,
2804 const char *component
, /* enum prefix_priority */ int priority
,
2805 int require_machine_suffix
, int os_multilib
)
2807 struct prefix_list
*pl
, **prev
;
2810 for (prev
= &pprefix
->plist
;
2811 (*prev
) != NULL
&& (*prev
)->priority
<= priority
;
2812 prev
= &(*prev
)->next
)
2815 /* Keep track of the longest prefix. */
2817 prefix
= update_path (prefix
, component
);
2818 len
= strlen (prefix
);
2819 if (len
> pprefix
->max_len
)
2820 pprefix
->max_len
= len
;
2822 pl
= XNEW (struct prefix_list
);
2823 pl
->prefix
= prefix
;
2824 pl
->require_machine_suffix
= require_machine_suffix
;
2825 pl
->priority
= priority
;
2826 pl
->os_multilib
= os_multilib
;
2828 /* Insert after PREV. */
2833 /* Same as add_prefix, but prepending target_system_root to prefix. */
2834 /* The target_system_root prefix has been relocated by gcc_exec_prefix. */
2836 add_sysrooted_prefix (struct path_prefix
*pprefix
, const char *prefix
,
2837 const char *component
,
2838 /* enum prefix_priority */ int priority
,
2839 int require_machine_suffix
, int os_multilib
)
2841 if (!IS_ABSOLUTE_PATH (prefix
))
2842 fatal_error (input_location
, "system path %qs is not absolute", prefix
);
2844 if (target_system_root
)
2846 char *sysroot_no_trailing_dir_separator
= xstrdup (target_system_root
);
2847 size_t sysroot_len
= strlen (target_system_root
);
2850 && target_system_root
[sysroot_len
- 1] == DIR_SEPARATOR
)
2851 sysroot_no_trailing_dir_separator
[sysroot_len
- 1] = '\0';
2853 if (target_sysroot_suffix
)
2854 prefix
= concat (sysroot_no_trailing_dir_separator
,
2855 target_sysroot_suffix
, prefix
, NULL
);
2857 prefix
= concat (sysroot_no_trailing_dir_separator
, prefix
, NULL
);
2859 free (sysroot_no_trailing_dir_separator
);
2861 /* We have to override this because GCC's notion of sysroot
2862 moves along with GCC. */
2866 add_prefix (pprefix
, prefix
, component
, priority
,
2867 require_machine_suffix
, os_multilib
);
2870 /* Execute the command specified by the arguments on the current line of spec.
2871 When using pipes, this includes several piped-together commands
2872 with `|' between them.
2874 Return 0 if successful, -1 if failed. */
2880 int n_commands
; /* # of command. */
2882 struct pex_obj
*pex
;
2885 const char *prog
; /* program name. */
2886 const char **argv
; /* vector of args. */
2890 struct command
*commands
; /* each command buffer with above info. */
2892 gcc_assert (!processing_spec_function
);
2896 string
= find_a_file (&exec_prefixes
,
2897 argbuf
[0], X_OK
, false);
2900 insert_wrapper (wrapper_string
);
2903 /* Count # of piped commands. */
2904 for (n_commands
= 1, i
= 0; argbuf
.iterate (i
, &arg
); i
++)
2905 if (strcmp (arg
, "|") == 0)
2908 /* Get storage for each command. */
2909 commands
= (struct command
*) alloca (n_commands
* sizeof (struct command
));
2911 /* Split argbuf into its separate piped processes,
2912 and record info about each one.
2913 Also search for the programs that are to be run. */
2915 argbuf
.safe_push (0);
2917 commands
[0].prog
= argbuf
[0]; /* first command. */
2918 commands
[0].argv
= argbuf
.address ();
2920 if (!wrapper_string
)
2922 string
= find_a_file (&exec_prefixes
, commands
[0].prog
, X_OK
, false);
2923 commands
[0].argv
[0] = (string
) ? string
: commands
[0].argv
[0];
2926 for (n_commands
= 1, i
= 0; argbuf
.iterate (i
, &arg
); i
++)
2927 if (arg
&& strcmp (arg
, "|") == 0)
2928 { /* each command. */
2929 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2930 fatal_error (input_location
, "-pipe not supported");
2932 argbuf
[i
] = 0; /* Termination of
2934 commands
[n_commands
].prog
= argbuf
[i
+ 1];
2935 commands
[n_commands
].argv
2936 = &(argbuf
.address ())[i
+ 1];
2937 string
= find_a_file (&exec_prefixes
, commands
[n_commands
].prog
,
2940 commands
[n_commands
].argv
[0] = string
;
2944 /* If -v, print what we are about to do, and maybe query. */
2948 /* For help listings, put a blank line between sub-processes. */
2949 if (print_help_list
)
2950 fputc ('\n', stderr
);
2952 /* Print each piped command as a separate line. */
2953 for (i
= 0; i
< n_commands
; i
++)
2955 const char *const *j
;
2957 if (verbose_only_flag
)
2959 for (j
= commands
[i
].argv
; *j
; j
++)
2962 for (p
= *j
; *p
; ++p
)
2963 if (!ISALNUM ((unsigned char) *p
)
2964 && *p
!= '_' && *p
!= '/' && *p
!= '-' && *p
!= '.')
2968 fprintf (stderr
, " \"");
2969 for (p
= *j
; *p
; ++p
)
2971 if (*p
== '"' || *p
== '\\' || *p
== '$')
2972 fputc ('\\', stderr
);
2975 fputc ('"', stderr
);
2977 /* If it's empty, print "". */
2979 fprintf (stderr
, " \"\"");
2981 fprintf (stderr
, " %s", *j
);
2985 for (j
= commands
[i
].argv
; *j
; j
++)
2986 /* If it's empty, print "". */
2988 fprintf (stderr
, " \"\"");
2990 fprintf (stderr
, " %s", *j
);
2992 /* Print a pipe symbol after all but the last command. */
2993 if (i
+ 1 != n_commands
)
2994 fprintf (stderr
, " |");
2995 fprintf (stderr
, "\n");
2998 if (verbose_only_flag
!= 0)
3000 /* verbose_only_flag should act as if the spec was
3001 executed, so increment execution_count before
3002 returning. This prevents spurious warnings about
3003 unused linker input files, etc. */
3008 fnotice (stderr
, "\nGo ahead? (y or n) ");
3012 while (getchar () != '\n')
3015 if (i
!= 'y' && i
!= 'Y')
3020 #ifdef ENABLE_VALGRIND_CHECKING
3021 /* Run the each command through valgrind. To simplify prepending the
3022 path to valgrind and the option "-q" (for quiet operation unless
3023 something triggers), we allocate a separate argv array. */
3025 for (i
= 0; i
< n_commands
; i
++)
3031 for (argc
= 0; commands
[i
].argv
[argc
] != NULL
; argc
++)
3034 argv
= XALLOCAVEC (const char *, argc
+ 3);
3036 argv
[0] = VALGRIND_PATH
;
3038 for (j
= 2; j
< argc
+ 2; j
++)
3039 argv
[j
] = commands
[i
].argv
[j
- 2];
3042 commands
[i
].argv
= argv
;
3043 commands
[i
].prog
= argv
[0];
3047 /* Run each piped subprocess. */
3049 pex
= pex_init (PEX_USE_PIPES
| ((report_times
|| report_times_to_file
)
3050 ? PEX_RECORD_TIMES
: 0),
3051 progname
, temp_filename
);
3053 fatal_error (input_location
, "pex_init failed: %m");
3055 for (i
= 0; i
< n_commands
; i
++)
3059 const char *string
= commands
[i
].argv
[0];
3061 errmsg
= pex_run (pex
,
3062 ((i
+ 1 == n_commands
? PEX_LAST
: 0)
3063 | (string
== commands
[i
].prog
? PEX_SEARCH
: 0)),
3064 string
, CONST_CAST (char **, commands
[i
].argv
),
3069 fatal_error (input_location
, errmsg
);
3073 pfatal_with_name (errmsg
);
3077 if (i
&& string
!= commands
[i
].prog
)
3078 free (CONST_CAST (char *, string
));
3083 /* Wait for all the subprocesses to finish. */
3087 struct pex_time
*times
= NULL
;
3090 statuses
= (int *) alloca (n_commands
* sizeof (int));
3091 if (!pex_get_status (pex
, n_commands
, statuses
))
3092 fatal_error (input_location
, "failed to get exit status: %m");
3094 if (report_times
|| report_times_to_file
)
3096 times
= (struct pex_time
*) alloca (n_commands
* sizeof (struct pex_time
));
3097 if (!pex_get_times (pex
, n_commands
, times
))
3098 fatal_error (input_location
, "failed to get process times: %m");
3103 for (i
= 0; i
< n_commands
; ++i
)
3105 int status
= statuses
[i
];
3107 if (WIFSIGNALED (status
))
3110 /* SIGPIPE is a special case. It happens in -pipe mode
3111 when the compiler dies before the preprocessor is done,
3112 or the assembler dies before the compiler is done.
3113 There's generally been an error already, and this is
3114 just fallout. So don't generate another error unless
3115 we would otherwise have succeeded. */
3116 if (WTERMSIG (status
) == SIGPIPE
3117 && (signal_count
|| greatest_status
>= MIN_FATAL_STATUS
))
3124 internal_error_no_backtrace ("%s (program %s)",
3125 strsignal (WTERMSIG (status
)),
3128 else if (WIFEXITED (status
)
3129 && WEXITSTATUS (status
) >= MIN_FATAL_STATUS
)
3131 /* For ICEs in cc1, cc1obj, cc1plus see if it is
3132 reproducible or not. */
3135 && WEXITSTATUS (status
) == ICE_EXIT_CODE
3137 && (p
= strrchr (commands
[0].argv
[0], DIR_SEPARATOR
))
3138 && ! strncmp (p
+ 1, "cc1", 3))
3139 try_generate_repro (commands
[0].argv
);
3140 if (WEXITSTATUS (status
) > greatest_status
)
3141 greatest_status
= WEXITSTATUS (status
);
3145 if (report_times
|| report_times_to_file
)
3147 struct pex_time
*pt
= ×
[i
];
3150 ut
= ((double) pt
->user_seconds
3151 + (double) pt
->user_microseconds
/ 1.0e6
);
3152 st
= ((double) pt
->system_seconds
3153 + (double) pt
->system_microseconds
/ 1.0e6
);
3158 fnotice (stderr
, "# %s %.2f %.2f\n",
3159 commands
[i
].prog
, ut
, st
);
3161 if (report_times_to_file
)
3164 const char *const *j
;
3166 fprintf (report_times_to_file
, "%g %g", ut
, st
);
3168 for (j
= &commands
[i
].prog
; *j
; j
= &commands
[i
].argv
[++c
])
3171 for (p
= *j
; *p
; ++p
)
3172 if (*p
== '"' || *p
== '\\' || *p
== '$'
3178 fprintf (report_times_to_file
, " \"");
3179 for (p
= *j
; *p
; ++p
)
3181 if (*p
== '"' || *p
== '\\' || *p
== '$')
3182 fputc ('\\', report_times_to_file
);
3183 fputc (*p
, report_times_to_file
);
3185 fputc ('"', report_times_to_file
);
3188 fprintf (report_times_to_file
, " %s", *j
);
3191 fputc ('\n', report_times_to_file
);
3197 if (commands
[0].argv
[0] != commands
[0].prog
)
3198 free (CONST_CAST (char *, commands
[0].argv
[0]));
3204 /* Find all the switches given to us
3205 and make a vector describing them.
3206 The elements of the vector are strings, one per switch given.
3207 If a switch uses following arguments, then the `part1' field
3208 is the switch itself and the `args' field
3209 is a null-terminated vector containing the following arguments.
3210 Bits in the `live_cond' field are:
3211 SWITCH_LIVE to indicate this switch is true in a conditional spec.
3212 SWITCH_FALSE to indicate this switch is overridden by a later switch.
3213 SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
3214 SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored.
3215 SWITCH_KEEP_FOR_GCC to indicate that this switch, otherwise ignored,
3216 should be included in COLLECT_GCC_OPTIONS.
3217 in all do_spec calls afterwards. Used for %<S from self specs.
3218 The `known' field describes whether this is an internal switch.
3219 The `validated' field describes whether any spec has looked at this switch;
3220 if it remains false at the end of the run, the switch must be meaningless.
3221 The `ordering' field is used to temporarily mark switches that have to be
3222 kept in a specific order. */
3224 #define SWITCH_LIVE (1 << 0)
3225 #define SWITCH_FALSE (1 << 1)
3226 #define SWITCH_IGNORE (1 << 2)
3227 #define SWITCH_IGNORE_PERMANENTLY (1 << 3)
3228 #define SWITCH_KEEP_FOR_GCC (1 << 4)
3234 unsigned int live_cond
;
3240 static struct switchstr
*switches
;
3242 static int n_switches
;
3244 static int n_switches_alloc
;
3246 /* Set to zero if -fcompare-debug is disabled, positive if it's
3247 enabled and we're running the first compilation, negative if it's
3248 enabled and we're running the second compilation. For most of the
3249 time, it's in the range -1..1, but it can be temporarily set to 2
3250 or 3 to indicate that the -fcompare-debug flags didn't come from
3251 the command-line, but rather from the GCC_COMPARE_DEBUG environment
3252 variable, until a synthesized -fcompare-debug flag is added to the
3256 /* Set to nonzero if we've seen the -fcompare-debug-second flag. */
3257 int compare_debug_second
;
3259 /* Set to the flags that should be passed to the second compilation in
3260 a -fcompare-debug compilation. */
3261 const char *compare_debug_opt
;
3263 static struct switchstr
*switches_debug_check
[2];
3265 static int n_switches_debug_check
[2];
3267 static int n_switches_alloc_debug_check
[2];
3269 static char *debug_check_temp_file
[2];
3271 /* Language is one of three things:
3273 1) The name of a real programming language.
3274 2) NULL, indicating that no one has figured out
3276 3) '*', indicating that the file should be passed
3281 const char *language
;
3282 struct compiler
*incompiler
;
3287 /* Also a vector of input files specified. */
3289 static struct infile
*infiles
;
3293 static int n_infiles_alloc
;
3295 /* True if multiple input files are being compiled to a single
3298 static bool combine_inputs
;
3300 /* This counts the number of libraries added by lang_specific_driver, so that
3301 we can tell if there were any user supplied any files or libraries. */
3303 static int added_libraries
;
3305 /* And a vector of corresponding output files is made up later. */
3307 const char **outfiles
;
3309 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3311 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
3312 is true if we should look for an executable suffix. DO_OBJ
3313 is true if we should look for an object suffix. */
3316 convert_filename (const char *name
, int do_exe ATTRIBUTE_UNUSED
,
3317 int do_obj ATTRIBUTE_UNUSED
)
3319 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3327 len
= strlen (name
);
3329 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3330 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
3331 if (do_obj
&& len
> 2
3332 && name
[len
- 2] == '.'
3333 && name
[len
- 1] == 'o')
3335 obstack_grow (&obstack
, name
, len
- 2);
3336 obstack_grow0 (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
3337 name
= XOBFINISH (&obstack
, const char *);
3341 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3342 /* If there is no filetype, make it the executable suffix (which includes
3343 the "."). But don't get confused if we have just "-o". */
3344 if (! do_exe
|| TARGET_EXECUTABLE_SUFFIX
[0] == 0 || (len
== 2 && name
[0] == '-'))
3347 for (i
= len
- 1; i
>= 0; i
--)
3348 if (IS_DIR_SEPARATOR (name
[i
]))
3351 for (i
++; i
< len
; i
++)
3355 obstack_grow (&obstack
, name
, len
);
3356 obstack_grow0 (&obstack
, TARGET_EXECUTABLE_SUFFIX
,
3357 strlen (TARGET_EXECUTABLE_SUFFIX
));
3358 name
= XOBFINISH (&obstack
, const char *);
3365 /* Display the command line switches accepted by gcc. */
3369 printf (_("Usage: %s [options] file...\n"), progname
);
3370 fputs (_("Options:\n"), stdout
);
3372 fputs (_(" -pass-exit-codes Exit with highest error code from a phase.\n"), stdout
);
3373 fputs (_(" --help Display this information.\n"), stdout
);
3374 fputs (_(" --target-help Display target specific command line options.\n"), stdout
);
3375 fputs (_(" --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...].\n"), stdout
);
3376 fputs (_(" Display specific types of command line options.\n"), stdout
);
3378 fputs (_(" (Use '-v --help' to display command line options of sub-processes).\n"), stdout
);
3379 fputs (_(" --version Display compiler version information.\n"), stdout
);
3380 fputs (_(" -dumpspecs Display all of the built in spec strings.\n"), stdout
);
3381 fputs (_(" -dumpversion Display the version of the compiler.\n"), stdout
);
3382 fputs (_(" -dumpmachine Display the compiler's target processor.\n"), stdout
);
3383 fputs (_(" -print-search-dirs Display the directories in the compiler's search path.\n"), stdout
);
3384 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library.\n"), stdout
);
3385 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>.\n"), stdout
);
3386 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>.\n"), stdout
);
3388 -print-multiarch Display the target's normalized GNU triplet, used as\n\
3389 a component in the library path.\n"), stdout
);
3390 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc.\n"), stdout
);
3392 -print-multi-lib Display the mapping between command line options and\n\
3393 multiple library search directories.\n"), stdout
);
3394 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries.\n"), stdout
);
3395 fputs (_(" -print-sysroot Display the target libraries directory.\n"), stdout
);
3396 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers.\n"), stdout
);
3397 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler.\n"), stdout
);
3398 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor.\n"), stdout
);
3399 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker.\n"), stdout
);
3400 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler.\n"), stdout
);
3401 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor.\n"), stdout
);
3402 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker.\n"), stdout
);
3403 fputs (_(" -save-temps Do not delete intermediate files.\n"), stdout
);
3404 fputs (_(" -save-temps=<arg> Do not delete intermediate files.\n"), stdout
);
3406 -no-canonical-prefixes Do not canonicalize paths when building relative\n\
3407 prefixes to other gcc components.\n"), stdout
);
3408 fputs (_(" -pipe Use pipes rather than intermediate files.\n"), stdout
);
3409 fputs (_(" -time Time the execution of each subprocess.\n"), stdout
);
3410 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>.\n"), stdout
);
3411 fputs (_(" -std=<standard> Assume that the input sources are for <standard>.\n"), stdout
);
3413 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3414 and libraries.\n"), stdout
);
3415 fputs (_(" -B <directory> Add <directory> to the compiler's search paths.\n"), stdout
);
3416 fputs (_(" -v Display the programs invoked by the compiler.\n"), stdout
);
3417 fputs (_(" -### Like -v but options quoted and commands not executed.\n"), stdout
);
3418 fputs (_(" -E Preprocess only; do not compile, assemble or link.\n"), stdout
);
3419 fputs (_(" -S Compile only; do not assemble or link.\n"), stdout
);
3420 fputs (_(" -c Compile and assemble, but do not link.\n"), stdout
);
3421 fputs (_(" -o <file> Place the output into <file>.\n"), stdout
);
3422 fputs (_(" -pie Create a position independent executable.\n"), stdout
);
3423 fputs (_(" -shared Create a shared library.\n"), stdout
);
3425 -x <language> Specify the language of the following input files.\n\
3426 Permissible languages include: c c++ assembler none\n\
3427 'none' means revert to the default behavior of\n\
3428 guessing the language based on the file's extension.\n\
3432 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3433 passed on to the various sub-processes invoked by %s. In order to pass\n\
3434 other options on to these processes the -W<letter> options must be used.\n\
3437 /* The rest of the options are displayed by invocations of the various
3442 add_preprocessor_option (const char *option
, int len
)
3444 preprocessor_options
.safe_push (save_string (option
, len
));
3448 add_assembler_option (const char *option
, int len
)
3450 assembler_options
.safe_push (save_string (option
, len
));
3454 add_linker_option (const char *option
, int len
)
3456 linker_options
.safe_push (save_string (option
, len
));
3459 /* Allocate space for an input file in infiles. */
3464 if (n_infiles_alloc
== 0)
3466 n_infiles_alloc
= 16;
3467 infiles
= XNEWVEC (struct infile
, n_infiles_alloc
);
3469 else if (n_infiles_alloc
== n_infiles
)
3471 n_infiles_alloc
*= 2;
3472 infiles
= XRESIZEVEC (struct infile
, infiles
, n_infiles_alloc
);
3476 /* Store an input file with the given NAME and LANGUAGE in
3480 add_infile (const char *name
, const char *language
)
3483 infiles
[n_infiles
].name
= name
;
3484 infiles
[n_infiles
++].language
= language
;
3487 /* Allocate space for a switch in switches. */
3492 if (n_switches_alloc
== 0)
3494 n_switches_alloc
= 16;
3495 switches
= XNEWVEC (struct switchstr
, n_switches_alloc
);
3497 else if (n_switches_alloc
== n_switches
)
3499 n_switches_alloc
*= 2;
3500 switches
= XRESIZEVEC (struct switchstr
, switches
, n_switches_alloc
);
3504 /* Save an option OPT with N_ARGS arguments in array ARGS, marking it
3505 as validated if VALIDATED and KNOWN if it is an internal switch. */
3508 save_switch (const char *opt
, size_t n_args
, const char *const *args
,
3509 bool validated
, bool known
)
3512 switches
[n_switches
].part1
= opt
+ 1;
3514 switches
[n_switches
].args
= 0;
3517 switches
[n_switches
].args
= XNEWVEC (const char *, n_args
+ 1);
3518 memcpy (switches
[n_switches
].args
, args
, n_args
* sizeof (const char *));
3519 switches
[n_switches
].args
[n_args
] = NULL
;
3522 switches
[n_switches
].live_cond
= 0;
3523 switches
[n_switches
].validated
= validated
;
3524 switches
[n_switches
].known
= known
;
3525 switches
[n_switches
].ordering
= 0;
3529 /* Handle an option DECODED that is unknown to the option-processing
3533 driver_unknown_option_callback (const struct cl_decoded_option
*decoded
)
3535 const char *opt
= decoded
->arg
;
3536 if (opt
[1] == 'W' && opt
[2] == 'n' && opt
[3] == 'o' && opt
[4] == '-'
3537 && !(decoded
->errors
& CL_ERR_NEGATIVE
))
3539 /* Leave unknown -Wno-* options for the compiler proper, to be
3540 diagnosed only if there are warnings. */
3541 save_switch (decoded
->canonical_option
[0],
3542 decoded
->canonical_option_num_elements
- 1,
3543 &decoded
->canonical_option
[1], false, true);
3546 if (decoded
->opt_index
== OPT_SPECIAL_unknown
)
3548 /* Give it a chance to define it a spec file. */
3549 save_switch (decoded
->canonical_option
[0],
3550 decoded
->canonical_option_num_elements
- 1,
3551 &decoded
->canonical_option
[1], false, false);
3558 /* Handle an option DECODED that is not marked as CL_DRIVER.
3559 LANG_MASK will always be CL_DRIVER. */
3562 driver_wrong_lang_callback (const struct cl_decoded_option
*decoded
,
3563 unsigned int lang_mask ATTRIBUTE_UNUSED
)
3565 /* At this point, non-driver options are accepted (and expected to
3566 be passed down by specs) unless marked to be rejected by the
3567 driver. Options to be rejected by the driver but accepted by the
3568 compilers proper are treated just like completely unknown
3570 const struct cl_option
*option
= &cl_options
[decoded
->opt_index
];
3572 if (option
->cl_reject_driver
)
3573 error ("unrecognized command line option %qs",
3574 decoded
->orig_option_with_args_text
);
3576 save_switch (decoded
->canonical_option
[0],
3577 decoded
->canonical_option_num_elements
- 1,
3578 &decoded
->canonical_option
[1], false, true);
3581 static const char *spec_lang
= 0;
3582 static int last_language_n_infiles
;
3584 /* Parse -foffload option argument. */
3587 handle_foffload_option (const char *arg
)
3589 const char *c
, *cur
, *n
, *next
, *end
;
3592 /* If option argument starts with '-' then no target is specified and we
3593 do not need to parse it. */
3597 end
= strchr (arg
, '=');
3599 end
= strchr (arg
, '\0');
3604 next
= strchr (cur
, ',');
3607 next
= (next
> end
) ? end
: next
;
3609 target
= XNEWVEC (char, next
- cur
+ 1);
3610 memcpy (target
, cur
, next
- cur
);
3611 target
[next
- cur
] = '\0';
3613 /* If 'disable' is passed to the option, stop parsing the option and clean
3614 the list of offload targets. */
3615 if (strcmp (target
, "disable") == 0)
3617 free (offload_targets
);
3618 offload_targets
= xstrdup ("");
3622 /* Check that GCC is configured to support the offload target. */
3623 c
= OFFLOAD_TARGETS
;
3626 n
= strchr (c
, ',');
3628 n
= strchr (c
, '\0');
3630 if (next
- cur
== n
- c
&& strncmp (target
, c
, n
- c
) == 0)
3633 c
= *n
? n
+ 1 : NULL
;
3637 fatal_error (input_location
,
3638 "GCC is not configured to support %s as offload target",
3641 if (!offload_targets
)
3643 offload_targets
= target
;
3648 /* Check that the target hasn't already presented in the list. */
3649 c
= offload_targets
;
3652 n
= strchr (c
, ':');
3654 n
= strchr (c
, '\0');
3656 if (next
- cur
== n
- c
&& strncmp (c
, target
, n
- c
) == 0)
3663 /* If duplicate is not found, append the target to the list. */
3666 size_t offload_targets_len
= strlen (offload_targets
);
3668 = XRESIZEVEC (char, offload_targets
,
3669 offload_targets_len
+ 1 + next
- cur
+ 1);
3670 offload_targets
[offload_targets_len
++] = ':';
3671 memcpy (offload_targets
+ offload_targets_len
, target
, next
- cur
+ 1);
3676 XDELETEVEC (target
);
3680 /* Handle a driver option; arguments and return value as for
3684 driver_handle_option (struct gcc_options
*opts
,
3685 struct gcc_options
*opts_set
,
3686 const struct cl_decoded_option
*decoded
,
3687 unsigned int lang_mask ATTRIBUTE_UNUSED
, int kind
,
3689 const struct cl_option_handlers
*handlers ATTRIBUTE_UNUSED
,
3690 diagnostic_context
*dc
)
3692 size_t opt_index
= decoded
->opt_index
;
3693 const char *arg
= decoded
->arg
;
3694 const char *compare_debug_replacement_opt
;
3695 int value
= decoded
->value
;
3696 bool validated
= false;
3697 bool do_save
= true;
3699 gcc_assert (opts
== &global_options
);
3700 gcc_assert (opts_set
== &global_options_set
);
3701 gcc_assert (kind
== DK_UNSPECIFIED
);
3702 gcc_assert (loc
== UNKNOWN_LOCATION
);
3703 gcc_assert (dc
== global_dc
);
3709 struct spec_list
*sl
;
3711 for (sl
= specs
; sl
; sl
= sl
->next
)
3712 printf ("*%s:\n%s\n\n", sl
->name
, *(sl
->ptr_spec
));
3713 if (link_command_spec
)
3714 printf ("*link_command:\n%s\n\n", link_command_spec
);
3718 case OPT_dumpversion
:
3719 printf ("%s\n", spec_version
);
3722 case OPT_dumpmachine
:
3723 printf ("%s\n", spec_machine
);
3729 /* CPP driver cannot obtain switch from cc1_options. */
3731 add_preprocessor_option ("--version", strlen ("--version"));
3732 add_assembler_option ("--version", strlen ("--version"));
3733 add_linker_option ("--version", strlen ("--version"));
3737 print_help_list
= 1;
3739 /* CPP driver cannot obtain switch from cc1_options. */
3741 add_preprocessor_option ("--help", 6);
3742 add_assembler_option ("--help", 6);
3743 add_linker_option ("--help", 6);
3747 print_subprocess_help
= 2;
3750 case OPT__target_help
:
3751 print_subprocess_help
= 1;
3753 /* CPP driver cannot obtain switch from cc1_options. */
3755 add_preprocessor_option ("--target-help", 13);
3756 add_assembler_option ("--target-help", 13);
3757 add_linker_option ("--target-help", 13);
3760 case OPT__no_sysroot_suffix
:
3761 case OPT_pass_exit_codes
:
3762 case OPT_print_search_dirs
:
3763 case OPT_print_file_name_
:
3764 case OPT_print_prog_name_
:
3765 case OPT_print_multi_lib
:
3766 case OPT_print_multi_directory
:
3767 case OPT_print_sysroot
:
3768 case OPT_print_multi_os_directory
:
3769 case OPT_print_multiarch
:
3770 case OPT_print_sysroot_headers_suffix
:
3773 /* These options set the variables specified in common.opt
3774 automatically, and do not need to be saved for spec
3779 case OPT_print_libgcc_file_name
:
3780 print_file_name
= "libgcc.a";
3784 case OPT_fuse_ld_bfd
:
3788 case OPT_fuse_ld_gold
:
3792 case OPT_fcompare_debug_second
:
3793 compare_debug_second
= 1;
3796 case OPT_fcompare_debug
:
3800 compare_debug_replacement_opt
= "-fcompare-debug=";
3802 goto compare_debug_with_arg
;
3805 compare_debug_replacement_opt
= "-fcompare-debug=-gtoggle";
3807 goto compare_debug_with_arg
;
3814 case OPT_fcompare_debug_
:
3815 compare_debug_replacement_opt
= decoded
->canonical_option
[0];
3816 compare_debug_with_arg
:
3817 gcc_assert (decoded
->canonical_option_num_elements
== 1);
3818 gcc_assert (arg
!= NULL
);
3823 if (compare_debug
< 0)
3824 compare_debug_opt
= NULL
;
3826 compare_debug_opt
= arg
;
3827 save_switch (compare_debug_replacement_opt
, 0, NULL
, validated
, true);
3830 case OPT_fdiagnostics_color_
:
3831 diagnostic_color_init (dc
, value
);
3837 /* Pass the rest of this option to the assembler. */
3839 /* Split the argument at commas. */
3841 for (j
= 0; arg
[j
]; j
++)
3844 add_assembler_option (arg
+ prev
, j
- prev
);
3848 /* Record the part after the last comma. */
3849 add_assembler_option (arg
+ prev
, j
- prev
);
3857 /* Pass the rest of this option to the preprocessor. */
3859 /* Split the argument at commas. */
3861 for (j
= 0; arg
[j
]; j
++)
3864 add_preprocessor_option (arg
+ prev
, j
- prev
);
3868 /* Record the part after the last comma. */
3869 add_preprocessor_option (arg
+ prev
, j
- prev
);
3877 /* Split the argument at commas. */
3879 for (j
= 0; arg
[j
]; j
++)
3882 add_infile (save_string (arg
+ prev
, j
- prev
), "*");
3885 /* Record the part after the last comma. */
3886 add_infile (arg
+ prev
, "*");
3892 add_infile (arg
, "*");
3896 case OPT_Xpreprocessor
:
3897 add_preprocessor_option (arg
, strlen (arg
));
3901 case OPT_Xassembler
:
3902 add_assembler_option (arg
, strlen (arg
));
3907 /* POSIX allows separation of -l and the lib arg; canonicalize
3908 by concatenating -l with its arg */
3909 add_infile (concat ("-l", arg
, NULL
), "*");
3914 /* Similarly, canonicalize -L for linkers that may not accept
3915 separate arguments. */
3916 save_switch (concat ("-L", arg
, NULL
), 0, NULL
, validated
, true);
3921 save_switch (concat ("-F", arg
, NULL
), 0, NULL
, validated
, true);
3924 case OPT_save_temps
:
3925 save_temps_flag
= SAVE_TEMPS_CWD
;
3929 case OPT_save_temps_
:
3930 if (strcmp (arg
, "cwd") == 0)
3931 save_temps_flag
= SAVE_TEMPS_CWD
;
3932 else if (strcmp (arg
, "obj") == 0
3933 || strcmp (arg
, "object") == 0)
3934 save_temps_flag
= SAVE_TEMPS_OBJ
;
3936 fatal_error (input_location
, "%qs is an unknown -save-temps option",
3937 decoded
->orig_option_with_args_text
);
3940 case OPT_no_canonical_prefixes
:
3941 /* Already handled as a special case, so ignored here. */
3947 /* These options set the variables specified in common.opt
3948 automatically, but do need to be saved for spec
3954 struct user_specs
*user
= XNEW (struct user_specs
);
3956 user
->next
= (struct user_specs
*) 0;
3957 user
->filename
= arg
;
3958 if (user_specs_tail
)
3959 user_specs_tail
->next
= user
;
3961 user_specs_head
= user
;
3962 user_specs_tail
= user
;
3968 target_system_root
= arg
;
3969 target_system_root_changed
= 1;
3974 if (report_times_to_file
)
3975 fclose (report_times_to_file
);
3976 report_times_to_file
= fopen (arg
, "a");
3982 This is similar to -v except that there is no execution
3983 of the commands and the echoed arguments are quoted. It
3984 is intended for use in shell scripts to capture the
3985 driver-generated command line. */
3986 verbose_only_flag
++;
3993 size_t len
= strlen (arg
);
3995 /* Catch the case where the user has forgotten to append a
3996 directory separator to the path. Note, they may be using
3997 -B to add an executable name prefix, eg "i386-elf-", in
3998 order to distinguish between multiple installations of
3999 GCC in the same directory. Hence we must check to see
4000 if appending a directory separator actually makes a
4001 valid directory name. */
4002 if (!IS_DIR_SEPARATOR (arg
[len
- 1])
4003 && is_directory (arg
, false))
4005 char *tmp
= XNEWVEC (char, len
+ 2);
4007 tmp
[len
] = DIR_SEPARATOR
;
4012 add_prefix (&exec_prefixes
, arg
, NULL
,
4013 PREFIX_PRIORITY_B_OPT
, 0, 0);
4014 add_prefix (&startfile_prefixes
, arg
, NULL
,
4015 PREFIX_PRIORITY_B_OPT
, 0, 0);
4016 add_prefix (&include_prefixes
, arg
, NULL
,
4017 PREFIX_PRIORITY_B_OPT
, 0, 0);
4024 if (!strcmp (spec_lang
, "none"))
4025 /* Suppress the warning if -xnone comes after the last input
4026 file, because alternate command interfaces like g++ might
4027 find it useful to place -xnone after each input file. */
4030 last_language_n_infiles
= n_infiles
;
4036 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
4037 arg
= convert_filename (arg
, ! have_c
, 0);
4040 /* Save the output name in case -save-temps=obj was used. */
4041 save_temps_prefix
= xstrdup (arg
);
4042 /* On some systems, ld cannot handle "-o" without a space. So
4043 split the option from its argument. */
4044 save_switch ("-o", 1, &arg
, validated
, true);
4047 #ifdef ENABLE_DEFAULT_PIE
4049 /* -pie is turned on by default. */
4052 case OPT_static_libgcc
:
4053 case OPT_shared_libgcc
:
4054 case OPT_static_libgfortran
:
4055 case OPT_static_libstdc__
:
4056 /* These are always valid, since gcc.c itself understands the
4057 first two, gfortranspec.c understands -static-libgfortran and
4058 g++spec.c understands -static-libstdc++ */
4067 handle_foffload_option (arg
);
4071 /* Various driver options need no special processing at this
4072 point, having been handled in a prescan above or being
4073 handled by specs. */
4078 save_switch (decoded
->canonical_option
[0],
4079 decoded
->canonical_option_num_elements
- 1,
4080 &decoded
->canonical_option
[1], validated
, true);
4084 /* Put the driver's standard set of option handlers in *HANDLERS. */
4087 set_option_handlers (struct cl_option_handlers
*handlers
)
4089 handlers
->unknown_option_callback
= driver_unknown_option_callback
;
4090 handlers
->wrong_lang_callback
= driver_wrong_lang_callback
;
4091 handlers
->num_handlers
= 3;
4092 handlers
->handlers
[0].handler
= driver_handle_option
;
4093 handlers
->handlers
[0].mask
= CL_DRIVER
;
4094 handlers
->handlers
[1].handler
= common_handle_option
;
4095 handlers
->handlers
[1].mask
= CL_COMMON
;
4096 handlers
->handlers
[2].handler
= target_handle_option
;
4097 handlers
->handlers
[2].mask
= CL_TARGET
;
4100 /* Create the vector `switches' and its contents.
4101 Store its length in `n_switches'. */
4104 process_command (unsigned int decoded_options_count
,
4105 struct cl_decoded_option
*decoded_options
)
4109 char *tooldir_prefix
, *tooldir_prefix2
;
4110 char *(*get_relative_prefix
) (const char *, const char *,
4111 const char *) = NULL
;
4112 struct cl_option_handlers handlers
;
4115 gcc_exec_prefix
= env
.get ("GCC_EXEC_PREFIX");
4119 added_libraries
= 0;
4121 /* Figure compiler version from version string. */
4123 compiler_version
= temp1
= xstrdup (version_string
);
4125 for (; *temp1
; ++temp1
)
4134 /* Handle any -no-canonical-prefixes flag early, to assign the function
4135 that builds relative prefixes. This function creates default search
4136 paths that are needed later in normal option handling. */
4138 for (j
= 1; j
< decoded_options_count
; j
++)
4140 if (decoded_options
[j
].opt_index
== OPT_no_canonical_prefixes
)
4142 get_relative_prefix
= make_relative_prefix_ignore_links
;
4146 if (! get_relative_prefix
)
4147 get_relative_prefix
= make_relative_prefix
;
4149 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
4150 see if we can create it from the pathname specified in
4151 decoded_options[0].arg. */
4153 gcc_libexec_prefix
= standard_libexec_prefix
;
4155 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
4156 if (!gcc_exec_prefix
)
4158 gcc_exec_prefix
= get_relative_prefix (decoded_options
[0].arg
,
4159 standard_bindir_prefix
,
4160 standard_exec_prefix
);
4161 gcc_libexec_prefix
= get_relative_prefix (decoded_options
[0].arg
,
4162 standard_bindir_prefix
,
4163 standard_libexec_prefix
);
4164 if (gcc_exec_prefix
)
4165 xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix
, NULL
));
4169 /* make_relative_prefix requires a program name, but
4170 GCC_EXEC_PREFIX is typically a directory name with a trailing
4171 / (which is ignored by make_relative_prefix), so append a
4173 char *tmp_prefix
= concat (gcc_exec_prefix
, "gcc", NULL
);
4174 gcc_libexec_prefix
= get_relative_prefix (tmp_prefix
,
4175 standard_exec_prefix
,
4176 standard_libexec_prefix
);
4178 /* The path is unrelocated, so fallback to the original setting. */
4179 if (!gcc_libexec_prefix
)
4180 gcc_libexec_prefix
= standard_libexec_prefix
;
4186 /* From this point onward, gcc_exec_prefix is non-null if the toolchain
4187 is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
4188 or an automatically created GCC_EXEC_PREFIX from
4189 decoded_options[0].arg. */
4191 /* Do language-specific adjustment/addition of flags. */
4192 lang_specific_driver (&decoded_options
, &decoded_options_count
,
4195 if (gcc_exec_prefix
)
4197 int len
= strlen (gcc_exec_prefix
);
4199 if (len
> (int) sizeof ("/lib/gcc/") - 1
4200 && (IS_DIR_SEPARATOR (gcc_exec_prefix
[len
-1])))
4202 temp
= gcc_exec_prefix
+ len
- sizeof ("/lib/gcc/") + 1;
4203 if (IS_DIR_SEPARATOR (*temp
)
4204 && filename_ncmp (temp
+ 1, "lib", 3) == 0
4205 && IS_DIR_SEPARATOR (temp
[4])
4206 && filename_ncmp (temp
+ 5, "gcc", 3) == 0)
4207 len
-= sizeof ("/lib/gcc/") - 1;
4210 set_std_prefix (gcc_exec_prefix
, len
);
4211 add_prefix (&exec_prefixes
, gcc_libexec_prefix
, "GCC",
4212 PREFIX_PRIORITY_LAST
, 0, 0);
4213 add_prefix (&startfile_prefixes
, gcc_exec_prefix
, "GCC",
4214 PREFIX_PRIORITY_LAST
, 0, 0);
4217 /* COMPILER_PATH and LIBRARY_PATH have values
4218 that are lists of directory names with colons. */
4220 temp
= env
.get ("COMPILER_PATH");
4223 const char *startp
, *endp
;
4224 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4226 startp
= endp
= temp
;
4229 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4231 strncpy (nstore
, startp
, endp
- startp
);
4233 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4234 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4236 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4237 nstore
[endp
- startp
+ 1] = 0;
4240 nstore
[endp
- startp
] = 0;
4241 add_prefix (&exec_prefixes
, nstore
, 0,
4242 PREFIX_PRIORITY_LAST
, 0, 0);
4243 add_prefix (&include_prefixes
, nstore
, 0,
4244 PREFIX_PRIORITY_LAST
, 0, 0);
4247 endp
= startp
= endp
+ 1;
4254 temp
= env
.get (LIBRARY_PATH_ENV
);
4255 if (temp
&& *cross_compile
== '0')
4257 const char *startp
, *endp
;
4258 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4260 startp
= endp
= temp
;
4263 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4265 strncpy (nstore
, startp
, endp
- startp
);
4267 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4268 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4270 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4271 nstore
[endp
- startp
+ 1] = 0;
4274 nstore
[endp
- startp
] = 0;
4275 add_prefix (&startfile_prefixes
, nstore
, NULL
,
4276 PREFIX_PRIORITY_LAST
, 0, 1);
4279 endp
= startp
= endp
+ 1;
4286 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
4287 temp
= env
.get ("LPATH");
4288 if (temp
&& *cross_compile
== '0')
4290 const char *startp
, *endp
;
4291 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4293 startp
= endp
= temp
;
4296 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4298 strncpy (nstore
, startp
, endp
- startp
);
4300 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4301 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4303 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4304 nstore
[endp
- startp
+ 1] = 0;
4307 nstore
[endp
- startp
] = 0;
4308 add_prefix (&startfile_prefixes
, nstore
, NULL
,
4309 PREFIX_PRIORITY_LAST
, 0, 1);
4312 endp
= startp
= endp
+ 1;
4319 /* Process the options and store input files and switches in their
4322 last_language_n_infiles
= -1;
4324 set_option_handlers (&handlers
);
4326 for (j
= 1; j
< decoded_options_count
; j
++)
4328 switch (decoded_options
[j
].opt_index
)
4340 for (j
= 1; j
< decoded_options_count
; j
++)
4342 if (decoded_options
[j
].opt_index
== OPT_SPECIAL_input_file
)
4344 const char *arg
= decoded_options
[j
].arg
;
4345 const char *p
= strrchr (arg
, '@');
4349 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4350 arg
= convert_filename (arg
, 0, access (arg
, F_OK
));
4352 /* For LTO static archive support we handle input file
4353 specifications that are composed of a filename and
4354 an offset like FNAME@OFFSET. */
4357 && sscanf (p
, "@%li%n", &offset
, &consumed
) >= 1
4358 && strlen (p
) == (unsigned int)consumed
)
4360 fname
= (char *)xmalloc (p
- arg
+ 1);
4361 memcpy (fname
, arg
, p
- arg
);
4362 fname
[p
- arg
] = '\0';
4363 /* Only accept non-stdin and existing FNAME parts, otherwise
4364 try with the full name. */
4365 if (strcmp (fname
, "-") == 0 || access (fname
, F_OK
) < 0)
4368 fname
= xstrdup (arg
);
4372 fname
= xstrdup (arg
);
4374 if (strcmp (fname
, "-") != 0 && access (fname
, F_OK
) < 0)
4375 perror_with_name (fname
);
4377 add_infile (arg
, spec_lang
);
4383 read_cmdline_option (&global_options
, &global_options_set
,
4384 decoded_options
+ j
, UNKNOWN_LOCATION
,
4385 CL_DRIVER
, &handlers
, global_dc
);
4388 #ifdef ENABLE_OFFLOADING
4389 /* If the user didn't specify any, default to all configured offload
4391 if (offload_targets
== NULL
)
4392 handle_foffload_option (OFFLOAD_TARGETS
);
4396 && strcmp (output_file
, "-") != 0
4397 && strcmp (output_file
, HOST_BIT_BUCKET
) != 0)
4400 for (i
= 0; i
< n_infiles
; i
++)
4401 if ((!infiles
[i
].language
|| infiles
[i
].language
[0] != '*')
4402 && canonical_filename_eq (infiles
[i
].name
, output_file
))
4403 fatal_error (input_location
,
4404 "input file %qs is the same as output file",
4408 /* If -save-temps=obj and -o name, create the prefix to use for %b.
4409 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
4410 if (save_temps_flag
== SAVE_TEMPS_OBJ
&& save_temps_prefix
!= NULL
)
4412 save_temps_length
= strlen (save_temps_prefix
);
4413 temp
= strrchr (lbasename (save_temps_prefix
), '.');
4416 save_temps_length
-= strlen (temp
);
4417 save_temps_prefix
[save_temps_length
] = '\0';
4421 else if (save_temps_prefix
!= NULL
)
4423 free (save_temps_prefix
);
4424 save_temps_prefix
= NULL
;
4427 if (save_temps_flag
&& use_pipes
)
4429 /* -save-temps overrides -pipe, so that temp files are produced */
4430 if (save_temps_flag
)
4431 warning (0, "-pipe ignored because -save-temps specified");
4437 const char *gcd
= env
.get ("GCC_COMPARE_DEBUG");
4439 if (gcd
&& gcd
[0] == '-')
4442 compare_debug_opt
= gcd
;
4444 else if (gcd
&& *gcd
&& strcmp (gcd
, "0"))
4447 compare_debug_opt
= "-gtoggle";
4450 else if (compare_debug
< 0)
4453 gcc_assert (!compare_debug_opt
);
4456 /* Set up the search paths. We add directories that we expect to
4457 contain GNU Toolchain components before directories specified by
4458 the machine description so that we will find GNU components (like
4459 the GNU assembler) before those of the host system. */
4461 /* If we don't know where the toolchain has been installed, use the
4462 configured-in locations. */
4463 if (!gcc_exec_prefix
)
4466 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "GCC",
4467 PREFIX_PRIORITY_LAST
, 1, 0);
4468 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "BINUTILS",
4469 PREFIX_PRIORITY_LAST
, 2, 0);
4470 add_prefix (&exec_prefixes
, standard_exec_prefix
, "BINUTILS",
4471 PREFIX_PRIORITY_LAST
, 2, 0);
4473 add_prefix (&startfile_prefixes
, standard_exec_prefix
, "BINUTILS",
4474 PREFIX_PRIORITY_LAST
, 1, 0);
4477 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix
));
4478 tooldir_prefix2
= concat (tooldir_base_prefix
, spec_machine
,
4479 dir_separator_str
, NULL
);
4481 /* Look for tools relative to the location from which the driver is
4482 running, or, if that is not available, the configured prefix. */
4484 = concat (gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
4485 spec_host_machine
, dir_separator_str
, spec_version
,
4486 accel_dir_suffix
, dir_separator_str
, tooldir_prefix2
, NULL
);
4487 free (tooldir_prefix2
);
4489 add_prefix (&exec_prefixes
,
4490 concat (tooldir_prefix
, "bin", dir_separator_str
, NULL
),
4491 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 0);
4492 add_prefix (&startfile_prefixes
,
4493 concat (tooldir_prefix
, "lib", dir_separator_str
, NULL
),
4494 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 1);
4495 free (tooldir_prefix
);
4497 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
4498 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
4499 then consider it to relocate with the rest of the GCC installation
4500 if GCC_EXEC_PREFIX is set.
4501 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
4502 if (target_system_root
&& !target_system_root_changed
&& gcc_exec_prefix
)
4504 char *tmp_prefix
= get_relative_prefix (decoded_options
[0].arg
,
4505 standard_bindir_prefix
,
4506 target_system_root
);
4507 if (tmp_prefix
&& access_check (tmp_prefix
, F_OK
) == 0)
4509 target_system_root
= tmp_prefix
;
4510 target_system_root_changed
= 1;
4515 /* More prefixes are enabled in main, after we read the specs file
4516 and determine whether this is cross-compilation or not. */
4518 if (n_infiles
== last_language_n_infiles
&& spec_lang
!= 0)
4519 warning (0, "%<-x %s%> after last input file has no effect", spec_lang
);
4521 /* Synthesize -fcompare-debug flag from the GCC_COMPARE_DEBUG
4522 environment variable. */
4523 if (compare_debug
== 2 || compare_debug
== 3)
4525 const char *opt
= concat ("-fcompare-debug=", compare_debug_opt
, NULL
);
4526 save_switch (opt
, 0, NULL
, false, true);
4530 /* Ensure we only invoke each subprocess once. */
4531 if (print_subprocess_help
|| print_help_list
|| print_version
)
4535 /* Create a dummy input file, so that we can pass
4536 the help option on to the various sub-processes. */
4537 add_infile ("help-dummy", "c");
4541 switches
[n_switches
].part1
= 0;
4543 infiles
[n_infiles
].name
= 0;
4546 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4547 and place that in the environment. */
4550 set_collect_gcc_options (void)
4555 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4557 obstack_grow (&collect_obstack
, "COLLECT_GCC_OPTIONS=",
4558 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4561 for (i
= 0; (int) i
< n_switches
; i
++)
4563 const char *const *args
;
4566 obstack_grow (&collect_obstack
, " ", 1);
4570 /* Ignore elided switches. */
4571 if ((switches
[i
].live_cond
4572 & (SWITCH_IGNORE
| SWITCH_KEEP_FOR_GCC
))
4576 obstack_grow (&collect_obstack
, "'-", 2);
4577 q
= switches
[i
].part1
;
4578 while ((p
= strchr (q
, '\'')))
4580 obstack_grow (&collect_obstack
, q
, p
- q
);
4581 obstack_grow (&collect_obstack
, "'\\''", 4);
4584 obstack_grow (&collect_obstack
, q
, strlen (q
));
4585 obstack_grow (&collect_obstack
, "'", 1);
4587 for (args
= switches
[i
].args
; args
&& *args
; args
++)
4589 obstack_grow (&collect_obstack
, " '", 2);
4591 while ((p
= strchr (q
, '\'')))
4593 obstack_grow (&collect_obstack
, q
, p
- q
);
4594 obstack_grow (&collect_obstack
, "'\\''", 4);
4597 obstack_grow (&collect_obstack
, q
, strlen (q
));
4598 obstack_grow (&collect_obstack
, "'", 1);
4601 obstack_grow (&collect_obstack
, "\0", 1);
4602 xputenv (XOBFINISH (&collect_obstack
, char *));
4605 /* Process a spec string, accumulating and running commands. */
4607 /* These variables describe the input file name.
4608 input_file_number is the index on outfiles of this file,
4609 so that the output file name can be stored for later use by %o.
4610 input_basename is the start of the part of the input file
4611 sans all directory names, and basename_length is the number
4612 of characters starting there excluding the suffix .c or whatever. */
4614 static const char *gcc_input_filename
;
4615 static int input_file_number
;
4616 size_t input_filename_length
;
4617 static int basename_length
;
4618 static int suffixed_basename_length
;
4619 static const char *input_basename
;
4620 static const char *input_suffix
;
4621 #ifndef HOST_LACKS_INODE_NUMBERS
4622 static struct stat input_stat
;
4624 static int input_stat_set
;
4626 /* The compiler used to process the current input file. */
4627 static struct compiler
*input_file_compiler
;
4629 /* These are variables used within do_spec and do_spec_1. */
4631 /* Nonzero if an arg has been started and not yet terminated
4632 (with space, tab or newline). */
4633 static int arg_going
;
4635 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4636 is a temporary file name. */
4637 static int delete_this_arg
;
4639 /* Nonzero means %w has been seen; the next arg to be terminated
4640 is the output file name of this compilation. */
4641 static int this_is_output_file
;
4643 /* Nonzero means %s has been seen; the next arg to be terminated
4644 is the name of a library file and we should try the standard
4645 search dirs for it. */
4646 static int this_is_library_file
;
4648 /* Nonzero means %T has been seen; the next arg to be terminated
4649 is the name of a linker script and we should try all of the
4650 standard search dirs for it. If it is found insert a --script
4651 command line switch and then substitute the full path in place,
4652 otherwise generate an error message. */
4653 static int this_is_linker_script
;
4655 /* Nonzero means that the input of this command is coming from a pipe. */
4656 static int input_from_pipe
;
4658 /* Nonnull means substitute this for any suffix when outputting a switches
4660 static const char *suffix_subst
;
4662 /* If there is an argument being accumulated, terminate it and store it. */
4665 end_going_arg (void)
4671 obstack_1grow (&obstack
, 0);
4672 string
= XOBFINISH (&obstack
, const char *);
4673 if (this_is_library_file
)
4674 string
= find_file (string
);
4675 if (this_is_linker_script
)
4677 char * full_script_path
= find_a_file (&startfile_prefixes
, string
, R_OK
, true);
4679 if (full_script_path
== NULL
)
4681 error ("unable to locate default linker script %qs in the library search paths", string
);
4682 /* Script was not found on search path. */
4685 store_arg ("--script", false, false);
4686 string
= full_script_path
;
4688 store_arg (string
, delete_this_arg
, this_is_output_file
);
4689 if (this_is_output_file
)
4690 outfiles
[input_file_number
] = string
;
4696 /* Parse the WRAPPER string which is a comma separated list of the command line
4697 and insert them into the beginning of argbuf. */
4700 insert_wrapper (const char *wrapper
)
4704 char *buf
= xstrdup (wrapper
);
4706 unsigned int old_length
= argbuf
.length ();
4714 while ((p
= strchr (p
, ',')) != NULL
);
4716 argbuf
.safe_grow (old_length
+ n
);
4717 memmove (argbuf
.address () + n
,
4719 old_length
* sizeof (const_char_p
));
4733 while ((p
= strchr (p
, ',')) != NULL
);
4734 gcc_assert (i
== n
);
4737 /* Process the spec SPEC and run the commands specified therein.
4738 Returns 0 if the spec is successfully processed; -1 if failed. */
4741 do_spec (const char *spec
)
4745 value
= do_spec_2 (spec
);
4747 /* Force out any unfinished command.
4748 If -pipe, this forces out the last command if it ended in `|'. */
4751 if (argbuf
.length () > 0
4752 && !strcmp (argbuf
.last (), "|"))
4755 set_collect_gcc_options ();
4757 if (argbuf
.length () > 0)
4765 do_spec_2 (const char *spec
)
4771 delete_this_arg
= 0;
4772 this_is_output_file
= 0;
4773 this_is_library_file
= 0;
4774 this_is_linker_script
= 0;
4775 input_from_pipe
= 0;
4776 suffix_subst
= NULL
;
4778 result
= do_spec_1 (spec
, 0, NULL
);
4786 /* Process the given spec string and add any new options to the end
4787 of the switches/n_switches array. */
4790 do_option_spec (const char *name
, const char *spec
)
4792 unsigned int i
, value_count
, value_len
;
4793 const char *p
, *q
, *value
;
4794 char *tmp_spec
, *tmp_spec_p
;
4796 if (configure_default_options
[0].name
== NULL
)
4799 for (i
= 0; i
< ARRAY_SIZE (configure_default_options
); i
++)
4800 if (strcmp (configure_default_options
[i
].name
, name
) == 0)
4802 if (i
== ARRAY_SIZE (configure_default_options
))
4805 value
= configure_default_options
[i
].value
;
4806 value_len
= strlen (value
);
4808 /* Compute the size of the final spec. */
4811 while ((p
= strstr (p
, "%(VALUE)")) != NULL
)
4817 /* Replace each %(VALUE) by the specified value. */
4818 tmp_spec
= (char *) alloca (strlen (spec
) + 1
4819 + value_count
* (value_len
- strlen ("%(VALUE)")));
4820 tmp_spec_p
= tmp_spec
;
4822 while ((p
= strstr (q
, "%(VALUE)")) != NULL
)
4824 memcpy (tmp_spec_p
, q
, p
- q
);
4825 tmp_spec_p
= tmp_spec_p
+ (p
- q
);
4826 memcpy (tmp_spec_p
, value
, value_len
);
4827 tmp_spec_p
+= value_len
;
4828 q
= p
+ strlen ("%(VALUE)");
4830 strcpy (tmp_spec_p
, q
);
4832 do_self_spec (tmp_spec
);
4835 /* Process the given spec string and add any new options to the end
4836 of the switches/n_switches array. */
4839 do_self_spec (const char *spec
)
4844 do_spec_1 (" ", 0, NULL
);
4846 /* Mark %<S switches processed by do_self_spec to be ignored permanently.
4847 do_self_specs adds the replacements to switches array, so it shouldn't
4848 be processed afterwards. */
4849 for (i
= 0; i
< n_switches
; i
++)
4850 if ((switches
[i
].live_cond
& SWITCH_IGNORE
))
4851 switches
[i
].live_cond
|= SWITCH_IGNORE_PERMANENTLY
;
4853 if (argbuf
.length () > 0)
4855 const char **argbuf_copy
;
4856 struct cl_decoded_option
*decoded_options
;
4857 struct cl_option_handlers handlers
;
4858 unsigned int decoded_options_count
;
4861 /* Create a copy of argbuf with a dummy argv[0] entry for
4862 decode_cmdline_options_to_array. */
4863 argbuf_copy
= XNEWVEC (const char *,
4864 argbuf
.length () + 1);
4865 argbuf_copy
[0] = "";
4866 memcpy (argbuf_copy
+ 1, argbuf
.address (),
4867 argbuf
.length () * sizeof (const char *));
4869 decode_cmdline_options_to_array (argbuf
.length () + 1,
4871 CL_DRIVER
, &decoded_options
,
4872 &decoded_options_count
);
4875 set_option_handlers (&handlers
);
4877 for (j
= 1; j
< decoded_options_count
; j
++)
4879 switch (decoded_options
[j
].opt_index
)
4881 case OPT_SPECIAL_input_file
:
4882 /* Specs should only generate options, not input
4884 if (strcmp (decoded_options
[j
].arg
, "-") != 0)
4885 fatal_error (input_location
,
4886 "switch %qs does not start with %<-%>",
4887 decoded_options
[j
].arg
);
4889 fatal_error (input_location
,
4890 "spec-generated switch is just %<-%>");
4893 case OPT_fcompare_debug_second
:
4894 case OPT_fcompare_debug
:
4895 case OPT_fcompare_debug_
:
4897 /* Avoid duplicate processing of some options from
4898 compare-debug specs; just save them here. */
4899 save_switch (decoded_options
[j
].canonical_option
[0],
4900 (decoded_options
[j
].canonical_option_num_elements
4902 &decoded_options
[j
].canonical_option
[1], false, true);
4906 read_cmdline_option (&global_options
, &global_options_set
,
4907 decoded_options
+ j
, UNKNOWN_LOCATION
,
4908 CL_DRIVER
, &handlers
, global_dc
);
4913 free (decoded_options
);
4916 switches
[n_switches
].part1
= 0;
4920 /* Callback for processing %D and %I specs. */
4922 struct spec_path_info
{
4927 bool separate_options
;
4931 spec_path (char *path
, void *data
)
4933 struct spec_path_info
*info
= (struct spec_path_info
*) data
;
4937 if (info
->omit_relative
&& !IS_ABSOLUTE_PATH (path
))
4940 if (info
->append_len
!= 0)
4942 len
= strlen (path
);
4943 memcpy (path
+ len
, info
->append
, info
->append_len
+ 1);
4946 if (!is_directory (path
, true))
4949 do_spec_1 (info
->option
, 1, NULL
);
4950 if (info
->separate_options
)
4951 do_spec_1 (" ", 0, NULL
);
4953 if (info
->append_len
== 0)
4955 len
= strlen (path
);
4956 save
= path
[len
- 1];
4957 if (IS_DIR_SEPARATOR (path
[len
- 1]))
4958 path
[len
- 1] = '\0';
4961 do_spec_1 (path
, 1, NULL
);
4962 do_spec_1 (" ", 0, NULL
);
4964 /* Must not damage the original path. */
4965 if (info
->append_len
== 0)
4966 path
[len
- 1] = save
;
4971 /* Create a temporary FILE with the contents of ARGV. Add @FILE to the
4975 create_at_file (char **argv
)
4977 char *temp_file
= make_temp_file ("");
4978 char *at_argument
= concat ("@", temp_file
, NULL
);
4979 FILE *f
= fopen (temp_file
, "w");
4983 fatal_error (input_location
, "could not open temporary response file %s",
4986 status
= writeargv (argv
, f
);
4989 fatal_error (input_location
,
4990 "could not write to temporary response file %s",
4993 status
= fclose (f
);
4996 fatal_error (input_location
, "could not close temporary response file %s",
4999 store_arg (at_argument
, 0, 0);
5001 record_temp_file (temp_file
, !save_temps_flag
, !save_temps_flag
);
5004 /* True if we should compile INFILE. */
5007 compile_input_file_p (struct infile
*infile
)
5009 if ((!infile
->language
) || (infile
->language
[0] != '*'))
5010 if (infile
->incompiler
== input_file_compiler
)
5015 /* Process each member of VEC as a spec. */
5018 do_specs_vec (vec
<char_p
> vec
)
5023 FOR_EACH_VEC_ELT (vec
, ix
, opt
)
5025 do_spec_1 (opt
, 1, NULL
);
5026 /* Make each accumulated option a separate argument. */
5027 do_spec_1 (" ", 0, NULL
);
5031 /* Process the sub-spec SPEC as a portion of a larger spec.
5032 This is like processing a whole spec except that we do
5033 not initialize at the beginning and we do not supply a
5034 newline by default at the end.
5035 INSWITCH nonzero means don't process %-sequences in SPEC;
5036 in this case, % is treated as an ordinary character.
5037 This is used while substituting switches.
5038 INSWITCH nonzero also causes SPC not to terminate an argument.
5040 Value is zero unless a line was finished
5041 and the command on that line reported an error. */
5044 do_spec_1 (const char *spec
, int inswitch
, const char *soft_matched_part
)
5046 const char *p
= spec
;
5051 /* If it's an empty string argument to a switch, keep it as is. */
5052 if (inswitch
&& !*p
)
5056 /* If substituting a switch, treat all chars like letters.
5057 Otherwise, NL, SPC, TAB and % are special. */
5058 switch (inswitch
? 'a' : c
)
5063 if (argbuf
.length () > 0
5064 && !strcmp (argbuf
.last (), "|"))
5066 /* A `|' before the newline means use a pipe here,
5067 but only if -pipe was specified.
5068 Otherwise, execute now and don't pass the `|' as an arg. */
5071 input_from_pipe
= 1;
5078 set_collect_gcc_options ();
5080 if (argbuf
.length () > 0)
5086 /* Reinitialize for a new command, and for a new argument. */
5089 delete_this_arg
= 0;
5090 this_is_output_file
= 0;
5091 this_is_library_file
= 0;
5092 this_is_linker_script
= 0;
5093 input_from_pipe
= 0;
5100 obstack_1grow (&obstack
, c
);
5108 /* Reinitialize for a new argument. */
5109 delete_this_arg
= 0;
5110 this_is_output_file
= 0;
5111 this_is_library_file
= 0;
5112 this_is_linker_script
= 0;
5119 fatal_error (input_location
, "spec %qs invalid", spec
);
5122 if (save_temps_length
)
5123 obstack_grow (&obstack
, save_temps_prefix
, save_temps_length
);
5125 obstack_grow (&obstack
, input_basename
, basename_length
);
5126 if (compare_debug
< 0)
5127 obstack_grow (&obstack
, ".gk", 3);
5132 if (save_temps_length
)
5133 obstack_grow (&obstack
, save_temps_prefix
, save_temps_length
);
5135 obstack_grow (&obstack
, input_basename
, suffixed_basename_length
);
5136 if (compare_debug
< 0)
5137 obstack_grow (&obstack
, ".gk", 3);
5142 delete_this_arg
= 2;
5145 /* Dump out the directories specified with LIBRARY_PATH,
5146 followed by the absolute directories
5147 that we search for startfiles. */
5150 struct spec_path_info info
;
5153 info
.append_len
= 0;
5154 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
5155 /* Used on systems which record the specified -L dirs
5156 and use them to search for dynamic linking.
5157 Relative directories always come from -B,
5158 and it is better not to use them for searching
5159 at run time. In particular, stage1 loses. */
5160 info
.omit_relative
= true;
5162 info
.omit_relative
= false;
5164 info
.separate_options
= false;
5166 for_each_path (&startfile_prefixes
, true, 0, spec_path
, &info
);
5171 /* %efoo means report an error with `foo' as error message
5172 and don't execute any more commands for this file. */
5176 while (*p
!= 0 && *p
!= '\n')
5178 buf
= (char *) alloca (p
- q
+ 1);
5179 strncpy (buf
, q
, p
- q
);
5181 error ("%s", _(buf
));
5186 /* %nfoo means report a notice with `foo' on stderr. */
5190 while (*p
!= 0 && *p
!= '\n')
5192 buf
= (char *) alloca (p
- q
+ 1);
5193 strncpy (buf
, q
, p
- q
);
5195 inform (0, "%s", _(buf
));
5205 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
5206 defined, and it is not a directory, and it is
5207 writable, use it. Otherwise, treat this like any
5208 other temporary file. */
5210 if ((!save_temps_flag
)
5211 && (stat (HOST_BIT_BUCKET
, &st
) == 0) && (!S_ISDIR (st
.st_mode
))
5212 && (access (HOST_BIT_BUCKET
, W_OK
) == 0))
5214 obstack_grow (&obstack
, HOST_BIT_BUCKET
,
5215 strlen (HOST_BIT_BUCKET
));
5216 delete_this_arg
= 0;
5221 goto create_temp_file
;
5225 obstack_1grow (&obstack
, '-');
5226 delete_this_arg
= 0;
5229 /* consume suffix */
5230 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
5232 if (p
[0] == '%' && p
[1] == 'O')
5237 goto create_temp_file
;
5241 /* consume suffix */
5242 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
5244 if (p
[0] == '%' && p
[1] == 'O')
5249 goto create_temp_file
;
5255 struct temp_name
*t
;
5257 const char *suffix
= p
;
5258 char *saved_suffix
= NULL
;
5260 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
5262 suffix_length
= p
- suffix
;
5263 if (p
[0] == '%' && p
[1] == 'O')
5266 /* We don't support extra suffix characters after %O. */
5267 if (*p
== '.' || ISALNUM ((unsigned char) *p
))
5268 fatal_error (input_location
,
5269 "spec %qs has invalid %<%%0%c%>", spec
, *p
);
5270 if (suffix_length
== 0)
5271 suffix
= TARGET_OBJECT_SUFFIX
;
5275 = XNEWVEC (char, suffix_length
5276 + strlen (TARGET_OBJECT_SUFFIX
) + 1);
5277 strncpy (saved_suffix
, suffix
, suffix_length
);
5278 strcpy (saved_suffix
+ suffix_length
,
5279 TARGET_OBJECT_SUFFIX
);
5281 suffix_length
+= strlen (TARGET_OBJECT_SUFFIX
);
5284 if (compare_debug
< 0)
5286 suffix
= concat (".gk", suffix
, NULL
);
5290 /* If -save-temps=obj and -o were specified, use that for the
5292 if (save_temps_length
)
5295 temp_filename_length
5296 = save_temps_length
+ suffix_length
+ 1;
5297 tmp
= (char *) alloca (temp_filename_length
);
5298 memcpy (tmp
, save_temps_prefix
, save_temps_length
);
5299 memcpy (tmp
+ save_temps_length
, suffix
, suffix_length
);
5300 tmp
[save_temps_length
+ suffix_length
] = '\0';
5301 temp_filename
= save_string (tmp
, save_temps_length
5303 obstack_grow (&obstack
, temp_filename
,
5304 temp_filename_length
);
5306 delete_this_arg
= 0;
5310 /* If the gcc_input_filename has the same suffix specified
5311 for the %g, %u, or %U, and -save-temps is specified,
5312 we could end up using that file as an intermediate
5313 thus clobbering the user's source file (.e.g.,
5314 gcc -save-temps foo.s would clobber foo.s with the
5315 output of cpp0). So check for this condition and
5316 generate a temp file as the intermediate. */
5318 if (save_temps_flag
)
5321 temp_filename_length
= basename_length
+ suffix_length
+ 1;
5322 tmp
= (char *) alloca (temp_filename_length
);
5323 memcpy (tmp
, input_basename
, basename_length
);
5324 memcpy (tmp
+ basename_length
, suffix
, suffix_length
);
5325 tmp
[basename_length
+ suffix_length
] = '\0';
5326 temp_filename
= tmp
;
5328 if (filename_cmp (temp_filename
, gcc_input_filename
) != 0)
5330 #ifndef HOST_LACKS_INODE_NUMBERS
5331 struct stat st_temp
;
5333 /* Note, set_input() resets input_stat_set to 0. */
5334 if (input_stat_set
== 0)
5336 input_stat_set
= stat (gcc_input_filename
,
5338 if (input_stat_set
>= 0)
5342 /* If we have the stat for the gcc_input_filename
5343 and we can do the stat for the temp_filename
5344 then the they could still refer to the same
5345 file if st_dev/st_ino's are the same. */
5346 if (input_stat_set
!= 1
5347 || stat (temp_filename
, &st_temp
) < 0
5348 || input_stat
.st_dev
!= st_temp
.st_dev
5349 || input_stat
.st_ino
!= st_temp
.st_ino
)
5351 /* Just compare canonical pathnames. */
5352 char* input_realname
= lrealpath (gcc_input_filename
);
5353 char* temp_realname
= lrealpath (temp_filename
);
5354 bool files_differ
= filename_cmp (input_realname
, temp_realname
);
5355 free (input_realname
);
5356 free (temp_realname
);
5360 temp_filename
= save_string (temp_filename
,
5361 temp_filename_length
+ 1);
5362 obstack_grow (&obstack
, temp_filename
,
5363 temp_filename_length
);
5365 delete_this_arg
= 0;
5371 /* See if we already have an association of %g/%u/%U and
5373 for (t
= temp_names
; t
; t
= t
->next
)
5374 if (t
->length
== suffix_length
5375 && strncmp (t
->suffix
, suffix
, suffix_length
) == 0
5376 && t
->unique
== (c
== 'u' || c
== 'U' || c
== 'j'))
5379 /* Make a new association if needed. %u and %j
5381 if (t
== 0 || c
== 'u' || c
== 'j')
5385 t
= XNEW (struct temp_name
);
5386 t
->next
= temp_names
;
5389 t
->length
= suffix_length
;
5392 t
->suffix
= saved_suffix
;
5393 saved_suffix
= NULL
;
5396 t
->suffix
= save_string (suffix
, suffix_length
);
5397 t
->unique
= (c
== 'u' || c
== 'U' || c
== 'j');
5398 temp_filename
= make_temp_file (t
->suffix
);
5399 temp_filename_length
= strlen (temp_filename
);
5400 t
->filename
= temp_filename
;
5401 t
->filename_length
= temp_filename_length
;
5404 free (saved_suffix
);
5406 obstack_grow (&obstack
, t
->filename
, t
->filename_length
);
5407 delete_this_arg
= 1;
5415 if (at_file_supplied
)
5417 /* We are going to expand `%i' to `@FILE', where FILE
5418 is a newly-created temporary filename. The filenames
5419 that would usually be expanded in place of %o will be
5420 written to the temporary file. */
5425 for (i
= 0; i
< n_infiles
; i
++)
5426 if (compile_input_file_p (&infiles
[i
]))
5429 argv
= (char **) alloca (sizeof (char *) * (n_files
+ 1));
5431 /* Copy the strings over. */
5432 for (i
= 0, j
= 0; i
< n_infiles
; i
++)
5433 if (compile_input_file_p (&infiles
[i
]))
5435 argv
[j
] = CONST_CAST (char *, infiles
[i
].name
);
5436 infiles
[i
].compiled
= true;
5441 create_at_file (argv
);
5444 for (i
= 0; (int) i
< n_infiles
; i
++)
5445 if (compile_input_file_p (&infiles
[i
]))
5447 store_arg (infiles
[i
].name
, 0, 0);
5448 infiles
[i
].compiled
= true;
5453 obstack_grow (&obstack
, gcc_input_filename
,
5454 input_filename_length
);
5461 struct spec_path_info info
;
5465 do_spec_1 ("-imultilib", 1, NULL
);
5466 /* Make this a separate argument. */
5467 do_spec_1 (" ", 0, NULL
);
5468 do_spec_1 (multilib_dir
, 1, NULL
);
5469 do_spec_1 (" ", 0, NULL
);
5474 do_spec_1 ("-imultiarch", 1, NULL
);
5475 /* Make this a separate argument. */
5476 do_spec_1 (" ", 0, NULL
);
5477 do_spec_1 (multiarch_dir
, 1, NULL
);
5478 do_spec_1 (" ", 0, NULL
);
5481 if (gcc_exec_prefix
)
5483 do_spec_1 ("-iprefix", 1, NULL
);
5484 /* Make this a separate argument. */
5485 do_spec_1 (" ", 0, NULL
);
5486 do_spec_1 (gcc_exec_prefix
, 1, NULL
);
5487 do_spec_1 (" ", 0, NULL
);
5490 if (target_system_root_changed
||
5491 (target_system_root
&& target_sysroot_hdrs_suffix
))
5493 do_spec_1 ("-isysroot", 1, NULL
);
5494 /* Make this a separate argument. */
5495 do_spec_1 (" ", 0, NULL
);
5496 do_spec_1 (target_system_root
, 1, NULL
);
5497 if (target_sysroot_hdrs_suffix
)
5498 do_spec_1 (target_sysroot_hdrs_suffix
, 1, NULL
);
5499 do_spec_1 (" ", 0, NULL
);
5502 info
.option
= "-isystem";
5503 info
.append
= "include";
5504 info
.append_len
= strlen (info
.append
);
5505 info
.omit_relative
= false;
5506 info
.separate_options
= true;
5508 for_each_path (&include_prefixes
, false, info
.append_len
,
5511 info
.append
= "include-fixed";
5512 if (*sysroot_hdrs_suffix_spec
)
5513 info
.append
= concat (info
.append
, dir_separator_str
,
5514 multilib_dir
, NULL
);
5515 info
.append_len
= strlen (info
.append
);
5516 for_each_path (&include_prefixes
, false, info
.append_len
,
5523 int max
= n_infiles
;
5524 max
+= lang_specific_extra_outfiles
;
5526 if (HAVE_GNU_LD
&& at_file_supplied
)
5528 /* We are going to expand `%o' to `@FILE', where FILE
5529 is a newly-created temporary filename. The filenames
5530 that would usually be expanded in place of %o will be
5531 written to the temporary file. */
5536 /* Convert OUTFILES into a form suitable for writeargv. */
5538 /* Determine how many are non-NULL. */
5539 for (n_files
= 0, i
= 0; i
< max
; i
++)
5540 n_files
+= outfiles
[i
] != NULL
;
5542 argv
= (char **) alloca (sizeof (char *) * (n_files
+ 1));
5544 /* Copy the strings over. */
5545 for (i
= 0, j
= 0; i
< max
; i
++)
5548 argv
[j
] = CONST_CAST (char *, outfiles
[i
]);
5553 create_at_file (argv
);
5556 for (i
= 0; i
< max
; i
++)
5558 store_arg (outfiles
[i
], 0, 0);
5563 obstack_grow (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
5568 this_is_library_file
= 1;
5572 this_is_linker_script
= 1;
5576 outfiles
[input_file_number
] = NULL
;
5580 this_is_output_file
= 1;
5585 unsigned int cur_index
= argbuf
.length ();
5586 /* Handle the {...} following the %W. */
5588 fatal_error (input_location
,
5589 "spec %qs has invalid %<%%W%c%>", spec
, *p
);
5590 p
= handle_braces (p
+ 1);
5594 /* If any args were output, mark the last one for deletion
5596 if (argbuf
.length () != cur_index
)
5597 record_temp_file (argbuf
.last (), 0, 1);
5601 /* %x{OPTION} records OPTION for %X to output. */
5609 /* Skip past the option value and make a copy. */
5611 fatal_error (input_location
,
5612 "spec %qs has invalid %<%%x%c%>", spec
, *p
);
5615 string
= save_string (p1
+ 1, p
- p1
- 2);
5617 /* See if we already recorded this option. */
5618 FOR_EACH_VEC_ELT (linker_options
, ix
, opt
)
5619 if (! strcmp (string
, opt
))
5625 /* This option is new; add it. */
5626 add_linker_option (string
, strlen (string
));
5631 /* Dump out the options accumulated previously using %x. */
5633 do_specs_vec (linker_options
);
5636 /* Dump out the options accumulated previously using -Wa,. */
5638 do_specs_vec (assembler_options
);
5641 /* Dump out the options accumulated previously using -Wp,. */
5643 do_specs_vec (preprocessor_options
);
5646 /* Here are digits and numbers that just process
5647 a certain constant string as a spec. */
5650 value
= do_spec_1 (cc1_spec
, 0, NULL
);
5656 value
= do_spec_1 (cc1plus_spec
, 0, NULL
);
5662 value
= do_spec_1 (asm_spec
, 0, NULL
);
5668 value
= do_spec_1 (asm_final_spec
, 0, NULL
);
5675 const char *const spec
5676 = (input_file_compiler
->cpp_spec
5677 ? input_file_compiler
->cpp_spec
5679 value
= do_spec_1 (spec
, 0, NULL
);
5686 value
= do_spec_1 (endfile_spec
, 0, NULL
);
5692 value
= do_spec_1 (link_spec
, 0, NULL
);
5698 value
= do_spec_1 (lib_spec
, 0, NULL
);
5704 if (multilib_os_dir
== NULL
)
5705 obstack_1grow (&obstack
, '.');
5707 obstack_grow (&obstack
, multilib_os_dir
,
5708 strlen (multilib_os_dir
));
5712 value
= do_spec_1 (libgcc_spec
, 0, NULL
);
5718 /* We assume there is a directory
5719 separator at the end of this string. */
5720 if (target_system_root
)
5722 obstack_grow (&obstack
, target_system_root
,
5723 strlen (target_system_root
));
5724 if (target_sysroot_suffix
)
5725 obstack_grow (&obstack
, target_sysroot_suffix
,
5726 strlen (target_sysroot_suffix
));
5731 value
= do_spec_1 (startfile_spec
, 0, NULL
);
5736 /* Here we define characters other than letters and digits. */
5739 p
= handle_braces (p
);
5745 p
= handle_spec_function (p
, NULL
);
5751 obstack_1grow (&obstack
, '%');
5758 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '%')
5760 suffix_subst
= save_string (p
- 1, len
+ 1);
5765 /* Henceforth ignore the option(s) matching the pattern
5771 int have_wildcard
= 0;
5776 switch_option
= SWITCH_IGNORE
| SWITCH_KEEP_FOR_GCC
;
5778 switch_option
= SWITCH_IGNORE
;
5780 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '\t')
5783 if (p
[len
-1] == '*')
5786 for (i
= 0; i
< n_switches
; i
++)
5787 if (!strncmp (switches
[i
].part1
, p
, len
- have_wildcard
)
5788 && (have_wildcard
|| switches
[i
].part1
[len
] == '\0'))
5790 switches
[i
].live_cond
|= switch_option
;
5791 /* User switch be validated from validate_all_switches.
5792 when the definition is seen from the spec file.
5793 If not defined anywhere, will be rejected. */
5794 if (switches
[i
].known
)
5795 switches
[i
].validated
= true;
5803 if (soft_matched_part
)
5805 if (soft_matched_part
[0])
5806 do_spec_1 (soft_matched_part
, 1, NULL
);
5807 /* Only insert a space after the substitution if it is at the
5808 end of the current sequence. So if:
5810 "%{foo=*:bar%*}%{foo=*:one%*two}"
5812 matches -foo=hello then it will produce:
5814 barhello onehellotwo
5816 if (*p
== 0 || *p
== '}')
5817 do_spec_1 (" ", 0, NULL
);
5820 /* Catch the case where a spec string contains something like
5821 '%{foo:%*}'. i.e. there is no * in the pattern on the left
5822 hand side of the :. */
5823 error ("spec failure: %<%%*%> has not been initialized by pattern match");
5826 /* Process a string found as the value of a spec given by name.
5827 This feature allows individual machine descriptions
5828 to add and use their own specs. */
5831 const char *name
= p
;
5832 struct spec_list
*sl
;
5835 /* The string after the S/P is the name of a spec that is to be
5837 while (*p
&& *p
!= ')')
5840 /* See if it's in the list. */
5841 for (len
= p
- name
, sl
= specs
; sl
; sl
= sl
->next
)
5842 if (sl
->name_len
== len
&& !strncmp (sl
->name
, name
, len
))
5844 name
= *(sl
->ptr_spec
);
5846 fnotice (stderr
, "Processing spec (%s), which is '%s'\n",
5854 value
= do_spec_1 (name
, 0, NULL
);
5859 /* Discard the closing paren. */
5866 error ("spec failure: unrecognized spec option %qc", c
);
5872 /* Backslash: treat next character as ordinary. */
5877 /* Ordinary character: put it into the current argument. */
5878 obstack_1grow (&obstack
, c
);
5882 /* End of string. If we are processing a spec function, we need to
5883 end any pending argument. */
5884 if (processing_spec_function
)
5890 /* Look up a spec function. */
5892 static const struct spec_function
*
5893 lookup_spec_function (const char *name
)
5895 const struct spec_function
*sf
;
5897 for (sf
= static_spec_functions
; sf
->name
!= NULL
; sf
++)
5898 if (strcmp (sf
->name
, name
) == 0)
5904 /* Evaluate a spec function. */
5907 eval_spec_function (const char *func
, const char *args
)
5909 const struct spec_function
*sf
;
5910 const char *funcval
;
5912 /* Saved spec processing context. */
5913 vec
<const_char_p
> save_argbuf
;
5916 int save_delete_this_arg
;
5917 int save_this_is_output_file
;
5918 int save_this_is_library_file
;
5919 int save_input_from_pipe
;
5920 int save_this_is_linker_script
;
5921 const char *save_suffix_subst
;
5923 int save_growing_size
;
5924 void *save_growing_value
= NULL
;
5926 sf
= lookup_spec_function (func
);
5928 fatal_error (input_location
, "unknown spec function %qs", func
);
5930 /* Push the spec processing context. */
5931 save_argbuf
= argbuf
;
5933 save_arg_going
= arg_going
;
5934 save_delete_this_arg
= delete_this_arg
;
5935 save_this_is_output_file
= this_is_output_file
;
5936 save_this_is_library_file
= this_is_library_file
;
5937 save_this_is_linker_script
= this_is_linker_script
;
5938 save_input_from_pipe
= input_from_pipe
;
5939 save_suffix_subst
= suffix_subst
;
5941 /* If we have some object growing now, finalize it so the args and function
5942 eval proceed from a cleared context. This is needed to prevent the first
5943 constructed arg from mistakenly including the growing value. We'll push
5944 this value back on the obstack once the function evaluation is done, to
5945 restore a consistent processing context for our caller. This is fine as
5946 the address of growing objects isn't guaranteed to remain stable until
5947 they are finalized, and we expect this situation to be rare enough for
5948 the extra copy not to be an issue. */
5949 save_growing_size
= obstack_object_size (&obstack
);
5950 if (save_growing_size
> 0)
5951 save_growing_value
= obstack_finish (&obstack
);
5953 /* Create a new spec processing context, and build the function
5957 if (do_spec_2 (args
) < 0)
5958 fatal_error (input_location
, "error in args to spec function %qs", func
);
5960 /* argbuf_index is an index for the next argument to be inserted, and
5961 so contains the count of the args already inserted. */
5963 funcval
= (*sf
->func
) (argbuf
.length (),
5966 /* Pop the spec processing context. */
5968 argbuf
= save_argbuf
;
5970 arg_going
= save_arg_going
;
5971 delete_this_arg
= save_delete_this_arg
;
5972 this_is_output_file
= save_this_is_output_file
;
5973 this_is_library_file
= save_this_is_library_file
;
5974 this_is_linker_script
= save_this_is_linker_script
;
5975 input_from_pipe
= save_input_from_pipe
;
5976 suffix_subst
= save_suffix_subst
;
5978 if (save_growing_size
> 0)
5979 obstack_grow (&obstack
, save_growing_value
, save_growing_size
);
5984 /* Handle a spec function call of the form:
5988 ARGS is processed as a spec in a separate context and split into an
5989 argument vector in the normal fashion. The function returns a string
5990 containing a spec which we then process in the caller's context, or
5991 NULL if no processing is required.
5993 If RETVAL_NONNULL is not NULL, then store a bool whether function
5994 returned non-NULL. */
5997 handle_spec_function (const char *p
, bool *retval_nonnull
)
6000 const char *endp
, *funcval
;
6003 processing_spec_function
++;
6005 /* Get the function name. */
6006 for (endp
= p
; *endp
!= '\0'; endp
++)
6008 if (*endp
== '(') /* ) */
6010 /* Only allow [A-Za-z0-9], -, and _ in function names. */
6011 if (!ISALNUM (*endp
) && !(*endp
== '-' || *endp
== '_'))
6012 fatal_error (input_location
, "malformed spec function name");
6014 if (*endp
!= '(') /* ) */
6015 fatal_error (input_location
, "no arguments for spec function");
6016 func
= save_string (p
, endp
- p
);
6019 /* Get the arguments. */
6020 for (count
= 0; *endp
!= '\0'; endp
++)
6029 else if (*endp
== '(') /* ) */
6034 fatal_error (input_location
, "malformed spec function arguments");
6035 args
= save_string (p
, endp
- p
);
6038 /* p now points to just past the end of the spec function expression. */
6040 funcval
= eval_spec_function (func
, args
);
6041 if (funcval
!= NULL
&& do_spec_1 (funcval
, 0, NULL
) < 0)
6044 *retval_nonnull
= funcval
!= NULL
;
6049 processing_spec_function
--;
6054 /* Inline subroutine of handle_braces. Returns true if the current
6055 input suffix matches the atom bracketed by ATOM and END_ATOM. */
6057 input_suffix_matches (const char *atom
, const char *end_atom
)
6059 return (input_suffix
6060 && !strncmp (input_suffix
, atom
, end_atom
- atom
)
6061 && input_suffix
[end_atom
- atom
] == '\0');
6064 /* Subroutine of handle_braces. Returns true if the current
6065 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
6067 input_spec_matches (const char *atom
, const char *end_atom
)
6069 return (input_file_compiler
6070 && input_file_compiler
->suffix
6071 && input_file_compiler
->suffix
[0] != '\0'
6072 && !strncmp (input_file_compiler
->suffix
+ 1, atom
,
6074 && input_file_compiler
->suffix
[end_atom
- atom
+ 1] == '\0');
6077 /* Subroutine of handle_braces. Returns true if a switch
6078 matching the atom bracketed by ATOM and END_ATOM appeared on the
6081 switch_matches (const char *atom
, const char *end_atom
, int starred
)
6084 int len
= end_atom
- atom
;
6085 int plen
= starred
? len
: -1;
6087 for (i
= 0; i
< n_switches
; i
++)
6088 if (!strncmp (switches
[i
].part1
, atom
, len
)
6089 && (starred
|| switches
[i
].part1
[len
] == '\0')
6090 && check_live_switch (i
, plen
))
6093 /* Check if a switch with separated form matching the atom.
6094 We check -D and -U switches. */
6095 else if (switches
[i
].args
!= 0)
6097 if ((*switches
[i
].part1
== 'D' || *switches
[i
].part1
== 'U')
6098 && *switches
[i
].part1
== atom
[0])
6100 if (!strncmp (switches
[i
].args
[0], &atom
[1], len
- 1)
6101 && (starred
|| (switches
[i
].part1
[1] == '\0'
6102 && switches
[i
].args
[0][len
- 1] == '\0'))
6103 && check_live_switch (i
, (starred
? 1 : -1)))
6111 /* Inline subroutine of handle_braces. Mark all of the switches which
6112 match ATOM (extends to END_ATOM; STARRED indicates whether there
6113 was a star after the atom) for later processing. */
6115 mark_matching_switches (const char *atom
, const char *end_atom
, int starred
)
6118 int len
= end_atom
- atom
;
6119 int plen
= starred
? len
: -1;
6121 for (i
= 0; i
< n_switches
; i
++)
6122 if (!strncmp (switches
[i
].part1
, atom
, len
)
6123 && (starred
|| switches
[i
].part1
[len
] == '\0')
6124 && check_live_switch (i
, plen
))
6125 switches
[i
].ordering
= 1;
6128 /* Inline subroutine of handle_braces. Process all the currently
6129 marked switches through give_switch, and clear the marks. */
6131 process_marked_switches (void)
6135 for (i
= 0; i
< n_switches
; i
++)
6136 if (switches
[i
].ordering
== 1)
6138 switches
[i
].ordering
= 0;
6143 /* Handle a %{ ... } construct. P points just inside the leading {.
6144 Returns a pointer one past the end of the brace block, or 0
6145 if we call do_spec_1 and that returns -1. */
6148 handle_braces (const char *p
)
6150 const char *atom
, *end_atom
;
6151 const char *d_atom
= NULL
, *d_end_atom
= NULL
;
6152 const char *orig
= p
;
6160 bool a_must_be_last
= false;
6161 bool ordered_set
= false;
6162 bool disjunct_set
= false;
6163 bool disj_matched
= false;
6164 bool disj_starred
= true;
6165 bool n_way_choice
= false;
6166 bool n_way_matched
= false;
6168 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
6175 /* Scan one "atom" (S in the description above of %{}, possibly
6176 with '!', '.', '@', ',', or '*' modifiers). */
6178 a_is_suffix
= false;
6179 a_is_starred
= false;
6180 a_is_negated
= false;
6181 a_is_spectype
= false;
6185 p
++, a_is_negated
= true;
6188 if (*p
== '%' && p
[1] == ':')
6192 p
= handle_spec_function (p
+ 2, &a_matched
);
6197 p
++, a_is_suffix
= true;
6199 p
++, a_is_spectype
= true;
6202 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
6203 || *p
== ',' || *p
== '.' || *p
== '@')
6208 p
++, a_is_starred
= 1;
6215 /* Substitute the switch(es) indicated by the current atom. */
6217 if (disjunct_set
|| n_way_choice
|| a_is_negated
|| a_is_suffix
6218 || a_is_spectype
|| atom
== end_atom
)
6221 mark_matching_switches (atom
, end_atom
, a_is_starred
);
6224 process_marked_switches ();
6228 /* Substitute some text if the current atom appears as a switch
6230 disjunct_set
= true;
6234 if (atom
&& atom
== end_atom
)
6236 if (!n_way_choice
|| disj_matched
|| *p
== '|'
6237 || a_is_negated
|| a_is_suffix
|| a_is_spectype
6241 /* An empty term may appear as the last choice of an
6242 N-way choice set; it means "otherwise". */
6243 a_must_be_last
= true;
6244 disj_matched
= !n_way_matched
;
6245 disj_starred
= false;
6249 if ((a_is_suffix
|| a_is_spectype
) && a_is_starred
)
6253 disj_starred
= false;
6255 /* Don't bother testing this atom if we already have a
6257 if (!disj_matched
&& !n_way_matched
)
6260 /* a_matched is already set by handle_spec_function. */;
6261 else if (a_is_suffix
)
6262 a_matched
= input_suffix_matches (atom
, end_atom
);
6263 else if (a_is_spectype
)
6264 a_matched
= input_spec_matches (atom
, end_atom
);
6266 a_matched
= switch_matches (atom
, end_atom
, a_is_starred
);
6268 if (a_matched
!= a_is_negated
)
6270 disj_matched
= true;
6272 d_end_atom
= end_atom
;
6279 /* Found the body, that is, the text to substitute if the
6280 current disjunction matches. */
6281 p
= process_brace_body (p
+ 1, d_atom
, d_end_atom
, disj_starred
,
6282 disj_matched
&& !n_way_matched
);
6286 /* If we have an N-way choice, reset state for the next
6290 n_way_choice
= true;
6291 n_way_matched
|= disj_matched
;
6292 disj_matched
= false;
6293 disj_starred
= true;
6294 d_atom
= d_end_atom
= NULL
;
6303 while (*p
++ != '}');
6308 fatal_error (input_location
, "braced spec %qs is invalid at %qc", orig
, *p
);
6313 /* Subroutine of handle_braces. Scan and process a brace substitution body
6314 (X in the description of %{} syntax). P points one past the colon;
6315 ATOM and END_ATOM bracket the first atom which was found to be true
6316 (present) in the current disjunction; STARRED indicates whether all
6317 the atoms in the current disjunction were starred (for syntax validation);
6318 MATCHED indicates whether the disjunction matched or not, and therefore
6319 whether or not the body is to be processed through do_spec_1 or just
6320 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
6324 process_brace_body (const char *p
, const char *atom
, const char *end_atom
,
6325 int starred
, int matched
)
6327 const char *body
, *end_body
;
6328 unsigned int nesting_level
;
6329 bool have_subst
= false;
6331 /* Locate the closing } or ;, honoring nested braces.
6332 Trim trailing whitespace. */
6341 if (!--nesting_level
)
6344 else if (*p
== ';' && nesting_level
== 1)
6346 else if (*p
== '%' && p
[1] == '*' && nesting_level
== 1)
6348 else if (*p
== '\0')
6354 while (end_body
[-1] == ' ' || end_body
[-1] == '\t')
6357 if (have_subst
&& !starred
)
6362 /* Copy the substitution body to permanent storage and execute it.
6363 If have_subst is false, this is a simple matter of running the
6364 body through do_spec_1... */
6365 char *string
= save_string (body
, end_body
- body
);
6368 if (do_spec_1 (string
, 0, NULL
) < 0)
6376 /* ... but if have_subst is true, we have to process the
6377 body once for each matching switch, with %* set to the
6378 variant part of the switch. */
6379 unsigned int hard_match_len
= end_atom
- atom
;
6382 for (i
= 0; i
< n_switches
; i
++)
6383 if (!strncmp (switches
[i
].part1
, atom
, hard_match_len
)
6384 && check_live_switch (i
, hard_match_len
))
6386 if (do_spec_1 (string
, 0,
6387 &switches
[i
].part1
[hard_match_len
]) < 0)
6392 /* Pass any arguments this switch has. */
6394 suffix_subst
= NULL
;
6403 fatal_error (input_location
, "braced spec body %qs is invalid", body
);
6406 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
6407 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
6408 spec, or -1 if either exact match or %* is used.
6410 A -O switch is obsoleted by a later -O switch. A -f, -g, -m, or -W switch
6411 whose value does not begin with "no-" is obsoleted by the same value
6412 with the "no-", similarly for a switch with the "no-" prefix. */
6415 check_live_switch (int switchnum
, int prefix_length
)
6417 const char *name
= switches
[switchnum
].part1
;
6420 /* If we already processed this switch and determined if it was
6421 live or not, return our past determination. */
6422 if (switches
[switchnum
].live_cond
!= 0)
6423 return ((switches
[switchnum
].live_cond
& SWITCH_LIVE
) != 0
6424 && (switches
[switchnum
].live_cond
& SWITCH_FALSE
) == 0
6425 && (switches
[switchnum
].live_cond
& SWITCH_IGNORE_PERMANENTLY
)
6428 /* In the common case of {<at-most-one-letter>*}, a negating
6429 switch would always match, so ignore that case. We will just
6430 send the conflicting switches to the compiler phase. */
6431 if (prefix_length
>= 0 && prefix_length
<= 1)
6434 /* Now search for duplicate in a manner that depends on the name. */
6438 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
6439 if (switches
[i
].part1
[0] == 'O')
6441 switches
[switchnum
].validated
= true;
6442 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
6447 case 'W': case 'f': case 'm': case 'g':
6448 if (! strncmp (name
+ 1, "no-", 3))
6450 /* We have Xno-YYY, search for XYYY. */
6451 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
6452 if (switches
[i
].part1
[0] == name
[0]
6453 && ! strcmp (&switches
[i
].part1
[1], &name
[4]))
6455 /* --specs are validated with the validate_switches mechanism. */
6456 if (switches
[switchnum
].known
)
6457 switches
[switchnum
].validated
= true;
6458 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
6464 /* We have XYYY, search for Xno-YYY. */
6465 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
6466 if (switches
[i
].part1
[0] == name
[0]
6467 && switches
[i
].part1
[1] == 'n'
6468 && switches
[i
].part1
[2] == 'o'
6469 && switches
[i
].part1
[3] == '-'
6470 && !strcmp (&switches
[i
].part1
[4], &name
[1]))
6472 /* --specs are validated with the validate_switches mechanism. */
6473 if (switches
[switchnum
].known
)
6474 switches
[switchnum
].validated
= true;
6475 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
6482 /* Otherwise the switch is live. */
6483 switches
[switchnum
].live_cond
|= SWITCH_LIVE
;
6487 /* Pass a switch to the current accumulating command
6488 in the same form that we received it.
6489 SWITCHNUM identifies the switch; it is an index into
6490 the vector of switches gcc received, which is `switches'.
6491 This cannot fail since it never finishes a command line.
6493 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
6496 give_switch (int switchnum
, int omit_first_word
)
6498 if ((switches
[switchnum
].live_cond
& SWITCH_IGNORE
) != 0)
6501 if (!omit_first_word
)
6503 do_spec_1 ("-", 0, NULL
);
6504 do_spec_1 (switches
[switchnum
].part1
, 1, NULL
);
6507 if (switches
[switchnum
].args
!= 0)
6510 for (p
= switches
[switchnum
].args
; *p
; p
++)
6512 const char *arg
= *p
;
6514 do_spec_1 (" ", 0, NULL
);
6517 unsigned length
= strlen (arg
);
6520 while (length
-- && !IS_DIR_SEPARATOR (arg
[length
]))
6521 if (arg
[length
] == '.')
6523 (CONST_CAST (char *, arg
))[length
] = 0;
6527 do_spec_1 (arg
, 1, NULL
);
6529 (CONST_CAST (char *, arg
))[length
] = '.';
6530 do_spec_1 (suffix_subst
, 1, NULL
);
6533 do_spec_1 (arg
, 1, NULL
);
6537 do_spec_1 (" ", 0, NULL
);
6538 switches
[switchnum
].validated
= true;
6541 /* Print GCC configuration (e.g. version, thread model, target,
6542 configuration_arguments) to a given FILE. */
6545 print_configuration (FILE *file
)
6550 fnotice (file
, "Target: %s\n", spec_machine
);
6551 fnotice (file
, "Configured with: %s\n", configuration_arguments
);
6553 #ifdef THREAD_MODEL_SPEC
6554 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
6555 but there's no point in doing all this processing just to get
6556 thread_model back. */
6557 obstack_init (&obstack
);
6558 do_spec_1 (THREAD_MODEL_SPEC
, 0, thread_model
);
6559 obstack_1grow (&obstack
, '\0');
6560 thrmod
= XOBFINISH (&obstack
, const char *);
6562 thrmod
= thread_model
;
6565 fnotice (file
, "Thread model: %s\n", thrmod
);
6567 /* compiler_version is truncated at the first space when initialized
6568 from version string, so truncate version_string at the first space
6569 before comparing. */
6570 for (n
= 0; version_string
[n
]; n
++)
6571 if (version_string
[n
] == ' ')
6574 if (! strncmp (version_string
, compiler_version
, n
)
6575 && compiler_version
[n
] == 0)
6576 fnotice (file
, "gcc version %s %s\n", version_string
,
6579 fnotice (file
, "gcc driver version %s %sexecuting gcc version %s\n",
6580 version_string
, pkgversion_string
, compiler_version
);
6584 #define RETRY_ICE_ATTEMPTS 3
6586 /* Returns true if FILE1 and FILE2 contain equivalent data, 0 otherwise. */
6589 files_equal_p (char *file1
, char *file2
)
6591 struct stat st1
, st2
;
6594 const int bufsize
= 8192;
6595 char *buf
= XNEWVEC (char, bufsize
);
6597 fd1
= open (file1
, O_RDONLY
);
6598 fd2
= open (file2
, O_RDONLY
);
6600 if (fd1
< 0 || fd2
< 0)
6603 if (fstat (fd1
, &st1
) < 0 || fstat (fd2
, &st2
) < 0)
6606 if (st1
.st_size
!= st2
.st_size
)
6609 for (n
= st1
.st_size
; n
; n
-= len
)
6612 if ((int) len
> bufsize
/ 2)
6615 if (read (fd1
, buf
, len
) != (int) len
6616 || read (fd2
, buf
+ bufsize
/ 2, len
) != (int) len
)
6621 if (memcmp (buf
, buf
+ bufsize
/ 2, len
) != 0)
6638 /* Check that compiler's output doesn't differ across runs.
6639 TEMP_STDOUT_FILES and TEMP_STDERR_FILES are arrays of files, containing
6640 stdout and stderr for each compiler run. Return true if all of
6641 TEMP_STDOUT_FILES and TEMP_STDERR_FILES are equivalent. */
6644 check_repro (char **temp_stdout_files
, char **temp_stderr_files
)
6647 for (i
= 0; i
< RETRY_ICE_ATTEMPTS
- 2; ++i
)
6649 if (!files_equal_p (temp_stdout_files
[i
], temp_stdout_files
[i
+ 1])
6650 || !files_equal_p (temp_stderr_files
[i
], temp_stderr_files
[i
+ 1]))
6652 fnotice (stderr
, "The bug is not reproducible, so it is"
6653 " likely a hardware or OS problem.\n");
6657 return i
== RETRY_ICE_ATTEMPTS
- 2;
6660 enum attempt_status
{
6661 ATTEMPT_STATUS_FAIL_TO_RUN
,
6662 ATTEMPT_STATUS_SUCCESS
,
6667 /* Run compiler with arguments NEW_ARGV to reproduce the ICE, storing stdout
6668 to OUT_TEMP and stderr to ERR_TEMP. If APPEND is TRUE, append to OUT_TEMP
6669 and ERR_TEMP instead of truncating. If EMIT_SYSTEM_INFO is TRUE, also write
6670 GCC configuration into to ERR_TEMP. Return ATTEMPT_STATUS_FAIL_TO_RUN if
6671 compiler failed to run, ATTEMPT_STATUS_ICE if compiled ICE-ed and
6672 ATTEMPT_STATUS_SUCCESS otherwise. */
6674 static enum attempt_status
6675 run_attempt (const char **new_argv
, const char *out_temp
,
6676 const char *err_temp
, int emit_system_info
, int append
)
6679 if (emit_system_info
)
6681 FILE *file_out
= fopen (err_temp
, "a");
6682 print_configuration (file_out
);
6683 fputs ("\n", file_out
);
6689 struct pex_obj
*pex
;
6691 int pex_flags
= PEX_USE_PIPES
| PEX_LAST
;
6692 enum attempt_status status
= ATTEMPT_STATUS_FAIL_TO_RUN
;
6695 pex_flags
|= PEX_STDOUT_APPEND
| PEX_STDERR_APPEND
;
6697 pex
= pex_init (PEX_USE_PIPES
, new_argv
[0], NULL
);
6699 fatal_error (input_location
, "pex_init failed: %m");
6701 errmsg
= pex_run (pex
, pex_flags
, new_argv
[0],
6702 CONST_CAST2 (char *const *, const char **, &new_argv
[1]), out_temp
,
6707 fatal_error (input_location
, errmsg
);
6711 pfatal_with_name (errmsg
);
6715 if (!pex_get_status (pex
, 1, &exit_status
))
6718 switch (WEXITSTATUS (exit_status
))
6721 status
= ATTEMPT_STATUS_ICE
;
6724 case SUCCESS_EXIT_CODE
:
6725 status
= ATTEMPT_STATUS_SUCCESS
;
6737 /* This routine reads lines from IN file, adds C++ style comments
6738 at the begining of each line and writes result into OUT. */
6741 insert_comments (const char *file_in
, const char *file_out
)
6743 FILE *in
= fopen (file_in
, "rb");
6744 FILE *out
= fopen (file_out
, "wb");
6747 bool add_comment
= true;
6748 while (fgets (line
, sizeof (line
), in
))
6753 add_comment
= strchr (line
, '\n') != NULL
;
6760 /* This routine adds preprocessed source code into the given ERR_FILE.
6761 To do this, it adds "-E" to NEW_ARGV and execute RUN_ATTEMPT routine to
6762 add information in report file. RUN_ATTEMPT should return
6763 ATTEMPT_STATUS_SUCCESS, in other case we cannot generate the report. */
6766 do_report_bug (const char **new_argv
, const int nargs
,
6767 char **out_file
, char **err_file
)
6770 int fd
= open (*out_file
, O_RDWR
| O_APPEND
);
6773 write (fd
, "\n//", 3);
6774 for (i
= 0; i
< nargs
; i
++)
6777 write (fd
, new_argv
[i
], strlen (new_argv
[i
]));
6779 write (fd
, "\n\n", 2);
6781 new_argv
[nargs
] = "-E";
6782 new_argv
[nargs
+ 1] = NULL
;
6784 status
= run_attempt (new_argv
, *out_file
, *err_file
, 0, 1);
6786 if (status
== ATTEMPT_STATUS_SUCCESS
)
6788 fnotice (stderr
, "Preprocessed source stored into %s file,"
6789 " please attach this to your bugreport.\n", *out_file
);
6790 /* Make sure it is not deleted. */
6796 /* Try to reproduce ICE. If bug is reproducible, generate report .err file
6797 containing GCC configuration, backtrace, compiler's command line options
6798 and preprocessed source code. */
6801 try_generate_repro (const char **argv
)
6803 int i
, nargs
, out_arg
= -1, quiet
= 0, attempt
;
6804 const char **new_argv
;
6805 char *temp_files
[RETRY_ICE_ATTEMPTS
* 2];
6806 char **temp_stdout_files
= &temp_files
[0];
6807 char **temp_stderr_files
= &temp_files
[RETRY_ICE_ATTEMPTS
];
6809 if (gcc_input_filename
== NULL
|| ! strcmp (gcc_input_filename
, "-"))
6812 for (nargs
= 0; argv
[nargs
] != NULL
; ++nargs
)
6813 /* Only retry compiler ICEs, not preprocessor ones. */
6814 if (! strcmp (argv
[nargs
], "-E"))
6816 else if (argv
[nargs
][0] == '-' && argv
[nargs
][1] == 'o')
6823 /* If the compiler is going to output any time information,
6824 it might varry between invocations. */
6825 else if (! strcmp (argv
[nargs
], "-quiet"))
6827 else if (! strcmp (argv
[nargs
], "-ftime-report"))
6830 if (out_arg
== -1 || !quiet
)
6833 memset (temp_files
, '\0', sizeof (temp_files
));
6834 new_argv
= XALLOCAVEC (const char *, nargs
+ 4);
6835 memcpy (new_argv
, argv
, (nargs
+ 1) * sizeof (const char *));
6836 new_argv
[nargs
++] = "-frandom-seed=0";
6837 new_argv
[nargs
++] = "-fdump-noaddr";
6838 new_argv
[nargs
] = NULL
;
6839 if (new_argv
[out_arg
][2] == '\0')
6840 new_argv
[out_arg
+ 1] = "-";
6842 new_argv
[out_arg
] = "-o-";
6845 for (attempt
= 0; attempt
< RETRY_ICE_ATTEMPTS
; ++attempt
)
6847 int emit_system_info
= 0;
6849 temp_stdout_files
[attempt
] = make_temp_file (".out");
6850 temp_stderr_files
[attempt
] = make_temp_file (".err");
6852 if (attempt
== RETRY_ICE_ATTEMPTS
- 1)
6855 emit_system_info
= 1;
6858 status
= run_attempt (new_argv
, temp_stdout_files
[attempt
],
6859 temp_stderr_files
[attempt
], emit_system_info
,
6862 if (status
!= ATTEMPT_STATUS_ICE
)
6864 fnotice (stderr
, "The bug is not reproducible, so it is"
6865 " likely a hardware or OS problem.\n");
6870 if (!check_repro (temp_stdout_files
, temp_stderr_files
))
6874 /* Insert commented out backtrace into report file. */
6875 char **stderr_commented
= &temp_stdout_files
[RETRY_ICE_ATTEMPTS
- 1];
6876 insert_comments (temp_stderr_files
[RETRY_ICE_ATTEMPTS
- 1],
6879 /* In final attempt we append compiler options and preprocesssed code to last
6880 generated .out file with configuration and backtrace. */
6881 char **output
= &temp_stdout_files
[RETRY_ICE_ATTEMPTS
- 1];
6882 do_report_bug (new_argv
, nargs
, stderr_commented
, output
);
6886 for (i
= 0; i
< RETRY_ICE_ATTEMPTS
* 2; i
++)
6889 unlink (temp_stdout_files
[i
]);
6890 free (temp_stdout_files
[i
]);
6894 /* Search for a file named NAME trying various prefixes including the
6895 user's -B prefix and some standard ones.
6896 Return the absolute file name found. If nothing is found, return NAME. */
6899 find_file (const char *name
)
6901 char *newname
= find_a_file (&startfile_prefixes
, name
, R_OK
, true);
6902 return newname
? newname
: name
;
6905 /* Determine whether a directory exists. If LINKER, return 0 for
6906 certain fixed names not needed by the linker. */
6909 is_directory (const char *path1
, bool linker
)
6916 /* Ensure the string ends with "/.". The resulting path will be a
6917 directory even if the given path is a symbolic link. */
6918 len1
= strlen (path1
);
6919 path
= (char *) alloca (3 + len1
);
6920 memcpy (path
, path1
, len1
);
6922 if (!IS_DIR_SEPARATOR (cp
[-1]))
6923 *cp
++ = DIR_SEPARATOR
;
6927 /* Exclude directories that the linker is known to search. */
6929 && IS_DIR_SEPARATOR (path
[0])
6931 && filename_ncmp (path
+ 1, "lib", 3) == 0)
6933 && filename_ncmp (path
+ 1, "usr", 3) == 0
6934 && IS_DIR_SEPARATOR (path
[4])
6935 && filename_ncmp (path
+ 5, "lib", 3) == 0)))
6938 return (stat (path
, &st
) >= 0 && S_ISDIR (st
.st_mode
));
6941 /* Set up the various global variables to indicate that we're processing
6942 the input file named FILENAME. */
6945 set_input (const char *filename
)
6949 gcc_input_filename
= filename
;
6950 input_filename_length
= strlen (gcc_input_filename
);
6951 input_basename
= lbasename (gcc_input_filename
);
6953 /* Find a suffix starting with the last period,
6954 and set basename_length to exclude that suffix. */
6955 basename_length
= strlen (input_basename
);
6956 suffixed_basename_length
= basename_length
;
6957 p
= input_basename
+ basename_length
;
6958 while (p
!= input_basename
&& *p
!= '.')
6960 if (*p
== '.' && p
!= input_basename
)
6962 basename_length
= p
- input_basename
;
6963 input_suffix
= p
+ 1;
6968 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
6969 we will need to do a stat on the gcc_input_filename. The
6970 INPUT_STAT_SET signals that the stat is needed. */
6974 /* On fatal signals, delete all the temporary files. */
6977 fatal_signal (int signum
)
6979 signal (signum
, SIG_DFL
);
6980 delete_failure_queue ();
6981 delete_temp_files ();
6982 /* Get the same signal again, this time not handled,
6983 so its normal effect occurs. */
6984 kill (getpid (), signum
);
6987 /* Compare the contents of the two files named CMPFILE[0] and
6988 CMPFILE[1]. Return zero if they're identical, nonzero
6992 compare_files (char *cmpfile
[])
6995 FILE *temp
[2] = { NULL
, NULL
};
7001 void *map
[2] = { NULL
, NULL
};
7003 for (i
= 0; i
< 2; i
++)
7007 if (stat (cmpfile
[i
], &st
) < 0 || !S_ISREG (st
.st_mode
))
7009 error ("%s: could not determine length of compare-debug file %s",
7010 gcc_input_filename
, cmpfile
[i
]);
7015 length
[i
] = st
.st_size
;
7018 if (!ret
&& length
[0] != length
[1])
7020 error ("%s: -fcompare-debug failure (length)", gcc_input_filename
);
7025 for (i
= 0; i
< 2; i
++)
7027 int fd
= open (cmpfile
[i
], O_RDONLY
);
7030 error ("%s: could not open compare-debug file %s",
7031 gcc_input_filename
, cmpfile
[i
]);
7036 map
[i
] = mmap (NULL
, length
[i
], PROT_READ
, MAP_PRIVATE
, fd
, 0);
7039 if (map
[i
] == (void *) MAP_FAILED
)
7048 if (memcmp (map
[0], map
[1], length
[0]) != 0)
7050 error ("%s: -fcompare-debug failure", gcc_input_filename
);
7055 for (i
= 0; i
< 2; i
++)
7057 munmap ((caddr_t
) map
[i
], length
[i
]);
7066 for (i
= 0; i
< 2; i
++)
7068 temp
[i
] = fopen (cmpfile
[i
], "r");
7071 error ("%s: could not open compare-debug file %s",
7072 gcc_input_filename
, cmpfile
[i
]);
7078 if (!ret
&& temp
[0] && temp
[1])
7082 c0
= fgetc (temp
[0]);
7083 c1
= fgetc (temp
[1]);
7087 error ("%s: -fcompare-debug failure",
7088 gcc_input_filename
);
7097 for (i
= 1; i
>= 0; i
--)
7106 driver::driver (bool can_finalize
, bool debug
) :
7107 explicit_link_files (NULL
),
7108 decoded_options (NULL
)
7110 env
.init (can_finalize
, debug
);
7115 XDELETEVEC (explicit_link_files
);
7116 XDELETEVEC (decoded_options
);
7119 /* driver::main is implemented as a series of driver:: method calls. */
7122 driver::main (int argc
, char **argv
)
7126 set_progname (argv
[0]);
7127 expand_at_files (&argc
, &argv
);
7128 decode_argv (argc
, const_cast <const char **> (argv
));
7129 global_initializations ();
7130 build_multilib_strings ();
7132 putenv_COLLECT_GCC (argv
[0]);
7133 maybe_putenv_COLLECT_LTO_WRAPPER ();
7134 maybe_putenv_OFFLOAD_TARGETS ();
7135 handle_unrecognized_options ();
7137 if (!maybe_print_and_exit ())
7140 early_exit
= prepare_infiles ();
7142 return get_exit_code ();
7144 do_spec_on_infiles ();
7145 maybe_run_linker (argv
[0]);
7147 return get_exit_code ();
7150 /* Locate the final component of argv[0] after any leading path, and set
7151 the program name accordingly. */
7154 driver::set_progname (const char *argv0
) const
7156 const char *p
= argv0
+ strlen (argv0
);
7157 while (p
!= argv0
&& !IS_DIR_SEPARATOR (p
[-1]))
7161 xmalloc_set_program_name (progname
);
7164 /* Expand any @ files within the command-line args,
7165 setting at_file_supplied if any were expanded. */
7168 driver::expand_at_files (int *argc
, char ***argv
) const
7170 char **old_argv
= *argv
;
7172 expandargv (argc
, argv
);
7174 /* Determine if any expansions were made. */
7175 if (*argv
!= old_argv
)
7176 at_file_supplied
= true;
7179 /* Decode the command-line arguments from argc/argv into the
7180 decoded_options array. */
7183 driver::decode_argv (int argc
, const char **argv
)
7185 /* Register the language-independent parameters. */
7186 global_init_params ();
7189 init_options_struct (&global_options
, &global_options_set
);
7191 decode_cmdline_options_to_array (argc
, argv
,
7193 &decoded_options
, &decoded_options_count
);
7196 /* Perform various initializations and setup. */
7199 driver::global_initializations ()
7201 /* Unlock the stdio streams. */
7202 unlock_std_streams ();
7204 gcc_init_libintl ();
7206 diagnostic_initialize (global_dc
, 0);
7207 diagnostic_color_init (global_dc
);
7209 #ifdef GCC_DRIVER_HOST_INITIALIZATION
7210 /* Perform host dependent initialization when needed. */
7211 GCC_DRIVER_HOST_INITIALIZATION
;
7214 if (atexit (delete_temp_files
) != 0)
7215 fatal_error (input_location
, "atexit failed");
7217 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
7218 signal (SIGINT
, fatal_signal
);
7220 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
7221 signal (SIGHUP
, fatal_signal
);
7223 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
7224 signal (SIGTERM
, fatal_signal
);
7226 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
7227 signal (SIGPIPE
, fatal_signal
);
7230 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
7231 receive the signal. A different setting is inheritable */
7232 signal (SIGCHLD
, SIG_DFL
);
7235 /* Parsing and gimplification sometimes need quite large stack.
7236 Increase stack size limits if possible. */
7237 stack_limit_increase (64 * 1024 * 1024);
7239 /* Allocate the argument vector. */
7242 obstack_init (&obstack
);
7245 /* Build multilib_select, et. al from the separate lines that make up each
7246 multilib selection. */
7249 driver::build_multilib_strings () const
7253 const char *const *q
= multilib_raw
;
7256 obstack_init (&multilib_obstack
);
7257 while ((p
= *q
++) != (char *) 0)
7258 obstack_grow (&multilib_obstack
, p
, strlen (p
));
7260 obstack_1grow (&multilib_obstack
, 0);
7261 multilib_select
= XOBFINISH (&multilib_obstack
, const char *);
7263 q
= multilib_matches_raw
;
7264 while ((p
= *q
++) != (char *) 0)
7265 obstack_grow (&multilib_obstack
, p
, strlen (p
));
7267 obstack_1grow (&multilib_obstack
, 0);
7268 multilib_matches
= XOBFINISH (&multilib_obstack
, const char *);
7270 q
= multilib_exclusions_raw
;
7271 while ((p
= *q
++) != (char *) 0)
7272 obstack_grow (&multilib_obstack
, p
, strlen (p
));
7274 obstack_1grow (&multilib_obstack
, 0);
7275 multilib_exclusions
= XOBFINISH (&multilib_obstack
, const char *);
7277 q
= multilib_reuse_raw
;
7278 while ((p
= *q
++) != (char *) 0)
7279 obstack_grow (&multilib_obstack
, p
, strlen (p
));
7281 obstack_1grow (&multilib_obstack
, 0);
7282 multilib_reuse
= XOBFINISH (&multilib_obstack
, const char *);
7285 for (size_t i
= 0; i
< ARRAY_SIZE (multilib_defaults_raw
); i
++)
7288 obstack_1grow (&multilib_obstack
, ' ');
7289 obstack_grow (&multilib_obstack
,
7290 multilib_defaults_raw
[i
],
7291 strlen (multilib_defaults_raw
[i
]));
7295 obstack_1grow (&multilib_obstack
, 0);
7296 multilib_defaults
= XOBFINISH (&multilib_obstack
, const char *);
7300 /* Set up the spec-handling machinery. */
7303 driver::set_up_specs () const
7305 const char *spec_machine_suffix
;
7309 #ifdef INIT_ENVIRONMENT
7310 /* Set up any other necessary machine specific environment variables. */
7311 xputenv (INIT_ENVIRONMENT
);
7314 /* Make a table of what switches there are (switches, n_switches).
7315 Make a table of specified input files (infiles, n_infiles).
7316 Decode switches that are handled locally. */
7318 process_command (decoded_options_count
, decoded_options
);
7320 /* Initialize the vector of specs to just the default.
7321 This means one element containing 0s, as a terminator. */
7323 compilers
= XNEWVAR (struct compiler
, sizeof default_compilers
);
7324 memcpy (compilers
, default_compilers
, sizeof default_compilers
);
7325 n_compilers
= n_default_compilers
;
7327 /* Read specs from a file if there is one. */
7329 machine_suffix
= concat (spec_host_machine
, dir_separator_str
, spec_version
,
7330 accel_dir_suffix
, dir_separator_str
, NULL
);
7331 just_machine_suffix
= concat (spec_machine
, dir_separator_str
, NULL
);
7333 specs_file
= find_a_file (&startfile_prefixes
, "specs", R_OK
, true);
7334 /* Read the specs file unless it is a default one. */
7335 if (specs_file
!= 0 && strcmp (specs_file
, "specs"))
7336 read_specs (specs_file
, true, false);
7340 #ifdef ACCEL_COMPILER
7341 spec_machine_suffix
= machine_suffix
;
7343 spec_machine_suffix
= just_machine_suffix
;
7346 /* We need to check standard_exec_prefix/spec_machine_suffix/specs
7347 for any override of as, ld and libraries. */
7348 specs_file
= (char *) alloca (strlen (standard_exec_prefix
)
7349 + strlen (spec_machine_suffix
) + sizeof ("specs"));
7350 strcpy (specs_file
, standard_exec_prefix
);
7351 strcat (specs_file
, spec_machine_suffix
);
7352 strcat (specs_file
, "specs");
7353 if (access (specs_file
, R_OK
) == 0)
7354 read_specs (specs_file
, true, false);
7356 /* Process any configure-time defaults specified for the command line
7357 options, via OPTION_DEFAULT_SPECS. */
7358 for (i
= 0; i
< ARRAY_SIZE (option_default_specs
); i
++)
7359 do_option_spec (option_default_specs
[i
].name
,
7360 option_default_specs
[i
].spec
);
7362 /* Process DRIVER_SELF_SPECS, adding any new options to the end
7363 of the command line. */
7365 for (i
= 0; i
< ARRAY_SIZE (driver_self_specs
); i
++)
7366 do_self_spec (driver_self_specs
[i
]);
7368 /* If not cross-compiling, look for executables in the standard
7370 if (*cross_compile
== '0')
7372 if (*md_exec_prefix
)
7374 add_prefix (&exec_prefixes
, md_exec_prefix
, "GCC",
7375 PREFIX_PRIORITY_LAST
, 0, 0);
7379 /* Process sysroot_suffix_spec. */
7380 if (*sysroot_suffix_spec
!= 0
7381 && !no_sysroot_suffix
7382 && do_spec_2 (sysroot_suffix_spec
) == 0)
7384 if (argbuf
.length () > 1)
7385 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
7386 else if (argbuf
.length () == 1)
7387 target_sysroot_suffix
= xstrdup (argbuf
.last ());
7390 #ifdef HAVE_LD_SYSROOT
7391 /* Pass the --sysroot option to the linker, if it supports that. If
7392 there is a sysroot_suffix_spec, it has already been processed by
7393 this point, so target_system_root really is the system root we
7395 if (target_system_root
)
7397 obstack_grow (&obstack
, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
7398 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
7399 set_spec ("link", XOBFINISH (&obstack
, const char *), false);
7403 /* Process sysroot_hdrs_suffix_spec. */
7404 if (*sysroot_hdrs_suffix_spec
!= 0
7405 && !no_sysroot_suffix
7406 && do_spec_2 (sysroot_hdrs_suffix_spec
) == 0)
7408 if (argbuf
.length () > 1)
7409 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
7410 else if (argbuf
.length () == 1)
7411 target_sysroot_hdrs_suffix
= xstrdup (argbuf
.last ());
7414 /* Look for startfiles in the standard places. */
7415 if (*startfile_prefix_spec
!= 0
7416 && do_spec_2 (startfile_prefix_spec
) == 0
7417 && do_spec_1 (" ", 0, NULL
) == 0)
7421 FOR_EACH_VEC_ELT (argbuf
, ndx
, arg
)
7422 add_sysrooted_prefix (&startfile_prefixes
, arg
, "BINUTILS",
7423 PREFIX_PRIORITY_LAST
, 0, 1);
7425 /* We should eventually get rid of all these and stick to
7426 startfile_prefix_spec exclusively. */
7427 else if (*cross_compile
== '0' || target_system_root
)
7429 if (*md_startfile_prefix
)
7430 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix
,
7431 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
7433 if (*md_startfile_prefix_1
)
7434 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix_1
,
7435 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
7437 /* If standard_startfile_prefix is relative, base it on
7438 standard_exec_prefix. This lets us move the installed tree
7439 as a unit. If GCC_EXEC_PREFIX is defined, base
7440 standard_startfile_prefix on that as well.
7442 If the prefix is relative, only search it for native compilers;
7443 otherwise we will search a directory containing host libraries. */
7444 if (IS_ABSOLUTE_PATH (standard_startfile_prefix
))
7445 add_sysrooted_prefix (&startfile_prefixes
,
7446 standard_startfile_prefix
, "BINUTILS",
7447 PREFIX_PRIORITY_LAST
, 0, 1);
7448 else if (*cross_compile
== '0')
7450 add_prefix (&startfile_prefixes
,
7451 concat (gcc_exec_prefix
7452 ? gcc_exec_prefix
: standard_exec_prefix
,
7454 standard_startfile_prefix
, NULL
),
7455 NULL
, PREFIX_PRIORITY_LAST
, 0, 1);
7458 /* Sysrooted prefixes are relocated because target_system_root is
7459 also relocated by gcc_exec_prefix. */
7460 if (*standard_startfile_prefix_1
)
7461 add_sysrooted_prefix (&startfile_prefixes
,
7462 standard_startfile_prefix_1
, "BINUTILS",
7463 PREFIX_PRIORITY_LAST
, 0, 1);
7464 if (*standard_startfile_prefix_2
)
7465 add_sysrooted_prefix (&startfile_prefixes
,
7466 standard_startfile_prefix_2
, "BINUTILS",
7467 PREFIX_PRIORITY_LAST
, 0, 1);
7470 /* Process any user specified specs in the order given on the command
7472 for (struct user_specs
*uptr
= user_specs_head
; uptr
; uptr
= uptr
->next
)
7474 char *filename
= find_a_file (&startfile_prefixes
, uptr
->filename
,
7476 read_specs (filename
? filename
: uptr
->filename
, false, true);
7479 /* Process any user self specs. */
7481 struct spec_list
*sl
;
7482 for (sl
= specs
; sl
; sl
= sl
->next
)
7483 if (sl
->name_len
== sizeof "self_spec" - 1
7484 && !strcmp (sl
->name
, "self_spec"))
7485 do_self_spec (*sl
->ptr_spec
);
7490 enum save_temps save
;
7492 if (!compare_debug_second
)
7494 n_switches_debug_check
[1] = n_switches
;
7495 n_switches_alloc_debug_check
[1] = n_switches_alloc
;
7496 switches_debug_check
[1] = XDUPVEC (struct switchstr
, switches
,
7499 do_self_spec ("%:compare-debug-self-opt()");
7500 n_switches_debug_check
[0] = n_switches
;
7501 n_switches_alloc_debug_check
[0] = n_switches_alloc
;
7502 switches_debug_check
[0] = switches
;
7504 n_switches
= n_switches_debug_check
[1];
7505 n_switches_alloc
= n_switches_alloc_debug_check
[1];
7506 switches
= switches_debug_check
[1];
7509 /* Avoid crash when computing %j in this early. */
7510 save
= save_temps_flag
;
7511 save_temps_flag
= SAVE_TEMPS_NONE
;
7513 compare_debug
= -compare_debug
;
7514 do_self_spec ("%:compare-debug-self-opt()");
7516 save_temps_flag
= save
;
7518 if (!compare_debug_second
)
7520 n_switches_debug_check
[1] = n_switches
;
7521 n_switches_alloc_debug_check
[1] = n_switches_alloc
;
7522 switches_debug_check
[1] = switches
;
7523 compare_debug
= -compare_debug
;
7524 n_switches
= n_switches_debug_check
[0];
7525 n_switches_alloc
= n_switches_debug_check
[0];
7526 switches
= switches_debug_check
[0];
7531 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
7532 if (gcc_exec_prefix
)
7533 gcc_exec_prefix
= concat (gcc_exec_prefix
, spec_host_machine
,
7534 dir_separator_str
, spec_version
,
7535 accel_dir_suffix
, dir_separator_str
, NULL
);
7537 /* Now we have the specs.
7538 Set the `valid' bits for switches that match anything in any spec. */
7540 validate_all_switches ();
7542 /* Now that we have the switches and the specs, set
7543 the subdirectory based on the options. */
7544 set_multilib_dir ();
7547 /* Set up to remember the pathname of gcc and any options
7548 needed for collect. We use argv[0] instead of progname because
7549 we need the complete pathname. */
7552 driver::putenv_COLLECT_GCC (const char *argv0
) const
7554 obstack_init (&collect_obstack
);
7555 obstack_grow (&collect_obstack
, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
7556 obstack_grow (&collect_obstack
, argv0
, strlen (argv0
) + 1);
7557 xputenv (XOBFINISH (&collect_obstack
, char *));
7560 /* Set up to remember the pathname of the lto wrapper. */
7563 driver::maybe_putenv_COLLECT_LTO_WRAPPER () const
7565 char *lto_wrapper_file
;
7568 lto_wrapper_file
= NULL
;
7570 lto_wrapper_file
= find_a_file (&exec_prefixes
, "lto-wrapper",
7572 if (lto_wrapper_file
)
7574 lto_wrapper_file
= convert_white_space (lto_wrapper_file
);
7575 lto_wrapper_spec
= lto_wrapper_file
;
7576 obstack_init (&collect_obstack
);
7577 obstack_grow (&collect_obstack
, "COLLECT_LTO_WRAPPER=",
7578 sizeof ("COLLECT_LTO_WRAPPER=") - 1);
7579 obstack_grow (&collect_obstack
, lto_wrapper_spec
,
7580 strlen (lto_wrapper_spec
) + 1);
7581 xputenv (XOBFINISH (&collect_obstack
, char *));
7586 /* Set up to remember the names of offload targets. */
7589 driver::maybe_putenv_OFFLOAD_TARGETS () const
7591 if (offload_targets
&& offload_targets
[0] != '\0')
7593 obstack_grow (&collect_obstack
, "OFFLOAD_TARGET_NAMES=",
7594 sizeof ("OFFLOAD_TARGET_NAMES=") - 1);
7595 obstack_grow (&collect_obstack
, offload_targets
,
7596 strlen (offload_targets
) + 1);
7597 xputenv (XOBFINISH (&collect_obstack
, char *));
7600 free (offload_targets
);
7601 offload_targets
= NULL
;
7604 /* Reject switches that no pass was interested in. */
7607 driver::handle_unrecognized_options () const
7609 for (size_t i
= 0; (int) i
< n_switches
; i
++)
7610 if (! switches
[i
].validated
)
7611 error ("unrecognized command line option %<-%s%>", switches
[i
].part1
);
7614 /* Handle the various -print-* options, returning 0 if the driver
7615 should exit, or nonzero if the driver should continue. */
7618 driver::maybe_print_and_exit () const
7620 if (print_search_dirs
)
7622 printf (_("install: %s%s\n"),
7623 gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
7624 gcc_exec_prefix
? "" : machine_suffix
);
7625 printf (_("programs: %s\n"),
7626 build_search_list (&exec_prefixes
, "", false, false));
7627 printf (_("libraries: %s\n"),
7628 build_search_list (&startfile_prefixes
, "", false, true));
7632 if (print_file_name
)
7634 printf ("%s\n", find_file (print_file_name
));
7638 if (print_prog_name
)
7640 if (use_ld
!= NULL
&& ! strcmp (print_prog_name
, "ld"))
7642 /* Append USE_LD to the default linker. */
7643 #ifdef DEFAULT_LINKER
7645 # ifdef HAVE_HOST_EXECUTABLE_SUFFIX
7646 int len
= (sizeof (DEFAULT_LINKER
)
7647 - sizeof (HOST_EXECUTABLE_SUFFIX
));
7651 char *default_linker
= xstrdup (DEFAULT_LINKER
);
7652 /* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains
7653 HOST_EXECUTABLE_SUFFIX. */
7654 if (! strcmp (&default_linker
[len
], HOST_EXECUTABLE_SUFFIX
))
7656 default_linker
[len
] = '\0';
7657 ld
= concat (default_linker
, use_ld
,
7658 HOST_EXECUTABLE_SUFFIX
, NULL
);
7663 ld
= concat (DEFAULT_LINKER
, use_ld
, NULL
);
7664 if (access (ld
, X_OK
) == 0)
7666 printf ("%s\n", ld
);
7670 print_prog_name
= concat (print_prog_name
, use_ld
, NULL
);
7672 char *newname
= find_a_file (&exec_prefixes
, print_prog_name
, X_OK
, 0);
7673 printf ("%s\n", (newname
? newname
: print_prog_name
));
7677 if (print_multi_lib
)
7679 print_multilib_info ();
7683 if (print_multi_directory
)
7685 if (multilib_dir
== NULL
)
7688 printf ("%s\n", multilib_dir
);
7692 if (print_multiarch
)
7694 if (multiarch_dir
== NULL
)
7697 printf ("%s\n", multiarch_dir
);
7703 if (target_system_root
)
7705 if (target_sysroot_suffix
)
7706 printf ("%s%s\n", target_system_root
, target_sysroot_suffix
);
7708 printf ("%s\n", target_system_root
);
7713 if (print_multi_os_directory
)
7715 if (multilib_os_dir
== NULL
)
7718 printf ("%s\n", multilib_os_dir
);
7722 if (print_sysroot_headers_suffix
)
7724 if (*sysroot_hdrs_suffix_spec
)
7726 printf("%s\n", (target_sysroot_hdrs_suffix
7727 ? target_sysroot_hdrs_suffix
7732 /* The error status indicates that only one set of fixed
7733 headers should be built. */
7734 fatal_error (input_location
,
7735 "not configured with sysroot headers suffix");
7738 if (print_help_list
)
7744 printf (_("\nFor bug reporting instructions, please see:\n"));
7745 printf ("%s.\n", bug_report_url
);
7750 /* We do not exit here. Instead we have created a fake input file
7751 called 'help-dummy' which needs to be compiled, and we pass this
7752 on the various sub-processes, along with the --help switch.
7753 Ensure their output appears after ours. */
7754 fputc ('\n', stdout
);
7760 printf (_("%s %s%s\n"), progname
, pkgversion_string
,
7762 printf ("Copyright %s 2015 Free Software Foundation, Inc.\n",
7764 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
7765 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
7770 /* We do not exit here. We use the same mechanism of --help to print
7771 the version of the sub-processes. */
7772 fputc ('\n', stdout
);
7778 print_configuration (stderr
);
7786 /* Figure out what to do with each input file.
7787 Return true if we need to exit early from "main", false otherwise. */
7790 driver::prepare_infiles ()
7793 int lang_n_infiles
= 0;
7795 if (n_infiles
== added_libraries
)
7796 fatal_error (input_location
, "no input files");
7799 /* Early exit needed from main. */
7802 /* Make a place to record the compiler output file names
7803 that correspond to the input files. */
7806 i
+= lang_specific_extra_outfiles
;
7807 outfiles
= XCNEWVEC (const char *, i
);
7809 /* Record which files were specified explicitly as link input. */
7811 explicit_link_files
= XCNEWVEC (char, n_infiles
);
7813 combine_inputs
= have_o
|| flag_wpa
;
7815 for (i
= 0; (int) i
< n_infiles
; i
++)
7817 const char *name
= infiles
[i
].name
;
7818 struct compiler
*compiler
= lookup_compiler (name
,
7820 infiles
[i
].language
);
7822 if (compiler
&& !(compiler
->combinable
))
7823 combine_inputs
= false;
7825 if (lang_n_infiles
> 0 && compiler
!= input_file_compiler
7826 && infiles
[i
].language
&& infiles
[i
].language
[0] != '*')
7827 infiles
[i
].incompiler
= compiler
;
7831 input_file_compiler
= compiler
;
7832 infiles
[i
].incompiler
= compiler
;
7836 /* Since there is no compiler for this input file, assume it is a
7838 explicit_link_files
[i
] = 1;
7839 infiles
[i
].incompiler
= NULL
;
7841 infiles
[i
].compiled
= false;
7842 infiles
[i
].preprocessed
= false;
7845 if (!combine_inputs
&& have_c
&& have_o
&& lang_n_infiles
> 1)
7846 fatal_error (input_location
,
7847 "cannot specify -o with -c, -S or -E with multiple files");
7849 /* No early exit needed from main; we can continue. */
7853 /* Run the spec machinery on each input file. */
7856 driver::do_spec_on_infiles () const
7860 for (i
= 0; (int) i
< n_infiles
; i
++)
7862 int this_file_error
= 0;
7864 /* Tell do_spec what to substitute for %i. */
7866 input_file_number
= i
;
7867 set_input (infiles
[i
].name
);
7869 if (infiles
[i
].compiled
)
7872 /* Use the same thing in %o, unless cp->spec says otherwise. */
7874 outfiles
[i
] = gcc_input_filename
;
7876 /* Figure out which compiler from the file's suffix. */
7879 = lookup_compiler (infiles
[i
].name
, input_filename_length
,
7880 infiles
[i
].language
);
7882 if (input_file_compiler
)
7884 /* Ok, we found an applicable compiler. Run its spec. */
7886 if (input_file_compiler
->spec
[0] == '#')
7888 error ("%s: %s compiler not installed on this system",
7889 gcc_input_filename
, &input_file_compiler
->spec
[1]);
7890 this_file_error
= 1;
7898 free (debug_check_temp_file
[0]);
7899 debug_check_temp_file
[0] = NULL
;
7901 free (debug_check_temp_file
[1]);
7902 debug_check_temp_file
[1] = NULL
;
7905 value
= do_spec (input_file_compiler
->spec
);
7906 infiles
[i
].compiled
= true;
7908 this_file_error
= 1;
7909 else if (compare_debug
&& debug_check_temp_file
[0])
7912 inform (0, "recompiling with -fcompare-debug");
7914 compare_debug
= -compare_debug
;
7915 n_switches
= n_switches_debug_check
[1];
7916 n_switches_alloc
= n_switches_alloc_debug_check
[1];
7917 switches
= switches_debug_check
[1];
7919 value
= do_spec (input_file_compiler
->spec
);
7921 compare_debug
= -compare_debug
;
7922 n_switches
= n_switches_debug_check
[0];
7923 n_switches_alloc
= n_switches_alloc_debug_check
[0];
7924 switches
= switches_debug_check
[0];
7928 error ("during -fcompare-debug recompilation");
7929 this_file_error
= 1;
7932 gcc_assert (debug_check_temp_file
[1]
7933 && filename_cmp (debug_check_temp_file
[0],
7934 debug_check_temp_file
[1]));
7937 inform (0, "comparing final insns dumps");
7939 if (compare_files (debug_check_temp_file
))
7940 this_file_error
= 1;
7945 free (debug_check_temp_file
[0]);
7946 debug_check_temp_file
[0] = NULL
;
7948 free (debug_check_temp_file
[1]);
7949 debug_check_temp_file
[1] = NULL
;
7954 /* If this file's name does not contain a recognized suffix,
7955 record it as explicit linker input. */
7958 explicit_link_files
[i
] = 1;
7960 /* Clear the delete-on-failure queue, deleting the files in it
7961 if this compilation failed. */
7963 if (this_file_error
)
7965 delete_failure_queue ();
7968 /* If this compilation succeeded, don't delete those files later. */
7969 clear_failure_queue ();
7972 /* Reset the input file name to the first compile/object file name, for use
7973 with %b in LINK_SPEC. We use the first input file that we can find
7974 a compiler to compile it instead of using infiles.language since for
7975 languages other than C we use aliases that we then lookup later. */
7980 for (i
= 0; i
< n_infiles
; i
++)
7981 if (infiles
[i
].incompiler
7982 || (infiles
[i
].language
&& infiles
[i
].language
[0] != '*'))
7984 set_input (infiles
[i
].name
);
7991 /* Make sure INPUT_FILE_NUMBER points to first available open
7993 input_file_number
= n_infiles
;
7994 if (lang_specific_pre_link ())
7999 /* If we have to run the linker, do it now. */
8002 driver::maybe_run_linker (const char *argv0
) const
8005 int linker_was_run
= 0;
8006 int num_linker_inputs
;
8008 /* Determine if there are any linker input files. */
8009 num_linker_inputs
= 0;
8010 for (i
= 0; (int) i
< n_infiles
; i
++)
8011 if (explicit_link_files
[i
] || outfiles
[i
] != NULL
)
8012 num_linker_inputs
++;
8014 /* Run ld to link all the compiler output files. */
8016 if (num_linker_inputs
> 0 && !seen_error () && print_subprocess_help
< 2)
8018 int tmp
= execution_count
;
8022 #if HAVE_LTO_PLUGIN > 0
8023 #if HAVE_LTO_PLUGIN == 2
8024 const char *fno_use_linker_plugin
= "fno-use-linker-plugin";
8026 const char *fuse_linker_plugin
= "fuse-linker-plugin";
8030 /* We'll use ld if we can't find collect2. */
8031 if (! strcmp (linker_name_spec
, "collect2"))
8033 char *s
= find_a_file (&exec_prefixes
, "collect2", X_OK
, false);
8035 linker_name_spec
= "ld";
8038 #if HAVE_LTO_PLUGIN > 0
8039 #if HAVE_LTO_PLUGIN == 2
8040 if (!switch_matches (fno_use_linker_plugin
,
8041 fno_use_linker_plugin
8042 + strlen (fno_use_linker_plugin
), 0))
8044 if (switch_matches (fuse_linker_plugin
,
8046 + strlen (fuse_linker_plugin
), 0))
8049 char *temp_spec
= find_a_file (&exec_prefixes
,
8050 LTOPLUGINSONAME
, R_OK
,
8053 fatal_error (input_location
,
8054 "-fuse-linker-plugin, but %s not found",
8056 linker_plugin_file_spec
= convert_white_space (temp_spec
);
8059 lto_gcc_spec
= argv0
;
8062 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
8064 putenv_from_prefixes (&exec_prefixes
, "COMPILER_PATH", false);
8065 putenv_from_prefixes (&startfile_prefixes
, LIBRARY_PATH_ENV
, true);
8067 if (print_subprocess_help
== 1)
8069 printf (_("\nLinker options\n==============\n\n"));
8070 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
8071 " to the linker.\n\n"));
8074 int value
= do_spec (link_command_spec
);
8077 linker_was_run
= (tmp
!= execution_count
);
8080 /* If options said don't run linker,
8081 complain about input files to be given to the linker. */
8083 if (! linker_was_run
&& !seen_error ())
8084 for (i
= 0; (int) i
< n_infiles
; i
++)
8085 if (explicit_link_files
[i
]
8086 && !(infiles
[i
].language
&& infiles
[i
].language
[0] == '*'))
8087 warning (0, "%s: linker input file unused because linking not done",
8091 /* The end of "main". */
8094 driver::final_actions () const
8096 /* Delete some or all of the temporary files we made. */
8099 delete_failure_queue ();
8100 delete_temp_files ();
8102 if (print_help_list
)
8104 printf (("\nFor bug reporting instructions, please see:\n"));
8105 printf ("%s\n", bug_report_url
);
8109 /* Determine what the exit code of the driver should be. */
8112 driver::get_exit_code () const
8114 return (signal_count
!= 0 ? 2
8115 : seen_error () ? (pass_exit_codes
? greatest_status
: 1)
8119 /* Find the proper compilation spec for the file name NAME,
8120 whose length is LENGTH. LANGUAGE is the specified language,
8121 or 0 if this file is to be passed to the linker. */
8123 static struct compiler
*
8124 lookup_compiler (const char *name
, size_t length
, const char *language
)
8126 struct compiler
*cp
;
8128 /* If this was specified by the user to be a linker input, indicate that. */
8129 if (language
!= 0 && language
[0] == '*')
8132 /* Otherwise, look for the language, if one is spec'd. */
8135 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
8136 if (cp
->suffix
[0] == '@' && !strcmp (cp
->suffix
+ 1, language
))
8139 error ("language %s not recognized", language
);
8143 /* Look for a suffix. */
8144 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
8146 if (/* The suffix `-' matches only the file name `-'. */
8147 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
8148 || (strlen (cp
->suffix
) < length
8149 /* See if the suffix matches the end of NAME. */
8150 && !strcmp (cp
->suffix
,
8151 name
+ length
- strlen (cp
->suffix
))
8156 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
8157 /* Look again, but case-insensitively this time. */
8159 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
8161 if (/* The suffix `-' matches only the file name `-'. */
8162 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
8163 || (strlen (cp
->suffix
) < length
8164 /* See if the suffix matches the end of NAME. */
8165 && ((!strcmp (cp
->suffix
,
8166 name
+ length
- strlen (cp
->suffix
))
8167 || !strpbrk (cp
->suffix
, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
8168 && !strcasecmp (cp
->suffix
,
8169 name
+ length
- strlen (cp
->suffix
)))
8175 if (cp
>= compilers
)
8177 if (cp
->spec
[0] != '@')
8178 /* A non-alias entry: return it. */
8181 /* An alias entry maps a suffix to a language.
8182 Search for the language; pass 0 for NAME and LENGTH
8183 to avoid infinite recursion if language not found. */
8184 return lookup_compiler (NULL
, 0, cp
->spec
+ 1);
8190 save_string (const char *s
, int len
)
8192 char *result
= XNEWVEC (char, len
+ 1);
8194 memcpy (result
, s
, len
);
8200 pfatal_with_name (const char *name
)
8202 perror_with_name (name
);
8203 delete_temp_files ();
8208 perror_with_name (const char *name
)
8210 error ("%s: %m", name
);
8214 validate_switches_from_spec (const char *spec
, bool user
)
8216 const char *p
= spec
;
8219 if (c
== '%' && (*p
== '{' || *p
== '<' || (*p
== 'W' && *++p
== '{')))
8220 /* We have a switch spec. */
8221 p
= validate_switches (p
+ 1, user
);
8225 validate_all_switches (void)
8227 struct compiler
*comp
;
8228 struct spec_list
*spec
;
8230 for (comp
= compilers
; comp
->spec
; comp
++)
8231 validate_switches_from_spec (comp
->spec
, false);
8233 /* Look through the linked list of specs read from the specs file. */
8234 for (spec
= specs
; spec
; spec
= spec
->next
)
8235 validate_switches_from_spec (*spec
->ptr_spec
, spec
->user_p
);
8237 validate_switches_from_spec (link_command_spec
, false);
8240 /* Look at the switch-name that comes after START
8241 and mark as valid all supplied switches that match it. */
8244 validate_switches (const char *start
, bool user_spec
)
8246 const char *p
= start
;
8250 bool suffix
= false;
8251 bool starred
= false;
8253 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
8262 if (*p
== '.' || *p
== ',')
8266 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
8267 || *p
== ',' || *p
== '.' || *p
== '@')
8272 starred
= true, p
++;
8278 /* Mark all matching switches as valid. */
8279 for (i
= 0; i
< n_switches
; i
++)
8280 if (!strncmp (switches
[i
].part1
, atom
, len
)
8281 && (starred
|| switches
[i
].part1
[len
] == '\0')
8282 && (switches
[i
].known
|| user_spec
))
8283 switches
[i
].validated
= true;
8287 if (*p
&& (p
[-1] == '|' || p
[-1] == '&'))
8290 if (*p
&& p
[-1] == ':')
8292 while (*p
&& *p
!= ';' && *p
!= '}')
8297 if (*p
== '{' || *p
== '<')
8298 p
= validate_switches (p
+1, user_spec
);
8299 else if (p
[0] == 'W' && p
[1] == '{')
8300 p
= validate_switches (p
+2, user_spec
);
8307 if (*p
&& p
[-1] == ';')
8321 static struct mdswitchstr
*mdswitches
;
8322 static int n_mdswitches
;
8324 /* Check whether a particular argument was used. The first time we
8325 canonicalize the switches to keep only the ones we care about. */
8330 int operator () (const char *p
, int len
);
8337 const char *replace
;
8342 mswitchstr
*mswitches
;
8347 used_arg_t used_arg
;
8350 used_arg_t::operator () (const char *p
, int len
)
8356 struct mswitchstr
*matches
;
8360 /* Break multilib_matches into the component strings of string
8361 and replacement string. */
8362 for (q
= multilib_matches
; *q
!= '\0'; q
++)
8367 = (struct mswitchstr
*) alloca ((sizeof (struct mswitchstr
)) * cnt
);
8369 q
= multilib_matches
;
8378 fatal_error (input_location
, "multilib spec %qs is invalid",
8383 matches
[i
].len
= q
- matches
[i
].str
;
8385 matches
[i
].replace
= ++q
;
8386 while (*q
!= ';' && *q
!= '\0')
8389 goto invalid_matches
;
8392 matches
[i
].rep_len
= q
- matches
[i
].replace
;
8398 /* Now build a list of the replacement string for switches that we care
8399 about. Make sure we allocate at least one entry. This prevents
8400 xmalloc from calling fatal, and prevents us from re-executing this
8403 = XNEWVEC (struct mswitchstr
, n_mdswitches
+ (n_switches
? n_switches
: 1));
8404 for (i
= 0; i
< n_switches
; i
++)
8405 if ((switches
[i
].live_cond
& SWITCH_IGNORE
) == 0)
8407 int xlen
= strlen (switches
[i
].part1
);
8408 for (j
= 0; j
< cnt
; j
++)
8409 if (xlen
== matches
[j
].len
8410 && ! strncmp (switches
[i
].part1
, matches
[j
].str
, xlen
))
8412 mswitches
[n_mswitches
].str
= matches
[j
].replace
;
8413 mswitches
[n_mswitches
].len
= matches
[j
].rep_len
;
8414 mswitches
[n_mswitches
].replace
= (char *) 0;
8415 mswitches
[n_mswitches
].rep_len
= 0;
8421 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
8422 on the command line nor any options mutually incompatible with
8424 for (i
= 0; i
< n_mdswitches
; i
++)
8428 for (q
= multilib_options
; *q
!= '\0'; *q
&& q
++)
8434 while (strncmp (q
, mdswitches
[i
].str
, mdswitches
[i
].len
) != 0
8435 || strchr (" /", q
[mdswitches
[i
].len
]) == NULL
)
8437 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
8444 if (*q
!= ' ' && *q
!= '\0')
8446 while (*r
!= ' ' && *r
!= '\0')
8449 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
8452 if (used_arg (r
, q
- r
))
8457 mswitches
[n_mswitches
].str
= mdswitches
[i
].str
;
8458 mswitches
[n_mswitches
].len
= mdswitches
[i
].len
;
8459 mswitches
[n_mswitches
].replace
= (char *) 0;
8460 mswitches
[n_mswitches
].rep_len
= 0;
8473 for (i
= 0; i
< n_mswitches
; i
++)
8474 if (len
== mswitches
[i
].len
&& ! strncmp (p
, mswitches
[i
].str
, len
))
8480 void used_arg_t::finalize ()
8482 XDELETEVEC (mswitches
);
8489 default_arg (const char *p
, int len
)
8493 for (i
= 0; i
< n_mdswitches
; i
++)
8494 if (len
== mdswitches
[i
].len
&& ! strncmp (p
, mdswitches
[i
].str
, len
))
8500 /* Work out the subdirectory to use based on the options. The format of
8501 multilib_select is a list of elements. Each element is a subdirectory
8502 name followed by a list of options followed by a semicolon. The format
8503 of multilib_exclusions is the same, but without the preceding
8504 directory. First gcc will check the exclusions, if none of the options
8505 beginning with an exclamation point are present, and all of the other
8506 options are present, then we will ignore this completely. Passing
8507 that, gcc will consider each multilib_select in turn using the same
8508 rules for matching the options. If a match is found, that subdirectory
8510 A subdirectory name is optionally followed by a colon and the corresponding
8514 set_multilib_dir (void)
8517 unsigned int this_path_len
;
8518 const char *this_path
, *this_arg
;
8519 const char *start
, *end
;
8521 int ok
, ndfltok
, first
;
8524 start
= multilib_defaults
;
8525 while (*start
== ' ' || *start
== '\t')
8527 while (*start
!= '\0')
8530 while (*start
!= ' ' && *start
!= '\t' && *start
!= '\0')
8532 while (*start
== ' ' || *start
== '\t')
8540 mdswitches
= XNEWVEC (struct mdswitchstr
, n_mdswitches
);
8541 for (start
= multilib_defaults
; *start
!= '\0'; start
= end
+ 1)
8543 while (*start
== ' ' || *start
== '\t')
8549 for (end
= start
+ 1;
8550 *end
!= ' ' && *end
!= '\t' && *end
!= '\0'; end
++)
8553 obstack_grow (&multilib_obstack
, start
, end
- start
);
8554 obstack_1grow (&multilib_obstack
, 0);
8555 mdswitches
[i
].str
= XOBFINISH (&multilib_obstack
, const char *);
8556 mdswitches
[i
++].len
= end
- start
;
8563 p
= multilib_exclusions
;
8566 /* Ignore newlines. */
8573 /* Check the arguments. */
8580 fatal_error (input_location
, "multilib exclusions %qs is invalid",
8581 multilib_exclusions
);
8591 while (*p
!= ' ' && *p
!= ';')
8594 goto invalid_exclusions
;
8598 if (*this_arg
!= '!')
8606 ok
= used_arg (this_arg
, p
- this_arg
);
8621 p
= multilib_select
;
8623 /* Append multilib reuse rules if any. With those rules, we can reuse
8624 one multilib for certain different options sets. */
8625 if (strlen (multilib_reuse
) > 0)
8626 p
= concat (p
, multilib_reuse
, NULL
);
8630 /* Ignore newlines. */
8637 /* Get the initial path. */
8644 fatal_error (input_location
, "multilib select %qs %qs is invalid",
8645 multilib_select
, multilib_reuse
);
8649 this_path_len
= p
- this_path
;
8651 /* Check the arguments. */
8658 goto invalid_select
;
8667 while (*p
!= ' ' && *p
!= ';')
8670 goto invalid_select
;
8674 if (*this_arg
!= '!')
8682 /* If this is a default argument, we can just ignore it.
8683 This is true even if this_arg begins with '!'. Beginning
8684 with '!' does not mean that this argument is necessarily
8685 inappropriate for this library: it merely means that
8686 there is a more specific library which uses this
8687 argument. If this argument is a default, we need not
8688 consider that more specific library. */
8689 ok
= used_arg (this_arg
, p
- this_arg
);
8696 if (default_arg (this_arg
, p
- this_arg
))
8705 if (this_path_len
!= 1
8706 || this_path
[0] != '.')
8708 char *new_multilib_dir
= XNEWVEC (char, this_path_len
+ 1);
8711 strncpy (new_multilib_dir
, this_path
, this_path_len
);
8712 new_multilib_dir
[this_path_len
] = '\0';
8713 q
= strchr (new_multilib_dir
, ':');
8716 multilib_dir
= new_multilib_dir
;
8723 const char *q
= this_path
, *end
= this_path
+ this_path_len
;
8725 while (q
< end
&& *q
!= ':')
8729 const char *q2
= q
+ 1, *ml_end
= end
;
8730 char *new_multilib_os_dir
;
8732 while (q2
< end
&& *q2
!= ':')
8736 if (ml_end
- q
== 1)
8737 multilib_os_dir
= xstrdup (".");
8740 new_multilib_os_dir
= XNEWVEC (char, ml_end
- q
);
8741 memcpy (new_multilib_os_dir
, q
+ 1, ml_end
- q
- 1);
8742 new_multilib_os_dir
[ml_end
- q
- 1] = '\0';
8743 multilib_os_dir
= new_multilib_os_dir
;
8746 if (q2
< end
&& *q2
== ':')
8748 char *new_multiarch_dir
= XNEWVEC (char, end
- q2
);
8749 memcpy (new_multiarch_dir
, q2
+ 1, end
- q2
- 1);
8750 new_multiarch_dir
[end
- q2
- 1] = '\0';
8751 multiarch_dir
= new_multiarch_dir
;
8760 if (multilib_dir
== NULL
&& multilib_os_dir
!= NULL
8761 && strcmp (multilib_os_dir
, ".") == 0)
8763 free (CONST_CAST (char *, multilib_os_dir
));
8764 multilib_os_dir
= NULL
;
8766 else if (multilib_dir
!= NULL
&& multilib_os_dir
== NULL
)
8767 multilib_os_dir
= multilib_dir
;
8770 /* Print out the multiple library subdirectory selection
8771 information. This prints out a series of lines. Each line looks
8772 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
8773 required. Only the desired options are printed out, the negative
8774 matches. The options are print without a leading dash. There are
8775 no spaces to make it easy to use the information in the shell.
8776 Each subdirectory is printed only once. This assumes the ordering
8777 generated by the genmultilib script. Also, we leave out ones that match
8781 print_multilib_info (void)
8783 const char *p
= multilib_select
;
8784 const char *last_path
= 0, *this_path
;
8786 unsigned int last_path_len
= 0;
8791 /* Ignore newlines. */
8798 /* Get the initial path. */
8805 fatal_error (input_location
,
8806 "multilib select %qs is invalid", multilib_select
);
8812 /* When --disable-multilib was used but target defines
8813 MULTILIB_OSDIRNAMES, entries starting with .: (and not starting
8814 with .:: for multiarch configurations) are there just to find
8815 multilib_os_dir, so skip them from output. */
8816 if (this_path
[0] == '.' && this_path
[1] == ':' && this_path
[2] != ':')
8819 /* Check for matches with the multilib_exclusions. We don't bother
8820 with the '!' in either list. If any of the exclusion rules match
8821 all of its options with the select rule, we skip it. */
8823 const char *e
= multilib_exclusions
;
8824 const char *this_arg
;
8829 /* Ignore newlines. */
8836 /* Check the arguments. */
8845 fatal_error (input_location
,
8846 "multilib exclusion %qs is invalid",
8847 multilib_exclusions
);
8858 while (*e
!= ' ' && *e
!= ';')
8861 goto invalid_exclusion
;
8869 int len
= e
- this_arg
;
8872 goto invalid_select
;
8876 while (*q
!= ' ' && *q
!= ';')
8879 goto invalid_select
;
8883 if (! strncmp (arg
, this_arg
,
8884 (len
< q
- arg
) ? q
- arg
: len
)
8885 || default_arg (this_arg
, e
- this_arg
))
8915 /* If this is a duplicate, skip it. */
8916 skip
= (last_path
!= 0
8917 && (unsigned int) (p
- this_path
) == last_path_len
8918 && ! filename_ncmp (last_path
, this_path
, last_path_len
));
8920 last_path
= this_path
;
8921 last_path_len
= p
- this_path
;
8924 /* If this directory requires any default arguments, we can skip
8925 it. We will already have printed a directory identical to
8926 this one which does not require that default argument. */
8937 goto invalid_select
;
8944 while (*q
!= ' ' && *q
!= ';')
8947 goto invalid_select
;
8952 && default_arg (arg
, q
- arg
))
8967 for (p1
= last_path
; p1
< p
&& *p1
!= ':'; p1
++)
8978 goto invalid_select
;
8986 use_arg
= *p
!= '!';
8991 while (*p
!= ' ' && *p
!= ';')
8994 goto invalid_select
;
9006 /* If there are extra options, print them now. */
9007 if (multilib_extra
&& *multilib_extra
)
9009 int print_at
= TRUE
;
9012 for (q
= multilib_extra
; *q
!= '\0'; q
++)
9033 /* getenv built-in spec function.
9035 Returns the value of the environment variable given by its first
9036 argument, concatenated with the second argument. If the
9037 environment variable is not defined, a fatal error is issued. */
9040 getenv_spec_function (int argc
, const char **argv
)
9050 value
= env
.get (argv
[0]);
9052 fatal_error (input_location
,
9053 "environment variable %qs not defined", argv
[0]);
9055 /* We have to escape every character of the environment variable so
9056 they are not interpreted as active spec characters. A
9057 particularly painful case is when we are reading a variable
9058 holding a windows path complete with \ separators. */
9059 len
= strlen (value
) * 2 + strlen (argv
[1]) + 1;
9060 result
= XNEWVAR (char, len
);
9061 for (ptr
= result
; *value
; ptr
+= 2)
9067 strcpy (ptr
, argv
[1]);
9072 /* if-exists built-in spec function.
9074 Checks to see if the file specified by the absolute pathname in
9075 ARGS exists. Returns that pathname if found.
9077 The usual use for this function is to check for a library file
9078 (whose name has been expanded with %s). */
9081 if_exists_spec_function (int argc
, const char **argv
)
9083 /* Must have only one argument. */
9084 if (argc
== 1 && IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
9090 /* if-exists-else built-in spec function.
9092 This is like if-exists, but takes an additional argument which
9093 is returned if the first argument does not exist. */
9096 if_exists_else_spec_function (int argc
, const char **argv
)
9098 /* Must have exactly two arguments. */
9102 if (IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
9108 /* sanitize built-in spec function.
9110 This returns non-NULL, if sanitizing address, thread or
9111 any of the undefined behavior sanitizers. */
9114 sanitize_spec_function (int argc
, const char **argv
)
9119 if (strcmp (argv
[0], "address") == 0)
9120 return (flag_sanitize
& SANITIZE_USER_ADDRESS
) ? "" : NULL
;
9121 if (strcmp (argv
[0], "kernel-address") == 0)
9122 return (flag_sanitize
& SANITIZE_KERNEL_ADDRESS
) ? "" : NULL
;
9123 if (strcmp (argv
[0], "thread") == 0)
9124 return (flag_sanitize
& SANITIZE_THREAD
) ? "" : NULL
;
9125 if (strcmp (argv
[0], "undefined") == 0)
9126 return ((flag_sanitize
& (SANITIZE_UNDEFINED
| SANITIZE_NONDEFAULT
))
9127 && !flag_sanitize_undefined_trap_on_error
) ? "" : NULL
;
9128 if (strcmp (argv
[0], "leak") == 0)
9129 return ((flag_sanitize
9130 & (SANITIZE_ADDRESS
| SANITIZE_LEAK
| SANITIZE_THREAD
))
9131 == SANITIZE_LEAK
) ? "" : NULL
;
9135 /* replace-outfile built-in spec function.
9137 This looks for the first argument in the outfiles array's name and
9138 replaces it with the second argument. */
9141 replace_outfile_spec_function (int argc
, const char **argv
)
9144 /* Must have exactly two arguments. */
9148 for (i
= 0; i
< n_infiles
; i
++)
9150 if (outfiles
[i
] && !filename_cmp (outfiles
[i
], argv
[0]))
9151 outfiles
[i
] = xstrdup (argv
[1]);
9156 /* remove-outfile built-in spec function.
9158 * This looks for the first argument in the outfiles array's name and
9162 remove_outfile_spec_function (int argc
, const char **argv
)
9165 /* Must have exactly one argument. */
9169 for (i
= 0; i
< n_infiles
; i
++)
9171 if (outfiles
[i
] && !filename_cmp (outfiles
[i
], argv
[0]))
9177 /* Given two version numbers, compares the two numbers.
9178 A version number must match the regular expression
9179 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
9182 compare_version_strings (const char *v1
, const char *v2
)
9187 if (regcomp (&r
, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
9188 REG_EXTENDED
| REG_NOSUB
) != 0)
9190 rresult
= regexec (&r
, v1
, 0, NULL
, 0);
9191 if (rresult
== REG_NOMATCH
)
9192 fatal_error (input_location
, "invalid version number %qs", v1
);
9193 else if (rresult
!= 0)
9195 rresult
= regexec (&r
, v2
, 0, NULL
, 0);
9196 if (rresult
== REG_NOMATCH
)
9197 fatal_error (input_location
, "invalid version number %qs", v2
);
9198 else if (rresult
!= 0)
9201 return strverscmp (v1
, v2
);
9205 /* version_compare built-in spec function.
9207 This takes an argument of the following form:
9209 <comparison-op> <arg1> [<arg2>] <switch> <result>
9211 and produces "result" if the comparison evaluates to true,
9212 and nothing if it doesn't.
9214 The supported <comparison-op> values are:
9216 >= true if switch is a later (or same) version than arg1
9218 < true if switch is an earlier version than arg1
9220 >< true if switch is arg1 or later, and earlier than arg2
9221 <> true if switch is earlier than arg1 or is arg2 or later
9223 If the switch is not present, the condition is false unless
9224 the first character of the <comparison-op> is '!'.
9227 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
9228 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
9231 version_compare_spec_function (int argc
, const char **argv
)
9235 const char *switch_value
= NULL
;
9240 fatal_error (input_location
, "too few arguments to %%:version-compare");
9241 if (argv
[0][0] == '\0')
9243 if ((argv
[0][1] == '<' || argv
[0][1] == '>') && argv
[0][0] != '!')
9245 if (argc
!= nargs
+ 3)
9246 fatal_error (input_location
, "too many arguments to %%:version-compare");
9248 switch_len
= strlen (argv
[nargs
+ 1]);
9249 for (i
= 0; i
< n_switches
; i
++)
9250 if (!strncmp (switches
[i
].part1
, argv
[nargs
+ 1], switch_len
)
9251 && check_live_switch (i
, switch_len
))
9252 switch_value
= switches
[i
].part1
+ switch_len
;
9254 if (switch_value
== NULL
)
9258 comp1
= compare_version_strings (switch_value
, argv
[1]);
9260 comp2
= compare_version_strings (switch_value
, argv
[2]);
9262 comp2
= -1; /* This value unused. */
9265 switch (argv
[0][0] << 8 | argv
[0][1])
9267 case '>' << 8 | '=':
9268 result
= comp1
>= 0;
9270 case '!' << 8 | '<':
9271 result
= comp1
>= 0 || switch_value
== NULL
;
9276 case '!' << 8 | '>':
9277 result
= comp1
< 0 || switch_value
== NULL
;
9279 case '>' << 8 | '<':
9280 result
= comp1
>= 0 && comp2
< 0;
9282 case '<' << 8 | '>':
9283 result
= comp1
< 0 || comp2
>= 0;
9287 fatal_error (input_location
,
9288 "unknown operator %qs in %%:version-compare", argv
[0]);
9293 return argv
[nargs
+ 2];
9296 /* %:include builtin spec function. This differs from %include in that it
9297 can be nested inside a spec, and thus be conditionalized. It takes
9298 one argument, the filename, and looks for it in the startfile path.
9299 The result is always NULL, i.e. an empty expansion. */
9302 include_spec_function (int argc
, const char **argv
)
9309 file
= find_a_file (&startfile_prefixes
, argv
[0], R_OK
, true);
9310 read_specs (file
? file
: argv
[0], false, false);
9315 /* %:find-file spec function. This function replaces its argument by
9316 the file found through find_file, that is the -print-file-name gcc
9319 find_file_spec_function (int argc
, const char **argv
)
9326 file
= find_file (argv
[0]);
9331 /* %:find-plugindir spec function. This function replaces its argument
9332 by the -iplugindir=<dir> option. `dir' is found through find_file, that
9333 is the -print-file-name gcc program option. */
9335 find_plugindir_spec_function (int argc
, const char **argv ATTRIBUTE_UNUSED
)
9342 option
= concat ("-iplugindir=", find_file ("plugin"), NULL
);
9347 /* %:print-asm-header spec function. Print a banner to say that the
9348 following output is from the assembler. */
9351 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED
,
9352 const char **argv ATTRIBUTE_UNUSED
)
9354 printf (_("Assembler options\n=================\n\n"));
9355 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
9360 /* Get a random number for -frandom-seed */
9362 static unsigned HOST_WIDE_INT
9363 get_random_number (void)
9365 unsigned HOST_WIDE_INT ret
= 0;
9368 fd
= open ("/dev/urandom", O_RDONLY
);
9371 read (fd
, &ret
, sizeof (HOST_WIDE_INT
));
9377 /* Get some more or less random data. */
9378 #ifdef HAVE_GETTIMEOFDAY
9382 gettimeofday (&tv
, NULL
);
9383 ret
= tv
.tv_sec
* 1000 + tv
.tv_usec
/ 1000;
9387 time_t now
= time (NULL
);
9389 if (now
!= (time_t)-1)
9390 ret
= (unsigned) now
;
9394 return ret
^ getpid ();
9397 /* %:compare-debug-dump-opt spec function. Save the last argument,
9398 expected to be the last -fdump-final-insns option, or generate a
9402 compare_debug_dump_opt_spec_function (int arg
,
9403 const char **argv ATTRIBUTE_UNUSED
)
9408 static char random_seed
[HOST_BITS_PER_WIDE_INT
/ 4 + 3];
9411 fatal_error (input_location
,
9412 "too many arguments to %%:compare-debug-dump-opt");
9414 do_spec_2 ("%{fdump-final-insns=*:%*}");
9415 do_spec_1 (" ", 0, NULL
);
9417 if (argbuf
.length () > 0
9418 && strcmp (argv
[argbuf
.length () - 1], "."))
9423 name
= xstrdup (argv
[argbuf
.length () - 1]);
9428 const char *ext
= NULL
;
9430 if (argbuf
.length () > 0)
9432 do_spec_2 ("%{o*:%*}%{!o:%{!S:%b%O}%{S:%b.s}}");
9435 else if (!compare_debug
)
9438 do_spec_2 ("%g.gkd");
9440 do_spec_1 (" ", 0, NULL
);
9442 gcc_assert (argbuf
.length () > 0);
9444 name
= concat (argbuf
.last (), ext
, NULL
);
9446 ret
= concat ("-fdump-final-insns=", name
, NULL
);
9449 which
= compare_debug
< 0;
9450 debug_check_temp_file
[which
] = name
;
9454 unsigned HOST_WIDE_INT value
= get_random_number ();
9456 sprintf (random_seed
, HOST_WIDE_INT_PRINT_HEX
, value
);
9462 ret
= concat ("%{!frandom-seed=*:-frandom-seed=", random_seed
, "} ",
9473 static const char *debug_auxbase_opt
;
9475 /* %:compare-debug-self-opt spec function. Expands to the options
9476 that are to be passed in the second compilation of
9480 compare_debug_self_opt_spec_function (int arg
,
9481 const char **argv ATTRIBUTE_UNUSED
)
9484 fatal_error (input_location
,
9485 "too many arguments to %%:compare-debug-self-opt");
9487 if (compare_debug
>= 0)
9490 do_spec_2 ("%{c|S:%{o*:%*}}");
9491 do_spec_1 (" ", 0, NULL
);
9493 if (argbuf
.length () > 0)
9494 debug_auxbase_opt
= concat ("-auxbase-strip ",
9498 debug_auxbase_opt
= NULL
;
9501 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
9502 %<fdump-final-insns=* -w -S -o %j \
9503 %{!fcompare-debug-second:-fcompare-debug-second} \
9504 ", compare_debug_opt
, NULL
);
9507 /* %:compare-debug-auxbase-opt spec function. Expands to the auxbase
9508 options that are to be passed in the second compilation of
9509 compare-debug. It expects, as an argument, the basename of the
9510 current input file name, with the .gk suffix appended to it. */
9513 compare_debug_auxbase_opt_spec_function (int arg
,
9520 fatal_error (input_location
,
9521 "too few arguments to %%:compare-debug-auxbase-opt");
9524 fatal_error (input_location
,
9525 "too many arguments to %%:compare-debug-auxbase-opt");
9527 if (compare_debug
>= 0)
9530 len
= strlen (argv
[0]);
9531 if (len
< 3 || strcmp (argv
[0] + len
- 3, ".gk") != 0)
9532 fatal_error (input_location
, "argument to %%:compare-debug-auxbase-opt "
9533 "does not end in .gk");
9535 if (debug_auxbase_opt
)
9536 return debug_auxbase_opt
;
9538 #define OPT "-auxbase "
9541 name
= (char*) xmalloc (sizeof (OPT
) + len
);
9542 memcpy (name
, OPT
, sizeof (OPT
) - 1);
9543 memcpy (name
+ sizeof (OPT
) - 1, argv
[0], len
);
9544 name
[sizeof (OPT
) - 1 + len
] = '\0';
9551 /* %:pass-through-libs spec function. Finds all -l options and input
9552 file names in the lib spec passed to it, and makes a list of them
9553 prepended with the plugin option to cause them to be passed through
9554 to the final link after all the new object files have been added. */
9557 pass_through_libs_spec_func (int argc
, const char **argv
)
9559 char *prepended
= xstrdup (" ");
9561 /* Shlemiel the painter's algorithm. Innately horrible, but at least
9562 we know that there will never be more than a handful of strings to
9563 concat, and it's only once per run, so it's not worth optimising. */
9564 for (n
= 0; n
< argc
; n
++)
9566 char *old
= prepended
;
9567 /* Anything that isn't an option is a full path to an output
9568 file; pass it through if it ends in '.a'. Among options,
9570 if (argv
[n
][0] == '-' && argv
[n
][1] == 'l')
9572 const char *lopt
= argv
[n
] + 2;
9573 /* Handle both joined and non-joined -l options. If for any
9574 reason there's a trailing -l with no joined or following
9575 arg just discard it. */
9576 if (!*lopt
&& ++n
>= argc
)
9580 prepended
= concat (prepended
, "-plugin-opt=-pass-through=-l",
9583 else if (!strcmp (".a", argv
[n
] + strlen (argv
[n
]) - 2))
9585 prepended
= concat (prepended
, "-plugin-opt=-pass-through=",
9586 argv
[n
], " ", NULL
);
9588 if (prepended
!= old
)
9594 /* %:replace-extension spec function. Replaces the extension of the
9595 first argument with the second argument. */
9598 replace_extension_spec_func (int argc
, const char **argv
)
9606 fatal_error (input_location
, "too few arguments to %%:replace-extension");
9608 name
= xstrdup (argv
[0]);
9610 for (i
= strlen (name
) - 1; i
>= 0; i
--)
9611 if (IS_DIR_SEPARATOR (name
[i
]))
9614 p
= strrchr (name
+ i
+ 1, '.');
9618 result
= concat (name
, argv
[1], NULL
);
9624 /* Returns "" if the n in ARGV[1] == -opt=<n> is greater than ARGV[2].
9625 Otherwise, return NULL. */
9628 greater_than_spec_func (int argc
, const char **argv
)
9635 gcc_assert (argc
== 3);
9636 gcc_assert (argv
[0][0] == '-');
9637 gcc_assert (argv
[0][1] == '\0');
9639 /* Point p to <n> in in -opt=<n>. */
9640 const char *p
= argv
[1];
9653 long arg
= strtol (p
, &converted
, 10);
9654 gcc_assert (converted
!= p
);
9656 long lim
= strtol (argv
[2], &converted
, 10);
9657 gcc_assert (converted
!= argv
[2]);
9665 /* Insert backslash before spaces in ORIG (usually a file path), to
9666 avoid being broken by spec parser.
9668 This function is needed as do_spec_1 treats white space (' ' and '\t')
9669 as the end of an argument. But in case of -plugin /usr/gcc install/xxx.so,
9670 the file name should be treated as a single argument rather than being
9671 broken into multiple. Solution is to insert '\\' before the space in a
9674 This function converts and only converts all occurrence of ' '
9675 to '\\' + ' ' and '\t' to '\\' + '\t'. For example:
9679 "a\\ b" -> "a\\\\ b"
9681 orig: input null-terminating string that was allocated by xalloc. The
9682 memory it points to might be freed in this function. Behavior undefined
9683 if ORIG wasn't xalloced or was freed already at entry.
9685 Return: ORIG if no conversion needed. Otherwise a newly allocated string
9686 that was converted from ORIG. */
9689 convert_white_space (char *orig
)
9691 int len
, number_of_space
= 0;
9693 for (len
= 0; orig
[len
]; len
++)
9694 if (orig
[len
] == ' ' || orig
[len
] == '\t') number_of_space
++;
9696 if (number_of_space
)
9698 char *new_spec
= (char *) xmalloc (len
+ number_of_space
+ 1);
9700 for (j
= 0, k
= 0; j
<= len
; j
++, k
++)
9702 if (orig
[j
] == ' ' || orig
[j
] == '\t')
9703 new_spec
[k
++] = '\\';
9704 new_spec
[k
] = orig
[j
];
9714 path_prefix_reset (path_prefix
*prefix
)
9716 struct prefix_list
*iter
, *next
;
9717 iter
= prefix
->plist
;
9721 free (const_cast <char *> (iter
->prefix
));
9726 prefix
->max_len
= 0;
9729 /* Restore all state within gcc.c to the initial state, so that the driver
9730 code can be safely re-run in-process.
9732 Many const char * variables are referenced by static specs (see
9733 INIT_STATIC_SPEC above). These variables are restored to their default
9734 values by a simple loop over the static specs.
9736 For other variables, we directly restore them all to their initial
9737 values (often implicitly 0).
9739 Free the various obstacks in this file, along with "opts_obstack"
9742 This function also restores any environment variables that were changed. */
9748 params_c_finalize ();
9749 diagnostic_finish (global_dc
);
9752 at_file_supplied
= 0;
9753 print_help_list
= 0;
9755 verbose_only_flag
= 0;
9756 print_subprocess_help
= 0;
9758 report_times_to_file
= NULL
;
9759 target_system_root
= DEFAULT_TARGET_SYSTEM_ROOT
;
9760 target_system_root_changed
= 0;
9761 target_sysroot_suffix
= 0;
9762 target_sysroot_hdrs_suffix
= 0;
9763 save_temps_flag
= SAVE_TEMPS_NONE
;
9764 save_temps_prefix
= 0;
9765 save_temps_length
= 0;
9766 spec_machine
= DEFAULT_TARGET_MACHINE
;
9767 greatest_status
= 1;
9769 finalize_options_struct (&global_options
);
9770 finalize_options_struct (&global_options_set
);
9772 obstack_free (&obstack
, NULL
);
9773 obstack_free (&opts_obstack
, NULL
); /* in opts.c */
9774 obstack_free (&collect_obstack
, NULL
);
9776 link_command_spec
= LINK_COMMAND_SPEC
;
9778 obstack_free (&multilib_obstack
, NULL
);
9780 user_specs_head
= NULL
;
9781 user_specs_tail
= NULL
;
9783 /* Within the "compilers" vec, the fields "suffix" and "spec" were
9784 statically allocated for the default compilers, but dynamically
9785 allocated for additional compilers. Delete them for the latter. */
9786 for (int i
= n_default_compilers
; i
< n_compilers
; i
++)
9788 free (const_cast <char *> (compilers
[i
].suffix
));
9789 free (const_cast <char *> (compilers
[i
].spec
));
9791 XDELETEVEC (compilers
);
9795 linker_options
.truncate (0);
9796 assembler_options
.truncate (0);
9797 preprocessor_options
.truncate (0);
9799 path_prefix_reset (&exec_prefixes
);
9800 path_prefix_reset (&startfile_prefixes
);
9801 path_prefix_reset (&include_prefixes
);
9804 just_machine_suffix
= 0;
9805 gcc_exec_prefix
= 0;
9806 gcc_libexec_prefix
= 0;
9807 md_exec_prefix
= MD_EXEC_PREFIX
;
9808 md_startfile_prefix
= MD_STARTFILE_PREFIX
;
9809 md_startfile_prefix_1
= MD_STARTFILE_PREFIX_1
;
9811 multilib_os_dir
= 0;
9816 for (unsigned i
= 0; i
< ARRAY_SIZE (static_specs
); i
++)
9818 spec_list
*sl
= &static_specs
[i
];
9822 free (const_cast <char *> (*(sl
->ptr_spec
)));
9823 sl
->alloc_p
= false;
9825 *(sl
->ptr_spec
) = sl
->default_ptr
;
9831 processing_spec_function
= 0;
9833 argbuf
.truncate (0);
9839 execution_count
= 0;
9842 temp_filename
= NULL
;
9843 temp_filename_length
= 0;
9844 always_delete_queue
= NULL
;
9845 failure_delete_queue
= NULL
;
9847 XDELETEVEC (switches
);
9850 n_switches_alloc
= 0;
9853 compare_debug_second
= 0;
9854 compare_debug_opt
= NULL
;
9855 for (int i
= 0; i
< 2; i
++)
9857 switches_debug_check
[i
] = NULL
;
9858 n_switches_debug_check
[i
] = 0;
9859 n_switches_alloc_debug_check
[i
] = 0;
9860 debug_check_temp_file
[i
] = NULL
;
9863 XDELETEVEC (infiles
);
9866 n_infiles_alloc
= 0;
9868 combine_inputs
= false;
9869 added_libraries
= 0;
9870 XDELETEVEC (outfiles
);
9873 last_language_n_infiles
= 0;
9874 gcc_input_filename
= NULL
;
9875 input_file_number
= 0;
9876 input_filename_length
= 0;
9877 basename_length
= 0;
9878 suffixed_basename_length
= 0;
9879 input_basename
= NULL
;
9880 input_suffix
= NULL
;
9881 /* We don't need to purge "input_stat", just to unset "input_stat_set". */
9883 input_file_compiler
= NULL
;
9885 delete_this_arg
= 0;
9886 this_is_output_file
= 0;
9887 this_is_library_file
= 0;
9888 this_is_linker_script
= 0;
9889 input_from_pipe
= 0;
9890 suffix_subst
= NULL
;
9895 debug_auxbase_opt
= NULL
;
9897 used_arg
.finalize ();
9901 Targets can provide configure-time default options in
9902 OPTION_DEFAULT_SPECS. The jit needs to access these, but
9903 they are expressed in the spec language.
9905 Run just enough of the driver to be able to expand these
9906 specs, and then call the callback CB on each
9907 such option. The options strings are *without* a leading
9908 '-' character e.g. ("march=x86-64"). Finally, clean up. */
9911 driver_get_configure_time_options (void (*cb
) (const char *option
,
9917 obstack_init (&obstack
);
9918 gcc_obstack_init (&opts_obstack
);
9921 for (i
= 0; i
< ARRAY_SIZE (option_default_specs
); i
++)
9922 do_option_spec (option_default_specs
[i
].name
,
9923 option_default_specs
[i
].spec
);
9925 for (i
= 0; (int) i
< n_switches
; i
++)
9927 gcc_assert (switches
[i
].part1
);
9928 (*cb
) (switches
[i
].part1
, user_data
);
9931 obstack_free (&opts_obstack
, NULL
);
9932 obstack_free (&obstack
, NULL
);