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
))
2350 temp
= XNEW (struct temp_file
);
2351 temp
->next
= always_delete_queue
;
2353 always_delete_queue
= temp
;
2360 struct temp_file
*temp
;
2361 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2362 if (! filename_cmp (name
, temp
->name
))
2368 temp
= XNEW (struct temp_file
);
2369 temp
->next
= failure_delete_queue
;
2371 failure_delete_queue
= temp
;
2377 /* Delete all the temporary files whose names we previously recorded. */
2379 #ifndef DELETE_IF_ORDINARY
2380 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2383 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2384 if (unlink (NAME) < 0) \
2386 perror_with_name (NAME); \
2391 delete_if_ordinary (const char *name
)
2397 printf ("Delete %s? (y or n) ", name
);
2401 while ((c
= getchar ()) != '\n' && c
!= EOF
)
2404 if (i
== 'y' || i
== 'Y')
2406 DELETE_IF_ORDINARY (name
, st
, verbose_flag
);
2410 delete_temp_files (void)
2412 struct temp_file
*temp
;
2414 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2415 delete_if_ordinary (temp
->name
);
2416 always_delete_queue
= 0;
2419 /* Delete all the files to be deleted on error. */
2422 delete_failure_queue (void)
2424 struct temp_file
*temp
;
2426 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2427 delete_if_ordinary (temp
->name
);
2431 clear_failure_queue (void)
2433 failure_delete_queue
= 0;
2436 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2438 If DO_MULTI is true iterate over the paths twice, first with multilib
2439 suffix then without, otherwise iterate over the paths once without
2440 adding a multilib suffix. When DO_MULTI is true, some attempt is made
2441 to avoid visiting the same path twice, but we could do better. For
2442 instance, /usr/lib/../lib is considered different from /usr/lib.
2443 At least EXTRA_SPACE chars past the end of the path passed to
2444 CALLBACK are available for use by the callback.
2445 CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2447 Returns the value returned by CALLBACK. */
2450 for_each_path (const struct path_prefix
*paths
,
2453 void *(*callback
) (char *, void *),
2454 void *callback_info
)
2456 struct prefix_list
*pl
;
2457 const char *multi_dir
= NULL
;
2458 const char *multi_os_dir
= NULL
;
2459 const char *multiarch_suffix
= NULL
;
2460 const char *multi_suffix
;
2461 const char *just_multi_suffix
;
2464 bool skip_multi_dir
= false;
2465 bool skip_multi_os_dir
= false;
2467 multi_suffix
= machine_suffix
;
2468 just_multi_suffix
= just_machine_suffix
;
2469 if (do_multi
&& multilib_dir
&& strcmp (multilib_dir
, ".") != 0)
2471 multi_dir
= concat (multilib_dir
, dir_separator_str
, NULL
);
2472 multi_suffix
= concat (multi_suffix
, multi_dir
, NULL
);
2473 just_multi_suffix
= concat (just_multi_suffix
, multi_dir
, NULL
);
2475 if (do_multi
&& multilib_os_dir
&& strcmp (multilib_os_dir
, ".") != 0)
2476 multi_os_dir
= concat (multilib_os_dir
, dir_separator_str
, NULL
);
2478 multiarch_suffix
= concat (multiarch_dir
, dir_separator_str
, NULL
);
2482 size_t multi_dir_len
= 0;
2483 size_t multi_os_dir_len
= 0;
2484 size_t multiarch_len
= 0;
2486 size_t just_suffix_len
;
2490 multi_dir_len
= strlen (multi_dir
);
2492 multi_os_dir_len
= strlen (multi_os_dir
);
2493 if (multiarch_suffix
)
2494 multiarch_len
= strlen (multiarch_suffix
);
2495 suffix_len
= strlen (multi_suffix
);
2496 just_suffix_len
= strlen (just_multi_suffix
);
2500 len
= paths
->max_len
+ extra_space
+ 1;
2501 len
+= MAX (MAX (suffix_len
, multi_os_dir_len
), multiarch_len
);
2502 path
= XNEWVEC (char, len
);
2505 for (pl
= paths
->plist
; pl
!= 0; pl
= pl
->next
)
2507 len
= strlen (pl
->prefix
);
2508 memcpy (path
, pl
->prefix
, len
);
2510 /* Look first in MACHINE/VERSION subdirectory. */
2511 if (!skip_multi_dir
)
2513 memcpy (path
+ len
, multi_suffix
, suffix_len
+ 1);
2514 ret
= callback (path
, callback_info
);
2519 /* Some paths are tried with just the machine (ie. target)
2520 subdir. This is used for finding as, ld, etc. */
2522 && pl
->require_machine_suffix
== 2)
2524 memcpy (path
+ len
, just_multi_suffix
, just_suffix_len
+ 1);
2525 ret
= callback (path
, callback_info
);
2530 /* Now try the multiarch path. */
2532 && !pl
->require_machine_suffix
&& multiarch_dir
)
2534 memcpy (path
+ len
, multiarch_suffix
, multiarch_len
+ 1);
2535 ret
= callback (path
, callback_info
);
2540 /* Now try the base path. */
2541 if (!pl
->require_machine_suffix
2542 && !(pl
->os_multilib
? skip_multi_os_dir
: skip_multi_dir
))
2544 const char *this_multi
;
2545 size_t this_multi_len
;
2547 if (pl
->os_multilib
)
2549 this_multi
= multi_os_dir
;
2550 this_multi_len
= multi_os_dir_len
;
2554 this_multi
= multi_dir
;
2555 this_multi_len
= multi_dir_len
;
2559 memcpy (path
+ len
, this_multi
, this_multi_len
+ 1);
2563 ret
= callback (path
, callback_info
);
2571 if (multi_dir
== NULL
&& multi_os_dir
== NULL
)
2574 /* Run through the paths again, this time without multilibs.
2575 Don't repeat any we have already seen. */
2578 free (CONST_CAST (char *, multi_dir
));
2580 free (CONST_CAST (char *, multi_suffix
));
2581 multi_suffix
= machine_suffix
;
2582 free (CONST_CAST (char *, just_multi_suffix
));
2583 just_multi_suffix
= just_machine_suffix
;
2586 skip_multi_dir
= true;
2589 free (CONST_CAST (char *, multi_os_dir
));
2590 multi_os_dir
= NULL
;
2593 skip_multi_os_dir
= true;
2598 free (CONST_CAST (char *, multi_dir
));
2599 free (CONST_CAST (char *, multi_suffix
));
2600 free (CONST_CAST (char *, just_multi_suffix
));
2603 free (CONST_CAST (char *, multi_os_dir
));
2609 /* Callback for build_search_list. Adds path to obstack being built. */
2611 struct add_to_obstack_info
{
2618 add_to_obstack (char *path
, void *data
)
2620 struct add_to_obstack_info
*info
= (struct add_to_obstack_info
*) data
;
2622 if (info
->check_dir
&& !is_directory (path
, false))
2625 if (!info
->first_time
)
2626 obstack_1grow (info
->ob
, PATH_SEPARATOR
);
2628 obstack_grow (info
->ob
, path
, strlen (path
));
2630 info
->first_time
= false;
2634 /* Add or change the value of an environment variable, outputting the
2635 change to standard error if in verbose mode. */
2637 xputenv (const char *string
)
2642 /* Build a list of search directories from PATHS.
2643 PREFIX is a string to prepend to the list.
2644 If CHECK_DIR_P is true we ensure the directory exists.
2645 If DO_MULTI is true, multilib paths are output first, then
2647 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2648 It is also used by the --print-search-dirs flag. */
2651 build_search_list (const struct path_prefix
*paths
, const char *prefix
,
2652 bool check_dir
, bool do_multi
)
2654 struct add_to_obstack_info info
;
2656 info
.ob
= &collect_obstack
;
2657 info
.check_dir
= check_dir
;
2658 info
.first_time
= true;
2660 obstack_grow (&collect_obstack
, prefix
, strlen (prefix
));
2661 obstack_1grow (&collect_obstack
, '=');
2663 for_each_path (paths
, do_multi
, 0, add_to_obstack
, &info
);
2665 obstack_1grow (&collect_obstack
, '\0');
2666 return XOBFINISH (&collect_obstack
, char *);
2669 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2673 putenv_from_prefixes (const struct path_prefix
*paths
, const char *env_var
,
2676 xputenv (build_search_list (paths
, env_var
, true, do_multi
));
2679 /* Check whether NAME can be accessed in MODE. This is like access,
2680 except that it never considers directories to be executable. */
2683 access_check (const char *name
, int mode
)
2689 if (stat (name
, &st
) < 0
2690 || S_ISDIR (st
.st_mode
))
2694 return access (name
, mode
);
2697 /* Callback for find_a_file. Appends the file name to the directory
2698 path. If the resulting file exists in the right mode, return the
2699 full pathname to the file. */
2701 struct file_at_path_info
{
2710 file_at_path (char *path
, void *data
)
2712 struct file_at_path_info
*info
= (struct file_at_path_info
*) data
;
2713 size_t len
= strlen (path
);
2715 memcpy (path
+ len
, info
->name
, info
->name_len
);
2716 len
+= info
->name_len
;
2718 /* Some systems have a suffix for executable files.
2719 So try appending that first. */
2720 if (info
->suffix_len
)
2722 memcpy (path
+ len
, info
->suffix
, info
->suffix_len
+ 1);
2723 if (access_check (path
, info
->mode
) == 0)
2728 if (access_check (path
, info
->mode
) == 0)
2734 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2735 access to check permissions. If DO_MULTI is true, search multilib
2736 paths then non-multilib paths, otherwise do not search multilib paths.
2737 Return 0 if not found, otherwise return its name, allocated with malloc. */
2740 find_a_file (const struct path_prefix
*pprefix
, const char *name
, int mode
,
2743 struct file_at_path_info info
;
2745 #ifdef DEFAULT_ASSEMBLER
2746 if (! strcmp (name
, "as") && access (DEFAULT_ASSEMBLER
, mode
) == 0)
2747 return xstrdup (DEFAULT_ASSEMBLER
);
2750 #ifdef DEFAULT_LINKER
2751 if (! strcmp (name
, "ld") && access (DEFAULT_LINKER
, mode
) == 0)
2752 return xstrdup (DEFAULT_LINKER
);
2755 /* Determine the filename to execute (special case for absolute paths). */
2757 if (IS_ABSOLUTE_PATH (name
))
2759 if (access (name
, mode
) == 0)
2760 return xstrdup (name
);
2766 info
.suffix
= (mode
& X_OK
) != 0 ? HOST_EXECUTABLE_SUFFIX
: "";
2767 info
.name_len
= strlen (info
.name
);
2768 info
.suffix_len
= strlen (info
.suffix
);
2771 return (char*) for_each_path (pprefix
, do_multi
,
2772 info
.name_len
+ info
.suffix_len
,
2773 file_at_path
, &info
);
2776 /* Ranking of prefixes in the sort list. -B prefixes are put before
2779 enum path_prefix_priority
2781 PREFIX_PRIORITY_B_OPT
,
2782 PREFIX_PRIORITY_LAST
2785 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
2786 order according to PRIORITY. Within each PRIORITY, new entries are
2789 If WARN is nonzero, we will warn if no file is found
2790 through this prefix. WARN should point to an int
2791 which will be set to 1 if this entry is used.
2793 COMPONENT is the value to be passed to update_path.
2795 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2796 the complete value of machine_suffix.
2797 2 means try both machine_suffix and just_machine_suffix. */
2800 add_prefix (struct path_prefix
*pprefix
, const char *prefix
,
2801 const char *component
, /* enum prefix_priority */ int priority
,
2802 int require_machine_suffix
, int os_multilib
)
2804 struct prefix_list
*pl
, **prev
;
2807 for (prev
= &pprefix
->plist
;
2808 (*prev
) != NULL
&& (*prev
)->priority
<= priority
;
2809 prev
= &(*prev
)->next
)
2812 /* Keep track of the longest prefix. */
2814 prefix
= update_path (prefix
, component
);
2815 len
= strlen (prefix
);
2816 if (len
> pprefix
->max_len
)
2817 pprefix
->max_len
= len
;
2819 pl
= XNEW (struct prefix_list
);
2820 pl
->prefix
= prefix
;
2821 pl
->require_machine_suffix
= require_machine_suffix
;
2822 pl
->priority
= priority
;
2823 pl
->os_multilib
= os_multilib
;
2825 /* Insert after PREV. */
2830 /* Same as add_prefix, but prepending target_system_root to prefix. */
2831 /* The target_system_root prefix has been relocated by gcc_exec_prefix. */
2833 add_sysrooted_prefix (struct path_prefix
*pprefix
, const char *prefix
,
2834 const char *component
,
2835 /* enum prefix_priority */ int priority
,
2836 int require_machine_suffix
, int os_multilib
)
2838 if (!IS_ABSOLUTE_PATH (prefix
))
2839 fatal_error (input_location
, "system path %qs is not absolute", prefix
);
2841 if (target_system_root
)
2843 char *sysroot_no_trailing_dir_separator
= xstrdup (target_system_root
);
2844 size_t sysroot_len
= strlen (target_system_root
);
2847 && target_system_root
[sysroot_len
- 1] == DIR_SEPARATOR
)
2848 sysroot_no_trailing_dir_separator
[sysroot_len
- 1] = '\0';
2850 if (target_sysroot_suffix
)
2851 prefix
= concat (sysroot_no_trailing_dir_separator
,
2852 target_sysroot_suffix
, prefix
, NULL
);
2854 prefix
= concat (sysroot_no_trailing_dir_separator
, prefix
, NULL
);
2856 free (sysroot_no_trailing_dir_separator
);
2858 /* We have to override this because GCC's notion of sysroot
2859 moves along with GCC. */
2863 add_prefix (pprefix
, prefix
, component
, priority
,
2864 require_machine_suffix
, os_multilib
);
2867 /* Execute the command specified by the arguments on the current line of spec.
2868 When using pipes, this includes several piped-together commands
2869 with `|' between them.
2871 Return 0 if successful, -1 if failed. */
2877 int n_commands
; /* # of command. */
2879 struct pex_obj
*pex
;
2882 const char *prog
; /* program name. */
2883 const char **argv
; /* vector of args. */
2887 struct command
*commands
; /* each command buffer with above info. */
2889 gcc_assert (!processing_spec_function
);
2893 string
= find_a_file (&exec_prefixes
,
2894 argbuf
[0], X_OK
, false);
2897 insert_wrapper (wrapper_string
);
2900 /* Count # of piped commands. */
2901 for (n_commands
= 1, i
= 0; argbuf
.iterate (i
, &arg
); i
++)
2902 if (strcmp (arg
, "|") == 0)
2905 /* Get storage for each command. */
2906 commands
= (struct command
*) alloca (n_commands
* sizeof (struct command
));
2908 /* Split argbuf into its separate piped processes,
2909 and record info about each one.
2910 Also search for the programs that are to be run. */
2912 argbuf
.safe_push (0);
2914 commands
[0].prog
= argbuf
[0]; /* first command. */
2915 commands
[0].argv
= argbuf
.address ();
2917 if (!wrapper_string
)
2919 string
= find_a_file (&exec_prefixes
, commands
[0].prog
, X_OK
, false);
2920 commands
[0].argv
[0] = (string
) ? string
: commands
[0].argv
[0];
2923 for (n_commands
= 1, i
= 0; argbuf
.iterate (i
, &arg
); i
++)
2924 if (arg
&& strcmp (arg
, "|") == 0)
2925 { /* each command. */
2926 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2927 fatal_error (input_location
, "-pipe not supported");
2929 argbuf
[i
] = 0; /* Termination of
2931 commands
[n_commands
].prog
= argbuf
[i
+ 1];
2932 commands
[n_commands
].argv
2933 = &(argbuf
.address ())[i
+ 1];
2934 string
= find_a_file (&exec_prefixes
, commands
[n_commands
].prog
,
2937 commands
[n_commands
].argv
[0] = string
;
2941 /* If -v, print what we are about to do, and maybe query. */
2945 /* For help listings, put a blank line between sub-processes. */
2946 if (print_help_list
)
2947 fputc ('\n', stderr
);
2949 /* Print each piped command as a separate line. */
2950 for (i
= 0; i
< n_commands
; i
++)
2952 const char *const *j
;
2954 if (verbose_only_flag
)
2956 for (j
= commands
[i
].argv
; *j
; j
++)
2959 for (p
= *j
; *p
; ++p
)
2960 if (!ISALNUM ((unsigned char) *p
)
2961 && *p
!= '_' && *p
!= '/' && *p
!= '-' && *p
!= '.')
2965 fprintf (stderr
, " \"");
2966 for (p
= *j
; *p
; ++p
)
2968 if (*p
== '"' || *p
== '\\' || *p
== '$')
2969 fputc ('\\', stderr
);
2972 fputc ('"', stderr
);
2974 /* If it's empty, print "". */
2976 fprintf (stderr
, " \"\"");
2978 fprintf (stderr
, " %s", *j
);
2982 for (j
= commands
[i
].argv
; *j
; j
++)
2983 /* If it's empty, print "". */
2985 fprintf (stderr
, " \"\"");
2987 fprintf (stderr
, " %s", *j
);
2989 /* Print a pipe symbol after all but the last command. */
2990 if (i
+ 1 != n_commands
)
2991 fprintf (stderr
, " |");
2992 fprintf (stderr
, "\n");
2995 if (verbose_only_flag
!= 0)
2997 /* verbose_only_flag should act as if the spec was
2998 executed, so increment execution_count before
2999 returning. This prevents spurious warnings about
3000 unused linker input files, etc. */
3005 fnotice (stderr
, "\nGo ahead? (y or n) ");
3009 while (getchar () != '\n')
3012 if (i
!= 'y' && i
!= 'Y')
3017 #ifdef ENABLE_VALGRIND_CHECKING
3018 /* Run the each command through valgrind. To simplify prepending the
3019 path to valgrind and the option "-q" (for quiet operation unless
3020 something triggers), we allocate a separate argv array. */
3022 for (i
= 0; i
< n_commands
; i
++)
3028 for (argc
= 0; commands
[i
].argv
[argc
] != NULL
; argc
++)
3031 argv
= XALLOCAVEC (const char *, argc
+ 3);
3033 argv
[0] = VALGRIND_PATH
;
3035 for (j
= 2; j
< argc
+ 2; j
++)
3036 argv
[j
] = commands
[i
].argv
[j
- 2];
3039 commands
[i
].argv
= argv
;
3040 commands
[i
].prog
= argv
[0];
3044 /* Run each piped subprocess. */
3046 pex
= pex_init (PEX_USE_PIPES
| ((report_times
|| report_times_to_file
)
3047 ? PEX_RECORD_TIMES
: 0),
3048 progname
, temp_filename
);
3050 fatal_error (input_location
, "pex_init failed: %m");
3052 for (i
= 0; i
< n_commands
; i
++)
3056 const char *string
= commands
[i
].argv
[0];
3058 errmsg
= pex_run (pex
,
3059 ((i
+ 1 == n_commands
? PEX_LAST
: 0)
3060 | (string
== commands
[i
].prog
? PEX_SEARCH
: 0)),
3061 string
, CONST_CAST (char **, commands
[i
].argv
),
3066 fatal_error (input_location
, errmsg
);
3070 pfatal_with_name (errmsg
);
3074 if (i
&& string
!= commands
[i
].prog
)
3075 free (CONST_CAST (char *, string
));
3080 /* Wait for all the subprocesses to finish. */
3084 struct pex_time
*times
= NULL
;
3087 statuses
= (int *) alloca (n_commands
* sizeof (int));
3088 if (!pex_get_status (pex
, n_commands
, statuses
))
3089 fatal_error (input_location
, "failed to get exit status: %m");
3091 if (report_times
|| report_times_to_file
)
3093 times
= (struct pex_time
*) alloca (n_commands
* sizeof (struct pex_time
));
3094 if (!pex_get_times (pex
, n_commands
, times
))
3095 fatal_error (input_location
, "failed to get process times: %m");
3100 for (i
= 0; i
< n_commands
; ++i
)
3102 int status
= statuses
[i
];
3104 if (WIFSIGNALED (status
))
3107 /* SIGPIPE is a special case. It happens in -pipe mode
3108 when the compiler dies before the preprocessor is done,
3109 or the assembler dies before the compiler is done.
3110 There's generally been an error already, and this is
3111 just fallout. So don't generate another error unless
3112 we would otherwise have succeeded. */
3113 if (WTERMSIG (status
) == SIGPIPE
3114 && (signal_count
|| greatest_status
>= MIN_FATAL_STATUS
))
3121 internal_error_no_backtrace ("%s (program %s)",
3122 strsignal (WTERMSIG (status
)),
3125 else if (WIFEXITED (status
)
3126 && WEXITSTATUS (status
) >= MIN_FATAL_STATUS
)
3128 /* For ICEs in cc1, cc1obj, cc1plus see if it is
3129 reproducible or not. */
3132 && WEXITSTATUS (status
) == ICE_EXIT_CODE
3134 && (p
= strrchr (commands
[0].argv
[0], DIR_SEPARATOR
))
3135 && ! strncmp (p
+ 1, "cc1", 3))
3136 try_generate_repro (commands
[0].argv
);
3137 if (WEXITSTATUS (status
) > greatest_status
)
3138 greatest_status
= WEXITSTATUS (status
);
3142 if (report_times
|| report_times_to_file
)
3144 struct pex_time
*pt
= ×
[i
];
3147 ut
= ((double) pt
->user_seconds
3148 + (double) pt
->user_microseconds
/ 1.0e6
);
3149 st
= ((double) pt
->system_seconds
3150 + (double) pt
->system_microseconds
/ 1.0e6
);
3155 fnotice (stderr
, "# %s %.2f %.2f\n",
3156 commands
[i
].prog
, ut
, st
);
3158 if (report_times_to_file
)
3161 const char *const *j
;
3163 fprintf (report_times_to_file
, "%g %g", ut
, st
);
3165 for (j
= &commands
[i
].prog
; *j
; j
= &commands
[i
].argv
[++c
])
3168 for (p
= *j
; *p
; ++p
)
3169 if (*p
== '"' || *p
== '\\' || *p
== '$'
3175 fprintf (report_times_to_file
, " \"");
3176 for (p
= *j
; *p
; ++p
)
3178 if (*p
== '"' || *p
== '\\' || *p
== '$')
3179 fputc ('\\', report_times_to_file
);
3180 fputc (*p
, report_times_to_file
);
3182 fputc ('"', report_times_to_file
);
3185 fprintf (report_times_to_file
, " %s", *j
);
3188 fputc ('\n', report_times_to_file
);
3194 if (commands
[0].argv
[0] != commands
[0].prog
)
3195 free (CONST_CAST (char *, commands
[0].argv
[0]));
3201 /* Find all the switches given to us
3202 and make a vector describing them.
3203 The elements of the vector are strings, one per switch given.
3204 If a switch uses following arguments, then the `part1' field
3205 is the switch itself and the `args' field
3206 is a null-terminated vector containing the following arguments.
3207 Bits in the `live_cond' field are:
3208 SWITCH_LIVE to indicate this switch is true in a conditional spec.
3209 SWITCH_FALSE to indicate this switch is overridden by a later switch.
3210 SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
3211 SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored.
3212 SWITCH_KEEP_FOR_GCC to indicate that this switch, otherwise ignored,
3213 should be included in COLLECT_GCC_OPTIONS.
3214 in all do_spec calls afterwards. Used for %<S from self specs.
3215 The `known' field describes whether this is an internal switch.
3216 The `validated' field describes whether any spec has looked at this switch;
3217 if it remains false at the end of the run, the switch must be meaningless.
3218 The `ordering' field is used to temporarily mark switches that have to be
3219 kept in a specific order. */
3221 #define SWITCH_LIVE (1 << 0)
3222 #define SWITCH_FALSE (1 << 1)
3223 #define SWITCH_IGNORE (1 << 2)
3224 #define SWITCH_IGNORE_PERMANENTLY (1 << 3)
3225 #define SWITCH_KEEP_FOR_GCC (1 << 4)
3231 unsigned int live_cond
;
3237 static struct switchstr
*switches
;
3239 static int n_switches
;
3241 static int n_switches_alloc
;
3243 /* Set to zero if -fcompare-debug is disabled, positive if it's
3244 enabled and we're running the first compilation, negative if it's
3245 enabled and we're running the second compilation. For most of the
3246 time, it's in the range -1..1, but it can be temporarily set to 2
3247 or 3 to indicate that the -fcompare-debug flags didn't come from
3248 the command-line, but rather from the GCC_COMPARE_DEBUG environment
3249 variable, until a synthesized -fcompare-debug flag is added to the
3253 /* Set to nonzero if we've seen the -fcompare-debug-second flag. */
3254 int compare_debug_second
;
3256 /* Set to the flags that should be passed to the second compilation in
3257 a -fcompare-debug compilation. */
3258 const char *compare_debug_opt
;
3260 static struct switchstr
*switches_debug_check
[2];
3262 static int n_switches_debug_check
[2];
3264 static int n_switches_alloc_debug_check
[2];
3266 static char *debug_check_temp_file
[2];
3268 /* Language is one of three things:
3270 1) The name of a real programming language.
3271 2) NULL, indicating that no one has figured out
3273 3) '*', indicating that the file should be passed
3278 const char *language
;
3279 struct compiler
*incompiler
;
3284 /* Also a vector of input files specified. */
3286 static struct infile
*infiles
;
3290 static int n_infiles_alloc
;
3292 /* True if multiple input files are being compiled to a single
3295 static bool combine_inputs
;
3297 /* This counts the number of libraries added by lang_specific_driver, so that
3298 we can tell if there were any user supplied any files or libraries. */
3300 static int added_libraries
;
3302 /* And a vector of corresponding output files is made up later. */
3304 const char **outfiles
;
3306 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3308 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
3309 is true if we should look for an executable suffix. DO_OBJ
3310 is true if we should look for an object suffix. */
3313 convert_filename (const char *name
, int do_exe ATTRIBUTE_UNUSED
,
3314 int do_obj ATTRIBUTE_UNUSED
)
3316 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3324 len
= strlen (name
);
3326 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3327 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
3328 if (do_obj
&& len
> 2
3329 && name
[len
- 2] == '.'
3330 && name
[len
- 1] == 'o')
3332 obstack_grow (&obstack
, name
, len
- 2);
3333 obstack_grow0 (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
3334 name
= XOBFINISH (&obstack
, const char *);
3338 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3339 /* If there is no filetype, make it the executable suffix (which includes
3340 the "."). But don't get confused if we have just "-o". */
3341 if (! do_exe
|| TARGET_EXECUTABLE_SUFFIX
[0] == 0 || (len
== 2 && name
[0] == '-'))
3344 for (i
= len
- 1; i
>= 0; i
--)
3345 if (IS_DIR_SEPARATOR (name
[i
]))
3348 for (i
++; i
< len
; i
++)
3352 obstack_grow (&obstack
, name
, len
);
3353 obstack_grow0 (&obstack
, TARGET_EXECUTABLE_SUFFIX
,
3354 strlen (TARGET_EXECUTABLE_SUFFIX
));
3355 name
= XOBFINISH (&obstack
, const char *);
3362 /* Display the command line switches accepted by gcc. */
3366 printf (_("Usage: %s [options] file...\n"), progname
);
3367 fputs (_("Options:\n"), stdout
);
3369 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout
);
3370 fputs (_(" --help Display this information\n"), stdout
);
3371 fputs (_(" --target-help Display target specific command line options\n"), stdout
);
3372 fputs (_(" --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...]\n"), stdout
);
3373 fputs (_(" Display specific types of command line options\n"), stdout
);
3375 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout
);
3376 fputs (_(" --version Display compiler version information\n"), stdout
);
3377 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout
);
3378 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout
);
3379 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout
);
3380 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout
);
3381 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout
);
3382 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout
);
3383 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout
);
3385 -print-multiarch Display the target's normalized GNU triplet, used as\n\
3386 a component in the library path\n"), stdout
);
3387 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout
);
3389 -print-multi-lib Display the mapping between command line options and\n\
3390 multiple library search directories\n"), stdout
);
3391 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries\n"), stdout
);
3392 fputs (_(" -print-sysroot Display the target libraries directory\n"), stdout
);
3393 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n"), stdout
);
3394 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout
);
3395 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout
);
3396 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout
);
3397 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler\n"), stdout
);
3398 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n"), stdout
);
3399 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout
);
3400 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout
);
3401 fputs (_(" -save-temps=<arg> Do not delete intermediate files\n"), stdout
);
3403 -no-canonical-prefixes Do not canonicalize paths when building relative\n\
3404 prefixes to other gcc components\n"), stdout
);
3405 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout
);
3406 fputs (_(" -time Time the execution of each subprocess\n"), stdout
);
3407 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout
);
3408 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout
);
3410 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3411 and libraries\n"), stdout
);
3412 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout
);
3413 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout
);
3414 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout
);
3415 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout
);
3416 fputs (_(" -S Compile only; do not assemble or link\n"), stdout
);
3417 fputs (_(" -c Compile and assemble, but do not link\n"), stdout
);
3418 fputs (_(" -o <file> Place the output into <file>\n"), stdout
);
3419 fputs (_(" -pie Create a position independent executable\n"), stdout
);
3420 fputs (_(" -shared Create a shared library\n"), stdout
);
3422 -x <language> Specify the language of the following input files\n\
3423 Permissible languages include: c c++ assembler none\n\
3424 'none' means revert to the default behavior of\n\
3425 guessing the language based on the file's extension\n\
3429 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3430 passed on to the various sub-processes invoked by %s. In order to pass\n\
3431 other options on to these processes the -W<letter> options must be used.\n\
3434 /* The rest of the options are displayed by invocations of the various
3439 add_preprocessor_option (const char *option
, int len
)
3441 preprocessor_options
.safe_push (save_string (option
, len
));
3445 add_assembler_option (const char *option
, int len
)
3447 assembler_options
.safe_push (save_string (option
, len
));
3451 add_linker_option (const char *option
, int len
)
3453 linker_options
.safe_push (save_string (option
, len
));
3456 /* Allocate space for an input file in infiles. */
3461 if (n_infiles_alloc
== 0)
3463 n_infiles_alloc
= 16;
3464 infiles
= XNEWVEC (struct infile
, n_infiles_alloc
);
3466 else if (n_infiles_alloc
== n_infiles
)
3468 n_infiles_alloc
*= 2;
3469 infiles
= XRESIZEVEC (struct infile
, infiles
, n_infiles_alloc
);
3473 /* Store an input file with the given NAME and LANGUAGE in
3477 add_infile (const char *name
, const char *language
)
3480 infiles
[n_infiles
].name
= name
;
3481 infiles
[n_infiles
++].language
= language
;
3484 /* Allocate space for a switch in switches. */
3489 if (n_switches_alloc
== 0)
3491 n_switches_alloc
= 16;
3492 switches
= XNEWVEC (struct switchstr
, n_switches_alloc
);
3494 else if (n_switches_alloc
== n_switches
)
3496 n_switches_alloc
*= 2;
3497 switches
= XRESIZEVEC (struct switchstr
, switches
, n_switches_alloc
);
3501 /* Save an option OPT with N_ARGS arguments in array ARGS, marking it
3502 as validated if VALIDATED and KNOWN if it is an internal switch. */
3505 save_switch (const char *opt
, size_t n_args
, const char *const *args
,
3506 bool validated
, bool known
)
3509 switches
[n_switches
].part1
= opt
+ 1;
3511 switches
[n_switches
].args
= 0;
3514 switches
[n_switches
].args
= XNEWVEC (const char *, n_args
+ 1);
3515 memcpy (switches
[n_switches
].args
, args
, n_args
* sizeof (const char *));
3516 switches
[n_switches
].args
[n_args
] = NULL
;
3519 switches
[n_switches
].live_cond
= 0;
3520 switches
[n_switches
].validated
= validated
;
3521 switches
[n_switches
].known
= known
;
3522 switches
[n_switches
].ordering
= 0;
3526 /* Handle an option DECODED that is unknown to the option-processing
3530 driver_unknown_option_callback (const struct cl_decoded_option
*decoded
)
3532 const char *opt
= decoded
->arg
;
3533 if (opt
[1] == 'W' && opt
[2] == 'n' && opt
[3] == 'o' && opt
[4] == '-'
3534 && !(decoded
->errors
& CL_ERR_NEGATIVE
))
3536 /* Leave unknown -Wno-* options for the compiler proper, to be
3537 diagnosed only if there are warnings. */
3538 save_switch (decoded
->canonical_option
[0],
3539 decoded
->canonical_option_num_elements
- 1,
3540 &decoded
->canonical_option
[1], false, true);
3543 if (decoded
->opt_index
== OPT_SPECIAL_unknown
)
3545 /* Give it a chance to define it a spec file. */
3546 save_switch (decoded
->canonical_option
[0],
3547 decoded
->canonical_option_num_elements
- 1,
3548 &decoded
->canonical_option
[1], false, false);
3555 /* Handle an option DECODED that is not marked as CL_DRIVER.
3556 LANG_MASK will always be CL_DRIVER. */
3559 driver_wrong_lang_callback (const struct cl_decoded_option
*decoded
,
3560 unsigned int lang_mask ATTRIBUTE_UNUSED
)
3562 /* At this point, non-driver options are accepted (and expected to
3563 be passed down by specs) unless marked to be rejected by the
3564 driver. Options to be rejected by the driver but accepted by the
3565 compilers proper are treated just like completely unknown
3567 const struct cl_option
*option
= &cl_options
[decoded
->opt_index
];
3569 if (option
->cl_reject_driver
)
3570 error ("unrecognized command line option %qs",
3571 decoded
->orig_option_with_args_text
);
3573 save_switch (decoded
->canonical_option
[0],
3574 decoded
->canonical_option_num_elements
- 1,
3575 &decoded
->canonical_option
[1], false, true);
3578 static const char *spec_lang
= 0;
3579 static int last_language_n_infiles
;
3581 /* Parse -foffload option argument. */
3584 handle_foffload_option (const char *arg
)
3586 const char *c
, *cur
, *n
, *next
, *end
;
3589 /* If option argument starts with '-' then no target is specified and we
3590 do not need to parse it. */
3594 end
= strchr (arg
, '=');
3596 end
= strchr (arg
, '\0');
3601 next
= strchr (cur
, ',');
3604 next
= (next
> end
) ? end
: next
;
3606 target
= XNEWVEC (char, next
- cur
+ 1);
3607 memcpy (target
, cur
, next
- cur
);
3608 target
[next
- cur
] = '\0';
3610 /* If 'disable' is passed to the option, stop parsing the option and clean
3611 the list of offload targets. */
3612 if (strcmp (target
, "disable") == 0)
3614 free (offload_targets
);
3615 offload_targets
= xstrdup ("");
3619 /* Check that GCC is configured to support the offload target. */
3620 c
= OFFLOAD_TARGETS
;
3623 n
= strchr (c
, ',');
3625 n
= strchr (c
, '\0');
3627 if (next
- cur
== n
- c
&& strncmp (target
, c
, n
- c
) == 0)
3630 c
= *n
? n
+ 1 : NULL
;
3634 fatal_error (input_location
,
3635 "GCC is not configured to support %s as offload target",
3638 if (!offload_targets
)
3640 offload_targets
= target
;
3645 /* Check that the target hasn't already presented in the list. */
3646 c
= offload_targets
;
3649 n
= strchr (c
, ':');
3651 n
= strchr (c
, '\0');
3653 if (next
- cur
== n
- c
&& strncmp (c
, target
, n
- c
) == 0)
3660 /* If duplicate is not found, append the target to the list. */
3663 size_t offload_targets_len
= strlen (offload_targets
);
3665 = XRESIZEVEC (char, offload_targets
,
3666 offload_targets_len
+ 1 + next
- cur
+ 1);
3667 offload_targets
[offload_targets_len
++] = ':';
3668 memcpy (offload_targets
+ offload_targets_len
, target
, next
- cur
+ 1);
3673 XDELETEVEC (target
);
3677 /* Handle a driver option; arguments and return value as for
3681 driver_handle_option (struct gcc_options
*opts
,
3682 struct gcc_options
*opts_set
,
3683 const struct cl_decoded_option
*decoded
,
3684 unsigned int lang_mask ATTRIBUTE_UNUSED
, int kind
,
3686 const struct cl_option_handlers
*handlers ATTRIBUTE_UNUSED
,
3687 diagnostic_context
*dc
)
3689 size_t opt_index
= decoded
->opt_index
;
3690 const char *arg
= decoded
->arg
;
3691 const char *compare_debug_replacement_opt
;
3692 int value
= decoded
->value
;
3693 bool validated
= false;
3694 bool do_save
= true;
3696 gcc_assert (opts
== &global_options
);
3697 gcc_assert (opts_set
== &global_options_set
);
3698 gcc_assert (kind
== DK_UNSPECIFIED
);
3699 gcc_assert (loc
== UNKNOWN_LOCATION
);
3700 gcc_assert (dc
== global_dc
);
3706 struct spec_list
*sl
;
3708 for (sl
= specs
; sl
; sl
= sl
->next
)
3709 printf ("*%s:\n%s\n\n", sl
->name
, *(sl
->ptr_spec
));
3710 if (link_command_spec
)
3711 printf ("*link_command:\n%s\n\n", link_command_spec
);
3715 case OPT_dumpversion
:
3716 printf ("%s\n", spec_version
);
3719 case OPT_dumpmachine
:
3720 printf ("%s\n", spec_machine
);
3726 /* CPP driver cannot obtain switch from cc1_options. */
3728 add_preprocessor_option ("--version", strlen ("--version"));
3729 add_assembler_option ("--version", strlen ("--version"));
3730 add_linker_option ("--version", strlen ("--version"));
3734 print_help_list
= 1;
3736 /* CPP driver cannot obtain switch from cc1_options. */
3738 add_preprocessor_option ("--help", 6);
3739 add_assembler_option ("--help", 6);
3740 add_linker_option ("--help", 6);
3744 print_subprocess_help
= 2;
3747 case OPT__target_help
:
3748 print_subprocess_help
= 1;
3750 /* CPP driver cannot obtain switch from cc1_options. */
3752 add_preprocessor_option ("--target-help", 13);
3753 add_assembler_option ("--target-help", 13);
3754 add_linker_option ("--target-help", 13);
3757 case OPT__no_sysroot_suffix
:
3758 case OPT_pass_exit_codes
:
3759 case OPT_print_search_dirs
:
3760 case OPT_print_file_name_
:
3761 case OPT_print_prog_name_
:
3762 case OPT_print_multi_lib
:
3763 case OPT_print_multi_directory
:
3764 case OPT_print_sysroot
:
3765 case OPT_print_multi_os_directory
:
3766 case OPT_print_multiarch
:
3767 case OPT_print_sysroot_headers_suffix
:
3770 /* These options set the variables specified in common.opt
3771 automatically, and do not need to be saved for spec
3776 case OPT_print_libgcc_file_name
:
3777 print_file_name
= "libgcc.a";
3781 case OPT_fuse_ld_bfd
:
3785 case OPT_fuse_ld_gold
:
3789 case OPT_fcompare_debug_second
:
3790 compare_debug_second
= 1;
3793 case OPT_fcompare_debug
:
3797 compare_debug_replacement_opt
= "-fcompare-debug=";
3799 goto compare_debug_with_arg
;
3802 compare_debug_replacement_opt
= "-fcompare-debug=-gtoggle";
3804 goto compare_debug_with_arg
;
3811 case OPT_fcompare_debug_
:
3812 compare_debug_replacement_opt
= decoded
->canonical_option
[0];
3813 compare_debug_with_arg
:
3814 gcc_assert (decoded
->canonical_option_num_elements
== 1);
3815 gcc_assert (arg
!= NULL
);
3820 if (compare_debug
< 0)
3821 compare_debug_opt
= NULL
;
3823 compare_debug_opt
= arg
;
3824 save_switch (compare_debug_replacement_opt
, 0, NULL
, validated
, true);
3827 case OPT_fdiagnostics_color_
:
3828 diagnostic_color_init (dc
, value
);
3834 /* Pass the rest of this option to the assembler. */
3836 /* Split the argument at commas. */
3838 for (j
= 0; arg
[j
]; j
++)
3841 add_assembler_option (arg
+ prev
, j
- prev
);
3845 /* Record the part after the last comma. */
3846 add_assembler_option (arg
+ prev
, j
- prev
);
3854 /* Pass the rest of this option to the preprocessor. */
3856 /* Split the argument at commas. */
3858 for (j
= 0; arg
[j
]; j
++)
3861 add_preprocessor_option (arg
+ prev
, j
- prev
);
3865 /* Record the part after the last comma. */
3866 add_preprocessor_option (arg
+ prev
, j
- prev
);
3874 /* Split the argument at commas. */
3876 for (j
= 0; arg
[j
]; j
++)
3879 add_infile (save_string (arg
+ prev
, j
- prev
), "*");
3882 /* Record the part after the last comma. */
3883 add_infile (arg
+ prev
, "*");
3889 add_infile (arg
, "*");
3893 case OPT_Xpreprocessor
:
3894 add_preprocessor_option (arg
, strlen (arg
));
3898 case OPT_Xassembler
:
3899 add_assembler_option (arg
, strlen (arg
));
3904 /* POSIX allows separation of -l and the lib arg; canonicalize
3905 by concatenating -l with its arg */
3906 add_infile (concat ("-l", arg
, NULL
), "*");
3911 /* Similarly, canonicalize -L for linkers that may not accept
3912 separate arguments. */
3913 save_switch (concat ("-L", arg
, NULL
), 0, NULL
, validated
, true);
3918 save_switch (concat ("-F", arg
, NULL
), 0, NULL
, validated
, true);
3921 case OPT_save_temps
:
3922 save_temps_flag
= SAVE_TEMPS_CWD
;
3926 case OPT_save_temps_
:
3927 if (strcmp (arg
, "cwd") == 0)
3928 save_temps_flag
= SAVE_TEMPS_CWD
;
3929 else if (strcmp (arg
, "obj") == 0
3930 || strcmp (arg
, "object") == 0)
3931 save_temps_flag
= SAVE_TEMPS_OBJ
;
3933 fatal_error (input_location
, "%qs is an unknown -save-temps option",
3934 decoded
->orig_option_with_args_text
);
3937 case OPT_no_canonical_prefixes
:
3938 /* Already handled as a special case, so ignored here. */
3944 /* These options set the variables specified in common.opt
3945 automatically, but do need to be saved for spec
3951 struct user_specs
*user
= XNEW (struct user_specs
);
3953 user
->next
= (struct user_specs
*) 0;
3954 user
->filename
= arg
;
3955 if (user_specs_tail
)
3956 user_specs_tail
->next
= user
;
3958 user_specs_head
= user
;
3959 user_specs_tail
= user
;
3965 target_system_root
= arg
;
3966 target_system_root_changed
= 1;
3971 if (report_times_to_file
)
3972 fclose (report_times_to_file
);
3973 report_times_to_file
= fopen (arg
, "a");
3979 This is similar to -v except that there is no execution
3980 of the commands and the echoed arguments are quoted. It
3981 is intended for use in shell scripts to capture the
3982 driver-generated command line. */
3983 verbose_only_flag
++;
3990 size_t len
= strlen (arg
);
3992 /* Catch the case where the user has forgotten to append a
3993 directory separator to the path. Note, they may be using
3994 -B to add an executable name prefix, eg "i386-elf-", in
3995 order to distinguish between multiple installations of
3996 GCC in the same directory. Hence we must check to see
3997 if appending a directory separator actually makes a
3998 valid directory name. */
3999 if (!IS_DIR_SEPARATOR (arg
[len
- 1])
4000 && is_directory (arg
, false))
4002 char *tmp
= XNEWVEC (char, len
+ 2);
4004 tmp
[len
] = DIR_SEPARATOR
;
4009 add_prefix (&exec_prefixes
, arg
, NULL
,
4010 PREFIX_PRIORITY_B_OPT
, 0, 0);
4011 add_prefix (&startfile_prefixes
, arg
, NULL
,
4012 PREFIX_PRIORITY_B_OPT
, 0, 0);
4013 add_prefix (&include_prefixes
, arg
, NULL
,
4014 PREFIX_PRIORITY_B_OPT
, 0, 0);
4021 if (!strcmp (spec_lang
, "none"))
4022 /* Suppress the warning if -xnone comes after the last input
4023 file, because alternate command interfaces like g++ might
4024 find it useful to place -xnone after each input file. */
4027 last_language_n_infiles
= n_infiles
;
4033 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
4034 arg
= convert_filename (arg
, ! have_c
, 0);
4037 /* Save the output name in case -save-temps=obj was used. */
4038 save_temps_prefix
= xstrdup (arg
);
4039 /* On some systems, ld cannot handle "-o" without a space. So
4040 split the option from its argument. */
4041 save_switch ("-o", 1, &arg
, validated
, true);
4044 #ifdef ENABLE_DEFAULT_PIE
4046 /* -pie is turned on by default. */
4049 case OPT_static_libgcc
:
4050 case OPT_shared_libgcc
:
4051 case OPT_static_libgfortran
:
4052 case OPT_static_libstdc__
:
4053 /* These are always valid, since gcc.c itself understands the
4054 first two, gfortranspec.c understands -static-libgfortran and
4055 g++spec.c understands -static-libstdc++ */
4064 handle_foffload_option (arg
);
4068 /* Various driver options need no special processing at this
4069 point, having been handled in a prescan above or being
4070 handled by specs. */
4075 save_switch (decoded
->canonical_option
[0],
4076 decoded
->canonical_option_num_elements
- 1,
4077 &decoded
->canonical_option
[1], validated
, true);
4081 /* Put the driver's standard set of option handlers in *HANDLERS. */
4084 set_option_handlers (struct cl_option_handlers
*handlers
)
4086 handlers
->unknown_option_callback
= driver_unknown_option_callback
;
4087 handlers
->wrong_lang_callback
= driver_wrong_lang_callback
;
4088 handlers
->num_handlers
= 3;
4089 handlers
->handlers
[0].handler
= driver_handle_option
;
4090 handlers
->handlers
[0].mask
= CL_DRIVER
;
4091 handlers
->handlers
[1].handler
= common_handle_option
;
4092 handlers
->handlers
[1].mask
= CL_COMMON
;
4093 handlers
->handlers
[2].handler
= target_handle_option
;
4094 handlers
->handlers
[2].mask
= CL_TARGET
;
4097 /* Create the vector `switches' and its contents.
4098 Store its length in `n_switches'. */
4101 process_command (unsigned int decoded_options_count
,
4102 struct cl_decoded_option
*decoded_options
)
4106 char *tooldir_prefix
, *tooldir_prefix2
;
4107 char *(*get_relative_prefix
) (const char *, const char *,
4108 const char *) = NULL
;
4109 struct cl_option_handlers handlers
;
4112 gcc_exec_prefix
= env
.get ("GCC_EXEC_PREFIX");
4116 added_libraries
= 0;
4118 /* Figure compiler version from version string. */
4120 compiler_version
= temp1
= xstrdup (version_string
);
4122 for (; *temp1
; ++temp1
)
4131 /* Handle any -no-canonical-prefixes flag early, to assign the function
4132 that builds relative prefixes. This function creates default search
4133 paths that are needed later in normal option handling. */
4135 for (j
= 1; j
< decoded_options_count
; j
++)
4137 if (decoded_options
[j
].opt_index
== OPT_no_canonical_prefixes
)
4139 get_relative_prefix
= make_relative_prefix_ignore_links
;
4143 if (! get_relative_prefix
)
4144 get_relative_prefix
= make_relative_prefix
;
4146 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
4147 see if we can create it from the pathname specified in
4148 decoded_options[0].arg. */
4150 gcc_libexec_prefix
= standard_libexec_prefix
;
4152 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
4153 if (!gcc_exec_prefix
)
4155 gcc_exec_prefix
= get_relative_prefix (decoded_options
[0].arg
,
4156 standard_bindir_prefix
,
4157 standard_exec_prefix
);
4158 gcc_libexec_prefix
= get_relative_prefix (decoded_options
[0].arg
,
4159 standard_bindir_prefix
,
4160 standard_libexec_prefix
);
4161 if (gcc_exec_prefix
)
4162 xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix
, NULL
));
4166 /* make_relative_prefix requires a program name, but
4167 GCC_EXEC_PREFIX is typically a directory name with a trailing
4168 / (which is ignored by make_relative_prefix), so append a
4170 char *tmp_prefix
= concat (gcc_exec_prefix
, "gcc", NULL
);
4171 gcc_libexec_prefix
= get_relative_prefix (tmp_prefix
,
4172 standard_exec_prefix
,
4173 standard_libexec_prefix
);
4175 /* The path is unrelocated, so fallback to the original setting. */
4176 if (!gcc_libexec_prefix
)
4177 gcc_libexec_prefix
= standard_libexec_prefix
;
4183 /* From this point onward, gcc_exec_prefix is non-null if the toolchain
4184 is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
4185 or an automatically created GCC_EXEC_PREFIX from
4186 decoded_options[0].arg. */
4188 /* Do language-specific adjustment/addition of flags. */
4189 lang_specific_driver (&decoded_options
, &decoded_options_count
,
4192 if (gcc_exec_prefix
)
4194 int len
= strlen (gcc_exec_prefix
);
4196 if (len
> (int) sizeof ("/lib/gcc/") - 1
4197 && (IS_DIR_SEPARATOR (gcc_exec_prefix
[len
-1])))
4199 temp
= gcc_exec_prefix
+ len
- sizeof ("/lib/gcc/") + 1;
4200 if (IS_DIR_SEPARATOR (*temp
)
4201 && filename_ncmp (temp
+ 1, "lib", 3) == 0
4202 && IS_DIR_SEPARATOR (temp
[4])
4203 && filename_ncmp (temp
+ 5, "gcc", 3) == 0)
4204 len
-= sizeof ("/lib/gcc/") - 1;
4207 set_std_prefix (gcc_exec_prefix
, len
);
4208 add_prefix (&exec_prefixes
, gcc_libexec_prefix
, "GCC",
4209 PREFIX_PRIORITY_LAST
, 0, 0);
4210 add_prefix (&startfile_prefixes
, gcc_exec_prefix
, "GCC",
4211 PREFIX_PRIORITY_LAST
, 0, 0);
4214 /* COMPILER_PATH and LIBRARY_PATH have values
4215 that are lists of directory names with colons. */
4217 temp
= env
.get ("COMPILER_PATH");
4220 const char *startp
, *endp
;
4221 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4223 startp
= endp
= temp
;
4226 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4228 strncpy (nstore
, startp
, endp
- startp
);
4230 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4231 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4233 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4234 nstore
[endp
- startp
+ 1] = 0;
4237 nstore
[endp
- startp
] = 0;
4238 add_prefix (&exec_prefixes
, nstore
, 0,
4239 PREFIX_PRIORITY_LAST
, 0, 0);
4240 add_prefix (&include_prefixes
, nstore
, 0,
4241 PREFIX_PRIORITY_LAST
, 0, 0);
4244 endp
= startp
= endp
+ 1;
4251 temp
= env
.get (LIBRARY_PATH_ENV
);
4252 if (temp
&& *cross_compile
== '0')
4254 const char *startp
, *endp
;
4255 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4257 startp
= endp
= temp
;
4260 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4262 strncpy (nstore
, startp
, endp
- startp
);
4264 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4265 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4267 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4268 nstore
[endp
- startp
+ 1] = 0;
4271 nstore
[endp
- startp
] = 0;
4272 add_prefix (&startfile_prefixes
, nstore
, NULL
,
4273 PREFIX_PRIORITY_LAST
, 0, 1);
4276 endp
= startp
= endp
+ 1;
4283 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
4284 temp
= env
.get ("LPATH");
4285 if (temp
&& *cross_compile
== '0')
4287 const char *startp
, *endp
;
4288 char *nstore
= (char *) alloca (strlen (temp
) + 3);
4290 startp
= endp
= temp
;
4293 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
4295 strncpy (nstore
, startp
, endp
- startp
);
4297 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
4298 else if (!IS_DIR_SEPARATOR (endp
[-1]))
4300 nstore
[endp
- startp
] = DIR_SEPARATOR
;
4301 nstore
[endp
- startp
+ 1] = 0;
4304 nstore
[endp
- startp
] = 0;
4305 add_prefix (&startfile_prefixes
, nstore
, NULL
,
4306 PREFIX_PRIORITY_LAST
, 0, 1);
4309 endp
= startp
= endp
+ 1;
4316 /* Process the options and store input files and switches in their
4319 last_language_n_infiles
= -1;
4321 set_option_handlers (&handlers
);
4323 for (j
= 1; j
< decoded_options_count
; j
++)
4325 switch (decoded_options
[j
].opt_index
)
4337 for (j
= 1; j
< decoded_options_count
; j
++)
4339 if (decoded_options
[j
].opt_index
== OPT_SPECIAL_input_file
)
4341 const char *arg
= decoded_options
[j
].arg
;
4342 const char *p
= strrchr (arg
, '@');
4346 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4347 arg
= convert_filename (arg
, 0, access (arg
, F_OK
));
4349 /* For LTO static archive support we handle input file
4350 specifications that are composed of a filename and
4351 an offset like FNAME@OFFSET. */
4354 && sscanf (p
, "@%li%n", &offset
, &consumed
) >= 1
4355 && strlen (p
) == (unsigned int)consumed
)
4357 fname
= (char *)xmalloc (p
- arg
+ 1);
4358 memcpy (fname
, arg
, p
- arg
);
4359 fname
[p
- arg
] = '\0';
4360 /* Only accept non-stdin and existing FNAME parts, otherwise
4361 try with the full name. */
4362 if (strcmp (fname
, "-") == 0 || access (fname
, F_OK
) < 0)
4365 fname
= xstrdup (arg
);
4369 fname
= xstrdup (arg
);
4371 if (strcmp (fname
, "-") != 0 && access (fname
, F_OK
) < 0)
4372 perror_with_name (fname
);
4374 add_infile (arg
, spec_lang
);
4380 read_cmdline_option (&global_options
, &global_options_set
,
4381 decoded_options
+ j
, UNKNOWN_LOCATION
,
4382 CL_DRIVER
, &handlers
, global_dc
);
4385 #ifdef ENABLE_OFFLOADING
4386 /* If the user didn't specify any, default to all configured offload
4388 if (offload_targets
== NULL
)
4389 handle_foffload_option (OFFLOAD_TARGETS
);
4393 && strcmp (output_file
, "-") != 0
4394 && strcmp (output_file
, HOST_BIT_BUCKET
) != 0)
4397 for (i
= 0; i
< n_infiles
; i
++)
4398 if ((!infiles
[i
].language
|| infiles
[i
].language
[0] != '*')
4399 && canonical_filename_eq (infiles
[i
].name
, output_file
))
4400 fatal_error (input_location
,
4401 "input file %qs is the same as output file",
4405 /* If -save-temps=obj and -o name, create the prefix to use for %b.
4406 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
4407 if (save_temps_flag
== SAVE_TEMPS_OBJ
&& save_temps_prefix
!= NULL
)
4409 save_temps_length
= strlen (save_temps_prefix
);
4410 temp
= strrchr (lbasename (save_temps_prefix
), '.');
4413 save_temps_length
-= strlen (temp
);
4414 save_temps_prefix
[save_temps_length
] = '\0';
4418 else if (save_temps_prefix
!= NULL
)
4420 free (save_temps_prefix
);
4421 save_temps_prefix
= NULL
;
4424 if (save_temps_flag
&& use_pipes
)
4426 /* -save-temps overrides -pipe, so that temp files are produced */
4427 if (save_temps_flag
)
4428 warning (0, "-pipe ignored because -save-temps specified");
4434 const char *gcd
= env
.get ("GCC_COMPARE_DEBUG");
4436 if (gcd
&& gcd
[0] == '-')
4439 compare_debug_opt
= gcd
;
4441 else if (gcd
&& *gcd
&& strcmp (gcd
, "0"))
4444 compare_debug_opt
= "-gtoggle";
4447 else if (compare_debug
< 0)
4450 gcc_assert (!compare_debug_opt
);
4453 /* Set up the search paths. We add directories that we expect to
4454 contain GNU Toolchain components before directories specified by
4455 the machine description so that we will find GNU components (like
4456 the GNU assembler) before those of the host system. */
4458 /* If we don't know where the toolchain has been installed, use the
4459 configured-in locations. */
4460 if (!gcc_exec_prefix
)
4463 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "GCC",
4464 PREFIX_PRIORITY_LAST
, 1, 0);
4465 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "BINUTILS",
4466 PREFIX_PRIORITY_LAST
, 2, 0);
4467 add_prefix (&exec_prefixes
, standard_exec_prefix
, "BINUTILS",
4468 PREFIX_PRIORITY_LAST
, 2, 0);
4470 add_prefix (&startfile_prefixes
, standard_exec_prefix
, "BINUTILS",
4471 PREFIX_PRIORITY_LAST
, 1, 0);
4474 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix
));
4475 tooldir_prefix2
= concat (tooldir_base_prefix
, spec_host_machine
,
4476 dir_separator_str
, NULL
);
4478 /* Look for tools relative to the location from which the driver is
4479 running, or, if that is not available, the configured prefix. */
4481 = concat (gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
4482 spec_host_machine
, dir_separator_str
, spec_version
,
4483 accel_dir_suffix
, dir_separator_str
, tooldir_prefix2
, NULL
);
4484 free (tooldir_prefix2
);
4486 add_prefix (&exec_prefixes
,
4487 concat (tooldir_prefix
, "bin", dir_separator_str
, NULL
),
4488 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 0);
4489 add_prefix (&startfile_prefixes
,
4490 concat (tooldir_prefix
, "lib", dir_separator_str
, NULL
),
4491 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 1);
4492 free (tooldir_prefix
);
4494 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
4495 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
4496 then consider it to relocate with the rest of the GCC installation
4497 if GCC_EXEC_PREFIX is set.
4498 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
4499 if (target_system_root
&& !target_system_root_changed
&& gcc_exec_prefix
)
4501 char *tmp_prefix
= get_relative_prefix (decoded_options
[0].arg
,
4502 standard_bindir_prefix
,
4503 target_system_root
);
4504 if (tmp_prefix
&& access_check (tmp_prefix
, F_OK
) == 0)
4506 target_system_root
= tmp_prefix
;
4507 target_system_root_changed
= 1;
4512 /* More prefixes are enabled in main, after we read the specs file
4513 and determine whether this is cross-compilation or not. */
4515 if (n_infiles
== last_language_n_infiles
&& spec_lang
!= 0)
4516 warning (0, "%<-x %s%> after last input file has no effect", spec_lang
);
4518 /* Synthesize -fcompare-debug flag from the GCC_COMPARE_DEBUG
4519 environment variable. */
4520 if (compare_debug
== 2 || compare_debug
== 3)
4522 const char *opt
= concat ("-fcompare-debug=", compare_debug_opt
, NULL
);
4523 save_switch (opt
, 0, NULL
, false, true);
4527 /* Ensure we only invoke each subprocess once. */
4528 if (print_subprocess_help
|| print_help_list
|| print_version
)
4532 /* Create a dummy input file, so that we can pass
4533 the help option on to the various sub-processes. */
4534 add_infile ("help-dummy", "c");
4538 switches
[n_switches
].part1
= 0;
4540 infiles
[n_infiles
].name
= 0;
4543 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4544 and place that in the environment. */
4547 set_collect_gcc_options (void)
4552 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4554 obstack_grow (&collect_obstack
, "COLLECT_GCC_OPTIONS=",
4555 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4558 for (i
= 0; (int) i
< n_switches
; i
++)
4560 const char *const *args
;
4563 obstack_grow (&collect_obstack
, " ", 1);
4567 /* Ignore elided switches. */
4568 if ((switches
[i
].live_cond
4569 & (SWITCH_IGNORE
| SWITCH_KEEP_FOR_GCC
))
4573 obstack_grow (&collect_obstack
, "'-", 2);
4574 q
= switches
[i
].part1
;
4575 while ((p
= strchr (q
, '\'')))
4577 obstack_grow (&collect_obstack
, q
, p
- q
);
4578 obstack_grow (&collect_obstack
, "'\\''", 4);
4581 obstack_grow (&collect_obstack
, q
, strlen (q
));
4582 obstack_grow (&collect_obstack
, "'", 1);
4584 for (args
= switches
[i
].args
; args
&& *args
; args
++)
4586 obstack_grow (&collect_obstack
, " '", 2);
4588 while ((p
= strchr (q
, '\'')))
4590 obstack_grow (&collect_obstack
, q
, p
- q
);
4591 obstack_grow (&collect_obstack
, "'\\''", 4);
4594 obstack_grow (&collect_obstack
, q
, strlen (q
));
4595 obstack_grow (&collect_obstack
, "'", 1);
4598 obstack_grow (&collect_obstack
, "\0", 1);
4599 xputenv (XOBFINISH (&collect_obstack
, char *));
4602 /* Process a spec string, accumulating and running commands. */
4604 /* These variables describe the input file name.
4605 input_file_number is the index on outfiles of this file,
4606 so that the output file name can be stored for later use by %o.
4607 input_basename is the start of the part of the input file
4608 sans all directory names, and basename_length is the number
4609 of characters starting there excluding the suffix .c or whatever. */
4611 static const char *gcc_input_filename
;
4612 static int input_file_number
;
4613 size_t input_filename_length
;
4614 static int basename_length
;
4615 static int suffixed_basename_length
;
4616 static const char *input_basename
;
4617 static const char *input_suffix
;
4618 #ifndef HOST_LACKS_INODE_NUMBERS
4619 static struct stat input_stat
;
4621 static int input_stat_set
;
4623 /* The compiler used to process the current input file. */
4624 static struct compiler
*input_file_compiler
;
4626 /* These are variables used within do_spec and do_spec_1. */
4628 /* Nonzero if an arg has been started and not yet terminated
4629 (with space, tab or newline). */
4630 static int arg_going
;
4632 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4633 is a temporary file name. */
4634 static int delete_this_arg
;
4636 /* Nonzero means %w has been seen; the next arg to be terminated
4637 is the output file name of this compilation. */
4638 static int this_is_output_file
;
4640 /* Nonzero means %s has been seen; the next arg to be terminated
4641 is the name of a library file and we should try the standard
4642 search dirs for it. */
4643 static int this_is_library_file
;
4645 /* Nonzero means %T has been seen; the next arg to be terminated
4646 is the name of a linker script and we should try all of the
4647 standard search dirs for it. If it is found insert a --script
4648 command line switch and then substitute the full path in place,
4649 otherwise generate an error message. */
4650 static int this_is_linker_script
;
4652 /* Nonzero means that the input of this command is coming from a pipe. */
4653 static int input_from_pipe
;
4655 /* Nonnull means substitute this for any suffix when outputting a switches
4657 static const char *suffix_subst
;
4659 /* If there is an argument being accumulated, terminate it and store it. */
4662 end_going_arg (void)
4668 obstack_1grow (&obstack
, 0);
4669 string
= XOBFINISH (&obstack
, const char *);
4670 if (this_is_library_file
)
4671 string
= find_file (string
);
4672 if (this_is_linker_script
)
4674 char * full_script_path
= find_a_file (&startfile_prefixes
, string
, R_OK
, true);
4676 if (full_script_path
== NULL
)
4678 error ("unable to locate default linker script %qs in the library search paths", string
);
4679 /* Script was not found on search path. */
4682 store_arg ("--script", false, false);
4683 string
= full_script_path
;
4685 store_arg (string
, delete_this_arg
, this_is_output_file
);
4686 if (this_is_output_file
)
4687 outfiles
[input_file_number
] = string
;
4693 /* Parse the WRAPPER string which is a comma separated list of the command line
4694 and insert them into the beginning of argbuf. */
4697 insert_wrapper (const char *wrapper
)
4701 char *buf
= xstrdup (wrapper
);
4703 unsigned int old_length
= argbuf
.length ();
4711 while ((p
= strchr (p
, ',')) != NULL
);
4713 argbuf
.safe_grow (old_length
+ n
);
4714 memmove (argbuf
.address () + n
,
4716 old_length
* sizeof (const_char_p
));
4730 while ((p
= strchr (p
, ',')) != NULL
);
4731 gcc_assert (i
== n
);
4734 /* Process the spec SPEC and run the commands specified therein.
4735 Returns 0 if the spec is successfully processed; -1 if failed. */
4738 do_spec (const char *spec
)
4742 value
= do_spec_2 (spec
);
4744 /* Force out any unfinished command.
4745 If -pipe, this forces out the last command if it ended in `|'. */
4748 if (argbuf
.length () > 0
4749 && !strcmp (argbuf
.last (), "|"))
4752 set_collect_gcc_options ();
4754 if (argbuf
.length () > 0)
4762 do_spec_2 (const char *spec
)
4768 delete_this_arg
= 0;
4769 this_is_output_file
= 0;
4770 this_is_library_file
= 0;
4771 this_is_linker_script
= 0;
4772 input_from_pipe
= 0;
4773 suffix_subst
= NULL
;
4775 result
= do_spec_1 (spec
, 0, NULL
);
4783 /* Process the given spec string and add any new options to the end
4784 of the switches/n_switches array. */
4787 do_option_spec (const char *name
, const char *spec
)
4789 unsigned int i
, value_count
, value_len
;
4790 const char *p
, *q
, *value
;
4791 char *tmp_spec
, *tmp_spec_p
;
4793 if (configure_default_options
[0].name
== NULL
)
4796 for (i
= 0; i
< ARRAY_SIZE (configure_default_options
); i
++)
4797 if (strcmp (configure_default_options
[i
].name
, name
) == 0)
4799 if (i
== ARRAY_SIZE (configure_default_options
))
4802 value
= configure_default_options
[i
].value
;
4803 value_len
= strlen (value
);
4805 /* Compute the size of the final spec. */
4808 while ((p
= strstr (p
, "%(VALUE)")) != NULL
)
4814 /* Replace each %(VALUE) by the specified value. */
4815 tmp_spec
= (char *) alloca (strlen (spec
) + 1
4816 + value_count
* (value_len
- strlen ("%(VALUE)")));
4817 tmp_spec_p
= tmp_spec
;
4819 while ((p
= strstr (q
, "%(VALUE)")) != NULL
)
4821 memcpy (tmp_spec_p
, q
, p
- q
);
4822 tmp_spec_p
= tmp_spec_p
+ (p
- q
);
4823 memcpy (tmp_spec_p
, value
, value_len
);
4824 tmp_spec_p
+= value_len
;
4825 q
= p
+ strlen ("%(VALUE)");
4827 strcpy (tmp_spec_p
, q
);
4829 do_self_spec (tmp_spec
);
4832 /* Process the given spec string and add any new options to the end
4833 of the switches/n_switches array. */
4836 do_self_spec (const char *spec
)
4841 do_spec_1 (" ", 0, NULL
);
4843 /* Mark %<S switches processed by do_self_spec to be ignored permanently.
4844 do_self_specs adds the replacements to switches array, so it shouldn't
4845 be processed afterwards. */
4846 for (i
= 0; i
< n_switches
; i
++)
4847 if ((switches
[i
].live_cond
& SWITCH_IGNORE
))
4848 switches
[i
].live_cond
|= SWITCH_IGNORE_PERMANENTLY
;
4850 if (argbuf
.length () > 0)
4852 const char **argbuf_copy
;
4853 struct cl_decoded_option
*decoded_options
;
4854 struct cl_option_handlers handlers
;
4855 unsigned int decoded_options_count
;
4858 /* Create a copy of argbuf with a dummy argv[0] entry for
4859 decode_cmdline_options_to_array. */
4860 argbuf_copy
= XNEWVEC (const char *,
4861 argbuf
.length () + 1);
4862 argbuf_copy
[0] = "";
4863 memcpy (argbuf_copy
+ 1, argbuf
.address (),
4864 argbuf
.length () * sizeof (const char *));
4866 decode_cmdline_options_to_array (argbuf
.length () + 1,
4868 CL_DRIVER
, &decoded_options
,
4869 &decoded_options_count
);
4872 set_option_handlers (&handlers
);
4874 for (j
= 1; j
< decoded_options_count
; j
++)
4876 switch (decoded_options
[j
].opt_index
)
4878 case OPT_SPECIAL_input_file
:
4879 /* Specs should only generate options, not input
4881 if (strcmp (decoded_options
[j
].arg
, "-") != 0)
4882 fatal_error (input_location
,
4883 "switch %qs does not start with %<-%>",
4884 decoded_options
[j
].arg
);
4886 fatal_error (input_location
,
4887 "spec-generated switch is just %<-%>");
4890 case OPT_fcompare_debug_second
:
4891 case OPT_fcompare_debug
:
4892 case OPT_fcompare_debug_
:
4894 /* Avoid duplicate processing of some options from
4895 compare-debug specs; just save them here. */
4896 save_switch (decoded_options
[j
].canonical_option
[0],
4897 (decoded_options
[j
].canonical_option_num_elements
4899 &decoded_options
[j
].canonical_option
[1], false, true);
4903 read_cmdline_option (&global_options
, &global_options_set
,
4904 decoded_options
+ j
, UNKNOWN_LOCATION
,
4905 CL_DRIVER
, &handlers
, global_dc
);
4910 free (decoded_options
);
4913 switches
[n_switches
].part1
= 0;
4917 /* Callback for processing %D and %I specs. */
4919 struct spec_path_info
{
4924 bool separate_options
;
4928 spec_path (char *path
, void *data
)
4930 struct spec_path_info
*info
= (struct spec_path_info
*) data
;
4934 if (info
->omit_relative
&& !IS_ABSOLUTE_PATH (path
))
4937 if (info
->append_len
!= 0)
4939 len
= strlen (path
);
4940 memcpy (path
+ len
, info
->append
, info
->append_len
+ 1);
4943 if (!is_directory (path
, true))
4946 do_spec_1 (info
->option
, 1, NULL
);
4947 if (info
->separate_options
)
4948 do_spec_1 (" ", 0, NULL
);
4950 if (info
->append_len
== 0)
4952 len
= strlen (path
);
4953 save
= path
[len
- 1];
4954 if (IS_DIR_SEPARATOR (path
[len
- 1]))
4955 path
[len
- 1] = '\0';
4958 do_spec_1 (path
, 1, NULL
);
4959 do_spec_1 (" ", 0, NULL
);
4961 /* Must not damage the original path. */
4962 if (info
->append_len
== 0)
4963 path
[len
- 1] = save
;
4968 /* Create a temporary FILE with the contents of ARGV. Add @FILE to the
4972 create_at_file (char **argv
)
4974 char *temp_file
= make_temp_file ("");
4975 char *at_argument
= concat ("@", temp_file
, NULL
);
4976 FILE *f
= fopen (temp_file
, "w");
4980 fatal_error (input_location
, "could not open temporary response file %s",
4983 status
= writeargv (argv
, f
);
4986 fatal_error (input_location
,
4987 "could not write to temporary response file %s",
4990 status
= fclose (f
);
4993 fatal_error (input_location
, "could not close temporary response file %s",
4996 store_arg (at_argument
, 0, 0);
4998 record_temp_file (temp_file
, !save_temps_flag
, !save_temps_flag
);
5001 /* True if we should compile INFILE. */
5004 compile_input_file_p (struct infile
*infile
)
5006 if ((!infile
->language
) || (infile
->language
[0] != '*'))
5007 if (infile
->incompiler
== input_file_compiler
)
5012 /* Process each member of VEC as a spec. */
5015 do_specs_vec (vec
<char_p
> vec
)
5020 FOR_EACH_VEC_ELT (vec
, ix
, opt
)
5022 do_spec_1 (opt
, 1, NULL
);
5023 /* Make each accumulated option a separate argument. */
5024 do_spec_1 (" ", 0, NULL
);
5028 /* Process the sub-spec SPEC as a portion of a larger spec.
5029 This is like processing a whole spec except that we do
5030 not initialize at the beginning and we do not supply a
5031 newline by default at the end.
5032 INSWITCH nonzero means don't process %-sequences in SPEC;
5033 in this case, % is treated as an ordinary character.
5034 This is used while substituting switches.
5035 INSWITCH nonzero also causes SPC not to terminate an argument.
5037 Value is zero unless a line was finished
5038 and the command on that line reported an error. */
5041 do_spec_1 (const char *spec
, int inswitch
, const char *soft_matched_part
)
5043 const char *p
= spec
;
5048 /* If it's an empty string argument to a switch, keep it as is. */
5049 if (inswitch
&& !*p
)
5053 /* If substituting a switch, treat all chars like letters.
5054 Otherwise, NL, SPC, TAB and % are special. */
5055 switch (inswitch
? 'a' : c
)
5060 if (argbuf
.length () > 0
5061 && !strcmp (argbuf
.last (), "|"))
5063 /* A `|' before the newline means use a pipe here,
5064 but only if -pipe was specified.
5065 Otherwise, execute now and don't pass the `|' as an arg. */
5068 input_from_pipe
= 1;
5075 set_collect_gcc_options ();
5077 if (argbuf
.length () > 0)
5083 /* Reinitialize for a new command, and for a new argument. */
5086 delete_this_arg
= 0;
5087 this_is_output_file
= 0;
5088 this_is_library_file
= 0;
5089 this_is_linker_script
= 0;
5090 input_from_pipe
= 0;
5097 obstack_1grow (&obstack
, c
);
5105 /* Reinitialize for a new argument. */
5106 delete_this_arg
= 0;
5107 this_is_output_file
= 0;
5108 this_is_library_file
= 0;
5109 this_is_linker_script
= 0;
5116 fatal_error (input_location
, "spec %qs invalid", spec
);
5119 if (save_temps_length
)
5120 obstack_grow (&obstack
, save_temps_prefix
, save_temps_length
);
5122 obstack_grow (&obstack
, input_basename
, basename_length
);
5123 if (compare_debug
< 0)
5124 obstack_grow (&obstack
, ".gk", 3);
5129 if (save_temps_length
)
5130 obstack_grow (&obstack
, save_temps_prefix
, save_temps_length
);
5132 obstack_grow (&obstack
, input_basename
, suffixed_basename_length
);
5133 if (compare_debug
< 0)
5134 obstack_grow (&obstack
, ".gk", 3);
5139 delete_this_arg
= 2;
5142 /* Dump out the directories specified with LIBRARY_PATH,
5143 followed by the absolute directories
5144 that we search for startfiles. */
5147 struct spec_path_info info
;
5150 info
.append_len
= 0;
5151 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
5152 /* Used on systems which record the specified -L dirs
5153 and use them to search for dynamic linking.
5154 Relative directories always come from -B,
5155 and it is better not to use them for searching
5156 at run time. In particular, stage1 loses. */
5157 info
.omit_relative
= true;
5159 info
.omit_relative
= false;
5161 info
.separate_options
= false;
5163 for_each_path (&startfile_prefixes
, true, 0, spec_path
, &info
);
5168 /* %efoo means report an error with `foo' as error message
5169 and don't execute any more commands for this file. */
5173 while (*p
!= 0 && *p
!= '\n')
5175 buf
= (char *) alloca (p
- q
+ 1);
5176 strncpy (buf
, q
, p
- q
);
5178 error ("%s", _(buf
));
5183 /* %nfoo means report a notice with `foo' on stderr. */
5187 while (*p
!= 0 && *p
!= '\n')
5189 buf
= (char *) alloca (p
- q
+ 1);
5190 strncpy (buf
, q
, p
- q
);
5192 inform (0, "%s", _(buf
));
5202 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
5203 defined, and it is not a directory, and it is
5204 writable, use it. Otherwise, treat this like any
5205 other temporary file. */
5207 if ((!save_temps_flag
)
5208 && (stat (HOST_BIT_BUCKET
, &st
) == 0) && (!S_ISDIR (st
.st_mode
))
5209 && (access (HOST_BIT_BUCKET
, W_OK
) == 0))
5211 obstack_grow (&obstack
, HOST_BIT_BUCKET
,
5212 strlen (HOST_BIT_BUCKET
));
5213 delete_this_arg
= 0;
5218 goto create_temp_file
;
5222 obstack_1grow (&obstack
, '-');
5223 delete_this_arg
= 0;
5226 /* consume suffix */
5227 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
5229 if (p
[0] == '%' && p
[1] == 'O')
5234 goto create_temp_file
;
5238 /* consume suffix */
5239 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
5241 if (p
[0] == '%' && p
[1] == 'O')
5246 goto create_temp_file
;
5252 struct temp_name
*t
;
5254 const char *suffix
= p
;
5255 char *saved_suffix
= NULL
;
5257 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
5259 suffix_length
= p
- suffix
;
5260 if (p
[0] == '%' && p
[1] == 'O')
5263 /* We don't support extra suffix characters after %O. */
5264 if (*p
== '.' || ISALNUM ((unsigned char) *p
))
5265 fatal_error (input_location
,
5266 "spec %qs has invalid %<%%0%c%>", spec
, *p
);
5267 if (suffix_length
== 0)
5268 suffix
= TARGET_OBJECT_SUFFIX
;
5272 = XNEWVEC (char, suffix_length
5273 + strlen (TARGET_OBJECT_SUFFIX
) + 1);
5274 strncpy (saved_suffix
, suffix
, suffix_length
);
5275 strcpy (saved_suffix
+ suffix_length
,
5276 TARGET_OBJECT_SUFFIX
);
5278 suffix_length
+= strlen (TARGET_OBJECT_SUFFIX
);
5281 if (compare_debug
< 0)
5283 suffix
= concat (".gk", suffix
, NULL
);
5287 /* If -save-temps=obj and -o were specified, use that for the
5289 if (save_temps_length
)
5292 temp_filename_length
5293 = save_temps_length
+ suffix_length
+ 1;
5294 tmp
= (char *) alloca (temp_filename_length
);
5295 memcpy (tmp
, save_temps_prefix
, save_temps_length
);
5296 memcpy (tmp
+ save_temps_length
, suffix
, suffix_length
);
5297 tmp
[save_temps_length
+ suffix_length
] = '\0';
5298 temp_filename
= save_string (tmp
, save_temps_length
5300 obstack_grow (&obstack
, temp_filename
,
5301 temp_filename_length
);
5303 delete_this_arg
= 0;
5307 /* If the gcc_input_filename has the same suffix specified
5308 for the %g, %u, or %U, and -save-temps is specified,
5309 we could end up using that file as an intermediate
5310 thus clobbering the user's source file (.e.g.,
5311 gcc -save-temps foo.s would clobber foo.s with the
5312 output of cpp0). So check for this condition and
5313 generate a temp file as the intermediate. */
5315 if (save_temps_flag
)
5318 temp_filename_length
= basename_length
+ suffix_length
+ 1;
5319 tmp
= (char *) alloca (temp_filename_length
);
5320 memcpy (tmp
, input_basename
, basename_length
);
5321 memcpy (tmp
+ basename_length
, suffix
, suffix_length
);
5322 tmp
[basename_length
+ suffix_length
] = '\0';
5323 temp_filename
= tmp
;
5325 if (filename_cmp (temp_filename
, gcc_input_filename
) != 0)
5327 #ifndef HOST_LACKS_INODE_NUMBERS
5328 struct stat st_temp
;
5330 /* Note, set_input() resets input_stat_set to 0. */
5331 if (input_stat_set
== 0)
5333 input_stat_set
= stat (gcc_input_filename
,
5335 if (input_stat_set
>= 0)
5339 /* If we have the stat for the gcc_input_filename
5340 and we can do the stat for the temp_filename
5341 then the they could still refer to the same
5342 file if st_dev/st_ino's are the same. */
5343 if (input_stat_set
!= 1
5344 || stat (temp_filename
, &st_temp
) < 0
5345 || input_stat
.st_dev
!= st_temp
.st_dev
5346 || input_stat
.st_ino
!= st_temp
.st_ino
)
5348 /* Just compare canonical pathnames. */
5349 char* input_realname
= lrealpath (gcc_input_filename
);
5350 char* temp_realname
= lrealpath (temp_filename
);
5351 bool files_differ
= filename_cmp (input_realname
, temp_realname
);
5352 free (input_realname
);
5353 free (temp_realname
);
5357 temp_filename
= save_string (temp_filename
,
5358 temp_filename_length
+ 1);
5359 obstack_grow (&obstack
, temp_filename
,
5360 temp_filename_length
);
5362 delete_this_arg
= 0;
5368 /* See if we already have an association of %g/%u/%U and
5370 for (t
= temp_names
; t
; t
= t
->next
)
5371 if (t
->length
== suffix_length
5372 && strncmp (t
->suffix
, suffix
, suffix_length
) == 0
5373 && t
->unique
== (c
== 'u' || c
== 'U' || c
== 'j'))
5376 /* Make a new association if needed. %u and %j
5378 if (t
== 0 || c
== 'u' || c
== 'j')
5382 t
= XNEW (struct temp_name
);
5383 t
->next
= temp_names
;
5386 t
->length
= suffix_length
;
5389 t
->suffix
= saved_suffix
;
5390 saved_suffix
= NULL
;
5393 t
->suffix
= save_string (suffix
, suffix_length
);
5394 t
->unique
= (c
== 'u' || c
== 'U' || c
== 'j');
5395 temp_filename
= make_temp_file (t
->suffix
);
5396 temp_filename_length
= strlen (temp_filename
);
5397 t
->filename
= temp_filename
;
5398 t
->filename_length
= temp_filename_length
;
5401 free (saved_suffix
);
5403 obstack_grow (&obstack
, t
->filename
, t
->filename_length
);
5404 delete_this_arg
= 1;
5412 if (at_file_supplied
)
5414 /* We are going to expand `%i' to `@FILE', where FILE
5415 is a newly-created temporary filename. The filenames
5416 that would usually be expanded in place of %o will be
5417 written to the temporary file. */
5422 for (i
= 0; i
< n_infiles
; i
++)
5423 if (compile_input_file_p (&infiles
[i
]))
5426 argv
= (char **) alloca (sizeof (char *) * (n_files
+ 1));
5428 /* Copy the strings over. */
5429 for (i
= 0, j
= 0; i
< n_infiles
; i
++)
5430 if (compile_input_file_p (&infiles
[i
]))
5432 argv
[j
] = CONST_CAST (char *, infiles
[i
].name
);
5433 infiles
[i
].compiled
= true;
5438 create_at_file (argv
);
5441 for (i
= 0; (int) i
< n_infiles
; i
++)
5442 if (compile_input_file_p (&infiles
[i
]))
5444 store_arg (infiles
[i
].name
, 0, 0);
5445 infiles
[i
].compiled
= true;
5450 obstack_grow (&obstack
, gcc_input_filename
,
5451 input_filename_length
);
5458 struct spec_path_info info
;
5462 do_spec_1 ("-imultilib", 1, NULL
);
5463 /* Make this a separate argument. */
5464 do_spec_1 (" ", 0, NULL
);
5465 do_spec_1 (multilib_dir
, 1, NULL
);
5466 do_spec_1 (" ", 0, NULL
);
5471 do_spec_1 ("-imultiarch", 1, NULL
);
5472 /* Make this a separate argument. */
5473 do_spec_1 (" ", 0, NULL
);
5474 do_spec_1 (multiarch_dir
, 1, NULL
);
5475 do_spec_1 (" ", 0, NULL
);
5478 if (gcc_exec_prefix
)
5480 do_spec_1 ("-iprefix", 1, NULL
);
5481 /* Make this a separate argument. */
5482 do_spec_1 (" ", 0, NULL
);
5483 do_spec_1 (gcc_exec_prefix
, 1, NULL
);
5484 do_spec_1 (" ", 0, NULL
);
5487 if (target_system_root_changed
||
5488 (target_system_root
&& target_sysroot_hdrs_suffix
))
5490 do_spec_1 ("-isysroot", 1, NULL
);
5491 /* Make this a separate argument. */
5492 do_spec_1 (" ", 0, NULL
);
5493 do_spec_1 (target_system_root
, 1, NULL
);
5494 if (target_sysroot_hdrs_suffix
)
5495 do_spec_1 (target_sysroot_hdrs_suffix
, 1, NULL
);
5496 do_spec_1 (" ", 0, NULL
);
5499 info
.option
= "-isystem";
5500 info
.append
= "include";
5501 info
.append_len
= strlen (info
.append
);
5502 info
.omit_relative
= false;
5503 info
.separate_options
= true;
5505 for_each_path (&include_prefixes
, false, info
.append_len
,
5508 info
.append
= "include-fixed";
5509 if (*sysroot_hdrs_suffix_spec
)
5510 info
.append
= concat (info
.append
, dir_separator_str
,
5511 multilib_dir
, NULL
);
5512 info
.append_len
= strlen (info
.append
);
5513 for_each_path (&include_prefixes
, false, info
.append_len
,
5520 int max
= n_infiles
;
5521 max
+= lang_specific_extra_outfiles
;
5523 if (HAVE_GNU_LD
&& at_file_supplied
)
5525 /* We are going to expand `%o' to `@FILE', where FILE
5526 is a newly-created temporary filename. The filenames
5527 that would usually be expanded in place of %o will be
5528 written to the temporary file. */
5533 /* Convert OUTFILES into a form suitable for writeargv. */
5535 /* Determine how many are non-NULL. */
5536 for (n_files
= 0, i
= 0; i
< max
; i
++)
5537 n_files
+= outfiles
[i
] != NULL
;
5539 argv
= (char **) alloca (sizeof (char *) * (n_files
+ 1));
5541 /* Copy the strings over. */
5542 for (i
= 0, j
= 0; i
< max
; i
++)
5545 argv
[j
] = CONST_CAST (char *, outfiles
[i
]);
5550 create_at_file (argv
);
5553 for (i
= 0; i
< max
; i
++)
5555 store_arg (outfiles
[i
], 0, 0);
5560 obstack_grow (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
5565 this_is_library_file
= 1;
5569 this_is_linker_script
= 1;
5573 outfiles
[input_file_number
] = NULL
;
5577 this_is_output_file
= 1;
5582 unsigned int cur_index
= argbuf
.length ();
5583 /* Handle the {...} following the %W. */
5585 fatal_error (input_location
,
5586 "spec %qs has invalid %<%%W%c%>", spec
, *p
);
5587 p
= handle_braces (p
+ 1);
5591 /* If any args were output, mark the last one for deletion
5593 if (argbuf
.length () != cur_index
)
5594 record_temp_file (argbuf
.last (), 0, 1);
5598 /* %x{OPTION} records OPTION for %X to output. */
5606 /* Skip past the option value and make a copy. */
5608 fatal_error (input_location
,
5609 "spec %qs has invalid %<%%x%c%>", spec
, *p
);
5612 string
= save_string (p1
+ 1, p
- p1
- 2);
5614 /* See if we already recorded this option. */
5615 FOR_EACH_VEC_ELT (linker_options
, ix
, opt
)
5616 if (! strcmp (string
, opt
))
5622 /* This option is new; add it. */
5623 add_linker_option (string
, strlen (string
));
5628 /* Dump out the options accumulated previously using %x. */
5630 do_specs_vec (linker_options
);
5633 /* Dump out the options accumulated previously using -Wa,. */
5635 do_specs_vec (assembler_options
);
5638 /* Dump out the options accumulated previously using -Wp,. */
5640 do_specs_vec (preprocessor_options
);
5643 /* Here are digits and numbers that just process
5644 a certain constant string as a spec. */
5647 value
= do_spec_1 (cc1_spec
, 0, NULL
);
5653 value
= do_spec_1 (cc1plus_spec
, 0, NULL
);
5659 value
= do_spec_1 (asm_spec
, 0, NULL
);
5665 value
= do_spec_1 (asm_final_spec
, 0, NULL
);
5672 const char *const spec
5673 = (input_file_compiler
->cpp_spec
5674 ? input_file_compiler
->cpp_spec
5676 value
= do_spec_1 (spec
, 0, NULL
);
5683 value
= do_spec_1 (endfile_spec
, 0, NULL
);
5689 value
= do_spec_1 (link_spec
, 0, NULL
);
5695 value
= do_spec_1 (lib_spec
, 0, NULL
);
5701 if (multilib_os_dir
== NULL
)
5702 obstack_1grow (&obstack
, '.');
5704 obstack_grow (&obstack
, multilib_os_dir
,
5705 strlen (multilib_os_dir
));
5709 value
= do_spec_1 (libgcc_spec
, 0, NULL
);
5715 /* We assume there is a directory
5716 separator at the end of this string. */
5717 if (target_system_root
)
5719 obstack_grow (&obstack
, target_system_root
,
5720 strlen (target_system_root
));
5721 if (target_sysroot_suffix
)
5722 obstack_grow (&obstack
, target_sysroot_suffix
,
5723 strlen (target_sysroot_suffix
));
5728 value
= do_spec_1 (startfile_spec
, 0, NULL
);
5733 /* Here we define characters other than letters and digits. */
5736 p
= handle_braces (p
);
5742 p
= handle_spec_function (p
, NULL
);
5748 obstack_1grow (&obstack
, '%');
5755 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '%')
5757 suffix_subst
= save_string (p
- 1, len
+ 1);
5762 /* Henceforth ignore the option(s) matching the pattern
5768 int have_wildcard
= 0;
5773 switch_option
= SWITCH_IGNORE
| SWITCH_KEEP_FOR_GCC
;
5775 switch_option
= SWITCH_IGNORE
;
5777 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '\t')
5780 if (p
[len
-1] == '*')
5783 for (i
= 0; i
< n_switches
; i
++)
5784 if (!strncmp (switches
[i
].part1
, p
, len
- have_wildcard
)
5785 && (have_wildcard
|| switches
[i
].part1
[len
] == '\0'))
5787 switches
[i
].live_cond
|= switch_option
;
5788 /* User switch be validated from validate_all_switches.
5789 when the definition is seen from the spec file.
5790 If not defined anywhere, will be rejected. */
5791 if (switches
[i
].known
)
5792 switches
[i
].validated
= true;
5800 if (soft_matched_part
)
5802 if (soft_matched_part
[0])
5803 do_spec_1 (soft_matched_part
, 1, NULL
);
5804 /* Only insert a space after the substitution if it is at the
5805 end of the current sequence. So if:
5807 "%{foo=*:bar%*}%{foo=*:one%*two}"
5809 matches -foo=hello then it will produce:
5811 barhello onehellotwo
5813 if (*p
== 0 || *p
== '}')
5814 do_spec_1 (" ", 0, NULL
);
5817 /* Catch the case where a spec string contains something like
5818 '%{foo:%*}'. i.e. there is no * in the pattern on the left
5819 hand side of the :. */
5820 error ("spec failure: %<%%*%> has not been initialized by pattern match");
5823 /* Process a string found as the value of a spec given by name.
5824 This feature allows individual machine descriptions
5825 to add and use their own specs. */
5828 const char *name
= p
;
5829 struct spec_list
*sl
;
5832 /* The string after the S/P is the name of a spec that is to be
5834 while (*p
&& *p
!= ')')
5837 /* See if it's in the list. */
5838 for (len
= p
- name
, sl
= specs
; sl
; sl
= sl
->next
)
5839 if (sl
->name_len
== len
&& !strncmp (sl
->name
, name
, len
))
5841 name
= *(sl
->ptr_spec
);
5843 fnotice (stderr
, "Processing spec (%s), which is '%s'\n",
5851 value
= do_spec_1 (name
, 0, NULL
);
5856 /* Discard the closing paren. */
5863 error ("spec failure: unrecognized spec option %qc", c
);
5869 /* Backslash: treat next character as ordinary. */
5874 /* Ordinary character: put it into the current argument. */
5875 obstack_1grow (&obstack
, c
);
5879 /* End of string. If we are processing a spec function, we need to
5880 end any pending argument. */
5881 if (processing_spec_function
)
5887 /* Look up a spec function. */
5889 static const struct spec_function
*
5890 lookup_spec_function (const char *name
)
5892 const struct spec_function
*sf
;
5894 for (sf
= static_spec_functions
; sf
->name
!= NULL
; sf
++)
5895 if (strcmp (sf
->name
, name
) == 0)
5901 /* Evaluate a spec function. */
5904 eval_spec_function (const char *func
, const char *args
)
5906 const struct spec_function
*sf
;
5907 const char *funcval
;
5909 /* Saved spec processing context. */
5910 vec
<const_char_p
> save_argbuf
;
5913 int save_delete_this_arg
;
5914 int save_this_is_output_file
;
5915 int save_this_is_library_file
;
5916 int save_input_from_pipe
;
5917 int save_this_is_linker_script
;
5918 const char *save_suffix_subst
;
5920 int save_growing_size
;
5921 void *save_growing_value
= NULL
;
5923 sf
= lookup_spec_function (func
);
5925 fatal_error (input_location
, "unknown spec function %qs", func
);
5927 /* Push the spec processing context. */
5928 save_argbuf
= argbuf
;
5930 save_arg_going
= arg_going
;
5931 save_delete_this_arg
= delete_this_arg
;
5932 save_this_is_output_file
= this_is_output_file
;
5933 save_this_is_library_file
= this_is_library_file
;
5934 save_this_is_linker_script
= this_is_linker_script
;
5935 save_input_from_pipe
= input_from_pipe
;
5936 save_suffix_subst
= suffix_subst
;
5938 /* If we have some object growing now, finalize it so the args and function
5939 eval proceed from a cleared context. This is needed to prevent the first
5940 constructed arg from mistakenly including the growing value. We'll push
5941 this value back on the obstack once the function evaluation is done, to
5942 restore a consistent processing context for our caller. This is fine as
5943 the address of growing objects isn't guaranteed to remain stable until
5944 they are finalized, and we expect this situation to be rare enough for
5945 the extra copy not to be an issue. */
5946 save_growing_size
= obstack_object_size (&obstack
);
5947 if (save_growing_size
> 0)
5948 save_growing_value
= obstack_finish (&obstack
);
5950 /* Create a new spec processing context, and build the function
5954 if (do_spec_2 (args
) < 0)
5955 fatal_error (input_location
, "error in args to spec function %qs", func
);
5957 /* argbuf_index is an index for the next argument to be inserted, and
5958 so contains the count of the args already inserted. */
5960 funcval
= (*sf
->func
) (argbuf
.length (),
5963 /* Pop the spec processing context. */
5965 argbuf
= save_argbuf
;
5967 arg_going
= save_arg_going
;
5968 delete_this_arg
= save_delete_this_arg
;
5969 this_is_output_file
= save_this_is_output_file
;
5970 this_is_library_file
= save_this_is_library_file
;
5971 this_is_linker_script
= save_this_is_linker_script
;
5972 input_from_pipe
= save_input_from_pipe
;
5973 suffix_subst
= save_suffix_subst
;
5975 if (save_growing_size
> 0)
5976 obstack_grow (&obstack
, save_growing_value
, save_growing_size
);
5981 /* Handle a spec function call of the form:
5985 ARGS is processed as a spec in a separate context and split into an
5986 argument vector in the normal fashion. The function returns a string
5987 containing a spec which we then process in the caller's context, or
5988 NULL if no processing is required.
5990 If RETVAL_NONNULL is not NULL, then store a bool whether function
5991 returned non-NULL. */
5994 handle_spec_function (const char *p
, bool *retval_nonnull
)
5997 const char *endp
, *funcval
;
6000 processing_spec_function
++;
6002 /* Get the function name. */
6003 for (endp
= p
; *endp
!= '\0'; endp
++)
6005 if (*endp
== '(') /* ) */
6007 /* Only allow [A-Za-z0-9], -, and _ in function names. */
6008 if (!ISALNUM (*endp
) && !(*endp
== '-' || *endp
== '_'))
6009 fatal_error (input_location
, "malformed spec function name");
6011 if (*endp
!= '(') /* ) */
6012 fatal_error (input_location
, "no arguments for spec function");
6013 func
= save_string (p
, endp
- p
);
6016 /* Get the arguments. */
6017 for (count
= 0; *endp
!= '\0'; endp
++)
6026 else if (*endp
== '(') /* ) */
6031 fatal_error (input_location
, "malformed spec function arguments");
6032 args
= save_string (p
, endp
- p
);
6035 /* p now points to just past the end of the spec function expression. */
6037 funcval
= eval_spec_function (func
, args
);
6038 if (funcval
!= NULL
&& do_spec_1 (funcval
, 0, NULL
) < 0)
6041 *retval_nonnull
= funcval
!= NULL
;
6046 processing_spec_function
--;
6051 /* Inline subroutine of handle_braces. Returns true if the current
6052 input suffix matches the atom bracketed by ATOM and END_ATOM. */
6054 input_suffix_matches (const char *atom
, const char *end_atom
)
6056 return (input_suffix
6057 && !strncmp (input_suffix
, atom
, end_atom
- atom
)
6058 && input_suffix
[end_atom
- atom
] == '\0');
6061 /* Subroutine of handle_braces. Returns true if the current
6062 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
6064 input_spec_matches (const char *atom
, const char *end_atom
)
6066 return (input_file_compiler
6067 && input_file_compiler
->suffix
6068 && input_file_compiler
->suffix
[0] != '\0'
6069 && !strncmp (input_file_compiler
->suffix
+ 1, atom
,
6071 && input_file_compiler
->suffix
[end_atom
- atom
+ 1] == '\0');
6074 /* Subroutine of handle_braces. Returns true if a switch
6075 matching the atom bracketed by ATOM and END_ATOM appeared on the
6078 switch_matches (const char *atom
, const char *end_atom
, int starred
)
6081 int len
= end_atom
- atom
;
6082 int plen
= starred
? len
: -1;
6084 for (i
= 0; i
< n_switches
; i
++)
6085 if (!strncmp (switches
[i
].part1
, atom
, len
)
6086 && (starred
|| switches
[i
].part1
[len
] == '\0')
6087 && check_live_switch (i
, plen
))
6090 /* Check if a switch with separated form matching the atom.
6091 We check -D and -U switches. */
6092 else if (switches
[i
].args
!= 0)
6094 if ((*switches
[i
].part1
== 'D' || *switches
[i
].part1
== 'U')
6095 && *switches
[i
].part1
== atom
[0])
6097 if (!strncmp (switches
[i
].args
[0], &atom
[1], len
- 1)
6098 && (starred
|| (switches
[i
].part1
[1] == '\0'
6099 && switches
[i
].args
[0][len
- 1] == '\0'))
6100 && check_live_switch (i
, (starred
? 1 : -1)))
6108 /* Inline subroutine of handle_braces. Mark all of the switches which
6109 match ATOM (extends to END_ATOM; STARRED indicates whether there
6110 was a star after the atom) for later processing. */
6112 mark_matching_switches (const char *atom
, const char *end_atom
, int starred
)
6115 int len
= end_atom
- atom
;
6116 int plen
= starred
? len
: -1;
6118 for (i
= 0; i
< n_switches
; i
++)
6119 if (!strncmp (switches
[i
].part1
, atom
, len
)
6120 && (starred
|| switches
[i
].part1
[len
] == '\0')
6121 && check_live_switch (i
, plen
))
6122 switches
[i
].ordering
= 1;
6125 /* Inline subroutine of handle_braces. Process all the currently
6126 marked switches through give_switch, and clear the marks. */
6128 process_marked_switches (void)
6132 for (i
= 0; i
< n_switches
; i
++)
6133 if (switches
[i
].ordering
== 1)
6135 switches
[i
].ordering
= 0;
6140 /* Handle a %{ ... } construct. P points just inside the leading {.
6141 Returns a pointer one past the end of the brace block, or 0
6142 if we call do_spec_1 and that returns -1. */
6145 handle_braces (const char *p
)
6147 const char *atom
, *end_atom
;
6148 const char *d_atom
= NULL
, *d_end_atom
= NULL
;
6149 const char *orig
= p
;
6157 bool a_must_be_last
= false;
6158 bool ordered_set
= false;
6159 bool disjunct_set
= false;
6160 bool disj_matched
= false;
6161 bool disj_starred
= true;
6162 bool n_way_choice
= false;
6163 bool n_way_matched
= false;
6165 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
6172 /* Scan one "atom" (S in the description above of %{}, possibly
6173 with '!', '.', '@', ',', or '*' modifiers). */
6175 a_is_suffix
= false;
6176 a_is_starred
= false;
6177 a_is_negated
= false;
6178 a_is_spectype
= false;
6182 p
++, a_is_negated
= true;
6185 if (*p
== '%' && p
[1] == ':')
6189 p
= handle_spec_function (p
+ 2, &a_matched
);
6194 p
++, a_is_suffix
= true;
6196 p
++, a_is_spectype
= true;
6199 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
6200 || *p
== ',' || *p
== '.' || *p
== '@')
6205 p
++, a_is_starred
= 1;
6212 /* Substitute the switch(es) indicated by the current atom. */
6214 if (disjunct_set
|| n_way_choice
|| a_is_negated
|| a_is_suffix
6215 || a_is_spectype
|| atom
== end_atom
)
6218 mark_matching_switches (atom
, end_atom
, a_is_starred
);
6221 process_marked_switches ();
6225 /* Substitute some text if the current atom appears as a switch
6227 disjunct_set
= true;
6231 if (atom
&& atom
== end_atom
)
6233 if (!n_way_choice
|| disj_matched
|| *p
== '|'
6234 || a_is_negated
|| a_is_suffix
|| a_is_spectype
6238 /* An empty term may appear as the last choice of an
6239 N-way choice set; it means "otherwise". */
6240 a_must_be_last
= true;
6241 disj_matched
= !n_way_matched
;
6242 disj_starred
= false;
6246 if ((a_is_suffix
|| a_is_spectype
) && a_is_starred
)
6250 disj_starred
= false;
6252 /* Don't bother testing this atom if we already have a
6254 if (!disj_matched
&& !n_way_matched
)
6257 /* a_matched is already set by handle_spec_function. */;
6258 else if (a_is_suffix
)
6259 a_matched
= input_suffix_matches (atom
, end_atom
);
6260 else if (a_is_spectype
)
6261 a_matched
= input_spec_matches (atom
, end_atom
);
6263 a_matched
= switch_matches (atom
, end_atom
, a_is_starred
);
6265 if (a_matched
!= a_is_negated
)
6267 disj_matched
= true;
6269 d_end_atom
= end_atom
;
6276 /* Found the body, that is, the text to substitute if the
6277 current disjunction matches. */
6278 p
= process_brace_body (p
+ 1, d_atom
, d_end_atom
, disj_starred
,
6279 disj_matched
&& !n_way_matched
);
6283 /* If we have an N-way choice, reset state for the next
6287 n_way_choice
= true;
6288 n_way_matched
|= disj_matched
;
6289 disj_matched
= false;
6290 disj_starred
= true;
6291 d_atom
= d_end_atom
= NULL
;
6300 while (*p
++ != '}');
6305 fatal_error (input_location
, "braced spec %qs is invalid at %qc", orig
, *p
);
6310 /* Subroutine of handle_braces. Scan and process a brace substitution body
6311 (X in the description of %{} syntax). P points one past the colon;
6312 ATOM and END_ATOM bracket the first atom which was found to be true
6313 (present) in the current disjunction; STARRED indicates whether all
6314 the atoms in the current disjunction were starred (for syntax validation);
6315 MATCHED indicates whether the disjunction matched or not, and therefore
6316 whether or not the body is to be processed through do_spec_1 or just
6317 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
6321 process_brace_body (const char *p
, const char *atom
, const char *end_atom
,
6322 int starred
, int matched
)
6324 const char *body
, *end_body
;
6325 unsigned int nesting_level
;
6326 bool have_subst
= false;
6328 /* Locate the closing } or ;, honoring nested braces.
6329 Trim trailing whitespace. */
6338 if (!--nesting_level
)
6341 else if (*p
== ';' && nesting_level
== 1)
6343 else if (*p
== '%' && p
[1] == '*' && nesting_level
== 1)
6345 else if (*p
== '\0')
6351 while (end_body
[-1] == ' ' || end_body
[-1] == '\t')
6354 if (have_subst
&& !starred
)
6359 /* Copy the substitution body to permanent storage and execute it.
6360 If have_subst is false, this is a simple matter of running the
6361 body through do_spec_1... */
6362 char *string
= save_string (body
, end_body
- body
);
6365 if (do_spec_1 (string
, 0, NULL
) < 0)
6373 /* ... but if have_subst is true, we have to process the
6374 body once for each matching switch, with %* set to the
6375 variant part of the switch. */
6376 unsigned int hard_match_len
= end_atom
- atom
;
6379 for (i
= 0; i
< n_switches
; i
++)
6380 if (!strncmp (switches
[i
].part1
, atom
, hard_match_len
)
6381 && check_live_switch (i
, hard_match_len
))
6383 if (do_spec_1 (string
, 0,
6384 &switches
[i
].part1
[hard_match_len
]) < 0)
6389 /* Pass any arguments this switch has. */
6391 suffix_subst
= NULL
;
6400 fatal_error (input_location
, "braced spec body %qs is invalid", body
);
6403 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
6404 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
6405 spec, or -1 if either exact match or %* is used.
6407 A -O switch is obsoleted by a later -O switch. A -f, -g, -m, or -W switch
6408 whose value does not begin with "no-" is obsoleted by the same value
6409 with the "no-", similarly for a switch with the "no-" prefix. */
6412 check_live_switch (int switchnum
, int prefix_length
)
6414 const char *name
= switches
[switchnum
].part1
;
6417 /* If we already processed this switch and determined if it was
6418 live or not, return our past determination. */
6419 if (switches
[switchnum
].live_cond
!= 0)
6420 return ((switches
[switchnum
].live_cond
& SWITCH_LIVE
) != 0
6421 && (switches
[switchnum
].live_cond
& SWITCH_FALSE
) == 0
6422 && (switches
[switchnum
].live_cond
& SWITCH_IGNORE_PERMANENTLY
)
6425 /* In the common case of {<at-most-one-letter>*}, a negating
6426 switch would always match, so ignore that case. We will just
6427 send the conflicting switches to the compiler phase. */
6428 if (prefix_length
>= 0 && prefix_length
<= 1)
6431 /* Now search for duplicate in a manner that depends on the name. */
6435 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
6436 if (switches
[i
].part1
[0] == 'O')
6438 switches
[switchnum
].validated
= true;
6439 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
6444 case 'W': case 'f': case 'm': case 'g':
6445 if (! strncmp (name
+ 1, "no-", 3))
6447 /* We have Xno-YYY, search for XYYY. */
6448 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
6449 if (switches
[i
].part1
[0] == name
[0]
6450 && ! strcmp (&switches
[i
].part1
[1], &name
[4]))
6452 /* --specs are validated with the validate_switches mechanism. */
6453 if (switches
[switchnum
].known
)
6454 switches
[switchnum
].validated
= true;
6455 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
6461 /* We have XYYY, search for Xno-YYY. */
6462 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
6463 if (switches
[i
].part1
[0] == name
[0]
6464 && switches
[i
].part1
[1] == 'n'
6465 && switches
[i
].part1
[2] == 'o'
6466 && switches
[i
].part1
[3] == '-'
6467 && !strcmp (&switches
[i
].part1
[4], &name
[1]))
6469 /* --specs are validated with the validate_switches mechanism. */
6470 if (switches
[switchnum
].known
)
6471 switches
[switchnum
].validated
= true;
6472 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
6479 /* Otherwise the switch is live. */
6480 switches
[switchnum
].live_cond
|= SWITCH_LIVE
;
6484 /* Pass a switch to the current accumulating command
6485 in the same form that we received it.
6486 SWITCHNUM identifies the switch; it is an index into
6487 the vector of switches gcc received, which is `switches'.
6488 This cannot fail since it never finishes a command line.
6490 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
6493 give_switch (int switchnum
, int omit_first_word
)
6495 if ((switches
[switchnum
].live_cond
& SWITCH_IGNORE
) != 0)
6498 if (!omit_first_word
)
6500 do_spec_1 ("-", 0, NULL
);
6501 do_spec_1 (switches
[switchnum
].part1
, 1, NULL
);
6504 if (switches
[switchnum
].args
!= 0)
6507 for (p
= switches
[switchnum
].args
; *p
; p
++)
6509 const char *arg
= *p
;
6511 do_spec_1 (" ", 0, NULL
);
6514 unsigned length
= strlen (arg
);
6517 while (length
-- && !IS_DIR_SEPARATOR (arg
[length
]))
6518 if (arg
[length
] == '.')
6520 (CONST_CAST (char *, arg
))[length
] = 0;
6524 do_spec_1 (arg
, 1, NULL
);
6526 (CONST_CAST (char *, arg
))[length
] = '.';
6527 do_spec_1 (suffix_subst
, 1, NULL
);
6530 do_spec_1 (arg
, 1, NULL
);
6534 do_spec_1 (" ", 0, NULL
);
6535 switches
[switchnum
].validated
= true;
6538 /* Print GCC configuration (e.g. version, thread model, target,
6539 configuration_arguments) to a given FILE. */
6542 print_configuration (FILE *file
)
6547 fnotice (file
, "Target: %s\n", spec_machine
);
6548 fnotice (file
, "Configured with: %s\n", configuration_arguments
);
6550 #ifdef THREAD_MODEL_SPEC
6551 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
6552 but there's no point in doing all this processing just to get
6553 thread_model back. */
6554 obstack_init (&obstack
);
6555 do_spec_1 (THREAD_MODEL_SPEC
, 0, thread_model
);
6556 obstack_1grow (&obstack
, '\0');
6557 thrmod
= XOBFINISH (&obstack
, const char *);
6559 thrmod
= thread_model
;
6562 fnotice (file
, "Thread model: %s\n", thrmod
);
6564 /* compiler_version is truncated at the first space when initialized
6565 from version string, so truncate version_string at the first space
6566 before comparing. */
6567 for (n
= 0; version_string
[n
]; n
++)
6568 if (version_string
[n
] == ' ')
6571 if (! strncmp (version_string
, compiler_version
, n
)
6572 && compiler_version
[n
] == 0)
6573 fnotice (file
, "gcc version %s %s\n", version_string
,
6576 fnotice (file
, "gcc driver version %s %sexecuting gcc version %s\n",
6577 version_string
, pkgversion_string
, compiler_version
);
6581 #define RETRY_ICE_ATTEMPTS 3
6583 /* Returns true if FILE1 and FILE2 contain equivalent data, 0 otherwise. */
6586 files_equal_p (char *file1
, char *file2
)
6588 struct stat st1
, st2
;
6591 const int bufsize
= 8192;
6592 char *buf
= XNEWVEC (char, bufsize
);
6594 fd1
= open (file1
, O_RDONLY
);
6595 fd2
= open (file2
, O_RDONLY
);
6597 if (fd1
< 0 || fd2
< 0)
6600 if (fstat (fd1
, &st1
) < 0 || fstat (fd2
, &st2
) < 0)
6603 if (st1
.st_size
!= st2
.st_size
)
6606 for (n
= st1
.st_size
; n
; n
-= len
)
6609 if ((int) len
> bufsize
/ 2)
6612 if (read (fd1
, buf
, len
) != (int) len
6613 || read (fd2
, buf
+ bufsize
/ 2, len
) != (int) len
)
6618 if (memcmp (buf
, buf
+ bufsize
/ 2, len
) != 0)
6635 /* Check that compiler's output doesn't differ across runs.
6636 TEMP_STDOUT_FILES and TEMP_STDERR_FILES are arrays of files, containing
6637 stdout and stderr for each compiler run. Return true if all of
6638 TEMP_STDOUT_FILES and TEMP_STDERR_FILES are equivalent. */
6641 check_repro (char **temp_stdout_files
, char **temp_stderr_files
)
6644 for (i
= 0; i
< RETRY_ICE_ATTEMPTS
- 2; ++i
)
6646 if (!files_equal_p (temp_stdout_files
[i
], temp_stdout_files
[i
+ 1])
6647 || !files_equal_p (temp_stderr_files
[i
], temp_stderr_files
[i
+ 1]))
6649 fnotice (stderr
, "The bug is not reproducible, so it is"
6650 " likely a hardware or OS problem.\n");
6654 return i
== RETRY_ICE_ATTEMPTS
- 2;
6657 enum attempt_status
{
6658 ATTEMPT_STATUS_FAIL_TO_RUN
,
6659 ATTEMPT_STATUS_SUCCESS
,
6664 /* Run compiler with arguments NEW_ARGV to reproduce the ICE, storing stdout
6665 to OUT_TEMP and stderr to ERR_TEMP. If APPEND is TRUE, append to OUT_TEMP
6666 and ERR_TEMP instead of truncating. If EMIT_SYSTEM_INFO is TRUE, also write
6667 GCC configuration into to ERR_TEMP. Return ATTEMPT_STATUS_FAIL_TO_RUN if
6668 compiler failed to run, ATTEMPT_STATUS_ICE if compiled ICE-ed and
6669 ATTEMPT_STATUS_SUCCESS otherwise. */
6671 static enum attempt_status
6672 run_attempt (const char **new_argv
, const char *out_temp
,
6673 const char *err_temp
, int emit_system_info
, int append
)
6676 if (emit_system_info
)
6678 FILE *file_out
= fopen (err_temp
, "a");
6679 print_configuration (file_out
);
6680 fputs ("\n", file_out
);
6686 struct pex_obj
*pex
;
6688 int pex_flags
= PEX_USE_PIPES
| PEX_LAST
;
6689 enum attempt_status status
= ATTEMPT_STATUS_FAIL_TO_RUN
;
6692 pex_flags
|= PEX_STDOUT_APPEND
| PEX_STDERR_APPEND
;
6694 pex
= pex_init (PEX_USE_PIPES
, new_argv
[0], NULL
);
6696 fatal_error (input_location
, "pex_init failed: %m");
6698 errmsg
= pex_run (pex
, pex_flags
, new_argv
[0],
6699 CONST_CAST2 (char *const *, const char **, &new_argv
[1]), out_temp
,
6704 fatal_error (input_location
, errmsg
);
6708 pfatal_with_name (errmsg
);
6712 if (!pex_get_status (pex
, 1, &exit_status
))
6715 switch (WEXITSTATUS (exit_status
))
6718 status
= ATTEMPT_STATUS_ICE
;
6721 case SUCCESS_EXIT_CODE
:
6722 status
= ATTEMPT_STATUS_SUCCESS
;
6734 /* This routine reads lines from IN file, adds C++ style comments
6735 at the begining of each line and writes result into OUT. */
6738 insert_comments (const char *file_in
, const char *file_out
)
6740 FILE *in
= fopen (file_in
, "rb");
6741 FILE *out
= fopen (file_out
, "wb");
6744 bool add_comment
= true;
6745 while (fgets (line
, sizeof (line
), in
))
6750 add_comment
= strchr (line
, '\n') != NULL
;
6757 /* This routine adds preprocessed source code into the given ERR_FILE.
6758 To do this, it adds "-E" to NEW_ARGV and execute RUN_ATTEMPT routine to
6759 add information in report file. RUN_ATTEMPT should return
6760 ATTEMPT_STATUS_SUCCESS, in other case we cannot generate the report. */
6763 do_report_bug (const char **new_argv
, const int nargs
,
6764 char **out_file
, char **err_file
)
6767 int fd
= open (*out_file
, O_RDWR
| O_APPEND
);
6770 write (fd
, "\n//", 3);
6771 for (i
= 0; i
< nargs
; i
++)
6774 write (fd
, new_argv
[i
], strlen (new_argv
[i
]));
6776 write (fd
, "\n\n", 2);
6778 new_argv
[nargs
] = "-E";
6779 new_argv
[nargs
+ 1] = NULL
;
6781 status
= run_attempt (new_argv
, *out_file
, *err_file
, 0, 1);
6783 if (status
== ATTEMPT_STATUS_SUCCESS
)
6785 fnotice (stderr
, "Preprocessed source stored into %s file,"
6786 " please attach this to your bugreport.\n", *out_file
);
6787 /* Make sure it is not deleted. */
6793 /* Try to reproduce ICE. If bug is reproducible, generate report .err file
6794 containing GCC configuration, backtrace, compiler's command line options
6795 and preprocessed source code. */
6798 try_generate_repro (const char **argv
)
6800 int i
, nargs
, out_arg
= -1, quiet
= 0, attempt
;
6801 const char **new_argv
;
6802 char *temp_files
[RETRY_ICE_ATTEMPTS
* 2];
6803 char **temp_stdout_files
= &temp_files
[0];
6804 char **temp_stderr_files
= &temp_files
[RETRY_ICE_ATTEMPTS
];
6806 if (gcc_input_filename
== NULL
|| ! strcmp (gcc_input_filename
, "-"))
6809 for (nargs
= 0; argv
[nargs
] != NULL
; ++nargs
)
6810 /* Only retry compiler ICEs, not preprocessor ones. */
6811 if (! strcmp (argv
[nargs
], "-E"))
6813 else if (argv
[nargs
][0] == '-' && argv
[nargs
][1] == 'o')
6820 /* If the compiler is going to output any time information,
6821 it might varry between invocations. */
6822 else if (! strcmp (argv
[nargs
], "-quiet"))
6824 else if (! strcmp (argv
[nargs
], "-ftime-report"))
6827 if (out_arg
== -1 || !quiet
)
6830 memset (temp_files
, '\0', sizeof (temp_files
));
6831 new_argv
= XALLOCAVEC (const char *, nargs
+ 4);
6832 memcpy (new_argv
, argv
, (nargs
+ 1) * sizeof (const char *));
6833 new_argv
[nargs
++] = "-frandom-seed=0";
6834 new_argv
[nargs
++] = "-fdump-noaddr";
6835 new_argv
[nargs
] = NULL
;
6836 if (new_argv
[out_arg
][2] == '\0')
6837 new_argv
[out_arg
+ 1] = "-";
6839 new_argv
[out_arg
] = "-o-";
6842 for (attempt
= 0; attempt
< RETRY_ICE_ATTEMPTS
; ++attempt
)
6844 int emit_system_info
= 0;
6846 temp_stdout_files
[attempt
] = make_temp_file (".out");
6847 temp_stderr_files
[attempt
] = make_temp_file (".err");
6849 if (attempt
== RETRY_ICE_ATTEMPTS
- 1)
6852 emit_system_info
= 1;
6855 status
= run_attempt (new_argv
, temp_stdout_files
[attempt
],
6856 temp_stderr_files
[attempt
], emit_system_info
,
6859 if (status
!= ATTEMPT_STATUS_ICE
)
6861 fnotice (stderr
, "The bug is not reproducible, so it is"
6862 " likely a hardware or OS problem.\n");
6867 if (!check_repro (temp_stdout_files
, temp_stderr_files
))
6871 /* Insert commented out backtrace into report file. */
6872 char **stderr_commented
= &temp_stdout_files
[RETRY_ICE_ATTEMPTS
- 1];
6873 insert_comments (temp_stderr_files
[RETRY_ICE_ATTEMPTS
- 1],
6876 /* In final attempt we append compiler options and preprocesssed code to last
6877 generated .out file with configuration and backtrace. */
6878 char **output
= &temp_stdout_files
[RETRY_ICE_ATTEMPTS
- 1];
6879 do_report_bug (new_argv
, nargs
, stderr_commented
, output
);
6883 for (i
= 0; i
< RETRY_ICE_ATTEMPTS
* 2; i
++)
6886 unlink (temp_stdout_files
[i
]);
6887 free (temp_stdout_files
[i
]);
6891 /* Search for a file named NAME trying various prefixes including the
6892 user's -B prefix and some standard ones.
6893 Return the absolute file name found. If nothing is found, return NAME. */
6896 find_file (const char *name
)
6898 char *newname
= find_a_file (&startfile_prefixes
, name
, R_OK
, true);
6899 return newname
? newname
: name
;
6902 /* Determine whether a directory exists. If LINKER, return 0 for
6903 certain fixed names not needed by the linker. */
6906 is_directory (const char *path1
, bool linker
)
6913 /* Ensure the string ends with "/.". The resulting path will be a
6914 directory even if the given path is a symbolic link. */
6915 len1
= strlen (path1
);
6916 path
= (char *) alloca (3 + len1
);
6917 memcpy (path
, path1
, len1
);
6919 if (!IS_DIR_SEPARATOR (cp
[-1]))
6920 *cp
++ = DIR_SEPARATOR
;
6924 /* Exclude directories that the linker is known to search. */
6926 && IS_DIR_SEPARATOR (path
[0])
6928 && filename_ncmp (path
+ 1, "lib", 3) == 0)
6930 && filename_ncmp (path
+ 1, "usr", 3) == 0
6931 && IS_DIR_SEPARATOR (path
[4])
6932 && filename_ncmp (path
+ 5, "lib", 3) == 0)))
6935 return (stat (path
, &st
) >= 0 && S_ISDIR (st
.st_mode
));
6938 /* Set up the various global variables to indicate that we're processing
6939 the input file named FILENAME. */
6942 set_input (const char *filename
)
6946 gcc_input_filename
= filename
;
6947 input_filename_length
= strlen (gcc_input_filename
);
6948 input_basename
= lbasename (gcc_input_filename
);
6950 /* Find a suffix starting with the last period,
6951 and set basename_length to exclude that suffix. */
6952 basename_length
= strlen (input_basename
);
6953 suffixed_basename_length
= basename_length
;
6954 p
= input_basename
+ basename_length
;
6955 while (p
!= input_basename
&& *p
!= '.')
6957 if (*p
== '.' && p
!= input_basename
)
6959 basename_length
= p
- input_basename
;
6960 input_suffix
= p
+ 1;
6965 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
6966 we will need to do a stat on the gcc_input_filename. The
6967 INPUT_STAT_SET signals that the stat is needed. */
6971 /* On fatal signals, delete all the temporary files. */
6974 fatal_signal (int signum
)
6976 signal (signum
, SIG_DFL
);
6977 delete_failure_queue ();
6978 delete_temp_files ();
6979 /* Get the same signal again, this time not handled,
6980 so its normal effect occurs. */
6981 kill (getpid (), signum
);
6984 /* Compare the contents of the two files named CMPFILE[0] and
6985 CMPFILE[1]. Return zero if they're identical, nonzero
6989 compare_files (char *cmpfile
[])
6992 FILE *temp
[2] = { NULL
, NULL
};
6998 void *map
[2] = { NULL
, NULL
};
7000 for (i
= 0; i
< 2; i
++)
7004 if (stat (cmpfile
[i
], &st
) < 0 || !S_ISREG (st
.st_mode
))
7006 error ("%s: could not determine length of compare-debug file %s",
7007 gcc_input_filename
, cmpfile
[i
]);
7012 length
[i
] = st
.st_size
;
7015 if (!ret
&& length
[0] != length
[1])
7017 error ("%s: -fcompare-debug failure (length)", gcc_input_filename
);
7022 for (i
= 0; i
< 2; i
++)
7024 int fd
= open (cmpfile
[i
], O_RDONLY
);
7027 error ("%s: could not open compare-debug file %s",
7028 gcc_input_filename
, cmpfile
[i
]);
7033 map
[i
] = mmap (NULL
, length
[i
], PROT_READ
, MAP_PRIVATE
, fd
, 0);
7036 if (map
[i
] == (void *) MAP_FAILED
)
7045 if (memcmp (map
[0], map
[1], length
[0]) != 0)
7047 error ("%s: -fcompare-debug failure", gcc_input_filename
);
7052 for (i
= 0; i
< 2; i
++)
7054 munmap ((caddr_t
) map
[i
], length
[i
]);
7063 for (i
= 0; i
< 2; i
++)
7065 temp
[i
] = fopen (cmpfile
[i
], "r");
7068 error ("%s: could not open compare-debug file %s",
7069 gcc_input_filename
, cmpfile
[i
]);
7075 if (!ret
&& temp
[0] && temp
[1])
7079 c0
= fgetc (temp
[0]);
7080 c1
= fgetc (temp
[1]);
7084 error ("%s: -fcompare-debug failure",
7085 gcc_input_filename
);
7094 for (i
= 1; i
>= 0; i
--)
7103 driver::driver (bool can_finalize
, bool debug
) :
7104 explicit_link_files (NULL
),
7105 decoded_options (NULL
)
7107 env
.init (can_finalize
, debug
);
7112 XDELETEVEC (explicit_link_files
);
7113 XDELETEVEC (decoded_options
);
7116 /* driver::main is implemented as a series of driver:: method calls. */
7119 driver::main (int argc
, char **argv
)
7123 set_progname (argv
[0]);
7124 expand_at_files (&argc
, &argv
);
7125 decode_argv (argc
, const_cast <const char **> (argv
));
7126 global_initializations ();
7127 build_multilib_strings ();
7129 putenv_COLLECT_GCC (argv
[0]);
7130 maybe_putenv_COLLECT_LTO_WRAPPER ();
7131 maybe_putenv_OFFLOAD_TARGETS ();
7132 handle_unrecognized_options ();
7134 if (!maybe_print_and_exit ())
7137 early_exit
= prepare_infiles ();
7139 return get_exit_code ();
7141 do_spec_on_infiles ();
7142 maybe_run_linker (argv
[0]);
7144 return get_exit_code ();
7147 /* Locate the final component of argv[0] after any leading path, and set
7148 the program name accordingly. */
7151 driver::set_progname (const char *argv0
) const
7153 const char *p
= argv0
+ strlen (argv0
);
7154 while (p
!= argv0
&& !IS_DIR_SEPARATOR (p
[-1]))
7158 xmalloc_set_program_name (progname
);
7161 /* Expand any @ files within the command-line args,
7162 setting at_file_supplied if any were expanded. */
7165 driver::expand_at_files (int *argc
, char ***argv
) const
7167 char **old_argv
= *argv
;
7169 expandargv (argc
, argv
);
7171 /* Determine if any expansions were made. */
7172 if (*argv
!= old_argv
)
7173 at_file_supplied
= true;
7176 /* Decode the command-line arguments from argc/argv into the
7177 decoded_options array. */
7180 driver::decode_argv (int argc
, const char **argv
)
7182 /* Register the language-independent parameters. */
7183 global_init_params ();
7186 init_options_struct (&global_options
, &global_options_set
);
7188 decode_cmdline_options_to_array (argc
, argv
,
7190 &decoded_options
, &decoded_options_count
);
7193 /* Perform various initializations and setup. */
7196 driver::global_initializations ()
7198 /* Unlock the stdio streams. */
7199 unlock_std_streams ();
7201 gcc_init_libintl ();
7203 diagnostic_initialize (global_dc
, 0);
7204 diagnostic_color_init (global_dc
);
7206 #ifdef GCC_DRIVER_HOST_INITIALIZATION
7207 /* Perform host dependent initialization when needed. */
7208 GCC_DRIVER_HOST_INITIALIZATION
;
7211 if (atexit (delete_temp_files
) != 0)
7212 fatal_error (input_location
, "atexit failed");
7214 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
7215 signal (SIGINT
, fatal_signal
);
7217 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
7218 signal (SIGHUP
, fatal_signal
);
7220 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
7221 signal (SIGTERM
, fatal_signal
);
7223 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
7224 signal (SIGPIPE
, fatal_signal
);
7227 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
7228 receive the signal. A different setting is inheritable */
7229 signal (SIGCHLD
, SIG_DFL
);
7232 /* Parsing and gimplification sometimes need quite large stack.
7233 Increase stack size limits if possible. */
7234 stack_limit_increase (64 * 1024 * 1024);
7236 /* Allocate the argument vector. */
7239 obstack_init (&obstack
);
7242 /* Build multilib_select, et. al from the separate lines that make up each
7243 multilib selection. */
7246 driver::build_multilib_strings () const
7250 const char *const *q
= multilib_raw
;
7253 obstack_init (&multilib_obstack
);
7254 while ((p
= *q
++) != (char *) 0)
7255 obstack_grow (&multilib_obstack
, p
, strlen (p
));
7257 obstack_1grow (&multilib_obstack
, 0);
7258 multilib_select
= XOBFINISH (&multilib_obstack
, const char *);
7260 q
= multilib_matches_raw
;
7261 while ((p
= *q
++) != (char *) 0)
7262 obstack_grow (&multilib_obstack
, p
, strlen (p
));
7264 obstack_1grow (&multilib_obstack
, 0);
7265 multilib_matches
= XOBFINISH (&multilib_obstack
, const char *);
7267 q
= multilib_exclusions_raw
;
7268 while ((p
= *q
++) != (char *) 0)
7269 obstack_grow (&multilib_obstack
, p
, strlen (p
));
7271 obstack_1grow (&multilib_obstack
, 0);
7272 multilib_exclusions
= XOBFINISH (&multilib_obstack
, const char *);
7274 q
= multilib_reuse_raw
;
7275 while ((p
= *q
++) != (char *) 0)
7276 obstack_grow (&multilib_obstack
, p
, strlen (p
));
7278 obstack_1grow (&multilib_obstack
, 0);
7279 multilib_reuse
= XOBFINISH (&multilib_obstack
, const char *);
7282 for (size_t i
= 0; i
< ARRAY_SIZE (multilib_defaults_raw
); i
++)
7285 obstack_1grow (&multilib_obstack
, ' ');
7286 obstack_grow (&multilib_obstack
,
7287 multilib_defaults_raw
[i
],
7288 strlen (multilib_defaults_raw
[i
]));
7292 obstack_1grow (&multilib_obstack
, 0);
7293 multilib_defaults
= XOBFINISH (&multilib_obstack
, const char *);
7297 /* Set up the spec-handling machinery. */
7300 driver::set_up_specs () const
7302 const char *spec_machine_suffix
;
7306 #ifdef INIT_ENVIRONMENT
7307 /* Set up any other necessary machine specific environment variables. */
7308 xputenv (INIT_ENVIRONMENT
);
7311 /* Make a table of what switches there are (switches, n_switches).
7312 Make a table of specified input files (infiles, n_infiles).
7313 Decode switches that are handled locally. */
7315 process_command (decoded_options_count
, decoded_options
);
7317 /* Initialize the vector of specs to just the default.
7318 This means one element containing 0s, as a terminator. */
7320 compilers
= XNEWVAR (struct compiler
, sizeof default_compilers
);
7321 memcpy (compilers
, default_compilers
, sizeof default_compilers
);
7322 n_compilers
= n_default_compilers
;
7324 /* Read specs from a file if there is one. */
7326 machine_suffix
= concat (spec_host_machine
, dir_separator_str
, spec_version
,
7327 accel_dir_suffix
, dir_separator_str
, NULL
);
7328 just_machine_suffix
= concat (spec_machine
, dir_separator_str
, NULL
);
7330 specs_file
= find_a_file (&startfile_prefixes
, "specs", R_OK
, true);
7331 /* Read the specs file unless it is a default one. */
7332 if (specs_file
!= 0 && strcmp (specs_file
, "specs"))
7333 read_specs (specs_file
, true, false);
7337 #ifdef ACCEL_COMPILER
7338 spec_machine_suffix
= machine_suffix
;
7340 spec_machine_suffix
= just_machine_suffix
;
7343 /* We need to check standard_exec_prefix/spec_machine_suffix/specs
7344 for any override of as, ld and libraries. */
7345 specs_file
= (char *) alloca (strlen (standard_exec_prefix
)
7346 + strlen (spec_machine_suffix
) + sizeof ("specs"));
7347 strcpy (specs_file
, standard_exec_prefix
);
7348 strcat (specs_file
, spec_machine_suffix
);
7349 strcat (specs_file
, "specs");
7350 if (access (specs_file
, R_OK
) == 0)
7351 read_specs (specs_file
, true, false);
7353 /* Process any configure-time defaults specified for the command line
7354 options, via OPTION_DEFAULT_SPECS. */
7355 for (i
= 0; i
< ARRAY_SIZE (option_default_specs
); i
++)
7356 do_option_spec (option_default_specs
[i
].name
,
7357 option_default_specs
[i
].spec
);
7359 /* Process DRIVER_SELF_SPECS, adding any new options to the end
7360 of the command line. */
7362 for (i
= 0; i
< ARRAY_SIZE (driver_self_specs
); i
++)
7363 do_self_spec (driver_self_specs
[i
]);
7365 /* If not cross-compiling, look for executables in the standard
7367 if (*cross_compile
== '0')
7369 if (*md_exec_prefix
)
7371 add_prefix (&exec_prefixes
, md_exec_prefix
, "GCC",
7372 PREFIX_PRIORITY_LAST
, 0, 0);
7376 /* Process sysroot_suffix_spec. */
7377 if (*sysroot_suffix_spec
!= 0
7378 && !no_sysroot_suffix
7379 && do_spec_2 (sysroot_suffix_spec
) == 0)
7381 if (argbuf
.length () > 1)
7382 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
7383 else if (argbuf
.length () == 1)
7384 target_sysroot_suffix
= xstrdup (argbuf
.last ());
7387 #ifdef HAVE_LD_SYSROOT
7388 /* Pass the --sysroot option to the linker, if it supports that. If
7389 there is a sysroot_suffix_spec, it has already been processed by
7390 this point, so target_system_root really is the system root we
7392 if (target_system_root
)
7394 obstack_grow (&obstack
, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
7395 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
7396 set_spec ("link", XOBFINISH (&obstack
, const char *), false);
7400 /* Process sysroot_hdrs_suffix_spec. */
7401 if (*sysroot_hdrs_suffix_spec
!= 0
7402 && !no_sysroot_suffix
7403 && do_spec_2 (sysroot_hdrs_suffix_spec
) == 0)
7405 if (argbuf
.length () > 1)
7406 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
7407 else if (argbuf
.length () == 1)
7408 target_sysroot_hdrs_suffix
= xstrdup (argbuf
.last ());
7411 /* Look for startfiles in the standard places. */
7412 if (*startfile_prefix_spec
!= 0
7413 && do_spec_2 (startfile_prefix_spec
) == 0
7414 && do_spec_1 (" ", 0, NULL
) == 0)
7418 FOR_EACH_VEC_ELT (argbuf
, ndx
, arg
)
7419 add_sysrooted_prefix (&startfile_prefixes
, arg
, "BINUTILS",
7420 PREFIX_PRIORITY_LAST
, 0, 1);
7422 /* We should eventually get rid of all these and stick to
7423 startfile_prefix_spec exclusively. */
7424 else if (*cross_compile
== '0' || target_system_root
)
7426 if (*md_startfile_prefix
)
7427 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix
,
7428 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
7430 if (*md_startfile_prefix_1
)
7431 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix_1
,
7432 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
7434 /* If standard_startfile_prefix is relative, base it on
7435 standard_exec_prefix. This lets us move the installed tree
7436 as a unit. If GCC_EXEC_PREFIX is defined, base
7437 standard_startfile_prefix on that as well.
7439 If the prefix is relative, only search it for native compilers;
7440 otherwise we will search a directory containing host libraries. */
7441 if (IS_ABSOLUTE_PATH (standard_startfile_prefix
))
7442 add_sysrooted_prefix (&startfile_prefixes
,
7443 standard_startfile_prefix
, "BINUTILS",
7444 PREFIX_PRIORITY_LAST
, 0, 1);
7445 else if (*cross_compile
== '0')
7447 add_prefix (&startfile_prefixes
,
7448 concat (gcc_exec_prefix
7449 ? gcc_exec_prefix
: standard_exec_prefix
,
7451 standard_startfile_prefix
, NULL
),
7452 NULL
, PREFIX_PRIORITY_LAST
, 0, 1);
7455 /* Sysrooted prefixes are relocated because target_system_root is
7456 also relocated by gcc_exec_prefix. */
7457 if (*standard_startfile_prefix_1
)
7458 add_sysrooted_prefix (&startfile_prefixes
,
7459 standard_startfile_prefix_1
, "BINUTILS",
7460 PREFIX_PRIORITY_LAST
, 0, 1);
7461 if (*standard_startfile_prefix_2
)
7462 add_sysrooted_prefix (&startfile_prefixes
,
7463 standard_startfile_prefix_2
, "BINUTILS",
7464 PREFIX_PRIORITY_LAST
, 0, 1);
7467 /* Process any user specified specs in the order given on the command
7469 for (struct user_specs
*uptr
= user_specs_head
; uptr
; uptr
= uptr
->next
)
7471 char *filename
= find_a_file (&startfile_prefixes
, uptr
->filename
,
7473 read_specs (filename
? filename
: uptr
->filename
, false, true);
7476 /* Process any user self specs. */
7478 struct spec_list
*sl
;
7479 for (sl
= specs
; sl
; sl
= sl
->next
)
7480 if (sl
->name_len
== sizeof "self_spec" - 1
7481 && !strcmp (sl
->name
, "self_spec"))
7482 do_self_spec (*sl
->ptr_spec
);
7487 enum save_temps save
;
7489 if (!compare_debug_second
)
7491 n_switches_debug_check
[1] = n_switches
;
7492 n_switches_alloc_debug_check
[1] = n_switches_alloc
;
7493 switches_debug_check
[1] = XDUPVEC (struct switchstr
, switches
,
7496 do_self_spec ("%:compare-debug-self-opt()");
7497 n_switches_debug_check
[0] = n_switches
;
7498 n_switches_alloc_debug_check
[0] = n_switches_alloc
;
7499 switches_debug_check
[0] = switches
;
7501 n_switches
= n_switches_debug_check
[1];
7502 n_switches_alloc
= n_switches_alloc_debug_check
[1];
7503 switches
= switches_debug_check
[1];
7506 /* Avoid crash when computing %j in this early. */
7507 save
= save_temps_flag
;
7508 save_temps_flag
= SAVE_TEMPS_NONE
;
7510 compare_debug
= -compare_debug
;
7511 do_self_spec ("%:compare-debug-self-opt()");
7513 save_temps_flag
= save
;
7515 if (!compare_debug_second
)
7517 n_switches_debug_check
[1] = n_switches
;
7518 n_switches_alloc_debug_check
[1] = n_switches_alloc
;
7519 switches_debug_check
[1] = switches
;
7520 compare_debug
= -compare_debug
;
7521 n_switches
= n_switches_debug_check
[0];
7522 n_switches_alloc
= n_switches_debug_check
[0];
7523 switches
= switches_debug_check
[0];
7528 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
7529 if (gcc_exec_prefix
)
7530 gcc_exec_prefix
= concat (gcc_exec_prefix
, spec_host_machine
,
7531 dir_separator_str
, spec_version
,
7532 accel_dir_suffix
, dir_separator_str
, NULL
);
7534 /* Now we have the specs.
7535 Set the `valid' bits for switches that match anything in any spec. */
7537 validate_all_switches ();
7539 /* Now that we have the switches and the specs, set
7540 the subdirectory based on the options. */
7541 set_multilib_dir ();
7544 /* Set up to remember the pathname of gcc and any options
7545 needed for collect. We use argv[0] instead of progname because
7546 we need the complete pathname. */
7549 driver::putenv_COLLECT_GCC (const char *argv0
) const
7551 obstack_init (&collect_obstack
);
7552 obstack_grow (&collect_obstack
, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
7553 obstack_grow (&collect_obstack
, argv0
, strlen (argv0
) + 1);
7554 xputenv (XOBFINISH (&collect_obstack
, char *));
7557 /* Set up to remember the pathname of the lto wrapper. */
7560 driver::maybe_putenv_COLLECT_LTO_WRAPPER () const
7562 char *lto_wrapper_file
;
7565 lto_wrapper_file
= NULL
;
7567 lto_wrapper_file
= find_a_file (&exec_prefixes
, "lto-wrapper",
7569 if (lto_wrapper_file
)
7571 lto_wrapper_file
= convert_white_space (lto_wrapper_file
);
7572 lto_wrapper_spec
= lto_wrapper_file
;
7573 obstack_init (&collect_obstack
);
7574 obstack_grow (&collect_obstack
, "COLLECT_LTO_WRAPPER=",
7575 sizeof ("COLLECT_LTO_WRAPPER=") - 1);
7576 obstack_grow (&collect_obstack
, lto_wrapper_spec
,
7577 strlen (lto_wrapper_spec
) + 1);
7578 xputenv (XOBFINISH (&collect_obstack
, char *));
7583 /* Set up to remember the names of offload targets. */
7586 driver::maybe_putenv_OFFLOAD_TARGETS () const
7588 if (offload_targets
&& offload_targets
[0] != '\0')
7590 obstack_grow (&collect_obstack
, "OFFLOAD_TARGET_NAMES=",
7591 sizeof ("OFFLOAD_TARGET_NAMES=") - 1);
7592 obstack_grow (&collect_obstack
, offload_targets
,
7593 strlen (offload_targets
) + 1);
7594 xputenv (XOBFINISH (&collect_obstack
, char *));
7597 free (offload_targets
);
7598 offload_targets
= NULL
;
7601 /* Reject switches that no pass was interested in. */
7604 driver::handle_unrecognized_options () const
7606 for (size_t i
= 0; (int) i
< n_switches
; i
++)
7607 if (! switches
[i
].validated
)
7608 error ("unrecognized command line option %<-%s%>", switches
[i
].part1
);
7611 /* Handle the various -print-* options, returning 0 if the driver
7612 should exit, or nonzero if the driver should continue. */
7615 driver::maybe_print_and_exit () const
7617 if (print_search_dirs
)
7619 printf (_("install: %s%s\n"),
7620 gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
7621 gcc_exec_prefix
? "" : machine_suffix
);
7622 printf (_("programs: %s\n"),
7623 build_search_list (&exec_prefixes
, "", false, false));
7624 printf (_("libraries: %s\n"),
7625 build_search_list (&startfile_prefixes
, "", false, true));
7629 if (print_file_name
)
7631 printf ("%s\n", find_file (print_file_name
));
7635 if (print_prog_name
)
7637 if (use_ld
!= NULL
&& ! strcmp (print_prog_name
, "ld"))
7639 /* Append USE_LD to the default linker. */
7640 #ifdef DEFAULT_LINKER
7642 # ifdef HAVE_HOST_EXECUTABLE_SUFFIX
7643 int len
= (sizeof (DEFAULT_LINKER
)
7644 - sizeof (HOST_EXECUTABLE_SUFFIX
));
7648 char *default_linker
= xstrdup (DEFAULT_LINKER
);
7649 /* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains
7650 HOST_EXECUTABLE_SUFFIX. */
7651 if (! strcmp (&default_linker
[len
], HOST_EXECUTABLE_SUFFIX
))
7653 default_linker
[len
] = '\0';
7654 ld
= concat (default_linker
, use_ld
,
7655 HOST_EXECUTABLE_SUFFIX
, NULL
);
7660 ld
= concat (DEFAULT_LINKER
, use_ld
, NULL
);
7661 if (access (ld
, X_OK
) == 0)
7663 printf ("%s\n", ld
);
7667 print_prog_name
= concat (print_prog_name
, use_ld
, NULL
);
7669 char *newname
= find_a_file (&exec_prefixes
, print_prog_name
, X_OK
, 0);
7670 printf ("%s\n", (newname
? newname
: print_prog_name
));
7674 if (print_multi_lib
)
7676 print_multilib_info ();
7680 if (print_multi_directory
)
7682 if (multilib_dir
== NULL
)
7685 printf ("%s\n", multilib_dir
);
7689 if (print_multiarch
)
7691 if (multiarch_dir
== NULL
)
7694 printf ("%s\n", multiarch_dir
);
7700 if (target_system_root
)
7702 if (target_sysroot_suffix
)
7703 printf ("%s%s\n", target_system_root
, target_sysroot_suffix
);
7705 printf ("%s\n", target_system_root
);
7710 if (print_multi_os_directory
)
7712 if (multilib_os_dir
== NULL
)
7715 printf ("%s\n", multilib_os_dir
);
7719 if (print_sysroot_headers_suffix
)
7721 if (*sysroot_hdrs_suffix_spec
)
7723 printf("%s\n", (target_sysroot_hdrs_suffix
7724 ? target_sysroot_hdrs_suffix
7729 /* The error status indicates that only one set of fixed
7730 headers should be built. */
7731 fatal_error (input_location
,
7732 "not configured with sysroot headers suffix");
7735 if (print_help_list
)
7741 printf (_("\nFor bug reporting instructions, please see:\n"));
7742 printf ("%s.\n", bug_report_url
);
7747 /* We do not exit here. Instead we have created a fake input file
7748 called 'help-dummy' which needs to be compiled, and we pass this
7749 on the various sub-processes, along with the --help switch.
7750 Ensure their output appears after ours. */
7751 fputc ('\n', stdout
);
7757 printf (_("%s %s%s\n"), progname
, pkgversion_string
,
7759 printf ("Copyright %s 2015 Free Software Foundation, Inc.\n",
7761 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
7762 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
7767 /* We do not exit here. We use the same mechanism of --help to print
7768 the version of the sub-processes. */
7769 fputc ('\n', stdout
);
7775 print_configuration (stderr
);
7783 /* Figure out what to do with each input file.
7784 Return true if we need to exit early from "main", false otherwise. */
7787 driver::prepare_infiles ()
7790 int lang_n_infiles
= 0;
7792 if (n_infiles
== added_libraries
)
7793 fatal_error (input_location
, "no input files");
7796 /* Early exit needed from main. */
7799 /* Make a place to record the compiler output file names
7800 that correspond to the input files. */
7803 i
+= lang_specific_extra_outfiles
;
7804 outfiles
= XCNEWVEC (const char *, i
);
7806 /* Record which files were specified explicitly as link input. */
7808 explicit_link_files
= XCNEWVEC (char, n_infiles
);
7810 combine_inputs
= have_o
|| flag_wpa
;
7812 for (i
= 0; (int) i
< n_infiles
; i
++)
7814 const char *name
= infiles
[i
].name
;
7815 struct compiler
*compiler
= lookup_compiler (name
,
7817 infiles
[i
].language
);
7819 if (compiler
&& !(compiler
->combinable
))
7820 combine_inputs
= false;
7822 if (lang_n_infiles
> 0 && compiler
!= input_file_compiler
7823 && infiles
[i
].language
&& infiles
[i
].language
[0] != '*')
7824 infiles
[i
].incompiler
= compiler
;
7828 input_file_compiler
= compiler
;
7829 infiles
[i
].incompiler
= compiler
;
7833 /* Since there is no compiler for this input file, assume it is a
7835 explicit_link_files
[i
] = 1;
7836 infiles
[i
].incompiler
= NULL
;
7838 infiles
[i
].compiled
= false;
7839 infiles
[i
].preprocessed
= false;
7842 if (!combine_inputs
&& have_c
&& have_o
&& lang_n_infiles
> 1)
7843 fatal_error (input_location
,
7844 "cannot specify -o with -c, -S or -E with multiple files");
7846 /* No early exit needed from main; we can continue. */
7850 /* Run the spec machinery on each input file. */
7853 driver::do_spec_on_infiles () const
7857 for (i
= 0; (int) i
< n_infiles
; i
++)
7859 int this_file_error
= 0;
7861 /* Tell do_spec what to substitute for %i. */
7863 input_file_number
= i
;
7864 set_input (infiles
[i
].name
);
7866 if (infiles
[i
].compiled
)
7869 /* Use the same thing in %o, unless cp->spec says otherwise. */
7871 outfiles
[i
] = gcc_input_filename
;
7873 /* Figure out which compiler from the file's suffix. */
7876 = lookup_compiler (infiles
[i
].name
, input_filename_length
,
7877 infiles
[i
].language
);
7879 if (input_file_compiler
)
7881 /* Ok, we found an applicable compiler. Run its spec. */
7883 if (input_file_compiler
->spec
[0] == '#')
7885 error ("%s: %s compiler not installed on this system",
7886 gcc_input_filename
, &input_file_compiler
->spec
[1]);
7887 this_file_error
= 1;
7895 free (debug_check_temp_file
[0]);
7896 debug_check_temp_file
[0] = NULL
;
7898 free (debug_check_temp_file
[1]);
7899 debug_check_temp_file
[1] = NULL
;
7902 value
= do_spec (input_file_compiler
->spec
);
7903 infiles
[i
].compiled
= true;
7905 this_file_error
= 1;
7906 else if (compare_debug
&& debug_check_temp_file
[0])
7909 inform (0, "recompiling with -fcompare-debug");
7911 compare_debug
= -compare_debug
;
7912 n_switches
= n_switches_debug_check
[1];
7913 n_switches_alloc
= n_switches_alloc_debug_check
[1];
7914 switches
= switches_debug_check
[1];
7916 value
= do_spec (input_file_compiler
->spec
);
7918 compare_debug
= -compare_debug
;
7919 n_switches
= n_switches_debug_check
[0];
7920 n_switches_alloc
= n_switches_alloc_debug_check
[0];
7921 switches
= switches_debug_check
[0];
7925 error ("during -fcompare-debug recompilation");
7926 this_file_error
= 1;
7929 gcc_assert (debug_check_temp_file
[1]
7930 && filename_cmp (debug_check_temp_file
[0],
7931 debug_check_temp_file
[1]));
7934 inform (0, "comparing final insns dumps");
7936 if (compare_files (debug_check_temp_file
))
7937 this_file_error
= 1;
7942 free (debug_check_temp_file
[0]);
7943 debug_check_temp_file
[0] = NULL
;
7945 free (debug_check_temp_file
[1]);
7946 debug_check_temp_file
[1] = NULL
;
7951 /* If this file's name does not contain a recognized suffix,
7952 record it as explicit linker input. */
7955 explicit_link_files
[i
] = 1;
7957 /* Clear the delete-on-failure queue, deleting the files in it
7958 if this compilation failed. */
7960 if (this_file_error
)
7962 delete_failure_queue ();
7965 /* If this compilation succeeded, don't delete those files later. */
7966 clear_failure_queue ();
7969 /* Reset the input file name to the first compile/object file name, for use
7970 with %b in LINK_SPEC. We use the first input file that we can find
7971 a compiler to compile it instead of using infiles.language since for
7972 languages other than C we use aliases that we then lookup later. */
7977 for (i
= 0; i
< n_infiles
; i
++)
7978 if (infiles
[i
].incompiler
7979 || (infiles
[i
].language
&& infiles
[i
].language
[0] != '*'))
7981 set_input (infiles
[i
].name
);
7988 /* Make sure INPUT_FILE_NUMBER points to first available open
7990 input_file_number
= n_infiles
;
7991 if (lang_specific_pre_link ())
7996 /* If we have to run the linker, do it now. */
7999 driver::maybe_run_linker (const char *argv0
) const
8002 int linker_was_run
= 0;
8003 int num_linker_inputs
;
8005 /* Determine if there are any linker input files. */
8006 num_linker_inputs
= 0;
8007 for (i
= 0; (int) i
< n_infiles
; i
++)
8008 if (explicit_link_files
[i
] || outfiles
[i
] != NULL
)
8009 num_linker_inputs
++;
8011 /* Run ld to link all the compiler output files. */
8013 if (num_linker_inputs
> 0 && !seen_error () && print_subprocess_help
< 2)
8015 int tmp
= execution_count
;
8019 #if HAVE_LTO_PLUGIN > 0
8020 #if HAVE_LTO_PLUGIN == 2
8021 const char *fno_use_linker_plugin
= "fno-use-linker-plugin";
8023 const char *fuse_linker_plugin
= "fuse-linker-plugin";
8027 /* We'll use ld if we can't find collect2. */
8028 if (! strcmp (linker_name_spec
, "collect2"))
8030 char *s
= find_a_file (&exec_prefixes
, "collect2", X_OK
, false);
8032 linker_name_spec
= "ld";
8035 #if HAVE_LTO_PLUGIN > 0
8036 #if HAVE_LTO_PLUGIN == 2
8037 if (!switch_matches (fno_use_linker_plugin
,
8038 fno_use_linker_plugin
8039 + strlen (fno_use_linker_plugin
), 0))
8041 if (switch_matches (fuse_linker_plugin
,
8043 + strlen (fuse_linker_plugin
), 0))
8046 char *temp_spec
= find_a_file (&exec_prefixes
,
8047 LTOPLUGINSONAME
, R_OK
,
8050 fatal_error (input_location
,
8051 "-fuse-linker-plugin, but %s not found",
8053 linker_plugin_file_spec
= convert_white_space (temp_spec
);
8056 lto_gcc_spec
= argv0
;
8059 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
8061 putenv_from_prefixes (&exec_prefixes
, "COMPILER_PATH", false);
8062 putenv_from_prefixes (&startfile_prefixes
, LIBRARY_PATH_ENV
, true);
8064 if (print_subprocess_help
== 1)
8066 printf (_("\nLinker options\n==============\n\n"));
8067 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
8068 " to the linker.\n\n"));
8071 int value
= do_spec (link_command_spec
);
8074 linker_was_run
= (tmp
!= execution_count
);
8077 /* If options said don't run linker,
8078 complain about input files to be given to the linker. */
8080 if (! linker_was_run
&& !seen_error ())
8081 for (i
= 0; (int) i
< n_infiles
; i
++)
8082 if (explicit_link_files
[i
]
8083 && !(infiles
[i
].language
&& infiles
[i
].language
[0] == '*'))
8084 warning (0, "%s: linker input file unused because linking not done",
8088 /* The end of "main". */
8091 driver::final_actions () const
8093 /* Delete some or all of the temporary files we made. */
8096 delete_failure_queue ();
8097 delete_temp_files ();
8099 if (print_help_list
)
8101 printf (("\nFor bug reporting instructions, please see:\n"));
8102 printf ("%s\n", bug_report_url
);
8106 /* Determine what the exit code of the driver should be. */
8109 driver::get_exit_code () const
8111 return (signal_count
!= 0 ? 2
8112 : seen_error () ? (pass_exit_codes
? greatest_status
: 1)
8116 /* Find the proper compilation spec for the file name NAME,
8117 whose length is LENGTH. LANGUAGE is the specified language,
8118 or 0 if this file is to be passed to the linker. */
8120 static struct compiler
*
8121 lookup_compiler (const char *name
, size_t length
, const char *language
)
8123 struct compiler
*cp
;
8125 /* If this was specified by the user to be a linker input, indicate that. */
8126 if (language
!= 0 && language
[0] == '*')
8129 /* Otherwise, look for the language, if one is spec'd. */
8132 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
8133 if (cp
->suffix
[0] == '@' && !strcmp (cp
->suffix
+ 1, language
))
8136 error ("language %s not recognized", language
);
8140 /* Look for a suffix. */
8141 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
8143 if (/* The suffix `-' matches only the file name `-'. */
8144 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
8145 || (strlen (cp
->suffix
) < length
8146 /* See if the suffix matches the end of NAME. */
8147 && !strcmp (cp
->suffix
,
8148 name
+ length
- strlen (cp
->suffix
))
8153 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
8154 /* Look again, but case-insensitively this time. */
8156 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
8158 if (/* The suffix `-' matches only the file name `-'. */
8159 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
8160 || (strlen (cp
->suffix
) < length
8161 /* See if the suffix matches the end of NAME. */
8162 && ((!strcmp (cp
->suffix
,
8163 name
+ length
- strlen (cp
->suffix
))
8164 || !strpbrk (cp
->suffix
, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
8165 && !strcasecmp (cp
->suffix
,
8166 name
+ length
- strlen (cp
->suffix
)))
8172 if (cp
>= compilers
)
8174 if (cp
->spec
[0] != '@')
8175 /* A non-alias entry: return it. */
8178 /* An alias entry maps a suffix to a language.
8179 Search for the language; pass 0 for NAME and LENGTH
8180 to avoid infinite recursion if language not found. */
8181 return lookup_compiler (NULL
, 0, cp
->spec
+ 1);
8187 save_string (const char *s
, int len
)
8189 char *result
= XNEWVEC (char, len
+ 1);
8191 memcpy (result
, s
, len
);
8197 pfatal_with_name (const char *name
)
8199 perror_with_name (name
);
8200 delete_temp_files ();
8205 perror_with_name (const char *name
)
8207 error ("%s: %m", name
);
8211 validate_switches_from_spec (const char *spec
, bool user
)
8213 const char *p
= spec
;
8216 if (c
== '%' && (*p
== '{' || *p
== '<' || (*p
== 'W' && *++p
== '{')))
8217 /* We have a switch spec. */
8218 p
= validate_switches (p
+ 1, user
);
8222 validate_all_switches (void)
8224 struct compiler
*comp
;
8225 struct spec_list
*spec
;
8227 for (comp
= compilers
; comp
->spec
; comp
++)
8228 validate_switches_from_spec (comp
->spec
, false);
8230 /* Look through the linked list of specs read from the specs file. */
8231 for (spec
= specs
; spec
; spec
= spec
->next
)
8232 validate_switches_from_spec (*spec
->ptr_spec
, spec
->user_p
);
8234 validate_switches_from_spec (link_command_spec
, false);
8237 /* Look at the switch-name that comes after START
8238 and mark as valid all supplied switches that match it. */
8241 validate_switches (const char *start
, bool user_spec
)
8243 const char *p
= start
;
8247 bool suffix
= false;
8248 bool starred
= false;
8250 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
8259 if (*p
== '.' || *p
== ',')
8263 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
8264 || *p
== ',' || *p
== '.' || *p
== '@')
8269 starred
= true, p
++;
8275 /* Mark all matching switches as valid. */
8276 for (i
= 0; i
< n_switches
; i
++)
8277 if (!strncmp (switches
[i
].part1
, atom
, len
)
8278 && (starred
|| switches
[i
].part1
[len
] == '\0')
8279 && (switches
[i
].known
|| user_spec
))
8280 switches
[i
].validated
= true;
8284 if (*p
&& (p
[-1] == '|' || p
[-1] == '&'))
8287 if (*p
&& p
[-1] == ':')
8289 while (*p
&& *p
!= ';' && *p
!= '}')
8294 if (*p
== '{' || *p
== '<')
8295 p
= validate_switches (p
+1, user_spec
);
8296 else if (p
[0] == 'W' && p
[1] == '{')
8297 p
= validate_switches (p
+2, user_spec
);
8304 if (*p
&& p
[-1] == ';')
8318 static struct mdswitchstr
*mdswitches
;
8319 static int n_mdswitches
;
8321 /* Check whether a particular argument was used. The first time we
8322 canonicalize the switches to keep only the ones we care about. */
8327 int operator () (const char *p
, int len
);
8334 const char *replace
;
8339 mswitchstr
*mswitches
;
8344 used_arg_t used_arg
;
8347 used_arg_t::operator () (const char *p
, int len
)
8353 struct mswitchstr
*matches
;
8357 /* Break multilib_matches into the component strings of string
8358 and replacement string. */
8359 for (q
= multilib_matches
; *q
!= '\0'; q
++)
8364 = (struct mswitchstr
*) alloca ((sizeof (struct mswitchstr
)) * cnt
);
8366 q
= multilib_matches
;
8375 fatal_error (input_location
, "multilib spec %qs is invalid",
8380 matches
[i
].len
= q
- matches
[i
].str
;
8382 matches
[i
].replace
= ++q
;
8383 while (*q
!= ';' && *q
!= '\0')
8386 goto invalid_matches
;
8389 matches
[i
].rep_len
= q
- matches
[i
].replace
;
8395 /* Now build a list of the replacement string for switches that we care
8396 about. Make sure we allocate at least one entry. This prevents
8397 xmalloc from calling fatal, and prevents us from re-executing this
8400 = XNEWVEC (struct mswitchstr
, n_mdswitches
+ (n_switches
? n_switches
: 1));
8401 for (i
= 0; i
< n_switches
; i
++)
8402 if ((switches
[i
].live_cond
& SWITCH_IGNORE
) == 0)
8404 int xlen
= strlen (switches
[i
].part1
);
8405 for (j
= 0; j
< cnt
; j
++)
8406 if (xlen
== matches
[j
].len
8407 && ! strncmp (switches
[i
].part1
, matches
[j
].str
, xlen
))
8409 mswitches
[n_mswitches
].str
= matches
[j
].replace
;
8410 mswitches
[n_mswitches
].len
= matches
[j
].rep_len
;
8411 mswitches
[n_mswitches
].replace
= (char *) 0;
8412 mswitches
[n_mswitches
].rep_len
= 0;
8418 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
8419 on the command line nor any options mutually incompatible with
8421 for (i
= 0; i
< n_mdswitches
; i
++)
8425 for (q
= multilib_options
; *q
!= '\0'; *q
&& q
++)
8431 while (strncmp (q
, mdswitches
[i
].str
, mdswitches
[i
].len
) != 0
8432 || strchr (" /", q
[mdswitches
[i
].len
]) == NULL
)
8434 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
8441 if (*q
!= ' ' && *q
!= '\0')
8443 while (*r
!= ' ' && *r
!= '\0')
8446 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
8449 if (used_arg (r
, q
- r
))
8454 mswitches
[n_mswitches
].str
= mdswitches
[i
].str
;
8455 mswitches
[n_mswitches
].len
= mdswitches
[i
].len
;
8456 mswitches
[n_mswitches
].replace
= (char *) 0;
8457 mswitches
[n_mswitches
].rep_len
= 0;
8470 for (i
= 0; i
< n_mswitches
; i
++)
8471 if (len
== mswitches
[i
].len
&& ! strncmp (p
, mswitches
[i
].str
, len
))
8477 void used_arg_t::finalize ()
8479 XDELETEVEC (mswitches
);
8486 default_arg (const char *p
, int len
)
8490 for (i
= 0; i
< n_mdswitches
; i
++)
8491 if (len
== mdswitches
[i
].len
&& ! strncmp (p
, mdswitches
[i
].str
, len
))
8497 /* Work out the subdirectory to use based on the options. The format of
8498 multilib_select is a list of elements. Each element is a subdirectory
8499 name followed by a list of options followed by a semicolon. The format
8500 of multilib_exclusions is the same, but without the preceding
8501 directory. First gcc will check the exclusions, if none of the options
8502 beginning with an exclamation point are present, and all of the other
8503 options are present, then we will ignore this completely. Passing
8504 that, gcc will consider each multilib_select in turn using the same
8505 rules for matching the options. If a match is found, that subdirectory
8507 A subdirectory name is optionally followed by a colon and the corresponding
8511 set_multilib_dir (void)
8514 unsigned int this_path_len
;
8515 const char *this_path
, *this_arg
;
8516 const char *start
, *end
;
8518 int ok
, ndfltok
, first
;
8521 start
= multilib_defaults
;
8522 while (*start
== ' ' || *start
== '\t')
8524 while (*start
!= '\0')
8527 while (*start
!= ' ' && *start
!= '\t' && *start
!= '\0')
8529 while (*start
== ' ' || *start
== '\t')
8537 mdswitches
= XNEWVEC (struct mdswitchstr
, n_mdswitches
);
8538 for (start
= multilib_defaults
; *start
!= '\0'; start
= end
+ 1)
8540 while (*start
== ' ' || *start
== '\t')
8546 for (end
= start
+ 1;
8547 *end
!= ' ' && *end
!= '\t' && *end
!= '\0'; end
++)
8550 obstack_grow (&multilib_obstack
, start
, end
- start
);
8551 obstack_1grow (&multilib_obstack
, 0);
8552 mdswitches
[i
].str
= XOBFINISH (&multilib_obstack
, const char *);
8553 mdswitches
[i
++].len
= end
- start
;
8560 p
= multilib_exclusions
;
8563 /* Ignore newlines. */
8570 /* Check the arguments. */
8577 fatal_error (input_location
, "multilib exclusions %qs is invalid",
8578 multilib_exclusions
);
8588 while (*p
!= ' ' && *p
!= ';')
8591 goto invalid_exclusions
;
8595 if (*this_arg
!= '!')
8603 ok
= used_arg (this_arg
, p
- this_arg
);
8618 p
= multilib_select
;
8620 /* Append multilib reuse rules if any. With those rules, we can reuse
8621 one multilib for certain different options sets. */
8622 if (strlen (multilib_reuse
) > 0)
8623 p
= concat (p
, multilib_reuse
, NULL
);
8627 /* Ignore newlines. */
8634 /* Get the initial path. */
8641 fatal_error (input_location
, "multilib select %qs %qs is invalid",
8642 multilib_select
, multilib_reuse
);
8646 this_path_len
= p
- this_path
;
8648 /* Check the arguments. */
8655 goto invalid_select
;
8664 while (*p
!= ' ' && *p
!= ';')
8667 goto invalid_select
;
8671 if (*this_arg
!= '!')
8679 /* If this is a default argument, we can just ignore it.
8680 This is true even if this_arg begins with '!'. Beginning
8681 with '!' does not mean that this argument is necessarily
8682 inappropriate for this library: it merely means that
8683 there is a more specific library which uses this
8684 argument. If this argument is a default, we need not
8685 consider that more specific library. */
8686 ok
= used_arg (this_arg
, p
- this_arg
);
8693 if (default_arg (this_arg
, p
- this_arg
))
8702 if (this_path_len
!= 1
8703 || this_path
[0] != '.')
8705 char *new_multilib_dir
= XNEWVEC (char, this_path_len
+ 1);
8708 strncpy (new_multilib_dir
, this_path
, this_path_len
);
8709 new_multilib_dir
[this_path_len
] = '\0';
8710 q
= strchr (new_multilib_dir
, ':');
8713 multilib_dir
= new_multilib_dir
;
8720 const char *q
= this_path
, *end
= this_path
+ this_path_len
;
8722 while (q
< end
&& *q
!= ':')
8726 const char *q2
= q
+ 1, *ml_end
= end
;
8727 char *new_multilib_os_dir
;
8729 while (q2
< end
&& *q2
!= ':')
8733 if (ml_end
- q
== 1)
8734 multilib_os_dir
= xstrdup (".");
8737 new_multilib_os_dir
= XNEWVEC (char, ml_end
- q
);
8738 memcpy (new_multilib_os_dir
, q
+ 1, ml_end
- q
- 1);
8739 new_multilib_os_dir
[ml_end
- q
- 1] = '\0';
8740 multilib_os_dir
= new_multilib_os_dir
;
8743 if (q2
< end
&& *q2
== ':')
8745 char *new_multiarch_dir
= XNEWVEC (char, end
- q2
);
8746 memcpy (new_multiarch_dir
, q2
+ 1, end
- q2
- 1);
8747 new_multiarch_dir
[end
- q2
- 1] = '\0';
8748 multiarch_dir
= new_multiarch_dir
;
8757 if (multilib_dir
== NULL
&& multilib_os_dir
!= NULL
8758 && strcmp (multilib_os_dir
, ".") == 0)
8760 free (CONST_CAST (char *, multilib_os_dir
));
8761 multilib_os_dir
= NULL
;
8763 else if (multilib_dir
!= NULL
&& multilib_os_dir
== NULL
)
8764 multilib_os_dir
= multilib_dir
;
8767 /* Print out the multiple library subdirectory selection
8768 information. This prints out a series of lines. Each line looks
8769 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
8770 required. Only the desired options are printed out, the negative
8771 matches. The options are print without a leading dash. There are
8772 no spaces to make it easy to use the information in the shell.
8773 Each subdirectory is printed only once. This assumes the ordering
8774 generated by the genmultilib script. Also, we leave out ones that match
8778 print_multilib_info (void)
8780 const char *p
= multilib_select
;
8781 const char *last_path
= 0, *this_path
;
8783 unsigned int last_path_len
= 0;
8788 /* Ignore newlines. */
8795 /* Get the initial path. */
8802 fatal_error (input_location
,
8803 "multilib select %qs is invalid", multilib_select
);
8809 /* When --disable-multilib was used but target defines
8810 MULTILIB_OSDIRNAMES, entries starting with .: (and not starting
8811 with .:: for multiarch configurations) are there just to find
8812 multilib_os_dir, so skip them from output. */
8813 if (this_path
[0] == '.' && this_path
[1] == ':' && this_path
[2] != ':')
8816 /* Check for matches with the multilib_exclusions. We don't bother
8817 with the '!' in either list. If any of the exclusion rules match
8818 all of its options with the select rule, we skip it. */
8820 const char *e
= multilib_exclusions
;
8821 const char *this_arg
;
8826 /* Ignore newlines. */
8833 /* Check the arguments. */
8842 fatal_error (input_location
,
8843 "multilib exclusion %qs is invalid",
8844 multilib_exclusions
);
8855 while (*e
!= ' ' && *e
!= ';')
8858 goto invalid_exclusion
;
8866 int len
= e
- this_arg
;
8869 goto invalid_select
;
8873 while (*q
!= ' ' && *q
!= ';')
8876 goto invalid_select
;
8880 if (! strncmp (arg
, this_arg
,
8881 (len
< q
- arg
) ? q
- arg
: len
)
8882 || default_arg (this_arg
, e
- this_arg
))
8912 /* If this is a duplicate, skip it. */
8913 skip
= (last_path
!= 0
8914 && (unsigned int) (p
- this_path
) == last_path_len
8915 && ! filename_ncmp (last_path
, this_path
, last_path_len
));
8917 last_path
= this_path
;
8918 last_path_len
= p
- this_path
;
8921 /* If this directory requires any default arguments, we can skip
8922 it. We will already have printed a directory identical to
8923 this one which does not require that default argument. */
8934 goto invalid_select
;
8941 while (*q
!= ' ' && *q
!= ';')
8944 goto invalid_select
;
8949 && default_arg (arg
, q
- arg
))
8964 for (p1
= last_path
; p1
< p
&& *p1
!= ':'; p1
++)
8975 goto invalid_select
;
8983 use_arg
= *p
!= '!';
8988 while (*p
!= ' ' && *p
!= ';')
8991 goto invalid_select
;
9003 /* If there are extra options, print them now. */
9004 if (multilib_extra
&& *multilib_extra
)
9006 int print_at
= TRUE
;
9009 for (q
= multilib_extra
; *q
!= '\0'; q
++)
9030 /* getenv built-in spec function.
9032 Returns the value of the environment variable given by its first
9033 argument, concatenated with the second argument. If the
9034 environment variable is not defined, a fatal error is issued. */
9037 getenv_spec_function (int argc
, const char **argv
)
9047 value
= env
.get (argv
[0]);
9049 fatal_error (input_location
,
9050 "environment variable %qs not defined", argv
[0]);
9052 /* We have to escape every character of the environment variable so
9053 they are not interpreted as active spec characters. A
9054 particularly painful case is when we are reading a variable
9055 holding a windows path complete with \ separators. */
9056 len
= strlen (value
) * 2 + strlen (argv
[1]) + 1;
9057 result
= XNEWVAR (char, len
);
9058 for (ptr
= result
; *value
; ptr
+= 2)
9064 strcpy (ptr
, argv
[1]);
9069 /* if-exists built-in spec function.
9071 Checks to see if the file specified by the absolute pathname in
9072 ARGS exists. Returns that pathname if found.
9074 The usual use for this function is to check for a library file
9075 (whose name has been expanded with %s). */
9078 if_exists_spec_function (int argc
, const char **argv
)
9080 /* Must have only one argument. */
9081 if (argc
== 1 && IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
9087 /* if-exists-else built-in spec function.
9089 This is like if-exists, but takes an additional argument which
9090 is returned if the first argument does not exist. */
9093 if_exists_else_spec_function (int argc
, const char **argv
)
9095 /* Must have exactly two arguments. */
9099 if (IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
9105 /* sanitize built-in spec function.
9107 This returns non-NULL, if sanitizing address, thread or
9108 any of the undefined behavior sanitizers. */
9111 sanitize_spec_function (int argc
, const char **argv
)
9116 if (strcmp (argv
[0], "address") == 0)
9117 return (flag_sanitize
& SANITIZE_USER_ADDRESS
) ? "" : NULL
;
9118 if (strcmp (argv
[0], "kernel-address") == 0)
9119 return (flag_sanitize
& SANITIZE_KERNEL_ADDRESS
) ? "" : NULL
;
9120 if (strcmp (argv
[0], "thread") == 0)
9121 return (flag_sanitize
& SANITIZE_THREAD
) ? "" : NULL
;
9122 if (strcmp (argv
[0], "undefined") == 0)
9123 return ((flag_sanitize
& (SANITIZE_UNDEFINED
| SANITIZE_NONDEFAULT
))
9124 && !flag_sanitize_undefined_trap_on_error
) ? "" : NULL
;
9125 if (strcmp (argv
[0], "leak") == 0)
9126 return ((flag_sanitize
9127 & (SANITIZE_ADDRESS
| SANITIZE_LEAK
| SANITIZE_THREAD
))
9128 == SANITIZE_LEAK
) ? "" : NULL
;
9132 /* replace-outfile built-in spec function.
9134 This looks for the first argument in the outfiles array's name and
9135 replaces it with the second argument. */
9138 replace_outfile_spec_function (int argc
, const char **argv
)
9141 /* Must have exactly two arguments. */
9145 for (i
= 0; i
< n_infiles
; i
++)
9147 if (outfiles
[i
] && !filename_cmp (outfiles
[i
], argv
[0]))
9148 outfiles
[i
] = xstrdup (argv
[1]);
9153 /* remove-outfile built-in spec function.
9155 * This looks for the first argument in the outfiles array's name and
9159 remove_outfile_spec_function (int argc
, const char **argv
)
9162 /* Must have exactly one argument. */
9166 for (i
= 0; i
< n_infiles
; i
++)
9168 if (outfiles
[i
] && !filename_cmp (outfiles
[i
], argv
[0]))
9174 /* Given two version numbers, compares the two numbers.
9175 A version number must match the regular expression
9176 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
9179 compare_version_strings (const char *v1
, const char *v2
)
9184 if (regcomp (&r
, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
9185 REG_EXTENDED
| REG_NOSUB
) != 0)
9187 rresult
= regexec (&r
, v1
, 0, NULL
, 0);
9188 if (rresult
== REG_NOMATCH
)
9189 fatal_error (input_location
, "invalid version number %qs", v1
);
9190 else if (rresult
!= 0)
9192 rresult
= regexec (&r
, v2
, 0, NULL
, 0);
9193 if (rresult
== REG_NOMATCH
)
9194 fatal_error (input_location
, "invalid version number %qs", v2
);
9195 else if (rresult
!= 0)
9198 return strverscmp (v1
, v2
);
9202 /* version_compare built-in spec function.
9204 This takes an argument of the following form:
9206 <comparison-op> <arg1> [<arg2>] <switch> <result>
9208 and produces "result" if the comparison evaluates to true,
9209 and nothing if it doesn't.
9211 The supported <comparison-op> values are:
9213 >= true if switch is a later (or same) version than arg1
9215 < true if switch is an earlier version than arg1
9217 >< true if switch is arg1 or later, and earlier than arg2
9218 <> true if switch is earlier than arg1 or is arg2 or later
9220 If the switch is not present, the condition is false unless
9221 the first character of the <comparison-op> is '!'.
9224 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
9225 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
9228 version_compare_spec_function (int argc
, const char **argv
)
9232 const char *switch_value
= NULL
;
9237 fatal_error (input_location
, "too few arguments to %%:version-compare");
9238 if (argv
[0][0] == '\0')
9240 if ((argv
[0][1] == '<' || argv
[0][1] == '>') && argv
[0][0] != '!')
9242 if (argc
!= nargs
+ 3)
9243 fatal_error (input_location
, "too many arguments to %%:version-compare");
9245 switch_len
= strlen (argv
[nargs
+ 1]);
9246 for (i
= 0; i
< n_switches
; i
++)
9247 if (!strncmp (switches
[i
].part1
, argv
[nargs
+ 1], switch_len
)
9248 && check_live_switch (i
, switch_len
))
9249 switch_value
= switches
[i
].part1
+ switch_len
;
9251 if (switch_value
== NULL
)
9255 comp1
= compare_version_strings (switch_value
, argv
[1]);
9257 comp2
= compare_version_strings (switch_value
, argv
[2]);
9259 comp2
= -1; /* This value unused. */
9262 switch (argv
[0][0] << 8 | argv
[0][1])
9264 case '>' << 8 | '=':
9265 result
= comp1
>= 0;
9267 case '!' << 8 | '<':
9268 result
= comp1
>= 0 || switch_value
== NULL
;
9273 case '!' << 8 | '>':
9274 result
= comp1
< 0 || switch_value
== NULL
;
9276 case '>' << 8 | '<':
9277 result
= comp1
>= 0 && comp2
< 0;
9279 case '<' << 8 | '>':
9280 result
= comp1
< 0 || comp2
>= 0;
9284 fatal_error (input_location
,
9285 "unknown operator %qs in %%:version-compare", argv
[0]);
9290 return argv
[nargs
+ 2];
9293 /* %:include builtin spec function. This differs from %include in that it
9294 can be nested inside a spec, and thus be conditionalized. It takes
9295 one argument, the filename, and looks for it in the startfile path.
9296 The result is always NULL, i.e. an empty expansion. */
9299 include_spec_function (int argc
, const char **argv
)
9306 file
= find_a_file (&startfile_prefixes
, argv
[0], R_OK
, true);
9307 read_specs (file
? file
: argv
[0], false, false);
9312 /* %:find-file spec function. This function replaces its argument by
9313 the file found through find_file, that is the -print-file-name gcc
9316 find_file_spec_function (int argc
, const char **argv
)
9323 file
= find_file (argv
[0]);
9328 /* %:find-plugindir spec function. This function replaces its argument
9329 by the -iplugindir=<dir> option. `dir' is found through find_file, that
9330 is the -print-file-name gcc program option. */
9332 find_plugindir_spec_function (int argc
, const char **argv ATTRIBUTE_UNUSED
)
9339 option
= concat ("-iplugindir=", find_file ("plugin"), NULL
);
9344 /* %:print-asm-header spec function. Print a banner to say that the
9345 following output is from the assembler. */
9348 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED
,
9349 const char **argv ATTRIBUTE_UNUSED
)
9351 printf (_("Assembler options\n=================\n\n"));
9352 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
9357 /* Get a random number for -frandom-seed */
9359 static unsigned HOST_WIDE_INT
9360 get_random_number (void)
9362 unsigned HOST_WIDE_INT ret
= 0;
9365 fd
= open ("/dev/urandom", O_RDONLY
);
9368 read (fd
, &ret
, sizeof (HOST_WIDE_INT
));
9374 /* Get some more or less random data. */
9375 #ifdef HAVE_GETTIMEOFDAY
9379 gettimeofday (&tv
, NULL
);
9380 ret
= tv
.tv_sec
* 1000 + tv
.tv_usec
/ 1000;
9384 time_t now
= time (NULL
);
9386 if (now
!= (time_t)-1)
9387 ret
= (unsigned) now
;
9391 return ret
^ getpid ();
9394 /* %:compare-debug-dump-opt spec function. Save the last argument,
9395 expected to be the last -fdump-final-insns option, or generate a
9399 compare_debug_dump_opt_spec_function (int arg
,
9400 const char **argv ATTRIBUTE_UNUSED
)
9405 static char random_seed
[HOST_BITS_PER_WIDE_INT
/ 4 + 3];
9408 fatal_error (input_location
,
9409 "too many arguments to %%:compare-debug-dump-opt");
9411 do_spec_2 ("%{fdump-final-insns=*:%*}");
9412 do_spec_1 (" ", 0, NULL
);
9414 if (argbuf
.length () > 0
9415 && strcmp (argv
[argbuf
.length () - 1], "."))
9420 name
= xstrdup (argv
[argbuf
.length () - 1]);
9425 const char *ext
= NULL
;
9427 if (argbuf
.length () > 0)
9429 do_spec_2 ("%{o*:%*}%{!o:%{!S:%b%O}%{S:%b.s}}");
9432 else if (!compare_debug
)
9435 do_spec_2 ("%g.gkd");
9437 do_spec_1 (" ", 0, NULL
);
9439 gcc_assert (argbuf
.length () > 0);
9441 name
= concat (argbuf
.last (), ext
, NULL
);
9443 ret
= concat ("-fdump-final-insns=", name
, NULL
);
9446 which
= compare_debug
< 0;
9447 debug_check_temp_file
[which
] = name
;
9451 unsigned HOST_WIDE_INT value
= get_random_number ();
9453 sprintf (random_seed
, HOST_WIDE_INT_PRINT_HEX
, value
);
9459 ret
= concat ("%{!frandom-seed=*:-frandom-seed=", random_seed
, "} ",
9470 static const char *debug_auxbase_opt
;
9472 /* %:compare-debug-self-opt spec function. Expands to the options
9473 that are to be passed in the second compilation of
9477 compare_debug_self_opt_spec_function (int arg
,
9478 const char **argv ATTRIBUTE_UNUSED
)
9481 fatal_error (input_location
,
9482 "too many arguments to %%:compare-debug-self-opt");
9484 if (compare_debug
>= 0)
9487 do_spec_2 ("%{c|S:%{o*:%*}}");
9488 do_spec_1 (" ", 0, NULL
);
9490 if (argbuf
.length () > 0)
9491 debug_auxbase_opt
= concat ("-auxbase-strip ",
9495 debug_auxbase_opt
= NULL
;
9498 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
9499 %<fdump-final-insns=* -w -S -o %j \
9500 %{!fcompare-debug-second:-fcompare-debug-second} \
9501 ", compare_debug_opt
, NULL
);
9504 /* %:compare-debug-auxbase-opt spec function. Expands to the auxbase
9505 options that are to be passed in the second compilation of
9506 compare-debug. It expects, as an argument, the basename of the
9507 current input file name, with the .gk suffix appended to it. */
9510 compare_debug_auxbase_opt_spec_function (int arg
,
9517 fatal_error (input_location
,
9518 "too few arguments to %%:compare-debug-auxbase-opt");
9521 fatal_error (input_location
,
9522 "too many arguments to %%:compare-debug-auxbase-opt");
9524 if (compare_debug
>= 0)
9527 len
= strlen (argv
[0]);
9528 if (len
< 3 || strcmp (argv
[0] + len
- 3, ".gk") != 0)
9529 fatal_error (input_location
, "argument to %%:compare-debug-auxbase-opt "
9530 "does not end in .gk");
9532 if (debug_auxbase_opt
)
9533 return debug_auxbase_opt
;
9535 #define OPT "-auxbase "
9538 name
= (char*) xmalloc (sizeof (OPT
) + len
);
9539 memcpy (name
, OPT
, sizeof (OPT
) - 1);
9540 memcpy (name
+ sizeof (OPT
) - 1, argv
[0], len
);
9541 name
[sizeof (OPT
) - 1 + len
] = '\0';
9548 /* %:pass-through-libs spec function. Finds all -l options and input
9549 file names in the lib spec passed to it, and makes a list of them
9550 prepended with the plugin option to cause them to be passed through
9551 to the final link after all the new object files have been added. */
9554 pass_through_libs_spec_func (int argc
, const char **argv
)
9556 char *prepended
= xstrdup (" ");
9558 /* Shlemiel the painter's algorithm. Innately horrible, but at least
9559 we know that there will never be more than a handful of strings to
9560 concat, and it's only once per run, so it's not worth optimising. */
9561 for (n
= 0; n
< argc
; n
++)
9563 char *old
= prepended
;
9564 /* Anything that isn't an option is a full path to an output
9565 file; pass it through if it ends in '.a'. Among options,
9567 if (argv
[n
][0] == '-' && argv
[n
][1] == 'l')
9569 const char *lopt
= argv
[n
] + 2;
9570 /* Handle both joined and non-joined -l options. If for any
9571 reason there's a trailing -l with no joined or following
9572 arg just discard it. */
9573 if (!*lopt
&& ++n
>= argc
)
9577 prepended
= concat (prepended
, "-plugin-opt=-pass-through=-l",
9580 else if (!strcmp (".a", argv
[n
] + strlen (argv
[n
]) - 2))
9582 prepended
= concat (prepended
, "-plugin-opt=-pass-through=",
9583 argv
[n
], " ", NULL
);
9585 if (prepended
!= old
)
9591 /* %:replace-extension spec function. Replaces the extension of the
9592 first argument with the second argument. */
9595 replace_extension_spec_func (int argc
, const char **argv
)
9603 fatal_error (input_location
, "too few arguments to %%:replace-extension");
9605 name
= xstrdup (argv
[0]);
9607 for (i
= strlen (name
) - 1; i
>= 0; i
--)
9608 if (IS_DIR_SEPARATOR (name
[i
]))
9611 p
= strrchr (name
+ i
+ 1, '.');
9615 result
= concat (name
, argv
[1], NULL
);
9621 /* Returns "" if the n in ARGV[1] == -opt=<n> is greater than ARGV[2].
9622 Otherwise, return NULL. */
9625 greater_than_spec_func (int argc
, const char **argv
)
9632 gcc_assert (argc
== 3);
9633 gcc_assert (argv
[0][0] == '-');
9634 gcc_assert (argv
[0][1] == '\0');
9636 /* Point p to <n> in in -opt=<n>. */
9637 const char *p
= argv
[1];
9650 long arg
= strtol (p
, &converted
, 10);
9651 gcc_assert (converted
!= p
);
9653 long lim
= strtol (argv
[2], &converted
, 10);
9654 gcc_assert (converted
!= argv
[2]);
9662 /* Insert backslash before spaces in ORIG (usually a file path), to
9663 avoid being broken by spec parser.
9665 This function is needed as do_spec_1 treats white space (' ' and '\t')
9666 as the end of an argument. But in case of -plugin /usr/gcc install/xxx.so,
9667 the file name should be treated as a single argument rather than being
9668 broken into multiple. Solution is to insert '\\' before the space in a
9671 This function converts and only converts all occurrence of ' '
9672 to '\\' + ' ' and '\t' to '\\' + '\t'. For example:
9676 "a\\ b" -> "a\\\\ b"
9678 orig: input null-terminating string that was allocated by xalloc. The
9679 memory it points to might be freed in this function. Behavior undefined
9680 if ORIG wasn't xalloced or was freed already at entry.
9682 Return: ORIG if no conversion needed. Otherwise a newly allocated string
9683 that was converted from ORIG. */
9686 convert_white_space (char *orig
)
9688 int len
, number_of_space
= 0;
9690 for (len
= 0; orig
[len
]; len
++)
9691 if (orig
[len
] == ' ' || orig
[len
] == '\t') number_of_space
++;
9693 if (number_of_space
)
9695 char *new_spec
= (char *) xmalloc (len
+ number_of_space
+ 1);
9697 for (j
= 0, k
= 0; j
<= len
; j
++, k
++)
9699 if (orig
[j
] == ' ' || orig
[j
] == '\t')
9700 new_spec
[k
++] = '\\';
9701 new_spec
[k
] = orig
[j
];
9711 path_prefix_reset (path_prefix
*prefix
)
9713 struct prefix_list
*iter
, *next
;
9714 iter
= prefix
->plist
;
9718 free (const_cast <char *> (iter
->prefix
));
9723 prefix
->max_len
= 0;
9726 /* Restore all state within gcc.c to the initial state, so that the driver
9727 code can be safely re-run in-process.
9729 Many const char * variables are referenced by static specs (see
9730 INIT_STATIC_SPEC above). These variables are restored to their default
9731 values by a simple loop over the static specs.
9733 For other variables, we directly restore them all to their initial
9734 values (often implicitly 0).
9736 Free the various obstacks in this file, along with "opts_obstack"
9739 This function also restores any environment variables that were changed. */
9745 params_c_finalize ();
9746 diagnostic_finish (global_dc
);
9749 at_file_supplied
= 0;
9750 print_help_list
= 0;
9752 verbose_only_flag
= 0;
9753 print_subprocess_help
= 0;
9755 report_times_to_file
= NULL
;
9756 target_system_root
= DEFAULT_TARGET_SYSTEM_ROOT
;
9757 target_system_root_changed
= 0;
9758 target_sysroot_suffix
= 0;
9759 target_sysroot_hdrs_suffix
= 0;
9760 save_temps_flag
= SAVE_TEMPS_NONE
;
9761 save_temps_prefix
= 0;
9762 save_temps_length
= 0;
9763 spec_machine
= DEFAULT_TARGET_MACHINE
;
9764 greatest_status
= 1;
9766 finalize_options_struct (&global_options
);
9767 finalize_options_struct (&global_options_set
);
9769 obstack_free (&obstack
, NULL
);
9770 obstack_free (&opts_obstack
, NULL
); /* in opts.c */
9771 obstack_free (&collect_obstack
, NULL
);
9773 link_command_spec
= LINK_COMMAND_SPEC
;
9775 obstack_free (&multilib_obstack
, NULL
);
9777 user_specs_head
= NULL
;
9778 user_specs_tail
= NULL
;
9780 /* Within the "compilers" vec, the fields "suffix" and "spec" were
9781 statically allocated for the default compilers, but dynamically
9782 allocated for additional compilers. Delete them for the latter. */
9783 for (int i
= n_default_compilers
; i
< n_compilers
; i
++)
9785 free (const_cast <char *> (compilers
[i
].suffix
));
9786 free (const_cast <char *> (compilers
[i
].spec
));
9788 XDELETEVEC (compilers
);
9792 linker_options
.truncate (0);
9793 assembler_options
.truncate (0);
9794 preprocessor_options
.truncate (0);
9796 path_prefix_reset (&exec_prefixes
);
9797 path_prefix_reset (&startfile_prefixes
);
9798 path_prefix_reset (&include_prefixes
);
9801 just_machine_suffix
= 0;
9802 gcc_exec_prefix
= 0;
9803 gcc_libexec_prefix
= 0;
9804 md_exec_prefix
= MD_EXEC_PREFIX
;
9805 md_startfile_prefix
= MD_STARTFILE_PREFIX
;
9806 md_startfile_prefix_1
= MD_STARTFILE_PREFIX_1
;
9808 multilib_os_dir
= 0;
9813 for (unsigned i
= 0; i
< ARRAY_SIZE (static_specs
); i
++)
9815 spec_list
*sl
= &static_specs
[i
];
9819 free (const_cast <char *> (*(sl
->ptr_spec
)));
9820 sl
->alloc_p
= false;
9822 *(sl
->ptr_spec
) = sl
->default_ptr
;
9828 processing_spec_function
= 0;
9830 argbuf
.truncate (0);
9836 execution_count
= 0;
9839 temp_filename
= NULL
;
9840 temp_filename_length
= 0;
9841 always_delete_queue
= NULL
;
9842 failure_delete_queue
= NULL
;
9844 XDELETEVEC (switches
);
9847 n_switches_alloc
= 0;
9850 compare_debug_second
= 0;
9851 compare_debug_opt
= NULL
;
9852 for (int i
= 0; i
< 2; i
++)
9854 switches_debug_check
[i
] = NULL
;
9855 n_switches_debug_check
[i
] = 0;
9856 n_switches_alloc_debug_check
[i
] = 0;
9857 debug_check_temp_file
[i
] = NULL
;
9860 XDELETEVEC (infiles
);
9863 n_infiles_alloc
= 0;
9865 combine_inputs
= false;
9866 added_libraries
= 0;
9867 XDELETEVEC (outfiles
);
9870 last_language_n_infiles
= 0;
9871 gcc_input_filename
= NULL
;
9872 input_file_number
= 0;
9873 input_filename_length
= 0;
9874 basename_length
= 0;
9875 suffixed_basename_length
= 0;
9876 input_basename
= NULL
;
9877 input_suffix
= NULL
;
9878 /* We don't need to purge "input_stat", just to unset "input_stat_set". */
9880 input_file_compiler
= NULL
;
9882 delete_this_arg
= 0;
9883 this_is_output_file
= 0;
9884 this_is_library_file
= 0;
9885 this_is_linker_script
= 0;
9886 input_from_pipe
= 0;
9887 suffix_subst
= NULL
;
9892 debug_auxbase_opt
= NULL
;
9894 used_arg
.finalize ();
9898 Targets can provide configure-time default options in
9899 OPTION_DEFAULT_SPECS. The jit needs to access these, but
9900 they are expressed in the spec language.
9902 Run just enough of the driver to be able to expand these
9903 specs, and then call the callback CB on each
9904 such option. The options strings are *without* a leading
9905 '-' character e.g. ("march=x86-64"). Finally, clean up. */
9908 driver_get_configure_time_options (void (*cb
) (const char *option
,
9914 obstack_init (&obstack
);
9915 gcc_obstack_init (&opts_obstack
);
9918 for (i
= 0; i
< ARRAY_SIZE (option_default_specs
); i
++)
9919 do_option_spec (option_default_specs
[i
].name
,
9920 option_default_specs
[i
].spec
);
9922 for (i
= 0; (int) i
< n_switches
; i
++)
9924 gcc_assert (switches
[i
].part1
);
9925 (*cb
) (switches
[i
].part1
, user_data
);
9928 obstack_free (&opts_obstack
, NULL
);
9929 obstack_free (&obstack
, NULL
);