PR c/79855: add full stop to store merging param descriptions
[official-gcc.git] / gcc / gcc.c
blob826b012cd77384031e2cdef49fd314fe7879decd
1 /* Compiler driver program that can handle many languages.
2 Copyright (C) 1987-2017 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
9 version.
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
14 for more details.
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". */
30 #include "config.h"
31 #include "system.h"
32 #include "coretypes.h"
33 #include "multilib.h" /* before tm.h */
34 #include "tm.h"
35 #include "xregex.h"
36 #include "obstack.h"
37 #include "intl.h"
38 #include "prefix.h"
39 #include "gcc.h"
40 #include "diagnostic.h"
41 #include "flags.h"
42 #include "opts.h"
43 #include "params.h"
44 #include "filenames.h"
45 #include "spellcheck.h"
49 /* Manage the manipulation of env vars.
51 We poison "getenv" and "putenv", so that all enviroment-handling is
52 done through this class. Note that poisoning happens in the
53 preprocessor at the identifier level, and doesn't distinguish between
54 env.getenv ();
55 and
56 getenv ();
57 Hence we need to use "get" for the accessor method, not "getenv". */
59 class env_manager
61 public:
62 void init (bool can_restore, bool debug);
63 const char *get (const char *name);
64 void xput (const char *string);
65 void restore ();
67 private:
68 bool m_can_restore;
69 bool m_debug;
70 struct kv
72 char *m_key;
73 char *m_value;
75 vec<kv> m_keys;
79 /* The singleton instance of class env_manager. */
81 static env_manager env;
83 /* Initializer for class env_manager.
85 We can't do this as a constructor since we have a statically
86 allocated instance ("env" above). */
88 void
89 env_manager::init (bool can_restore, bool debug)
91 m_can_restore = can_restore;
92 m_debug = debug;
95 /* Get the value of NAME within the environment. Essentially
96 a wrapper for ::getenv, but adding logging, and the possibility
97 of caching results. */
99 const char *
100 env_manager::get (const char *name)
102 const char *result = ::getenv (name);
103 if (m_debug)
104 fprintf (stderr, "env_manager::getenv (%s) -> %s\n", name, result);
105 return result;
108 /* Put the given KEY=VALUE entry STRING into the environment.
109 If the env_manager was initialized with CAN_RESTORE set, then
110 also record the old value of KEY within the environment, so that it
111 can be later restored. */
113 void
114 env_manager::xput (const char *string)
116 if (m_debug)
117 fprintf (stderr, "env_manager::xput (%s)\n", string);
118 if (verbose_flag)
119 fnotice (stderr, "%s\n", string);
121 if (m_can_restore)
123 char *equals = strchr (const_cast <char *> (string), '=');
124 gcc_assert (equals);
126 struct kv kv;
127 kv.m_key = xstrndup (string, equals - string);
128 const char *cur_value = ::getenv (kv.m_key);
129 if (m_debug)
130 fprintf (stderr, "saving old value: %s\n",cur_value);
131 kv.m_value = cur_value ? xstrdup (cur_value) : NULL;
132 m_keys.safe_push (kv);
135 ::putenv (CONST_CAST (char *, string));
138 /* Undo any xputenv changes made since last restore.
139 Can only be called if the env_manager was initialized with
140 CAN_RESTORE enabled. */
142 void
143 env_manager::restore ()
145 unsigned int i;
146 struct kv *item;
148 gcc_assert (m_can_restore);
150 FOR_EACH_VEC_ELT_REVERSE (m_keys, i, item)
152 if (m_debug)
153 printf ("restoring saved key: %s value: %s\n", item->m_key, item->m_value);
154 if (item->m_value)
155 ::setenv (item->m_key, item->m_value, 1);
156 else
157 ::unsetenv (item->m_key);
158 free (item->m_key);
159 free (item->m_value);
162 m_keys.truncate (0);
165 /* Forbid other uses of getenv and putenv. */
166 #if (GCC_VERSION >= 3000)
167 #pragma GCC poison getenv putenv
168 #endif
172 /* By default there is no special suffix for target executables. */
173 /* FIXME: when autoconf is fixed, remove the host check - dj */
174 #if defined(TARGET_EXECUTABLE_SUFFIX) && defined(HOST_EXECUTABLE_SUFFIX)
175 #define HAVE_TARGET_EXECUTABLE_SUFFIX
176 #endif
178 /* By default there is no special suffix for host executables. */
179 #ifdef HOST_EXECUTABLE_SUFFIX
180 #define HAVE_HOST_EXECUTABLE_SUFFIX
181 #else
182 #define HOST_EXECUTABLE_SUFFIX ""
183 #endif
185 /* By default, the suffix for target object files is ".o". */
186 #ifdef TARGET_OBJECT_SUFFIX
187 #define HAVE_TARGET_OBJECT_SUFFIX
188 #else
189 #define TARGET_OBJECT_SUFFIX ".o"
190 #endif
192 static const char dir_separator_str[] = { DIR_SEPARATOR, 0 };
194 /* Most every one is fine with LIBRARY_PATH. For some, it conflicts. */
195 #ifndef LIBRARY_PATH_ENV
196 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
197 #endif
199 /* If a stage of compilation returns an exit status >= 1,
200 compilation of that file ceases. */
202 #define MIN_FATAL_STATUS 1
204 /* Flag set by cppspec.c to 1. */
205 int is_cpp_driver;
207 /* Flag set to nonzero if an @file argument has been supplied to gcc. */
208 static bool at_file_supplied;
210 /* Definition of string containing the arguments given to configure. */
211 #include "configargs.h"
213 /* Flag saying to print the command line options understood by gcc and its
214 sub-processes. */
216 static int print_help_list;
218 /* Flag saying to print the version of gcc and its sub-processes. */
220 static int print_version;
222 /* Flag indicating whether we should ONLY print the command and
223 arguments (like verbose_flag) without executing the command.
224 Displayed arguments are quoted so that the generated command
225 line is suitable for execution. This is intended for use in
226 shell scripts to capture the driver-generated command line. */
227 static int verbose_only_flag;
229 /* Flag indicating how to print command line options of sub-processes. */
231 static int print_subprocess_help;
233 /* Linker suffix passed to -fuse-ld=... */
234 static const char *use_ld;
236 /* Whether we should report subprocess execution times to a file. */
238 FILE *report_times_to_file = NULL;
240 /* Nonzero means place this string before uses of /, so that include
241 and library files can be found in an alternate location. */
243 #ifdef TARGET_SYSTEM_ROOT
244 #define DEFAULT_TARGET_SYSTEM_ROOT (TARGET_SYSTEM_ROOT)
245 #else
246 #define DEFAULT_TARGET_SYSTEM_ROOT (0)
247 #endif
248 static const char *target_system_root = DEFAULT_TARGET_SYSTEM_ROOT;
250 /* Nonzero means pass the updated target_system_root to the compiler. */
252 static int target_system_root_changed;
254 /* Nonzero means append this string to target_system_root. */
256 static const char *target_sysroot_suffix = 0;
258 /* Nonzero means append this string to target_system_root for headers. */
260 static const char *target_sysroot_hdrs_suffix = 0;
262 /* Nonzero means write "temp" files in source directory
263 and use the source file's name in them, and don't delete them. */
265 static enum save_temps {
266 SAVE_TEMPS_NONE, /* no -save-temps */
267 SAVE_TEMPS_CWD, /* -save-temps in current directory */
268 SAVE_TEMPS_OBJ /* -save-temps in object directory */
269 } save_temps_flag;
271 /* Output file to use to get the object directory for -save-temps=obj */
272 static char *save_temps_prefix = 0;
273 static size_t save_temps_length = 0;
275 /* The compiler version. */
277 static const char *compiler_version;
279 /* The target version. */
281 static const char *const spec_version = DEFAULT_TARGET_VERSION;
283 /* The target machine. */
285 static const char *spec_machine = DEFAULT_TARGET_MACHINE;
286 static const char *spec_host_machine = DEFAULT_REAL_TARGET_MACHINE;
288 /* List of offload targets. Separated by colon. Empty string for
289 -foffload=disable. */
291 static char *offload_targets = NULL;
293 /* Nonzero if cross-compiling.
294 When -b is used, the value comes from the `specs' file. */
296 #ifdef CROSS_DIRECTORY_STRUCTURE
297 static const char *cross_compile = "1";
298 #else
299 static const char *cross_compile = "0";
300 #endif
302 /* Greatest exit code of sub-processes that has been encountered up to
303 now. */
304 static int greatest_status = 1;
306 /* This is the obstack which we use to allocate many strings. */
308 static struct obstack obstack;
310 /* This is the obstack to build an environment variable to pass to
311 collect2 that describes all of the relevant switches of what to
312 pass the compiler in building the list of pointers to constructors
313 and destructors. */
315 static struct obstack collect_obstack;
317 /* Forward declaration for prototypes. */
318 struct path_prefix;
319 struct prefix_list;
321 static void init_spec (void);
322 static void store_arg (const char *, int, int);
323 static void insert_wrapper (const char *);
324 static char *load_specs (const char *);
325 static void read_specs (const char *, bool, bool);
326 static void set_spec (const char *, const char *, bool);
327 static struct compiler *lookup_compiler (const char *, size_t, const char *);
328 static char *build_search_list (const struct path_prefix *, const char *,
329 bool, bool);
330 static void xputenv (const char *);
331 static void putenv_from_prefixes (const struct path_prefix *, const char *,
332 bool);
333 static int access_check (const char *, int);
334 static char *find_a_file (const struct path_prefix *, const char *, int, bool);
335 static void add_prefix (struct path_prefix *, const char *, const char *,
336 int, int, int);
337 static void add_sysrooted_prefix (struct path_prefix *, const char *,
338 const char *, int, int, int);
339 static char *skip_whitespace (char *);
340 static void delete_if_ordinary (const char *);
341 static void delete_temp_files (void);
342 static void delete_failure_queue (void);
343 static void clear_failure_queue (void);
344 static int check_live_switch (int, int);
345 static const char *handle_braces (const char *);
346 static inline bool input_suffix_matches (const char *, const char *);
347 static inline bool switch_matches (const char *, const char *, int);
348 static inline void mark_matching_switches (const char *, const char *, int);
349 static inline void process_marked_switches (void);
350 static const char *process_brace_body (const char *, const char *, const char *, int, int);
351 static const struct spec_function *lookup_spec_function (const char *);
352 static const char *eval_spec_function (const char *, const char *);
353 static const char *handle_spec_function (const char *, bool *);
354 static char *save_string (const char *, int);
355 static void set_collect_gcc_options (void);
356 static int do_spec_1 (const char *, int, const char *);
357 static int do_spec_2 (const char *);
358 static void do_option_spec (const char *, const char *);
359 static void do_self_spec (const char *);
360 static const char *find_file (const char *);
361 static int is_directory (const char *, bool);
362 static const char *validate_switches (const char *, bool);
363 static void validate_all_switches (void);
364 static inline void validate_switches_from_spec (const char *, bool);
365 static void give_switch (int, int);
366 static int default_arg (const char *, int);
367 static void set_multilib_dir (void);
368 static void print_multilib_info (void);
369 static void perror_with_name (const char *);
370 static void display_help (void);
371 static void add_preprocessor_option (const char *, int);
372 static void add_assembler_option (const char *, int);
373 static void add_linker_option (const char *, int);
374 static void process_command (unsigned int, struct cl_decoded_option *);
375 static int execute (void);
376 static void alloc_args (void);
377 static void clear_args (void);
378 static void fatal_signal (int);
379 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
380 static void init_gcc_specs (struct obstack *, const char *, const char *,
381 const char *);
382 #endif
383 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
384 static const char *convert_filename (const char *, int, int);
385 #endif
387 static void try_generate_repro (const char **argv);
388 static const char *getenv_spec_function (int, const char **);
389 static const char *if_exists_spec_function (int, const char **);
390 static const char *if_exists_else_spec_function (int, const char **);
391 static const char *sanitize_spec_function (int, const char **);
392 static const char *replace_outfile_spec_function (int, const char **);
393 static const char *remove_outfile_spec_function (int, const char **);
394 static const char *version_compare_spec_function (int, const char **);
395 static const char *include_spec_function (int, const char **);
396 static const char *find_file_spec_function (int, const char **);
397 static const char *find_plugindir_spec_function (int, const char **);
398 static const char *print_asm_header_spec_function (int, const char **);
399 static const char *compare_debug_dump_opt_spec_function (int, const char **);
400 static const char *compare_debug_self_opt_spec_function (int, const char **);
401 static const char *compare_debug_auxbase_opt_spec_function (int, const char **);
402 static const char *pass_through_libs_spec_func (int, const char **);
403 static const char *replace_extension_spec_func (int, const char **);
404 static const char *greater_than_spec_func (int, const char **);
405 static const char *debug_level_greater_than_spec_func (int, const char **);
406 static char *convert_white_space (char *);
408 /* The Specs Language
410 Specs are strings containing lines, each of which (if not blank)
411 is made up of a program name, and arguments separated by spaces.
412 The program name must be exact and start from root, since no path
413 is searched and it is unreliable to depend on the current working directory.
414 Redirection of input or output is not supported; the subprograms must
415 accept filenames saying what files to read and write.
417 In addition, the specs can contain %-sequences to substitute variable text
418 or for conditional text. Here is a table of all defined %-sequences.
419 Note that spaces are not generated automatically around the results of
420 expanding these sequences; therefore, you can concatenate them together
421 or with constant text in a single argument.
423 %% substitute one % into the program name or argument.
424 %i substitute the name of the input file being processed.
425 %b substitute the basename of the input file being processed.
426 This is the substring up to (and not including) the last period
427 and not including the directory unless -save-temps was specified
428 to put temporaries in a different location.
429 %B same as %b, but include the file suffix (text after the last period).
430 %gSUFFIX
431 substitute a file name that has suffix SUFFIX and is chosen
432 once per compilation, and mark the argument a la %d. To reduce
433 exposure to denial-of-service attacks, the file name is now
434 chosen in a way that is hard to predict even when previously
435 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
436 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
437 the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
438 had been pre-processed. Previously, %g was simply substituted
439 with a file name chosen once per compilation, without regard
440 to any appended suffix (which was therefore treated just like
441 ordinary text), making such attacks more likely to succeed.
442 %|SUFFIX
443 like %g, but if -pipe is in effect, expands simply to "-".
444 %mSUFFIX
445 like %g, but if -pipe is in effect, expands to nothing. (We have both
446 %| and %m to accommodate differences between system assemblers; see
447 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
448 %uSUFFIX
449 like %g, but generates a new temporary file name even if %uSUFFIX
450 was already seen.
451 %USUFFIX
452 substitutes the last file name generated with %uSUFFIX, generating a
453 new one if there is no such last file name. In the absence of any
454 %uSUFFIX, this is just like %gSUFFIX, except they don't share
455 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
456 would involve the generation of two distinct file names, one
457 for each `%g.s' and another for each `%U.s'. Previously, %U was
458 simply substituted with a file name chosen for the previous %u,
459 without regard to any appended suffix.
460 %jSUFFIX
461 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
462 writable, and if save-temps is off; otherwise, substitute the name
463 of a temporary file, just like %u. This temporary file is not
464 meant for communication between processes, but rather as a junk
465 disposal mechanism.
466 %.SUFFIX
467 substitutes .SUFFIX for the suffixes of a matched switch's args when
468 it is subsequently output with %*. SUFFIX is terminated by the next
469 space or %.
470 %d marks the argument containing or following the %d as a
471 temporary file name, so that file will be deleted if GCC exits
472 successfully. Unlike %g, this contributes no text to the argument.
473 %w marks the argument containing or following the %w as the
474 "output file" of this compilation. This puts the argument
475 into the sequence of arguments that %o will substitute later.
476 %V indicates that this compilation produces no "output file".
477 %W{...}
478 like %{...} but mark last argument supplied within
479 as a file to be deleted on failure.
480 %o substitutes the names of all the output files, with spaces
481 automatically placed around them. You should write spaces
482 around the %o as well or the results are undefined.
483 %o is for use in the specs for running the linker.
484 Input files whose names have no recognized suffix are not compiled
485 at all, but they are included among the output files, so they will
486 be linked.
487 %O substitutes the suffix for object files. Note that this is
488 handled specially when it immediately follows %g, %u, or %U
489 (with or without a suffix argument) because of the need for
490 those to form complete file names. The handling is such that
491 %O is treated exactly as if it had already been substituted,
492 except that %g, %u, and %U do not currently support additional
493 SUFFIX characters following %O as they would following, for
494 example, `.o'.
495 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
496 (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
497 and -B options) and -imultilib as necessary.
498 %s current argument is the name of a library or startup file of some sort.
499 Search for that file in a standard list of directories
500 and substitute the full name found.
501 %eSTR Print STR as an error message. STR is terminated by a newline.
502 Use this when inconsistent options are detected.
503 %nSTR Print STR as a notice. STR is terminated by a newline.
504 %x{OPTION} Accumulate an option for %X.
505 %X Output the accumulated linker options specified by compilations.
506 %Y Output the accumulated assembler options specified by compilations.
507 %Z Output the accumulated preprocessor options specified by compilations.
508 %a process ASM_SPEC as a spec.
509 This allows config.h to specify part of the spec for running as.
510 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
511 used here. This can be used to run a post-processor after the
512 assembler has done its job.
513 %D Dump out a -L option for each directory in startfile_prefixes.
514 If multilib_dir is set, extra entries are generated with it affixed.
515 %l process LINK_SPEC as a spec.
516 %L process LIB_SPEC as a spec.
517 %M Output multilib_os_dir.
518 %G process LIBGCC_SPEC as a spec.
519 %R Output the concatenation of target_system_root and
520 target_sysroot_suffix.
521 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
522 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
523 %C process CPP_SPEC as a spec.
524 %1 process CC1_SPEC as a spec.
525 %2 process CC1PLUS_SPEC as a spec.
526 %* substitute the variable part of a matched option. (See below.)
527 Note that each comma in the substituted string is replaced by
528 a single space. A space is appended after the last substition
529 unless there is more text in current sequence.
530 %<S remove all occurrences of -S from the command line.
531 Note - this command is position dependent. % commands in the
532 spec string before this one will see -S, % commands in the
533 spec string after this one will not.
534 %>S Similar to "%<S", but keep it in the GCC command line.
535 %<S* remove all occurrences of all switches beginning with -S from the
536 command line.
537 %:function(args)
538 Call the named function FUNCTION, passing it ARGS. ARGS is
539 first processed as a nested spec string, then split into an
540 argument vector in the usual fashion. The function returns
541 a string which is processed as if it had appeared literally
542 as part of the current spec.
543 %{S} substitutes the -S switch, if that switch was given to GCC.
544 If that switch was not specified, this substitutes nothing.
545 Here S is a metasyntactic variable.
546 %{S*} substitutes all the switches specified to GCC whose names start
547 with -S. This is used for -o, -I, etc; switches that take
548 arguments. GCC considers `-o foo' as being one switch whose
549 name starts with `o'. %{o*} would substitute this text,
550 including the space; thus, two arguments would be generated.
551 %{S*&T*} likewise, but preserve order of S and T options (the order
552 of S and T in the spec is not significant). Can be any number
553 of ampersand-separated variables; for each the wild card is
554 optional. Useful for CPP as %{D*&U*&A*}.
556 %{S:X} substitutes X, if the -S switch was given to GCC.
557 %{!S:X} substitutes X, if the -S switch was NOT given to GCC.
558 %{S*:X} substitutes X if one or more switches whose names start
559 with -S was given to GCC. Normally X is substituted only
560 once, no matter how many such switches appeared. However,
561 if %* appears somewhere in X, then X will be substituted
562 once for each matching switch, with the %* replaced by the
563 part of that switch that matched the '*'. A space will be
564 appended after the last substition unless there is more
565 text in current sequence.
566 %{.S:X} substitutes X, if processing a file with suffix S.
567 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
568 %{,S:X} substitutes X, if processing a file which will use spec S.
569 %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
571 %{S|T:X} substitutes X if either -S or -T was given to GCC. This may be
572 combined with '!', '.', ',', and '*' as above binding stronger
573 than the OR.
574 If %* appears in X, all of the alternatives must be starred, and
575 only the first matching alternative is substituted.
576 %{%:function(args):X}
577 Call function named FUNCTION with args ARGS. If the function
578 returns non-NULL, then X is substituted, if it returns
579 NULL, it isn't substituted.
580 %{S:X; if S was given to GCC, substitutes X;
581 T:Y; else if T was given to GCC, substitutes Y;
582 :D} else substitutes D. There can be as many clauses as you need.
583 This may be combined with '.', '!', ',', '|', and '*' as above.
585 %(Spec) processes a specification defined in a specs file as *Spec:
587 The conditional text X in a %{S:X} or similar construct may contain
588 other nested % constructs or spaces, or even newlines. They are
589 processed as usual, as described above. Trailing white space in X is
590 ignored. White space may also appear anywhere on the left side of the
591 colon in these constructs, except between . or * and the corresponding
592 word.
594 The -O, -f, -g, -m, and -W switches are handled specifically in these
595 constructs. If another value of -O or the negated form of a -f, -m, or
596 -W switch is found later in the command line, the earlier switch
597 value is ignored, except with {S*} where S is just one letter; this
598 passes all matching options.
600 The character | at the beginning of the predicate text is used to indicate
601 that a command should be piped to the following command, but only if -pipe
602 is specified.
604 Note that it is built into GCC which switches take arguments and which
605 do not. You might think it would be useful to generalize this to
606 allow each compiler's spec to say which switches take arguments. But
607 this cannot be done in a consistent fashion. GCC cannot even decide
608 which input files have been specified without knowing which switches
609 take arguments, and it must know which input files to compile in order
610 to tell which compilers to run.
612 GCC also knows implicitly that arguments starting in `-l' are to be
613 treated as compiler output files, and passed to the linker in their
614 proper position among the other output files. */
616 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
618 /* config.h can define ASM_SPEC to provide extra args to the assembler
619 or extra switch-translations. */
620 #ifndef ASM_SPEC
621 #define ASM_SPEC ""
622 #endif
624 /* config.h can define ASM_FINAL_SPEC to run a post processor after
625 the assembler has run. */
626 #ifndef ASM_FINAL_SPEC
627 #define ASM_FINAL_SPEC \
628 "%{gsplit-dwarf: \n\
629 objcopy --extract-dwo \
630 %{c:%{o*:%*}%{!o*:%b%O}}%{!c:%U%O} \
631 %{c:%{o*:%:replace-extension(%{o*:%*} .dwo)}%{!o*:%b.dwo}}%{!c:%b.dwo} \n\
632 objcopy --strip-dwo \
633 %{c:%{o*:%*}%{!o*:%b%O}}%{!c:%U%O} \
635 #endif
637 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
638 or extra switch-translations. */
639 #ifndef CPP_SPEC
640 #define CPP_SPEC ""
641 #endif
643 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
644 or extra switch-translations. */
645 #ifndef CC1_SPEC
646 #define CC1_SPEC ""
647 #endif
649 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
650 or extra switch-translations. */
651 #ifndef CC1PLUS_SPEC
652 #define CC1PLUS_SPEC ""
653 #endif
655 /* config.h can define LINK_SPEC to provide extra args to the linker
656 or extra switch-translations. */
657 #ifndef LINK_SPEC
658 #define LINK_SPEC ""
659 #endif
661 /* config.h can define LIB_SPEC to override the default libraries. */
662 #ifndef LIB_SPEC
663 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
664 #endif
666 /* When using -fsplit-stack we need to wrap pthread_create, in order
667 to initialize the stack guard. We always use wrapping, rather than
668 shared library ordering, and we keep the wrapper function in
669 libgcc. This is not yet a real spec, though it could become one;
670 it is currently just stuffed into LINK_SPEC. FIXME: This wrapping
671 only works with GNU ld and gold. */
672 #ifdef HAVE_GOLD_NON_DEFAULT_SPLIT_STACK
673 #define STACK_SPLIT_SPEC " %{fsplit-stack: -fuse-ld=gold --wrap=pthread_create}"
674 #else
675 #define STACK_SPLIT_SPEC " %{fsplit-stack: --wrap=pthread_create}"
676 #endif
678 #ifndef LIBASAN_SPEC
679 #define STATIC_LIBASAN_LIBS \
680 " %{static-libasan:%:include(libsanitizer.spec)%(link_libasan)}"
681 #ifdef LIBASAN_EARLY_SPEC
682 #define LIBASAN_SPEC STATIC_LIBASAN_LIBS
683 #elif defined(HAVE_LD_STATIC_DYNAMIC)
684 #define LIBASAN_SPEC "%{static-libasan:" LD_STATIC_OPTION \
685 "} -lasan %{static-libasan:" LD_DYNAMIC_OPTION "}" \
686 STATIC_LIBASAN_LIBS
687 #else
688 #define LIBASAN_SPEC "-lasan" STATIC_LIBASAN_LIBS
689 #endif
690 #endif
692 #ifndef LIBASAN_EARLY_SPEC
693 #define LIBASAN_EARLY_SPEC ""
694 #endif
696 #ifndef LIBTSAN_SPEC
697 #define STATIC_LIBTSAN_LIBS \
698 " %{static-libtsan:%:include(libsanitizer.spec)%(link_libtsan)}"
699 #ifdef LIBTSAN_EARLY_SPEC
700 #define LIBTSAN_SPEC STATIC_LIBTSAN_LIBS
701 #elif defined(HAVE_LD_STATIC_DYNAMIC)
702 #define LIBTSAN_SPEC "%{static-libtsan:" LD_STATIC_OPTION \
703 "} -ltsan %{static-libtsan:" LD_DYNAMIC_OPTION "}" \
704 STATIC_LIBTSAN_LIBS
705 #else
706 #define LIBTSAN_SPEC "-ltsan" STATIC_LIBTSAN_LIBS
707 #endif
708 #endif
710 #ifndef LIBTSAN_EARLY_SPEC
711 #define LIBTSAN_EARLY_SPEC ""
712 #endif
714 #ifndef LIBLSAN_SPEC
715 #define STATIC_LIBLSAN_LIBS \
716 " %{static-liblsan:%:include(libsanitizer.spec)%(link_liblsan)}"
717 #ifdef LIBLSAN_EARLY_SPEC
718 #define LIBLSAN_SPEC STATIC_LIBLSAN_LIBS
719 #elif defined(HAVE_LD_STATIC_DYNAMIC)
720 #define LIBLSAN_SPEC "%{static-liblsan:" LD_STATIC_OPTION \
721 "} -llsan %{static-liblsan:" LD_DYNAMIC_OPTION "}" \
722 STATIC_LIBLSAN_LIBS
723 #else
724 #define LIBLSAN_SPEC "-llsan" STATIC_LIBLSAN_LIBS
725 #endif
726 #endif
728 #ifndef LIBLSAN_EARLY_SPEC
729 #define LIBLSAN_EARLY_SPEC ""
730 #endif
732 #ifndef LIBUBSAN_SPEC
733 #define STATIC_LIBUBSAN_LIBS \
734 " %{static-libubsan:%:include(libsanitizer.spec)%(link_libubsan)}"
735 #ifdef HAVE_LD_STATIC_DYNAMIC
736 #define LIBUBSAN_SPEC "%{static-libubsan:" LD_STATIC_OPTION \
737 "} -lubsan %{static-libubsan:" LD_DYNAMIC_OPTION "}" \
738 STATIC_LIBUBSAN_LIBS
739 #else
740 #define LIBUBSAN_SPEC "-lubsan" STATIC_LIBUBSAN_LIBS
741 #endif
742 #endif
744 /* Linker options for compressed debug sections. */
745 #if HAVE_LD_COMPRESS_DEBUG == 0
746 /* No linker support. */
747 #define LINK_COMPRESS_DEBUG_SPEC \
748 " %{gz*:%e-gz is not supported in this configuration} "
749 #elif HAVE_LD_COMPRESS_DEBUG == 1
750 /* GNU style on input, GNU ld options. Reject, not useful. */
751 #define LINK_COMPRESS_DEBUG_SPEC \
752 " %{gz*:%e-gz is not supported in this configuration} "
753 #elif HAVE_LD_COMPRESS_DEBUG == 2
754 /* GNU style, GNU gold options. */
755 #define LINK_COMPRESS_DEBUG_SPEC \
756 " %{gz|gz=zlib-gnu:" LD_COMPRESS_DEBUG_OPTION "=zlib}" \
757 " %{gz=none:" LD_COMPRESS_DEBUG_OPTION "=none}" \
758 " %{gz=zlib:%e-gz=zlib is not supported in this configuration} "
759 #elif HAVE_LD_COMPRESS_DEBUG == 3
760 /* ELF gABI style. */
761 #define LINK_COMPRESS_DEBUG_SPEC \
762 " %{gz|gz=zlib:" LD_COMPRESS_DEBUG_OPTION "=zlib}" \
763 " %{gz=none:" LD_COMPRESS_DEBUG_OPTION "=none}" \
764 " %{gz=zlib-gnu:" LD_COMPRESS_DEBUG_OPTION "=zlib-gnu} "
765 #else
766 #error Unknown value for HAVE_LD_COMPRESS_DEBUG.
767 #endif
769 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
770 included. */
771 #ifndef LIBGCC_SPEC
772 #if defined(REAL_LIBGCC_SPEC)
773 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
774 #elif defined(LINK_LIBGCC_SPECIAL_1)
775 /* Have gcc do the search for libgcc.a. */
776 #define LIBGCC_SPEC "libgcc.a%s"
777 #else
778 #define LIBGCC_SPEC "-lgcc"
779 #endif
780 #endif
782 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
783 #ifndef STARTFILE_SPEC
784 #define STARTFILE_SPEC \
785 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
786 #endif
788 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
789 #ifndef ENDFILE_SPEC
790 #define ENDFILE_SPEC ""
791 #endif
793 #ifndef LINKER_NAME
794 #define LINKER_NAME "collect2"
795 #endif
797 #ifdef HAVE_AS_DEBUG_PREFIX_MAP
798 #define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
799 #else
800 #define ASM_MAP ""
801 #endif
803 /* Assembler options for compressed debug sections. */
804 #if HAVE_LD_COMPRESS_DEBUG < 2
805 /* Reject if the linker cannot write compressed debug sections. */
806 #define ASM_COMPRESS_DEBUG_SPEC \
807 " %{gz*:%e-gz is not supported in this configuration} "
808 #else /* HAVE_LD_COMPRESS_DEBUG >= 2 */
809 #if HAVE_AS_COMPRESS_DEBUG == 0
810 /* No assembler support. Ignore silently. */
811 #define ASM_COMPRESS_DEBUG_SPEC \
812 " %{gz*:} "
813 #elif HAVE_AS_COMPRESS_DEBUG == 1
814 /* GNU style, GNU as options. */
815 #define ASM_COMPRESS_DEBUG_SPEC \
816 " %{gz|gz=zlib-gnu:" AS_COMPRESS_DEBUG_OPTION "}" \
817 " %{gz=none:" AS_NO_COMPRESS_DEBUG_OPTION "}" \
818 " %{gz=zlib:%e-gz=zlib is not supported in this configuration} "
819 #elif HAVE_AS_COMPRESS_DEBUG == 2
820 /* ELF gABI style. */
821 #define ASM_COMPRESS_DEBUG_SPEC \
822 " %{gz|gz=zlib:" AS_COMPRESS_DEBUG_OPTION "=zlib}" \
823 " %{gz=none:" AS_COMPRESS_DEBUG_OPTION "=none}" \
824 " %{gz=zlib-gnu:" AS_COMPRESS_DEBUG_OPTION "=zlib-gnu} "
825 #else
826 #error Unknown value for HAVE_AS_COMPRESS_DEBUG.
827 #endif
828 #endif /* HAVE_LD_COMPRESS_DEBUG >= 2 */
830 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
831 to the assembler. */
832 #ifndef ASM_DEBUG_SPEC
833 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
834 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
835 # define ASM_DEBUG_SPEC \
836 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
837 ? "%{%:debug-level-gt(0):" \
838 "%{gdwarf*:--gdwarf2}%{!gdwarf*:%{g*:--gstabs}}}" ASM_MAP \
839 : "%{%:debug-level-gt(0):" \
840 "%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}}" ASM_MAP)
841 # else
842 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
843 # define ASM_DEBUG_SPEC "%{g*:%{%:debug-level-gt(0):--gstabs}}" ASM_MAP
844 # endif
845 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
846 # define ASM_DEBUG_SPEC "%{g*:%{%:debug-level-gt(0):--gdwarf2}}" ASM_MAP
847 # endif
848 # endif
849 #endif
850 #ifndef ASM_DEBUG_SPEC
851 # define ASM_DEBUG_SPEC ""
852 #endif
854 /* Here is the spec for running the linker, after compiling all files. */
856 /* This is overridable by the target in case they need to specify the
857 -lgcc and -lc order specially, yet not require them to override all
858 of LINK_COMMAND_SPEC. */
859 #ifndef LINK_GCC_C_SEQUENCE_SPEC
860 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
861 #endif
863 #ifndef LINK_SSP_SPEC
864 #ifdef TARGET_LIBC_PROVIDES_SSP
865 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all" \
866 "|fstack-protector-strong|fstack-protector-explicit:}"
867 #else
868 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all" \
869 "|fstack-protector-strong|fstack-protector-explicit" \
870 ":-lssp_nonshared -lssp}"
871 #endif
872 #endif
874 #ifdef ENABLE_DEFAULT_PIE
875 #define NO_PIE_SPEC "no-pie|static"
876 #define PIE_SPEC NO_PIE_SPEC "|r|shared:;"
877 #define NO_FPIE1_SPEC "fno-pie"
878 #define FPIE1_SPEC NO_FPIE1_SPEC ":;"
879 #define NO_FPIE2_SPEC "fno-PIE"
880 #define FPIE2_SPEC NO_FPIE2_SPEC ":;"
881 #define NO_FPIE_SPEC NO_FPIE1_SPEC "|" NO_FPIE2_SPEC
882 #define FPIE_SPEC NO_FPIE_SPEC ":;"
883 #define NO_FPIC1_SPEC "fno-pic"
884 #define FPIC1_SPEC NO_FPIC1_SPEC ":;"
885 #define NO_FPIC2_SPEC "fno-PIC"
886 #define FPIC2_SPEC NO_FPIC2_SPEC ":;"
887 #define NO_FPIC_SPEC NO_FPIC1_SPEC "|" NO_FPIC2_SPEC
888 #define FPIC_SPEC NO_FPIC_SPEC ":;"
889 #define NO_FPIE1_AND_FPIC1_SPEC NO_FPIE1_SPEC "|" NO_FPIC1_SPEC
890 #define FPIE1_OR_FPIC1_SPEC NO_FPIE1_AND_FPIC1_SPEC ":;"
891 #define NO_FPIE2_AND_FPIC2_SPEC NO_FPIE2_SPEC "|" NO_FPIC2_SPEC
892 #define FPIE2_OR_FPIC2_SPEC NO_FPIE2_AND_FPIC2_SPEC ":;"
893 #define NO_FPIE_AND_FPIC_SPEC NO_FPIE_SPEC "|" NO_FPIC_SPEC
894 #define FPIE_OR_FPIC_SPEC NO_FPIE_AND_FPIC_SPEC ":;"
895 #else
896 #define PIE_SPEC "pie"
897 #define NO_PIE_SPEC PIE_SPEC "|r|shared:;"
898 #define FPIE1_SPEC "fpie"
899 #define NO_FPIE1_SPEC FPIE1_SPEC ":;"
900 #define FPIE2_SPEC "fPIE"
901 #define NO_FPIE2_SPEC FPIE2_SPEC ":;"
902 #define FPIE_SPEC FPIE1_SPEC "|" FPIE2_SPEC
903 #define NO_FPIE_SPEC FPIE_SPEC ":;"
904 #define FPIC1_SPEC "fpic"
905 #define NO_FPIC1_SPEC FPIC1_SPEC ":;"
906 #define FPIC2_SPEC "fPIC"
907 #define NO_FPIC2_SPEC FPIC2_SPEC ":;"
908 #define FPIC_SPEC FPIC1_SPEC "|" FPIC2_SPEC
909 #define NO_FPIC_SPEC FPIC_SPEC ":;"
910 #define FPIE1_OR_FPIC1_SPEC FPIE1_SPEC "|" FPIC1_SPEC
911 #define NO_FPIE1_AND_FPIC1_SPEC FPIE1_OR_FPIC1_SPEC ":;"
912 #define FPIE2_OR_FPIC2_SPEC FPIE2_SPEC "|" FPIC2_SPEC
913 #define NO_FPIE2_AND_FPIC2_SPEC FPIE1_OR_FPIC2_SPEC ":;"
914 #define FPIE_OR_FPIC_SPEC FPIE_SPEC "|" FPIC_SPEC
915 #define NO_FPIE_AND_FPIC_SPEC FPIE_OR_FPIC_SPEC ":;"
916 #endif
918 #ifndef LINK_PIE_SPEC
919 #ifdef HAVE_LD_PIE
920 #ifndef LD_PIE_SPEC
921 #define LD_PIE_SPEC "-pie"
922 #endif
923 #else
924 #define LD_PIE_SPEC ""
925 #endif
926 #define LINK_PIE_SPEC "%{no-pie:} " "%{" PIE_SPEC ":" LD_PIE_SPEC "} "
927 #endif
929 #ifndef LINK_BUILDID_SPEC
930 # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
931 # define LINK_BUILDID_SPEC "%{!r:--build-id} "
932 # endif
933 #endif
935 /* Conditional to test whether the LTO plugin is used or not.
936 FIXME: For slim LTO we will need to enable plugin unconditionally. This
937 still cause problems with PLUGIN_LD != LD and when plugin is built but
938 not useable. For GCC 4.6 we don't support slim LTO and thus we can enable
939 plugin only when LTO is enabled. We still honor explicit
940 -fuse-linker-plugin if the linker used understands -plugin. */
942 /* The linker has some plugin support. */
943 #if HAVE_LTO_PLUGIN > 0
944 /* The linker used has full plugin support, use LTO plugin by default. */
945 #if HAVE_LTO_PLUGIN == 2
946 #define PLUGIN_COND "!fno-use-linker-plugin:%{!fno-lto"
947 #define PLUGIN_COND_CLOSE "}"
948 #else
949 /* The linker used has limited plugin support, use LTO plugin with explicit
950 -fuse-linker-plugin. */
951 #define PLUGIN_COND "fuse-linker-plugin"
952 #define PLUGIN_COND_CLOSE ""
953 #endif
954 #define LINK_PLUGIN_SPEC \
955 "%{" PLUGIN_COND": \
956 -plugin %(linker_plugin_file) \
957 -plugin-opt=%(lto_wrapper) \
958 -plugin-opt=-fresolution=%u.res \
959 %{!nostdlib:%{!nodefaultlibs:%:pass-through-libs(%(link_gcc_c_sequence))}} \
960 }" PLUGIN_COND_CLOSE
961 #else
962 /* The linker used doesn't support -plugin, reject -fuse-linker-plugin. */
963 #define LINK_PLUGIN_SPEC "%{fuse-linker-plugin:\
964 %e-fuse-linker-plugin is not supported in this configuration}"
965 #endif
967 /* Linker command line options for -fsanitize= early on the command line. */
968 #ifndef SANITIZER_EARLY_SPEC
969 #define SANITIZER_EARLY_SPEC "\
970 %{!nostdlib:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_EARLY_SPEC "} \
971 %{%:sanitize(thread):" LIBTSAN_EARLY_SPEC "} \
972 %{%:sanitize(leak):" LIBLSAN_EARLY_SPEC "}}}"
973 #endif
975 /* Linker command line options for -fsanitize= late on the command line. */
976 #ifndef SANITIZER_SPEC
977 #define SANITIZER_SPEC "\
978 %{!nostdlib:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_SPEC "\
979 %{static:%ecannot specify -static with -fsanitize=address}}\
980 %{%:sanitize(thread):" LIBTSAN_SPEC "\
981 %{static:%ecannot specify -static with -fsanitize=thread}}\
982 %{%:sanitize(undefined):" LIBUBSAN_SPEC "}\
983 %{%:sanitize(leak):" LIBLSAN_SPEC "}}}"
984 #endif
986 #ifndef POST_LINK_SPEC
987 #define POST_LINK_SPEC ""
988 #endif
990 /* This is the spec to use, once the code for creating the vtable
991 verification runtime library, libvtv.so, has been created. Currently
992 the vtable verification runtime functions are in libstdc++, so we use
993 the spec just below this one. */
994 #ifndef VTABLE_VERIFICATION_SPEC
995 #if ENABLE_VTABLE_VERIFY
996 #define VTABLE_VERIFICATION_SPEC "\
997 %{!nostdlib:%{fvtable-verify=std: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}\
998 %{fvtable-verify=preinit: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}}"
999 #else
1000 #define VTABLE_VERIFICATION_SPEC "\
1001 %{fvtable-verify=none:} \
1002 %{fvtable-verify=std: \
1003 %e-fvtable-verify=std is not supported in this configuration} \
1004 %{fvtable-verify=preinit: \
1005 %e-fvtable-verify=preinit is not supported in this configuration}"
1006 #endif
1007 #endif
1009 #ifndef CHKP_SPEC
1010 #define CHKP_SPEC ""
1011 #endif
1013 /* -u* was put back because both BSD and SysV seem to support it. */
1014 /* %{static:} simply prevents an error message if the target machine
1015 doesn't handle -static. */
1016 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
1017 scripts which exist in user specified directories, or in standard
1018 directories. */
1019 /* We pass any -flto flags on to the linker, which is expected
1020 to understand them. In practice, this means it had better be collect2. */
1021 /* %{e*} includes -export-dynamic; see comment in common.opt. */
1022 #ifndef LINK_COMMAND_SPEC
1023 #define LINK_COMMAND_SPEC "\
1024 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
1025 %(linker) " \
1026 LINK_PLUGIN_SPEC \
1027 "%{flto|flto=*:%<fcompare-debug*} \
1028 %{flto} %{fno-lto} %{flto=*} %l " LINK_PIE_SPEC \
1029 "%{fuse-ld=*:-fuse-ld=%*} " LINK_COMPRESS_DEBUG_SPEC \
1030 "%X %{o*} %{e*} %{N} %{n} %{r}\
1031 %{s} %{t} %{u*} %{z} %{Z} %{!nostdlib:%{!nostartfiles:%S}} \
1032 %{static:} %{L*} %(mfwrap) %(link_libgcc) " \
1033 VTABLE_VERIFICATION_SPEC " " SANITIZER_EARLY_SPEC " %o " CHKP_SPEC " \
1034 %{fopenacc|fopenmp|%:gt(%{ftree-parallelize-loops=*:%*} 1):\
1035 %:include(libgomp.spec)%(link_gomp)}\
1036 %{fcilkplus:%:include(libcilkrts.spec)%(link_cilkrts)}\
1037 %{fgnu-tm:%:include(libitm.spec)%(link_itm)}\
1038 %(mflib) " STACK_SPLIT_SPEC "\
1039 %{fprofile-arcs|fprofile-generate*|coverage:-lgcov} " SANITIZER_SPEC " \
1040 %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\
1041 %{!nostdlib:%{!nostartfiles:%E}} %{T*} \n%(post_link) }}}}}}"
1042 #endif
1044 #ifndef LINK_LIBGCC_SPEC
1045 /* Generate -L options for startfile prefix list. */
1046 # define LINK_LIBGCC_SPEC "%D"
1047 #endif
1049 #ifndef STARTFILE_PREFIX_SPEC
1050 # define STARTFILE_PREFIX_SPEC ""
1051 #endif
1053 #ifndef SYSROOT_SPEC
1054 # define SYSROOT_SPEC "--sysroot=%R"
1055 #endif
1057 #ifndef SYSROOT_SUFFIX_SPEC
1058 # define SYSROOT_SUFFIX_SPEC ""
1059 #endif
1061 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
1062 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
1063 #endif
1065 static const char *asm_debug = ASM_DEBUG_SPEC;
1066 static const char *cpp_spec = CPP_SPEC;
1067 static const char *cc1_spec = CC1_SPEC;
1068 static const char *cc1plus_spec = CC1PLUS_SPEC;
1069 static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC;
1070 static const char *link_ssp_spec = LINK_SSP_SPEC;
1071 static const char *asm_spec = ASM_SPEC;
1072 static const char *asm_final_spec = ASM_FINAL_SPEC;
1073 static const char *link_spec = LINK_SPEC;
1074 static const char *lib_spec = LIB_SPEC;
1075 static const char *link_gomp_spec = "";
1076 static const char *libgcc_spec = LIBGCC_SPEC;
1077 static const char *endfile_spec = ENDFILE_SPEC;
1078 static const char *startfile_spec = STARTFILE_SPEC;
1079 static const char *linker_name_spec = LINKER_NAME;
1080 static const char *linker_plugin_file_spec = "";
1081 static const char *lto_wrapper_spec = "";
1082 static const char *lto_gcc_spec = "";
1083 static const char *post_link_spec = POST_LINK_SPEC;
1084 static const char *link_command_spec = LINK_COMMAND_SPEC;
1085 static const char *link_libgcc_spec = LINK_LIBGCC_SPEC;
1086 static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC;
1087 static const char *sysroot_spec = SYSROOT_SPEC;
1088 static const char *sysroot_suffix_spec = SYSROOT_SUFFIX_SPEC;
1089 static const char *sysroot_hdrs_suffix_spec = SYSROOT_HEADERS_SUFFIX_SPEC;
1090 static const char *self_spec = "";
1092 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
1093 There should be no need to override these in target dependent files,
1094 but we need to copy them to the specs file so that newer versions
1095 of the GCC driver can correctly drive older tool chains with the
1096 appropriate -B options. */
1098 /* When cpplib handles traditional preprocessing, get rid of this, and
1099 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
1100 that we default the front end language better. */
1101 static const char *trad_capable_cpp =
1102 "cc1 -E %{traditional|traditional-cpp:-traditional-cpp}";
1104 /* We don't wrap .d files in %W{} since a missing .d file, and
1105 therefore no dependency entry, confuses make into thinking a .o
1106 file that happens to exist is up-to-date. */
1107 static const char *cpp_unique_options =
1108 "%{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\
1109 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
1110 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
1111 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
1112 %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
1113 %{remap} %{g3|ggdb3|gstabs3|gcoff3|gxcoff3|gvms3:-dD}\
1114 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
1115 %{H} %C %{D*&U*&A*} %{i*} %Z %i\
1116 %{E|M|MM:%W{o*}}";
1118 /* This contains cpp options which are common with cc1_options and are passed
1119 only when preprocessing only to avoid duplication. We pass the cc1 spec
1120 options to the preprocessor so that it the cc1 spec may manipulate
1121 options used to set target flags. Those special target flags settings may
1122 in turn cause preprocessor symbols to be defined specially. */
1123 static const char *cpp_options =
1124 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
1125 %{f*} %{g*:%{%:debug-level-gt(0):%{g*}\
1126 %{!fno-working-directory:-fworking-directory}}} %{O*}\
1127 %{undef} %{save-temps*:-fpch-preprocess}";
1129 /* This contains cpp options which are not passed when the preprocessor
1130 output will be used by another program. */
1131 static const char *cpp_debug_options = "%{d*}";
1133 /* NB: This is shared amongst all front-ends, except for Ada. */
1134 static const char *cc1_options =
1135 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
1136 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
1137 %1 %{!Q:-quiet} %{!dumpbase:-dumpbase %B} %{d*} %{m*} %{aux-info*}\
1138 %{fcompare-debug-second:%:compare-debug-auxbase-opt(%b)} \
1139 %{!fcompare-debug-second:%{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}}%{!c:%{!S:-auxbase %b}} \
1140 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
1141 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
1142 %{Qn:-fno-ident} %{Qy:} %{-help:--help}\
1143 %{-target-help:--target-help}\
1144 %{-version:--version}\
1145 %{-help=*:--help=%*}\
1146 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
1147 %{fsyntax-only:-o %j} %{-param*}\
1148 %{coverage:-fprofile-arcs -ftest-coverage}\
1149 %{fprofile-arcs|fprofile-generate*|coverage:\
1150 %{!fprofile-update=single:\
1151 %{pthread:-fprofile-update=prefer-atomic}}}";
1153 static const char *asm_options =
1154 "%{-target-help:%:print-asm-header()} "
1155 #if HAVE_GNU_AS
1156 /* If GNU AS is used, then convert -w (no warnings), -I, and -v
1157 to the assembler equivalents. */
1158 "%{v} %{w:-W} %{I*} "
1159 #endif
1160 ASM_COMPRESS_DEBUG_SPEC
1161 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
1163 static const char *invoke_as =
1164 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1165 "%{!fwpa*:\
1166 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
1167 %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
1169 #else
1170 "%{!fwpa*:\
1171 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
1172 %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
1174 #endif
1176 /* Some compilers have limits on line lengths, and the multilib_select
1177 and/or multilib_matches strings can be very long, so we build them at
1178 run time. */
1179 static struct obstack multilib_obstack;
1180 static const char *multilib_select;
1181 static const char *multilib_matches;
1182 static const char *multilib_defaults;
1183 static const char *multilib_exclusions;
1184 static const char *multilib_reuse;
1186 /* Check whether a particular argument is a default argument. */
1188 #ifndef MULTILIB_DEFAULTS
1189 #define MULTILIB_DEFAULTS { "" }
1190 #endif
1192 static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
1194 #ifndef DRIVER_SELF_SPECS
1195 #define DRIVER_SELF_SPECS ""
1196 #endif
1198 /* Linking to libgomp implies pthreads. This is particularly important
1199 for targets that use different start files and suchlike. */
1200 #ifndef GOMP_SELF_SPECS
1201 #define GOMP_SELF_SPECS \
1202 "%{fopenacc|fopenmp|%:gt(%{ftree-parallelize-loops=*:%*} 1): " \
1203 "-pthread}"
1204 #endif
1206 /* Likewise for -fgnu-tm. */
1207 #ifndef GTM_SELF_SPECS
1208 #define GTM_SELF_SPECS "%{fgnu-tm: -pthread}"
1209 #endif
1211 /* Likewise for -fcilkplus. */
1212 #ifndef CILK_SELF_SPECS
1213 #define CILK_SELF_SPECS "%{fcilkplus: -pthread}"
1214 #endif
1216 static const char *const driver_self_specs[] = {
1217 "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
1218 DRIVER_SELF_SPECS, CONFIGURE_SPECS, GOMP_SELF_SPECS, GTM_SELF_SPECS,
1219 CILK_SELF_SPECS
1222 #ifndef OPTION_DEFAULT_SPECS
1223 #define OPTION_DEFAULT_SPECS { "", "" }
1224 #endif
1226 struct default_spec
1228 const char *name;
1229 const char *spec;
1232 static const struct default_spec
1233 option_default_specs[] = { OPTION_DEFAULT_SPECS };
1235 struct user_specs
1237 struct user_specs *next;
1238 const char *filename;
1241 static struct user_specs *user_specs_head, *user_specs_tail;
1244 /* Record the mapping from file suffixes for compilation specs. */
1246 struct compiler
1248 const char *suffix; /* Use this compiler for input files
1249 whose names end in this suffix. */
1251 const char *spec; /* To use this compiler, run this spec. */
1253 const char *cpp_spec; /* If non-NULL, substitute this spec
1254 for `%C', rather than the usual
1255 cpp_spec. */
1256 const int combinable; /* If nonzero, compiler can deal with
1257 multiple source files at once (IMA). */
1258 const int needs_preprocessing; /* If nonzero, source files need to
1259 be run through a preprocessor. */
1262 /* Pointer to a vector of `struct compiler' that gives the spec for
1263 compiling a file, based on its suffix.
1264 A file that does not end in any of these suffixes will be passed
1265 unchanged to the loader and nothing else will be done to it.
1267 An entry containing two 0s is used to terminate the vector.
1269 If multiple entries match a file, the last matching one is used. */
1271 static struct compiler *compilers;
1273 /* Number of entries in `compilers', not counting the null terminator. */
1275 static int n_compilers;
1277 /* The default list of file name suffixes and their compilation specs. */
1279 static const struct compiler default_compilers[] =
1281 /* Add lists of suffixes of known languages here. If those languages
1282 were not present when we built the driver, we will hit these copies
1283 and be given a more meaningful error than "file not used since
1284 linking is not done". */
1285 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0},
1286 {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
1287 {".mii", "#Objective-C++", 0, 0, 0},
1288 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
1289 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
1290 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
1291 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
1292 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
1293 {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
1294 {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
1295 {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
1296 {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
1297 {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
1298 {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
1299 {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
1300 {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
1301 {".r", "#Ratfor", 0, 0, 0},
1302 {".p", "#Pascal", 0, 0, 0}, {".pas", "#Pascal", 0, 0, 0},
1303 {".java", "#Java", 0, 0, 0}, {".class", "#Java", 0, 0, 0},
1304 {".zip", "#Java", 0, 0, 0}, {".jar", "#Java", 0, 0, 0},
1305 {".go", "#Go", 0, 1, 0},
1306 /* Next come the entries for C. */
1307 {".c", "@c", 0, 0, 1},
1308 {"@c",
1309 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1310 external preprocessor if -save-temps is given. */
1311 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1312 %{!E:%{!M:%{!MM:\
1313 %{traditional:\
1314 %eGNU C no longer supports -traditional without -E}\
1315 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1316 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1317 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1318 %(cc1_options)}\
1319 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1320 cc1 %(cpp_unique_options) %(cc1_options)}}}\
1321 %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 1},
1322 {"-",
1323 "%{!E:%e-E or -x required when input is from standard input}\
1324 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
1325 {".h", "@c-header", 0, 0, 0},
1326 {"@c-header",
1327 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1328 external preprocessor if -save-temps is given. */
1329 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1330 %{!E:%{!M:%{!MM:\
1331 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1332 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1333 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1334 %(cc1_options)\
1335 %{!fsyntax-only:%{!S:-o %g.s} \
1336 %{!fdump-ada-spec*:%{!o*:--output-pch=%i.gch}\
1337 %W{o*:--output-pch=%*}}%V}}\
1338 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1339 cc1 %(cpp_unique_options) %(cc1_options)\
1340 %{!fsyntax-only:%{!S:-o %g.s} \
1341 %{!fdump-ada-spec*:%{!o*:--output-pch=%i.gch}\
1342 %W{o*:--output-pch=%*}}%V}}}}}}}", 0, 0, 0},
1343 {".i", "@cpp-output", 0, 0, 0},
1344 {"@cpp-output",
1345 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 0},
1346 {".s", "@assembler", 0, 0, 0},
1347 {"@assembler",
1348 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 0, 0},
1349 {".sx", "@assembler-with-cpp", 0, 0, 0},
1350 {".S", "@assembler-with-cpp", 0, 0, 0},
1351 {"@assembler-with-cpp",
1352 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1353 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1354 %{E|M|MM:%(cpp_debug_options)}\
1355 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1356 as %(asm_debug) %(asm_options) %|.s %A }}}}"
1357 #else
1358 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1359 %{E|M|MM:%(cpp_debug_options)}\
1360 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1361 as %(asm_debug) %(asm_options) %m.s %A }}}}"
1362 #endif
1363 , 0, 0, 0},
1365 #include "specs.h"
1366 /* Mark end of table. */
1367 {0, 0, 0, 0, 0}
1370 /* Number of elements in default_compilers, not counting the terminator. */
1372 static const int n_default_compilers = ARRAY_SIZE (default_compilers) - 1;
1374 typedef char *char_p; /* For DEF_VEC_P. */
1376 /* A vector of options to give to the linker.
1377 These options are accumulated by %x,
1378 and substituted into the linker command with %X. */
1379 static vec<char_p> linker_options;
1381 /* A vector of options to give to the assembler.
1382 These options are accumulated by -Wa,
1383 and substituted into the assembler command with %Y. */
1384 static vec<char_p> assembler_options;
1386 /* A vector of options to give to the preprocessor.
1387 These options are accumulated by -Wp,
1388 and substituted into the preprocessor command with %Z. */
1389 static vec<char_p> preprocessor_options;
1391 static char *
1392 skip_whitespace (char *p)
1394 while (1)
1396 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1397 be considered whitespace. */
1398 if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
1399 return p + 1;
1400 else if (*p == '\n' || *p == ' ' || *p == '\t')
1401 p++;
1402 else if (*p == '#')
1404 while (*p != '\n')
1405 p++;
1406 p++;
1408 else
1409 break;
1412 return p;
1414 /* Structures to keep track of prefixes to try when looking for files. */
1416 struct prefix_list
1418 const char *prefix; /* String to prepend to the path. */
1419 struct prefix_list *next; /* Next in linked list. */
1420 int require_machine_suffix; /* Don't use without machine_suffix. */
1421 /* 2 means try both machine_suffix and just_machine_suffix. */
1422 int priority; /* Sort key - priority within list. */
1423 int os_multilib; /* 1 if OS multilib scheme should be used,
1424 0 for GCC multilib scheme. */
1427 struct path_prefix
1429 struct prefix_list *plist; /* List of prefixes to try */
1430 int max_len; /* Max length of a prefix in PLIST */
1431 const char *name; /* Name of this list (used in config stuff) */
1434 /* List of prefixes to try when looking for executables. */
1436 static struct path_prefix exec_prefixes = { 0, 0, "exec" };
1438 /* List of prefixes to try when looking for startup (crt0) files. */
1440 static struct path_prefix startfile_prefixes = { 0, 0, "startfile" };
1442 /* List of prefixes to try when looking for include files. */
1444 static struct path_prefix include_prefixes = { 0, 0, "include" };
1446 /* Suffix to attach to directories searched for commands.
1447 This looks like `MACHINE/VERSION/'. */
1449 static const char *machine_suffix = 0;
1451 /* Suffix to attach to directories searched for commands.
1452 This is just `MACHINE/'. */
1454 static const char *just_machine_suffix = 0;
1456 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1458 static const char *gcc_exec_prefix;
1460 /* Adjusted value of standard_libexec_prefix. */
1462 static const char *gcc_libexec_prefix;
1464 /* Default prefixes to attach to command names. */
1466 #ifndef STANDARD_STARTFILE_PREFIX_1
1467 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1468 #endif
1469 #ifndef STANDARD_STARTFILE_PREFIX_2
1470 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1471 #endif
1473 #ifdef CROSS_DIRECTORY_STRUCTURE /* Don't use these prefixes for a cross compiler. */
1474 #undef MD_EXEC_PREFIX
1475 #undef MD_STARTFILE_PREFIX
1476 #undef MD_STARTFILE_PREFIX_1
1477 #endif
1479 /* If no prefixes defined, use the null string, which will disable them. */
1480 #ifndef MD_EXEC_PREFIX
1481 #define MD_EXEC_PREFIX ""
1482 #endif
1483 #ifndef MD_STARTFILE_PREFIX
1484 #define MD_STARTFILE_PREFIX ""
1485 #endif
1486 #ifndef MD_STARTFILE_PREFIX_1
1487 #define MD_STARTFILE_PREFIX_1 ""
1488 #endif
1490 /* These directories are locations set at configure-time based on the
1491 --prefix option provided to configure. Their initializers are
1492 defined in Makefile.in. These paths are not *directly* used when
1493 gcc_exec_prefix is set because, in that case, we know where the
1494 compiler has been installed, and use paths relative to that
1495 location instead. */
1496 static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
1497 static const char *const standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX;
1498 static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
1499 static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1501 /* For native compilers, these are well-known paths containing
1502 components that may be provided by the system. For cross
1503 compilers, these paths are not used. */
1504 static const char *md_exec_prefix = MD_EXEC_PREFIX;
1505 static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1506 static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1507 static const char *const standard_startfile_prefix_1
1508 = STANDARD_STARTFILE_PREFIX_1;
1509 static const char *const standard_startfile_prefix_2
1510 = STANDARD_STARTFILE_PREFIX_2;
1512 /* A relative path to be used in finding the location of tools
1513 relative to the driver. */
1514 static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1516 /* A prefix to be used when this is an accelerator compiler. */
1517 static const char *const accel_dir_suffix = ACCEL_DIR_SUFFIX;
1519 /* Subdirectory to use for locating libraries. Set by
1520 set_multilib_dir based on the compilation options. */
1522 static const char *multilib_dir;
1524 /* Subdirectory to use for locating libraries in OS conventions. Set by
1525 set_multilib_dir based on the compilation options. */
1527 static const char *multilib_os_dir;
1529 /* Subdirectory to use for locating libraries in multiarch conventions. Set by
1530 set_multilib_dir based on the compilation options. */
1532 static const char *multiarch_dir;
1534 /* Structure to keep track of the specs that have been defined so far.
1535 These are accessed using %(specname) in a compiler or link
1536 spec. */
1538 struct spec_list
1540 /* The following 2 fields must be first */
1541 /* to allow EXTRA_SPECS to be initialized */
1542 const char *name; /* name of the spec. */
1543 const char *ptr; /* available ptr if no static pointer */
1545 /* The following fields are not initialized */
1546 /* by EXTRA_SPECS */
1547 const char **ptr_spec; /* pointer to the spec itself. */
1548 struct spec_list *next; /* Next spec in linked list. */
1549 int name_len; /* length of the name */
1550 bool user_p; /* whether string come from file spec. */
1551 bool alloc_p; /* whether string was allocated */
1552 const char *default_ptr; /* The default value of *ptr_spec. */
1555 #define INIT_STATIC_SPEC(NAME,PTR) \
1556 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, false, false, \
1557 *PTR }
1559 /* List of statically defined specs. */
1560 static struct spec_list static_specs[] =
1562 INIT_STATIC_SPEC ("asm", &asm_spec),
1563 INIT_STATIC_SPEC ("asm_debug", &asm_debug),
1564 INIT_STATIC_SPEC ("asm_final", &asm_final_spec),
1565 INIT_STATIC_SPEC ("asm_options", &asm_options),
1566 INIT_STATIC_SPEC ("invoke_as", &invoke_as),
1567 INIT_STATIC_SPEC ("cpp", &cpp_spec),
1568 INIT_STATIC_SPEC ("cpp_options", &cpp_options),
1569 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options),
1570 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options),
1571 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp),
1572 INIT_STATIC_SPEC ("cc1", &cc1_spec),
1573 INIT_STATIC_SPEC ("cc1_options", &cc1_options),
1574 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec),
1575 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec),
1576 INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec),
1577 INIT_STATIC_SPEC ("endfile", &endfile_spec),
1578 INIT_STATIC_SPEC ("link", &link_spec),
1579 INIT_STATIC_SPEC ("lib", &lib_spec),
1580 INIT_STATIC_SPEC ("link_gomp", &link_gomp_spec),
1581 INIT_STATIC_SPEC ("libgcc", &libgcc_spec),
1582 INIT_STATIC_SPEC ("startfile", &startfile_spec),
1583 INIT_STATIC_SPEC ("cross_compile", &cross_compile),
1584 INIT_STATIC_SPEC ("version", &compiler_version),
1585 INIT_STATIC_SPEC ("multilib", &multilib_select),
1586 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults),
1587 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra),
1588 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches),
1589 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions),
1590 INIT_STATIC_SPEC ("multilib_options", &multilib_options),
1591 INIT_STATIC_SPEC ("multilib_reuse", &multilib_reuse),
1592 INIT_STATIC_SPEC ("linker", &linker_name_spec),
1593 INIT_STATIC_SPEC ("linker_plugin_file", &linker_plugin_file_spec),
1594 INIT_STATIC_SPEC ("lto_wrapper", &lto_wrapper_spec),
1595 INIT_STATIC_SPEC ("lto_gcc", &lto_gcc_spec),
1596 INIT_STATIC_SPEC ("post_link", &post_link_spec),
1597 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec),
1598 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix),
1599 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix),
1600 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1),
1601 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec),
1602 INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec),
1603 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec),
1604 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec),
1605 INIT_STATIC_SPEC ("self_spec", &self_spec),
1608 #ifdef EXTRA_SPECS /* additional specs needed */
1609 /* Structure to keep track of just the first two args of a spec_list.
1610 That is all that the EXTRA_SPECS macro gives us. */
1611 struct spec_list_1
1613 const char *const name;
1614 const char *const ptr;
1617 static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1618 static struct spec_list *extra_specs = (struct spec_list *) 0;
1619 #endif
1621 /* List of dynamically allocates specs that have been defined so far. */
1623 static struct spec_list *specs = (struct spec_list *) 0;
1625 /* List of static spec functions. */
1627 static const struct spec_function static_spec_functions[] =
1629 { "getenv", getenv_spec_function },
1630 { "if-exists", if_exists_spec_function },
1631 { "if-exists-else", if_exists_else_spec_function },
1632 { "sanitize", sanitize_spec_function },
1633 { "replace-outfile", replace_outfile_spec_function },
1634 { "remove-outfile", remove_outfile_spec_function },
1635 { "version-compare", version_compare_spec_function },
1636 { "include", include_spec_function },
1637 { "find-file", find_file_spec_function },
1638 { "find-plugindir", find_plugindir_spec_function },
1639 { "print-asm-header", print_asm_header_spec_function },
1640 { "compare-debug-dump-opt", compare_debug_dump_opt_spec_function },
1641 { "compare-debug-self-opt", compare_debug_self_opt_spec_function },
1642 { "compare-debug-auxbase-opt", compare_debug_auxbase_opt_spec_function },
1643 { "pass-through-libs", pass_through_libs_spec_func },
1644 { "replace-extension", replace_extension_spec_func },
1645 { "gt", greater_than_spec_func },
1646 { "debug-level-gt", debug_level_greater_than_spec_func },
1647 #ifdef EXTRA_SPEC_FUNCTIONS
1648 EXTRA_SPEC_FUNCTIONS
1649 #endif
1650 { 0, 0 }
1653 static int processing_spec_function;
1655 /* Add appropriate libgcc specs to OBSTACK, taking into account
1656 various permutations of -shared-libgcc, -shared, and such. */
1658 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1660 #ifndef USE_LD_AS_NEEDED
1661 #define USE_LD_AS_NEEDED 0
1662 #endif
1664 static void
1665 init_gcc_specs (struct obstack *obstack, const char *shared_name,
1666 const char *static_name, const char *eh_name)
1668 char *buf;
1670 buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name, "}"
1671 "%{!static:%{!static-libgcc:"
1672 #if USE_LD_AS_NEEDED
1673 "%{!shared-libgcc:",
1674 static_name, " " LD_AS_NEEDED_OPTION " ",
1675 shared_name, " " LD_NO_AS_NEEDED_OPTION
1677 "%{shared-libgcc:",
1678 shared_name, "%{!shared: ", static_name, "}"
1680 #else
1681 "%{!shared:"
1682 "%{!shared-libgcc:", static_name, " ", eh_name, "}"
1683 "%{shared-libgcc:", shared_name, " ", static_name, "}"
1685 #ifdef LINK_EH_SPEC
1686 "%{shared:"
1687 "%{shared-libgcc:", shared_name, "}"
1688 "%{!shared-libgcc:", static_name, "}"
1690 #else
1691 "%{shared:", shared_name, "}"
1692 #endif
1693 #endif
1694 "}}", NULL);
1696 obstack_grow (obstack, buf, strlen (buf));
1697 free (buf);
1699 #endif /* ENABLE_SHARED_LIBGCC */
1701 /* Initialize the specs lookup routines. */
1703 static void
1704 init_spec (void)
1706 struct spec_list *next = (struct spec_list *) 0;
1707 struct spec_list *sl = (struct spec_list *) 0;
1708 int i;
1710 if (specs)
1711 return; /* Already initialized. */
1713 if (verbose_flag)
1714 fnotice (stderr, "Using built-in specs.\n");
1716 #ifdef EXTRA_SPECS
1717 extra_specs = XCNEWVEC (struct spec_list, ARRAY_SIZE (extra_specs_1));
1719 for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--)
1721 sl = &extra_specs[i];
1722 sl->name = extra_specs_1[i].name;
1723 sl->ptr = extra_specs_1[i].ptr;
1724 sl->next = next;
1725 sl->name_len = strlen (sl->name);
1726 sl->ptr_spec = &sl->ptr;
1727 gcc_assert (sl->ptr_spec != NULL);
1728 sl->default_ptr = sl->ptr;
1729 next = sl;
1731 #endif
1733 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1735 sl = &static_specs[i];
1736 sl->next = next;
1737 next = sl;
1740 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1741 /* ??? If neither -shared-libgcc nor --static-libgcc was
1742 seen, then we should be making an educated guess. Some proposed
1743 heuristics for ELF include:
1745 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1746 program will be doing dynamic loading, which will likely
1747 need the shared libgcc.
1749 (2) If "-ldl", then it's also a fair bet that we're doing
1750 dynamic loading.
1752 (3) For each ET_DYN we're linking against (either through -lfoo
1753 or /some/path/foo.so), check to see whether it or one of
1754 its dependencies depends on a shared libgcc.
1756 (4) If "-shared"
1758 If the runtime is fixed to look for program headers instead
1759 of calling __register_frame_info at all, for each object,
1760 use the shared libgcc if any EH symbol referenced.
1762 If crtstuff is fixed to not invoke __register_frame_info
1763 automatically, for each object, use the shared libgcc if
1764 any non-empty unwind section found.
1766 Doing any of this probably requires invoking an external program to
1767 do the actual object file scanning. */
1769 const char *p = libgcc_spec;
1770 int in_sep = 1;
1772 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1773 when given the proper command line arguments. */
1774 while (*p)
1776 if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
1778 init_gcc_specs (&obstack,
1779 "-lgcc_s"
1780 #ifdef USE_LIBUNWIND_EXCEPTIONS
1781 " -lunwind"
1782 #endif
1784 "-lgcc",
1785 "-lgcc_eh"
1786 #ifdef USE_LIBUNWIND_EXCEPTIONS
1787 # ifdef HAVE_LD_STATIC_DYNAMIC
1788 " %{!static:" LD_STATIC_OPTION "} -lunwind"
1789 " %{!static:" LD_DYNAMIC_OPTION "}"
1790 # else
1791 " -lunwind"
1792 # endif
1793 #endif
1796 p += 5;
1797 in_sep = 0;
1799 else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0)
1801 /* Ug. We don't know shared library extensions. Hope that
1802 systems that use this form don't do shared libraries. */
1803 init_gcc_specs (&obstack,
1804 "-lgcc_s",
1805 "libgcc.a%s",
1806 "libgcc_eh.a%s"
1807 #ifdef USE_LIBUNWIND_EXCEPTIONS
1808 " -lunwind"
1809 #endif
1811 p += 10;
1812 in_sep = 0;
1814 else
1816 obstack_1grow (&obstack, *p);
1817 in_sep = (*p == ' ');
1818 p += 1;
1822 obstack_1grow (&obstack, '\0');
1823 libgcc_spec = XOBFINISH (&obstack, const char *);
1825 #endif
1826 #ifdef USE_AS_TRADITIONAL_FORMAT
1827 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1829 static const char tf[] = "--traditional-format ";
1830 obstack_grow (&obstack, tf, sizeof (tf) - 1);
1831 obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
1832 asm_spec = XOBFINISH (&obstack, const char *);
1834 #endif
1836 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC || \
1837 defined LINKER_HASH_STYLE
1838 # ifdef LINK_BUILDID_SPEC
1839 /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. */
1840 obstack_grow (&obstack, LINK_BUILDID_SPEC, sizeof (LINK_BUILDID_SPEC) - 1);
1841 # endif
1842 # ifdef LINK_EH_SPEC
1843 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1844 obstack_grow (&obstack, LINK_EH_SPEC, sizeof (LINK_EH_SPEC) - 1);
1845 # endif
1846 # ifdef LINKER_HASH_STYLE
1847 /* Prepend --hash-style=LINKER_HASH_STYLE to whatever link_spec we had
1848 before. */
1850 static const char hash_style[] = "--hash-style=";
1851 obstack_grow (&obstack, hash_style, sizeof (hash_style) - 1);
1852 obstack_grow (&obstack, LINKER_HASH_STYLE, sizeof (LINKER_HASH_STYLE) - 1);
1853 obstack_1grow (&obstack, ' ');
1855 # endif
1856 obstack_grow0 (&obstack, link_spec, strlen (link_spec));
1857 link_spec = XOBFINISH (&obstack, const char *);
1858 #endif
1860 specs = sl;
1863 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1864 removed; If the spec starts with a + then SPEC is added to the end of the
1865 current spec. */
1867 static void
1868 set_spec (const char *name, const char *spec, bool user_p)
1870 struct spec_list *sl;
1871 const char *old_spec;
1872 int name_len = strlen (name);
1873 int i;
1875 /* If this is the first call, initialize the statically allocated specs. */
1876 if (!specs)
1878 struct spec_list *next = (struct spec_list *) 0;
1879 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1881 sl = &static_specs[i];
1882 sl->next = next;
1883 next = sl;
1885 specs = sl;
1888 /* See if the spec already exists. */
1889 for (sl = specs; sl; sl = sl->next)
1890 if (name_len == sl->name_len && !strcmp (sl->name, name))
1891 break;
1893 if (!sl)
1895 /* Not found - make it. */
1896 sl = XNEW (struct spec_list);
1897 sl->name = xstrdup (name);
1898 sl->name_len = name_len;
1899 sl->ptr_spec = &sl->ptr;
1900 sl->alloc_p = 0;
1901 *(sl->ptr_spec) = "";
1902 sl->next = specs;
1903 sl->default_ptr = NULL;
1904 specs = sl;
1907 old_spec = *(sl->ptr_spec);
1908 *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
1909 ? concat (old_spec, spec + 1, NULL)
1910 : xstrdup (spec));
1912 #ifdef DEBUG_SPECS
1913 if (verbose_flag)
1914 fnotice (stderr, "Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
1915 #endif
1917 /* Free the old spec. */
1918 if (old_spec && sl->alloc_p)
1919 free (CONST_CAST (char *, old_spec));
1921 sl->user_p = user_p;
1922 sl->alloc_p = true;
1925 /* Accumulate a command (program name and args), and run it. */
1927 typedef const char *const_char_p; /* For DEF_VEC_P. */
1929 /* Vector of pointers to arguments in the current line of specifications. */
1931 static vec<const_char_p> argbuf;
1933 /* Were the options -c, -S or -E passed. */
1934 static int have_c = 0;
1936 /* Was the option -o passed. */
1937 static int have_o = 0;
1939 /* Was the option -E passed. */
1940 static int have_E = 0;
1942 /* Pointer to output file name passed in with -o. */
1943 static const char *output_file = 0;
1945 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1946 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
1947 it here. */
1949 static struct temp_name {
1950 const char *suffix; /* suffix associated with the code. */
1951 int length; /* strlen (suffix). */
1952 int unique; /* Indicates whether %g or %u/%U was used. */
1953 const char *filename; /* associated filename. */
1954 int filename_length; /* strlen (filename). */
1955 struct temp_name *next;
1956 } *temp_names;
1958 /* Number of commands executed so far. */
1960 static int execution_count;
1962 /* Number of commands that exited with a signal. */
1964 static int signal_count;
1966 /* Allocate the argument vector. */
1968 static void
1969 alloc_args (void)
1971 argbuf.create (10);
1974 /* Clear out the vector of arguments (after a command is executed). */
1976 static void
1977 clear_args (void)
1979 argbuf.truncate (0);
1982 /* Add one argument to the vector at the end.
1983 This is done when a space is seen or at the end of the line.
1984 If DELETE_ALWAYS is nonzero, the arg is a filename
1985 and the file should be deleted eventually.
1986 If DELETE_FAILURE is nonzero, the arg is a filename
1987 and the file should be deleted if this compilation fails. */
1989 static void
1990 store_arg (const char *arg, int delete_always, int delete_failure)
1992 argbuf.safe_push (arg);
1994 if (delete_always || delete_failure)
1996 const char *p;
1997 /* If the temporary file we should delete is specified as
1998 part of a joined argument extract the filename. */
1999 if (arg[0] == '-'
2000 && (p = strrchr (arg, '=')))
2001 arg = p + 1;
2002 record_temp_file (arg, delete_always, delete_failure);
2006 /* Load specs from a file name named FILENAME, replacing occurrences of
2007 various different types of line-endings, \r\n, \n\r and just \r, with
2008 a single \n. */
2010 static char *
2011 load_specs (const char *filename)
2013 int desc;
2014 int readlen;
2015 struct stat statbuf;
2016 char *buffer;
2017 char *buffer_p;
2018 char *specs;
2019 char *specs_p;
2021 if (verbose_flag)
2022 fnotice (stderr, "Reading specs from %s\n", filename);
2024 /* Open and stat the file. */
2025 desc = open (filename, O_RDONLY, 0);
2026 if (desc < 0)
2027 pfatal_with_name (filename);
2028 if (stat (filename, &statbuf) < 0)
2029 pfatal_with_name (filename);
2031 /* Read contents of file into BUFFER. */
2032 buffer = XNEWVEC (char, statbuf.st_size + 1);
2033 readlen = read (desc, buffer, (unsigned) statbuf.st_size);
2034 if (readlen < 0)
2035 pfatal_with_name (filename);
2036 buffer[readlen] = 0;
2037 close (desc);
2039 specs = XNEWVEC (char, readlen + 1);
2040 specs_p = specs;
2041 for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
2043 int skip = 0;
2044 char c = *buffer_p;
2045 if (c == '\r')
2047 if (buffer_p > buffer && *(buffer_p - 1) == '\n') /* \n\r */
2048 skip = 1;
2049 else if (*(buffer_p + 1) == '\n') /* \r\n */
2050 skip = 1;
2051 else /* \r */
2052 c = '\n';
2054 if (! skip)
2055 *specs_p++ = c;
2057 *specs_p = '\0';
2059 free (buffer);
2060 return (specs);
2063 /* Read compilation specs from a file named FILENAME,
2064 replacing the default ones.
2066 A suffix which starts with `*' is a definition for
2067 one of the machine-specific sub-specs. The "suffix" should be
2068 *asm, *cc1, *cpp, *link, *startfile, etc.
2069 The corresponding spec is stored in asm_spec, etc.,
2070 rather than in the `compilers' vector.
2072 Anything invalid in the file is a fatal error. */
2074 static void
2075 read_specs (const char *filename, bool main_p, bool user_p)
2077 char *buffer;
2078 char *p;
2080 buffer = load_specs (filename);
2082 /* Scan BUFFER for specs, putting them in the vector. */
2083 p = buffer;
2084 while (1)
2086 char *suffix;
2087 char *spec;
2088 char *in, *out, *p1, *p2, *p3;
2090 /* Advance P in BUFFER to the next nonblank nocomment line. */
2091 p = skip_whitespace (p);
2092 if (*p == 0)
2093 break;
2095 /* Is this a special command that starts with '%'? */
2096 /* Don't allow this for the main specs file, since it would
2097 encourage people to overwrite it. */
2098 if (*p == '%' && !main_p)
2100 p1 = p;
2101 while (*p && *p != '\n')
2102 p++;
2104 /* Skip '\n'. */
2105 p++;
2107 if (!strncmp (p1, "%include", sizeof ("%include") - 1)
2108 && (p1[sizeof "%include" - 1] == ' '
2109 || p1[sizeof "%include" - 1] == '\t'))
2111 char *new_filename;
2113 p1 += sizeof ("%include");
2114 while (*p1 == ' ' || *p1 == '\t')
2115 p1++;
2117 if (*p1++ != '<' || p[-2] != '>')
2118 fatal_error (input_location,
2119 "specs %%include syntax malformed after "
2120 "%ld characters",
2121 (long) (p1 - buffer + 1));
2123 p[-2] = '\0';
2124 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
2125 read_specs (new_filename ? new_filename : p1, false, user_p);
2126 continue;
2128 else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
2129 && (p1[sizeof "%include_noerr" - 1] == ' '
2130 || p1[sizeof "%include_noerr" - 1] == '\t'))
2132 char *new_filename;
2134 p1 += sizeof "%include_noerr";
2135 while (*p1 == ' ' || *p1 == '\t')
2136 p1++;
2138 if (*p1++ != '<' || p[-2] != '>')
2139 fatal_error (input_location,
2140 "specs %%include syntax malformed after "
2141 "%ld characters",
2142 (long) (p1 - buffer + 1));
2144 p[-2] = '\0';
2145 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
2146 if (new_filename)
2147 read_specs (new_filename, false, user_p);
2148 else if (verbose_flag)
2149 fnotice (stderr, "could not find specs file %s\n", p1);
2150 continue;
2152 else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
2153 && (p1[sizeof "%rename" - 1] == ' '
2154 || p1[sizeof "%rename" - 1] == '\t'))
2156 int name_len;
2157 struct spec_list *sl;
2158 struct spec_list *newsl;
2160 /* Get original name. */
2161 p1 += sizeof "%rename";
2162 while (*p1 == ' ' || *p1 == '\t')
2163 p1++;
2165 if (! ISALPHA ((unsigned char) *p1))
2166 fatal_error (input_location,
2167 "specs %%rename syntax malformed after "
2168 "%ld characters",
2169 (long) (p1 - buffer));
2171 p2 = p1;
2172 while (*p2 && !ISSPACE ((unsigned char) *p2))
2173 p2++;
2175 if (*p2 != ' ' && *p2 != '\t')
2176 fatal_error (input_location,
2177 "specs %%rename syntax malformed after "
2178 "%ld characters",
2179 (long) (p2 - buffer));
2181 name_len = p2 - p1;
2182 *p2++ = '\0';
2183 while (*p2 == ' ' || *p2 == '\t')
2184 p2++;
2186 if (! ISALPHA ((unsigned char) *p2))
2187 fatal_error (input_location,
2188 "specs %%rename syntax malformed after "
2189 "%ld characters",
2190 (long) (p2 - buffer));
2192 /* Get new spec name. */
2193 p3 = p2;
2194 while (*p3 && !ISSPACE ((unsigned char) *p3))
2195 p3++;
2197 if (p3 != p - 1)
2198 fatal_error (input_location,
2199 "specs %%rename syntax malformed after "
2200 "%ld characters",
2201 (long) (p3 - buffer));
2202 *p3 = '\0';
2204 for (sl = specs; sl; sl = sl->next)
2205 if (name_len == sl->name_len && !strcmp (sl->name, p1))
2206 break;
2208 if (!sl)
2209 fatal_error (input_location,
2210 "specs %s spec was not found to be renamed", p1);
2212 if (strcmp (p1, p2) == 0)
2213 continue;
2215 for (newsl = specs; newsl; newsl = newsl->next)
2216 if (strcmp (newsl->name, p2) == 0)
2217 fatal_error (input_location,
2218 "%s: attempt to rename spec %qs to "
2219 "already defined spec %qs",
2220 filename, p1, p2);
2222 if (verbose_flag)
2224 fnotice (stderr, "rename spec %s to %s\n", p1, p2);
2225 #ifdef DEBUG_SPECS
2226 fnotice (stderr, "spec is '%s'\n\n", *(sl->ptr_spec));
2227 #endif
2230 set_spec (p2, *(sl->ptr_spec), user_p);
2231 if (sl->alloc_p)
2232 free (CONST_CAST (char *, *(sl->ptr_spec)));
2234 *(sl->ptr_spec) = "";
2235 sl->alloc_p = 0;
2236 continue;
2238 else
2239 fatal_error (input_location,
2240 "specs unknown %% command after %ld characters",
2241 (long) (p1 - buffer));
2244 /* Find the colon that should end the suffix. */
2245 p1 = p;
2246 while (*p1 && *p1 != ':' && *p1 != '\n')
2247 p1++;
2249 /* The colon shouldn't be missing. */
2250 if (*p1 != ':')
2251 fatal_error (input_location,
2252 "specs file malformed after %ld characters",
2253 (long) (p1 - buffer));
2255 /* Skip back over trailing whitespace. */
2256 p2 = p1;
2257 while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
2258 p2--;
2260 /* Copy the suffix to a string. */
2261 suffix = save_string (p, p2 - p);
2262 /* Find the next line. */
2263 p = skip_whitespace (p1 + 1);
2264 if (p[1] == 0)
2265 fatal_error (input_location,
2266 "specs file malformed after %ld characters",
2267 (long) (p - buffer));
2269 p1 = p;
2270 /* Find next blank line or end of string. */
2271 while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
2272 p1++;
2274 /* Specs end at the blank line and do not include the newline. */
2275 spec = save_string (p, p1 - p);
2276 p = p1;
2278 /* Delete backslash-newline sequences from the spec. */
2279 in = spec;
2280 out = spec;
2281 while (*in != 0)
2283 if (in[0] == '\\' && in[1] == '\n')
2284 in += 2;
2285 else if (in[0] == '#')
2286 while (*in && *in != '\n')
2287 in++;
2289 else
2290 *out++ = *in++;
2292 *out = 0;
2294 if (suffix[0] == '*')
2296 if (! strcmp (suffix, "*link_command"))
2297 link_command_spec = spec;
2298 else
2300 set_spec (suffix + 1, spec, user_p);
2301 free (spec);
2304 else
2306 /* Add this pair to the vector. */
2307 compilers
2308 = XRESIZEVEC (struct compiler, compilers, n_compilers + 2);
2310 compilers[n_compilers].suffix = suffix;
2311 compilers[n_compilers].spec = spec;
2312 n_compilers++;
2313 memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
2316 if (*suffix == 0)
2317 link_command_spec = spec;
2320 if (link_command_spec == 0)
2321 fatal_error (input_location, "spec file has no spec for linking");
2323 XDELETEVEC (buffer);
2326 /* Record the names of temporary files we tell compilers to write,
2327 and delete them at the end of the run. */
2329 /* This is the common prefix we use to make temp file names.
2330 It is chosen once for each run of this program.
2331 It is substituted into a spec by %g or %j.
2332 Thus, all temp file names contain this prefix.
2333 In practice, all temp file names start with this prefix.
2335 This prefix comes from the envvar TMPDIR if it is defined;
2336 otherwise, from the P_tmpdir macro if that is defined;
2337 otherwise, in /usr/tmp or /tmp;
2338 or finally the current directory if all else fails. */
2340 static const char *temp_filename;
2342 /* Length of the prefix. */
2344 static int temp_filename_length;
2346 /* Define the list of temporary files to delete. */
2348 struct temp_file
2350 const char *name;
2351 struct temp_file *next;
2354 /* Queue of files to delete on success or failure of compilation. */
2355 static struct temp_file *always_delete_queue;
2356 /* Queue of files to delete on failure of compilation. */
2357 static struct temp_file *failure_delete_queue;
2359 /* Record FILENAME as a file to be deleted automatically.
2360 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2361 otherwise delete it in any case.
2362 FAIL_DELETE nonzero means delete it if a compilation step fails;
2363 otherwise delete it in any case. */
2365 void
2366 record_temp_file (const char *filename, int always_delete, int fail_delete)
2368 char *const name = xstrdup (filename);
2370 if (always_delete)
2372 struct temp_file *temp;
2373 for (temp = always_delete_queue; temp; temp = temp->next)
2374 if (! filename_cmp (name, temp->name))
2376 free (name);
2377 goto already1;
2380 temp = XNEW (struct temp_file);
2381 temp->next = always_delete_queue;
2382 temp->name = name;
2383 always_delete_queue = temp;
2385 already1:;
2388 if (fail_delete)
2390 struct temp_file *temp;
2391 for (temp = failure_delete_queue; temp; temp = temp->next)
2392 if (! filename_cmp (name, temp->name))
2394 free (name);
2395 goto already2;
2398 temp = XNEW (struct temp_file);
2399 temp->next = failure_delete_queue;
2400 temp->name = name;
2401 failure_delete_queue = temp;
2403 already2:;
2407 /* Delete all the temporary files whose names we previously recorded. */
2409 #ifndef DELETE_IF_ORDINARY
2410 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2411 do \
2413 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2414 if (unlink (NAME) < 0) \
2415 if (VERBOSE_FLAG) \
2416 perror_with_name (NAME); \
2417 } while (0)
2418 #endif
2420 static void
2421 delete_if_ordinary (const char *name)
2423 struct stat st;
2424 #ifdef DEBUG
2425 int i, c;
2427 printf ("Delete %s? (y or n) ", name);
2428 fflush (stdout);
2429 i = getchar ();
2430 if (i != '\n')
2431 while ((c = getchar ()) != '\n' && c != EOF)
2434 if (i == 'y' || i == 'Y')
2435 #endif /* DEBUG */
2436 DELETE_IF_ORDINARY (name, st, verbose_flag);
2439 static void
2440 delete_temp_files (void)
2442 struct temp_file *temp;
2444 for (temp = always_delete_queue; temp; temp = temp->next)
2445 delete_if_ordinary (temp->name);
2446 always_delete_queue = 0;
2449 /* Delete all the files to be deleted on error. */
2451 static void
2452 delete_failure_queue (void)
2454 struct temp_file *temp;
2456 for (temp = failure_delete_queue; temp; temp = temp->next)
2457 delete_if_ordinary (temp->name);
2460 static void
2461 clear_failure_queue (void)
2463 failure_delete_queue = 0;
2466 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2467 returns non-NULL.
2468 If DO_MULTI is true iterate over the paths twice, first with multilib
2469 suffix then without, otherwise iterate over the paths once without
2470 adding a multilib suffix. When DO_MULTI is true, some attempt is made
2471 to avoid visiting the same path twice, but we could do better. For
2472 instance, /usr/lib/../lib is considered different from /usr/lib.
2473 At least EXTRA_SPACE chars past the end of the path passed to
2474 CALLBACK are available for use by the callback.
2475 CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2477 Returns the value returned by CALLBACK. */
2479 static void *
2480 for_each_path (const struct path_prefix *paths,
2481 bool do_multi,
2482 size_t extra_space,
2483 void *(*callback) (char *, void *),
2484 void *callback_info)
2486 struct prefix_list *pl;
2487 const char *multi_dir = NULL;
2488 const char *multi_os_dir = NULL;
2489 const char *multiarch_suffix = NULL;
2490 const char *multi_suffix;
2491 const char *just_multi_suffix;
2492 char *path = NULL;
2493 void *ret = NULL;
2494 bool skip_multi_dir = false;
2495 bool skip_multi_os_dir = false;
2497 multi_suffix = machine_suffix;
2498 just_multi_suffix = just_machine_suffix;
2499 if (do_multi && multilib_dir && strcmp (multilib_dir, ".") != 0)
2501 multi_dir = concat (multilib_dir, dir_separator_str, NULL);
2502 multi_suffix = concat (multi_suffix, multi_dir, NULL);
2503 just_multi_suffix = concat (just_multi_suffix, multi_dir, NULL);
2505 if (do_multi && multilib_os_dir && strcmp (multilib_os_dir, ".") != 0)
2506 multi_os_dir = concat (multilib_os_dir, dir_separator_str, NULL);
2507 if (multiarch_dir)
2508 multiarch_suffix = concat (multiarch_dir, dir_separator_str, NULL);
2510 while (1)
2512 size_t multi_dir_len = 0;
2513 size_t multi_os_dir_len = 0;
2514 size_t multiarch_len = 0;
2515 size_t suffix_len;
2516 size_t just_suffix_len;
2517 size_t len;
2519 if (multi_dir)
2520 multi_dir_len = strlen (multi_dir);
2521 if (multi_os_dir)
2522 multi_os_dir_len = strlen (multi_os_dir);
2523 if (multiarch_suffix)
2524 multiarch_len = strlen (multiarch_suffix);
2525 suffix_len = strlen (multi_suffix);
2526 just_suffix_len = strlen (just_multi_suffix);
2528 if (path == NULL)
2530 len = paths->max_len + extra_space + 1;
2531 len += MAX (MAX (suffix_len, multi_os_dir_len), multiarch_len);
2532 path = XNEWVEC (char, len);
2535 for (pl = paths->plist; pl != 0; pl = pl->next)
2537 len = strlen (pl->prefix);
2538 memcpy (path, pl->prefix, len);
2540 /* Look first in MACHINE/VERSION subdirectory. */
2541 if (!skip_multi_dir)
2543 memcpy (path + len, multi_suffix, suffix_len + 1);
2544 ret = callback (path, callback_info);
2545 if (ret)
2546 break;
2549 /* Some paths are tried with just the machine (ie. target)
2550 subdir. This is used for finding as, ld, etc. */
2551 if (!skip_multi_dir
2552 && pl->require_machine_suffix == 2)
2554 memcpy (path + len, just_multi_suffix, just_suffix_len + 1);
2555 ret = callback (path, callback_info);
2556 if (ret)
2557 break;
2560 /* Now try the multiarch path. */
2561 if (!skip_multi_dir
2562 && !pl->require_machine_suffix && multiarch_dir)
2564 memcpy (path + len, multiarch_suffix, multiarch_len + 1);
2565 ret = callback (path, callback_info);
2566 if (ret)
2567 break;
2570 /* Now try the base path. */
2571 if (!pl->require_machine_suffix
2572 && !(pl->os_multilib ? skip_multi_os_dir : skip_multi_dir))
2574 const char *this_multi;
2575 size_t this_multi_len;
2577 if (pl->os_multilib)
2579 this_multi = multi_os_dir;
2580 this_multi_len = multi_os_dir_len;
2582 else
2584 this_multi = multi_dir;
2585 this_multi_len = multi_dir_len;
2588 if (this_multi_len)
2589 memcpy (path + len, this_multi, this_multi_len + 1);
2590 else
2591 path[len] = '\0';
2593 ret = callback (path, callback_info);
2594 if (ret)
2595 break;
2598 if (pl)
2599 break;
2601 if (multi_dir == NULL && multi_os_dir == NULL)
2602 break;
2604 /* Run through the paths again, this time without multilibs.
2605 Don't repeat any we have already seen. */
2606 if (multi_dir)
2608 free (CONST_CAST (char *, multi_dir));
2609 multi_dir = NULL;
2610 free (CONST_CAST (char *, multi_suffix));
2611 multi_suffix = machine_suffix;
2612 free (CONST_CAST (char *, just_multi_suffix));
2613 just_multi_suffix = just_machine_suffix;
2615 else
2616 skip_multi_dir = true;
2617 if (multi_os_dir)
2619 free (CONST_CAST (char *, multi_os_dir));
2620 multi_os_dir = NULL;
2622 else
2623 skip_multi_os_dir = true;
2626 if (multi_dir)
2628 free (CONST_CAST (char *, multi_dir));
2629 free (CONST_CAST (char *, multi_suffix));
2630 free (CONST_CAST (char *, just_multi_suffix));
2632 if (multi_os_dir)
2633 free (CONST_CAST (char *, multi_os_dir));
2634 if (ret != path)
2635 free (path);
2636 return ret;
2639 /* Callback for build_search_list. Adds path to obstack being built. */
2641 struct add_to_obstack_info {
2642 struct obstack *ob;
2643 bool check_dir;
2644 bool first_time;
2647 static void *
2648 add_to_obstack (char *path, void *data)
2650 struct add_to_obstack_info *info = (struct add_to_obstack_info *) data;
2652 if (info->check_dir && !is_directory (path, false))
2653 return NULL;
2655 if (!info->first_time)
2656 obstack_1grow (info->ob, PATH_SEPARATOR);
2658 obstack_grow (info->ob, path, strlen (path));
2660 info->first_time = false;
2661 return NULL;
2664 /* Add or change the value of an environment variable, outputting the
2665 change to standard error if in verbose mode. */
2666 static void
2667 xputenv (const char *string)
2669 env.xput (string);
2672 /* Build a list of search directories from PATHS.
2673 PREFIX is a string to prepend to the list.
2674 If CHECK_DIR_P is true we ensure the directory exists.
2675 If DO_MULTI is true, multilib paths are output first, then
2676 non-multilib paths.
2677 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2678 It is also used by the --print-search-dirs flag. */
2680 static char *
2681 build_search_list (const struct path_prefix *paths, const char *prefix,
2682 bool check_dir, bool do_multi)
2684 struct add_to_obstack_info info;
2686 info.ob = &collect_obstack;
2687 info.check_dir = check_dir;
2688 info.first_time = true;
2690 obstack_grow (&collect_obstack, prefix, strlen (prefix));
2691 obstack_1grow (&collect_obstack, '=');
2693 for_each_path (paths, do_multi, 0, add_to_obstack, &info);
2695 obstack_1grow (&collect_obstack, '\0');
2696 return XOBFINISH (&collect_obstack, char *);
2699 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2700 for collect. */
2702 static void
2703 putenv_from_prefixes (const struct path_prefix *paths, const char *env_var,
2704 bool do_multi)
2706 xputenv (build_search_list (paths, env_var, true, do_multi));
2709 /* Check whether NAME can be accessed in MODE. This is like access,
2710 except that it never considers directories to be executable. */
2712 static int
2713 access_check (const char *name, int mode)
2715 if (mode == X_OK)
2717 struct stat st;
2719 if (stat (name, &st) < 0
2720 || S_ISDIR (st.st_mode))
2721 return -1;
2724 return access (name, mode);
2727 /* Callback for find_a_file. Appends the file name to the directory
2728 path. If the resulting file exists in the right mode, return the
2729 full pathname to the file. */
2731 struct file_at_path_info {
2732 const char *name;
2733 const char *suffix;
2734 int name_len;
2735 int suffix_len;
2736 int mode;
2739 static void *
2740 file_at_path (char *path, void *data)
2742 struct file_at_path_info *info = (struct file_at_path_info *) data;
2743 size_t len = strlen (path);
2745 memcpy (path + len, info->name, info->name_len);
2746 len += info->name_len;
2748 /* Some systems have a suffix for executable files.
2749 So try appending that first. */
2750 if (info->suffix_len)
2752 memcpy (path + len, info->suffix, info->suffix_len + 1);
2753 if (access_check (path, info->mode) == 0)
2754 return path;
2757 path[len] = '\0';
2758 if (access_check (path, info->mode) == 0)
2759 return path;
2761 return NULL;
2764 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2765 access to check permissions. If DO_MULTI is true, search multilib
2766 paths then non-multilib paths, otherwise do not search multilib paths.
2767 Return 0 if not found, otherwise return its name, allocated with malloc. */
2769 static char *
2770 find_a_file (const struct path_prefix *pprefix, const char *name, int mode,
2771 bool do_multi)
2773 struct file_at_path_info info;
2775 #ifdef DEFAULT_ASSEMBLER
2776 if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
2777 return xstrdup (DEFAULT_ASSEMBLER);
2778 #endif
2780 #ifdef DEFAULT_LINKER
2781 if (! strcmp (name, "ld") && access (DEFAULT_LINKER, mode) == 0)
2782 return xstrdup (DEFAULT_LINKER);
2783 #endif
2785 /* Determine the filename to execute (special case for absolute paths). */
2787 if (IS_ABSOLUTE_PATH (name))
2789 if (access (name, mode) == 0)
2790 return xstrdup (name);
2792 return NULL;
2795 info.name = name;
2796 info.suffix = (mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "";
2797 info.name_len = strlen (info.name);
2798 info.suffix_len = strlen (info.suffix);
2799 info.mode = mode;
2801 return (char*) for_each_path (pprefix, do_multi,
2802 info.name_len + info.suffix_len,
2803 file_at_path, &info);
2806 /* Ranking of prefixes in the sort list. -B prefixes are put before
2807 all others. */
2809 enum path_prefix_priority
2811 PREFIX_PRIORITY_B_OPT,
2812 PREFIX_PRIORITY_LAST
2815 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
2816 order according to PRIORITY. Within each PRIORITY, new entries are
2817 appended.
2819 If WARN is nonzero, we will warn if no file is found
2820 through this prefix. WARN should point to an int
2821 which will be set to 1 if this entry is used.
2823 COMPONENT is the value to be passed to update_path.
2825 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2826 the complete value of machine_suffix.
2827 2 means try both machine_suffix and just_machine_suffix. */
2829 static void
2830 add_prefix (struct path_prefix *pprefix, const char *prefix,
2831 const char *component, /* enum prefix_priority */ int priority,
2832 int require_machine_suffix, int os_multilib)
2834 struct prefix_list *pl, **prev;
2835 int len;
2837 for (prev = &pprefix->plist;
2838 (*prev) != NULL && (*prev)->priority <= priority;
2839 prev = &(*prev)->next)
2842 /* Keep track of the longest prefix. */
2844 prefix = update_path (prefix, component);
2845 len = strlen (prefix);
2846 if (len > pprefix->max_len)
2847 pprefix->max_len = len;
2849 pl = XNEW (struct prefix_list);
2850 pl->prefix = prefix;
2851 pl->require_machine_suffix = require_machine_suffix;
2852 pl->priority = priority;
2853 pl->os_multilib = os_multilib;
2855 /* Insert after PREV. */
2856 pl->next = (*prev);
2857 (*prev) = pl;
2860 /* Same as add_prefix, but prepending target_system_root to prefix. */
2861 /* The target_system_root prefix has been relocated by gcc_exec_prefix. */
2862 static void
2863 add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
2864 const char *component,
2865 /* enum prefix_priority */ int priority,
2866 int require_machine_suffix, int os_multilib)
2868 if (!IS_ABSOLUTE_PATH (prefix))
2869 fatal_error (input_location, "system path %qs is not absolute", prefix);
2871 if (target_system_root)
2873 char *sysroot_no_trailing_dir_separator = xstrdup (target_system_root);
2874 size_t sysroot_len = strlen (target_system_root);
2876 if (sysroot_len > 0
2877 && target_system_root[sysroot_len - 1] == DIR_SEPARATOR)
2878 sysroot_no_trailing_dir_separator[sysroot_len - 1] = '\0';
2880 if (target_sysroot_suffix)
2881 prefix = concat (sysroot_no_trailing_dir_separator,
2882 target_sysroot_suffix, prefix, NULL);
2883 else
2884 prefix = concat (sysroot_no_trailing_dir_separator, prefix, NULL);
2886 free (sysroot_no_trailing_dir_separator);
2888 /* We have to override this because GCC's notion of sysroot
2889 moves along with GCC. */
2890 component = "GCC";
2893 add_prefix (pprefix, prefix, component, priority,
2894 require_machine_suffix, os_multilib);
2897 /* Execute the command specified by the arguments on the current line of spec.
2898 When using pipes, this includes several piped-together commands
2899 with `|' between them.
2901 Return 0 if successful, -1 if failed. */
2903 static int
2904 execute (void)
2906 int i;
2907 int n_commands; /* # of command. */
2908 char *string;
2909 struct pex_obj *pex;
2910 struct command
2912 const char *prog; /* program name. */
2913 const char **argv; /* vector of args. */
2915 const char *arg;
2917 struct command *commands; /* each command buffer with above info. */
2919 gcc_assert (!processing_spec_function);
2921 if (wrapper_string)
2923 string = find_a_file (&exec_prefixes,
2924 argbuf[0], X_OK, false);
2925 if (string)
2926 argbuf[0] = string;
2927 insert_wrapper (wrapper_string);
2930 /* Count # of piped commands. */
2931 for (n_commands = 1, i = 0; argbuf.iterate (i, &arg); i++)
2932 if (strcmp (arg, "|") == 0)
2933 n_commands++;
2935 /* Get storage for each command. */
2936 commands = (struct command *) alloca (n_commands * sizeof (struct command));
2938 /* Split argbuf into its separate piped processes,
2939 and record info about each one.
2940 Also search for the programs that are to be run. */
2942 argbuf.safe_push (0);
2944 commands[0].prog = argbuf[0]; /* first command. */
2945 commands[0].argv = argbuf.address ();
2947 if (!wrapper_string)
2949 string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, false);
2950 commands[0].argv[0] = (string) ? string : commands[0].argv[0];
2953 for (n_commands = 1, i = 0; argbuf.iterate (i, &arg); i++)
2954 if (arg && strcmp (arg, "|") == 0)
2955 { /* each command. */
2956 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2957 fatal_error (input_location, "-pipe not supported");
2958 #endif
2959 argbuf[i] = 0; /* Termination of
2960 command args. */
2961 commands[n_commands].prog = argbuf[i + 1];
2962 commands[n_commands].argv
2963 = &(argbuf.address ())[i + 1];
2964 string = find_a_file (&exec_prefixes, commands[n_commands].prog,
2965 X_OK, false);
2966 if (string)
2967 commands[n_commands].argv[0] = string;
2968 n_commands++;
2971 /* If -v, print what we are about to do, and maybe query. */
2973 if (verbose_flag)
2975 /* For help listings, put a blank line between sub-processes. */
2976 if (print_help_list)
2977 fputc ('\n', stderr);
2979 /* Print each piped command as a separate line. */
2980 for (i = 0; i < n_commands; i++)
2982 const char *const *j;
2984 if (verbose_only_flag)
2986 for (j = commands[i].argv; *j; j++)
2988 const char *p;
2989 for (p = *j; *p; ++p)
2990 if (!ISALNUM ((unsigned char) *p)
2991 && *p != '_' && *p != '/' && *p != '-' && *p != '.')
2992 break;
2993 if (*p || !*j)
2995 fprintf (stderr, " \"");
2996 for (p = *j; *p; ++p)
2998 if (*p == '"' || *p == '\\' || *p == '$')
2999 fputc ('\\', stderr);
3000 fputc (*p, stderr);
3002 fputc ('"', stderr);
3004 /* If it's empty, print "". */
3005 else if (!**j)
3006 fprintf (stderr, " \"\"");
3007 else
3008 fprintf (stderr, " %s", *j);
3011 else
3012 for (j = commands[i].argv; *j; j++)
3013 /* If it's empty, print "". */
3014 if (!**j)
3015 fprintf (stderr, " \"\"");
3016 else
3017 fprintf (stderr, " %s", *j);
3019 /* Print a pipe symbol after all but the last command. */
3020 if (i + 1 != n_commands)
3021 fprintf (stderr, " |");
3022 fprintf (stderr, "\n");
3024 fflush (stderr);
3025 if (verbose_only_flag != 0)
3027 /* verbose_only_flag should act as if the spec was
3028 executed, so increment execution_count before
3029 returning. This prevents spurious warnings about
3030 unused linker input files, etc. */
3031 execution_count++;
3032 return 0;
3034 #ifdef DEBUG
3035 fnotice (stderr, "\nGo ahead? (y or n) ");
3036 fflush (stderr);
3037 i = getchar ();
3038 if (i != '\n')
3039 while (getchar () != '\n')
3042 if (i != 'y' && i != 'Y')
3043 return 0;
3044 #endif /* DEBUG */
3047 #ifdef ENABLE_VALGRIND_CHECKING
3048 /* Run the each command through valgrind. To simplify prepending the
3049 path to valgrind and the option "-q" (for quiet operation unless
3050 something triggers), we allocate a separate argv array. */
3052 for (i = 0; i < n_commands; i++)
3054 const char **argv;
3055 int argc;
3056 int j;
3058 for (argc = 0; commands[i].argv[argc] != NULL; argc++)
3061 argv = XALLOCAVEC (const char *, argc + 3);
3063 argv[0] = VALGRIND_PATH;
3064 argv[1] = "-q";
3065 for (j = 2; j < argc + 2; j++)
3066 argv[j] = commands[i].argv[j - 2];
3067 argv[j] = NULL;
3069 commands[i].argv = argv;
3070 commands[i].prog = argv[0];
3072 #endif
3074 /* Run each piped subprocess. */
3076 pex = pex_init (PEX_USE_PIPES | ((report_times || report_times_to_file)
3077 ? PEX_RECORD_TIMES : 0),
3078 progname, temp_filename);
3079 if (pex == NULL)
3080 fatal_error (input_location, "pex_init failed: %m");
3082 for (i = 0; i < n_commands; i++)
3084 const char *errmsg;
3085 int err;
3086 const char *string = commands[i].argv[0];
3088 errmsg = pex_run (pex,
3089 ((i + 1 == n_commands ? PEX_LAST : 0)
3090 | (string == commands[i].prog ? PEX_SEARCH : 0)),
3091 string, CONST_CAST (char **, commands[i].argv),
3092 NULL, NULL, &err);
3093 if (errmsg != NULL)
3095 if (err == 0)
3096 fatal_error (input_location, errmsg);
3097 else
3099 errno = err;
3100 pfatal_with_name (errmsg);
3104 if (i && string != commands[i].prog)
3105 free (CONST_CAST (char *, string));
3108 execution_count++;
3110 /* Wait for all the subprocesses to finish. */
3113 int *statuses;
3114 struct pex_time *times = NULL;
3115 int ret_code = 0;
3117 statuses = (int *) alloca (n_commands * sizeof (int));
3118 if (!pex_get_status (pex, n_commands, statuses))
3119 fatal_error (input_location, "failed to get exit status: %m");
3121 if (report_times || report_times_to_file)
3123 times = (struct pex_time *) alloca (n_commands * sizeof (struct pex_time));
3124 if (!pex_get_times (pex, n_commands, times))
3125 fatal_error (input_location, "failed to get process times: %m");
3128 pex_free (pex);
3130 for (i = 0; i < n_commands; ++i)
3132 int status = statuses[i];
3134 if (WIFSIGNALED (status))
3136 #ifdef SIGPIPE
3137 /* SIGPIPE is a special case. It happens in -pipe mode
3138 when the compiler dies before the preprocessor is done,
3139 or the assembler dies before the compiler is done.
3140 There's generally been an error already, and this is
3141 just fallout. So don't generate another error unless
3142 we would otherwise have succeeded. */
3143 if (WTERMSIG (status) == SIGPIPE
3144 && (signal_count || greatest_status >= MIN_FATAL_STATUS))
3146 signal_count++;
3147 ret_code = -1;
3149 else
3150 #endif
3151 internal_error_no_backtrace ("%s (program %s)",
3152 strsignal (WTERMSIG (status)),
3153 commands[i].prog);
3155 else if (WIFEXITED (status)
3156 && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
3158 /* For ICEs in cc1, cc1obj, cc1plus see if it is
3159 reproducible or not. */
3160 const char *p;
3161 if (flag_report_bug
3162 && WEXITSTATUS (status) == ICE_EXIT_CODE
3163 && i == 0
3164 && (p = strrchr (commands[0].argv[0], DIR_SEPARATOR))
3165 && ! strncmp (p + 1, "cc1", 3))
3166 try_generate_repro (commands[0].argv);
3167 if (WEXITSTATUS (status) > greatest_status)
3168 greatest_status = WEXITSTATUS (status);
3169 ret_code = -1;
3172 if (report_times || report_times_to_file)
3174 struct pex_time *pt = &times[i];
3175 double ut, st;
3177 ut = ((double) pt->user_seconds
3178 + (double) pt->user_microseconds / 1.0e6);
3179 st = ((double) pt->system_seconds
3180 + (double) pt->system_microseconds / 1.0e6);
3182 if (ut + st != 0)
3184 if (report_times)
3185 fnotice (stderr, "# %s %.2f %.2f\n",
3186 commands[i].prog, ut, st);
3188 if (report_times_to_file)
3190 int c = 0;
3191 const char *const *j;
3193 fprintf (report_times_to_file, "%g %g", ut, st);
3195 for (j = &commands[i].prog; *j; j = &commands[i].argv[++c])
3197 const char *p;
3198 for (p = *j; *p; ++p)
3199 if (*p == '"' || *p == '\\' || *p == '$'
3200 || ISSPACE (*p))
3201 break;
3203 if (*p)
3205 fprintf (report_times_to_file, " \"");
3206 for (p = *j; *p; ++p)
3208 if (*p == '"' || *p == '\\' || *p == '$')
3209 fputc ('\\', report_times_to_file);
3210 fputc (*p, report_times_to_file);
3212 fputc ('"', report_times_to_file);
3214 else
3215 fprintf (report_times_to_file, " %s", *j);
3218 fputc ('\n', report_times_to_file);
3224 if (commands[0].argv[0] != commands[0].prog)
3225 free (CONST_CAST (char *, commands[0].argv[0]));
3227 return ret_code;
3231 /* Find all the switches given to us
3232 and make a vector describing them.
3233 The elements of the vector are strings, one per switch given.
3234 If a switch uses following arguments, then the `part1' field
3235 is the switch itself and the `args' field
3236 is a null-terminated vector containing the following arguments.
3237 Bits in the `live_cond' field are:
3238 SWITCH_LIVE to indicate this switch is true in a conditional spec.
3239 SWITCH_FALSE to indicate this switch is overridden by a later switch.
3240 SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
3241 SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored.
3242 SWITCH_KEEP_FOR_GCC to indicate that this switch, otherwise ignored,
3243 should be included in COLLECT_GCC_OPTIONS.
3244 in all do_spec calls afterwards. Used for %<S from self specs.
3245 The `known' field describes whether this is an internal switch.
3246 The `validated' field describes whether any spec has looked at this switch;
3247 if it remains false at the end of the run, the switch must be meaningless.
3248 The `ordering' field is used to temporarily mark switches that have to be
3249 kept in a specific order. */
3251 #define SWITCH_LIVE (1 << 0)
3252 #define SWITCH_FALSE (1 << 1)
3253 #define SWITCH_IGNORE (1 << 2)
3254 #define SWITCH_IGNORE_PERMANENTLY (1 << 3)
3255 #define SWITCH_KEEP_FOR_GCC (1 << 4)
3257 struct switchstr
3259 const char *part1;
3260 const char **args;
3261 unsigned int live_cond;
3262 bool known;
3263 bool validated;
3264 bool ordering;
3267 static struct switchstr *switches;
3269 static int n_switches;
3271 static int n_switches_alloc;
3273 /* Set to zero if -fcompare-debug is disabled, positive if it's
3274 enabled and we're running the first compilation, negative if it's
3275 enabled and we're running the second compilation. For most of the
3276 time, it's in the range -1..1, but it can be temporarily set to 2
3277 or 3 to indicate that the -fcompare-debug flags didn't come from
3278 the command-line, but rather from the GCC_COMPARE_DEBUG environment
3279 variable, until a synthesized -fcompare-debug flag is added to the
3280 command line. */
3281 int compare_debug;
3283 /* Set to nonzero if we've seen the -fcompare-debug-second flag. */
3284 int compare_debug_second;
3286 /* Set to the flags that should be passed to the second compilation in
3287 a -fcompare-debug compilation. */
3288 const char *compare_debug_opt;
3290 static struct switchstr *switches_debug_check[2];
3292 static int n_switches_debug_check[2];
3294 static int n_switches_alloc_debug_check[2];
3296 static char *debug_check_temp_file[2];
3298 /* Language is one of three things:
3300 1) The name of a real programming language.
3301 2) NULL, indicating that no one has figured out
3302 what it is yet.
3303 3) '*', indicating that the file should be passed
3304 to the linker. */
3305 struct infile
3307 const char *name;
3308 const char *language;
3309 struct compiler *incompiler;
3310 bool compiled;
3311 bool preprocessed;
3314 /* Also a vector of input files specified. */
3316 static struct infile *infiles;
3318 int n_infiles;
3320 static int n_infiles_alloc;
3322 /* True if undefined environment variables encountered during spec processing
3323 are ok to ignore, typically when we're running for --help or --version. */
3325 static bool spec_undefvar_allowed;
3327 /* True if multiple input files are being compiled to a single
3328 assembly file. */
3330 static bool combine_inputs;
3332 /* This counts the number of libraries added by lang_specific_driver, so that
3333 we can tell if there were any user supplied any files or libraries. */
3335 static int added_libraries;
3337 /* And a vector of corresponding output files is made up later. */
3339 const char **outfiles;
3341 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3343 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
3344 is true if we should look for an executable suffix. DO_OBJ
3345 is true if we should look for an object suffix. */
3347 static const char *
3348 convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
3349 int do_obj ATTRIBUTE_UNUSED)
3351 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3352 int i;
3353 #endif
3354 int len;
3356 if (name == NULL)
3357 return NULL;
3359 len = strlen (name);
3361 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3362 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
3363 if (do_obj && len > 2
3364 && name[len - 2] == '.'
3365 && name[len - 1] == 'o')
3367 obstack_grow (&obstack, name, len - 2);
3368 obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
3369 name = XOBFINISH (&obstack, const char *);
3371 #endif
3373 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3374 /* If there is no filetype, make it the executable suffix (which includes
3375 the "."). But don't get confused if we have just "-o". */
3376 if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
3377 return name;
3379 for (i = len - 1; i >= 0; i--)
3380 if (IS_DIR_SEPARATOR (name[i]))
3381 break;
3383 for (i++; i < len; i++)
3384 if (name[i] == '.')
3385 return name;
3387 obstack_grow (&obstack, name, len);
3388 obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
3389 strlen (TARGET_EXECUTABLE_SUFFIX));
3390 name = XOBFINISH (&obstack, const char *);
3391 #endif
3393 return name;
3395 #endif
3397 /* Display the command line switches accepted by gcc. */
3398 static void
3399 display_help (void)
3401 printf (_("Usage: %s [options] file...\n"), progname);
3402 fputs (_("Options:\n"), stdout);
3404 fputs (_(" -pass-exit-codes Exit with highest error code from a phase.\n"), stdout);
3405 fputs (_(" --help Display this information.\n"), stdout);
3406 fputs (_(" --target-help Display target specific command line options.\n"), stdout);
3407 fputs (_(" --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...].\n"), stdout);
3408 fputs (_(" Display specific types of command line options.\n"), stdout);
3409 if (! verbose_flag)
3410 fputs (_(" (Use '-v --help' to display command line options of sub-processes).\n"), stdout);
3411 fputs (_(" --version Display compiler version information.\n"), stdout);
3412 fputs (_(" -dumpspecs Display all of the built in spec strings.\n"), stdout);
3413 fputs (_(" -dumpversion Display the version of the compiler.\n"), stdout);
3414 fputs (_(" -dumpmachine Display the compiler's target processor.\n"), stdout);
3415 fputs (_(" -print-search-dirs Display the directories in the compiler's search path.\n"), stdout);
3416 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library.\n"), stdout);
3417 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>.\n"), stdout);
3418 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>.\n"), stdout);
3419 fputs (_("\
3420 -print-multiarch Display the target's normalized GNU triplet, used as\n\
3421 a component in the library path.\n"), stdout);
3422 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc.\n"), stdout);
3423 fputs (_("\
3424 -print-multi-lib Display the mapping between command line options and\n\
3425 multiple library search directories.\n"), stdout);
3426 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries.\n"), stdout);
3427 fputs (_(" -print-sysroot Display the target libraries directory.\n"), stdout);
3428 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers.\n"), stdout);
3429 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler.\n"), stdout);
3430 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor.\n"), stdout);
3431 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker.\n"), stdout);
3432 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler.\n"), stdout);
3433 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor.\n"), stdout);
3434 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker.\n"), stdout);
3435 fputs (_(" -save-temps Do not delete intermediate files.\n"), stdout);
3436 fputs (_(" -save-temps=<arg> Do not delete intermediate files.\n"), stdout);
3437 fputs (_("\
3438 -no-canonical-prefixes Do not canonicalize paths when building relative\n\
3439 prefixes to other gcc components.\n"), stdout);
3440 fputs (_(" -pipe Use pipes rather than intermediate files.\n"), stdout);
3441 fputs (_(" -time Time the execution of each subprocess.\n"), stdout);
3442 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>.\n"), stdout);
3443 fputs (_(" -std=<standard> Assume that the input sources are for <standard>.\n"), stdout);
3444 fputs (_("\
3445 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3446 and libraries.\n"), stdout);
3447 fputs (_(" -B <directory> Add <directory> to the compiler's search paths.\n"), stdout);
3448 fputs (_(" -v Display the programs invoked by the compiler.\n"), stdout);
3449 fputs (_(" -### Like -v but options quoted and commands not executed.\n"), stdout);
3450 fputs (_(" -E Preprocess only; do not compile, assemble or link.\n"), stdout);
3451 fputs (_(" -S Compile only; do not assemble or link.\n"), stdout);
3452 fputs (_(" -c Compile and assemble, but do not link.\n"), stdout);
3453 fputs (_(" -o <file> Place the output into <file>.\n"), stdout);
3454 fputs (_(" -pie Create a position independent executable.\n"), stdout);
3455 fputs (_(" -shared Create a shared library.\n"), stdout);
3456 fputs (_("\
3457 -x <language> Specify the language of the following input files.\n\
3458 Permissible languages include: c c++ assembler none\n\
3459 'none' means revert to the default behavior of\n\
3460 guessing the language based on the file's extension.\n\
3461 "), stdout);
3463 printf (_("\
3464 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3465 passed on to the various sub-processes invoked by %s. In order to pass\n\
3466 other options on to these processes the -W<letter> options must be used.\n\
3467 "), progname);
3469 /* The rest of the options are displayed by invocations of the various
3470 sub-processes. */
3473 static void
3474 add_preprocessor_option (const char *option, int len)
3476 preprocessor_options.safe_push (save_string (option, len));
3479 static void
3480 add_assembler_option (const char *option, int len)
3482 assembler_options.safe_push (save_string (option, len));
3485 static void
3486 add_linker_option (const char *option, int len)
3488 linker_options.safe_push (save_string (option, len));
3491 /* Allocate space for an input file in infiles. */
3493 static void
3494 alloc_infile (void)
3496 if (n_infiles_alloc == 0)
3498 n_infiles_alloc = 16;
3499 infiles = XNEWVEC (struct infile, n_infiles_alloc);
3501 else if (n_infiles_alloc == n_infiles)
3503 n_infiles_alloc *= 2;
3504 infiles = XRESIZEVEC (struct infile, infiles, n_infiles_alloc);
3508 /* Store an input file with the given NAME and LANGUAGE in
3509 infiles. */
3511 static void
3512 add_infile (const char *name, const char *language)
3514 alloc_infile ();
3515 infiles[n_infiles].name = name;
3516 infiles[n_infiles++].language = language;
3519 /* Allocate space for a switch in switches. */
3521 static void
3522 alloc_switch (void)
3524 if (n_switches_alloc == 0)
3526 n_switches_alloc = 16;
3527 switches = XNEWVEC (struct switchstr, n_switches_alloc);
3529 else if (n_switches_alloc == n_switches)
3531 n_switches_alloc *= 2;
3532 switches = XRESIZEVEC (struct switchstr, switches, n_switches_alloc);
3536 /* Save an option OPT with N_ARGS arguments in array ARGS, marking it
3537 as validated if VALIDATED and KNOWN if it is an internal switch. */
3539 static void
3540 save_switch (const char *opt, size_t n_args, const char *const *args,
3541 bool validated, bool known)
3543 alloc_switch ();
3544 switches[n_switches].part1 = opt + 1;
3545 if (n_args == 0)
3546 switches[n_switches].args = 0;
3547 else
3549 switches[n_switches].args = XNEWVEC (const char *, n_args + 1);
3550 memcpy (switches[n_switches].args, args, n_args * sizeof (const char *));
3551 switches[n_switches].args[n_args] = NULL;
3554 switches[n_switches].live_cond = 0;
3555 switches[n_switches].validated = validated;
3556 switches[n_switches].known = known;
3557 switches[n_switches].ordering = 0;
3558 n_switches++;
3561 /* Set the SOURCE_DATE_EPOCH environment variable to the current time if it is
3562 not set already. */
3564 static void
3565 set_source_date_epoch_envvar ()
3567 /* Array size is 21 = ceil(log_10(2^64)) + 1 to hold string representations
3568 of 64 bit integers. */
3569 char source_date_epoch[21];
3570 time_t tt;
3572 errno = 0;
3573 tt = time (NULL);
3574 if (tt < (time_t) 0 || errno != 0)
3575 tt = (time_t) 0;
3577 snprintf (source_date_epoch, 21, "%llu", (unsigned long long) tt);
3578 /* Using setenv instead of xputenv because we want the variable to remain
3579 after finalizing so that it's still set in the second run when using
3580 -fcompare-debug. */
3581 setenv ("SOURCE_DATE_EPOCH", source_date_epoch, 0);
3584 /* Handle an option DECODED that is unknown to the option-processing
3585 machinery. */
3587 static bool
3588 driver_unknown_option_callback (const struct cl_decoded_option *decoded)
3590 const char *opt = decoded->arg;
3591 if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-'
3592 && !(decoded->errors & CL_ERR_NEGATIVE))
3594 /* Leave unknown -Wno-* options for the compiler proper, to be
3595 diagnosed only if there are warnings. */
3596 save_switch (decoded->canonical_option[0],
3597 decoded->canonical_option_num_elements - 1,
3598 &decoded->canonical_option[1], false, true);
3599 return false;
3601 if (decoded->opt_index == OPT_SPECIAL_unknown)
3603 /* Give it a chance to define it a spec file. */
3604 save_switch (decoded->canonical_option[0],
3605 decoded->canonical_option_num_elements - 1,
3606 &decoded->canonical_option[1], false, false);
3607 return false;
3609 else
3610 return true;
3613 /* Handle an option DECODED that is not marked as CL_DRIVER.
3614 LANG_MASK will always be CL_DRIVER. */
3616 static void
3617 driver_wrong_lang_callback (const struct cl_decoded_option *decoded,
3618 unsigned int lang_mask ATTRIBUTE_UNUSED)
3620 /* At this point, non-driver options are accepted (and expected to
3621 be passed down by specs) unless marked to be rejected by the
3622 driver. Options to be rejected by the driver but accepted by the
3623 compilers proper are treated just like completely unknown
3624 options. */
3625 const struct cl_option *option = &cl_options[decoded->opt_index];
3627 if (option->cl_reject_driver)
3628 error ("unrecognized command line option %qs",
3629 decoded->orig_option_with_args_text);
3630 else
3631 save_switch (decoded->canonical_option[0],
3632 decoded->canonical_option_num_elements - 1,
3633 &decoded->canonical_option[1], false, true);
3636 static const char *spec_lang = 0;
3637 static int last_language_n_infiles;
3639 /* Parse -foffload option argument. */
3641 static void
3642 handle_foffload_option (const char *arg)
3644 const char *c, *cur, *n, *next, *end;
3645 char *target;
3647 /* If option argument starts with '-' then no target is specified and we
3648 do not need to parse it. */
3649 if (arg[0] == '-')
3650 return;
3652 end = strchr (arg, '=');
3653 if (end == NULL)
3654 end = strchr (arg, '\0');
3655 cur = arg;
3657 while (cur < end)
3659 next = strchr (cur, ',');
3660 if (next == NULL)
3661 next = end;
3662 next = (next > end) ? end : next;
3664 target = XNEWVEC (char, next - cur + 1);
3665 memcpy (target, cur, next - cur);
3666 target[next - cur] = '\0';
3668 /* If 'disable' is passed to the option, stop parsing the option and clean
3669 the list of offload targets. */
3670 if (strcmp (target, "disable") == 0)
3672 free (offload_targets);
3673 offload_targets = xstrdup ("");
3674 break;
3677 /* Check that GCC is configured to support the offload target. */
3678 c = OFFLOAD_TARGETS;
3679 while (c)
3681 n = strchr (c, ',');
3682 if (n == NULL)
3683 n = strchr (c, '\0');
3685 if (next - cur == n - c && strncmp (target, c, n - c) == 0)
3686 break;
3688 c = *n ? n + 1 : NULL;
3691 if (!c)
3692 fatal_error (input_location,
3693 "GCC is not configured to support %s as offload target",
3694 target);
3696 if (!offload_targets)
3698 offload_targets = target;
3699 target = NULL;
3701 else
3703 /* Check that the target hasn't already presented in the list. */
3704 c = offload_targets;
3707 n = strchr (c, ':');
3708 if (n == NULL)
3709 n = strchr (c, '\0');
3711 if (next - cur == n - c && strncmp (c, target, n - c) == 0)
3712 break;
3714 c = n + 1;
3716 while (*n);
3718 /* If duplicate is not found, append the target to the list. */
3719 if (c > n)
3721 size_t offload_targets_len = strlen (offload_targets);
3722 offload_targets
3723 = XRESIZEVEC (char, offload_targets,
3724 offload_targets_len + 1 + next - cur + 1);
3725 offload_targets[offload_targets_len++] = ':';
3726 memcpy (offload_targets + offload_targets_len, target, next - cur + 1);
3730 cur = next + 1;
3731 XDELETEVEC (target);
3735 /* Handle a driver option; arguments and return value as for
3736 handle_option. */
3738 static bool
3739 driver_handle_option (struct gcc_options *opts,
3740 struct gcc_options *opts_set,
3741 const struct cl_decoded_option *decoded,
3742 unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
3743 location_t loc,
3744 const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED,
3745 diagnostic_context *dc)
3747 size_t opt_index = decoded->opt_index;
3748 const char *arg = decoded->arg;
3749 const char *compare_debug_replacement_opt;
3750 int value = decoded->value;
3751 bool validated = false;
3752 bool do_save = true;
3754 gcc_assert (opts == &global_options);
3755 gcc_assert (opts_set == &global_options_set);
3756 gcc_assert (kind == DK_UNSPECIFIED);
3757 gcc_assert (loc == UNKNOWN_LOCATION);
3758 gcc_assert (dc == global_dc);
3760 switch (opt_index)
3762 case OPT_dumpspecs:
3764 struct spec_list *sl;
3765 init_spec ();
3766 for (sl = specs; sl; sl = sl->next)
3767 printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3768 if (link_command_spec)
3769 printf ("*link_command:\n%s\n\n", link_command_spec);
3770 exit (0);
3773 case OPT_dumpversion:
3774 printf ("%s\n", spec_version);
3775 exit (0);
3777 case OPT_dumpmachine:
3778 printf ("%s\n", spec_machine);
3779 exit (0);
3781 case OPT_dumpfullversion:
3782 printf ("%s\n", BASEVER);
3783 exit (0);
3785 case OPT__version:
3786 print_version = 1;
3788 /* CPP driver cannot obtain switch from cc1_options. */
3789 if (is_cpp_driver)
3790 add_preprocessor_option ("--version", strlen ("--version"));
3791 add_assembler_option ("--version", strlen ("--version"));
3792 add_linker_option ("--version", strlen ("--version"));
3793 break;
3795 case OPT__help:
3796 print_help_list = 1;
3798 /* CPP driver cannot obtain switch from cc1_options. */
3799 if (is_cpp_driver)
3800 add_preprocessor_option ("--help", 6);
3801 add_assembler_option ("--help", 6);
3802 add_linker_option ("--help", 6);
3803 break;
3805 case OPT__help_:
3806 print_subprocess_help = 2;
3807 break;
3809 case OPT__target_help:
3810 print_subprocess_help = 1;
3812 /* CPP driver cannot obtain switch from cc1_options. */
3813 if (is_cpp_driver)
3814 add_preprocessor_option ("--target-help", 13);
3815 add_assembler_option ("--target-help", 13);
3816 add_linker_option ("--target-help", 13);
3817 break;
3819 case OPT__no_sysroot_suffix:
3820 case OPT_pass_exit_codes:
3821 case OPT_print_search_dirs:
3822 case OPT_print_file_name_:
3823 case OPT_print_prog_name_:
3824 case OPT_print_multi_lib:
3825 case OPT_print_multi_directory:
3826 case OPT_print_sysroot:
3827 case OPT_print_multi_os_directory:
3828 case OPT_print_multiarch:
3829 case OPT_print_sysroot_headers_suffix:
3830 case OPT_time:
3831 case OPT_wrapper:
3832 /* These options set the variables specified in common.opt
3833 automatically, and do not need to be saved for spec
3834 processing. */
3835 do_save = false;
3836 break;
3838 case OPT_print_libgcc_file_name:
3839 print_file_name = "libgcc.a";
3840 do_save = false;
3841 break;
3843 case OPT_fuse_ld_bfd:
3844 use_ld = ".bfd";
3845 break;
3847 case OPT_fuse_ld_gold:
3848 use_ld = ".gold";
3849 break;
3851 case OPT_fcompare_debug_second:
3852 compare_debug_second = 1;
3853 break;
3855 case OPT_fcompare_debug:
3856 switch (value)
3858 case 0:
3859 compare_debug_replacement_opt = "-fcompare-debug=";
3860 arg = "";
3861 goto compare_debug_with_arg;
3863 case 1:
3864 compare_debug_replacement_opt = "-fcompare-debug=-gtoggle";
3865 arg = "-gtoggle";
3866 goto compare_debug_with_arg;
3868 default:
3869 gcc_unreachable ();
3871 break;
3873 case OPT_fcompare_debug_:
3874 compare_debug_replacement_opt = decoded->canonical_option[0];
3875 compare_debug_with_arg:
3876 gcc_assert (decoded->canonical_option_num_elements == 1);
3877 gcc_assert (arg != NULL);
3878 if (*arg)
3879 compare_debug = 1;
3880 else
3881 compare_debug = -1;
3882 if (compare_debug < 0)
3883 compare_debug_opt = NULL;
3884 else
3885 compare_debug_opt = arg;
3886 save_switch (compare_debug_replacement_opt, 0, NULL, validated, true);
3887 set_source_date_epoch_envvar ();
3888 return true;
3890 case OPT_fdiagnostics_color_:
3891 diagnostic_color_init (dc, value);
3892 break;
3894 case OPT_Wa_:
3896 int prev, j;
3897 /* Pass the rest of this option to the assembler. */
3899 /* Split the argument at commas. */
3900 prev = 0;
3901 for (j = 0; arg[j]; j++)
3902 if (arg[j] == ',')
3904 add_assembler_option (arg + prev, j - prev);
3905 prev = j + 1;
3908 /* Record the part after the last comma. */
3909 add_assembler_option (arg + prev, j - prev);
3911 do_save = false;
3912 break;
3914 case OPT_Wp_:
3916 int prev, j;
3917 /* Pass the rest of this option to the preprocessor. */
3919 /* Split the argument at commas. */
3920 prev = 0;
3921 for (j = 0; arg[j]; j++)
3922 if (arg[j] == ',')
3924 add_preprocessor_option (arg + prev, j - prev);
3925 prev = j + 1;
3928 /* Record the part after the last comma. */
3929 add_preprocessor_option (arg + prev, j - prev);
3931 do_save = false;
3932 break;
3934 case OPT_Wl_:
3936 int prev, j;
3937 /* Split the argument at commas. */
3938 prev = 0;
3939 for (j = 0; arg[j]; j++)
3940 if (arg[j] == ',')
3942 add_infile (save_string (arg + prev, j - prev), "*");
3943 prev = j + 1;
3945 /* Record the part after the last comma. */
3946 add_infile (arg + prev, "*");
3948 do_save = false;
3949 break;
3951 case OPT_Xlinker:
3952 add_infile (arg, "*");
3953 do_save = false;
3954 break;
3956 case OPT_Xpreprocessor:
3957 add_preprocessor_option (arg, strlen (arg));
3958 do_save = false;
3959 break;
3961 case OPT_Xassembler:
3962 add_assembler_option (arg, strlen (arg));
3963 do_save = false;
3964 break;
3966 case OPT_l:
3967 /* POSIX allows separation of -l and the lib arg; canonicalize
3968 by concatenating -l with its arg */
3969 add_infile (concat ("-l", arg, NULL), "*");
3970 do_save = false;
3971 break;
3973 case OPT_L:
3974 /* Similarly, canonicalize -L for linkers that may not accept
3975 separate arguments. */
3976 save_switch (concat ("-L", arg, NULL), 0, NULL, validated, true);
3977 return true;
3979 case OPT_F:
3980 /* Likewise -F. */
3981 save_switch (concat ("-F", arg, NULL), 0, NULL, validated, true);
3982 return true;
3984 case OPT_save_temps:
3985 save_temps_flag = SAVE_TEMPS_CWD;
3986 validated = true;
3987 break;
3989 case OPT_save_temps_:
3990 if (strcmp (arg, "cwd") == 0)
3991 save_temps_flag = SAVE_TEMPS_CWD;
3992 else if (strcmp (arg, "obj") == 0
3993 || strcmp (arg, "object") == 0)
3994 save_temps_flag = SAVE_TEMPS_OBJ;
3995 else
3996 fatal_error (input_location, "%qs is an unknown -save-temps option",
3997 decoded->orig_option_with_args_text);
3998 break;
4000 case OPT_no_canonical_prefixes:
4001 /* Already handled as a special case, so ignored here. */
4002 do_save = false;
4003 break;
4005 case OPT_pipe:
4006 validated = true;
4007 /* These options set the variables specified in common.opt
4008 automatically, but do need to be saved for spec
4009 processing. */
4010 break;
4012 case OPT_specs_:
4014 struct user_specs *user = XNEW (struct user_specs);
4016 user->next = (struct user_specs *) 0;
4017 user->filename = arg;
4018 if (user_specs_tail)
4019 user_specs_tail->next = user;
4020 else
4021 user_specs_head = user;
4022 user_specs_tail = user;
4024 validated = true;
4025 break;
4027 case OPT__sysroot_:
4028 target_system_root = arg;
4029 target_system_root_changed = 1;
4030 do_save = false;
4031 break;
4033 case OPT_time_:
4034 if (report_times_to_file)
4035 fclose (report_times_to_file);
4036 report_times_to_file = fopen (arg, "a");
4037 do_save = false;
4038 break;
4040 case OPT____:
4041 /* "-###"
4042 This is similar to -v except that there is no execution
4043 of the commands and the echoed arguments are quoted. It
4044 is intended for use in shell scripts to capture the
4045 driver-generated command line. */
4046 verbose_only_flag++;
4047 verbose_flag = 1;
4048 do_save = false;
4049 break;
4051 case OPT_B:
4053 size_t len = strlen (arg);
4055 /* Catch the case where the user has forgotten to append a
4056 directory separator to the path. Note, they may be using
4057 -B to add an executable name prefix, eg "i386-elf-", in
4058 order to distinguish between multiple installations of
4059 GCC in the same directory. Hence we must check to see
4060 if appending a directory separator actually makes a
4061 valid directory name. */
4062 if (!IS_DIR_SEPARATOR (arg[len - 1])
4063 && is_directory (arg, false))
4065 char *tmp = XNEWVEC (char, len + 2);
4066 strcpy (tmp, arg);
4067 tmp[len] = DIR_SEPARATOR;
4068 tmp[++len] = 0;
4069 arg = tmp;
4072 add_prefix (&exec_prefixes, arg, NULL,
4073 PREFIX_PRIORITY_B_OPT, 0, 0);
4074 add_prefix (&startfile_prefixes, arg, NULL,
4075 PREFIX_PRIORITY_B_OPT, 0, 0);
4076 add_prefix (&include_prefixes, arg, NULL,
4077 PREFIX_PRIORITY_B_OPT, 0, 0);
4079 validated = true;
4080 break;
4082 case OPT_E:
4083 have_E = true;
4084 break;
4086 case OPT_x:
4087 spec_lang = arg;
4088 if (!strcmp (spec_lang, "none"))
4089 /* Suppress the warning if -xnone comes after the last input
4090 file, because alternate command interfaces like g++ might
4091 find it useful to place -xnone after each input file. */
4092 spec_lang = 0;
4093 else
4094 last_language_n_infiles = n_infiles;
4095 do_save = false;
4096 break;
4098 case OPT_o:
4099 have_o = 1;
4100 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
4101 arg = convert_filename (arg, ! have_c, 0);
4102 #endif
4103 output_file = arg;
4104 /* Save the output name in case -save-temps=obj was used. */
4105 save_temps_prefix = xstrdup (arg);
4106 /* On some systems, ld cannot handle "-o" without a space. So
4107 split the option from its argument. */
4108 save_switch ("-o", 1, &arg, validated, true);
4109 return true;
4111 #ifdef ENABLE_DEFAULT_PIE
4112 case OPT_pie:
4113 /* -pie is turned on by default. */
4114 #endif
4116 case OPT_static_libgcc:
4117 case OPT_shared_libgcc:
4118 case OPT_static_libgfortran:
4119 case OPT_static_libstdc__:
4120 /* These are always valid, since gcc.c itself understands the
4121 first two, gfortranspec.c understands -static-libgfortran and
4122 g++spec.c understands -static-libstdc++ */
4123 validated = true;
4124 break;
4126 case OPT_fwpa:
4127 flag_wpa = "";
4128 break;
4130 case OPT_foffload_:
4131 handle_foffload_option (arg);
4132 break;
4134 default:
4135 /* Various driver options need no special processing at this
4136 point, having been handled in a prescan above or being
4137 handled by specs. */
4138 break;
4141 if (do_save)
4142 save_switch (decoded->canonical_option[0],
4143 decoded->canonical_option_num_elements - 1,
4144 &decoded->canonical_option[1], validated, true);
4145 return true;
4148 /* Put the driver's standard set of option handlers in *HANDLERS. */
4150 static void
4151 set_option_handlers (struct cl_option_handlers *handlers)
4153 handlers->unknown_option_callback = driver_unknown_option_callback;
4154 handlers->wrong_lang_callback = driver_wrong_lang_callback;
4155 handlers->num_handlers = 3;
4156 handlers->handlers[0].handler = driver_handle_option;
4157 handlers->handlers[0].mask = CL_DRIVER;
4158 handlers->handlers[1].handler = common_handle_option;
4159 handlers->handlers[1].mask = CL_COMMON;
4160 handlers->handlers[2].handler = target_handle_option;
4161 handlers->handlers[2].mask = CL_TARGET;
4164 /* Create the vector `switches' and its contents.
4165 Store its length in `n_switches'. */
4167 static void
4168 process_command (unsigned int decoded_options_count,
4169 struct cl_decoded_option *decoded_options)
4171 const char *temp;
4172 char *temp1;
4173 char *tooldir_prefix, *tooldir_prefix2;
4174 char *(*get_relative_prefix) (const char *, const char *,
4175 const char *) = NULL;
4176 struct cl_option_handlers handlers;
4177 unsigned int j;
4179 gcc_exec_prefix = env.get ("GCC_EXEC_PREFIX");
4181 n_switches = 0;
4182 n_infiles = 0;
4183 added_libraries = 0;
4185 /* Figure compiler version from version string. */
4187 compiler_version = temp1 = xstrdup (version_string);
4189 for (; *temp1; ++temp1)
4191 if (*temp1 == ' ')
4193 *temp1 = '\0';
4194 break;
4198 /* Handle any -no-canonical-prefixes flag early, to assign the function
4199 that builds relative prefixes. This function creates default search
4200 paths that are needed later in normal option handling. */
4202 for (j = 1; j < decoded_options_count; j++)
4204 if (decoded_options[j].opt_index == OPT_no_canonical_prefixes)
4206 get_relative_prefix = make_relative_prefix_ignore_links;
4207 break;
4210 if (! get_relative_prefix)
4211 get_relative_prefix = make_relative_prefix;
4213 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
4214 see if we can create it from the pathname specified in
4215 decoded_options[0].arg. */
4217 gcc_libexec_prefix = standard_libexec_prefix;
4218 #ifndef VMS
4219 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
4220 if (!gcc_exec_prefix)
4222 gcc_exec_prefix = get_relative_prefix (decoded_options[0].arg,
4223 standard_bindir_prefix,
4224 standard_exec_prefix);
4225 gcc_libexec_prefix = get_relative_prefix (decoded_options[0].arg,
4226 standard_bindir_prefix,
4227 standard_libexec_prefix);
4228 if (gcc_exec_prefix)
4229 xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
4231 else
4233 /* make_relative_prefix requires a program name, but
4234 GCC_EXEC_PREFIX is typically a directory name with a trailing
4235 / (which is ignored by make_relative_prefix), so append a
4236 program name. */
4237 char *tmp_prefix = concat (gcc_exec_prefix, "gcc", NULL);
4238 gcc_libexec_prefix = get_relative_prefix (tmp_prefix,
4239 standard_exec_prefix,
4240 standard_libexec_prefix);
4242 /* The path is unrelocated, so fallback to the original setting. */
4243 if (!gcc_libexec_prefix)
4244 gcc_libexec_prefix = standard_libexec_prefix;
4246 free (tmp_prefix);
4248 #else
4249 #endif
4250 /* From this point onward, gcc_exec_prefix is non-null if the toolchain
4251 is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
4252 or an automatically created GCC_EXEC_PREFIX from
4253 decoded_options[0].arg. */
4255 /* Do language-specific adjustment/addition of flags. */
4256 lang_specific_driver (&decoded_options, &decoded_options_count,
4257 &added_libraries);
4259 if (gcc_exec_prefix)
4261 int len = strlen (gcc_exec_prefix);
4263 if (len > (int) sizeof ("/lib/gcc/") - 1
4264 && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
4266 temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1;
4267 if (IS_DIR_SEPARATOR (*temp)
4268 && filename_ncmp (temp + 1, "lib", 3) == 0
4269 && IS_DIR_SEPARATOR (temp[4])
4270 && filename_ncmp (temp + 5, "gcc", 3) == 0)
4271 len -= sizeof ("/lib/gcc/") - 1;
4274 set_std_prefix (gcc_exec_prefix, len);
4275 add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC",
4276 PREFIX_PRIORITY_LAST, 0, 0);
4277 add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
4278 PREFIX_PRIORITY_LAST, 0, 0);
4281 /* COMPILER_PATH and LIBRARY_PATH have values
4282 that are lists of directory names with colons. */
4284 temp = env.get ("COMPILER_PATH");
4285 if (temp)
4287 const char *startp, *endp;
4288 char *nstore = (char *) alloca (strlen (temp) + 3);
4290 startp = endp = temp;
4291 while (1)
4293 if (*endp == PATH_SEPARATOR || *endp == 0)
4295 strncpy (nstore, startp, endp - startp);
4296 if (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;
4303 else
4304 nstore[endp - startp] = 0;
4305 add_prefix (&exec_prefixes, nstore, 0,
4306 PREFIX_PRIORITY_LAST, 0, 0);
4307 add_prefix (&include_prefixes, nstore, 0,
4308 PREFIX_PRIORITY_LAST, 0, 0);
4309 if (*endp == 0)
4310 break;
4311 endp = startp = endp + 1;
4313 else
4314 endp++;
4318 temp = env.get (LIBRARY_PATH_ENV);
4319 if (temp && *cross_compile == '0')
4321 const char *startp, *endp;
4322 char *nstore = (char *) alloca (strlen (temp) + 3);
4324 startp = endp = temp;
4325 while (1)
4327 if (*endp == PATH_SEPARATOR || *endp == 0)
4329 strncpy (nstore, startp, endp - startp);
4330 if (endp == startp)
4331 strcpy (nstore, concat (".", dir_separator_str, NULL));
4332 else if (!IS_DIR_SEPARATOR (endp[-1]))
4334 nstore[endp - startp] = DIR_SEPARATOR;
4335 nstore[endp - startp + 1] = 0;
4337 else
4338 nstore[endp - startp] = 0;
4339 add_prefix (&startfile_prefixes, nstore, NULL,
4340 PREFIX_PRIORITY_LAST, 0, 1);
4341 if (*endp == 0)
4342 break;
4343 endp = startp = endp + 1;
4345 else
4346 endp++;
4350 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
4351 temp = env.get ("LPATH");
4352 if (temp && *cross_compile == '0')
4354 const char *startp, *endp;
4355 char *nstore = (char *) alloca (strlen (temp) + 3);
4357 startp = endp = temp;
4358 while (1)
4360 if (*endp == PATH_SEPARATOR || *endp == 0)
4362 strncpy (nstore, startp, endp - startp);
4363 if (endp == startp)
4364 strcpy (nstore, concat (".", dir_separator_str, NULL));
4365 else if (!IS_DIR_SEPARATOR (endp[-1]))
4367 nstore[endp - startp] = DIR_SEPARATOR;
4368 nstore[endp - startp + 1] = 0;
4370 else
4371 nstore[endp - startp] = 0;
4372 add_prefix (&startfile_prefixes, nstore, NULL,
4373 PREFIX_PRIORITY_LAST, 0, 1);
4374 if (*endp == 0)
4375 break;
4376 endp = startp = endp + 1;
4378 else
4379 endp++;
4383 /* Process the options and store input files and switches in their
4384 vectors. */
4386 last_language_n_infiles = -1;
4388 set_option_handlers (&handlers);
4390 for (j = 1; j < decoded_options_count; j++)
4392 switch (decoded_options[j].opt_index)
4394 case OPT_S:
4395 case OPT_c:
4396 case OPT_E:
4397 have_c = 1;
4398 break;
4400 if (have_c)
4401 break;
4404 for (j = 1; j < decoded_options_count; j++)
4406 if (decoded_options[j].opt_index == OPT_SPECIAL_input_file)
4408 const char *arg = decoded_options[j].arg;
4409 const char *p = strrchr (arg, '@');
4410 char *fname;
4411 long offset;
4412 int consumed;
4413 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4414 arg = convert_filename (arg, 0, access (arg, F_OK));
4415 #endif
4416 /* For LTO static archive support we handle input file
4417 specifications that are composed of a filename and
4418 an offset like FNAME@OFFSET. */
4419 if (p
4420 && p != arg
4421 && sscanf (p, "@%li%n", &offset, &consumed) >= 1
4422 && strlen (p) == (unsigned int)consumed)
4424 fname = (char *)xmalloc (p - arg + 1);
4425 memcpy (fname, arg, p - arg);
4426 fname[p - arg] = '\0';
4427 /* Only accept non-stdin and existing FNAME parts, otherwise
4428 try with the full name. */
4429 if (strcmp (fname, "-") == 0 || access (fname, F_OK) < 0)
4431 free (fname);
4432 fname = xstrdup (arg);
4435 else
4436 fname = xstrdup (arg);
4438 if (strcmp (fname, "-") != 0 && access (fname, F_OK) < 0)
4440 if (fname[0] == '@' && access (fname + 1, F_OK) < 0)
4441 perror_with_name (fname + 1);
4442 else
4443 perror_with_name (fname);
4445 else
4446 add_infile (arg, spec_lang);
4448 free (fname);
4449 continue;
4452 read_cmdline_option (&global_options, &global_options_set,
4453 decoded_options + j, UNKNOWN_LOCATION,
4454 CL_DRIVER, &handlers, global_dc);
4457 /* If the user didn't specify any, default to all configured offload
4458 targets. */
4459 if (ENABLE_OFFLOADING && offload_targets == NULL)
4460 handle_foffload_option (OFFLOAD_TARGETS);
4462 if (output_file
4463 && strcmp (output_file, "-") != 0
4464 && strcmp (output_file, HOST_BIT_BUCKET) != 0)
4466 int i;
4467 for (i = 0; i < n_infiles; i++)
4468 if ((!infiles[i].language || infiles[i].language[0] != '*')
4469 && canonical_filename_eq (infiles[i].name, output_file))
4470 fatal_error (input_location,
4471 "input file %qs is the same as output file",
4472 output_file);
4475 /* If -save-temps=obj and -o name, create the prefix to use for %b.
4476 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
4477 if (save_temps_flag == SAVE_TEMPS_OBJ && save_temps_prefix != NULL)
4479 save_temps_length = strlen (save_temps_prefix);
4480 temp = strrchr (lbasename (save_temps_prefix), '.');
4481 if (temp)
4483 save_temps_length -= strlen (temp);
4484 save_temps_prefix[save_temps_length] = '\0';
4488 else if (save_temps_prefix != NULL)
4490 free (save_temps_prefix);
4491 save_temps_prefix = NULL;
4494 if (save_temps_flag && use_pipes)
4496 /* -save-temps overrides -pipe, so that temp files are produced */
4497 if (save_temps_flag)
4498 warning (0, "-pipe ignored because -save-temps specified");
4499 use_pipes = 0;
4502 if (!compare_debug)
4504 const char *gcd = env.get ("GCC_COMPARE_DEBUG");
4506 if (gcd && gcd[0] == '-')
4508 compare_debug = 2;
4509 compare_debug_opt = gcd;
4511 else if (gcd && *gcd && strcmp (gcd, "0"))
4513 compare_debug = 3;
4514 compare_debug_opt = "-gtoggle";
4517 else if (compare_debug < 0)
4519 compare_debug = 0;
4520 gcc_assert (!compare_debug_opt);
4523 /* Set up the search paths. We add directories that we expect to
4524 contain GNU Toolchain components before directories specified by
4525 the machine description so that we will find GNU components (like
4526 the GNU assembler) before those of the host system. */
4528 /* If we don't know where the toolchain has been installed, use the
4529 configured-in locations. */
4530 if (!gcc_exec_prefix)
4532 #ifndef OS2
4533 add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC",
4534 PREFIX_PRIORITY_LAST, 1, 0);
4535 add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS",
4536 PREFIX_PRIORITY_LAST, 2, 0);
4537 add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
4538 PREFIX_PRIORITY_LAST, 2, 0);
4539 #endif
4540 add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
4541 PREFIX_PRIORITY_LAST, 1, 0);
4544 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix));
4545 tooldir_prefix2 = concat (tooldir_base_prefix, spec_machine,
4546 dir_separator_str, NULL);
4548 /* Look for tools relative to the location from which the driver is
4549 running, or, if that is not available, the configured prefix. */
4550 tooldir_prefix
4551 = concat (gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
4552 spec_host_machine, dir_separator_str, spec_version,
4553 accel_dir_suffix, dir_separator_str, tooldir_prefix2, NULL);
4554 free (tooldir_prefix2);
4556 add_prefix (&exec_prefixes,
4557 concat (tooldir_prefix, "bin", dir_separator_str, NULL),
4558 "BINUTILS", PREFIX_PRIORITY_LAST, 0, 0);
4559 add_prefix (&startfile_prefixes,
4560 concat (tooldir_prefix, "lib", dir_separator_str, NULL),
4561 "BINUTILS", PREFIX_PRIORITY_LAST, 0, 1);
4562 free (tooldir_prefix);
4564 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
4565 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
4566 then consider it to relocate with the rest of the GCC installation
4567 if GCC_EXEC_PREFIX is set.
4568 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
4569 if (target_system_root && !target_system_root_changed && gcc_exec_prefix)
4571 char *tmp_prefix = get_relative_prefix (decoded_options[0].arg,
4572 standard_bindir_prefix,
4573 target_system_root);
4574 if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0)
4576 target_system_root = tmp_prefix;
4577 target_system_root_changed = 1;
4580 #endif
4582 /* More prefixes are enabled in main, after we read the specs file
4583 and determine whether this is cross-compilation or not. */
4585 if (n_infiles == last_language_n_infiles && spec_lang != 0)
4586 warning (0, "%<-x %s%> after last input file has no effect", spec_lang);
4588 /* Synthesize -fcompare-debug flag from the GCC_COMPARE_DEBUG
4589 environment variable. */
4590 if (compare_debug == 2 || compare_debug == 3)
4592 const char *opt = concat ("-fcompare-debug=", compare_debug_opt, NULL);
4593 save_switch (opt, 0, NULL, false, true);
4594 compare_debug = 1;
4597 /* Ensure we only invoke each subprocess once. */
4598 if (print_subprocess_help || print_help_list || print_version)
4600 n_infiles = 0;
4602 /* Create a dummy input file, so that we can pass
4603 the help option on to the various sub-processes. */
4604 add_infile ("help-dummy", "c");
4607 /* Decide if undefined variable references are allowed in specs. */
4609 /* --version and --help alone or together are safe. Note that -v would
4610 make them unsafe, as they'd then be run for subprocesses as well, the
4611 location of which might depend on variables possibly coming from
4612 self-specs.
4614 Count the number of options we have for which undefined variables
4615 are harmless for sure, and check that nothing else is set. */
4617 unsigned n_varsafe_options = 0;
4619 if (print_version)
4620 n_varsafe_options++;
4622 if (print_help_list)
4623 n_varsafe_options++;
4625 spec_undefvar_allowed = (n_varsafe_options == decoded_options_count - 1);
4627 alloc_switch ();
4628 switches[n_switches].part1 = 0;
4629 alloc_infile ();
4630 infiles[n_infiles].name = 0;
4633 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4634 and place that in the environment. */
4636 static void
4637 set_collect_gcc_options (void)
4639 int i;
4640 int first_time;
4642 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4643 the compiler. */
4644 obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
4645 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4647 first_time = TRUE;
4648 for (i = 0; (int) i < n_switches; i++)
4650 const char *const *args;
4651 const char *p, *q;
4652 if (!first_time)
4653 obstack_grow (&collect_obstack, " ", 1);
4655 first_time = FALSE;
4657 /* Ignore elided switches. */
4658 if ((switches[i].live_cond
4659 & (SWITCH_IGNORE | SWITCH_KEEP_FOR_GCC))
4660 == SWITCH_IGNORE)
4661 continue;
4663 obstack_grow (&collect_obstack, "'-", 2);
4664 q = switches[i].part1;
4665 while ((p = strchr (q, '\'')))
4667 obstack_grow (&collect_obstack, q, p - q);
4668 obstack_grow (&collect_obstack, "'\\''", 4);
4669 q = ++p;
4671 obstack_grow (&collect_obstack, q, strlen (q));
4672 obstack_grow (&collect_obstack, "'", 1);
4674 for (args = switches[i].args; args && *args; args++)
4676 obstack_grow (&collect_obstack, " '", 2);
4677 q = *args;
4678 while ((p = strchr (q, '\'')))
4680 obstack_grow (&collect_obstack, q, p - q);
4681 obstack_grow (&collect_obstack, "'\\''", 4);
4682 q = ++p;
4684 obstack_grow (&collect_obstack, q, strlen (q));
4685 obstack_grow (&collect_obstack, "'", 1);
4688 obstack_grow (&collect_obstack, "\0", 1);
4689 xputenv (XOBFINISH (&collect_obstack, char *));
4692 /* Process a spec string, accumulating and running commands. */
4694 /* These variables describe the input file name.
4695 input_file_number is the index on outfiles of this file,
4696 so that the output file name can be stored for later use by %o.
4697 input_basename is the start of the part of the input file
4698 sans all directory names, and basename_length is the number
4699 of characters starting there excluding the suffix .c or whatever. */
4701 static const char *gcc_input_filename;
4702 static int input_file_number;
4703 size_t input_filename_length;
4704 static int basename_length;
4705 static int suffixed_basename_length;
4706 static const char *input_basename;
4707 static const char *input_suffix;
4708 #ifndef HOST_LACKS_INODE_NUMBERS
4709 static struct stat input_stat;
4710 #endif
4711 static int input_stat_set;
4713 /* The compiler used to process the current input file. */
4714 static struct compiler *input_file_compiler;
4716 /* These are variables used within do_spec and do_spec_1. */
4718 /* Nonzero if an arg has been started and not yet terminated
4719 (with space, tab or newline). */
4720 static int arg_going;
4722 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4723 is a temporary file name. */
4724 static int delete_this_arg;
4726 /* Nonzero means %w has been seen; the next arg to be terminated
4727 is the output file name of this compilation. */
4728 static int this_is_output_file;
4730 /* Nonzero means %s has been seen; the next arg to be terminated
4731 is the name of a library file and we should try the standard
4732 search dirs for it. */
4733 static int this_is_library_file;
4735 /* Nonzero means %T has been seen; the next arg to be terminated
4736 is the name of a linker script and we should try all of the
4737 standard search dirs for it. If it is found insert a --script
4738 command line switch and then substitute the full path in place,
4739 otherwise generate an error message. */
4740 static int this_is_linker_script;
4742 /* Nonzero means that the input of this command is coming from a pipe. */
4743 static int input_from_pipe;
4745 /* Nonnull means substitute this for any suffix when outputting a switches
4746 arguments. */
4747 static const char *suffix_subst;
4749 /* If there is an argument being accumulated, terminate it and store it. */
4751 static void
4752 end_going_arg (void)
4754 if (arg_going)
4756 const char *string;
4758 obstack_1grow (&obstack, 0);
4759 string = XOBFINISH (&obstack, const char *);
4760 if (this_is_library_file)
4761 string = find_file (string);
4762 if (this_is_linker_script)
4764 char * full_script_path = find_a_file (&startfile_prefixes, string, R_OK, true);
4766 if (full_script_path == NULL)
4768 error ("unable to locate default linker script %qs in the library search paths", string);
4769 /* Script was not found on search path. */
4770 return;
4772 store_arg ("--script", false, false);
4773 string = full_script_path;
4775 store_arg (string, delete_this_arg, this_is_output_file);
4776 if (this_is_output_file)
4777 outfiles[input_file_number] = string;
4778 arg_going = 0;
4783 /* Parse the WRAPPER string which is a comma separated list of the command line
4784 and insert them into the beginning of argbuf. */
4786 static void
4787 insert_wrapper (const char *wrapper)
4789 int n = 0;
4790 int i;
4791 char *buf = xstrdup (wrapper);
4792 char *p = buf;
4793 unsigned int old_length = argbuf.length ();
4797 n++;
4798 while (*p == ',')
4799 p++;
4801 while ((p = strchr (p, ',')) != NULL);
4803 argbuf.safe_grow (old_length + n);
4804 memmove (argbuf.address () + n,
4805 argbuf.address (),
4806 old_length * sizeof (const_char_p));
4808 i = 0;
4809 p = buf;
4812 while (*p == ',')
4814 *p = 0;
4815 p++;
4817 argbuf[i] = p;
4818 i++;
4820 while ((p = strchr (p, ',')) != NULL);
4821 gcc_assert (i == n);
4824 /* Process the spec SPEC and run the commands specified therein.
4825 Returns 0 if the spec is successfully processed; -1 if failed. */
4828 do_spec (const char *spec)
4830 int value;
4832 value = do_spec_2 (spec);
4834 /* Force out any unfinished command.
4835 If -pipe, this forces out the last command if it ended in `|'. */
4836 if (value == 0)
4838 if (argbuf.length () > 0
4839 && !strcmp (argbuf.last (), "|"))
4840 argbuf.pop ();
4842 set_collect_gcc_options ();
4844 if (argbuf.length () > 0)
4845 value = execute ();
4848 return value;
4851 static int
4852 do_spec_2 (const char *spec)
4854 int result;
4856 clear_args ();
4857 arg_going = 0;
4858 delete_this_arg = 0;
4859 this_is_output_file = 0;
4860 this_is_library_file = 0;
4861 this_is_linker_script = 0;
4862 input_from_pipe = 0;
4863 suffix_subst = NULL;
4865 result = do_spec_1 (spec, 0, NULL);
4867 end_going_arg ();
4869 return result;
4873 /* Process the given spec string and add any new options to the end
4874 of the switches/n_switches array. */
4876 static void
4877 do_option_spec (const char *name, const char *spec)
4879 unsigned int i, value_count, value_len;
4880 const char *p, *q, *value;
4881 char *tmp_spec, *tmp_spec_p;
4883 if (configure_default_options[0].name == NULL)
4884 return;
4886 for (i = 0; i < ARRAY_SIZE (configure_default_options); i++)
4887 if (strcmp (configure_default_options[i].name, name) == 0)
4888 break;
4889 if (i == ARRAY_SIZE (configure_default_options))
4890 return;
4892 value = configure_default_options[i].value;
4893 value_len = strlen (value);
4895 /* Compute the size of the final spec. */
4896 value_count = 0;
4897 p = spec;
4898 while ((p = strstr (p, "%(VALUE)")) != NULL)
4900 p ++;
4901 value_count ++;
4904 /* Replace each %(VALUE) by the specified value. */
4905 tmp_spec = (char *) alloca (strlen (spec) + 1
4906 + value_count * (value_len - strlen ("%(VALUE)")));
4907 tmp_spec_p = tmp_spec;
4908 q = spec;
4909 while ((p = strstr (q, "%(VALUE)")) != NULL)
4911 memcpy (tmp_spec_p, q, p - q);
4912 tmp_spec_p = tmp_spec_p + (p - q);
4913 memcpy (tmp_spec_p, value, value_len);
4914 tmp_spec_p += value_len;
4915 q = p + strlen ("%(VALUE)");
4917 strcpy (tmp_spec_p, q);
4919 do_self_spec (tmp_spec);
4922 /* Process the given spec string and add any new options to the end
4923 of the switches/n_switches array. */
4925 static void
4926 do_self_spec (const char *spec)
4928 int i;
4930 do_spec_2 (spec);
4931 do_spec_1 (" ", 0, NULL);
4933 /* Mark %<S switches processed by do_self_spec to be ignored permanently.
4934 do_self_specs adds the replacements to switches array, so it shouldn't
4935 be processed afterwards. */
4936 for (i = 0; i < n_switches; i++)
4937 if ((switches[i].live_cond & SWITCH_IGNORE))
4938 switches[i].live_cond |= SWITCH_IGNORE_PERMANENTLY;
4940 if (argbuf.length () > 0)
4942 const char **argbuf_copy;
4943 struct cl_decoded_option *decoded_options;
4944 struct cl_option_handlers handlers;
4945 unsigned int decoded_options_count;
4946 unsigned int j;
4948 /* Create a copy of argbuf with a dummy argv[0] entry for
4949 decode_cmdline_options_to_array. */
4950 argbuf_copy = XNEWVEC (const char *,
4951 argbuf.length () + 1);
4952 argbuf_copy[0] = "";
4953 memcpy (argbuf_copy + 1, argbuf.address (),
4954 argbuf.length () * sizeof (const char *));
4956 decode_cmdline_options_to_array (argbuf.length () + 1,
4957 argbuf_copy,
4958 CL_DRIVER, &decoded_options,
4959 &decoded_options_count);
4960 free (argbuf_copy);
4962 set_option_handlers (&handlers);
4964 for (j = 1; j < decoded_options_count; j++)
4966 switch (decoded_options[j].opt_index)
4968 case OPT_SPECIAL_input_file:
4969 /* Specs should only generate options, not input
4970 files. */
4971 if (strcmp (decoded_options[j].arg, "-") != 0)
4972 fatal_error (input_location,
4973 "switch %qs does not start with %<-%>",
4974 decoded_options[j].arg);
4975 else
4976 fatal_error (input_location,
4977 "spec-generated switch is just %<-%>");
4978 break;
4980 case OPT_fcompare_debug_second:
4981 case OPT_fcompare_debug:
4982 case OPT_fcompare_debug_:
4983 case OPT_o:
4984 /* Avoid duplicate processing of some options from
4985 compare-debug specs; just save them here. */
4986 save_switch (decoded_options[j].canonical_option[0],
4987 (decoded_options[j].canonical_option_num_elements
4988 - 1),
4989 &decoded_options[j].canonical_option[1], false, true);
4990 break;
4992 default:
4993 read_cmdline_option (&global_options, &global_options_set,
4994 decoded_options + j, UNKNOWN_LOCATION,
4995 CL_DRIVER, &handlers, global_dc);
4996 break;
5000 free (decoded_options);
5002 alloc_switch ();
5003 switches[n_switches].part1 = 0;
5007 /* Callback for processing %D and %I specs. */
5009 struct spec_path_info {
5010 const char *option;
5011 const char *append;
5012 size_t append_len;
5013 bool omit_relative;
5014 bool separate_options;
5017 static void *
5018 spec_path (char *path, void *data)
5020 struct spec_path_info *info = (struct spec_path_info *) data;
5021 size_t len = 0;
5022 char save = 0;
5024 if (info->omit_relative && !IS_ABSOLUTE_PATH (path))
5025 return NULL;
5027 if (info->append_len != 0)
5029 len = strlen (path);
5030 memcpy (path + len, info->append, info->append_len + 1);
5033 if (!is_directory (path, true))
5034 return NULL;
5036 do_spec_1 (info->option, 1, NULL);
5037 if (info->separate_options)
5038 do_spec_1 (" ", 0, NULL);
5040 if (info->append_len == 0)
5042 len = strlen (path);
5043 save = path[len - 1];
5044 if (IS_DIR_SEPARATOR (path[len - 1]))
5045 path[len - 1] = '\0';
5048 do_spec_1 (path, 1, NULL);
5049 do_spec_1 (" ", 0, NULL);
5051 /* Must not damage the original path. */
5052 if (info->append_len == 0)
5053 path[len - 1] = save;
5055 return NULL;
5058 /* Create a temporary FILE with the contents of ARGV. Add @FILE to the
5059 argument list. */
5061 static void
5062 create_at_file (char **argv)
5064 char *temp_file = make_temp_file ("");
5065 char *at_argument = concat ("@", temp_file, NULL);
5066 FILE *f = fopen (temp_file, "w");
5067 int status;
5069 if (f == NULL)
5070 fatal_error (input_location, "could not open temporary response file %s",
5071 temp_file);
5073 status = writeargv (argv, f);
5075 if (status)
5076 fatal_error (input_location,
5077 "could not write to temporary response file %s",
5078 temp_file);
5080 status = fclose (f);
5082 if (EOF == status)
5083 fatal_error (input_location, "could not close temporary response file %s",
5084 temp_file);
5086 store_arg (at_argument, 0, 0);
5088 record_temp_file (temp_file, !save_temps_flag, !save_temps_flag);
5091 /* True if we should compile INFILE. */
5093 static bool
5094 compile_input_file_p (struct infile *infile)
5096 if ((!infile->language) || (infile->language[0] != '*'))
5097 if (infile->incompiler == input_file_compiler)
5098 return true;
5099 return false;
5102 /* Process each member of VEC as a spec. */
5104 static void
5105 do_specs_vec (vec<char_p> vec)
5107 unsigned ix;
5108 char *opt;
5110 FOR_EACH_VEC_ELT (vec, ix, opt)
5112 do_spec_1 (opt, 1, NULL);
5113 /* Make each accumulated option a separate argument. */
5114 do_spec_1 (" ", 0, NULL);
5118 /* Process the sub-spec SPEC as a portion of a larger spec.
5119 This is like processing a whole spec except that we do
5120 not initialize at the beginning and we do not supply a
5121 newline by default at the end.
5122 INSWITCH nonzero means don't process %-sequences in SPEC;
5123 in this case, % is treated as an ordinary character.
5124 This is used while substituting switches.
5125 INSWITCH nonzero also causes SPC not to terminate an argument.
5127 Value is zero unless a line was finished
5128 and the command on that line reported an error. */
5130 static int
5131 do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
5133 const char *p = spec;
5134 int c;
5135 int i;
5136 int value;
5138 /* If it's an empty string argument to a switch, keep it as is. */
5139 if (inswitch && !*p)
5140 arg_going = 1;
5142 while ((c = *p++))
5143 /* If substituting a switch, treat all chars like letters.
5144 Otherwise, NL, SPC, TAB and % are special. */
5145 switch (inswitch ? 'a' : c)
5147 case '\n':
5148 end_going_arg ();
5150 if (argbuf.length () > 0
5151 && !strcmp (argbuf.last (), "|"))
5153 /* A `|' before the newline means use a pipe here,
5154 but only if -pipe was specified.
5155 Otherwise, execute now and don't pass the `|' as an arg. */
5156 if (use_pipes)
5158 input_from_pipe = 1;
5159 break;
5161 else
5162 argbuf.pop ();
5165 set_collect_gcc_options ();
5167 if (argbuf.length () > 0)
5169 value = execute ();
5170 if (value)
5171 return value;
5173 /* Reinitialize for a new command, and for a new argument. */
5174 clear_args ();
5175 arg_going = 0;
5176 delete_this_arg = 0;
5177 this_is_output_file = 0;
5178 this_is_library_file = 0;
5179 this_is_linker_script = 0;
5180 input_from_pipe = 0;
5181 break;
5183 case '|':
5184 end_going_arg ();
5186 /* Use pipe */
5187 obstack_1grow (&obstack, c);
5188 arg_going = 1;
5189 break;
5191 case '\t':
5192 case ' ':
5193 end_going_arg ();
5195 /* Reinitialize for a new argument. */
5196 delete_this_arg = 0;
5197 this_is_output_file = 0;
5198 this_is_library_file = 0;
5199 this_is_linker_script = 0;
5200 break;
5202 case '%':
5203 switch (c = *p++)
5205 case 0:
5206 fatal_error (input_location, "spec %qs invalid", spec);
5208 case 'b':
5209 if (save_temps_length)
5210 obstack_grow (&obstack, save_temps_prefix, save_temps_length);
5211 else
5212 obstack_grow (&obstack, input_basename, basename_length);
5213 if (compare_debug < 0)
5214 obstack_grow (&obstack, ".gk", 3);
5215 arg_going = 1;
5216 break;
5218 case 'B':
5219 if (save_temps_length)
5220 obstack_grow (&obstack, save_temps_prefix, save_temps_length);
5221 else
5222 obstack_grow (&obstack, input_basename, suffixed_basename_length);
5223 if (compare_debug < 0)
5224 obstack_grow (&obstack, ".gk", 3);
5225 arg_going = 1;
5226 break;
5228 case 'd':
5229 delete_this_arg = 2;
5230 break;
5232 /* Dump out the directories specified with LIBRARY_PATH,
5233 followed by the absolute directories
5234 that we search for startfiles. */
5235 case 'D':
5237 struct spec_path_info info;
5239 info.option = "-L";
5240 info.append_len = 0;
5241 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
5242 /* Used on systems which record the specified -L dirs
5243 and use them to search for dynamic linking.
5244 Relative directories always come from -B,
5245 and it is better not to use them for searching
5246 at run time. In particular, stage1 loses. */
5247 info.omit_relative = true;
5248 #else
5249 info.omit_relative = false;
5250 #endif
5251 info.separate_options = false;
5253 for_each_path (&startfile_prefixes, true, 0, spec_path, &info);
5255 break;
5257 case 'e':
5258 /* %efoo means report an error with `foo' as error message
5259 and don't execute any more commands for this file. */
5261 const char *q = p;
5262 char *buf;
5263 while (*p != 0 && *p != '\n')
5264 p++;
5265 buf = (char *) alloca (p - q + 1);
5266 strncpy (buf, q, p - q);
5267 buf[p - q] = 0;
5268 error ("%s", _(buf));
5269 return -1;
5271 break;
5272 case 'n':
5273 /* %nfoo means report a notice with `foo' on stderr. */
5275 const char *q = p;
5276 char *buf;
5277 while (*p != 0 && *p != '\n')
5278 p++;
5279 buf = (char *) alloca (p - q + 1);
5280 strncpy (buf, q, p - q);
5281 buf[p - q] = 0;
5282 inform (0, "%s", _(buf));
5283 if (*p)
5284 p++;
5286 break;
5288 case 'j':
5290 struct stat st;
5292 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
5293 defined, and it is not a directory, and it is
5294 writable, use it. Otherwise, treat this like any
5295 other temporary file. */
5297 if ((!save_temps_flag)
5298 && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode))
5299 && (access (HOST_BIT_BUCKET, W_OK) == 0))
5301 obstack_grow (&obstack, HOST_BIT_BUCKET,
5302 strlen (HOST_BIT_BUCKET));
5303 delete_this_arg = 0;
5304 arg_going = 1;
5305 break;
5308 goto create_temp_file;
5309 case '|':
5310 if (use_pipes)
5312 obstack_1grow (&obstack, '-');
5313 delete_this_arg = 0;
5314 arg_going = 1;
5316 /* consume suffix */
5317 while (*p == '.' || ISALNUM ((unsigned char) *p))
5318 p++;
5319 if (p[0] == '%' && p[1] == 'O')
5320 p += 2;
5322 break;
5324 goto create_temp_file;
5325 case 'm':
5326 if (use_pipes)
5328 /* consume suffix */
5329 while (*p == '.' || ISALNUM ((unsigned char) *p))
5330 p++;
5331 if (p[0] == '%' && p[1] == 'O')
5332 p += 2;
5334 break;
5336 goto create_temp_file;
5337 case 'g':
5338 case 'u':
5339 case 'U':
5340 create_temp_file:
5342 struct temp_name *t;
5343 int suffix_length;
5344 const char *suffix = p;
5345 char *saved_suffix = NULL;
5347 while (*p == '.' || ISALNUM ((unsigned char) *p))
5348 p++;
5349 suffix_length = p - suffix;
5350 if (p[0] == '%' && p[1] == 'O')
5352 p += 2;
5353 /* We don't support extra suffix characters after %O. */
5354 if (*p == '.' || ISALNUM ((unsigned char) *p))
5355 fatal_error (input_location,
5356 "spec %qs has invalid %<%%0%c%>", spec, *p);
5357 if (suffix_length == 0)
5358 suffix = TARGET_OBJECT_SUFFIX;
5359 else
5361 saved_suffix
5362 = XNEWVEC (char, suffix_length
5363 + strlen (TARGET_OBJECT_SUFFIX) + 1);
5364 strncpy (saved_suffix, suffix, suffix_length);
5365 strcpy (saved_suffix + suffix_length,
5366 TARGET_OBJECT_SUFFIX);
5368 suffix_length += strlen (TARGET_OBJECT_SUFFIX);
5371 if (compare_debug < 0)
5373 suffix = concat (".gk", suffix, NULL);
5374 suffix_length += 3;
5377 /* If -save-temps=obj and -o were specified, use that for the
5378 temp file. */
5379 if (save_temps_length)
5381 char *tmp;
5382 temp_filename_length
5383 = save_temps_length + suffix_length + 1;
5384 tmp = (char *) alloca (temp_filename_length);
5385 memcpy (tmp, save_temps_prefix, save_temps_length);
5386 memcpy (tmp + save_temps_length, suffix, suffix_length);
5387 tmp[save_temps_length + suffix_length] = '\0';
5388 temp_filename = save_string (tmp, save_temps_length
5389 + suffix_length);
5390 obstack_grow (&obstack, temp_filename,
5391 temp_filename_length);
5392 arg_going = 1;
5393 delete_this_arg = 0;
5394 break;
5397 /* If the gcc_input_filename has the same suffix specified
5398 for the %g, %u, or %U, and -save-temps is specified,
5399 we could end up using that file as an intermediate
5400 thus clobbering the user's source file (.e.g.,
5401 gcc -save-temps foo.s would clobber foo.s with the
5402 output of cpp0). So check for this condition and
5403 generate a temp file as the intermediate. */
5405 if (save_temps_flag)
5407 char *tmp;
5408 temp_filename_length = basename_length + suffix_length + 1;
5409 tmp = (char *) alloca (temp_filename_length);
5410 memcpy (tmp, input_basename, basename_length);
5411 memcpy (tmp + basename_length, suffix, suffix_length);
5412 tmp[basename_length + suffix_length] = '\0';
5413 temp_filename = tmp;
5415 if (filename_cmp (temp_filename, gcc_input_filename) != 0)
5417 #ifndef HOST_LACKS_INODE_NUMBERS
5418 struct stat st_temp;
5420 /* Note, set_input() resets input_stat_set to 0. */
5421 if (input_stat_set == 0)
5423 input_stat_set = stat (gcc_input_filename,
5424 &input_stat);
5425 if (input_stat_set >= 0)
5426 input_stat_set = 1;
5429 /* If we have the stat for the gcc_input_filename
5430 and we can do the stat for the temp_filename
5431 then the they could still refer to the same
5432 file if st_dev/st_ino's are the same. */
5433 if (input_stat_set != 1
5434 || stat (temp_filename, &st_temp) < 0
5435 || input_stat.st_dev != st_temp.st_dev
5436 || input_stat.st_ino != st_temp.st_ino)
5437 #else
5438 /* Just compare canonical pathnames. */
5439 char* input_realname = lrealpath (gcc_input_filename);
5440 char* temp_realname = lrealpath (temp_filename);
5441 bool files_differ = filename_cmp (input_realname, temp_realname);
5442 free (input_realname);
5443 free (temp_realname);
5444 if (files_differ)
5445 #endif
5447 temp_filename
5448 = save_string (temp_filename,
5449 temp_filename_length - 1);
5450 obstack_grow (&obstack, temp_filename,
5451 temp_filename_length);
5452 arg_going = 1;
5453 delete_this_arg = 0;
5454 break;
5459 /* See if we already have an association of %g/%u/%U and
5460 suffix. */
5461 for (t = temp_names; t; t = t->next)
5462 if (t->length == suffix_length
5463 && strncmp (t->suffix, suffix, suffix_length) == 0
5464 && t->unique == (c == 'u' || c == 'U' || c == 'j'))
5465 break;
5467 /* Make a new association if needed. %u and %j
5468 require one. */
5469 if (t == 0 || c == 'u' || c == 'j')
5471 if (t == 0)
5473 t = XNEW (struct temp_name);
5474 t->next = temp_names;
5475 temp_names = t;
5477 t->length = suffix_length;
5478 if (saved_suffix)
5480 t->suffix = saved_suffix;
5481 saved_suffix = NULL;
5483 else
5484 t->suffix = save_string (suffix, suffix_length);
5485 t->unique = (c == 'u' || c == 'U' || c == 'j');
5486 temp_filename = make_temp_file (t->suffix);
5487 temp_filename_length = strlen (temp_filename);
5488 t->filename = temp_filename;
5489 t->filename_length = temp_filename_length;
5492 free (saved_suffix);
5494 obstack_grow (&obstack, t->filename, t->filename_length);
5495 delete_this_arg = 1;
5497 arg_going = 1;
5498 break;
5500 case 'i':
5501 if (combine_inputs)
5503 if (at_file_supplied)
5505 /* We are going to expand `%i' to `@FILE', where FILE
5506 is a newly-created temporary filename. The filenames
5507 that would usually be expanded in place of %o will be
5508 written to the temporary file. */
5509 char **argv;
5510 int n_files = 0;
5511 int j;
5513 for (i = 0; i < n_infiles; i++)
5514 if (compile_input_file_p (&infiles[i]))
5515 n_files++;
5517 argv = (char **) alloca (sizeof (char *) * (n_files + 1));
5519 /* Copy the strings over. */
5520 for (i = 0, j = 0; i < n_infiles; i++)
5521 if (compile_input_file_p (&infiles[i]))
5523 argv[j] = CONST_CAST (char *, infiles[i].name);
5524 infiles[i].compiled = true;
5525 j++;
5527 argv[j] = NULL;
5529 create_at_file (argv);
5531 else
5532 for (i = 0; (int) i < n_infiles; i++)
5533 if (compile_input_file_p (&infiles[i]))
5535 store_arg (infiles[i].name, 0, 0);
5536 infiles[i].compiled = true;
5539 else
5541 obstack_grow (&obstack, gcc_input_filename,
5542 input_filename_length);
5543 arg_going = 1;
5545 break;
5547 case 'I':
5549 struct spec_path_info info;
5551 if (multilib_dir)
5553 do_spec_1 ("-imultilib", 1, NULL);
5554 /* Make this a separate argument. */
5555 do_spec_1 (" ", 0, NULL);
5556 do_spec_1 (multilib_dir, 1, NULL);
5557 do_spec_1 (" ", 0, NULL);
5560 if (multiarch_dir)
5562 do_spec_1 ("-imultiarch", 1, NULL);
5563 /* Make this a separate argument. */
5564 do_spec_1 (" ", 0, NULL);
5565 do_spec_1 (multiarch_dir, 1, NULL);
5566 do_spec_1 (" ", 0, NULL);
5569 if (gcc_exec_prefix)
5571 do_spec_1 ("-iprefix", 1, NULL);
5572 /* Make this a separate argument. */
5573 do_spec_1 (" ", 0, NULL);
5574 do_spec_1 (gcc_exec_prefix, 1, NULL);
5575 do_spec_1 (" ", 0, NULL);
5578 if (target_system_root_changed ||
5579 (target_system_root && target_sysroot_hdrs_suffix))
5581 do_spec_1 ("-isysroot", 1, NULL);
5582 /* Make this a separate argument. */
5583 do_spec_1 (" ", 0, NULL);
5584 do_spec_1 (target_system_root, 1, NULL);
5585 if (target_sysroot_hdrs_suffix)
5586 do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL);
5587 do_spec_1 (" ", 0, NULL);
5590 info.option = "-isystem";
5591 info.append = "include";
5592 info.append_len = strlen (info.append);
5593 info.omit_relative = false;
5594 info.separate_options = true;
5596 for_each_path (&include_prefixes, false, info.append_len,
5597 spec_path, &info);
5599 info.append = "include-fixed";
5600 if (*sysroot_hdrs_suffix_spec)
5601 info.append = concat (info.append, dir_separator_str,
5602 multilib_dir, NULL);
5603 info.append_len = strlen (info.append);
5604 for_each_path (&include_prefixes, false, info.append_len,
5605 spec_path, &info);
5607 break;
5609 case 'o':
5611 int max = n_infiles;
5612 max += lang_specific_extra_outfiles;
5614 if (HAVE_GNU_LD && at_file_supplied)
5616 /* We are going to expand `%o' to `@FILE', where FILE
5617 is a newly-created temporary filename. The filenames
5618 that would usually be expanded in place of %o will be
5619 written to the temporary file. */
5621 char **argv;
5622 int n_files, j;
5624 /* Convert OUTFILES into a form suitable for writeargv. */
5626 /* Determine how many are non-NULL. */
5627 for (n_files = 0, i = 0; i < max; i++)
5628 n_files += outfiles[i] != NULL;
5630 argv = (char **) alloca (sizeof (char *) * (n_files + 1));
5632 /* Copy the strings over. */
5633 for (i = 0, j = 0; i < max; i++)
5634 if (outfiles[i])
5636 argv[j] = CONST_CAST (char *, outfiles[i]);
5637 j++;
5639 argv[j] = NULL;
5641 create_at_file (argv);
5643 else
5644 for (i = 0; i < max; i++)
5645 if (outfiles[i])
5646 store_arg (outfiles[i], 0, 0);
5647 break;
5650 case 'O':
5651 obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
5652 arg_going = 1;
5653 break;
5655 case 's':
5656 this_is_library_file = 1;
5657 break;
5659 case 'T':
5660 this_is_linker_script = 1;
5661 break;
5663 case 'V':
5664 outfiles[input_file_number] = NULL;
5665 break;
5667 case 'w':
5668 this_is_output_file = 1;
5669 break;
5671 case 'W':
5673 unsigned int cur_index = argbuf.length ();
5674 /* Handle the {...} following the %W. */
5675 if (*p != '{')
5676 fatal_error (input_location,
5677 "spec %qs has invalid %<%%W%c%>", spec, *p);
5678 p = handle_braces (p + 1);
5679 if (p == 0)
5680 return -1;
5681 end_going_arg ();
5682 /* If any args were output, mark the last one for deletion
5683 on failure. */
5684 if (argbuf.length () != cur_index)
5685 record_temp_file (argbuf.last (), 0, 1);
5686 break;
5689 /* %x{OPTION} records OPTION for %X to output. */
5690 case 'x':
5692 const char *p1 = p;
5693 char *string;
5694 char *opt;
5695 unsigned ix;
5697 /* Skip past the option value and make a copy. */
5698 if (*p != '{')
5699 fatal_error (input_location,
5700 "spec %qs has invalid %<%%x%c%>", spec, *p);
5701 while (*p++ != '}')
5703 string = save_string (p1 + 1, p - p1 - 2);
5705 /* See if we already recorded this option. */
5706 FOR_EACH_VEC_ELT (linker_options, ix, opt)
5707 if (! strcmp (string, opt))
5709 free (string);
5710 return 0;
5713 /* This option is new; add it. */
5714 add_linker_option (string, strlen (string));
5715 free (string);
5717 break;
5719 /* Dump out the options accumulated previously using %x. */
5720 case 'X':
5721 do_specs_vec (linker_options);
5722 break;
5724 /* Dump out the options accumulated previously using -Wa,. */
5725 case 'Y':
5726 do_specs_vec (assembler_options);
5727 break;
5729 /* Dump out the options accumulated previously using -Wp,. */
5730 case 'Z':
5731 do_specs_vec (preprocessor_options);
5732 break;
5734 /* Here are digits and numbers that just process
5735 a certain constant string as a spec. */
5737 case '1':
5738 value = do_spec_1 (cc1_spec, 0, NULL);
5739 if (value != 0)
5740 return value;
5741 break;
5743 case '2':
5744 value = do_spec_1 (cc1plus_spec, 0, NULL);
5745 if (value != 0)
5746 return value;
5747 break;
5749 case 'a':
5750 value = do_spec_1 (asm_spec, 0, NULL);
5751 if (value != 0)
5752 return value;
5753 break;
5755 case 'A':
5756 value = do_spec_1 (asm_final_spec, 0, NULL);
5757 if (value != 0)
5758 return value;
5759 break;
5761 case 'C':
5763 const char *const spec
5764 = (input_file_compiler->cpp_spec
5765 ? input_file_compiler->cpp_spec
5766 : cpp_spec);
5767 value = do_spec_1 (spec, 0, NULL);
5768 if (value != 0)
5769 return value;
5771 break;
5773 case 'E':
5774 value = do_spec_1 (endfile_spec, 0, NULL);
5775 if (value != 0)
5776 return value;
5777 break;
5779 case 'l':
5780 value = do_spec_1 (link_spec, 0, NULL);
5781 if (value != 0)
5782 return value;
5783 break;
5785 case 'L':
5786 value = do_spec_1 (lib_spec, 0, NULL);
5787 if (value != 0)
5788 return value;
5789 break;
5791 case 'M':
5792 if (multilib_os_dir == NULL)
5793 obstack_1grow (&obstack, '.');
5794 else
5795 obstack_grow (&obstack, multilib_os_dir,
5796 strlen (multilib_os_dir));
5797 break;
5799 case 'G':
5800 value = do_spec_1 (libgcc_spec, 0, NULL);
5801 if (value != 0)
5802 return value;
5803 break;
5805 case 'R':
5806 /* We assume there is a directory
5807 separator at the end of this string. */
5808 if (target_system_root)
5810 obstack_grow (&obstack, target_system_root,
5811 strlen (target_system_root));
5812 if (target_sysroot_suffix)
5813 obstack_grow (&obstack, target_sysroot_suffix,
5814 strlen (target_sysroot_suffix));
5816 break;
5818 case 'S':
5819 value = do_spec_1 (startfile_spec, 0, NULL);
5820 if (value != 0)
5821 return value;
5822 break;
5824 /* Here we define characters other than letters and digits. */
5826 case '{':
5827 p = handle_braces (p);
5828 if (p == 0)
5829 return -1;
5830 break;
5832 case ':':
5833 p = handle_spec_function (p, NULL);
5834 if (p == 0)
5835 return -1;
5836 break;
5838 case '%':
5839 obstack_1grow (&obstack, '%');
5840 break;
5842 case '.':
5844 unsigned len = 0;
5846 while (p[len] && p[len] != ' ' && p[len] != '%')
5847 len++;
5848 suffix_subst = save_string (p - 1, len + 1);
5849 p += len;
5851 break;
5853 /* Henceforth ignore the option(s) matching the pattern
5854 after the %<. */
5855 case '<':
5856 case '>':
5858 unsigned len = 0;
5859 int have_wildcard = 0;
5860 int i;
5861 int switch_option;
5863 if (c == '>')
5864 switch_option = SWITCH_IGNORE | SWITCH_KEEP_FOR_GCC;
5865 else
5866 switch_option = SWITCH_IGNORE;
5868 while (p[len] && p[len] != ' ' && p[len] != '\t')
5869 len++;
5871 if (p[len-1] == '*')
5872 have_wildcard = 1;
5874 for (i = 0; i < n_switches; i++)
5875 if (!strncmp (switches[i].part1, p, len - have_wildcard)
5876 && (have_wildcard || switches[i].part1[len] == '\0'))
5878 switches[i].live_cond |= switch_option;
5879 /* User switch be validated from validate_all_switches.
5880 when the definition is seen from the spec file.
5881 If not defined anywhere, will be rejected. */
5882 if (switches[i].known)
5883 switches[i].validated = true;
5886 p += len;
5888 break;
5890 case '*':
5891 if (soft_matched_part)
5893 if (soft_matched_part[0])
5894 do_spec_1 (soft_matched_part, 1, NULL);
5895 /* Only insert a space after the substitution if it is at the
5896 end of the current sequence. So if:
5898 "%{foo=*:bar%*}%{foo=*:one%*two}"
5900 matches -foo=hello then it will produce:
5902 barhello onehellotwo
5904 if (*p == 0 || *p == '}')
5905 do_spec_1 (" ", 0, NULL);
5907 else
5908 /* Catch the case where a spec string contains something like
5909 '%{foo:%*}'. i.e. there is no * in the pattern on the left
5910 hand side of the :. */
5911 error ("spec failure: %<%%*%> has not been initialized by pattern match");
5912 break;
5914 /* Process a string found as the value of a spec given by name.
5915 This feature allows individual machine descriptions
5916 to add and use their own specs. */
5917 case '(':
5919 const char *name = p;
5920 struct spec_list *sl;
5921 int len;
5923 /* The string after the S/P is the name of a spec that is to be
5924 processed. */
5925 while (*p && *p != ')')
5926 p++;
5928 /* See if it's in the list. */
5929 for (len = p - name, sl = specs; sl; sl = sl->next)
5930 if (sl->name_len == len && !strncmp (sl->name, name, len))
5932 name = *(sl->ptr_spec);
5933 #ifdef DEBUG_SPECS
5934 fnotice (stderr, "Processing spec (%s), which is '%s'\n",
5935 sl->name, name);
5936 #endif
5937 break;
5940 if (sl)
5942 value = do_spec_1 (name, 0, NULL);
5943 if (value != 0)
5944 return value;
5947 /* Discard the closing paren. */
5948 if (*p)
5949 p++;
5951 break;
5953 default:
5954 error ("spec failure: unrecognized spec option %qc", c);
5955 break;
5957 break;
5959 case '\\':
5960 /* Backslash: treat next character as ordinary. */
5961 c = *p++;
5963 /* Fall through. */
5964 default:
5965 /* Ordinary character: put it into the current argument. */
5966 obstack_1grow (&obstack, c);
5967 arg_going = 1;
5970 /* End of string. If we are processing a spec function, we need to
5971 end any pending argument. */
5972 if (processing_spec_function)
5973 end_going_arg ();
5975 return 0;
5978 /* Look up a spec function. */
5980 static const struct spec_function *
5981 lookup_spec_function (const char *name)
5983 const struct spec_function *sf;
5985 for (sf = static_spec_functions; sf->name != NULL; sf++)
5986 if (strcmp (sf->name, name) == 0)
5987 return sf;
5989 return NULL;
5992 /* Evaluate a spec function. */
5994 static const char *
5995 eval_spec_function (const char *func, const char *args)
5997 const struct spec_function *sf;
5998 const char *funcval;
6000 /* Saved spec processing context. */
6001 vec<const_char_p> save_argbuf;
6003 int save_arg_going;
6004 int save_delete_this_arg;
6005 int save_this_is_output_file;
6006 int save_this_is_library_file;
6007 int save_input_from_pipe;
6008 int save_this_is_linker_script;
6009 const char *save_suffix_subst;
6011 int save_growing_size;
6012 void *save_growing_value = NULL;
6014 sf = lookup_spec_function (func);
6015 if (sf == NULL)
6016 fatal_error (input_location, "unknown spec function %qs", func);
6018 /* Push the spec processing context. */
6019 save_argbuf = argbuf;
6021 save_arg_going = arg_going;
6022 save_delete_this_arg = delete_this_arg;
6023 save_this_is_output_file = this_is_output_file;
6024 save_this_is_library_file = this_is_library_file;
6025 save_this_is_linker_script = this_is_linker_script;
6026 save_input_from_pipe = input_from_pipe;
6027 save_suffix_subst = suffix_subst;
6029 /* If we have some object growing now, finalize it so the args and function
6030 eval proceed from a cleared context. This is needed to prevent the first
6031 constructed arg from mistakenly including the growing value. We'll push
6032 this value back on the obstack once the function evaluation is done, to
6033 restore a consistent processing context for our caller. This is fine as
6034 the address of growing objects isn't guaranteed to remain stable until
6035 they are finalized, and we expect this situation to be rare enough for
6036 the extra copy not to be an issue. */
6037 save_growing_size = obstack_object_size (&obstack);
6038 if (save_growing_size > 0)
6039 save_growing_value = obstack_finish (&obstack);
6041 /* Create a new spec processing context, and build the function
6042 arguments. */
6044 alloc_args ();
6045 if (do_spec_2 (args) < 0)
6046 fatal_error (input_location, "error in args to spec function %qs", func);
6048 /* argbuf_index is an index for the next argument to be inserted, and
6049 so contains the count of the args already inserted. */
6051 funcval = (*sf->func) (argbuf.length (),
6052 argbuf.address ());
6054 /* Pop the spec processing context. */
6055 argbuf.release ();
6056 argbuf = save_argbuf;
6058 arg_going = save_arg_going;
6059 delete_this_arg = save_delete_this_arg;
6060 this_is_output_file = save_this_is_output_file;
6061 this_is_library_file = save_this_is_library_file;
6062 this_is_linker_script = save_this_is_linker_script;
6063 input_from_pipe = save_input_from_pipe;
6064 suffix_subst = save_suffix_subst;
6066 if (save_growing_size > 0)
6067 obstack_grow (&obstack, save_growing_value, save_growing_size);
6069 return funcval;
6072 /* Handle a spec function call of the form:
6074 %:function(args)
6076 ARGS is processed as a spec in a separate context and split into an
6077 argument vector in the normal fashion. The function returns a string
6078 containing a spec which we then process in the caller's context, or
6079 NULL if no processing is required.
6081 If RETVAL_NONNULL is not NULL, then store a bool whether function
6082 returned non-NULL. */
6084 static const char *
6085 handle_spec_function (const char *p, bool *retval_nonnull)
6087 char *func, *args;
6088 const char *endp, *funcval;
6089 int count;
6091 processing_spec_function++;
6093 /* Get the function name. */
6094 for (endp = p; *endp != '\0'; endp++)
6096 if (*endp == '(') /* ) */
6097 break;
6098 /* Only allow [A-Za-z0-9], -, and _ in function names. */
6099 if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_'))
6100 fatal_error (input_location, "malformed spec function name");
6102 if (*endp != '(') /* ) */
6103 fatal_error (input_location, "no arguments for spec function");
6104 func = save_string (p, endp - p);
6105 p = ++endp;
6107 /* Get the arguments. */
6108 for (count = 0; *endp != '\0'; endp++)
6110 /* ( */
6111 if (*endp == ')')
6113 if (count == 0)
6114 break;
6115 count--;
6117 else if (*endp == '(') /* ) */
6118 count++;
6120 /* ( */
6121 if (*endp != ')')
6122 fatal_error (input_location, "malformed spec function arguments");
6123 args = save_string (p, endp - p);
6124 p = ++endp;
6126 /* p now points to just past the end of the spec function expression. */
6128 funcval = eval_spec_function (func, args);
6129 if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0)
6130 p = NULL;
6131 if (retval_nonnull)
6132 *retval_nonnull = funcval != NULL;
6134 free (func);
6135 free (args);
6137 processing_spec_function--;
6139 return p;
6142 /* Inline subroutine of handle_braces. Returns true if the current
6143 input suffix matches the atom bracketed by ATOM and END_ATOM. */
6144 static inline bool
6145 input_suffix_matches (const char *atom, const char *end_atom)
6147 return (input_suffix
6148 && !strncmp (input_suffix, atom, end_atom - atom)
6149 && input_suffix[end_atom - atom] == '\0');
6152 /* Subroutine of handle_braces. Returns true if the current
6153 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
6154 static bool
6155 input_spec_matches (const char *atom, const char *end_atom)
6157 return (input_file_compiler
6158 && input_file_compiler->suffix
6159 && input_file_compiler->suffix[0] != '\0'
6160 && !strncmp (input_file_compiler->suffix + 1, atom,
6161 end_atom - atom)
6162 && input_file_compiler->suffix[end_atom - atom + 1] == '\0');
6165 /* Subroutine of handle_braces. Returns true if a switch
6166 matching the atom bracketed by ATOM and END_ATOM appeared on the
6167 command line. */
6168 static bool
6169 switch_matches (const char *atom, const char *end_atom, int starred)
6171 int i;
6172 int len = end_atom - atom;
6173 int plen = starred ? len : -1;
6175 for (i = 0; i < n_switches; i++)
6176 if (!strncmp (switches[i].part1, atom, len)
6177 && (starred || switches[i].part1[len] == '\0')
6178 && check_live_switch (i, plen))
6179 return true;
6181 /* Check if a switch with separated form matching the atom.
6182 We check -D and -U switches. */
6183 else if (switches[i].args != 0)
6185 if ((*switches[i].part1 == 'D' || *switches[i].part1 == 'U')
6186 && *switches[i].part1 == atom[0])
6188 if (!strncmp (switches[i].args[0], &atom[1], len - 1)
6189 && (starred || (switches[i].part1[1] == '\0'
6190 && switches[i].args[0][len - 1] == '\0'))
6191 && check_live_switch (i, (starred ? 1 : -1)))
6192 return true;
6196 return false;
6199 /* Inline subroutine of handle_braces. Mark all of the switches which
6200 match ATOM (extends to END_ATOM; STARRED indicates whether there
6201 was a star after the atom) for later processing. */
6202 static inline void
6203 mark_matching_switches (const char *atom, const char *end_atom, int starred)
6205 int i;
6206 int len = end_atom - atom;
6207 int plen = starred ? len : -1;
6209 for (i = 0; i < n_switches; i++)
6210 if (!strncmp (switches[i].part1, atom, len)
6211 && (starred || switches[i].part1[len] == '\0')
6212 && check_live_switch (i, plen))
6213 switches[i].ordering = 1;
6216 /* Inline subroutine of handle_braces. Process all the currently
6217 marked switches through give_switch, and clear the marks. */
6218 static inline void
6219 process_marked_switches (void)
6221 int i;
6223 for (i = 0; i < n_switches; i++)
6224 if (switches[i].ordering == 1)
6226 switches[i].ordering = 0;
6227 give_switch (i, 0);
6231 /* Handle a %{ ... } construct. P points just inside the leading {.
6232 Returns a pointer one past the end of the brace block, or 0
6233 if we call do_spec_1 and that returns -1. */
6235 static const char *
6236 handle_braces (const char *p)
6238 const char *atom, *end_atom;
6239 const char *d_atom = NULL, *d_end_atom = NULL;
6240 const char *orig = p;
6242 bool a_is_suffix;
6243 bool a_is_spectype;
6244 bool a_is_starred;
6245 bool a_is_negated;
6246 bool a_matched;
6248 bool a_must_be_last = false;
6249 bool ordered_set = false;
6250 bool disjunct_set = false;
6251 bool disj_matched = false;
6252 bool disj_starred = true;
6253 bool n_way_choice = false;
6254 bool n_way_matched = false;
6256 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
6260 if (a_must_be_last)
6261 goto invalid;
6263 /* Scan one "atom" (S in the description above of %{}, possibly
6264 with '!', '.', '@', ',', or '*' modifiers). */
6265 a_matched = false;
6266 a_is_suffix = false;
6267 a_is_starred = false;
6268 a_is_negated = false;
6269 a_is_spectype = false;
6271 SKIP_WHITE ();
6272 if (*p == '!')
6273 p++, a_is_negated = true;
6275 SKIP_WHITE ();
6276 if (*p == '%' && p[1] == ':')
6278 atom = NULL;
6279 end_atom = NULL;
6280 p = handle_spec_function (p + 2, &a_matched);
6282 else
6284 if (*p == '.')
6285 p++, a_is_suffix = true;
6286 else if (*p == ',')
6287 p++, a_is_spectype = true;
6289 atom = p;
6290 while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
6291 || *p == ',' || *p == '.' || *p == '@')
6292 p++;
6293 end_atom = p;
6295 if (*p == '*')
6296 p++, a_is_starred = 1;
6299 SKIP_WHITE ();
6300 switch (*p)
6302 case '&': case '}':
6303 /* Substitute the switch(es) indicated by the current atom. */
6304 ordered_set = true;
6305 if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix
6306 || a_is_spectype || atom == end_atom)
6307 goto invalid;
6309 mark_matching_switches (atom, end_atom, a_is_starred);
6311 if (*p == '}')
6312 process_marked_switches ();
6313 break;
6315 case '|': case ':':
6316 /* Substitute some text if the current atom appears as a switch
6317 or suffix. */
6318 disjunct_set = true;
6319 if (ordered_set)
6320 goto invalid;
6322 if (atom && atom == end_atom)
6324 if (!n_way_choice || disj_matched || *p == '|'
6325 || a_is_negated || a_is_suffix || a_is_spectype
6326 || a_is_starred)
6327 goto invalid;
6329 /* An empty term may appear as the last choice of an
6330 N-way choice set; it means "otherwise". */
6331 a_must_be_last = true;
6332 disj_matched = !n_way_matched;
6333 disj_starred = false;
6335 else
6337 if ((a_is_suffix || a_is_spectype) && a_is_starred)
6338 goto invalid;
6340 if (!a_is_starred)
6341 disj_starred = false;
6343 /* Don't bother testing this atom if we already have a
6344 match. */
6345 if (!disj_matched && !n_way_matched)
6347 if (atom == NULL)
6348 /* a_matched is already set by handle_spec_function. */;
6349 else if (a_is_suffix)
6350 a_matched = input_suffix_matches (atom, end_atom);
6351 else if (a_is_spectype)
6352 a_matched = input_spec_matches (atom, end_atom);
6353 else
6354 a_matched = switch_matches (atom, end_atom, a_is_starred);
6356 if (a_matched != a_is_negated)
6358 disj_matched = true;
6359 d_atom = atom;
6360 d_end_atom = end_atom;
6365 if (*p == ':')
6367 /* Found the body, that is, the text to substitute if the
6368 current disjunction matches. */
6369 p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred,
6370 disj_matched && !n_way_matched);
6371 if (p == 0)
6372 return 0;
6374 /* If we have an N-way choice, reset state for the next
6375 disjunction. */
6376 if (*p == ';')
6378 n_way_choice = true;
6379 n_way_matched |= disj_matched;
6380 disj_matched = false;
6381 disj_starred = true;
6382 d_atom = d_end_atom = NULL;
6385 break;
6387 default:
6388 goto invalid;
6391 while (*p++ != '}');
6393 return p;
6395 invalid:
6396 fatal_error (input_location, "braced spec %qs is invalid at %qc", orig, *p);
6398 #undef SKIP_WHITE
6401 /* Subroutine of handle_braces. Scan and process a brace substitution body
6402 (X in the description of %{} syntax). P points one past the colon;
6403 ATOM and END_ATOM bracket the first atom which was found to be true
6404 (present) in the current disjunction; STARRED indicates whether all
6405 the atoms in the current disjunction were starred (for syntax validation);
6406 MATCHED indicates whether the disjunction matched or not, and therefore
6407 whether or not the body is to be processed through do_spec_1 or just
6408 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
6409 returns -1. */
6411 static const char *
6412 process_brace_body (const char *p, const char *atom, const char *end_atom,
6413 int starred, int matched)
6415 const char *body, *end_body;
6416 unsigned int nesting_level;
6417 bool have_subst = false;
6419 /* Locate the closing } or ;, honoring nested braces.
6420 Trim trailing whitespace. */
6421 body = p;
6422 nesting_level = 1;
6423 for (;;)
6425 if (*p == '{')
6426 nesting_level++;
6427 else if (*p == '}')
6429 if (!--nesting_level)
6430 break;
6432 else if (*p == ';' && nesting_level == 1)
6433 break;
6434 else if (*p == '%' && p[1] == '*' && nesting_level == 1)
6435 have_subst = true;
6436 else if (*p == '\0')
6437 goto invalid;
6438 p++;
6441 end_body = p;
6442 while (end_body[-1] == ' ' || end_body[-1] == '\t')
6443 end_body--;
6445 if (have_subst && !starred)
6446 goto invalid;
6448 if (matched)
6450 /* Copy the substitution body to permanent storage and execute it.
6451 If have_subst is false, this is a simple matter of running the
6452 body through do_spec_1... */
6453 char *string = save_string (body, end_body - body);
6454 if (!have_subst)
6456 if (do_spec_1 (string, 0, NULL) < 0)
6458 free (string);
6459 return 0;
6462 else
6464 /* ... but if have_subst is true, we have to process the
6465 body once for each matching switch, with %* set to the
6466 variant part of the switch. */
6467 unsigned int hard_match_len = end_atom - atom;
6468 int i;
6470 for (i = 0; i < n_switches; i++)
6471 if (!strncmp (switches[i].part1, atom, hard_match_len)
6472 && check_live_switch (i, hard_match_len))
6474 if (do_spec_1 (string, 0,
6475 &switches[i].part1[hard_match_len]) < 0)
6477 free (string);
6478 return 0;
6480 /* Pass any arguments this switch has. */
6481 give_switch (i, 1);
6482 suffix_subst = NULL;
6485 free (string);
6488 return p;
6490 invalid:
6491 fatal_error (input_location, "braced spec body %qs is invalid", body);
6494 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
6495 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
6496 spec, or -1 if either exact match or %* is used.
6498 A -O switch is obsoleted by a later -O switch. A -f, -g, -m, or -W switch
6499 whose value does not begin with "no-" is obsoleted by the same value
6500 with the "no-", similarly for a switch with the "no-" prefix. */
6502 static int
6503 check_live_switch (int switchnum, int prefix_length)
6505 const char *name = switches[switchnum].part1;
6506 int i;
6508 /* If we already processed this switch and determined if it was
6509 live or not, return our past determination. */
6510 if (switches[switchnum].live_cond != 0)
6511 return ((switches[switchnum].live_cond & SWITCH_LIVE) != 0
6512 && (switches[switchnum].live_cond & SWITCH_FALSE) == 0
6513 && (switches[switchnum].live_cond & SWITCH_IGNORE_PERMANENTLY)
6514 == 0);
6516 /* In the common case of {<at-most-one-letter>*}, a negating
6517 switch would always match, so ignore that case. We will just
6518 send the conflicting switches to the compiler phase. */
6519 if (prefix_length >= 0 && prefix_length <= 1)
6520 return 1;
6522 /* Now search for duplicate in a manner that depends on the name. */
6523 switch (*name)
6525 case 'O':
6526 for (i = switchnum + 1; i < n_switches; i++)
6527 if (switches[i].part1[0] == 'O')
6529 switches[switchnum].validated = true;
6530 switches[switchnum].live_cond = SWITCH_FALSE;
6531 return 0;
6533 break;
6535 case 'W': case 'f': case 'm': case 'g':
6536 if (! strncmp (name + 1, "no-", 3))
6538 /* We have Xno-YYY, search for XYYY. */
6539 for (i = switchnum + 1; i < n_switches; i++)
6540 if (switches[i].part1[0] == name[0]
6541 && ! strcmp (&switches[i].part1[1], &name[4]))
6543 /* --specs are validated with the validate_switches mechanism. */
6544 if (switches[switchnum].known)
6545 switches[switchnum].validated = true;
6546 switches[switchnum].live_cond = SWITCH_FALSE;
6547 return 0;
6550 else
6552 /* We have XYYY, search for Xno-YYY. */
6553 for (i = switchnum + 1; i < n_switches; i++)
6554 if (switches[i].part1[0] == name[0]
6555 && switches[i].part1[1] == 'n'
6556 && switches[i].part1[2] == 'o'
6557 && switches[i].part1[3] == '-'
6558 && !strcmp (&switches[i].part1[4], &name[1]))
6560 /* --specs are validated with the validate_switches mechanism. */
6561 if (switches[switchnum].known)
6562 switches[switchnum].validated = true;
6563 switches[switchnum].live_cond = SWITCH_FALSE;
6564 return 0;
6567 break;
6570 /* Otherwise the switch is live. */
6571 switches[switchnum].live_cond |= SWITCH_LIVE;
6572 return 1;
6575 /* Pass a switch to the current accumulating command
6576 in the same form that we received it.
6577 SWITCHNUM identifies the switch; it is an index into
6578 the vector of switches gcc received, which is `switches'.
6579 This cannot fail since it never finishes a command line.
6581 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
6583 static void
6584 give_switch (int switchnum, int omit_first_word)
6586 if ((switches[switchnum].live_cond & SWITCH_IGNORE) != 0)
6587 return;
6589 if (!omit_first_word)
6591 do_spec_1 ("-", 0, NULL);
6592 do_spec_1 (switches[switchnum].part1, 1, NULL);
6595 if (switches[switchnum].args != 0)
6597 const char **p;
6598 for (p = switches[switchnum].args; *p; p++)
6600 const char *arg = *p;
6602 do_spec_1 (" ", 0, NULL);
6603 if (suffix_subst)
6605 unsigned length = strlen (arg);
6606 int dot = 0;
6608 while (length-- && !IS_DIR_SEPARATOR (arg[length]))
6609 if (arg[length] == '.')
6611 (CONST_CAST (char *, arg))[length] = 0;
6612 dot = 1;
6613 break;
6615 do_spec_1 (arg, 1, NULL);
6616 if (dot)
6617 (CONST_CAST (char *, arg))[length] = '.';
6618 do_spec_1 (suffix_subst, 1, NULL);
6620 else
6621 do_spec_1 (arg, 1, NULL);
6625 do_spec_1 (" ", 0, NULL);
6626 switches[switchnum].validated = true;
6629 /* Print GCC configuration (e.g. version, thread model, target,
6630 configuration_arguments) to a given FILE. */
6632 static void
6633 print_configuration (FILE *file)
6635 int n;
6636 const char *thrmod;
6638 fnotice (file, "Target: %s\n", spec_machine);
6639 fnotice (file, "Configured with: %s\n", configuration_arguments);
6641 #ifdef THREAD_MODEL_SPEC
6642 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
6643 but there's no point in doing all this processing just to get
6644 thread_model back. */
6645 obstack_init (&obstack);
6646 do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model);
6647 obstack_1grow (&obstack, '\0');
6648 thrmod = XOBFINISH (&obstack, const char *);
6649 #else
6650 thrmod = thread_model;
6651 #endif
6653 fnotice (file, "Thread model: %s\n", thrmod);
6655 /* compiler_version is truncated at the first space when initialized
6656 from version string, so truncate version_string at the first space
6657 before comparing. */
6658 for (n = 0; version_string[n]; n++)
6659 if (version_string[n] == ' ')
6660 break;
6662 if (! strncmp (version_string, compiler_version, n)
6663 && compiler_version[n] == 0)
6664 fnotice (file, "gcc version %s %s\n", version_string,
6665 pkgversion_string);
6666 else
6667 fnotice (file, "gcc driver version %s %sexecuting gcc version %s\n",
6668 version_string, pkgversion_string, compiler_version);
6672 #define RETRY_ICE_ATTEMPTS 3
6674 /* Returns true if FILE1 and FILE2 contain equivalent data, 0 otherwise. */
6676 static bool
6677 files_equal_p (char *file1, char *file2)
6679 struct stat st1, st2;
6680 off_t n, len;
6681 int fd1, fd2;
6682 const int bufsize = 8192;
6683 char *buf = XNEWVEC (char, bufsize);
6685 fd1 = open (file1, O_RDONLY);
6686 fd2 = open (file2, O_RDONLY);
6688 if (fd1 < 0 || fd2 < 0)
6689 goto error;
6691 if (fstat (fd1, &st1) < 0 || fstat (fd2, &st2) < 0)
6692 goto error;
6694 if (st1.st_size != st2.st_size)
6695 goto error;
6697 for (n = st1.st_size; n; n -= len)
6699 len = n;
6700 if ((int) len > bufsize / 2)
6701 len = bufsize / 2;
6703 if (read (fd1, buf, len) != (int) len
6704 || read (fd2, buf + bufsize / 2, len) != (int) len)
6706 goto error;
6709 if (memcmp (buf, buf + bufsize / 2, len) != 0)
6710 goto error;
6713 free (buf);
6714 close (fd1);
6715 close (fd2);
6717 return 1;
6719 error:
6720 free (buf);
6721 close (fd1);
6722 close (fd2);
6723 return 0;
6726 /* Check that compiler's output doesn't differ across runs.
6727 TEMP_STDOUT_FILES and TEMP_STDERR_FILES are arrays of files, containing
6728 stdout and stderr for each compiler run. Return true if all of
6729 TEMP_STDOUT_FILES and TEMP_STDERR_FILES are equivalent. */
6731 static bool
6732 check_repro (char **temp_stdout_files, char **temp_stderr_files)
6734 int i;
6735 for (i = 0; i < RETRY_ICE_ATTEMPTS - 2; ++i)
6737 if (!files_equal_p (temp_stdout_files[i], temp_stdout_files[i + 1])
6738 || !files_equal_p (temp_stderr_files[i], temp_stderr_files[i + 1]))
6740 fnotice (stderr, "The bug is not reproducible, so it is"
6741 " likely a hardware or OS problem.\n");
6742 break;
6745 return i == RETRY_ICE_ATTEMPTS - 2;
6748 enum attempt_status {
6749 ATTEMPT_STATUS_FAIL_TO_RUN,
6750 ATTEMPT_STATUS_SUCCESS,
6751 ATTEMPT_STATUS_ICE
6755 /* Run compiler with arguments NEW_ARGV to reproduce the ICE, storing stdout
6756 to OUT_TEMP and stderr to ERR_TEMP. If APPEND is TRUE, append to OUT_TEMP
6757 and ERR_TEMP instead of truncating. If EMIT_SYSTEM_INFO is TRUE, also write
6758 GCC configuration into to ERR_TEMP. Return ATTEMPT_STATUS_FAIL_TO_RUN if
6759 compiler failed to run, ATTEMPT_STATUS_ICE if compiled ICE-ed and
6760 ATTEMPT_STATUS_SUCCESS otherwise. */
6762 static enum attempt_status
6763 run_attempt (const char **new_argv, const char *out_temp,
6764 const char *err_temp, int emit_system_info, int append)
6767 if (emit_system_info)
6769 FILE *file_out = fopen (err_temp, "a");
6770 print_configuration (file_out);
6771 fputs ("\n", file_out);
6772 fclose (file_out);
6775 int exit_status;
6776 const char *errmsg;
6777 struct pex_obj *pex;
6778 int err;
6779 int pex_flags = PEX_USE_PIPES | PEX_LAST;
6780 enum attempt_status status = ATTEMPT_STATUS_FAIL_TO_RUN;
6782 if (append)
6783 pex_flags |= PEX_STDOUT_APPEND | PEX_STDERR_APPEND;
6785 pex = pex_init (PEX_USE_PIPES, new_argv[0], NULL);
6786 if (!pex)
6787 fatal_error (input_location, "pex_init failed: %m");
6789 errmsg = pex_run (pex, pex_flags, new_argv[0],
6790 CONST_CAST2 (char *const *, const char **, &new_argv[1]), out_temp,
6791 err_temp, &err);
6792 if (errmsg != NULL)
6794 if (err == 0)
6795 fatal_error (input_location, errmsg);
6796 else
6798 errno = err;
6799 pfatal_with_name (errmsg);
6803 if (!pex_get_status (pex, 1, &exit_status))
6804 goto out;
6806 switch (WEXITSTATUS (exit_status))
6808 case ICE_EXIT_CODE:
6809 status = ATTEMPT_STATUS_ICE;
6810 break;
6812 case SUCCESS_EXIT_CODE:
6813 status = ATTEMPT_STATUS_SUCCESS;
6814 break;
6816 default:
6820 out:
6821 pex_free (pex);
6822 return status;
6825 /* This routine reads lines from IN file, adds C++ style comments
6826 at the begining of each line and writes result into OUT. */
6828 static void
6829 insert_comments (const char *file_in, const char *file_out)
6831 FILE *in = fopen (file_in, "rb");
6832 FILE *out = fopen (file_out, "wb");
6833 char line[256];
6835 bool add_comment = true;
6836 while (fgets (line, sizeof (line), in))
6838 if (add_comment)
6839 fputs ("// ", out);
6840 fputs (line, out);
6841 add_comment = strchr (line, '\n') != NULL;
6844 fclose (in);
6845 fclose (out);
6848 /* This routine adds preprocessed source code into the given ERR_FILE.
6849 To do this, it adds "-E" to NEW_ARGV and execute RUN_ATTEMPT routine to
6850 add information in report file. RUN_ATTEMPT should return
6851 ATTEMPT_STATUS_SUCCESS, in other case we cannot generate the report. */
6853 static void
6854 do_report_bug (const char **new_argv, const int nargs,
6855 char **out_file, char **err_file)
6857 int i, status;
6858 int fd = open (*out_file, O_RDWR | O_APPEND);
6859 if (fd < 0)
6860 return;
6861 write (fd, "\n//", 3);
6862 for (i = 0; i < nargs; i++)
6864 write (fd, " ", 1);
6865 write (fd, new_argv[i], strlen (new_argv[i]));
6867 write (fd, "\n\n", 2);
6868 close (fd);
6869 new_argv[nargs] = "-E";
6870 new_argv[nargs + 1] = NULL;
6872 status = run_attempt (new_argv, *out_file, *err_file, 0, 1);
6874 if (status == ATTEMPT_STATUS_SUCCESS)
6876 fnotice (stderr, "Preprocessed source stored into %s file,"
6877 " please attach this to your bugreport.\n", *out_file);
6878 /* Make sure it is not deleted. */
6879 free (*out_file);
6880 *out_file = NULL;
6884 /* Try to reproduce ICE. If bug is reproducible, generate report .err file
6885 containing GCC configuration, backtrace, compiler's command line options
6886 and preprocessed source code. */
6888 static void
6889 try_generate_repro (const char **argv)
6891 int i, nargs, out_arg = -1, quiet = 0, attempt;
6892 const char **new_argv;
6893 char *temp_files[RETRY_ICE_ATTEMPTS * 2];
6894 char **temp_stdout_files = &temp_files[0];
6895 char **temp_stderr_files = &temp_files[RETRY_ICE_ATTEMPTS];
6897 if (gcc_input_filename == NULL || ! strcmp (gcc_input_filename, "-"))
6898 return;
6900 for (nargs = 0; argv[nargs] != NULL; ++nargs)
6901 /* Only retry compiler ICEs, not preprocessor ones. */
6902 if (! strcmp (argv[nargs], "-E"))
6903 return;
6904 else if (argv[nargs][0] == '-' && argv[nargs][1] == 'o')
6906 if (out_arg == -1)
6907 out_arg = nargs;
6908 else
6909 return;
6911 /* If the compiler is going to output any time information,
6912 it might varry between invocations. */
6913 else if (! strcmp (argv[nargs], "-quiet"))
6914 quiet = 1;
6915 else if (! strcmp (argv[nargs], "-ftime-report"))
6916 return;
6918 if (out_arg == -1 || !quiet)
6919 return;
6921 memset (temp_files, '\0', sizeof (temp_files));
6922 new_argv = XALLOCAVEC (const char *, nargs + 4);
6923 memcpy (new_argv, argv, (nargs + 1) * sizeof (const char *));
6924 new_argv[nargs++] = "-frandom-seed=0";
6925 new_argv[nargs++] = "-fdump-noaddr";
6926 new_argv[nargs] = NULL;
6927 if (new_argv[out_arg][2] == '\0')
6928 new_argv[out_arg + 1] = "-";
6929 else
6930 new_argv[out_arg] = "-o-";
6932 int status;
6933 for (attempt = 0; attempt < RETRY_ICE_ATTEMPTS; ++attempt)
6935 int emit_system_info = 0;
6936 int append = 0;
6937 temp_stdout_files[attempt] = make_temp_file (".out");
6938 temp_stderr_files[attempt] = make_temp_file (".err");
6940 if (attempt == RETRY_ICE_ATTEMPTS - 1)
6942 append = 1;
6943 emit_system_info = 1;
6946 status = run_attempt (new_argv, temp_stdout_files[attempt],
6947 temp_stderr_files[attempt], emit_system_info,
6948 append);
6950 if (status != ATTEMPT_STATUS_ICE)
6952 fnotice (stderr, "The bug is not reproducible, so it is"
6953 " likely a hardware or OS problem.\n");
6954 goto out;
6958 if (!check_repro (temp_stdout_files, temp_stderr_files))
6959 goto out;
6962 /* Insert commented out backtrace into report file. */
6963 char **stderr_commented = &temp_stdout_files[RETRY_ICE_ATTEMPTS - 1];
6964 insert_comments (temp_stderr_files[RETRY_ICE_ATTEMPTS - 1],
6965 *stderr_commented);
6967 /* In final attempt we append compiler options and preprocesssed code to last
6968 generated .out file with configuration and backtrace. */
6969 char **output = &temp_stdout_files[RETRY_ICE_ATTEMPTS - 1];
6970 do_report_bug (new_argv, nargs, stderr_commented, output);
6973 out:
6974 for (i = 0; i < RETRY_ICE_ATTEMPTS * 2; i++)
6975 if (temp_files[i])
6977 unlink (temp_stdout_files[i]);
6978 free (temp_stdout_files[i]);
6982 /* Search for a file named NAME trying various prefixes including the
6983 user's -B prefix and some standard ones.
6984 Return the absolute file name found. If nothing is found, return NAME. */
6986 static const char *
6987 find_file (const char *name)
6989 char *newname = find_a_file (&startfile_prefixes, name, R_OK, true);
6990 return newname ? newname : name;
6993 /* Determine whether a directory exists. If LINKER, return 0 for
6994 certain fixed names not needed by the linker. */
6996 static int
6997 is_directory (const char *path1, bool linker)
6999 int len1;
7000 char *path;
7001 char *cp;
7002 struct stat st;
7004 /* Ensure the string ends with "/.". The resulting path will be a
7005 directory even if the given path is a symbolic link. */
7006 len1 = strlen (path1);
7007 path = (char *) alloca (3 + len1);
7008 memcpy (path, path1, len1);
7009 cp = path + len1;
7010 if (!IS_DIR_SEPARATOR (cp[-1]))
7011 *cp++ = DIR_SEPARATOR;
7012 *cp++ = '.';
7013 *cp = '\0';
7015 /* Exclude directories that the linker is known to search. */
7016 if (linker
7017 && IS_DIR_SEPARATOR (path[0])
7018 && ((cp - path == 6
7019 && filename_ncmp (path + 1, "lib", 3) == 0)
7020 || (cp - path == 10
7021 && filename_ncmp (path + 1, "usr", 3) == 0
7022 && IS_DIR_SEPARATOR (path[4])
7023 && filename_ncmp (path + 5, "lib", 3) == 0)))
7024 return 0;
7026 return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
7029 /* Set up the various global variables to indicate that we're processing
7030 the input file named FILENAME. */
7032 void
7033 set_input (const char *filename)
7035 const char *p;
7037 gcc_input_filename = filename;
7038 input_filename_length = strlen (gcc_input_filename);
7039 input_basename = lbasename (gcc_input_filename);
7041 /* Find a suffix starting with the last period,
7042 and set basename_length to exclude that suffix. */
7043 basename_length = strlen (input_basename);
7044 suffixed_basename_length = basename_length;
7045 p = input_basename + basename_length;
7046 while (p != input_basename && *p != '.')
7047 --p;
7048 if (*p == '.' && p != input_basename)
7050 basename_length = p - input_basename;
7051 input_suffix = p + 1;
7053 else
7054 input_suffix = "";
7056 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
7057 we will need to do a stat on the gcc_input_filename. The
7058 INPUT_STAT_SET signals that the stat is needed. */
7059 input_stat_set = 0;
7062 /* On fatal signals, delete all the temporary files. */
7064 static void
7065 fatal_signal (int signum)
7067 signal (signum, SIG_DFL);
7068 delete_failure_queue ();
7069 delete_temp_files ();
7070 /* Get the same signal again, this time not handled,
7071 so its normal effect occurs. */
7072 kill (getpid (), signum);
7075 /* Compare the contents of the two files named CMPFILE[0] and
7076 CMPFILE[1]. Return zero if they're identical, nonzero
7077 otherwise. */
7079 static int
7080 compare_files (char *cmpfile[])
7082 int ret = 0;
7083 FILE *temp[2] = { NULL, NULL };
7084 int i;
7086 #if HAVE_MMAP_FILE
7088 size_t length[2];
7089 void *map[2] = { NULL, NULL };
7091 for (i = 0; i < 2; i++)
7093 struct stat st;
7095 if (stat (cmpfile[i], &st) < 0 || !S_ISREG (st.st_mode))
7097 error ("%s: could not determine length of compare-debug file %s",
7098 gcc_input_filename, cmpfile[i]);
7099 ret = 1;
7100 break;
7103 length[i] = st.st_size;
7106 if (!ret && length[0] != length[1])
7108 error ("%s: -fcompare-debug failure (length)", gcc_input_filename);
7109 ret = 1;
7112 if (!ret)
7113 for (i = 0; i < 2; i++)
7115 int fd = open (cmpfile[i], O_RDONLY);
7116 if (fd < 0)
7118 error ("%s: could not open compare-debug file %s",
7119 gcc_input_filename, cmpfile[i]);
7120 ret = 1;
7121 break;
7124 map[i] = mmap (NULL, length[i], PROT_READ, MAP_PRIVATE, fd, 0);
7125 close (fd);
7127 if (map[i] == (void *) MAP_FAILED)
7129 ret = -1;
7130 break;
7134 if (!ret)
7136 if (memcmp (map[0], map[1], length[0]) != 0)
7138 error ("%s: -fcompare-debug failure", gcc_input_filename);
7139 ret = 1;
7143 for (i = 0; i < 2; i++)
7144 if (map[i])
7145 munmap ((caddr_t) map[i], length[i]);
7147 if (ret >= 0)
7148 return ret;
7150 ret = 0;
7152 #endif
7154 for (i = 0; i < 2; i++)
7156 temp[i] = fopen (cmpfile[i], "r");
7157 if (!temp[i])
7159 error ("%s: could not open compare-debug file %s",
7160 gcc_input_filename, cmpfile[i]);
7161 ret = 1;
7162 break;
7166 if (!ret && temp[0] && temp[1])
7167 for (;;)
7169 int c0, c1;
7170 c0 = fgetc (temp[0]);
7171 c1 = fgetc (temp[1]);
7173 if (c0 != c1)
7175 error ("%s: -fcompare-debug failure",
7176 gcc_input_filename);
7177 ret = 1;
7178 break;
7181 if (c0 == EOF)
7182 break;
7185 for (i = 1; i >= 0; i--)
7187 if (temp[i])
7188 fclose (temp[i]);
7191 return ret;
7194 driver::driver (bool can_finalize, bool debug) :
7195 explicit_link_files (NULL),
7196 decoded_options (NULL),
7197 m_option_suggestions (NULL)
7199 env.init (can_finalize, debug);
7202 driver::~driver ()
7204 XDELETEVEC (explicit_link_files);
7205 XDELETEVEC (decoded_options);
7206 if (m_option_suggestions)
7208 int i;
7209 char *str;
7210 FOR_EACH_VEC_ELT (*m_option_suggestions, i, str)
7211 free (str);
7212 delete m_option_suggestions;
7216 /* driver::main is implemented as a series of driver:: method calls. */
7219 driver::main (int argc, char **argv)
7221 bool early_exit;
7223 set_progname (argv[0]);
7224 expand_at_files (&argc, &argv);
7225 decode_argv (argc, const_cast <const char **> (argv));
7226 global_initializations ();
7227 build_multilib_strings ();
7228 set_up_specs ();
7229 putenv_COLLECT_GCC (argv[0]);
7230 maybe_putenv_COLLECT_LTO_WRAPPER ();
7231 maybe_putenv_OFFLOAD_TARGETS ();
7232 handle_unrecognized_options ();
7234 if (!maybe_print_and_exit ())
7235 return 0;
7237 early_exit = prepare_infiles ();
7238 if (early_exit)
7239 return get_exit_code ();
7241 do_spec_on_infiles ();
7242 maybe_run_linker (argv[0]);
7243 final_actions ();
7244 return get_exit_code ();
7247 /* Locate the final component of argv[0] after any leading path, and set
7248 the program name accordingly. */
7250 void
7251 driver::set_progname (const char *argv0) const
7253 const char *p = argv0 + strlen (argv0);
7254 while (p != argv0 && !IS_DIR_SEPARATOR (p[-1]))
7255 --p;
7256 progname = p;
7258 xmalloc_set_program_name (progname);
7261 /* Expand any @ files within the command-line args,
7262 setting at_file_supplied if any were expanded. */
7264 void
7265 driver::expand_at_files (int *argc, char ***argv) const
7267 char **old_argv = *argv;
7269 expandargv (argc, argv);
7271 /* Determine if any expansions were made. */
7272 if (*argv != old_argv)
7273 at_file_supplied = true;
7276 /* Decode the command-line arguments from argc/argv into the
7277 decoded_options array. */
7279 void
7280 driver::decode_argv (int argc, const char **argv)
7282 /* Register the language-independent parameters. */
7283 global_init_params ();
7284 finish_params ();
7286 init_opts_obstack ();
7287 init_options_struct (&global_options, &global_options_set);
7289 decode_cmdline_options_to_array (argc, argv,
7290 CL_DRIVER,
7291 &decoded_options, &decoded_options_count);
7294 /* Perform various initializations and setup. */
7296 void
7297 driver::global_initializations ()
7299 /* Unlock the stdio streams. */
7300 unlock_std_streams ();
7302 gcc_init_libintl ();
7304 diagnostic_initialize (global_dc, 0);
7305 diagnostic_color_init (global_dc);
7307 #ifdef GCC_DRIVER_HOST_INITIALIZATION
7308 /* Perform host dependent initialization when needed. */
7309 GCC_DRIVER_HOST_INITIALIZATION;
7310 #endif
7312 if (atexit (delete_temp_files) != 0)
7313 fatal_error (input_location, "atexit failed");
7315 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
7316 signal (SIGINT, fatal_signal);
7317 #ifdef SIGHUP
7318 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
7319 signal (SIGHUP, fatal_signal);
7320 #endif
7321 if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
7322 signal (SIGTERM, fatal_signal);
7323 #ifdef SIGPIPE
7324 if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
7325 signal (SIGPIPE, fatal_signal);
7326 #endif
7327 #ifdef SIGCHLD
7328 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
7329 receive the signal. A different setting is inheritable */
7330 signal (SIGCHLD, SIG_DFL);
7331 #endif
7333 /* Parsing and gimplification sometimes need quite large stack.
7334 Increase stack size limits if possible. */
7335 stack_limit_increase (64 * 1024 * 1024);
7337 /* Allocate the argument vector. */
7338 alloc_args ();
7340 obstack_init (&obstack);
7343 /* Build multilib_select, et. al from the separate lines that make up each
7344 multilib selection. */
7346 void
7347 driver::build_multilib_strings () const
7350 const char *p;
7351 const char *const *q = multilib_raw;
7352 int need_space;
7354 obstack_init (&multilib_obstack);
7355 while ((p = *q++) != (char *) 0)
7356 obstack_grow (&multilib_obstack, p, strlen (p));
7358 obstack_1grow (&multilib_obstack, 0);
7359 multilib_select = XOBFINISH (&multilib_obstack, const char *);
7361 q = multilib_matches_raw;
7362 while ((p = *q++) != (char *) 0)
7363 obstack_grow (&multilib_obstack, p, strlen (p));
7365 obstack_1grow (&multilib_obstack, 0);
7366 multilib_matches = XOBFINISH (&multilib_obstack, const char *);
7368 q = multilib_exclusions_raw;
7369 while ((p = *q++) != (char *) 0)
7370 obstack_grow (&multilib_obstack, p, strlen (p));
7372 obstack_1grow (&multilib_obstack, 0);
7373 multilib_exclusions = XOBFINISH (&multilib_obstack, const char *);
7375 q = multilib_reuse_raw;
7376 while ((p = *q++) != (char *) 0)
7377 obstack_grow (&multilib_obstack, p, strlen (p));
7379 obstack_1grow (&multilib_obstack, 0);
7380 multilib_reuse = XOBFINISH (&multilib_obstack, const char *);
7382 need_space = FALSE;
7383 for (size_t i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++)
7385 if (need_space)
7386 obstack_1grow (&multilib_obstack, ' ');
7387 obstack_grow (&multilib_obstack,
7388 multilib_defaults_raw[i],
7389 strlen (multilib_defaults_raw[i]));
7390 need_space = TRUE;
7393 obstack_1grow (&multilib_obstack, 0);
7394 multilib_defaults = XOBFINISH (&multilib_obstack, const char *);
7398 /* Set up the spec-handling machinery. */
7400 void
7401 driver::set_up_specs () const
7403 const char *spec_machine_suffix;
7404 char *specs_file;
7405 size_t i;
7407 #ifdef INIT_ENVIRONMENT
7408 /* Set up any other necessary machine specific environment variables. */
7409 xputenv (INIT_ENVIRONMENT);
7410 #endif
7412 /* Make a table of what switches there are (switches, n_switches).
7413 Make a table of specified input files (infiles, n_infiles).
7414 Decode switches that are handled locally. */
7416 process_command (decoded_options_count, decoded_options);
7418 /* Initialize the vector of specs to just the default.
7419 This means one element containing 0s, as a terminator. */
7421 compilers = XNEWVAR (struct compiler, sizeof default_compilers);
7422 memcpy (compilers, default_compilers, sizeof default_compilers);
7423 n_compilers = n_default_compilers;
7425 /* Read specs from a file if there is one. */
7427 machine_suffix = concat (spec_host_machine, dir_separator_str, spec_version,
7428 accel_dir_suffix, dir_separator_str, NULL);
7429 just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
7431 specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, true);
7432 /* Read the specs file unless it is a default one. */
7433 if (specs_file != 0 && strcmp (specs_file, "specs"))
7434 read_specs (specs_file, true, false);
7435 else
7436 init_spec ();
7438 #ifdef ACCEL_COMPILER
7439 spec_machine_suffix = machine_suffix;
7440 #else
7441 spec_machine_suffix = just_machine_suffix;
7442 #endif
7444 /* We need to check standard_exec_prefix/spec_machine_suffix/specs
7445 for any override of as, ld and libraries. */
7446 specs_file = (char *) alloca (strlen (standard_exec_prefix)
7447 + strlen (spec_machine_suffix) + sizeof ("specs"));
7448 strcpy (specs_file, standard_exec_prefix);
7449 strcat (specs_file, spec_machine_suffix);
7450 strcat (specs_file, "specs");
7451 if (access (specs_file, R_OK) == 0)
7452 read_specs (specs_file, true, false);
7454 /* Process any configure-time defaults specified for the command line
7455 options, via OPTION_DEFAULT_SPECS. */
7456 for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
7457 do_option_spec (option_default_specs[i].name,
7458 option_default_specs[i].spec);
7460 /* Process DRIVER_SELF_SPECS, adding any new options to the end
7461 of the command line. */
7463 for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++)
7464 do_self_spec (driver_self_specs[i]);
7466 /* If not cross-compiling, look for executables in the standard
7467 places. */
7468 if (*cross_compile == '0')
7470 if (*md_exec_prefix)
7472 add_prefix (&exec_prefixes, md_exec_prefix, "GCC",
7473 PREFIX_PRIORITY_LAST, 0, 0);
7477 /* Process sysroot_suffix_spec. */
7478 if (*sysroot_suffix_spec != 0
7479 && !no_sysroot_suffix
7480 && do_spec_2 (sysroot_suffix_spec) == 0)
7482 if (argbuf.length () > 1)
7483 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
7484 else if (argbuf.length () == 1)
7485 target_sysroot_suffix = xstrdup (argbuf.last ());
7488 #ifdef HAVE_LD_SYSROOT
7489 /* Pass the --sysroot option to the linker, if it supports that. If
7490 there is a sysroot_suffix_spec, it has already been processed by
7491 this point, so target_system_root really is the system root we
7492 should be using. */
7493 if (target_system_root)
7495 obstack_grow (&obstack, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
7496 obstack_grow0 (&obstack, link_spec, strlen (link_spec));
7497 set_spec ("link", XOBFINISH (&obstack, const char *), false);
7499 #endif
7501 /* Process sysroot_hdrs_suffix_spec. */
7502 if (*sysroot_hdrs_suffix_spec != 0
7503 && !no_sysroot_suffix
7504 && do_spec_2 (sysroot_hdrs_suffix_spec) == 0)
7506 if (argbuf.length () > 1)
7507 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
7508 else if (argbuf.length () == 1)
7509 target_sysroot_hdrs_suffix = xstrdup (argbuf.last ());
7512 /* Look for startfiles in the standard places. */
7513 if (*startfile_prefix_spec != 0
7514 && do_spec_2 (startfile_prefix_spec) == 0
7515 && do_spec_1 (" ", 0, NULL) == 0)
7517 const char *arg;
7518 int ndx;
7519 FOR_EACH_VEC_ELT (argbuf, ndx, arg)
7520 add_sysrooted_prefix (&startfile_prefixes, arg, "BINUTILS",
7521 PREFIX_PRIORITY_LAST, 0, 1);
7523 /* We should eventually get rid of all these and stick to
7524 startfile_prefix_spec exclusively. */
7525 else if (*cross_compile == '0' || target_system_root)
7527 if (*md_startfile_prefix)
7528 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix,
7529 "GCC", PREFIX_PRIORITY_LAST, 0, 1);
7531 if (*md_startfile_prefix_1)
7532 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix_1,
7533 "GCC", PREFIX_PRIORITY_LAST, 0, 1);
7535 /* If standard_startfile_prefix is relative, base it on
7536 standard_exec_prefix. This lets us move the installed tree
7537 as a unit. If GCC_EXEC_PREFIX is defined, base
7538 standard_startfile_prefix on that as well.
7540 If the prefix is relative, only search it for native compilers;
7541 otherwise we will search a directory containing host libraries. */
7542 if (IS_ABSOLUTE_PATH (standard_startfile_prefix))
7543 add_sysrooted_prefix (&startfile_prefixes,
7544 standard_startfile_prefix, "BINUTILS",
7545 PREFIX_PRIORITY_LAST, 0, 1);
7546 else if (*cross_compile == '0')
7548 add_prefix (&startfile_prefixes,
7549 concat (gcc_exec_prefix
7550 ? gcc_exec_prefix : standard_exec_prefix,
7551 machine_suffix,
7552 standard_startfile_prefix, NULL),
7553 NULL, PREFIX_PRIORITY_LAST, 0, 1);
7556 /* Sysrooted prefixes are relocated because target_system_root is
7557 also relocated by gcc_exec_prefix. */
7558 if (*standard_startfile_prefix_1)
7559 add_sysrooted_prefix (&startfile_prefixes,
7560 standard_startfile_prefix_1, "BINUTILS",
7561 PREFIX_PRIORITY_LAST, 0, 1);
7562 if (*standard_startfile_prefix_2)
7563 add_sysrooted_prefix (&startfile_prefixes,
7564 standard_startfile_prefix_2, "BINUTILS",
7565 PREFIX_PRIORITY_LAST, 0, 1);
7568 /* Process any user specified specs in the order given on the command
7569 line. */
7570 for (struct user_specs *uptr = user_specs_head; uptr; uptr = uptr->next)
7572 char *filename = find_a_file (&startfile_prefixes, uptr->filename,
7573 R_OK, true);
7574 read_specs (filename ? filename : uptr->filename, false, true);
7577 /* Process any user self specs. */
7579 struct spec_list *sl;
7580 for (sl = specs; sl; sl = sl->next)
7581 if (sl->name_len == sizeof "self_spec" - 1
7582 && !strcmp (sl->name, "self_spec"))
7583 do_self_spec (*sl->ptr_spec);
7586 if (compare_debug)
7588 enum save_temps save;
7590 if (!compare_debug_second)
7592 n_switches_debug_check[1] = n_switches;
7593 n_switches_alloc_debug_check[1] = n_switches_alloc;
7594 switches_debug_check[1] = XDUPVEC (struct switchstr, switches,
7595 n_switches_alloc);
7597 do_self_spec ("%:compare-debug-self-opt()");
7598 n_switches_debug_check[0] = n_switches;
7599 n_switches_alloc_debug_check[0] = n_switches_alloc;
7600 switches_debug_check[0] = switches;
7602 n_switches = n_switches_debug_check[1];
7603 n_switches_alloc = n_switches_alloc_debug_check[1];
7604 switches = switches_debug_check[1];
7607 /* Avoid crash when computing %j in this early. */
7608 save = save_temps_flag;
7609 save_temps_flag = SAVE_TEMPS_NONE;
7611 compare_debug = -compare_debug;
7612 do_self_spec ("%:compare-debug-self-opt()");
7614 save_temps_flag = save;
7616 if (!compare_debug_second)
7618 n_switches_debug_check[1] = n_switches;
7619 n_switches_alloc_debug_check[1] = n_switches_alloc;
7620 switches_debug_check[1] = switches;
7621 compare_debug = -compare_debug;
7622 n_switches = n_switches_debug_check[0];
7623 n_switches_alloc = n_switches_debug_check[0];
7624 switches = switches_debug_check[0];
7629 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
7630 if (gcc_exec_prefix)
7631 gcc_exec_prefix = concat (gcc_exec_prefix, spec_host_machine,
7632 dir_separator_str, spec_version,
7633 accel_dir_suffix, dir_separator_str, NULL);
7635 /* Now we have the specs.
7636 Set the `valid' bits for switches that match anything in any spec. */
7638 validate_all_switches ();
7640 /* Now that we have the switches and the specs, set
7641 the subdirectory based on the options. */
7642 set_multilib_dir ();
7645 /* Set up to remember the pathname of gcc and any options
7646 needed for collect. We use argv[0] instead of progname because
7647 we need the complete pathname. */
7649 void
7650 driver::putenv_COLLECT_GCC (const char *argv0) const
7652 obstack_init (&collect_obstack);
7653 obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
7654 obstack_grow (&collect_obstack, argv0, strlen (argv0) + 1);
7655 xputenv (XOBFINISH (&collect_obstack, char *));
7658 /* Set up to remember the pathname of the lto wrapper. */
7660 void
7661 driver::maybe_putenv_COLLECT_LTO_WRAPPER () const
7663 char *lto_wrapper_file;
7665 if (have_c)
7666 lto_wrapper_file = NULL;
7667 else
7668 lto_wrapper_file = find_a_file (&exec_prefixes, "lto-wrapper",
7669 X_OK, false);
7670 if (lto_wrapper_file)
7672 lto_wrapper_file = convert_white_space (lto_wrapper_file);
7673 lto_wrapper_spec = lto_wrapper_file;
7674 obstack_init (&collect_obstack);
7675 obstack_grow (&collect_obstack, "COLLECT_LTO_WRAPPER=",
7676 sizeof ("COLLECT_LTO_WRAPPER=") - 1);
7677 obstack_grow (&collect_obstack, lto_wrapper_spec,
7678 strlen (lto_wrapper_spec) + 1);
7679 xputenv (XOBFINISH (&collect_obstack, char *));
7684 /* Set up to remember the names of offload targets. */
7686 void
7687 driver::maybe_putenv_OFFLOAD_TARGETS () const
7689 if (offload_targets && offload_targets[0] != '\0')
7691 obstack_grow (&collect_obstack, "OFFLOAD_TARGET_NAMES=",
7692 sizeof ("OFFLOAD_TARGET_NAMES=") - 1);
7693 obstack_grow (&collect_obstack, offload_targets,
7694 strlen (offload_targets) + 1);
7695 xputenv (XOBFINISH (&collect_obstack, char *));
7698 free (offload_targets);
7699 offload_targets = NULL;
7702 /* Helper function for driver::suggest_option. Populate
7703 m_option_suggestions with candidate strings for misspelled options.
7704 The strings will be freed by the driver's dtor. */
7706 void
7707 driver::build_option_suggestions (void)
7709 gcc_assert (m_option_suggestions == NULL);
7710 m_option_suggestions = new auto_vec <char *> ();
7712 /* We build a vec of m_option_suggestions, using add_misspelling_candidates
7713 to add copies of strings, without a leading dash. */
7715 for (unsigned int i = 0; i < cl_options_count; i++)
7717 const struct cl_option *option = &cl_options[i];
7718 const char *opt_text = option->opt_text;
7719 switch (i)
7721 default:
7722 if (option->var_type == CLVC_ENUM)
7724 const struct cl_enum *e = &cl_enums[option->var_enum];
7725 for (unsigned j = 0; e->values[j].arg != NULL; j++)
7727 char *with_arg = concat (opt_text, e->values[j].arg, NULL);
7728 add_misspelling_candidates (m_option_suggestions, option,
7729 with_arg);
7730 free (with_arg);
7733 else
7734 add_misspelling_candidates (m_option_suggestions, option,
7735 opt_text);
7736 break;
7738 case OPT_fsanitize_:
7739 case OPT_fsanitize_recover_:
7740 /* -fsanitize= and -fsanitize-recover= can take
7741 a comma-separated list of arguments. Given that combinations
7742 are supported, we can't add all potential candidates to the
7743 vec, but if we at least add them individually without commas,
7744 we should do a better job e.g. correcting
7745 "-sanitize=address"
7747 "-fsanitize=address"
7748 rather than to "-Wframe-address" (PR driver/69265). */
7750 for (int j = 0; sanitizer_opts[j].name != NULL; ++j)
7752 struct cl_option optb;
7753 /* -fsanitize=all is not valid, only -fno-sanitize=all.
7754 So don't register the positive misspelling candidates
7755 for it. */
7756 if (sanitizer_opts[j].flag == ~0U && i == OPT_fsanitize_)
7758 optb = *option;
7759 optb.opt_text = opt_text = "-fno-sanitize=";
7760 optb.cl_reject_negative = true;
7761 option = &optb;
7763 /* Get one arg at a time e.g. "-fsanitize=address". */
7764 char *with_arg = concat (opt_text,
7765 sanitizer_opts[j].name,
7766 NULL);
7767 /* Add with_arg and all of its variant spellings e.g.
7768 "-fno-sanitize=address" to candidates (albeit without
7769 leading dashes). */
7770 add_misspelling_candidates (m_option_suggestions, option,
7771 with_arg);
7772 free (with_arg);
7775 break;
7780 /* Helper function for driver::handle_unrecognized_options.
7782 Given an unrecognized option BAD_OPT (without the leading dash),
7783 locate the closest reasonable matching option (again, without the
7784 leading dash), or NULL.
7786 The returned string is owned by the driver instance. */
7788 const char *
7789 driver::suggest_option (const char *bad_opt)
7791 /* Lazily populate m_option_suggestions. */
7792 if (!m_option_suggestions)
7793 build_option_suggestions ();
7794 gcc_assert (m_option_suggestions);
7796 /* "m_option_suggestions" is now populated. Use it. */
7797 return find_closest_string
7798 (bad_opt,
7799 (auto_vec <const char *> *) m_option_suggestions);
7802 /* Reject switches that no pass was interested in. */
7804 void
7805 driver::handle_unrecognized_options ()
7807 for (size_t i = 0; (int) i < n_switches; i++)
7808 if (! switches[i].validated)
7810 const char *hint = suggest_option (switches[i].part1);
7811 if (hint)
7812 error ("unrecognized command line option %<-%s%>;"
7813 " did you mean %<-%s%>?",
7814 switches[i].part1, hint);
7815 else
7816 error ("unrecognized command line option %<-%s%>",
7817 switches[i].part1);
7821 /* Handle the various -print-* options, returning 0 if the driver
7822 should exit, or nonzero if the driver should continue. */
7825 driver::maybe_print_and_exit () const
7827 if (print_search_dirs)
7829 printf (_("install: %s%s\n"),
7830 gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
7831 gcc_exec_prefix ? "" : machine_suffix);
7832 printf (_("programs: %s\n"),
7833 build_search_list (&exec_prefixes, "", false, false));
7834 printf (_("libraries: %s\n"),
7835 build_search_list (&startfile_prefixes, "", false, true));
7836 return (0);
7839 if (print_file_name)
7841 printf ("%s\n", find_file (print_file_name));
7842 return (0);
7845 if (print_prog_name)
7847 if (use_ld != NULL && ! strcmp (print_prog_name, "ld"))
7849 /* Append USE_LD to the default linker. */
7850 #ifdef DEFAULT_LINKER
7851 char *ld;
7852 # ifdef HAVE_HOST_EXECUTABLE_SUFFIX
7853 int len = (sizeof (DEFAULT_LINKER)
7854 - sizeof (HOST_EXECUTABLE_SUFFIX));
7855 ld = NULL;
7856 if (len > 0)
7858 char *default_linker = xstrdup (DEFAULT_LINKER);
7859 /* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains
7860 HOST_EXECUTABLE_SUFFIX. */
7861 if (! strcmp (&default_linker[len], HOST_EXECUTABLE_SUFFIX))
7863 default_linker[len] = '\0';
7864 ld = concat (default_linker, use_ld,
7865 HOST_EXECUTABLE_SUFFIX, NULL);
7868 if (ld == NULL)
7869 # endif
7870 ld = concat (DEFAULT_LINKER, use_ld, NULL);
7871 if (access (ld, X_OK) == 0)
7873 printf ("%s\n", ld);
7874 return (0);
7876 #endif
7877 print_prog_name = concat (print_prog_name, use_ld, NULL);
7879 char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK, 0);
7880 printf ("%s\n", (newname ? newname : print_prog_name));
7881 return (0);
7884 if (print_multi_lib)
7886 print_multilib_info ();
7887 return (0);
7890 if (print_multi_directory)
7892 if (multilib_dir == NULL)
7893 printf (".\n");
7894 else
7895 printf ("%s\n", multilib_dir);
7896 return (0);
7899 if (print_multiarch)
7901 if (multiarch_dir == NULL)
7902 printf ("\n");
7903 else
7904 printf ("%s\n", multiarch_dir);
7905 return (0);
7908 if (print_sysroot)
7910 if (target_system_root)
7912 if (target_sysroot_suffix)
7913 printf ("%s%s\n", target_system_root, target_sysroot_suffix);
7914 else
7915 printf ("%s\n", target_system_root);
7917 return (0);
7920 if (print_multi_os_directory)
7922 if (multilib_os_dir == NULL)
7923 printf (".\n");
7924 else
7925 printf ("%s\n", multilib_os_dir);
7926 return (0);
7929 if (print_sysroot_headers_suffix)
7931 if (*sysroot_hdrs_suffix_spec)
7933 printf("%s\n", (target_sysroot_hdrs_suffix
7934 ? target_sysroot_hdrs_suffix
7935 : ""));
7936 return (0);
7938 else
7939 /* The error status indicates that only one set of fixed
7940 headers should be built. */
7941 fatal_error (input_location,
7942 "not configured with sysroot headers suffix");
7945 if (print_help_list)
7947 display_help ();
7949 if (! verbose_flag)
7951 printf (_("\nFor bug reporting instructions, please see:\n"));
7952 printf ("%s.\n", bug_report_url);
7954 return (0);
7957 /* We do not exit here. Instead we have created a fake input file
7958 called 'help-dummy' which needs to be compiled, and we pass this
7959 on the various sub-processes, along with the --help switch.
7960 Ensure their output appears after ours. */
7961 fputc ('\n', stdout);
7962 fflush (stdout);
7965 if (print_version)
7967 printf (_("%s %s%s\n"), progname, pkgversion_string,
7968 version_string);
7969 printf ("Copyright %s 2017 Free Software Foundation, Inc.\n",
7970 _("(C)"));
7971 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
7972 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
7973 stdout);
7974 if (! verbose_flag)
7975 return 0;
7977 /* We do not exit here. We use the same mechanism of --help to print
7978 the version of the sub-processes. */
7979 fputc ('\n', stdout);
7980 fflush (stdout);
7983 if (verbose_flag)
7985 print_configuration (stderr);
7986 if (n_infiles == 0)
7987 return (0);
7990 return 1;
7993 /* Figure out what to do with each input file.
7994 Return true if we need to exit early from "main", false otherwise. */
7996 bool
7997 driver::prepare_infiles ()
7999 size_t i;
8000 int lang_n_infiles = 0;
8002 if (n_infiles == added_libraries)
8003 fatal_error (input_location, "no input files");
8005 if (seen_error ())
8006 /* Early exit needed from main. */
8007 return true;
8009 /* Make a place to record the compiler output file names
8010 that correspond to the input files. */
8012 i = n_infiles;
8013 i += lang_specific_extra_outfiles;
8014 outfiles = XCNEWVEC (const char *, i);
8016 /* Record which files were specified explicitly as link input. */
8018 explicit_link_files = XCNEWVEC (char, n_infiles);
8020 combine_inputs = have_o || flag_wpa;
8022 for (i = 0; (int) i < n_infiles; i++)
8024 const char *name = infiles[i].name;
8025 struct compiler *compiler = lookup_compiler (name,
8026 strlen (name),
8027 infiles[i].language);
8029 if (compiler && !(compiler->combinable))
8030 combine_inputs = false;
8032 if (lang_n_infiles > 0 && compiler != input_file_compiler
8033 && infiles[i].language && infiles[i].language[0] != '*')
8034 infiles[i].incompiler = compiler;
8035 else if (compiler)
8037 lang_n_infiles++;
8038 input_file_compiler = compiler;
8039 infiles[i].incompiler = compiler;
8041 else
8043 /* Since there is no compiler for this input file, assume it is a
8044 linker file. */
8045 explicit_link_files[i] = 1;
8046 infiles[i].incompiler = NULL;
8048 infiles[i].compiled = false;
8049 infiles[i].preprocessed = false;
8052 if (!combine_inputs && have_c && have_o && lang_n_infiles > 1)
8053 fatal_error (input_location,
8054 "cannot specify -o with -c, -S or -E with multiple files");
8056 /* No early exit needed from main; we can continue. */
8057 return false;
8060 /* Run the spec machinery on each input file. */
8062 void
8063 driver::do_spec_on_infiles () const
8065 size_t i;
8067 for (i = 0; (int) i < n_infiles; i++)
8069 int this_file_error = 0;
8071 /* Tell do_spec what to substitute for %i. */
8073 input_file_number = i;
8074 set_input (infiles[i].name);
8076 if (infiles[i].compiled)
8077 continue;
8079 /* Use the same thing in %o, unless cp->spec says otherwise. */
8081 outfiles[i] = gcc_input_filename;
8083 /* Figure out which compiler from the file's suffix. */
8085 input_file_compiler
8086 = lookup_compiler (infiles[i].name, input_filename_length,
8087 infiles[i].language);
8089 if (input_file_compiler)
8091 /* Ok, we found an applicable compiler. Run its spec. */
8093 if (input_file_compiler->spec[0] == '#')
8095 error ("%s: %s compiler not installed on this system",
8096 gcc_input_filename, &input_file_compiler->spec[1]);
8097 this_file_error = 1;
8099 else
8101 int value;
8103 if (compare_debug)
8105 free (debug_check_temp_file[0]);
8106 debug_check_temp_file[0] = NULL;
8108 free (debug_check_temp_file[1]);
8109 debug_check_temp_file[1] = NULL;
8112 value = do_spec (input_file_compiler->spec);
8113 infiles[i].compiled = true;
8114 if (value < 0)
8115 this_file_error = 1;
8116 else if (compare_debug && debug_check_temp_file[0])
8118 if (verbose_flag)
8119 inform (0, "recompiling with -fcompare-debug");
8121 compare_debug = -compare_debug;
8122 n_switches = n_switches_debug_check[1];
8123 n_switches_alloc = n_switches_alloc_debug_check[1];
8124 switches = switches_debug_check[1];
8126 value = do_spec (input_file_compiler->spec);
8128 compare_debug = -compare_debug;
8129 n_switches = n_switches_debug_check[0];
8130 n_switches_alloc = n_switches_alloc_debug_check[0];
8131 switches = switches_debug_check[0];
8133 if (value < 0)
8135 error ("during -fcompare-debug recompilation");
8136 this_file_error = 1;
8139 gcc_assert (debug_check_temp_file[1]
8140 && filename_cmp (debug_check_temp_file[0],
8141 debug_check_temp_file[1]));
8143 if (verbose_flag)
8144 inform (0, "comparing final insns dumps");
8146 if (compare_files (debug_check_temp_file))
8147 this_file_error = 1;
8150 if (compare_debug)
8152 free (debug_check_temp_file[0]);
8153 debug_check_temp_file[0] = NULL;
8155 free (debug_check_temp_file[1]);
8156 debug_check_temp_file[1] = NULL;
8161 /* If this file's name does not contain a recognized suffix,
8162 record it as explicit linker input. */
8164 else
8165 explicit_link_files[i] = 1;
8167 /* Clear the delete-on-failure queue, deleting the files in it
8168 if this compilation failed. */
8170 if (this_file_error)
8172 delete_failure_queue ();
8173 errorcount++;
8175 /* If this compilation succeeded, don't delete those files later. */
8176 clear_failure_queue ();
8179 /* Reset the input file name to the first compile/object file name, for use
8180 with %b in LINK_SPEC. We use the first input file that we can find
8181 a compiler to compile it instead of using infiles.language since for
8182 languages other than C we use aliases that we then lookup later. */
8183 if (n_infiles > 0)
8185 int i;
8187 for (i = 0; i < n_infiles ; i++)
8188 if (infiles[i].incompiler
8189 || (infiles[i].language && infiles[i].language[0] != '*'))
8191 set_input (infiles[i].name);
8192 break;
8196 if (!seen_error ())
8198 /* Make sure INPUT_FILE_NUMBER points to first available open
8199 slot. */
8200 input_file_number = n_infiles;
8201 if (lang_specific_pre_link ())
8202 errorcount++;
8206 /* If we have to run the linker, do it now. */
8208 void
8209 driver::maybe_run_linker (const char *argv0) const
8211 size_t i;
8212 int linker_was_run = 0;
8213 int num_linker_inputs;
8215 /* Determine if there are any linker input files. */
8216 num_linker_inputs = 0;
8217 for (i = 0; (int) i < n_infiles; i++)
8218 if (explicit_link_files[i] || outfiles[i] != NULL)
8219 num_linker_inputs++;
8221 /* Run ld to link all the compiler output files. */
8223 if (num_linker_inputs > 0 && !seen_error () && print_subprocess_help < 2)
8225 int tmp = execution_count;
8227 if (! have_c)
8229 #if HAVE_LTO_PLUGIN > 0
8230 #if HAVE_LTO_PLUGIN == 2
8231 const char *fno_use_linker_plugin = "fno-use-linker-plugin";
8232 #else
8233 const char *fuse_linker_plugin = "fuse-linker-plugin";
8234 #endif
8235 #endif
8237 /* We'll use ld if we can't find collect2. */
8238 if (! strcmp (linker_name_spec, "collect2"))
8240 char *s = find_a_file (&exec_prefixes, "collect2", X_OK, false);
8241 if (s == NULL)
8242 linker_name_spec = "ld";
8245 #if HAVE_LTO_PLUGIN > 0
8246 #if HAVE_LTO_PLUGIN == 2
8247 if (!switch_matches (fno_use_linker_plugin,
8248 fno_use_linker_plugin
8249 + strlen (fno_use_linker_plugin), 0))
8250 #else
8251 if (switch_matches (fuse_linker_plugin,
8252 fuse_linker_plugin
8253 + strlen (fuse_linker_plugin), 0))
8254 #endif
8256 char *temp_spec = find_a_file (&exec_prefixes,
8257 LTOPLUGINSONAME, R_OK,
8258 false);
8259 if (!temp_spec)
8260 fatal_error (input_location,
8261 "-fuse-linker-plugin, but %s not found",
8262 LTOPLUGINSONAME);
8263 linker_plugin_file_spec = convert_white_space (temp_spec);
8265 #endif
8266 lto_gcc_spec = argv0;
8269 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
8270 for collect. */
8271 putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH", false);
8272 putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV, true);
8274 if (print_subprocess_help == 1)
8276 printf (_("\nLinker options\n==============\n\n"));
8277 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
8278 " to the linker.\n\n"));
8279 fflush (stdout);
8281 int value = do_spec (link_command_spec);
8282 if (value < 0)
8283 errorcount = 1;
8284 linker_was_run = (tmp != execution_count);
8287 /* If options said don't run linker,
8288 complain about input files to be given to the linker. */
8290 if (! linker_was_run && !seen_error ())
8291 for (i = 0; (int) i < n_infiles; i++)
8292 if (explicit_link_files[i]
8293 && !(infiles[i].language && infiles[i].language[0] == '*'))
8294 warning (0, "%s: linker input file unused because linking not done",
8295 outfiles[i]);
8298 /* The end of "main". */
8300 void
8301 driver::final_actions () const
8303 /* Delete some or all of the temporary files we made. */
8305 if (seen_error ())
8306 delete_failure_queue ();
8307 delete_temp_files ();
8309 if (print_help_list)
8311 printf (("\nFor bug reporting instructions, please see:\n"));
8312 printf ("%s\n", bug_report_url);
8316 /* Determine what the exit code of the driver should be. */
8319 driver::get_exit_code () const
8321 return (signal_count != 0 ? 2
8322 : seen_error () ? (pass_exit_codes ? greatest_status : 1)
8323 : 0);
8326 /* Find the proper compilation spec for the file name NAME,
8327 whose length is LENGTH. LANGUAGE is the specified language,
8328 or 0 if this file is to be passed to the linker. */
8330 static struct compiler *
8331 lookup_compiler (const char *name, size_t length, const char *language)
8333 struct compiler *cp;
8335 /* If this was specified by the user to be a linker input, indicate that. */
8336 if (language != 0 && language[0] == '*')
8337 return 0;
8339 /* Otherwise, look for the language, if one is spec'd. */
8340 if (language != 0)
8342 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
8343 if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
8345 if (name != NULL && strcmp (name, "-") == 0
8346 && (strcmp (cp->suffix, "@c-header") == 0
8347 || strcmp (cp->suffix, "@c++-header") == 0)
8348 && !have_E)
8349 fatal_error (input_location,
8350 "cannot use %<-%> as input filename for a "
8351 "precompiled header");
8353 return cp;
8356 error ("language %s not recognized", language);
8357 return 0;
8360 /* Look for a suffix. */
8361 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
8363 if (/* The suffix `-' matches only the file name `-'. */
8364 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
8365 || (strlen (cp->suffix) < length
8366 /* See if the suffix matches the end of NAME. */
8367 && !strcmp (cp->suffix,
8368 name + length - strlen (cp->suffix))
8370 break;
8373 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
8374 /* Look again, but case-insensitively this time. */
8375 if (cp < compilers)
8376 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
8378 if (/* The suffix `-' matches only the file name `-'. */
8379 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
8380 || (strlen (cp->suffix) < length
8381 /* See if the suffix matches the end of NAME. */
8382 && ((!strcmp (cp->suffix,
8383 name + length - strlen (cp->suffix))
8384 || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
8385 && !strcasecmp (cp->suffix,
8386 name + length - strlen (cp->suffix)))
8388 break;
8390 #endif
8392 if (cp >= compilers)
8394 if (cp->spec[0] != '@')
8395 /* A non-alias entry: return it. */
8396 return cp;
8398 /* An alias entry maps a suffix to a language.
8399 Search for the language; pass 0 for NAME and LENGTH
8400 to avoid infinite recursion if language not found. */
8401 return lookup_compiler (NULL, 0, cp->spec + 1);
8403 return 0;
8406 static char *
8407 save_string (const char *s, int len)
8409 char *result = XNEWVEC (char, len + 1);
8411 gcc_checking_assert (strlen (s) >= (unsigned int) len);
8412 memcpy (result, s, len);
8413 result[len] = 0;
8414 return result;
8417 void
8418 pfatal_with_name (const char *name)
8420 perror_with_name (name);
8421 delete_temp_files ();
8422 exit (1);
8425 static void
8426 perror_with_name (const char *name)
8428 error ("%s: %m", name);
8431 static inline void
8432 validate_switches_from_spec (const char *spec, bool user)
8434 const char *p = spec;
8435 char c;
8436 while ((c = *p++))
8437 if (c == '%' && (*p == '{' || *p == '<' || (*p == 'W' && *++p == '{')))
8438 /* We have a switch spec. */
8439 p = validate_switches (p + 1, user);
8442 static void
8443 validate_all_switches (void)
8445 struct compiler *comp;
8446 struct spec_list *spec;
8448 for (comp = compilers; comp->spec; comp++)
8449 validate_switches_from_spec (comp->spec, false);
8451 /* Look through the linked list of specs read from the specs file. */
8452 for (spec = specs; spec; spec = spec->next)
8453 validate_switches_from_spec (*spec->ptr_spec, spec->user_p);
8455 validate_switches_from_spec (link_command_spec, false);
8458 /* Look at the switch-name that comes after START
8459 and mark as valid all supplied switches that match it. */
8461 static const char *
8462 validate_switches (const char *start, bool user_spec)
8464 const char *p = start;
8465 const char *atom;
8466 size_t len;
8467 int i;
8468 bool suffix = false;
8469 bool starred = false;
8471 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
8473 next_member:
8474 SKIP_WHITE ();
8476 if (*p == '!')
8477 p++;
8479 SKIP_WHITE ();
8480 if (*p == '.' || *p == ',')
8481 suffix = true, p++;
8483 atom = p;
8484 while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
8485 || *p == ',' || *p == '.' || *p == '@')
8486 p++;
8487 len = p - atom;
8489 if (*p == '*')
8490 starred = true, p++;
8492 SKIP_WHITE ();
8494 if (!suffix)
8496 /* Mark all matching switches as valid. */
8497 for (i = 0; i < n_switches; i++)
8498 if (!strncmp (switches[i].part1, atom, len)
8499 && (starred || switches[i].part1[len] == '\0')
8500 && (switches[i].known || user_spec))
8501 switches[i].validated = true;
8504 if (*p) p++;
8505 if (*p && (p[-1] == '|' || p[-1] == '&'))
8506 goto next_member;
8508 if (*p && p[-1] == ':')
8510 while (*p && *p != ';' && *p != '}')
8512 if (*p == '%')
8514 p++;
8515 if (*p == '{' || *p == '<')
8516 p = validate_switches (p+1, user_spec);
8517 else if (p[0] == 'W' && p[1] == '{')
8518 p = validate_switches (p+2, user_spec);
8520 else
8521 p++;
8524 if (*p) p++;
8525 if (*p && p[-1] == ';')
8526 goto next_member;
8529 return p;
8530 #undef SKIP_WHITE
8533 struct mdswitchstr
8535 const char *str;
8536 int len;
8539 static struct mdswitchstr *mdswitches;
8540 static int n_mdswitches;
8542 /* Check whether a particular argument was used. The first time we
8543 canonicalize the switches to keep only the ones we care about. */
8545 class used_arg_t
8547 public:
8548 int operator () (const char *p, int len);
8549 void finalize ();
8551 private:
8552 struct mswitchstr
8554 const char *str;
8555 const char *replace;
8556 int len;
8557 int rep_len;
8560 mswitchstr *mswitches;
8561 int n_mswitches;
8565 used_arg_t used_arg;
8568 used_arg_t::operator () (const char *p, int len)
8570 int i, j;
8572 if (!mswitches)
8574 struct mswitchstr *matches;
8575 const char *q;
8576 int cnt = 0;
8578 /* Break multilib_matches into the component strings of string
8579 and replacement string. */
8580 for (q = multilib_matches; *q != '\0'; q++)
8581 if (*q == ';')
8582 cnt++;
8584 matches
8585 = (struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt);
8586 i = 0;
8587 q = multilib_matches;
8588 while (*q != '\0')
8590 matches[i].str = q;
8591 while (*q != ' ')
8593 if (*q == '\0')
8595 invalid_matches:
8596 fatal_error (input_location, "multilib spec %qs is invalid",
8597 multilib_matches);
8599 q++;
8601 matches[i].len = q - matches[i].str;
8603 matches[i].replace = ++q;
8604 while (*q != ';' && *q != '\0')
8606 if (*q == ' ')
8607 goto invalid_matches;
8608 q++;
8610 matches[i].rep_len = q - matches[i].replace;
8611 i++;
8612 if (*q == ';')
8613 q++;
8616 /* Now build a list of the replacement string for switches that we care
8617 about. Make sure we allocate at least one entry. This prevents
8618 xmalloc from calling fatal, and prevents us from re-executing this
8619 block of code. */
8620 mswitches
8621 = XNEWVEC (struct mswitchstr, n_mdswitches + (n_switches ? n_switches : 1));
8622 for (i = 0; i < n_switches; i++)
8623 if ((switches[i].live_cond & SWITCH_IGNORE) == 0)
8625 int xlen = strlen (switches[i].part1);
8626 for (j = 0; j < cnt; j++)
8627 if (xlen == matches[j].len
8628 && ! strncmp (switches[i].part1, matches[j].str, xlen))
8630 mswitches[n_mswitches].str = matches[j].replace;
8631 mswitches[n_mswitches].len = matches[j].rep_len;
8632 mswitches[n_mswitches].replace = (char *) 0;
8633 mswitches[n_mswitches].rep_len = 0;
8634 n_mswitches++;
8635 break;
8639 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
8640 on the command line nor any options mutually incompatible with
8641 them. */
8642 for (i = 0; i < n_mdswitches; i++)
8644 const char *r;
8646 for (q = multilib_options; *q != '\0'; *q && q++)
8648 while (*q == ' ')
8649 q++;
8651 r = q;
8652 while (strncmp (q, mdswitches[i].str, mdswitches[i].len) != 0
8653 || strchr (" /", q[mdswitches[i].len]) == NULL)
8655 while (*q != ' ' && *q != '/' && *q != '\0')
8656 q++;
8657 if (*q != '/')
8658 break;
8659 q++;
8662 if (*q != ' ' && *q != '\0')
8664 while (*r != ' ' && *r != '\0')
8666 q = r;
8667 while (*q != ' ' && *q != '/' && *q != '\0')
8668 q++;
8670 if (used_arg (r, q - r))
8671 break;
8673 if (*q != '/')
8675 mswitches[n_mswitches].str = mdswitches[i].str;
8676 mswitches[n_mswitches].len = mdswitches[i].len;
8677 mswitches[n_mswitches].replace = (char *) 0;
8678 mswitches[n_mswitches].rep_len = 0;
8679 n_mswitches++;
8680 break;
8683 r = q + 1;
8685 break;
8691 for (i = 0; i < n_mswitches; i++)
8692 if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
8693 return 1;
8695 return 0;
8698 void used_arg_t::finalize ()
8700 XDELETEVEC (mswitches);
8701 mswitches = NULL;
8702 n_mswitches = 0;
8706 static int
8707 default_arg (const char *p, int len)
8709 int i;
8711 for (i = 0; i < n_mdswitches; i++)
8712 if (len == mdswitches[i].len && ! strncmp (p, mdswitches[i].str, len))
8713 return 1;
8715 return 0;
8718 /* Work out the subdirectory to use based on the options. The format of
8719 multilib_select is a list of elements. Each element is a subdirectory
8720 name followed by a list of options followed by a semicolon. The format
8721 of multilib_exclusions is the same, but without the preceding
8722 directory. First gcc will check the exclusions, if none of the options
8723 beginning with an exclamation point are present, and all of the other
8724 options are present, then we will ignore this completely. Passing
8725 that, gcc will consider each multilib_select in turn using the same
8726 rules for matching the options. If a match is found, that subdirectory
8727 will be used.
8728 A subdirectory name is optionally followed by a colon and the corresponding
8729 multiarch name. */
8731 static void
8732 set_multilib_dir (void)
8734 const char *p;
8735 unsigned int this_path_len;
8736 const char *this_path, *this_arg;
8737 const char *start, *end;
8738 int not_arg;
8739 int ok, ndfltok, first;
8741 n_mdswitches = 0;
8742 start = multilib_defaults;
8743 while (*start == ' ' || *start == '\t')
8744 start++;
8745 while (*start != '\0')
8747 n_mdswitches++;
8748 while (*start != ' ' && *start != '\t' && *start != '\0')
8749 start++;
8750 while (*start == ' ' || *start == '\t')
8751 start++;
8754 if (n_mdswitches)
8756 int i = 0;
8758 mdswitches = XNEWVEC (struct mdswitchstr, n_mdswitches);
8759 for (start = multilib_defaults; *start != '\0'; start = end + 1)
8761 while (*start == ' ' || *start == '\t')
8762 start++;
8764 if (*start == '\0')
8765 break;
8767 for (end = start + 1;
8768 *end != ' ' && *end != '\t' && *end != '\0'; end++)
8771 obstack_grow (&multilib_obstack, start, end - start);
8772 obstack_1grow (&multilib_obstack, 0);
8773 mdswitches[i].str = XOBFINISH (&multilib_obstack, const char *);
8774 mdswitches[i++].len = end - start;
8776 if (*end == '\0')
8777 break;
8781 p = multilib_exclusions;
8782 while (*p != '\0')
8784 /* Ignore newlines. */
8785 if (*p == '\n')
8787 ++p;
8788 continue;
8791 /* Check the arguments. */
8792 ok = 1;
8793 while (*p != ';')
8795 if (*p == '\0')
8797 invalid_exclusions:
8798 fatal_error (input_location, "multilib exclusions %qs is invalid",
8799 multilib_exclusions);
8802 if (! ok)
8804 ++p;
8805 continue;
8808 this_arg = p;
8809 while (*p != ' ' && *p != ';')
8811 if (*p == '\0')
8812 goto invalid_exclusions;
8813 ++p;
8816 if (*this_arg != '!')
8817 not_arg = 0;
8818 else
8820 not_arg = 1;
8821 ++this_arg;
8824 ok = used_arg (this_arg, p - this_arg);
8825 if (not_arg)
8826 ok = ! ok;
8828 if (*p == ' ')
8829 ++p;
8832 if (ok)
8833 return;
8835 ++p;
8838 first = 1;
8839 p = multilib_select;
8841 /* Append multilib reuse rules if any. With those rules, we can reuse
8842 one multilib for certain different options sets. */
8843 if (strlen (multilib_reuse) > 0)
8844 p = concat (p, multilib_reuse, NULL);
8846 while (*p != '\0')
8848 /* Ignore newlines. */
8849 if (*p == '\n')
8851 ++p;
8852 continue;
8855 /* Get the initial path. */
8856 this_path = p;
8857 while (*p != ' ')
8859 if (*p == '\0')
8861 invalid_select:
8862 fatal_error (input_location, "multilib select %qs %qs is invalid",
8863 multilib_select, multilib_reuse);
8865 ++p;
8867 this_path_len = p - this_path;
8869 /* Check the arguments. */
8870 ok = 1;
8871 ndfltok = 1;
8872 ++p;
8873 while (*p != ';')
8875 if (*p == '\0')
8876 goto invalid_select;
8878 if (! ok)
8880 ++p;
8881 continue;
8884 this_arg = p;
8885 while (*p != ' ' && *p != ';')
8887 if (*p == '\0')
8888 goto invalid_select;
8889 ++p;
8892 if (*this_arg != '!')
8893 not_arg = 0;
8894 else
8896 not_arg = 1;
8897 ++this_arg;
8900 /* If this is a default argument, we can just ignore it.
8901 This is true even if this_arg begins with '!'. Beginning
8902 with '!' does not mean that this argument is necessarily
8903 inappropriate for this library: it merely means that
8904 there is a more specific library which uses this
8905 argument. If this argument is a default, we need not
8906 consider that more specific library. */
8907 ok = used_arg (this_arg, p - this_arg);
8908 if (not_arg)
8909 ok = ! ok;
8911 if (! ok)
8912 ndfltok = 0;
8914 if (default_arg (this_arg, p - this_arg))
8915 ok = 1;
8917 if (*p == ' ')
8918 ++p;
8921 if (ok && first)
8923 if (this_path_len != 1
8924 || this_path[0] != '.')
8926 char *new_multilib_dir = XNEWVEC (char, this_path_len + 1);
8927 char *q;
8929 strncpy (new_multilib_dir, this_path, this_path_len);
8930 new_multilib_dir[this_path_len] = '\0';
8931 q = strchr (new_multilib_dir, ':');
8932 if (q != NULL)
8933 *q = '\0';
8934 multilib_dir = new_multilib_dir;
8936 first = 0;
8939 if (ndfltok)
8941 const char *q = this_path, *end = this_path + this_path_len;
8943 while (q < end && *q != ':')
8944 q++;
8945 if (q < end)
8947 const char *q2 = q + 1, *ml_end = end;
8948 char *new_multilib_os_dir;
8950 while (q2 < end && *q2 != ':')
8951 q2++;
8952 if (*q2 == ':')
8953 ml_end = q2;
8954 if (ml_end - q == 1)
8955 multilib_os_dir = xstrdup (".");
8956 else
8958 new_multilib_os_dir = XNEWVEC (char, ml_end - q);
8959 memcpy (new_multilib_os_dir, q + 1, ml_end - q - 1);
8960 new_multilib_os_dir[ml_end - q - 1] = '\0';
8961 multilib_os_dir = new_multilib_os_dir;
8964 if (q2 < end && *q2 == ':')
8966 char *new_multiarch_dir = XNEWVEC (char, end - q2);
8967 memcpy (new_multiarch_dir, q2 + 1, end - q2 - 1);
8968 new_multiarch_dir[end - q2 - 1] = '\0';
8969 multiarch_dir = new_multiarch_dir;
8971 break;
8975 ++p;
8978 if (multilib_dir == NULL && multilib_os_dir != NULL
8979 && strcmp (multilib_os_dir, ".") == 0)
8981 free (CONST_CAST (char *, multilib_os_dir));
8982 multilib_os_dir = NULL;
8984 else if (multilib_dir != NULL && multilib_os_dir == NULL)
8985 multilib_os_dir = multilib_dir;
8988 /* Print out the multiple library subdirectory selection
8989 information. This prints out a series of lines. Each line looks
8990 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
8991 required. Only the desired options are printed out, the negative
8992 matches. The options are print without a leading dash. There are
8993 no spaces to make it easy to use the information in the shell.
8994 Each subdirectory is printed only once. This assumes the ordering
8995 generated by the genmultilib script. Also, we leave out ones that match
8996 the exclusions. */
8998 static void
8999 print_multilib_info (void)
9001 const char *p = multilib_select;
9002 const char *last_path = 0, *this_path;
9003 int skip;
9004 unsigned int last_path_len = 0;
9006 while (*p != '\0')
9008 skip = 0;
9009 /* Ignore newlines. */
9010 if (*p == '\n')
9012 ++p;
9013 continue;
9016 /* Get the initial path. */
9017 this_path = p;
9018 while (*p != ' ')
9020 if (*p == '\0')
9022 invalid_select:
9023 fatal_error (input_location,
9024 "multilib select %qs is invalid", multilib_select);
9027 ++p;
9030 /* When --disable-multilib was used but target defines
9031 MULTILIB_OSDIRNAMES, entries starting with .: (and not starting
9032 with .:: for multiarch configurations) are there just to find
9033 multilib_os_dir, so skip them from output. */
9034 if (this_path[0] == '.' && this_path[1] == ':' && this_path[2] != ':')
9035 skip = 1;
9037 /* Check for matches with the multilib_exclusions. We don't bother
9038 with the '!' in either list. If any of the exclusion rules match
9039 all of its options with the select rule, we skip it. */
9041 const char *e = multilib_exclusions;
9042 const char *this_arg;
9044 while (*e != '\0')
9046 int m = 1;
9047 /* Ignore newlines. */
9048 if (*e == '\n')
9050 ++e;
9051 continue;
9054 /* Check the arguments. */
9055 while (*e != ';')
9057 const char *q;
9058 int mp = 0;
9060 if (*e == '\0')
9062 invalid_exclusion:
9063 fatal_error (input_location,
9064 "multilib exclusion %qs is invalid",
9065 multilib_exclusions);
9068 if (! m)
9070 ++e;
9071 continue;
9074 this_arg = e;
9076 while (*e != ' ' && *e != ';')
9078 if (*e == '\0')
9079 goto invalid_exclusion;
9080 ++e;
9083 q = p + 1;
9084 while (*q != ';')
9086 const char *arg;
9087 int len = e - this_arg;
9089 if (*q == '\0')
9090 goto invalid_select;
9092 arg = q;
9094 while (*q != ' ' && *q != ';')
9096 if (*q == '\0')
9097 goto invalid_select;
9098 ++q;
9101 if (! strncmp (arg, this_arg,
9102 (len < q - arg) ? q - arg : len)
9103 || default_arg (this_arg, e - this_arg))
9105 mp = 1;
9106 break;
9109 if (*q == ' ')
9110 ++q;
9113 if (! mp)
9114 m = 0;
9116 if (*e == ' ')
9117 ++e;
9120 if (m)
9122 skip = 1;
9123 break;
9126 if (*e != '\0')
9127 ++e;
9131 if (! skip)
9133 /* If this is a duplicate, skip it. */
9134 skip = (last_path != 0
9135 && (unsigned int) (p - this_path) == last_path_len
9136 && ! filename_ncmp (last_path, this_path, last_path_len));
9138 last_path = this_path;
9139 last_path_len = p - this_path;
9142 /* If this directory requires any default arguments, we can skip
9143 it. We will already have printed a directory identical to
9144 this one which does not require that default argument. */
9145 if (! skip)
9147 const char *q;
9149 q = p + 1;
9150 while (*q != ';')
9152 const char *arg;
9154 if (*q == '\0')
9155 goto invalid_select;
9157 if (*q == '!')
9158 arg = NULL;
9159 else
9160 arg = q;
9162 while (*q != ' ' && *q != ';')
9164 if (*q == '\0')
9165 goto invalid_select;
9166 ++q;
9169 if (arg != NULL
9170 && default_arg (arg, q - arg))
9172 skip = 1;
9173 break;
9176 if (*q == ' ')
9177 ++q;
9181 if (! skip)
9183 const char *p1;
9185 for (p1 = last_path; p1 < p && *p1 != ':'; p1++)
9186 putchar (*p1);
9187 putchar (';');
9190 ++p;
9191 while (*p != ';')
9193 int use_arg;
9195 if (*p == '\0')
9196 goto invalid_select;
9198 if (skip)
9200 ++p;
9201 continue;
9204 use_arg = *p != '!';
9206 if (use_arg)
9207 putchar ('@');
9209 while (*p != ' ' && *p != ';')
9211 if (*p == '\0')
9212 goto invalid_select;
9213 if (use_arg)
9214 putchar (*p);
9215 ++p;
9218 if (*p == ' ')
9219 ++p;
9222 if (! skip)
9224 /* If there are extra options, print them now. */
9225 if (multilib_extra && *multilib_extra)
9227 int print_at = TRUE;
9228 const char *q;
9230 for (q = multilib_extra; *q != '\0'; q++)
9232 if (*q == ' ')
9233 print_at = TRUE;
9234 else
9236 if (print_at)
9237 putchar ('@');
9238 putchar (*q);
9239 print_at = FALSE;
9244 putchar ('\n');
9247 ++p;
9251 /* getenv built-in spec function.
9253 Returns the value of the environment variable given by its first argument,
9254 concatenated with the second argument. If the variable is not defined, a
9255 fatal error is issued unless such undefs are internally allowed, in which
9256 case the variable name is used as the variable value. */
9258 static const char *
9259 getenv_spec_function (int argc, const char **argv)
9261 const char *value;
9262 const char *varname;
9264 char *result;
9265 char *ptr;
9266 size_t len;
9268 if (argc != 2)
9269 return NULL;
9271 varname = argv[0];
9272 value = env.get (varname);
9274 if (!value && spec_undefvar_allowed)
9275 value = varname;
9277 if (!value)
9278 fatal_error (input_location,
9279 "environment variable %qs not defined", varname);
9281 /* We have to escape every character of the environment variable so
9282 they are not interpreted as active spec characters. A
9283 particularly painful case is when we are reading a variable
9284 holding a windows path complete with \ separators. */
9285 len = strlen (value) * 2 + strlen (argv[1]) + 1;
9286 result = XNEWVAR (char, len);
9287 for (ptr = result; *value; ptr += 2)
9289 ptr[0] = '\\';
9290 ptr[1] = *value++;
9293 strcpy (ptr, argv[1]);
9295 return result;
9298 /* if-exists built-in spec function.
9300 Checks to see if the file specified by the absolute pathname in
9301 ARGS exists. Returns that pathname if found.
9303 The usual use for this function is to check for a library file
9304 (whose name has been expanded with %s). */
9306 static const char *
9307 if_exists_spec_function (int argc, const char **argv)
9309 /* Must have only one argument. */
9310 if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
9311 return argv[0];
9313 return NULL;
9316 /* if-exists-else built-in spec function.
9318 This is like if-exists, but takes an additional argument which
9319 is returned if the first argument does not exist. */
9321 static const char *
9322 if_exists_else_spec_function (int argc, const char **argv)
9324 /* Must have exactly two arguments. */
9325 if (argc != 2)
9326 return NULL;
9328 if (IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
9329 return argv[0];
9331 return argv[1];
9334 /* sanitize built-in spec function.
9336 This returns non-NULL, if sanitizing address, thread or
9337 any of the undefined behavior sanitizers. */
9339 static const char *
9340 sanitize_spec_function (int argc, const char **argv)
9342 if (argc != 1)
9343 return NULL;
9345 if (strcmp (argv[0], "address") == 0)
9346 return (flag_sanitize & SANITIZE_USER_ADDRESS) ? "" : NULL;
9347 if (strcmp (argv[0], "kernel-address") == 0)
9348 return (flag_sanitize & SANITIZE_KERNEL_ADDRESS) ? "" : NULL;
9349 if (strcmp (argv[0], "thread") == 0)
9350 return (flag_sanitize & SANITIZE_THREAD) ? "" : NULL;
9351 if (strcmp (argv[0], "undefined") == 0)
9352 return ((flag_sanitize & (SANITIZE_UNDEFINED | SANITIZE_NONDEFAULT))
9353 && !flag_sanitize_undefined_trap_on_error) ? "" : NULL;
9354 if (strcmp (argv[0], "leak") == 0)
9355 return ((flag_sanitize
9356 & (SANITIZE_ADDRESS | SANITIZE_LEAK | SANITIZE_THREAD))
9357 == SANITIZE_LEAK) ? "" : NULL;
9358 return NULL;
9361 /* replace-outfile built-in spec function.
9363 This looks for the first argument in the outfiles array's name and
9364 replaces it with the second argument. */
9366 static const char *
9367 replace_outfile_spec_function (int argc, const char **argv)
9369 int i;
9370 /* Must have exactly two arguments. */
9371 if (argc != 2)
9372 abort ();
9374 for (i = 0; i < n_infiles; i++)
9376 if (outfiles[i] && !filename_cmp (outfiles[i], argv[0]))
9377 outfiles[i] = xstrdup (argv[1]);
9379 return NULL;
9382 /* remove-outfile built-in spec function.
9384 * This looks for the first argument in the outfiles array's name and
9385 * removes it. */
9387 static const char *
9388 remove_outfile_spec_function (int argc, const char **argv)
9390 int i;
9391 /* Must have exactly one argument. */
9392 if (argc != 1)
9393 abort ();
9395 for (i = 0; i < n_infiles; i++)
9397 if (outfiles[i] && !filename_cmp (outfiles[i], argv[0]))
9398 outfiles[i] = NULL;
9400 return NULL;
9403 /* Given two version numbers, compares the two numbers.
9404 A version number must match the regular expression
9405 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
9407 static int
9408 compare_version_strings (const char *v1, const char *v2)
9410 int rresult;
9411 regex_t r;
9413 if (regcomp (&r, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
9414 REG_EXTENDED | REG_NOSUB) != 0)
9415 abort ();
9416 rresult = regexec (&r, v1, 0, NULL, 0);
9417 if (rresult == REG_NOMATCH)
9418 fatal_error (input_location, "invalid version number %qs", v1);
9419 else if (rresult != 0)
9420 abort ();
9421 rresult = regexec (&r, v2, 0, NULL, 0);
9422 if (rresult == REG_NOMATCH)
9423 fatal_error (input_location, "invalid version number %qs", v2);
9424 else if (rresult != 0)
9425 abort ();
9427 return strverscmp (v1, v2);
9431 /* version_compare built-in spec function.
9433 This takes an argument of the following form:
9435 <comparison-op> <arg1> [<arg2>] <switch> <result>
9437 and produces "result" if the comparison evaluates to true,
9438 and nothing if it doesn't.
9440 The supported <comparison-op> values are:
9442 >= true if switch is a later (or same) version than arg1
9443 !> opposite of >=
9444 < true if switch is an earlier version than arg1
9445 !< opposite of <
9446 >< true if switch is arg1 or later, and earlier than arg2
9447 <> true if switch is earlier than arg1 or is arg2 or later
9449 If the switch is not present, the condition is false unless
9450 the first character of the <comparison-op> is '!'.
9452 For example,
9453 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
9454 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
9456 static const char *
9457 version_compare_spec_function (int argc, const char **argv)
9459 int comp1, comp2;
9460 size_t switch_len;
9461 const char *switch_value = NULL;
9462 int nargs = 1, i;
9463 bool result;
9465 if (argc < 3)
9466 fatal_error (input_location, "too few arguments to %%:version-compare");
9467 if (argv[0][0] == '\0')
9468 abort ();
9469 if ((argv[0][1] == '<' || argv[0][1] == '>') && argv[0][0] != '!')
9470 nargs = 2;
9471 if (argc != nargs + 3)
9472 fatal_error (input_location, "too many arguments to %%:version-compare");
9474 switch_len = strlen (argv[nargs + 1]);
9475 for (i = 0; i < n_switches; i++)
9476 if (!strncmp (switches[i].part1, argv[nargs + 1], switch_len)
9477 && check_live_switch (i, switch_len))
9478 switch_value = switches[i].part1 + switch_len;
9480 if (switch_value == NULL)
9481 comp1 = comp2 = -1;
9482 else
9484 comp1 = compare_version_strings (switch_value, argv[1]);
9485 if (nargs == 2)
9486 comp2 = compare_version_strings (switch_value, argv[2]);
9487 else
9488 comp2 = -1; /* This value unused. */
9491 switch (argv[0][0] << 8 | argv[0][1])
9493 case '>' << 8 | '=':
9494 result = comp1 >= 0;
9495 break;
9496 case '!' << 8 | '<':
9497 result = comp1 >= 0 || switch_value == NULL;
9498 break;
9499 case '<' << 8:
9500 result = comp1 < 0;
9501 break;
9502 case '!' << 8 | '>':
9503 result = comp1 < 0 || switch_value == NULL;
9504 break;
9505 case '>' << 8 | '<':
9506 result = comp1 >= 0 && comp2 < 0;
9507 break;
9508 case '<' << 8 | '>':
9509 result = comp1 < 0 || comp2 >= 0;
9510 break;
9512 default:
9513 fatal_error (input_location,
9514 "unknown operator %qs in %%:version-compare", argv[0]);
9516 if (! result)
9517 return NULL;
9519 return argv[nargs + 2];
9522 /* %:include builtin spec function. This differs from %include in that it
9523 can be nested inside a spec, and thus be conditionalized. It takes
9524 one argument, the filename, and looks for it in the startfile path.
9525 The result is always NULL, i.e. an empty expansion. */
9527 static const char *
9528 include_spec_function (int argc, const char **argv)
9530 char *file;
9532 if (argc != 1)
9533 abort ();
9535 file = find_a_file (&startfile_prefixes, argv[0], R_OK, true);
9536 read_specs (file ? file : argv[0], false, false);
9538 return NULL;
9541 /* %:find-file spec function. This function replaces its argument by
9542 the file found through find_file, that is the -print-file-name gcc
9543 program option. */
9544 static const char *
9545 find_file_spec_function (int argc, const char **argv)
9547 const char *file;
9549 if (argc != 1)
9550 abort ();
9552 file = find_file (argv[0]);
9553 return file;
9557 /* %:find-plugindir spec function. This function replaces its argument
9558 by the -iplugindir=<dir> option. `dir' is found through find_file, that
9559 is the -print-file-name gcc program option. */
9560 static const char *
9561 find_plugindir_spec_function (int argc, const char **argv ATTRIBUTE_UNUSED)
9563 const char *option;
9565 if (argc != 0)
9566 abort ();
9568 option = concat ("-iplugindir=", find_file ("plugin"), NULL);
9569 return option;
9573 /* %:print-asm-header spec function. Print a banner to say that the
9574 following output is from the assembler. */
9576 static const char *
9577 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED,
9578 const char **argv ATTRIBUTE_UNUSED)
9580 printf (_("Assembler options\n=================\n\n"));
9581 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
9582 fflush (stdout);
9583 return NULL;
9586 /* Get a random number for -frandom-seed */
9588 static unsigned HOST_WIDE_INT
9589 get_random_number (void)
9591 unsigned HOST_WIDE_INT ret = 0;
9592 int fd;
9594 fd = open ("/dev/urandom", O_RDONLY);
9595 if (fd >= 0)
9597 read (fd, &ret, sizeof (HOST_WIDE_INT));
9598 close (fd);
9599 if (ret)
9600 return ret;
9603 /* Get some more or less random data. */
9604 #ifdef HAVE_GETTIMEOFDAY
9606 struct timeval tv;
9608 gettimeofday (&tv, NULL);
9609 ret = tv.tv_sec * 1000 + tv.tv_usec / 1000;
9611 #else
9613 time_t now = time (NULL);
9615 if (now != (time_t)-1)
9616 ret = (unsigned) now;
9618 #endif
9620 return ret ^ getpid ();
9623 /* %:compare-debug-dump-opt spec function. Save the last argument,
9624 expected to be the last -fdump-final-insns option, or generate a
9625 temporary. */
9627 static const char *
9628 compare_debug_dump_opt_spec_function (int arg,
9629 const char **argv ATTRIBUTE_UNUSED)
9631 char *ret;
9632 char *name;
9633 int which;
9634 static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];
9636 if (arg != 0)
9637 fatal_error (input_location,
9638 "too many arguments to %%:compare-debug-dump-opt");
9640 do_spec_2 ("%{fdump-final-insns=*:%*}");
9641 do_spec_1 (" ", 0, NULL);
9643 if (argbuf.length () > 0
9644 && strcmp (argv[argbuf.length () - 1], "."))
9646 if (!compare_debug)
9647 return NULL;
9649 name = xstrdup (argv[argbuf.length () - 1]);
9650 ret = NULL;
9652 else
9654 const char *ext = NULL;
9656 if (argbuf.length () > 0)
9658 do_spec_2 ("%{o*:%*}%{!o:%{!S:%b%O}%{S:%b.s}}");
9659 ext = ".gkd";
9661 else if (!compare_debug)
9662 return NULL;
9663 else
9664 do_spec_2 ("%g.gkd");
9666 do_spec_1 (" ", 0, NULL);
9668 gcc_assert (argbuf.length () > 0);
9670 name = concat (argbuf.last (), ext, NULL);
9672 ret = concat ("-fdump-final-insns=", name, NULL);
9675 which = compare_debug < 0;
9676 debug_check_temp_file[which] = name;
9678 if (!which)
9680 unsigned HOST_WIDE_INT value = get_random_number ();
9682 sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value);
9685 if (*random_seed)
9687 char *tmp = ret;
9688 ret = concat ("%{!frandom-seed=*:-frandom-seed=", random_seed, "} ",
9689 ret, NULL);
9690 free (tmp);
9693 if (which)
9694 *random_seed = 0;
9696 return ret;
9699 static const char *debug_auxbase_opt;
9701 /* %:compare-debug-self-opt spec function. Expands to the options
9702 that are to be passed in the second compilation of
9703 compare-debug. */
9705 static const char *
9706 compare_debug_self_opt_spec_function (int arg,
9707 const char **argv ATTRIBUTE_UNUSED)
9709 if (arg != 0)
9710 fatal_error (input_location,
9711 "too many arguments to %%:compare-debug-self-opt");
9713 if (compare_debug >= 0)
9714 return NULL;
9716 do_spec_2 ("%{c|S:%{o*:%*}}");
9717 do_spec_1 (" ", 0, NULL);
9719 if (argbuf.length () > 0)
9720 debug_auxbase_opt = concat ("-auxbase-strip ",
9721 argbuf.last (),
9722 NULL);
9723 else
9724 debug_auxbase_opt = NULL;
9726 return concat ("\
9727 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
9728 %<fdump-final-insns=* -w -S -o %j \
9729 %{!fcompare-debug-second:-fcompare-debug-second} \
9730 ", compare_debug_opt, NULL);
9733 /* %:compare-debug-auxbase-opt spec function. Expands to the auxbase
9734 options that are to be passed in the second compilation of
9735 compare-debug. It expects, as an argument, the basename of the
9736 current input file name, with the .gk suffix appended to it. */
9738 static const char *
9739 compare_debug_auxbase_opt_spec_function (int arg,
9740 const char **argv)
9742 char *name;
9743 int len;
9745 if (arg == 0)
9746 fatal_error (input_location,
9747 "too few arguments to %%:compare-debug-auxbase-opt");
9749 if (arg != 1)
9750 fatal_error (input_location,
9751 "too many arguments to %%:compare-debug-auxbase-opt");
9753 if (compare_debug >= 0)
9754 return NULL;
9756 len = strlen (argv[0]);
9757 if (len < 3 || strcmp (argv[0] + len - 3, ".gk") != 0)
9758 fatal_error (input_location, "argument to %%:compare-debug-auxbase-opt "
9759 "does not end in .gk");
9761 if (debug_auxbase_opt)
9762 return debug_auxbase_opt;
9764 #define OPT "-auxbase "
9766 len -= 3;
9767 name = (char*) xmalloc (sizeof (OPT) + len);
9768 memcpy (name, OPT, sizeof (OPT) - 1);
9769 memcpy (name + sizeof (OPT) - 1, argv[0], len);
9770 name[sizeof (OPT) - 1 + len] = '\0';
9772 #undef OPT
9774 return name;
9777 /* %:pass-through-libs spec function. Finds all -l options and input
9778 file names in the lib spec passed to it, and makes a list of them
9779 prepended with the plugin option to cause them to be passed through
9780 to the final link after all the new object files have been added. */
9782 const char *
9783 pass_through_libs_spec_func (int argc, const char **argv)
9785 char *prepended = xstrdup (" ");
9786 int n;
9787 /* Shlemiel the painter's algorithm. Innately horrible, but at least
9788 we know that there will never be more than a handful of strings to
9789 concat, and it's only once per run, so it's not worth optimising. */
9790 for (n = 0; n < argc; n++)
9792 char *old = prepended;
9793 /* Anything that isn't an option is a full path to an output
9794 file; pass it through if it ends in '.a'. Among options,
9795 pass only -l. */
9796 if (argv[n][0] == '-' && argv[n][1] == 'l')
9798 const char *lopt = argv[n] + 2;
9799 /* Handle both joined and non-joined -l options. If for any
9800 reason there's a trailing -l with no joined or following
9801 arg just discard it. */
9802 if (!*lopt && ++n >= argc)
9803 break;
9804 else if (!*lopt)
9805 lopt = argv[n];
9806 prepended = concat (prepended, "-plugin-opt=-pass-through=-l",
9807 lopt, " ", NULL);
9809 else if (!strcmp (".a", argv[n] + strlen (argv[n]) - 2))
9811 prepended = concat (prepended, "-plugin-opt=-pass-through=",
9812 argv[n], " ", NULL);
9814 if (prepended != old)
9815 free (old);
9817 return prepended;
9820 /* %:replace-extension spec function. Replaces the extension of the
9821 first argument with the second argument. */
9823 const char *
9824 replace_extension_spec_func (int argc, const char **argv)
9826 char *name;
9827 char *p;
9828 char *result;
9829 int i;
9831 if (argc != 2)
9832 fatal_error (input_location, "too few arguments to %%:replace-extension");
9834 name = xstrdup (argv[0]);
9836 for (i = strlen (name) - 1; i >= 0; i--)
9837 if (IS_DIR_SEPARATOR (name[i]))
9838 break;
9840 p = strrchr (name + i + 1, '.');
9841 if (p != NULL)
9842 *p = '\0';
9844 result = concat (name, argv[1], NULL);
9846 free (name);
9847 return result;
9850 /* Returns "" if ARGV[ARGC - 2] is greater than ARGV[ARGC-1].
9851 Otherwise, return NULL. */
9853 static const char *
9854 greater_than_spec_func (int argc, const char **argv)
9856 char *converted;
9858 if (argc == 1)
9859 return NULL;
9861 gcc_assert (argc >= 2);
9863 long arg = strtol (argv[argc - 2], &converted, 10);
9864 gcc_assert (converted != argv[argc - 2]);
9866 long lim = strtol (argv[argc - 1], &converted, 10);
9867 gcc_assert (converted != argv[argc - 1]);
9869 if (arg > lim)
9870 return "";
9872 return NULL;
9875 /* Returns "" if debug_info_level is greater than ARGV[ARGC-1].
9876 Otherwise, return NULL. */
9878 static const char *
9879 debug_level_greater_than_spec_func (int argc, const char **argv)
9881 char *converted;
9883 if (argc != 1)
9884 fatal_error (input_location,
9885 "wrong number of arguments to %%:debug-level-gt");
9887 long arg = strtol (argv[0], &converted, 10);
9888 gcc_assert (converted != argv[0]);
9890 if (debug_info_level > arg)
9891 return "";
9893 return NULL;
9896 /* Insert backslash before spaces in ORIG (usually a file path), to
9897 avoid being broken by spec parser.
9899 This function is needed as do_spec_1 treats white space (' ' and '\t')
9900 as the end of an argument. But in case of -plugin /usr/gcc install/xxx.so,
9901 the file name should be treated as a single argument rather than being
9902 broken into multiple. Solution is to insert '\\' before the space in a
9903 file name.
9905 This function converts and only converts all occurrence of ' '
9906 to '\\' + ' ' and '\t' to '\\' + '\t'. For example:
9907 "a b" -> "a\\ b"
9908 "a b" -> "a\\ \\ b"
9909 "a\tb" -> "a\\\tb"
9910 "a\\ b" -> "a\\\\ b"
9912 orig: input null-terminating string that was allocated by xalloc. The
9913 memory it points to might be freed in this function. Behavior undefined
9914 if ORIG wasn't xalloced or was freed already at entry.
9916 Return: ORIG if no conversion needed. Otherwise a newly allocated string
9917 that was converted from ORIG. */
9919 static char *
9920 convert_white_space (char *orig)
9922 int len, number_of_space = 0;
9924 for (len = 0; orig[len]; len++)
9925 if (orig[len] == ' ' || orig[len] == '\t') number_of_space++;
9927 if (number_of_space)
9929 char *new_spec = (char *) xmalloc (len + number_of_space + 1);
9930 int j, k;
9931 for (j = 0, k = 0; j <= len; j++, k++)
9933 if (orig[j] == ' ' || orig[j] == '\t')
9934 new_spec[k++] = '\\';
9935 new_spec[k] = orig[j];
9937 free (orig);
9938 return new_spec;
9940 else
9941 return orig;
9944 static void
9945 path_prefix_reset (path_prefix *prefix)
9947 struct prefix_list *iter, *next;
9948 iter = prefix->plist;
9949 while (iter)
9951 next = iter->next;
9952 free (const_cast <char *> (iter->prefix));
9953 XDELETE (iter);
9954 iter = next;
9956 prefix->plist = 0;
9957 prefix->max_len = 0;
9960 /* Restore all state within gcc.c to the initial state, so that the driver
9961 code can be safely re-run in-process.
9963 Many const char * variables are referenced by static specs (see
9964 INIT_STATIC_SPEC above). These variables are restored to their default
9965 values by a simple loop over the static specs.
9967 For other variables, we directly restore them all to their initial
9968 values (often implicitly 0).
9970 Free the various obstacks in this file, along with "opts_obstack"
9971 from opts.c.
9973 This function also restores any environment variables that were changed. */
9975 void
9976 driver::finalize ()
9978 env.restore ();
9979 params_c_finalize ();
9980 diagnostic_finish (global_dc);
9982 is_cpp_driver = 0;
9983 at_file_supplied = 0;
9984 print_help_list = 0;
9985 print_version = 0;
9986 verbose_only_flag = 0;
9987 print_subprocess_help = 0;
9988 use_ld = NULL;
9989 report_times_to_file = NULL;
9990 target_system_root = DEFAULT_TARGET_SYSTEM_ROOT;
9991 target_system_root_changed = 0;
9992 target_sysroot_suffix = 0;
9993 target_sysroot_hdrs_suffix = 0;
9994 save_temps_flag = SAVE_TEMPS_NONE;
9995 save_temps_prefix = 0;
9996 save_temps_length = 0;
9997 spec_machine = DEFAULT_TARGET_MACHINE;
9998 greatest_status = 1;
10000 finalize_options_struct (&global_options);
10001 finalize_options_struct (&global_options_set);
10003 obstack_free (&obstack, NULL);
10004 obstack_free (&opts_obstack, NULL); /* in opts.c */
10005 obstack_free (&collect_obstack, NULL);
10007 link_command_spec = LINK_COMMAND_SPEC;
10009 obstack_free (&multilib_obstack, NULL);
10011 user_specs_head = NULL;
10012 user_specs_tail = NULL;
10014 /* Within the "compilers" vec, the fields "suffix" and "spec" were
10015 statically allocated for the default compilers, but dynamically
10016 allocated for additional compilers. Delete them for the latter. */
10017 for (int i = n_default_compilers; i < n_compilers; i++)
10019 free (const_cast <char *> (compilers[i].suffix));
10020 free (const_cast <char *> (compilers[i].spec));
10022 XDELETEVEC (compilers);
10023 compilers = NULL;
10024 n_compilers = 0;
10026 linker_options.truncate (0);
10027 assembler_options.truncate (0);
10028 preprocessor_options.truncate (0);
10030 path_prefix_reset (&exec_prefixes);
10031 path_prefix_reset (&startfile_prefixes);
10032 path_prefix_reset (&include_prefixes);
10034 machine_suffix = 0;
10035 just_machine_suffix = 0;
10036 gcc_exec_prefix = 0;
10037 gcc_libexec_prefix = 0;
10038 md_exec_prefix = MD_EXEC_PREFIX;
10039 md_startfile_prefix = MD_STARTFILE_PREFIX;
10040 md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
10041 multilib_dir = 0;
10042 multilib_os_dir = 0;
10043 multiarch_dir = 0;
10045 /* Free any specs dynamically-allocated by set_spec.
10046 These will be at the head of the list, before the
10047 statically-allocated ones. */
10048 if (specs)
10050 while (specs != static_specs)
10052 spec_list *next = specs->next;
10053 free (const_cast <char *> (specs->name));
10054 XDELETE (specs);
10055 specs = next;
10057 specs = 0;
10059 for (unsigned i = 0; i < ARRAY_SIZE (static_specs); i++)
10061 spec_list *sl = &static_specs[i];
10062 if (sl->alloc_p)
10064 if (0)
10065 free (const_cast <char *> (*(sl->ptr_spec)));
10066 sl->alloc_p = false;
10068 *(sl->ptr_spec) = sl->default_ptr;
10070 #ifdef EXTRA_SPECS
10071 extra_specs = NULL;
10072 #endif
10074 processing_spec_function = 0;
10076 argbuf.truncate (0);
10078 have_c = 0;
10079 have_o = 0;
10081 temp_names = NULL;
10082 execution_count = 0;
10083 signal_count = 0;
10085 temp_filename = NULL;
10086 temp_filename_length = 0;
10087 always_delete_queue = NULL;
10088 failure_delete_queue = NULL;
10090 XDELETEVEC (switches);
10091 switches = NULL;
10092 n_switches = 0;
10093 n_switches_alloc = 0;
10095 compare_debug = 0;
10096 compare_debug_second = 0;
10097 compare_debug_opt = NULL;
10098 for (int i = 0; i < 2; i++)
10100 switches_debug_check[i] = NULL;
10101 n_switches_debug_check[i] = 0;
10102 n_switches_alloc_debug_check[i] = 0;
10103 debug_check_temp_file[i] = NULL;
10106 XDELETEVEC (infiles);
10107 infiles = NULL;
10108 n_infiles = 0;
10109 n_infiles_alloc = 0;
10111 combine_inputs = false;
10112 added_libraries = 0;
10113 XDELETEVEC (outfiles);
10114 outfiles = NULL;
10115 spec_lang = 0;
10116 last_language_n_infiles = 0;
10117 gcc_input_filename = NULL;
10118 input_file_number = 0;
10119 input_filename_length = 0;
10120 basename_length = 0;
10121 suffixed_basename_length = 0;
10122 input_basename = NULL;
10123 input_suffix = NULL;
10124 /* We don't need to purge "input_stat", just to unset "input_stat_set". */
10125 input_stat_set = 0;
10126 input_file_compiler = NULL;
10127 arg_going = 0;
10128 delete_this_arg = 0;
10129 this_is_output_file = 0;
10130 this_is_library_file = 0;
10131 this_is_linker_script = 0;
10132 input_from_pipe = 0;
10133 suffix_subst = NULL;
10135 mdswitches = NULL;
10136 n_mdswitches = 0;
10138 debug_auxbase_opt = NULL;
10140 used_arg.finalize ();
10143 /* PR jit/64810.
10144 Targets can provide configure-time default options in
10145 OPTION_DEFAULT_SPECS. The jit needs to access these, but
10146 they are expressed in the spec language.
10148 Run just enough of the driver to be able to expand these
10149 specs, and then call the callback CB on each
10150 such option. The options strings are *without* a leading
10151 '-' character e.g. ("march=x86-64"). Finally, clean up. */
10153 void
10154 driver_get_configure_time_options (void (*cb) (const char *option,
10155 void *user_data),
10156 void *user_data)
10158 size_t i;
10160 obstack_init (&obstack);
10161 init_opts_obstack ();
10162 n_switches = 0;
10164 for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
10165 do_option_spec (option_default_specs[i].name,
10166 option_default_specs[i].spec);
10168 for (i = 0; (int) i < n_switches; i++)
10170 gcc_assert (switches[i].part1);
10171 (*cb) (switches[i].part1, user_data);
10174 obstack_free (&opts_obstack, NULL);
10175 obstack_free (&obstack, NULL);
10176 n_switches = 0;