1/* Compiler driver program that can handle many languages.
2 Copyright (C) 1987-2017 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.
10
11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3. If not see
18<http://www.gnu.org/licenses/>. */
19
20/* This program is the user interface to the C compiler and possibly to
21other compilers. It is used because compilation is a complicated procedure
22which involves running several programs and passing temporary files between
23them, forwarding the users switches to those programs selectively,
24and deleting the temporary files at the end.
25
26CC recognizes how to compile each input file by suffixes in the file names.
27Once it knows which kind of compilation to perform, the procedure for
28compilation is specified by a string called a "spec". */
29
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"
46
47
48
49/* Manage the manipulation of env vars.
50
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". */
58
59class env_manager
60{
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 ();
66
67 private:
68 bool m_can_restore;
69 bool m_debug;
70 struct kv
71 {
72 char *m_key;
73 char *m_value;
74 };
75 vec<kv> m_keys;
76
77};
78
79/* The singleton instance of class env_manager. */
80
81static env_manager env;
82
83/* Initializer for class env_manager.
84
85 We can't do this as a constructor since we have a statically
86 allocated instance ("env" above). */
87
88void
89env_manager::init (bool can_restore, bool debug)
90{
91 m_can_restore = can_restore;
92 m_debug = debug;
93}
94
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. */
98
99const char *
100env_manager::get (const char *name)
101{
102 const char *result = ::getenv (name);
103 if (m_debug)
104 fprintf (stderr, "env_manager::getenv (%s) -> %s\n", name, result);
105 return result;
106}
107
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. */
112
113void
114env_manager::xput (const char *string)
115{
116 if (m_debug)
117 fprintf (stderr, "env_manager::xput (%s)\n", string);
118 if (verbose_flag)
119 fnotice (stderr, "%s\n", string);
120
121 if (m_can_restore)
122 {
123 char *equals = strchr (const_cast <char *> (string), '=');
124 gcc_assert (equals);
125
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);
133 }
134
135 ::putenv (CONST_CAST (char *, string));
136}
137
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. */
141
142void
143env_manager::restore ()
144{
145 unsigned int i;
146 struct kv *item;
147
148 gcc_assert (m_can_restore);
149
150 FOR_EACH_VEC_ELT_REVERSE (m_keys, i, item)
151 {
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);
160 }
161
162 m_keys.truncate (0);
163}
164
165/* Forbid other uses of getenv and putenv. */
166#if (GCC_VERSION >= 3000)
167#pragma GCC poison getenv putenv
168#endif
169
170
171
172/* By default there is no special suffix for target executables. */
173#ifdef TARGET_EXECUTABLE_SUFFIX
174#define HAVE_TARGET_EXECUTABLE_SUFFIX
175#else
176#define TARGET_EXECUTABLE_SUFFIX ""
177#endif
178
179/* By default there is no special suffix for host executables. */
180#ifdef HOST_EXECUTABLE_SUFFIX
181#define HAVE_HOST_EXECUTABLE_SUFFIX
182#else
183#define HOST_EXECUTABLE_SUFFIX ""
184#endif
185
186/* By default, the suffix for target object files is ".o". */
187#ifdef TARGET_OBJECT_SUFFIX
188#define HAVE_TARGET_OBJECT_SUFFIX
189#else
190#define TARGET_OBJECT_SUFFIX ".o"
191#endif
192
193static const char dir_separator_str[] = { DIR_SEPARATOR, 0 };
194
195/* Most every one is fine with LIBRARY_PATH. For some, it conflicts. */
196#ifndef LIBRARY_PATH_ENV
197#define LIBRARY_PATH_ENV "LIBRARY_PATH"
198#endif
199
200/* If a stage of compilation returns an exit status >= 1,
201 compilation of that file ceases. */
202
203#define MIN_FATAL_STATUS 1
204
205/* Flag set by cppspec.c to 1. */
206int is_cpp_driver;
207
208/* Flag set to nonzero if an @file argument has been supplied to gcc. */
209static bool at_file_supplied;
210
211/* Definition of string containing the arguments given to configure. */
212#include "configargs.h"
213
214/* Flag saying to print the command line options understood by gcc and its
215 sub-processes. */
216
217static int print_help_list;
218
219/* Flag saying to print the version of gcc and its sub-processes. */
220
221static int print_version;
222
223/* Flag indicating whether we should ONLY print the command and
224 arguments (like verbose_flag) without executing the command.
225 Displayed arguments are quoted so that the generated command
226 line is suitable for execution. This is intended for use in
227 shell scripts to capture the driver-generated command line. */
228static int verbose_only_flag;
229
230/* Flag indicating how to print command line options of sub-processes. */
231
232static int print_subprocess_help;
233
234/* Linker suffix passed to -fuse-ld=... */
235static const char *use_ld;
236
237/* Whether we should report subprocess execution times to a file. */
238
239FILE *report_times_to_file = NULL;
240
241/* Nonzero means place this string before uses of /, so that include
242 and library files can be found in an alternate location. */
243
244#ifdef TARGET_SYSTEM_ROOT
245#define DEFAULT_TARGET_SYSTEM_ROOT (TARGET_SYSTEM_ROOT)
246#else
247#define DEFAULT_TARGET_SYSTEM_ROOT (0)
248#endif
249static const char *target_system_root = DEFAULT_TARGET_SYSTEM_ROOT;
250
251/* Nonzero means pass the updated target_system_root to the compiler. */
252
253static int target_system_root_changed;
254
255/* Nonzero means append this string to target_system_root. */
256
257static const char *target_sysroot_suffix = 0;
258
259/* Nonzero means append this string to target_system_root for headers. */
260
261static const char *target_sysroot_hdrs_suffix = 0;
262
263/* Nonzero means write "temp" files in source directory
264 and use the source file's name in them, and don't delete them. */
265
266static enum save_temps {
267 SAVE_TEMPS_NONE, /* no -save-temps */
268 SAVE_TEMPS_CWD, /* -save-temps in current directory */
269 SAVE_TEMPS_OBJ /* -save-temps in object directory */
270} save_temps_flag;
271
272/* Output file to use to get the object directory for -save-temps=obj */
273static char *save_temps_prefix = 0;
274static size_t save_temps_length = 0;
275
276/* The compiler version. */
277
278static const char *compiler_version;
279
280/* The target version. */
281
282static const char *const spec_version = DEFAULT_TARGET_VERSION;
283
284/* The target machine. */
285
286static const char *spec_machine = DEFAULT_TARGET_MACHINE;
287static const char *spec_host_machine = DEFAULT_REAL_TARGET_MACHINE;
288
289/* List of offload targets. Separated by colon. Empty string for
290 -foffload=disable. */
291
292static char *offload_targets = NULL;
293
294/* Nonzero if cross-compiling.
295 When -b is used, the value comes from the `specs' file. */
296
297#ifdef CROSS_DIRECTORY_STRUCTURE
298static const char *cross_compile = "1";
299#else
300static const char *cross_compile = "0";
301#endif
302
303/* Greatest exit code of sub-processes that has been encountered up to
304 now. */
305static int greatest_status = 1;
306
307/* This is the obstack which we use to allocate many strings. */
308
309static struct obstack obstack;
310
311/* This is the obstack to build an environment variable to pass to
312 collect2 that describes all of the relevant switches of what to
313 pass the compiler in building the list of pointers to constructors
314 and destructors. */
315
316static struct obstack collect_obstack;
317
318/* Forward declaration for prototypes. */
319struct path_prefix;
320struct prefix_list;
321
322static void init_spec (void);
323static void store_arg (const char *, int, int);
324static void insert_wrapper (const char *);
325static char *load_specs (const char *);
326static void read_specs (const char *, bool, bool);
327static void set_spec (const char *, const char *, bool);
328static struct compiler *lookup_compiler (const char *, size_t, const char *);
329static char *build_search_list (const struct path_prefix *, const char *,
330 bool, bool);
331static void xputenv (const char *);
332static void putenv_from_prefixes (const struct path_prefix *, const char *,
333 bool);
334static int access_check (const char *, int);
335static char *find_a_file (const struct path_prefix *, const char *, int, bool);
336static void add_prefix (struct path_prefix *, const char *, const char *,
337 int, int, int);
338static void add_sysrooted_prefix (struct path_prefix *, const char *,
339 const char *, int, int, int);
340static char *skip_whitespace (char *);
341static void delete_if_ordinary (const char *);
342static void delete_temp_files (void);
343static void delete_failure_queue (void);
344static void clear_failure_queue (void);
345static int check_live_switch (int, int);
346static const char *handle_braces (const char *);
347static inline bool input_suffix_matches (const char *, const char *);
348static inline bool switch_matches (const char *, const char *, int);
349static inline void mark_matching_switches (const char *, const char *, int);
350static inline void process_marked_switches (void);
351static const char *process_brace_body (const char *, const char *, const char *, int, int);
352static const struct spec_function *lookup_spec_function (const char *);
353static const char *eval_spec_function (const char *, const char *);
354static const char *handle_spec_function (const char *, bool *);
355static char *save_string (const char *, int);
356static void set_collect_gcc_options (void);
357static int do_spec_1 (const char *, int, const char *);
358static int do_spec_2 (const char *);
359static void do_option_spec (const char *, const char *);
360static void do_self_spec (const char *);
361static const char *find_file (const char *);
362static int is_directory (const char *, bool);
363static const char *validate_switches (const char *, bool);
364static void validate_all_switches (void);
365static inline void validate_switches_from_spec (const char *, bool);
366static void give_switch (int, int);
367static int default_arg (const char *, int);
368static void set_multilib_dir (void);
369static void print_multilib_info (void);
370static void perror_with_name (const char *);
371static void display_help (void);
372static void add_preprocessor_option (const char *, int);
373static void add_assembler_option (const char *, int);
374static void add_linker_option (const char *, int);
375static void process_command (unsigned int, struct cl_decoded_option *);
376static int execute (void);
377static void alloc_args (void);
378static void clear_args (void);
379static void fatal_signal (int);
380#if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
381static void init_gcc_specs (struct obstack *, const char *, const char *,
382 const char *);
383#endif
384#if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
385static const char *convert_filename (const char *, int, int);
386#endif
387
388static void try_generate_repro (const char **argv);
389static const char *getenv_spec_function (int, const char **);
390static const char *if_exists_spec_function (int, const char **);
391static const char *if_exists_else_spec_function (int, const char **);
392static const char *sanitize_spec_function (int, const char **);
393static const char *replace_outfile_spec_function (int, const char **);
394static const char *remove_outfile_spec_function (int, const char **);
395static const char *version_compare_spec_function (int, const char **);
396static const char *include_spec_function (int, const char **);
397static const char *find_file_spec_function (int, const char **);
398static const char *find_plugindir_spec_function (int, const char **);
399static const char *print_asm_header_spec_function (int, const char **);
400static const char *compare_debug_dump_opt_spec_function (int, const char **);
401static const char *compare_debug_self_opt_spec_function (int, const char **);
402static const char *compare_debug_auxbase_opt_spec_function (int, const char **);
403static const char *pass_through_libs_spec_func (int, const char **);
404static const char *replace_extension_spec_func (int, const char **);
405static const char *greater_than_spec_func (int, const char **);
406static const char *debug_level_greater_than_spec_func (int, const char **);
407static char *convert_white_space (char *);
408
409/* The Specs Language
410
411Specs are strings containing lines, each of which (if not blank)
412is made up of a program name, and arguments separated by spaces.
413The program name must be exact and start from root, since no path
414is searched and it is unreliable to depend on the current working directory.
415Redirection of input or output is not supported; the subprograms must
416accept filenames saying what files to read and write.
417
418In addition, the specs can contain %-sequences to substitute variable text
419or for conditional text. Here is a table of all defined %-sequences.
420Note that spaces are not generated automatically around the results of
421expanding these sequences; therefore, you can concatenate them together
422or with constant text in a single argument.
423
424 %% substitute one % into the program name or argument.
425 %i substitute the name of the input file being processed.
426 %b substitute the basename of the input file being processed.
427 This is the substring up to (and not including) the last period
428 and not including the directory unless -save-temps was specified
429 to put temporaries in a different location.
430 %B same as %b, but include the file suffix (text after the last period).
431 %gSUFFIX
432 substitute a file name that has suffix SUFFIX and is chosen
433 once per compilation, and mark the argument a la %d. To reduce
434 exposure to denial-of-service attacks, the file name is now
435 chosen in a way that is hard to predict even when previously
436 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
437 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
438 the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
439 had been pre-processed. Previously, %g was simply substituted
440 with a file name chosen once per compilation, without regard
441 to any appended suffix (which was therefore treated just like
442 ordinary text), making such attacks more likely to succeed.
443 %|SUFFIX
444 like %g, but if -pipe is in effect, expands simply to "-".
445 %mSUFFIX
446 like %g, but if -pipe is in effect, expands to nothing. (We have both
447 %| and %m to accommodate differences between system assemblers; see
448 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
449 %uSUFFIX
450 like %g, but generates a new temporary file name even if %uSUFFIX
451 was already seen.
452 %USUFFIX
453 substitutes the last file name generated with %uSUFFIX, generating a
454 new one if there is no such last file name. In the absence of any
455 %uSUFFIX, this is just like %gSUFFIX, except they don't share
456 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
457 would involve the generation of two distinct file names, one
458 for each `%g.s' and another for each `%U.s'. Previously, %U was
459 simply substituted with a file name chosen for the previous %u,
460 without regard to any appended suffix.
461 %jSUFFIX
462 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
463 writable, and if save-temps is off; otherwise, substitute the name
464 of a temporary file, just like %u. This temporary file is not
465 meant for communication between processes, but rather as a junk
466 disposal mechanism.
467 %.SUFFIX
468 substitutes .SUFFIX for the suffixes of a matched switch's args when
469 it is subsequently output with %*. SUFFIX is terminated by the next
470 space or %.
471 %d marks the argument containing or following the %d as a
472 temporary file name, so that file will be deleted if GCC exits
473 successfully. Unlike %g, this contributes no text to the argument.
474 %w marks the argument containing or following the %w as the
475 "output file" of this compilation. This puts the argument
476 into the sequence of arguments that %o will substitute later.
477 %V indicates that this compilation produces no "output file".
478 %W{...}
479 like %{...} but mark last argument supplied within
480 as a file to be deleted on failure.
481 %o substitutes the names of all the output files, with spaces
482 automatically placed around them. You should write spaces
483 around the %o as well or the results are undefined.
484 %o is for use in the specs for running the linker.
485 Input files whose names have no recognized suffix are not compiled
486 at all, but they are included among the output files, so they will
487 be linked.
488 %O substitutes the suffix for object files. Note that this is
489 handled specially when it immediately follows %g, %u, or %U
490 (with or without a suffix argument) because of the need for
491 those to form complete file names. The handling is such that
492 %O is treated exactly as if it had already been substituted,
493 except that %g, %u, and %U do not currently support additional
494 SUFFIX characters following %O as they would following, for
495 example, `.o'.
496 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
497 (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
498 and -B options) and -imultilib as necessary.
499 %s current argument is the name of a library or startup file of some sort.
500 Search for that file in a standard list of directories
501 and substitute the full name found.
502 %eSTR Print STR as an error message. STR is terminated by a newline.
503 Use this when inconsistent options are detected.
504 %nSTR Print STR as a notice. STR is terminated by a newline.
505 %x{OPTION} Accumulate an option for %X.
506 %X Output the accumulated linker options specified by compilations.
507 %Y Output the accumulated assembler options specified by compilations.
508 %Z Output the accumulated preprocessor options specified by compilations.
509 %a process ASM_SPEC as a spec.
510 This allows config.h to specify part of the spec for running as.
511 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
512 used here. This can be used to run a post-processor after the
513 assembler has done its job.
514 %D Dump out a -L option for each directory in startfile_prefixes.
515 If multilib_dir is set, extra entries are generated with it affixed.
516 %l process LINK_SPEC as a spec.
517 %L process LIB_SPEC as a spec.
518 %M Output multilib_os_dir.
519 %G process LIBGCC_SPEC as a spec.
520 %R Output the concatenation of target_system_root and
521 target_sysroot_suffix.
522 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
523 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
524 %C process CPP_SPEC as a spec.
525 %1 process CC1_SPEC as a spec.
526 %2 process CC1PLUS_SPEC as a spec.
527 %* substitute the variable part of a matched option. (See below.)
528 Note that each comma in the substituted string is replaced by
529 a single space. A space is appended after the last substition
530 unless there is more text in current sequence.
531 %<S remove all occurrences of -S from the command line.
532 Note - this command is position dependent. % commands in the
533 spec string before this one will see -S, % commands in the
534 spec string after this one will not.
535 %>S Similar to "%<S", but keep it in the GCC command line.
536 %<S* remove all occurrences of all switches beginning with -S from the
537 command line.
538 %:function(args)
539 Call the named function FUNCTION, passing it ARGS. ARGS is
540 first processed as a nested spec string, then split into an
541 argument vector in the usual fashion. The function returns
542 a string which is processed as if it had appeared literally
543 as part of the current spec.
544 %{S} substitutes the -S switch, if that switch was given to GCC.
545 If that switch was not specified, this substitutes nothing.
546 Here S is a metasyntactic variable.
547 %{S*} substitutes all the switches specified to GCC whose names start
548 with -S. This is used for -o, -I, etc; switches that take
549 arguments. GCC considers `-o foo' as being one switch whose
550 name starts with `o'. %{o*} would substitute this text,
551 including the space; thus, two arguments would be generated.
552 %{S*&T*} likewise, but preserve order of S and T options (the order
553 of S and T in the spec is not significant). Can be any number
554 of ampersand-separated variables; for each the wild card is
555 optional. Useful for CPP as %{D*&U*&A*}.
556
557 %{S:X} substitutes X, if the -S switch was given to GCC.
558 %{!S:X} substitutes X, if the -S switch was NOT given to GCC.
559 %{S*:X} substitutes X if one or more switches whose names start
560 with -S was given to GCC. Normally X is substituted only
561 once, no matter how many such switches appeared. However,
562 if %* appears somewhere in X, then X will be substituted
563 once for each matching switch, with the %* replaced by the
564 part of that switch that matched the '*'. A space will be
565 appended after the last substition unless there is more
566 text in current sequence.
567 %{.S:X} substitutes X, if processing a file with suffix S.
568 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
569 %{,S:X} substitutes X, if processing a file which will use spec S.
570 %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
571
572 %{S|T:X} substitutes X if either -S or -T was given to GCC. This may be
573 combined with '!', '.', ',', and '*' as above binding stronger
574 than the OR.
575 If %* appears in X, all of the alternatives must be starred, and
576 only the first matching alternative is substituted.
577 %{%:function(args):X}
578 Call function named FUNCTION with args ARGS. If the function
579 returns non-NULL, then X is substituted, if it returns
580 NULL, it isn't substituted.
581 %{S:X; if S was given to GCC, substitutes X;
582 T:Y; else if T was given to GCC, substitutes Y;
583 :D} else substitutes D. There can be as many clauses as you need.
584 This may be combined with '.', '!', ',', '|', and '*' as above.
585
586 %(Spec) processes a specification defined in a specs file as *Spec:
587
588The switch matching text S in a %{S}, %{S:X}, or similar construct can use
589a backslash to ignore the special meaning of the character following it,
590thus allowing literal matching of a character that is otherwise specially
591treated. For example, %{std=iso9899\:1999:X} substitutes X if the
592-std=iso9899:1999 option is given.
593
594The conditional text X in a %{S:X} or similar construct may contain
595other nested % constructs or spaces, or even newlines. They are
596processed as usual, as described above. Trailing white space in X is
597ignored. White space may also appear anywhere on the left side of the
598colon in these constructs, except between . or * and the corresponding
599word.
600
601The -O, -f, -g, -m, and -W switches are handled specifically in these
602constructs. If another value of -O or the negated form of a -f, -m, or
603-W switch is found later in the command line, the earlier switch
604value is ignored, except with {S*} where S is just one letter; this
605passes all matching options.
606
607The character | at the beginning of the predicate text is used to indicate
608that a command should be piped to the following command, but only if -pipe
609is specified.
610
611Note that it is built into GCC which switches take arguments and which
612do not. You might think it would be useful to generalize this to
613allow each compiler's spec to say which switches take arguments. But
614this cannot be done in a consistent fashion. GCC cannot even decide
615which input files have been specified without knowing which switches
616take arguments, and it must know which input files to compile in order
617to tell which compilers to run.
618
619GCC also knows implicitly that arguments starting in `-l' are to be
620treated as compiler output files, and passed to the linker in their
621proper position among the other output files. */
622
623/* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
624
625/* config.h can define ASM_SPEC to provide extra args to the assembler
626 or extra switch-translations. */
627#ifndef ASM_SPEC
628#define ASM_SPEC ""
629#endif
630
631/* config.h can define ASM_FINAL_SPEC to run a post processor after
632 the assembler has run. */
633#ifndef ASM_FINAL_SPEC
634#define ASM_FINAL_SPEC \
635 "%{gsplit-dwarf: \n\
636 objcopy --extract-dwo \
637 %{c:%{o*:%*}%{!o*:%b%O}}%{!c:%U%O} \
638 %{c:%{o*:%:replace-extension(%{o*:%*} .dwo)}%{!o*:%b.dwo}}%{!c:%b.dwo} \n\
639 objcopy --strip-dwo \
640 %{c:%{o*:%*}%{!o*:%b%O}}%{!c:%U%O} \
641 }"
642#endif
643
644/* config.h can define CPP_SPEC to provide extra args to the C preprocessor
645 or extra switch-translations. */
646#ifndef CPP_SPEC
647#define CPP_SPEC ""
648#endif
649
650/* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
651 or extra switch-translations. */
652#ifndef CC1_SPEC
653#define CC1_SPEC ""
654#endif
655
656/* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
657 or extra switch-translations. */
658#ifndef CC1PLUS_SPEC
659#define CC1PLUS_SPEC ""
660#endif
661
662/* config.h can define LINK_SPEC to provide extra args to the linker
663 or extra switch-translations. */
664#ifndef LINK_SPEC
665#define LINK_SPEC ""
666#endif
667
668/* config.h can define LIB_SPEC to override the default libraries. */
669#ifndef LIB_SPEC
670#define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
671#endif
672
673/* When using -fsplit-stack we need to wrap pthread_create, in order
674 to initialize the stack guard. We always use wrapping, rather than
675 shared library ordering, and we keep the wrapper function in
676 libgcc. This is not yet a real spec, though it could become one;
677 it is currently just stuffed into LINK_SPEC. FIXME: This wrapping
678 only works with GNU ld and gold. */
679#ifdef HAVE_GOLD_NON_DEFAULT_SPLIT_STACK
680#define STACK_SPLIT_SPEC " %{fsplit-stack: -fuse-ld=gold --wrap=pthread_create}"
681#else
682#define STACK_SPLIT_SPEC " %{fsplit-stack: --wrap=pthread_create}"
683#endif
684
685#ifndef LIBASAN_SPEC
686#define STATIC_LIBASAN_LIBS \
687 " %{static-libasan:%:include(libsanitizer.spec)%(link_libasan)}"
688#ifdef LIBASAN_EARLY_SPEC
689#define LIBASAN_SPEC STATIC_LIBASAN_LIBS
690#elif defined(HAVE_LD_STATIC_DYNAMIC)
691#define LIBASAN_SPEC "%{static-libasan:" LD_STATIC_OPTION \
692 "} -lasan %{static-libasan:" LD_DYNAMIC_OPTION "}" \
693 STATIC_LIBASAN_LIBS
694#else
695#define LIBASAN_SPEC "-lasan" STATIC_LIBASAN_LIBS
696#endif
697#endif
698
699#ifndef LIBASAN_EARLY_SPEC
700#define LIBASAN_EARLY_SPEC ""
701#endif
702
703#ifndef LIBTSAN_SPEC
704#define STATIC_LIBTSAN_LIBS \
705 " %{static-libtsan:%:include(libsanitizer.spec)%(link_libtsan)}"
706#ifdef LIBTSAN_EARLY_SPEC
707#define LIBTSAN_SPEC STATIC_LIBTSAN_LIBS
708#elif defined(HAVE_LD_STATIC_DYNAMIC)
709#define LIBTSAN_SPEC "%{static-libtsan:" LD_STATIC_OPTION \
710 "} -ltsan %{static-libtsan:" LD_DYNAMIC_OPTION "}" \
711 STATIC_LIBTSAN_LIBS
712#else
713#define LIBTSAN_SPEC "-ltsan" STATIC_LIBTSAN_LIBS
714#endif
715#endif
716
717#ifndef LIBTSAN_EARLY_SPEC
718#define LIBTSAN_EARLY_SPEC ""
719#endif
720
721#ifndef LIBLSAN_SPEC
722#define STATIC_LIBLSAN_LIBS \
723 " %{static-liblsan:%:include(libsanitizer.spec)%(link_liblsan)}"
724#ifdef LIBLSAN_EARLY_SPEC
725#define LIBLSAN_SPEC STATIC_LIBLSAN_LIBS
726#elif defined(HAVE_LD_STATIC_DYNAMIC)
727#define LIBLSAN_SPEC "%{static-liblsan:" LD_STATIC_OPTION \
728 "} -llsan %{static-liblsan:" LD_DYNAMIC_OPTION "}" \
729 STATIC_LIBLSAN_LIBS
730#else
731#define LIBLSAN_SPEC "-llsan" STATIC_LIBLSAN_LIBS
732#endif
733#endif
734
735#ifndef LIBLSAN_EARLY_SPEC
736#define LIBLSAN_EARLY_SPEC ""
737#endif
738
739#ifndef LIBUBSAN_SPEC
740#define STATIC_LIBUBSAN_LIBS \
741 " %{static-libubsan:%:include(libsanitizer.spec)%(link_libubsan)}"
742#ifdef HAVE_LD_STATIC_DYNAMIC
743#define LIBUBSAN_SPEC "%{static-libubsan:" LD_STATIC_OPTION \
744 "} -lubsan %{static-libubsan:" LD_DYNAMIC_OPTION "}" \
745 STATIC_LIBUBSAN_LIBS
746#else
747#define LIBUBSAN_SPEC "-lubsan" STATIC_LIBUBSAN_LIBS
748#endif
749#endif
750
751/* Linker options for compressed debug sections. */
752#if HAVE_LD_COMPRESS_DEBUG == 0
753/* No linker support. */
754#define LINK_COMPRESS_DEBUG_SPEC \
755 " %{gz*:%e-gz is not supported in this configuration} "
756#elif HAVE_LD_COMPRESS_DEBUG == 1
757/* GNU style on input, GNU ld options. Reject, not useful. */
758#define LINK_COMPRESS_DEBUG_SPEC \
759 " %{gz*:%e-gz is not supported in this configuration} "
760#elif HAVE_LD_COMPRESS_DEBUG == 2
761/* GNU style, GNU gold options. */
762#define LINK_COMPRESS_DEBUG_SPEC \
763 " %{gz|gz=zlib-gnu:" LD_COMPRESS_DEBUG_OPTION "=zlib}" \
764 " %{gz=none:" LD_COMPRESS_DEBUG_OPTION "=none}" \
765 " %{gz=zlib:%e-gz=zlib is not supported in this configuration} "
766#elif HAVE_LD_COMPRESS_DEBUG == 3
767/* ELF gABI style. */
768#define LINK_COMPRESS_DEBUG_SPEC \
769 " %{gz|gz=zlib:" LD_COMPRESS_DEBUG_OPTION "=zlib}" \
770 " %{gz=none:" LD_COMPRESS_DEBUG_OPTION "=none}" \
771 " %{gz=zlib-gnu:" LD_COMPRESS_DEBUG_OPTION "=zlib-gnu} "
772#else
773#error Unknown value for HAVE_LD_COMPRESS_DEBUG.
774#endif
775
776/* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
777 included. */
778#ifndef LIBGCC_SPEC
779#if defined(REAL_LIBGCC_SPEC)
780#define LIBGCC_SPEC REAL_LIBGCC_SPEC
781#elif defined(LINK_LIBGCC_SPECIAL_1)
782/* Have gcc do the search for libgcc.a. */
783#define LIBGCC_SPEC "libgcc.a%s"
784#else
785#define LIBGCC_SPEC "-lgcc"
786#endif
787#endif
788
789/* config.h can define STARTFILE_SPEC to override the default crt0 files. */
790#ifndef STARTFILE_SPEC
791#define STARTFILE_SPEC \
792 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
793#endif
794
795/* config.h can define ENDFILE_SPEC to override the default crtn files. */
796#ifndef ENDFILE_SPEC
797#define ENDFILE_SPEC ""
798#endif
799
800#ifndef LINKER_NAME
801#define LINKER_NAME "collect2"
802#endif
803
804#ifdef HAVE_AS_DEBUG_PREFIX_MAP
805#define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
806#else
807#define ASM_MAP ""
808#endif
809
810/* Assembler options for compressed debug sections. */
811#if HAVE_LD_COMPRESS_DEBUG < 2
812/* Reject if the linker cannot write compressed debug sections. */
813#define ASM_COMPRESS_DEBUG_SPEC \
814 " %{gz*:%e-gz is not supported in this configuration} "
815#else /* HAVE_LD_COMPRESS_DEBUG >= 2 */
816#if HAVE_AS_COMPRESS_DEBUG == 0
817/* No assembler support. Ignore silently. */
818#define ASM_COMPRESS_DEBUG_SPEC \
819 " %{gz*:} "
820#elif HAVE_AS_COMPRESS_DEBUG == 1
821/* GNU style, GNU as options. */
822#define ASM_COMPRESS_DEBUG_SPEC \
823 " %{gz|gz=zlib-gnu:" AS_COMPRESS_DEBUG_OPTION "}" \
824 " %{gz=none:" AS_NO_COMPRESS_DEBUG_OPTION "}" \
825 " %{gz=zlib:%e-gz=zlib is not supported in this configuration} "
826#elif HAVE_AS_COMPRESS_DEBUG == 2
827/* ELF gABI style. */
828#define ASM_COMPRESS_DEBUG_SPEC \
829 " %{gz|gz=zlib:" AS_COMPRESS_DEBUG_OPTION "=zlib}" \
830 " %{gz=none:" AS_COMPRESS_DEBUG_OPTION "=none}" \
831 " %{gz=zlib-gnu:" AS_COMPRESS_DEBUG_OPTION "=zlib-gnu} "
832#else
833#error Unknown value for HAVE_AS_COMPRESS_DEBUG.
834#endif
835#endif /* HAVE_LD_COMPRESS_DEBUG >= 2 */
836
837/* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
838 to the assembler. */
839#ifndef ASM_DEBUG_SPEC
840# if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
841 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
842# define ASM_DEBUG_SPEC \
843 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
844 ? "%{%:debug-level-gt(0):" \
845 "%{gdwarf*:--gdwarf2}%{!gdwarf*:%{g*:--gstabs}}}" ASM_MAP \
846 : "%{%:debug-level-gt(0):" \
847 "%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}}" ASM_MAP)
848# else
849# if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
850# define ASM_DEBUG_SPEC "%{g*:%{%:debug-level-gt(0):--gstabs}}" ASM_MAP
851# endif
852# if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
853# define ASM_DEBUG_SPEC "%{g*:%{%:debug-level-gt(0):--gdwarf2}}" ASM_MAP
854# endif
855# endif
856#endif
857#ifndef ASM_DEBUG_SPEC
858# define ASM_DEBUG_SPEC ""
859#endif
860
861/* Here is the spec for running the linker, after compiling all files. */
862
863/* This is overridable by the target in case they need to specify the
864 -lgcc and -lc order specially, yet not require them to override all
865 of LINK_COMMAND_SPEC. */
866#ifndef LINK_GCC_C_SEQUENCE_SPEC
867#define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
868#endif
869
870#ifndef LINK_SSP_SPEC
871#ifdef TARGET_LIBC_PROVIDES_SSP
872#define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all" \
873 "|fstack-protector-strong|fstack-protector-explicit:}"
874#else
875#define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all" \
876 "|fstack-protector-strong|fstack-protector-explicit" \
877 ":-lssp_nonshared -lssp}"
878#endif
879#endif
880
881#ifdef ENABLE_DEFAULT_PIE
882#define PIE_SPEC "!no-pie"
883#define NO_FPIE1_SPEC "fno-pie"
884#define FPIE1_SPEC NO_FPIE1_SPEC ":;"
885#define NO_FPIE2_SPEC "fno-PIE"
886#define FPIE2_SPEC NO_FPIE2_SPEC ":;"
887#define NO_FPIE_SPEC NO_FPIE1_SPEC "|" NO_FPIE2_SPEC
888#define FPIE_SPEC NO_FPIE_SPEC ":;"
889#define NO_FPIC1_SPEC "fno-pic"
890#define FPIC1_SPEC NO_FPIC1_SPEC ":;"
891#define NO_FPIC2_SPEC "fno-PIC"
892#define FPIC2_SPEC NO_FPIC2_SPEC ":;"
893#define NO_FPIC_SPEC NO_FPIC1_SPEC "|" NO_FPIC2_SPEC
894#define FPIC_SPEC NO_FPIC_SPEC ":;"
895#define NO_FPIE1_AND_FPIC1_SPEC NO_FPIE1_SPEC "|" NO_FPIC1_SPEC
896#define FPIE1_OR_FPIC1_SPEC NO_FPIE1_AND_FPIC1_SPEC ":;"
897#define NO_FPIE2_AND_FPIC2_SPEC NO_FPIE2_SPEC "|" NO_FPIC2_SPEC
898#define FPIE2_OR_FPIC2_SPEC NO_FPIE2_AND_FPIC2_SPEC ":;"
899#define NO_FPIE_AND_FPIC_SPEC NO_FPIE_SPEC "|" NO_FPIC_SPEC
900#define FPIE_OR_FPIC_SPEC NO_FPIE_AND_FPIC_SPEC ":;"
901#else
902#define PIE_SPEC "pie"
903#define FPIE1_SPEC "fpie"
904#define NO_FPIE1_SPEC FPIE1_SPEC ":;"
905#define FPIE2_SPEC "fPIE"
906#define NO_FPIE2_SPEC FPIE2_SPEC ":;"
907#define FPIE_SPEC FPIE1_SPEC "|" FPIE2_SPEC
908#define NO_FPIE_SPEC FPIE_SPEC ":;"
909#define FPIC1_SPEC "fpic"
910#define NO_FPIC1_SPEC FPIC1_SPEC ":;"
911#define FPIC2_SPEC "fPIC"
912#define NO_FPIC2_SPEC FPIC2_SPEC ":;"
913#define FPIC_SPEC FPIC1_SPEC "|" FPIC2_SPEC
914#define NO_FPIC_SPEC FPIC_SPEC ":;"
915#define FPIE1_OR_FPIC1_SPEC FPIE1_SPEC "|" FPIC1_SPEC
916#define NO_FPIE1_AND_FPIC1_SPEC FPIE1_OR_FPIC1_SPEC ":;"
917#define FPIE2_OR_FPIC2_SPEC FPIE2_SPEC "|" FPIC2_SPEC
918#define NO_FPIE2_AND_FPIC2_SPEC FPIE1_OR_FPIC2_SPEC ":;"
919#define FPIE_OR_FPIC_SPEC FPIE_SPEC "|" FPIC_SPEC
920#define NO_FPIE_AND_FPIC_SPEC FPIE_OR_FPIC_SPEC ":;"
921#endif
922
923#ifndef LINK_PIE_SPEC
924#ifdef HAVE_LD_PIE
925#ifndef LD_PIE_SPEC
926#define LD_PIE_SPEC "-pie"
927#endif
928#else
929#define LD_PIE_SPEC ""
930#endif
931#define LINK_PIE_SPEC "%{static|shared|r:;" PIE_SPEC ":" LD_PIE_SPEC "} "
932#endif
933
934#ifndef LINK_BUILDID_SPEC
935# if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
936# define LINK_BUILDID_SPEC "%{!r:--build-id} "
937# endif
938#endif
939
940/* Conditional to test whether the LTO plugin is used or not.
941 FIXME: For slim LTO we will need to enable plugin unconditionally. This
942 still cause problems with PLUGIN_LD != LD and when plugin is built but
943 not useable. For GCC 4.6 we don't support slim LTO and thus we can enable
944 plugin only when LTO is enabled. We still honor explicit
945 -fuse-linker-plugin if the linker used understands -plugin. */
946
947/* The linker has some plugin support. */
948#if HAVE_LTO_PLUGIN > 0
949/* The linker used has full plugin support, use LTO plugin by default. */
950#if HAVE_LTO_PLUGIN == 2
951#define PLUGIN_COND "!fno-use-linker-plugin:%{!fno-lto"
952#define PLUGIN_COND_CLOSE "}"
953#else
954/* The linker used has limited plugin support, use LTO plugin with explicit
955 -fuse-linker-plugin. */
956#define PLUGIN_COND "fuse-linker-plugin"
957#define PLUGIN_COND_CLOSE ""
958#endif
959#define LINK_PLUGIN_SPEC \
960 "%{" PLUGIN_COND": \
961 -plugin %(linker_plugin_file) \
962 -plugin-opt=%(lto_wrapper) \
963 -plugin-opt=-fresolution=%u.res \
964 %{!nostdlib:%{!nodefaultlibs:%:pass-through-libs(%(link_gcc_c_sequence))}} \
965 }" PLUGIN_COND_CLOSE
966#else
967/* The linker used doesn't support -plugin, reject -fuse-linker-plugin. */
968#define LINK_PLUGIN_SPEC "%{fuse-linker-plugin:\
969 %e-fuse-linker-plugin is not supported in this configuration}"
970#endif
971
972/* Linker command line options for -fsanitize= early on the command line. */
973#ifndef SANITIZER_EARLY_SPEC
974#define SANITIZER_EARLY_SPEC "\
975%{!nostdlib:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_EARLY_SPEC "} \
976 %{%:sanitize(thread):" LIBTSAN_EARLY_SPEC "} \
977 %{%:sanitize(leak):" LIBLSAN_EARLY_SPEC "}}}"
978#endif
979
980/* Linker command line options for -fsanitize= late on the command line. */
981#ifndef SANITIZER_SPEC
982#define SANITIZER_SPEC "\
983%{!nostdlib:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_SPEC "\
984 %{static:%ecannot specify -static with -fsanitize=address}}\
985 %{%:sanitize(thread):" LIBTSAN_SPEC "\
986 %{static:%ecannot specify -static with -fsanitize=thread}}\
987 %{%:sanitize(undefined):" LIBUBSAN_SPEC "}\
988 %{%:sanitize(leak):" LIBLSAN_SPEC "}}}"
989#endif
990
991#ifndef POST_LINK_SPEC
992#define POST_LINK_SPEC ""
993#endif
994
995/* This is the spec to use, once the code for creating the vtable
996 verification runtime library, libvtv.so, has been created. Currently
997 the vtable verification runtime functions are in libstdc++, so we use
998 the spec just below this one. */
999#ifndef VTABLE_VERIFICATION_SPEC
1000#if ENABLE_VTABLE_VERIFY
1001#define VTABLE_VERIFICATION_SPEC "\
1002%{!nostdlib:%{fvtable-verify=std: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}\
1003 %{fvtable-verify=preinit: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}}"
1004#else
1005#define VTABLE_VERIFICATION_SPEC "\
1006%{fvtable-verify=none:} \
1007%{fvtable-verify=std: \
1008 %e-fvtable-verify=std is not supported in this configuration} \
1009%{fvtable-verify=preinit: \
1010 %e-fvtable-verify=preinit is not supported in this configuration}"
1011#endif
1012#endif
1013
1014#ifndef CHKP_SPEC
1015#define CHKP_SPEC ""
1016#endif
1017
1018/* -u* was put back because both BSD and SysV seem to support it. */
1019/* %{static|no-pie|static-pie:} simply prevents an error message:
1020 1. If the target machine doesn't handle -static.
1021 2. If PIE isn't enabled by default.
1022 3. If the target machine doesn't handle -static-pie.
1023 */
1024/* We want %{T*} after %{L*} and %D so that it can be used to specify linker
1025 scripts which exist in user specified directories, or in standard
1026 directories. */
1027/* We pass any -flto flags on to the linker, which is expected
1028 to understand them. In practice, this means it had better be collect2. */
1029/* %{e*} includes -export-dynamic; see comment in common.opt. */
1030#ifndef LINK_COMMAND_SPEC
1031#define LINK_COMMAND_SPEC "\
1032%{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
1033 %(linker) " \
1034 LINK_PLUGIN_SPEC \
1035 "%{flto|flto=*:%<fcompare-debug*} \
1036 %{flto} %{fno-lto} %{flto=*} %l " LINK_PIE_SPEC \
1037 "%{fuse-ld=*:-fuse-ld=%*} " LINK_COMPRESS_DEBUG_SPEC \
1038 "%X %{o*} %{e*} %{N} %{n} %{r}\
1039 %{s} %{t} %{u*} %{z} %{Z} %{!nostdlib:%{!nostartfiles:%S}} \
1040 %{static|no-pie|static-pie:} %{L*} %(mfwrap) %(link_libgcc) " \
1041 VTABLE_VERIFICATION_SPEC " " SANITIZER_EARLY_SPEC " %o " CHKP_SPEC " \
1042 %{fopenacc|fopenmp|%:gt(%{ftree-parallelize-loops=*:%*} 1):\
1043 %:include(libgomp.spec)%(link_gomp)}\
1044 %{fgnu-tm:%:include(libitm.spec)%(link_itm)}\
1045 %(mflib) " STACK_SPLIT_SPEC "\
1046 %{fprofile-arcs|fprofile-generate*|coverage:-lgcov} " SANITIZER_SPEC " \
1047 %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\
1048 %{!nostdlib:%{!nostartfiles:%E}} %{T*} \n%(post_link) }}}}}}"
1049#endif
1050
1051#ifndef LINK_LIBGCC_SPEC
1052/* Generate -L options for startfile prefix list. */
1053# define LINK_LIBGCC_SPEC "%D"
1054#endif
1055
1056#ifndef STARTFILE_PREFIX_SPEC
1057# define STARTFILE_PREFIX_SPEC ""
1058#endif
1059
1060#ifndef SYSROOT_SPEC
1061# define SYSROOT_SPEC "--sysroot=%R"
1062#endif
1063
1064#ifndef SYSROOT_SUFFIX_SPEC
1065# define SYSROOT_SUFFIX_SPEC ""
1066#endif
1067
1068#ifndef SYSROOT_HEADERS_SUFFIX_SPEC
1069# define SYSROOT_HEADERS_SUFFIX_SPEC ""
1070#endif
1071
1072static const char *asm_debug = ASM_DEBUG_SPEC;
1073static const char *cpp_spec = CPP_SPEC;
1074static const char *cc1_spec = CC1_SPEC;
1075static const char *cc1plus_spec = CC1PLUS_SPEC;
1076static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC;
1077static const char *link_ssp_spec = LINK_SSP_SPEC;
1078static const char *asm_spec = ASM_SPEC;
1079static const char *asm_final_spec = ASM_FINAL_SPEC;
1080static const char *link_spec = LINK_SPEC;
1081static const char *lib_spec = LIB_SPEC;
1082static const char *link_gomp_spec = "";
1083static const char *libgcc_spec = LIBGCC_SPEC;
1084static const char *endfile_spec = ENDFILE_SPEC;
1085static const char *startfile_spec = STARTFILE_SPEC;
1086static const char *linker_name_spec = LINKER_NAME;
1087static const char *linker_plugin_file_spec = "";
1088static const char *lto_wrapper_spec = "";
1089static const char *lto_gcc_spec = "";
1090static const char *post_link_spec = POST_LINK_SPEC;
1091static const char *link_command_spec = LINK_COMMAND_SPEC;
1092static const char *link_libgcc_spec = LINK_LIBGCC_SPEC;
1093static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC;
1094static const char *sysroot_spec = SYSROOT_SPEC;
1095static const char *sysroot_suffix_spec = SYSROOT_SUFFIX_SPEC;
1096static const char *sysroot_hdrs_suffix_spec = SYSROOT_HEADERS_SUFFIX_SPEC;
1097static const char *self_spec = "";
1098
1099/* Standard options to cpp, cc1, and as, to reduce duplication in specs.
1100 There should be no need to override these in target dependent files,
1101 but we need to copy them to the specs file so that newer versions
1102 of the GCC driver can correctly drive older tool chains with the
1103 appropriate -B options. */
1104
1105/* When cpplib handles traditional preprocessing, get rid of this, and
1106 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
1107 that we default the front end language better. */
1108static const char *trad_capable_cpp =
1109"cc1 -E %{traditional|traditional-cpp:-traditional-cpp}";
1110
1111/* We don't wrap .d files in %W{} since a missing .d file, and
1112 therefore no dependency entry, confuses make into thinking a .o
1113 file that happens to exist is up-to-date. */
1114static const char *cpp_unique_options =
1115"%{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\
1116 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
1117 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
1118 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
1119 %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
1120 %{remap} %{g3|ggdb3|gstabs3|gxcoff3|gvms3:-dD}\
1121 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
1122 %{H} %C %{D*&U*&A*} %{i*} %Z %i\
1123 %{E|M|MM:%W{o*}}";
1124
1125/* This contains cpp options which are common with cc1_options and are passed
1126 only when preprocessing only to avoid duplication. We pass the cc1 spec
1127 options to the preprocessor so that it the cc1 spec may manipulate
1128 options used to set target flags. Those special target flags settings may
1129 in turn cause preprocessor symbols to be defined specially. */
1130static const char *cpp_options =
1131"%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
1132 %{f*} %{g*:%{%:debug-level-gt(0):%{g*}\
1133 %{!fno-working-directory:-fworking-directory}}} %{O*}\
1134 %{undef} %{save-temps*:-fpch-preprocess}";
1135
1136/* This contains cpp options which are not passed when the preprocessor
1137 output will be used by another program. */
1138static const char *cpp_debug_options = "%{d*}";
1139
1140/* NB: This is shared amongst all front-ends, except for Ada. */
1141static const char *cc1_options =
1142"%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
1143 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
1144 %1 %{!Q:-quiet} %{!dumpbase:-dumpbase %B} %{d*} %{m*} %{aux-info*}\
1145 %{fcompare-debug-second:%:compare-debug-auxbase-opt(%b)} \
1146 %{!fcompare-debug-second:%{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}}%{!c:%{!S:-auxbase %b}} \
1147 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
1148 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
1149 %{Qn:-fno-ident} %{Qy:} %{-help:--help}\
1150 %{-target-help:--target-help}\
1151 %{-version:--version}\
1152 %{-help=*:--help=%*}\
1153 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
1154 %{fsyntax-only:-o %j} %{-param*}\
1155 %{coverage:-fprofile-arcs -ftest-coverage}\
1156 %{fprofile-arcs|fprofile-generate*|coverage:\
1157 %{!fprofile-update=single:\
1158 %{pthread:-fprofile-update=prefer-atomic}}}";
1159
1160static const char *asm_options =
1161"%{-target-help:%:print-asm-header()} "
1162#if HAVE_GNU_AS
1163/* If GNU AS is used, then convert -w (no warnings), -I, and -v
1164 to the assembler equivalents. */
1165"%{v} %{w:-W} %{I*} "
1166#endif
1167ASM_COMPRESS_DEBUG_SPEC
1168"%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
1169
1170static const char *invoke_as =
1171#ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1172"%{!fwpa*:\
1173 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
1174 %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
1175 }";
1176#else
1177"%{!fwpa*:\
1178 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
1179 %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
1180 }";
1181#endif
1182
1183/* Some compilers have limits on line lengths, and the multilib_select
1184 and/or multilib_matches strings can be very long, so we build them at
1185 run time. */
1186static struct obstack multilib_obstack;
1187static const char *multilib_select;
1188static const char *multilib_matches;
1189static const char *multilib_defaults;
1190static const char *multilib_exclusions;
1191static const char *multilib_reuse;
1192
1193/* Check whether a particular argument is a default argument. */
1194
1195#ifndef MULTILIB_DEFAULTS
1196#define MULTILIB_DEFAULTS { "" }
1197#endif
1198
1199static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
1200
1201#ifndef DRIVER_SELF_SPECS
1202#define DRIVER_SELF_SPECS ""
1203#endif
1204
1205/* Linking to libgomp implies pthreads. This is particularly important
1206 for targets that use different start files and suchlike. */
1207#ifndef GOMP_SELF_SPECS
1208#define GOMP_SELF_SPECS \
1209 "%{fopenacc|fopenmp|%:gt(%{ftree-parallelize-loops=*:%*} 1): " \
1210 "-pthread}"
1211#endif
1212
1213/* Likewise for -fgnu-tm. */
1214#ifndef GTM_SELF_SPECS
1215#define GTM_SELF_SPECS "%{fgnu-tm: -pthread}"
1216#endif
1217
1218static const char *const driver_self_specs[] = {
1219 "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
1220 DRIVER_SELF_SPECS, CONFIGURE_SPECS, GOMP_SELF_SPECS, GTM_SELF_SPECS
1221};
1222
1223#ifndef OPTION_DEFAULT_SPECS
1224#define OPTION_DEFAULT_SPECS { "", "" }
1225#endif
1226
1227struct default_spec
1228{
1229 const char *name;
1230 const char *spec;
1231};
1232
1233static const struct default_spec
1234 option_default_specs[] = { OPTION_DEFAULT_SPECS };
1235
1236struct user_specs
1237{
1238 struct user_specs *next;
1239 const char *filename;
1240};
1241
1242static struct user_specs *user_specs_head, *user_specs_tail;
1243
1244
1245/* Record the mapping from file suffixes for compilation specs. */
1246
1247struct compiler
1248{
1249 const char *suffix; /* Use this compiler for input files
1250 whose names end in this suffix. */
1251
1252 const char *spec; /* To use this compiler, run this spec. */
1253
1254 const char *cpp_spec; /* If non-NULL, substitute this spec
1255 for `%C', rather than the usual
1256 cpp_spec. */
1257 int combinable; /* If nonzero, compiler can deal with
1258 multiple source files at once (IMA). */
1259 int needs_preprocessing; /* If nonzero, source files need to
1260 be run through a preprocessor. */
1261};
1262
1263/* Pointer to a vector of `struct compiler' that gives the spec for
1264 compiling a file, based on its suffix.
1265 A file that does not end in any of these suffixes will be passed
1266 unchanged to the loader and nothing else will be done to it.
1267
1268 An entry containing two 0s is used to terminate the vector.
1269
1270 If multiple entries match a file, the last matching one is used. */
1271
1272static struct compiler *compilers;
1273
1274/* Number of entries in `compilers', not counting the null terminator. */
1275
1276static int n_compilers;
1277
1278/* The default list of file name suffixes and their compilation specs. */
1279
1280static const struct compiler default_compilers[] =
1281{
1282 /* Add lists of suffixes of known languages here. If those languages
1283 were not present when we built the driver, we will hit these copies
1284 and be given a more meaningful error than "file not used since
1285 linking is not done". */
1286 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0},
1287 {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
1288 {".mii", "#Objective-C++", 0, 0, 0},
1289 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
1290 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
1291 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
1292 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
1293 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
1294 {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
1295 {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
1296 {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
1297 {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
1298 {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
1299 {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
1300 {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
1301 {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
1302 {".r", "#Ratfor", 0, 0, 0},
1303 {".go", "#Go", 0, 1, 0},
1304 /* Next come the entries for C. */
1305 {".c", "@c", 0, 0, 1},
1306 {"@c",
1307 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1308 external preprocessor if -save-temps is given. */
1309 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1310 %{!E:%{!M:%{!MM:\
1311 %{traditional:\
1312%eGNU C no longer supports -traditional without -E}\
1313 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1314 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1315 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1316 %(cc1_options)}\
1317 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1318 cc1 %(cpp_unique_options) %(cc1_options)}}}\
1319 %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 1},
1320 {"-",
1321 "%{!E:%e-E or -x required when input is from standard input}\
1322 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
1323 {".h", "@c-header", 0, 0, 0},
1324 {"@c-header",
1325 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1326 external preprocessor if -save-temps is given. */
1327 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1328 %{!E:%{!M:%{!MM:\
1329 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1330 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1331 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1332 %(cc1_options)\
1333 %{!fsyntax-only:%{!S:-o %g.s} \
1334 %{!fdump-ada-spec*:%{!o*:--output-pch=%i.gch}\
1335 %W{o*:--output-pch=%*}}%V}}\
1336 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1337 cc1 %(cpp_unique_options) %(cc1_options)\
1338 %{!fsyntax-only:%{!S:-o %g.s} \
1339 %{!fdump-ada-spec*:%{!o*:--output-pch=%i.gch}\
1340 %W{o*:--output-pch=%*}}%V}}}}}}}", 0, 0, 0},
1341 {".i", "@cpp-output", 0, 0, 0},
1342 {"@cpp-output",
1343 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 0},
1344 {".s", "@assembler", 0, 0, 0},
1345 {"@assembler",
1346 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 0, 0},
1347 {".sx", "@assembler-with-cpp", 0, 0, 0},
1348 {".S", "@assembler-with-cpp", 0, 0, 0},
1349 {"@assembler-with-cpp",
1350#ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1351 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1352 %{E|M|MM:%(cpp_debug_options)}\
1353 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1354 as %(asm_debug) %(asm_options) %|.s %A }}}}"
1355#else
1356 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1357 %{E|M|MM:%(cpp_debug_options)}\
1358 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1359 as %(asm_debug) %(asm_options) %m.s %A }}}}"
1360#endif
1361 , 0, 0, 0},
1362
1363#include "specs.h"
1364 /* Mark end of table. */
1365 {0, 0, 0, 0, 0}
1366};
1367
1368/* Number of elements in default_compilers, not counting the terminator. */
1369
1370static const int n_default_compilers = ARRAY_SIZE (default_compilers) - 1;
1371
1372typedef char *char_p; /* For DEF_VEC_P. */
1373
1374/* A vector of options to give to the linker.
1375 These options are accumulated by %x,
1376 and substituted into the linker command with %X. */
1377static vec<char_p> linker_options;
1378
1379/* A vector of options to give to the assembler.
1380 These options are accumulated by -Wa,
1381 and substituted into the assembler command with %Y. */
1382static vec<char_p> assembler_options;
1383
1384/* A vector of options to give to the preprocessor.
1385 These options are accumulated by -Wp,
1386 and substituted into the preprocessor command with %Z. */
1387static vec<char_p> preprocessor_options;
1388
1389static char *
1390skip_whitespace (char *p)
1391{
1392 while (1)
1393 {
1394 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1395 be considered whitespace. */
1396 if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
1397 return p + 1;
1398 else if (*p == '\n' || *p == ' ' || *p == '\t')
1399 p++;
1400 else if (*p == '#')
1401 {
1402 while (*p != '\n')
1403 p++;
1404 p++;
1405 }
1406 else
1407 break;
1408 }
1409
1410 return p;
1411}
1412/* Structures to keep track of prefixes to try when looking for files. */
1413
1414struct prefix_list
1415{
1416 const char *prefix; /* String to prepend to the path. */
1417 struct prefix_list *next; /* Next in linked list. */
1418 int require_machine_suffix; /* Don't use without machine_suffix. */
1419 /* 2 means try both machine_suffix and just_machine_suffix. */
1420 int priority; /* Sort key - priority within list. */
1421 int os_multilib; /* 1 if OS multilib scheme should be used,
1422 0 for GCC multilib scheme. */
1423};
1424
1425struct path_prefix
1426{
1427 struct prefix_list *plist; /* List of prefixes to try */
1428 int max_len; /* Max length of a prefix in PLIST */
1429 const char *name; /* Name of this list (used in config stuff) */
1430};
1431
1432/* List of prefixes to try when looking for executables. */
1433
1434static struct path_prefix exec_prefixes = { 0, 0, "exec" };
1435
1436/* List of prefixes to try when looking for startup (crt0) files. */
1437
1438static struct path_prefix startfile_prefixes = { 0, 0, "startfile" };
1439
1440/* List of prefixes to try when looking for include files. */
1441
1442static struct path_prefix include_prefixes = { 0, 0, "include" };
1443
1444/* Suffix to attach to directories searched for commands.
1445 This looks like `MACHINE/VERSION/'. */
1446
1447static const char *machine_suffix = 0;
1448
1449/* Suffix to attach to directories searched for commands.
1450 This is just `MACHINE/'. */
1451
1452static const char *just_machine_suffix = 0;
1453
1454/* Adjusted value of GCC_EXEC_PREFIX envvar. */
1455
1456static const char *gcc_exec_prefix;
1457
1458/* Adjusted value of standard_libexec_prefix. */
1459
1460static const char *gcc_libexec_prefix;
1461
1462/* Default prefixes to attach to command names. */
1463
1464#ifndef STANDARD_STARTFILE_PREFIX_1
1465#define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1466#endif
1467#ifndef STANDARD_STARTFILE_PREFIX_2
1468#define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1469#endif
1470
1471#ifdef CROSS_DIRECTORY_STRUCTURE /* Don't use these prefixes for a cross compiler. */
1472#undef MD_EXEC_PREFIX
1473#undef MD_STARTFILE_PREFIX
1474#undef MD_STARTFILE_PREFIX_1
1475#endif
1476
1477/* If no prefixes defined, use the null string, which will disable them. */
1478#ifndef MD_EXEC_PREFIX
1479#define MD_EXEC_PREFIX ""
1480#endif
1481#ifndef MD_STARTFILE_PREFIX
1482#define MD_STARTFILE_PREFIX ""
1483#endif
1484#ifndef MD_STARTFILE_PREFIX_1
1485#define MD_STARTFILE_PREFIX_1 ""
1486#endif
1487
1488/* These directories are locations set at configure-time based on the
1489 --prefix option provided to configure. Their initializers are
1490 defined in Makefile.in. These paths are not *directly* used when
1491 gcc_exec_prefix is set because, in that case, we know where the
1492 compiler has been installed, and use paths relative to that
1493 location instead. */
1494static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
1495static const char *const standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX;
1496static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
1497static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1498
1499/* For native compilers, these are well-known paths containing
1500 components that may be provided by the system. For cross
1501 compilers, these paths are not used. */
1502static const char *md_exec_prefix = MD_EXEC_PREFIX;
1503static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1504static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1505static const char *const standard_startfile_prefix_1
1506 = STANDARD_STARTFILE_PREFIX_1;
1507static const char *const standard_startfile_prefix_2
1508 = STANDARD_STARTFILE_PREFIX_2;
1509
1510/* A relative path to be used in finding the location of tools
1511 relative to the driver. */
1512static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1513
1514/* A prefix to be used when this is an accelerator compiler. */
1515static const char *const accel_dir_suffix = ACCEL_DIR_SUFFIX;
1516
1517/* Subdirectory to use for locating libraries. Set by
1518 set_multilib_dir based on the compilation options. */
1519
1520static const char *multilib_dir;
1521
1522/* Subdirectory to use for locating libraries in OS conventions. Set by
1523 set_multilib_dir based on the compilation options. */
1524
1525static const char *multilib_os_dir;
1526
1527/* Subdirectory to use for locating libraries in multiarch conventions. Set by
1528 set_multilib_dir based on the compilation options. */
1529
1530static const char *multiarch_dir;
1531
1532/* Structure to keep track of the specs that have been defined so far.
1533 These are accessed using %(specname) in a compiler or link
1534 spec. */
1535
1536struct spec_list
1537{
1538 /* The following 2 fields must be first */
1539 /* to allow EXTRA_SPECS to be initialized */
1540 const char *name; /* name of the spec. */
1541 const char *ptr; /* available ptr if no static pointer */
1542
1543 /* The following fields are not initialized */
1544 /* by EXTRA_SPECS */
1545 const char **ptr_spec; /* pointer to the spec itself. */
1546 struct spec_list *next; /* Next spec in linked list. */
1547 int name_len; /* length of the name */
1548 bool user_p; /* whether string come from file spec. */
1549 bool alloc_p; /* whether string was allocated */
1550 const char *default_ptr; /* The default value of *ptr_spec. */
1551};
1552
1553#define INIT_STATIC_SPEC(NAME,PTR) \
1554 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, false, false, \
1555 *PTR }
1556
1557/* List of statically defined specs. */
1558static struct spec_list static_specs[] =
1559{
1560 INIT_STATIC_SPEC ("asm", &asm_spec),
1561 INIT_STATIC_SPEC ("asm_debug", &asm_debug),
1562 INIT_STATIC_SPEC ("asm_final", &asm_final_spec),
1563 INIT_STATIC_SPEC ("asm_options", &asm_options),
1564 INIT_STATIC_SPEC ("invoke_as", &invoke_as),
1565 INIT_STATIC_SPEC ("cpp", &cpp_spec),
1566 INIT_STATIC_SPEC ("cpp_options", &cpp_options),
1567 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options),
1568 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options),
1569 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp),
1570 INIT_STATIC_SPEC ("cc1", &cc1_spec),
1571 INIT_STATIC_SPEC ("cc1_options", &cc1_options),
1572 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec),
1573 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec),
1574 INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec),
1575 INIT_STATIC_SPEC ("endfile", &endfile_spec),
1576 INIT_STATIC_SPEC ("link", &link_spec),
1577 INIT_STATIC_SPEC ("lib", &lib_spec),
1578 INIT_STATIC_SPEC ("link_gomp", &link_gomp_spec),
1579 INIT_STATIC_SPEC ("libgcc", &libgcc_spec),
1580 INIT_STATIC_SPEC ("startfile", &startfile_spec),
1581 INIT_STATIC_SPEC ("cross_compile", &cross_compile),
1582 INIT_STATIC_SPEC ("version", &compiler_version),
1583 INIT_STATIC_SPEC ("multilib", &multilib_select),
1584 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults),
1585 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra),
1586 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches),
1587 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions),
1588 INIT_STATIC_SPEC ("multilib_options", &multilib_options),
1589 INIT_STATIC_SPEC ("multilib_reuse", &multilib_reuse),
1590 INIT_STATIC_SPEC ("linker", &linker_name_spec),
1591 INIT_STATIC_SPEC ("linker_plugin_file", &linker_plugin_file_spec),
1592 INIT_STATIC_SPEC ("lto_wrapper", &lto_wrapper_spec),
1593 INIT_STATIC_SPEC ("lto_gcc", &lto_gcc_spec),
1594 INIT_STATIC_SPEC ("post_link", &post_link_spec),
1595 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec),
1596 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix),
1597 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix),
1598 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1),
1599 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec),
1600 INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec),
1601 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec),
1602 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec),
1603 INIT_STATIC_SPEC ("self_spec", &self_spec),
1604};
1605
1606#ifdef EXTRA_SPECS /* additional specs needed */
1607/* Structure to keep track of just the first two args of a spec_list.
1608 That is all that the EXTRA_SPECS macro gives us. */
1609struct spec_list_1
1610{
1611 const char *const name;
1612 const char *const ptr;
1613};
1614
1615static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1616static struct spec_list *extra_specs = (struct spec_list *) 0;
1617#endif
1618
1619/* List of dynamically allocates specs that have been defined so far. */
1620
1621static struct spec_list *specs = (struct spec_list *) 0;
1622
1623/* List of static spec functions. */
1624
1625static const struct spec_function static_spec_functions[] =
1626{
1627 { "getenv", getenv_spec_function },
1628 { "if-exists", if_exists_spec_function },
1629 { "if-exists-else", if_exists_else_spec_function },
1630 { "sanitize", sanitize_spec_function },
1631 { "replace-outfile", replace_outfile_spec_function },
1632 { "remove-outfile", remove_outfile_spec_function },
1633 { "version-compare", version_compare_spec_function },
1634 { "include", include_spec_function },
1635 { "find-file", find_file_spec_function },
1636 { "find-plugindir", find_plugindir_spec_function },
1637 { "print-asm-header", print_asm_header_spec_function },
1638 { "compare-debug-dump-opt", compare_debug_dump_opt_spec_function },
1639 { "compare-debug-self-opt", compare_debug_self_opt_spec_function },
1640 { "compare-debug-auxbase-opt", compare_debug_auxbase_opt_spec_function },
1641 { "pass-through-libs", pass_through_libs_spec_func },
1642 { "replace-extension", replace_extension_spec_func },
1643 { "gt", greater_than_spec_func },
1644 { "debug-level-gt", debug_level_greater_than_spec_func },
1645#ifdef EXTRA_SPEC_FUNCTIONS
1646 EXTRA_SPEC_FUNCTIONS
1647#endif
1648 { 0, 0 }
1649};
1650
1651static int processing_spec_function;
1652
1653/* Add appropriate libgcc specs to OBSTACK, taking into account
1654 various permutations of -shared-libgcc, -shared, and such. */
1655
1656#if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1657
1658#ifndef USE_LD_AS_NEEDED
1659#define USE_LD_AS_NEEDED 0
1660#endif
1661
1662static void
1663init_gcc_specs (struct obstack *obstack, const char *shared_name,
1664 const char *static_name, const char *eh_name)
1665{
1666 char *buf;
1667
1668#if USE_LD_AS_NEEDED
1669 buf = concat ("%{static|static-libgcc|static-pie:", static_name, " ", eh_name, "}"
1670 "%{!static:%{!static-libgcc:%{!static-pie:"
1671 "%{!shared-libgcc:",
1672 static_name, " " LD_AS_NEEDED_OPTION " ",
1673 shared_name, " " LD_NO_AS_NEEDED_OPTION
1674 "}"
1675 "%{shared-libgcc:",
1676 shared_name, "%{!shared: ", static_name, "}"
1677 "}}"
1678#else
1679 buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name, "}"
1680 "%{!static:%{!static-libgcc:"
1681 "%{!shared:"
1682 "%{!shared-libgcc:", static_name, " ", eh_name, "}"
1683 "%{shared-libgcc:", shared_name, " ", static_name, "}"
1684 "}"
1685#ifdef LINK_EH_SPEC
1686 "%{shared:"
1687 "%{shared-libgcc:", shared_name, "}"
1688 "%{!shared-libgcc:", static_name, "}"
1689 "}"
1690#else
1691 "%{shared:", shared_name, "}"
1692#endif
1693#endif
1694 "}}", NULL);
1695
1696 obstack_grow (obstack, buf, strlen (buf));
1697 free (buf);
1698}
1699#endif /* ENABLE_SHARED_LIBGCC */
1700
1701/* Initialize the specs lookup routines. */
1702
1703static void
1704init_spec (void)
1705{
1706 struct spec_list *next = (struct spec_list *) 0;
1707 struct spec_list *sl = (struct spec_list *) 0;
1708 int i;
1709
1710 if (specs)
1711 return; /* Already initialized. */
1712
1713 if (verbose_flag)
1714 fnotice (stderr, "Using built-in specs.\n");
1715
1716#ifdef EXTRA_SPECS
1717 extra_specs = XCNEWVEC (struct spec_list, ARRAY_SIZE (extra_specs_1));
1718
1719 for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--)
1720 {
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;
1730 }
1731#endif
1732
1733 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1734 {
1735 sl = &static_specs[i];
1736 sl->next = next;
1737 next = sl;
1738 }
1739
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:
1744
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.
1748
1749 (2) If "-ldl", then it's also a fair bet that we're doing
1750 dynamic loading.
1751
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.
1755
1756 (4) If "-shared"
1757
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.
1761
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.
1765
1766 Doing any of this probably requires invoking an external program to
1767 do the actual object file scanning. */
1768 {
1769 const char *p = libgcc_spec;
1770 int in_sep = 1;
1771
1772 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1773 when given the proper command line arguments. */
1774 while (*p)
1775 {
1776 if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
1777 {
1778 init_gcc_specs (&obstack,
1779 "-lgcc_s"
1780#ifdef USE_LIBUNWIND_EXCEPTIONS
1781 " -lunwind"
1782#endif
1783 ,
1784 "-lgcc",
1785 "-lgcc_eh"
1786#ifdef USE_LIBUNWIND_EXCEPTIONS
1787# ifdef HAVE_LD_STATIC_DYNAMIC
1788 " %{!static:%{!static-pie:" LD_STATIC_OPTION "}} -lunwind"
1789 " %{!static:%{!static-pie:" LD_DYNAMIC_OPTION "}}"
1790# else
1791 " -lunwind"
1792# endif
1793#endif
1794 );
1795
1796 p += 5;
1797 in_sep = 0;
1798 }
1799 else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0)
1800 {
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
1810 );
1811 p += 10;
1812 in_sep = 0;
1813 }
1814 else
1815 {
1816 obstack_1grow (&obstack, *p);
1817 in_sep = (*p == ' ');
1818 p += 1;
1819 }
1820 }
1821
1822 obstack_1grow (&obstack, '\0');
1823 libgcc_spec = XOBFINISH (&obstack, const char *);
1824 }
1825#endif
1826#ifdef USE_AS_TRADITIONAL_FORMAT
1827 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1828 {
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 *);
1833 }
1834#endif
1835
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. */
1849 {
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, ' ');
1854 }
1855# endif
1856 obstack_grow0 (&obstack, link_spec, strlen (link_spec));
1857 link_spec = XOBFINISH (&obstack, const char *);
1858#endif
1859
1860 specs = sl;
1861}
1862
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. */
1866
1867static void
1868set_spec (const char *name, const char *spec, bool user_p)
1869{
1870 struct spec_list *sl;
1871 const char *old_spec;
1872 int name_len = strlen (name);
1873 int i;
1874
1875 /* If this is the first call, initialize the statically allocated specs. */
1876 if (!specs)
1877 {
1878 struct spec_list *next = (struct spec_list *) 0;
1879 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1880 {
1881 sl = &static_specs[i];
1882 sl->next = next;
1883 next = sl;
1884 }
1885 specs = sl;
1886 }
1887
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;
1892
1893 if (!sl)
1894 {
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;
1905 }
1906
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));
1911
1912#ifdef DEBUG_SPECS
1913 if (verbose_flag)
1914 fnotice (stderr, "Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
1915#endif
1916
1917 /* Free the old spec. */
1918 if (old_spec && sl->alloc_p)
1919 free (CONST_CAST (char *, old_spec));
1920
1921 sl->user_p = user_p;
1922 sl->alloc_p = true;
1923}
1924
1925/* Accumulate a command (program name and args), and run it. */
1926
1927typedef const char *const_char_p; /* For DEF_VEC_P. */
1928
1929/* Vector of pointers to arguments in the current line of specifications. */
1930
1931static vec<const_char_p> argbuf;
1932
1933/* Were the options -c, -S or -E passed. */
1934static int have_c = 0;
1935
1936/* Was the option -o passed. */
1937static int have_o = 0;
1938
1939/* Was the option -E passed. */
1940static int have_E = 0;
1941
1942/* Pointer to output file name passed in with -o. */
1943static const char *output_file = 0;
1944
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. */
1948
1949static 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;
1957
1958/* Number of commands executed so far. */
1959
1960static int execution_count;
1961
1962/* Number of commands that exited with a signal. */
1963
1964static int signal_count;
1965
1966/* Allocate the argument vector. */
1967
1968static void
1969alloc_args (void)
1970{
1971 argbuf.create (10);
1972}
1973
1974/* Clear out the vector of arguments (after a command is executed). */
1975
1976static void
1977clear_args (void)
1978{
1979 argbuf.truncate (0);
1980}
1981
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. */
1988
1989static void
1990store_arg (const char *arg, int delete_always, int delete_failure)
1991{
1992 argbuf.safe_push (arg);
1993
1994 if (delete_always || delete_failure)
1995 {
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);
2003 }
2004}
2005
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. */
2009
2010static char *
2011load_specs (const char *filename)
2012{
2013 int desc;
2014 int readlen;
2015 struct stat statbuf;
2016 char *buffer;
2017 char *buffer_p;
2018 char *specs;
2019 char *specs_p;
2020
2021 if (verbose_flag)
2022 fnotice (stderr, "Reading specs from %s\n", filename);
2023
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);
2030
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);
2038
2039 specs = XNEWVEC (char, readlen + 1);
2040 specs_p = specs;
2041 for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
2042 {
2043 int skip = 0;
2044 char c = *buffer_p;
2045 if (c == '\r')
2046 {
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';
2053 }
2054 if (! skip)
2055 *specs_p++ = c;
2056 }
2057 *specs_p = '\0';
2058
2059 free (buffer);
2060 return (specs);
2061}
2062
2063/* Read compilation specs from a file named FILENAME,
2064 replacing the default ones.
2065
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.
2071
2072 Anything invalid in the file is a fatal error. */
2073
2074static void
2075read_specs (const char *filename, bool main_p, bool user_p)
2076{
2077 char *buffer;
2078 char *p;
2079
2080 buffer = load_specs (filename);
2081
2082 /* Scan BUFFER for specs, putting them in the vector. */
2083 p = buffer;
2084 while (1)
2085 {
2086 char *suffix;
2087 char *spec;
2088 char *in, *out, *p1, *p2, *p3;
2089
2090 /* Advance P in BUFFER to the next nonblank nocomment line. */
2091 p = skip_whitespace (p);
2092 if (*p == 0)
2093 break;
2094
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)
2099 {
2100 p1 = p;
2101 while (*p && *p != '\n')
2102 p++;
2103
2104 /* Skip '\n'. */
2105 p++;
2106
2107 if (!strncmp (p1, "%include", sizeof ("%include") - 1)
2108 && (p1[sizeof "%include" - 1] == ' '
2109 || p1[sizeof "%include" - 1] == '\t'))
2110 {
2111 char *new_filename;
2112
2113 p1 += sizeof ("%include");
2114 while (*p1 == ' ' || *p1 == '\t')
2115 p1++;
2116
2117 if (*p1++ != '<' || p[-2] != '>')
2118 fatal_error (input_location,
2119 "specs %%include syntax malformed after "
2120 "%ld characters",
2121 (long) (p1 - buffer + 1));
2122
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;
2127 }
2128 else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
2129 && (p1[sizeof "%include_noerr" - 1] == ' '
2130 || p1[sizeof "%include_noerr" - 1] == '\t'))
2131 {
2132 char *new_filename;
2133
2134 p1 += sizeof "%include_noerr";
2135 while (*p1 == ' ' || *p1 == '\t')
2136 p1++;
2137
2138 if (*p1++ != '<' || p[-2] != '>')
2139 fatal_error (input_location,
2140 "specs %%include syntax malformed after "
2141 "%ld characters",
2142 (long) (p1 - buffer + 1));
2143
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;
2151 }
2152 else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
2153 && (p1[sizeof "%rename" - 1] == ' '
2154 || p1[sizeof "%rename" - 1] == '\t'))
2155 {
2156 int name_len;
2157 struct spec_list *sl;
2158 struct spec_list *newsl;
2159
2160 /* Get original name. */
2161 p1 += sizeof "%rename";
2162 while (*p1 == ' ' || *p1 == '\t')
2163 p1++;
2164
2165 if (! ISALPHA ((unsigned char) *p1))
2166 fatal_error (input_location,
2167 "specs %%rename syntax malformed after "
2168 "%ld characters",
2169 (long) (p1 - buffer));
2170
2171 p2 = p1;
2172 while (*p2 && !ISSPACE ((unsigned char) *p2))
2173 p2++;
2174
2175 if (*p2 != ' ' && *p2 != '\t')
2176 fatal_error (input_location,
2177 "specs %%rename syntax malformed after "
2178 "%ld characters",
2179 (long) (p2 - buffer));
2180
2181 name_len = p2 - p1;
2182 *p2++ = '\0';
2183 while (*p2 == ' ' || *p2 == '\t')
2184 p2++;
2185
2186 if (! ISALPHA ((unsigned char) *p2))
2187 fatal_error (input_location,
2188 "specs %%rename syntax malformed after "
2189 "%ld characters",
2190 (long) (p2 - buffer));
2191
2192 /* Get new spec name. */
2193 p3 = p2;
2194 while (*p3 && !ISSPACE ((unsigned char) *p3))
2195 p3++;
2196
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';
2203
2204 for (sl = specs; sl; sl = sl->next)
2205 if (name_len == sl->name_len && !strcmp (sl->name, p1))
2206 break;
2207
2208 if (!sl)
2209 fatal_error (input_location,
2210 "specs %s spec was not found to be renamed", p1);
2211
2212 if (strcmp (p1, p2) == 0)
2213 continue;
2214
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);
2221
2222 if (verbose_flag)
2223 {
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
2228 }
2229
2230 set_spec (p2, *(sl->ptr_spec), user_p);
2231 if (sl->alloc_p)
2232 free (CONST_CAST (char *, *(sl->ptr_spec)));
2233
2234 *(sl->ptr_spec) = "";
2235 sl->alloc_p = 0;
2236 continue;
2237 }
2238 else
2239 fatal_error (input_location,
2240 "specs unknown %% command after %ld characters",
2241 (long) (p1 - buffer));
2242 }
2243
2244 /* Find the colon that should end the suffix. */
2245 p1 = p;
2246 while (*p1 && *p1 != ':' && *p1 != '\n')
2247 p1++;
2248
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));
2254
2255 /* Skip back over trailing whitespace. */
2256 p2 = p1;
2257 while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
2258 p2--;
2259
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));
2268
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++;
2273
2274 /* Specs end at the blank line and do not include the newline. */
2275 spec = save_string (p, p1 - p);
2276 p = p1;
2277
2278 /* Delete backslash-newline sequences from the spec. */
2279 in = spec;
2280 out = spec;
2281 while (*in != 0)
2282 {
2283 if (in[0] == '\\' && in[1] == '\n')
2284 in += 2;
2285 else if (in[0] == '#')
2286 while (*in && *in != '\n')
2287 in++;
2288
2289 else
2290 *out++ = *in++;
2291 }
2292 *out = 0;
2293
2294 if (suffix[0] == '*')
2295 {
2296 if (! strcmp (suffix, "*link_command"))
2297 link_command_spec = spec;
2298 else
2299 {
2300 set_spec (suffix + 1, spec, user_p);
2301 free (spec);
2302 }
2303 }
2304 else
2305 {
2306 /* Add this pair to the vector. */
2307 compilers
2308 = XRESIZEVEC (struct compiler, compilers, n_compilers + 2);
2309
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]);
2314 }
2315
2316 if (*suffix == 0)
2317 link_command_spec = spec;
2318 }
2319
2320 if (link_command_spec == 0)
2321 fatal_error (input_location, "spec file has no spec for linking");
2322
2323 XDELETEVEC (buffer);
2324}
2325
2326/* Record the names of temporary files we tell compilers to write,
2327 and delete them at the end of the run. */
2328
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.
2334
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. */
2339
2340static const char *temp_filename;
2341
2342/* Length of the prefix. */
2343
2344static int temp_filename_length;
2345
2346/* Define the list of temporary files to delete. */
2347
2348struct temp_file
2349{
2350 const char *name;
2351 struct temp_file *next;
2352};
2353
2354/* Queue of files to delete on success or failure of compilation. */
2355static struct temp_file *always_delete_queue;
2356/* Queue of files to delete on failure of compilation. */
2357static struct temp_file *failure_delete_queue;
2358
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. */
2364
2365void
2366record_temp_file (const char *filename, int always_delete, int fail_delete)
2367{
2368 char *const name = xstrdup (filename);
2369
2370 if (always_delete)
2371 {
2372 struct temp_file *temp;
2373 for (temp = always_delete_queue; temp; temp = temp->next)
2374 if (! filename_cmp (name, temp->name))
2375 {
2376 free (name);
2377 goto already1;
2378 }
2379
2380 temp = XNEW (struct temp_file);
2381 temp->next = always_delete_queue;
2382 temp->name = name;
2383 always_delete_queue = temp;
2384
2385 already1:;
2386 }
2387
2388 if (fail_delete)
2389 {
2390 struct temp_file *temp;
2391 for (temp = failure_delete_queue; temp; temp = temp->next)
2392 if (! filename_cmp (name, temp->name))
2393 {
2394 free (name);
2395 goto already2;
2396 }
2397
2398 temp = XNEW (struct temp_file);
2399 temp->next = failure_delete_queue;
2400 temp->name = name;
2401 failure_delete_queue = temp;
2402
2403 already2:;
2404 }
2405}
2406
2407/* Delete all the temporary files whose names we previously recorded. */
2408
2409#ifndef DELETE_IF_ORDINARY
2410#define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2411do \
2412 { \
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
2419
2420static void
2421delete_if_ordinary (const char *name)
2422{
2423 struct stat st;
2424#ifdef DEBUG
2425 int i, c;
2426
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)
2432 ;
2433
2434 if (i == 'y' || i == 'Y')
2435#endif /* DEBUG */
2436 DELETE_IF_ORDINARY (name, st, verbose_flag);
2437}
2438
2439static void
2440delete_temp_files (void)
2441{
2442 struct temp_file *temp;
2443
2444 for (temp = always_delete_queue; temp; temp = temp->next)
2445 delete_if_ordinary (temp->name);
2446 always_delete_queue = 0;
2447}
2448
2449/* Delete all the files to be deleted on error. */
2450
2451static void
2452delete_failure_queue (void)
2453{
2454 struct temp_file *temp;
2455
2456 for (temp = failure_delete_queue; temp; temp = temp->next)
2457 delete_if_ordinary (temp->name);
2458}
2459
2460static void
2461clear_failure_queue (void)
2462{
2463 failure_delete_queue = 0;
2464}
2465
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.
2476
2477 Returns the value returned by CALLBACK. */
2478
2479static void *
2480for_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)
2485{
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;
2496
2497 multi_suffix = machine_suffix;
2498 just_multi_suffix = just_machine_suffix;
2499 if (do_multi && multilib_dir && strcmp (multilib_dir, ".") != 0)
2500 {
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);
2504 }
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);
2509
2510 while (1)
2511 {
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;
2518
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);
2527
2528 if (path == NULL)
2529 {
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);
2533 }
2534
2535 for (pl = paths->plist; pl != 0; pl = pl->next)
2536 {
2537 len = strlen (pl->prefix);
2538 memcpy (path, pl->prefix, len);
2539
2540 /* Look first in MACHINE/VERSION subdirectory. */
2541 if (!skip_multi_dir)
2542 {
2543 memcpy (path + len, multi_suffix, suffix_len + 1);
2544 ret = callback (path, callback_info);
2545 if (ret)
2546 break;
2547 }
2548
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)
2553 {
2554 memcpy (path + len, just_multi_suffix, just_suffix_len + 1);
2555 ret = callback (path, callback_info);
2556 if (ret)
2557 break;
2558 }
2559
2560 /* Now try the multiarch path. */
2561 if (!skip_multi_dir
2562 && !pl->require_machine_suffix && multiarch_dir)
2563 {
2564 memcpy (path + len, multiarch_suffix, multiarch_len + 1);
2565 ret = callback (path, callback_info);
2566 if (ret)
2567 break;
2568 }
2569
2570 /* Now try the base path. */
2571 if (!pl->require_machine_suffix
2572 && !(pl->os_multilib ? skip_multi_os_dir : skip_multi_dir))
2573 {
2574 const char *this_multi;
2575 size_t this_multi_len;
2576
2577 if (pl->os_multilib)
2578 {
2579 this_multi = multi_os_dir;
2580 this_multi_len = multi_os_dir_len;
2581 }
2582 else
2583 {
2584 this_multi = multi_dir;
2585 this_multi_len = multi_dir_len;
2586 }
2587
2588 if (this_multi_len)
2589 memcpy (path + len, this_multi, this_multi_len + 1);
2590 else
2591 path[len] = '\0';
2592
2593 ret = callback (path, callback_info);
2594 if (ret)
2595 break;
2596 }
2597 }
2598 if (pl)
2599 break;
2600
2601 if (multi_dir == NULL && multi_os_dir == NULL)
2602 break;
2603
2604 /* Run through the paths again, this time without multilibs.
2605 Don't repeat any we have already seen. */
2606 if (multi_dir)
2607 {
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;
2614 }
2615 else
2616 skip_multi_dir = true;
2617 if (multi_os_dir)
2618 {
2619 free (CONST_CAST (char *, multi_os_dir));
2620 multi_os_dir = NULL;
2621 }
2622 else
2623 skip_multi_os_dir = true;
2624 }
2625
2626 if (multi_dir)
2627 {
2628 free (CONST_CAST (char *, multi_dir));
2629 free (CONST_CAST (char *, multi_suffix));
2630 free (CONST_CAST (char *, just_multi_suffix));
2631 }
2632 if (multi_os_dir)
2633 free (CONST_CAST (char *, multi_os_dir));
2634 if (ret != path)
2635 free (path);
2636 return ret;
2637}
2638
2639/* Callback for build_search_list. Adds path to obstack being built. */
2640
2641struct add_to_obstack_info {
2642 struct obstack *ob;
2643 bool check_dir;
2644 bool first_time;
2645};
2646
2647static void *
2648add_to_obstack (char *path, void *data)
2649{
2650 struct add_to_obstack_info *info = (struct add_to_obstack_info *) data;
2651
2652 if (info->check_dir && !is_directory (path, false))
2653 return NULL;
2654
2655 if (!info->first_time)
2656 obstack_1grow (info->ob, PATH_SEPARATOR);
2657
2658 obstack_grow (info->ob, path, strlen (path));
2659
2660 info->first_time = false;
2661 return NULL;
2662}
2663
2664/* Add or change the value of an environment variable, outputting the
2665 change to standard error if in verbose mode. */
2666static void
2667xputenv (const char *string)
2668{
2669 env.xput (string);
2670}
2671
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. */
2679
2680static char *
2681build_search_list (const struct path_prefix *paths, const char *prefix,
2682 bool check_dir, bool do_multi)
2683{
2684 struct add_to_obstack_info info;
2685
2686 info.ob = &collect_obstack;
2687 info.check_dir = check_dir;
2688 info.first_time = true;
2689
2690 obstack_grow (&collect_obstack, prefix, strlen (prefix));
2691 obstack_1grow (&collect_obstack, '=');
2692
2693 for_each_path (paths, do_multi, 0, add_to_obstack, &info);
2694
2695 obstack_1grow (&collect_obstack, '\0');
2696 return XOBFINISH (&collect_obstack, char *);
2697}
2698
2699/* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2700 for collect. */
2701
2702static void
2703putenv_from_prefixes (const struct path_prefix *paths, const char *env_var,
2704 bool do_multi)
2705{
2706 xputenv (build_search_list (paths, env_var, true, do_multi));
2707}
2708
2709/* Check whether NAME can be accessed in MODE. This is like access,
2710 except that it never considers directories to be executable. */
2711
2712static int
2713access_check (const char *name, int mode)
2714{
2715 if (mode == X_OK)
2716 {
2717 struct stat st;
2718
2719 if (stat (name, &st) < 0
2720 || S_ISDIR (st.st_mode))
2721 return -1;
2722 }
2723
2724 return access (name, mode);
2725}
2726
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. */
2730
2731struct file_at_path_info {
2732 const char *name;
2733 const char *suffix;
2734 int name_len;
2735 int suffix_len;
2736 int mode;
2737};
2738
2739static void *
2740file_at_path (char *path, void *data)
2741{
2742 struct file_at_path_info *info = (struct file_at_path_info *) data;
2743 size_t len = strlen (path);
2744
2745 memcpy (path + len, info->name, info->name_len);
2746 len += info->name_len;
2747
2748 /* Some systems have a suffix for executable files.
2749 So try appending that first. */
2750 if (info->suffix_len)
2751 {
2752 memcpy (path + len, info->suffix, info->suffix_len + 1);
2753 if (access_check (path, info->mode) == 0)
2754 return path;
2755 }
2756
2757 path[len] = '\0';
2758 if (access_check (path, info->mode) == 0)
2759 return path;
2760
2761 return NULL;
2762}
2763
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. */
2768
2769static char *
2770find_a_file (const struct path_prefix *pprefix, const char *name, int mode,
2771 bool do_multi)
2772{
2773 struct file_at_path_info info;
2774
2775#ifdef DEFAULT_ASSEMBLER
2776 if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
2777 return xstrdup (DEFAULT_ASSEMBLER);
2778#endif
2779
2780#ifdef DEFAULT_LINKER
2781 if (! strcmp (name, "ld") && access (DEFAULT_LINKER, mode) == 0)
2782 return xstrdup (DEFAULT_LINKER);
2783#endif
2784
2785 /* Determine the filename to execute (special case for absolute paths). */
2786
2787 if (IS_ABSOLUTE_PATH (name))
2788 {
2789 if (access (name, mode) == 0)
2790 return xstrdup (name);
2791
2792 return NULL;
2793 }
2794
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;
2800
2801 return (char*) for_each_path (pprefix, do_multi,
2802 info.name_len + info.suffix_len,
2803 file_at_path, &info);
2804}
2805
2806/* Ranking of prefixes in the sort list. -B prefixes are put before
2807 all others. */
2808
2809enum path_prefix_priority
2810{
2811 PREFIX_PRIORITY_B_OPT,
2812 PREFIX_PRIORITY_LAST
2813};
2814
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.
2818
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.
2822
2823 COMPONENT is the value to be passed to update_path.
2824
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. */
2828
2829static void
2830add_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)
2833{
2834 struct prefix_list *pl, **prev;
2835 int len;
2836
2837 for (prev = &pprefix->plist;
2838 (*prev) != NULL && (*prev)->priority <= priority;
2839 prev = &(*prev)->next)
2840 ;
2841
2842 /* Keep track of the longest prefix. */
2843
2844 prefix = update_path (prefix, component);
2845 len = strlen (prefix);
2846 if (len > pprefix->max_len)
2847 pprefix->max_len = len;
2848
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;
2854
2855 /* Insert after PREV. */
2856 pl->next = (*prev);
2857 (*prev) = pl;
2858}
2859
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. */
2862static void
2863add_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)
2867{
2868 if (!IS_ABSOLUTE_PATH (prefix))
2869 fatal_error (input_location, "system path %qs is not absolute", prefix);
2870
2871 if (target_system_root)
2872 {
2873 char *sysroot_no_trailing_dir_separator = xstrdup (target_system_root);
2874 size_t sysroot_len = strlen (target_system_root);
2875
2876 if (sysroot_len > 0
2877 && target_system_root[sysroot_len - 1] == DIR_SEPARATOR)
2878 sysroot_no_trailing_dir_separator[sysroot_len - 1] = '\0';
2879
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);
2885
2886 free (sysroot_no_trailing_dir_separator);
2887
2888 /* We have to override this because GCC's notion of sysroot
2889 moves along with GCC. */
2890 component = "GCC";
2891 }
2892
2893 add_prefix (pprefix, prefix, component, priority,
2894 require_machine_suffix, os_multilib);
2895}
2896
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.
2900
2901 Return 0 if successful, -1 if failed. */
2902
2903static int
2904execute (void)
2905{
2906 int i;
2907 int n_commands; /* # of command. */
2908 char *string;
2909 struct pex_obj *pex;
2910 struct command
2911 {
2912 const char *prog; /* program name. */
2913 const char **argv; /* vector of args. */
2914 };
2915 const char *arg;
2916
2917 struct command *commands; /* each command buffer with above info. */
2918
2919 gcc_assert (!processing_spec_function);
2920
2921 if (wrapper_string)
2922 {
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);
2928 }
2929
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++;
2934
2935 /* Get storage for each command. */
2936 commands = (struct command *) alloca (n_commands * sizeof (struct command));
2937
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. */
2941
2942 argbuf.safe_push (0);
2943
2944 commands[0].prog = argbuf[0]; /* first command. */
2945 commands[0].argv = argbuf.address ();
2946
2947 if (!wrapper_string)
2948 {
2949 string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, false);
2950 commands[0].argv[0] = (string) ? string : commands[0].argv[0];
2951 }
2952
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++;
2969 }
2970
2971 /* If -v, print what we are about to do, and maybe query. */
2972
2973 if (verbose_flag)
2974 {
2975 /* For help listings, put a blank line between sub-processes. */
2976 if (print_help_list)
2977 fputc ('\n', stderr);
2978
2979 /* Print each piped command as a separate line. */
2980 for (i = 0; i < n_commands; i++)
2981 {
2982 const char *const *j;
2983
2984 if (verbose_only_flag)
2985 {
2986 for (j = commands[i].argv; *j; j++)
2987 {
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)
2994 {
2995 fprintf (stderr, " \"");
2996 for (p = *j; *p; ++p)
2997 {
2998 if (*p == '"' || *p == '\\' || *p == '$')
2999 fputc ('\\', stderr);
3000 fputc (*p, stderr);
3001 }
3002 fputc ('"', stderr);
3003 }
3004 /* If it's empty, print "". */
3005 else if (!**j)
3006 fprintf (stderr, " \"\"");
3007 else
3008 fprintf (stderr, " %s", *j);
3009 }
3010 }
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);
3018
3019 /* Print a pipe symbol after all but the last command. */
3020 if (i + 1 != n_commands)
3021 fprintf (stderr, " |");
3022 fprintf (stderr, "\n");
3023 }
3024 fflush (stderr);
3025 if (verbose_only_flag != 0)
3026 {
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;
3033 }
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')
3040 ;
3041
3042 if (i != 'y' && i != 'Y')
3043 return 0;
3044#endif /* DEBUG */
3045 }
3046
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. */
3051
3052 for (i = 0; i < n_commands; i++)
3053 {
3054 const char **argv;
3055 int argc;
3056 int j;
3057
3058 for (argc = 0; commands[i].argv[argc] != NULL; argc++)
3059 ;
3060
3061 argv = XALLOCAVEC (const char *, argc + 3);
3062
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;
3068
3069 commands[i].argv = argv;
3070 commands[i].prog = argv[0];
3071 }
3072#endif
3073
3074 /* Run each piped subprocess. */
3075
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");
3081
3082 for (i = 0; i < n_commands; i++)
3083 {
3084 const char *errmsg;
3085 int err;
3086 const char *string = commands[i].argv[0];
3087
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)
3094 {
3095 if (err == 0)
3096 fatal_error (input_location, errmsg);
3097 else
3098 {
3099 errno = err;
3100 pfatal_with_name (errmsg);
3101 }
3102 }
3103
3104 if (i && string != commands[i].prog)
3105 free (CONST_CAST (char *, string));
3106 }
3107
3108 execution_count++;
3109
3110 /* Wait for all the subprocesses to finish. */
3111
3112 {
3113 int *statuses;
3114 struct pex_time *times = NULL;
3115 int ret_code = 0;
3116
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");
3120
3121 if (report_times || report_times_to_file)
3122 {
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");
3126 }
3127
3128 pex_free (pex);
3129
3130 for (i = 0; i < n_commands; ++i)
3131 {
3132 int status = statuses[i];
3133
3134 if (WIFSIGNALED (status))
3135 switch (WTERMSIG (status))
3136 {
3137 case SIGINT:
3138 case SIGTERM:
3139 /* SIGQUIT and SIGKILL are not available on MinGW. */
3140#ifdef SIGQUIT
3141 case SIGQUIT:
3142#endif
3143#ifdef SIGKILL
3144 case SIGKILL:
3145#endif
3146 /* The user (or environment) did something to the
3147 inferior. Making this an ICE confuses the user into
3148 thinking there's a compiler bug. Much more likely is
3149 the user or OOM killer nuked it. */
3150 fatal_error (input_location,
3151 "%s signal terminated program %s",
3152 strsignal (WTERMSIG (status)),
3153 commands[i].prog);
3154 break;
3155
3156#ifdef SIGPIPE
3157 case SIGPIPE:
3158 /* SIGPIPE is a special case. It happens in -pipe mode
3159 when the compiler dies before the preprocessor is
3160 done, or the assembler dies before the compiler is
3161 done. There's generally been an error already, and
3162 this is just fallout. So don't generate another
3163 error unless we would otherwise have succeeded. */
3164 if (signal_count || greatest_status >= MIN_FATAL_STATUS)
3165 {
3166 signal_count++;
3167 ret_code = -1;
3168 break;
3169 }
3170#endif
3171 /* FALLTHROUGH */
3172
3173 default:
3174 /* The inferior failed to catch the signal. */
3175 internal_error_no_backtrace ("%s signal terminated program %s",
3176 strsignal (WTERMSIG (status)),
3177 commands[i].prog);
3178 }
3179 else if (WIFEXITED (status)
3180 && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
3181 {
3182 /* For ICEs in cc1, cc1obj, cc1plus see if it is
3183 reproducible or not. */
3184 const char *p;
3185 if (flag_report_bug
3186 && WEXITSTATUS (status) == ICE_EXIT_CODE
3187 && i == 0
3188 && (p = strrchr (commands[0].argv[0], DIR_SEPARATOR))
3189 && ! strncmp (p + 1, "cc1", 3))
3190 try_generate_repro (commands[0].argv);
3191 if (WEXITSTATUS (status) > greatest_status)
3192 greatest_status = WEXITSTATUS (status);
3193 ret_code = -1;
3194 }
3195
3196 if (report_times || report_times_to_file)
3197 {
3198 struct pex_time *pt = &times[i];
3199 double ut, st;
3200
3201 ut = ((double) pt->user_seconds
3202 + (double) pt->user_microseconds / 1.0e6);
3203 st = ((double) pt->system_seconds
3204 + (double) pt->system_microseconds / 1.0e6);
3205
3206 if (ut + st != 0)
3207 {
3208 if (report_times)
3209 fnotice (stderr, "# %s %.2f %.2f\n",
3210 commands[i].prog, ut, st);
3211
3212 if (report_times_to_file)
3213 {
3214 int c = 0;
3215 const char *const *j;
3216
3217 fprintf (report_times_to_file, "%g %g", ut, st);
3218
3219 for (j = &commands[i].prog; *j; j = &commands[i].argv[++c])
3220 {
3221 const char *p;
3222 for (p = *j; *p; ++p)
3223 if (*p == '"' || *p == '\\' || *p == '$'
3224 || ISSPACE (*p))
3225 break;
3226
3227 if (*p)
3228 {
3229 fprintf (report_times_to_file, " \"");
3230 for (p = *j; *p; ++p)
3231 {
3232 if (*p == '"' || *p == '\\' || *p == '$')
3233 fputc ('\\', report_times_to_file);
3234 fputc (*p, report_times_to_file);
3235 }
3236 fputc ('"', report_times_to_file);
3237 }
3238 else
3239 fprintf (report_times_to_file, " %s", *j);
3240 }
3241
3242 fputc ('\n', report_times_to_file);
3243 }
3244 }
3245 }
3246 }
3247
3248 if (commands[0].argv[0] != commands[0].prog)
3249 free (CONST_CAST (char *, commands[0].argv[0]));
3250
3251 return ret_code;
3252 }
3253}
3254
3255/* Find all the switches given to us
3256 and make a vector describing them.
3257 The elements of the vector are strings, one per switch given.
3258 If a switch uses following arguments, then the `part1' field
3259 is the switch itself and the `args' field
3260 is a null-terminated vector containing the following arguments.
3261 Bits in the `live_cond' field are:
3262 SWITCH_LIVE to indicate this switch is true in a conditional spec.
3263 SWITCH_FALSE to indicate this switch is overridden by a later switch.
3264 SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
3265 SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored.
3266 SWITCH_KEEP_FOR_GCC to indicate that this switch, otherwise ignored,
3267 should be included in COLLECT_GCC_OPTIONS.
3268 in all do_spec calls afterwards. Used for %<S from self specs.
3269 The `known' field describes whether this is an internal switch.
3270 The `validated' field describes whether any spec has looked at this switch;
3271 if it remains false at the end of the run, the switch must be meaningless.
3272 The `ordering' field is used to temporarily mark switches that have to be
3273 kept in a specific order. */
3274
3275#define SWITCH_LIVE (1 << 0)
3276#define SWITCH_FALSE (1 << 1)
3277#define SWITCH_IGNORE (1 << 2)
3278#define SWITCH_IGNORE_PERMANENTLY (1 << 3)
3279#define SWITCH_KEEP_FOR_GCC (1 << 4)
3280
3281struct switchstr
3282{
3283 const char *part1;
3284 const char **args;
3285 unsigned int live_cond;
3286 bool known;
3287 bool validated;
3288 bool ordering;
3289};
3290
3291static struct switchstr *switches;
3292
3293static int n_switches;
3294
3295static int n_switches_alloc;
3296
3297/* Set to zero if -fcompare-debug is disabled, positive if it's
3298 enabled and we're running the first compilation, negative if it's
3299 enabled and we're running the second compilation. For most of the
3300 time, it's in the range -1..1, but it can be temporarily set to 2
3301 or 3 to indicate that the -fcompare-debug flags didn't come from
3302 the command-line, but rather from the GCC_COMPARE_DEBUG environment
3303 variable, until a synthesized -fcompare-debug flag is added to the
3304 command line. */
3305int compare_debug;
3306
3307/* Set to nonzero if we've seen the -fcompare-debug-second flag. */
3308int compare_debug_second;
3309
3310/* Set to the flags that should be passed to the second compilation in
3311 a -fcompare-debug compilation. */
3312const char *compare_debug_opt;
3313
3314static struct switchstr *switches_debug_check[2];
3315
3316static int n_switches_debug_check[2];
3317
3318static int n_switches_alloc_debug_check[2];
3319
3320static char *debug_check_temp_file[2];
3321
3322/* Language is one of three things:
3323
3324 1) The name of a real programming language.
3325 2) NULL, indicating that no one has figured out
3326 what it is yet.
3327 3) '*', indicating that the file should be passed
3328 to the linker. */
3329struct infile
3330{
3331 const char *name;
3332 const char *language;
3333 struct compiler *incompiler;
3334 bool compiled;
3335 bool preprocessed;
3336};
3337
3338/* Also a vector of input files specified. */
3339
3340static struct infile *infiles;
3341
3342int n_infiles;
3343
3344static int n_infiles_alloc;
3345
3346/* True if undefined environment variables encountered during spec processing
3347 are ok to ignore, typically when we're running for --help or --version. */
3348
3349static bool spec_undefvar_allowed;
3350
3351/* True if multiple input files are being compiled to a single
3352 assembly file. */
3353
3354static bool combine_inputs;
3355
3356/* This counts the number of libraries added by lang_specific_driver, so that
3357 we can tell if there were any user supplied any files or libraries. */
3358
3359static int added_libraries;
3360
3361/* And a vector of corresponding output files is made up later. */
3362
3363const char **outfiles;
3364
3365#if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3366
3367/* Convert NAME to a new name if it is the standard suffix. DO_EXE
3368 is true if we should look for an executable suffix. DO_OBJ
3369 is true if we should look for an object suffix. */
3370
3371static const char *
3372convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
3373 int do_obj ATTRIBUTE_UNUSED)
3374{
3375#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3376 int i;
3377#endif
3378 int len;
3379
3380 if (name == NULL)
3381 return NULL;
3382
3383 len = strlen (name);
3384
3385#ifdef HAVE_TARGET_OBJECT_SUFFIX
3386 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
3387 if (do_obj && len > 2
3388 && name[len - 2] == '.'
3389 && name[len - 1] == 'o')
3390 {
3391 obstack_grow (&obstack, name, len - 2);
3392 obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
3393 name = XOBFINISH (&obstack, const char *);
3394 }
3395#endif
3396
3397#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3398 /* If there is no filetype, make it the executable suffix (which includes
3399 the "."). But don't get confused if we have just "-o". */
3400 if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
3401 return name;
3402
3403 for (i = len - 1; i >= 0; i--)
3404 if (IS_DIR_SEPARATOR (name[i]))
3405 break;
3406
3407 for (i++; i < len; i++)
3408 if (name[i] == '.')
3409 return name;
3410
3411 obstack_grow (&obstack, name, len);
3412 obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
3413 strlen (TARGET_EXECUTABLE_SUFFIX));
3414 name = XOBFINISH (&obstack, const char *);
3415#endif
3416
3417 return name;
3418}
3419#endif
3420
3421/* Display the command line switches accepted by gcc. */
3422static void
3423display_help (void)
3424{
3425 printf (_("Usage: %s [options] file...\n"), progname);
3426 fputs (_("Options:\n"), stdout);
3427
3428 fputs (_(" -pass-exit-codes Exit with highest error code from a phase.\n"), stdout);
3429 fputs (_(" --help Display this information.\n"), stdout);
3430 fputs (_(" --target-help Display target specific command line options.\n"), stdout);
3431 fputs (_(" --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...].\n"), stdout);
3432 fputs (_(" Display specific types of command line options.\n"), stdout);
3433 if (! verbose_flag)
3434 fputs (_(" (Use '-v --help' to display command line options of sub-processes).\n"), stdout);
3435 fputs (_(" --version Display compiler version information.\n"), stdout);
3436 fputs (_(" -dumpspecs Display all of the built in spec strings.\n"), stdout);
3437 fputs (_(" -dumpversion Display the version of the compiler.\n"), stdout);
3438 fputs (_(" -dumpmachine Display the compiler's target processor.\n"), stdout);
3439 fputs (_(" -print-search-dirs Display the directories in the compiler's search path.\n"), stdout);
3440 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library.\n"), stdout);
3441 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>.\n"), stdout);
3442 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>.\n"), stdout);
3443 fputs (_("\
3444 -print-multiarch Display the target's normalized GNU triplet, used as\n\
3445 a component in the library path.\n"), stdout);
3446 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc.\n"), stdout);
3447 fputs (_("\
3448 -print-multi-lib Display the mapping between command line options and\n\
3449 multiple library search directories.\n"), stdout);
3450 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries.\n"), stdout);
3451 fputs (_(" -print-sysroot Display the target libraries directory.\n"), stdout);
3452 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers.\n"), stdout);
3453 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler.\n"), stdout);
3454 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor.\n"), stdout);
3455 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker.\n"), stdout);
3456 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler.\n"), stdout);
3457 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor.\n"), stdout);
3458 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker.\n"), stdout);
3459 fputs (_(" -save-temps Do not delete intermediate files.\n"), stdout);
3460 fputs (_(" -save-temps=<arg> Do not delete intermediate files.\n"), stdout);
3461 fputs (_("\
3462 -no-canonical-prefixes Do not canonicalize paths when building relative\n\
3463 prefixes to other gcc components.\n"), stdout);
3464 fputs (_(" -pipe Use pipes rather than intermediate files.\n"), stdout);
3465 fputs (_(" -time Time the execution of each subprocess.\n"), stdout);
3466 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>.\n"), stdout);
3467 fputs (_(" -std=<standard> Assume that the input sources are for <standard>.\n"), stdout);
3468 fputs (_("\
3469 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3470 and libraries.\n"), stdout);
3471 fputs (_(" -B <directory> Add <directory> to the compiler's search paths.\n"), stdout);
3472 fputs (_(" -v Display the programs invoked by the compiler.\n"), stdout);
3473 fputs (_(" -### Like -v but options quoted and commands not executed.\n"), stdout);
3474 fputs (_(" -E Preprocess only; do not compile, assemble or link.\n"), stdout);
3475 fputs (_(" -S Compile only; do not assemble or link.\n"), stdout);
3476 fputs (_(" -c Compile and assemble, but do not link.\n"), stdout);
3477 fputs (_(" -o <file> Place the output into <file>.\n"), stdout);
3478 fputs (_(" -pie Create a dynamically linked position independent\n\
3479 executable.\n"), stdout);
3480 fputs (_(" -shared Create a shared library.\n"), stdout);
3481 fputs (_("\
3482 -x <language> Specify the language of the following input files.\n\
3483 Permissible languages include: c c++ assembler none\n\
3484 'none' means revert to the default behavior of\n\
3485 guessing the language based on the file's extension.\n\
3486"), stdout);
3487
3488 printf (_("\
3489\nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3490 passed on to the various sub-processes invoked by %s. In order to pass\n\
3491 other options on to these processes the -W<letter> options must be used.\n\
3492"), progname);
3493
3494 /* The rest of the options are displayed by invocations of the various
3495 sub-processes. */
3496}
3497
3498static void
3499add_preprocessor_option (const char *option, int len)
3500{
3501 preprocessor_options.safe_push (save_string (option, len));
3502}
3503
3504static void
3505add_assembler_option (const char *option, int len)
3506{
3507 assembler_options.safe_push (save_string (option, len));
3508}
3509
3510static void
3511add_linker_option (const char *option, int len)
3512{
3513 linker_options.safe_push (save_string (option, len));
3514}
3515
3516/* Allocate space for an input file in infiles. */
3517
3518static void
3519alloc_infile (void)
3520{
3521 if (n_infiles_alloc == 0)
3522 {
3523 n_infiles_alloc = 16;
3524 infiles = XNEWVEC (struct infile, n_infiles_alloc);
3525 }
3526 else if (n_infiles_alloc == n_infiles)
3527 {
3528 n_infiles_alloc *= 2;
3529 infiles = XRESIZEVEC (struct infile, infiles, n_infiles_alloc);
3530 }
3531}
3532
3533/* Store an input file with the given NAME and LANGUAGE in
3534 infiles. */
3535
3536static void
3537add_infile (const char *name, const char *language)
3538{
3539 alloc_infile ();
3540 infiles[n_infiles].name = name;
3541 infiles[n_infiles++].language = language;
3542}
3543
3544/* Allocate space for a switch in switches. */
3545
3546static void
3547alloc_switch (void)
3548{
3549 if (n_switches_alloc == 0)
3550 {
3551 n_switches_alloc = 16;
3552 switches = XNEWVEC (struct switchstr, n_switches_alloc);
3553 }
3554 else if (n_switches_alloc == n_switches)
3555 {
3556 n_switches_alloc *= 2;
3557 switches = XRESIZEVEC (struct switchstr, switches, n_switches_alloc);
3558 }
3559}
3560
3561/* Save an option OPT with N_ARGS arguments in array ARGS, marking it
3562 as validated if VALIDATED and KNOWN if it is an internal switch. */
3563
3564static void
3565save_switch (const char *opt, size_t n_args, const char *const *args,
3566 bool validated, bool known)
3567{
3568 alloc_switch ();
3569 switches[n_switches].part1 = opt + 1;
3570 if (n_args == 0)
3571 switches[n_switches].args = 0;
3572 else
3573 {
3574 switches[n_switches].args = XNEWVEC (const char *, n_args + 1);
3575 memcpy (switches[n_switches].args, args, n_args * sizeof (const char *));
3576 switches[n_switches].args[n_args] = NULL;
3577 }
3578
3579 switches[n_switches].live_cond = 0;
3580 switches[n_switches].validated = validated;
3581 switches[n_switches].known = known;
3582 switches[n_switches].ordering = 0;
3583 n_switches++;
3584}
3585
3586/* Set the SOURCE_DATE_EPOCH environment variable to the current time if it is
3587 not set already. */
3588
3589static void
3590set_source_date_epoch_envvar ()
3591{
3592 /* Array size is 21 = ceil(log_10(2^64)) + 1 to hold string representations
3593 of 64 bit integers. */
3594 char source_date_epoch[21];
3595 time_t tt;
3596
3597 errno = 0;
3598 tt = time (NULL);
3599 if (tt < (time_t) 0 || errno != 0)
3600 tt = (time_t) 0;
3601
3602 snprintf (source_date_epoch, 21, "%llu", (unsigned long long) tt);
3603 /* Using setenv instead of xputenv because we want the variable to remain
3604 after finalizing so that it's still set in the second run when using
3605 -fcompare-debug. */
3606 setenv ("SOURCE_DATE_EPOCH", source_date_epoch, 0);
3607}
3608
3609/* Handle an option DECODED that is unknown to the option-processing
3610 machinery. */
3611
3612static bool
3613driver_unknown_option_callback (const struct cl_decoded_option *decoded)
3614{
3615 const char *opt = decoded->arg;
3616 if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-'
3617 && !(decoded->errors & CL_ERR_NEGATIVE))
3618 {
3619 /* Leave unknown -Wno-* options for the compiler proper, to be
3620 diagnosed only if there are warnings. */
3621 save_switch (decoded->canonical_option[0],
3622 decoded->canonical_option_num_elements - 1,
3623 &decoded->canonical_option[1], false, true);
3624 return false;
3625 }
3626 if (decoded->opt_index == OPT_SPECIAL_unknown)
3627 {
3628 /* Give it a chance to define it a spec file. */
3629 save_switch (decoded->canonical_option[0],
3630 decoded->canonical_option_num_elements - 1,
3631 &decoded->canonical_option[1], false, false);
3632 return false;
3633 }
3634 else
3635 return true;
3636}
3637
3638/* Handle an option DECODED that is not marked as CL_DRIVER.
3639 LANG_MASK will always be CL_DRIVER. */
3640
3641static void
3642driver_wrong_lang_callback (const struct cl_decoded_option *decoded,
3643 unsigned int lang_mask ATTRIBUTE_UNUSED)
3644{
3645 /* At this point, non-driver options are accepted (and expected to
3646 be passed down by specs) unless marked to be rejected by the
3647 driver. Options to be rejected by the driver but accepted by the
3648 compilers proper are treated just like completely unknown
3649 options. */
3650 const struct cl_option *option = &cl_options[decoded->opt_index];
3651
3652 if (option->cl_reject_driver)
3653 error ("unrecognized command line option %qs",
3654 decoded->orig_option_with_args_text);
3655 else
3656 save_switch (decoded->canonical_option[0],
3657 decoded->canonical_option_num_elements - 1,
3658 &decoded->canonical_option[1], false, true);
3659}
3660
3661static const char *spec_lang = 0;
3662static int last_language_n_infiles;
3663
3664/* Parse -foffload option argument. */
3665
3666static void
3667handle_foffload_option (const char *arg)
3668{
3669 const char *c, *cur, *n, *next, *end;
3670 char *target;
3671
3672 /* If option argument starts with '-' then no target is specified and we
3673 do not need to parse it. */
3674 if (arg[0] == '-')
3675 return;
3676
3677 end = strchr (arg, '=');
3678 if (end == NULL)
3679 end = strchr (arg, '\0');
3680 cur = arg;
3681
3682 while (cur < end)
3683 {
3684 next = strchr (cur, ',');
3685 if (next == NULL)
3686 next = end;
3687 next = (next > end) ? end : next;
3688
3689 target = XNEWVEC (char, next - cur + 1);
3690 memcpy (target, cur, next - cur);
3691 target[next - cur] = '\0';
3692
3693 /* If 'disable' is passed to the option, stop parsing the option and clean
3694 the list of offload targets. */
3695 if (strcmp (target, "disable") == 0)
3696 {
3697 free (offload_targets);
3698 offload_targets = xstrdup ("");
3699 break;
3700 }
3701
3702 /* Check that GCC is configured to support the offload target. */
3703 c = OFFLOAD_TARGETS;
3704 while (c)
3705 {
3706 n = strchr (c, ',');
3707 if (n == NULL)
3708 n = strchr (c, '\0');
3709
3710 if (next - cur == n - c && strncmp (target, c, n - c) == 0)
3711 break;
3712
3713 c = *n ? n + 1 : NULL;
3714 }
3715
3716 if (!c)
3717 fatal_error (input_location,
3718 "GCC is not configured to support %s as offload target",
3719 target);
3720
3721 if (!offload_targets)
3722 {
3723 offload_targets = target;
3724 target = NULL;
3725 }
3726 else
3727 {
3728 /* Check that the target hasn't already presented in the list. */
3729 c = offload_targets;
3730 do
3731 {
3732 n = strchr (c, ':');
3733 if (n == NULL)
3734 n = strchr (c, '\0');
3735
3736 if (next - cur == n - c && strncmp (c, target, n - c) == 0)
3737 break;
3738
3739 c = n + 1;
3740 }
3741 while (*n);
3742
3743 /* If duplicate is not found, append the target to the list. */
3744 if (c > n)
3745 {
3746 size_t offload_targets_len = strlen (offload_targets);
3747 offload_targets
3748 = XRESIZEVEC (char, offload_targets,
3749 offload_targets_len + 1 + next - cur + 1);
3750 offload_targets[offload_targets_len++] = ':';
3751 memcpy (offload_targets + offload_targets_len, target, next - cur + 1);
3752 }
3753 }
3754
3755 cur = next + 1;
3756 XDELETEVEC (target);
3757 }
3758}
3759
3760/* Handle a driver option; arguments and return value as for
3761 handle_option. */
3762
3763static bool
3764driver_handle_option (struct gcc_options *opts,
3765 struct gcc_options *opts_set,
3766 const struct cl_decoded_option *decoded,
3767 unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
3768 location_t loc,
3769 const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED,
3770 diagnostic_context *dc,
3771 void (*) (void))
3772{
3773 size_t opt_index = decoded->opt_index;
3774 const char *arg = decoded->arg;
3775 const char *compare_debug_replacement_opt;
3776 int value = decoded->value;
3777 bool validated = false;
3778 bool do_save = true;
3779
3780 gcc_assert (opts == &global_options);
3781 gcc_assert (opts_set == &global_options_set);
3782 gcc_assert (kind == DK_UNSPECIFIED);
3783 gcc_assert (loc == UNKNOWN_LOCATION);
3784 gcc_assert (dc == global_dc);
3785
3786 switch (opt_index)
3787 {
3788 case OPT_dumpspecs:
3789 {
3790 struct spec_list *sl;
3791 init_spec ();
3792 for (sl = specs; sl; sl = sl->next)
3793 printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3794 if (link_command_spec)
3795 printf ("*link_command:\n%s\n\n", link_command_spec);
3796 exit (0);
3797 }
3798
3799 case OPT_dumpversion:
3800 printf ("%s\n", spec_version);
3801 exit (0);
3802
3803 case OPT_dumpmachine:
3804 printf ("%s\n", spec_machine);
3805 exit (0);
3806
3807 case OPT_dumpfullversion:
3808 printf ("%s\n", BASEVER);
3809 exit (0);
3810
3811 case OPT__version:
3812 print_version = 1;
3813
3814 /* CPP driver cannot obtain switch from cc1_options. */
3815 if (is_cpp_driver)
3816 add_preprocessor_option ("--version", strlen ("--version"));
3817 add_assembler_option ("--version", strlen ("--version"));
3818 add_linker_option ("--version", strlen ("--version"));
3819 break;
3820
3821 case OPT__help:
3822 print_help_list = 1;
3823
3824 /* CPP driver cannot obtain switch from cc1_options. */
3825 if (is_cpp_driver)
3826 add_preprocessor_option ("--help", 6);
3827 add_assembler_option ("--help", 6);
3828 add_linker_option ("--help", 6);
3829 break;
3830
3831 case OPT__help_:
3832 print_subprocess_help = 2;
3833 break;
3834
3835 case OPT__target_help:
3836 print_subprocess_help = 1;
3837
3838 /* CPP driver cannot obtain switch from cc1_options. */
3839 if (is_cpp_driver)
3840 add_preprocessor_option ("--target-help", 13);
3841 add_assembler_option ("--target-help", 13);
3842 add_linker_option ("--target-help", 13);
3843 break;
3844
3845 case OPT__no_sysroot_suffix:
3846 case OPT_pass_exit_codes:
3847 case OPT_print_search_dirs:
3848 case OPT_print_file_name_:
3849 case OPT_print_prog_name_:
3850 case OPT_print_multi_lib:
3851 case OPT_print_multi_directory:
3852 case OPT_print_sysroot:
3853 case OPT_print_multi_os_directory:
3854 case OPT_print_multiarch:
3855 case OPT_print_sysroot_headers_suffix:
3856 case OPT_time:
3857 case OPT_wrapper:
3858 /* These options set the variables specified in common.opt
3859 automatically, and do not need to be saved for spec
3860 processing. */
3861 do_save = false;
3862 break;
3863
3864 case OPT_print_libgcc_file_name:
3865 print_file_name = "libgcc.a";
3866 do_save = false;
3867 break;
3868
3869 case OPT_fuse_ld_bfd:
3870 use_ld = ".bfd";
3871 break;
3872
3873 case OPT_fuse_ld_gold:
3874 use_ld = ".gold";
3875 break;
3876
3877 case OPT_fcompare_debug_second:
3878 compare_debug_second = 1;
3879 break;
3880
3881 case OPT_fcompare_debug:
3882 switch (value)
3883 {
3884 case 0:
3885 compare_debug_replacement_opt = "-fcompare-debug=";
3886 arg = "";
3887 goto compare_debug_with_arg;
3888
3889 case 1:
3890 compare_debug_replacement_opt = "-fcompare-debug=-gtoggle";
3891 arg = "-gtoggle";
3892 goto compare_debug_with_arg;
3893
3894 default:
3895 gcc_unreachable ();
3896 }
3897 break;
3898
3899 case OPT_fcompare_debug_:
3900 compare_debug_replacement_opt = decoded->canonical_option[0];
3901 compare_debug_with_arg:
3902 gcc_assert (decoded->canonical_option_num_elements == 1);
3903 gcc_assert (arg != NULL);
3904 if (*arg)
3905 compare_debug = 1;
3906 else
3907 compare_debug = -1;
3908 if (compare_debug < 0)
3909 compare_debug_opt = NULL;
3910 else
3911 compare_debug_opt = arg;
3912 save_switch (compare_debug_replacement_opt, 0, NULL, validated, true);
3913 set_source_date_epoch_envvar ();
3914 return true;
3915
3916 case OPT_fdiagnostics_color_:
3917 diagnostic_color_init (dc, value);
3918 break;
3919
3920 case OPT_Wa_:
3921 {
3922 int prev, j;
3923 /* Pass the rest of this option to the assembler. */
3924
3925 /* Split the argument at commas. */
3926 prev = 0;
3927 for (j = 0; arg[j]; j++)
3928 if (arg[j] == ',')
3929 {
3930 add_assembler_option (arg + prev, j - prev);
3931 prev = j + 1;
3932 }
3933
3934 /* Record the part after the last comma. */
3935 add_assembler_option (arg + prev, j - prev);
3936 }
3937 do_save = false;
3938 break;
3939
3940 case OPT_Wp_:
3941 {
3942 int prev, j;
3943 /* Pass the rest of this option to the preprocessor. */
3944
3945 /* Split the argument at commas. */
3946 prev = 0;
3947 for (j = 0; arg[j]; j++)
3948 if (arg[j] == ',')
3949 {
3950 add_preprocessor_option (arg + prev, j - prev);
3951 prev = j + 1;
3952 }
3953
3954 /* Record the part after the last comma. */
3955 add_preprocessor_option (arg + prev, j - prev);
3956 }
3957 do_save = false;
3958 break;
3959
3960 case OPT_Wl_:
3961 {
3962 int prev, j;
3963 /* Split the argument at commas. */
3964 prev = 0;
3965 for (j = 0; arg[j]; j++)
3966 if (arg[j] == ',')
3967 {
3968 add_infile (save_string (arg + prev, j - prev), "*");
3969 prev = j + 1;
3970 }
3971 /* Record the part after the last comma. */
3972 add_infile (arg + prev, "*");
3973 }
3974 do_save = false;
3975 break;
3976
3977 case OPT_Xlinker:
3978 add_infile (arg, "*");
3979 do_save = false;
3980 break;
3981
3982 case OPT_Xpreprocessor:
3983 add_preprocessor_option (arg, strlen (arg));
3984 do_save = false;
3985 break;
3986
3987 case OPT_Xassembler:
3988 add_assembler_option (arg, strlen (arg));
3989 do_save = false;
3990 break;
3991
3992 case OPT_l:
3993 /* POSIX allows separation of -l and the lib arg; canonicalize
3994 by concatenating -l with its arg */
3995 add_infile (concat ("-l", arg, NULL), "*");
3996 do_save = false;
3997 break;
3998
3999 case OPT_L:
4000 /* Similarly, canonicalize -L for linkers that may not accept
4001 separate arguments. */
4002 save_switch (concat ("-L", arg, NULL), 0, NULL, validated, true);
4003 return true;
4004
4005 case OPT_F:
4006 /* Likewise -F. */
4007 save_switch (concat ("-F", arg, NULL), 0, NULL, validated, true);
4008 return true;
4009
4010 case OPT_save_temps:
4011 save_temps_flag = SAVE_TEMPS_CWD;
4012 validated = true;
4013 break;
4014
4015 case OPT_save_temps_:
4016 if (strcmp (arg, "cwd") == 0)
4017 save_temps_flag = SAVE_TEMPS_CWD;
4018 else if (strcmp (arg, "obj") == 0
4019 || strcmp (arg, "object") == 0)
4020 save_temps_flag = SAVE_TEMPS_OBJ;
4021 else
4022 fatal_error (input_location, "%qs is an unknown -save-temps option",
4023 decoded->orig_option_with_args_text);
4024 break;
4025
4026 case OPT_no_canonical_prefixes:
4027 /* Already handled as a special case, so ignored here. */
4028 do_save = false;
4029 break;
4030
4031 case OPT_pipe:
4032 validated = true;
4033 /* These options set the variables specified in common.opt
4034 automatically, but do need to be saved for spec
4035 processing. */
4036 break;
4037
4038 case OPT_specs_:
4039 {
4040 struct user_specs *user = XNEW (struct user_specs);
4041
4042 user->next = (struct user_specs *) 0;
4043 user->filename = arg;
4044 if (user_specs_tail)
4045 user_specs_tail->next = user;
4046 else
4047 user_specs_head = user;
4048 user_specs_tail = user;
4049 }
4050 validated = true;
4051 break;
4052
4053 case OPT__sysroot_:
4054 target_system_root = arg;
4055 target_system_root_changed = 1;
4056 do_save = false;
4057 break;
4058
4059 case OPT_time_:
4060 if (report_times_to_file)
4061 fclose (report_times_to_file);
4062 report_times_to_file = fopen (arg, "a");
4063 do_save = false;
4064 break;
4065
4066 case OPT____:
4067 /* "-###"
4068 This is similar to -v except that there is no execution
4069 of the commands and the echoed arguments are quoted. It
4070 is intended for use in shell scripts to capture the
4071 driver-generated command line. */
4072 verbose_only_flag++;
4073 verbose_flag = 1;
4074 do_save = false;
4075 break;
4076
4077 case OPT_B:
4078 {
4079 size_t len = strlen (arg);
4080
4081 /* Catch the case where the user has forgotten to append a
4082 directory separator to the path. Note, they may be using
4083 -B to add an executable name prefix, eg "i386-elf-", in
4084 order to distinguish between multiple installations of
4085 GCC in the same directory. Hence we must check to see
4086 if appending a directory separator actually makes a
4087 valid directory name. */
4088 if (!IS_DIR_SEPARATOR (arg[len - 1])
4089 && is_directory (arg, false))
4090 {
4091 char *tmp = XNEWVEC (char, len + 2);
4092 strcpy (tmp, arg);
4093 tmp[len] = DIR_SEPARATOR;
4094 tmp[++len] = 0;
4095 arg = tmp;
4096 }
4097
4098 add_prefix (&exec_prefixes, arg, NULL,
4099 PREFIX_PRIORITY_B_OPT, 0, 0);
4100 add_prefix (&startfile_prefixes, arg, NULL,
4101 PREFIX_PRIORITY_B_OPT, 0, 0);
4102 add_prefix (&include_prefixes, arg, NULL,
4103 PREFIX_PRIORITY_B_OPT, 0, 0);
4104 }
4105 validated = true;
4106 break;
4107
4108 case OPT_E:
4109 have_E = true;
4110 break;
4111
4112 case OPT_x:
4113 spec_lang = arg;
4114 if (!strcmp (spec_lang, "none"))
4115 /* Suppress the warning if -xnone comes after the last input
4116 file, because alternate command interfaces like g++ might
4117 find it useful to place -xnone after each input file. */
4118 spec_lang = 0;
4119 else
4120 last_language_n_infiles = n_infiles;
4121 do_save = false;
4122 break;
4123
4124 case OPT_o:
4125 have_o = 1;
4126#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
4127 arg = convert_filename (arg, ! have_c, 0);
4128#endif
4129 output_file = arg;
4130 /* Save the output name in case -save-temps=obj was used. */
4131 save_temps_prefix = xstrdup (arg);
4132 /* On some systems, ld cannot handle "-o" without a space. So
4133 split the option from its argument. */
4134 save_switch ("-o", 1, &arg, validated, true);
4135 return true;
4136
4137#ifdef ENABLE_DEFAULT_PIE
4138 case OPT_pie:
4139 /* -pie is turned on by default. */
4140#endif
4141
4142 case OPT_static_libgcc:
4143 case OPT_shared_libgcc:
4144 case OPT_static_libgfortran:
4145 case OPT_static_libstdc__:
4146 /* These are always valid, since gcc.c itself understands the
4147 first two, gfortranspec.c understands -static-libgfortran and
4148 g++spec.c understands -static-libstdc++ */
4149 validated = true;
4150 break;
4151
4152 case OPT_fwpa:
4153 flag_wpa = "";
4154 break;
4155
4156 case OPT_foffload_:
4157 handle_foffload_option (arg);
4158 break;
4159
4160 default:
4161 /* Various driver options need no special processing at this
4162 point, having been handled in a prescan above or being
4163 handled by specs. */
4164 break;
4165 }
4166
4167 if (do_save)
4168 save_switch (decoded->canonical_option[0],
4169 decoded->canonical_option_num_elements - 1,
4170 &decoded->canonical_option[1], validated, true);
4171 return true;
4172}
4173
4174/* Put the driver's standard set of option handlers in *HANDLERS. */
4175
4176static void
4177set_option_handlers (struct cl_option_handlers *handlers)
4178{
4179 handlers->unknown_option_callback = driver_unknown_option_callback;
4180 handlers->wrong_lang_callback = driver_wrong_lang_callback;
4181 handlers->num_handlers = 3;
4182 handlers->handlers[0].handler = driver_handle_option;
4183 handlers->handlers[0].mask = CL_DRIVER;
4184 handlers->handlers[1].handler = common_handle_option;
4185 handlers->handlers[1].mask = CL_COMMON;
4186 handlers->handlers[2].handler = target_handle_option;
4187 handlers->handlers[2].mask = CL_TARGET;
4188}
4189
4190/* Create the vector `switches' and its contents.
4191 Store its length in `n_switches'. */
4192
4193static void
4194process_command (unsigned int decoded_options_count,
4195 struct cl_decoded_option *decoded_options)
4196{
4197 const char *temp;
4198 char *temp1;
4199 char *tooldir_prefix, *tooldir_prefix2;
4200 char *(*get_relative_prefix) (const char *, const char *,
4201 const char *) = NULL;
4202 struct cl_option_handlers handlers;
4203 unsigned int j;
4204
4205 gcc_exec_prefix = env.get ("GCC_EXEC_PREFIX");
4206
4207 n_switches = 0;
4208 n_infiles = 0;
4209 added_libraries = 0;
4210
4211 /* Figure compiler version from version string. */
4212
4213 compiler_version = temp1 = xstrdup (version_string);
4214
4215 for (; *temp1; ++temp1)
4216 {
4217 if (*temp1 == ' ')
4218 {
4219 *temp1 = '\0';
4220 break;
4221 }
4222 }
4223
4224 /* Handle any -no-canonical-prefixes flag early, to assign the function
4225 that builds relative prefixes. This function creates default search
4226 paths that are needed later in normal option handling. */
4227
4228 for (j = 1; j < decoded_options_count; j++)
4229 {
4230 if (decoded_options[j].opt_index == OPT_no_canonical_prefixes)
4231 {
4232 get_relative_prefix = make_relative_prefix_ignore_links;
4233 break;
4234 }
4235 }
4236 if (! get_relative_prefix)
4237 get_relative_prefix = make_relative_prefix;
4238
4239 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
4240 see if we can create it from the pathname specified in
4241 decoded_options[0].arg. */
4242
4243 gcc_libexec_prefix = standard_libexec_prefix;
4244#ifndef VMS
4245 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
4246 if (!gcc_exec_prefix)
4247 {
4248 gcc_exec_prefix = get_relative_prefix (decoded_options[0].arg,
4249 standard_bindir_prefix,
4250 standard_exec_prefix);
4251 gcc_libexec_prefix = get_relative_prefix (decoded_options[0].arg,
4252 standard_bindir_prefix,
4253 standard_libexec_prefix);
4254 if (gcc_exec_prefix)
4255 xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
4256 }
4257 else
4258 {
4259 /* make_relative_prefix requires a program name, but
4260 GCC_EXEC_PREFIX is typically a directory name with a trailing
4261 / (which is ignored by make_relative_prefix), so append a
4262 program name. */
4263 char *tmp_prefix = concat (gcc_exec_prefix, "gcc", NULL);
4264 gcc_libexec_prefix = get_relative_prefix (tmp_prefix,
4265 standard_exec_prefix,
4266 standard_libexec_prefix);
4267
4268 /* The path is unrelocated, so fallback to the original setting. */
4269 if (!gcc_libexec_prefix)
4270 gcc_libexec_prefix = standard_libexec_prefix;
4271
4272 free (tmp_prefix);
4273 }
4274#else
4275#endif
4276 /* From this point onward, gcc_exec_prefix is non-null if the toolchain
4277 is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
4278 or an automatically created GCC_EXEC_PREFIX from
4279 decoded_options[0].arg. */
4280
4281 /* Do language-specific adjustment/addition of flags. */
4282 lang_specific_driver (&decoded_options, &decoded_options_count,
4283 &added_libraries);
4284
4285 if (gcc_exec_prefix)
4286 {
4287 int len = strlen (gcc_exec_prefix);
4288
4289 if (len > (int) sizeof ("/lib/gcc/") - 1
4290 && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
4291 {
4292 temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1;
4293 if (IS_DIR_SEPARATOR (*temp)
4294 && filename_ncmp (temp + 1, "lib", 3) == 0
4295 && IS_DIR_SEPARATOR (temp[4])
4296 && filename_ncmp (temp + 5, "gcc", 3) == 0)
4297 len -= sizeof ("/lib/gcc/") - 1;
4298 }
4299
4300 set_std_prefix (gcc_exec_prefix, len);
4301 add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC",
4302 PREFIX_PRIORITY_LAST, 0, 0);
4303 add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
4304 PREFIX_PRIORITY_LAST, 0, 0);
4305 }
4306
4307 /* COMPILER_PATH and LIBRARY_PATH have values
4308 that are lists of directory names with colons. */
4309
4310 temp = env.get ("COMPILER_PATH");
4311 if (temp)
4312 {
4313 const char *startp, *endp;
4314 char *nstore = (char *) alloca (strlen (temp) + 3);
4315
4316 startp = endp = temp;
4317 while (1)
4318 {
4319 if (*endp == PATH_SEPARATOR || *endp == 0)
4320 {
4321 strncpy (nstore, startp, endp - startp);
4322 if (endp == startp)
4323 strcpy (nstore, concat (".", dir_separator_str, NULL));
4324 else if (!IS_DIR_SEPARATOR (endp[-1]))
4325 {
4326 nstore[endp - startp] = DIR_SEPARATOR;
4327 nstore[endp - startp + 1] = 0;
4328 }
4329 else
4330 nstore[endp - startp] = 0;
4331 add_prefix (&exec_prefixes, nstore, 0,
4332 PREFIX_PRIORITY_LAST, 0, 0);
4333 add_prefix (&include_prefixes, nstore, 0,
4334 PREFIX_PRIORITY_LAST, 0, 0);
4335 if (*endp == 0)
4336 break;
4337 endp = startp = endp + 1;
4338 }
4339 else
4340 endp++;
4341 }
4342 }
4343
4344 temp = env.get (LIBRARY_PATH_ENV);
4345 if (temp && *cross_compile == '0')
4346 {
4347 const char *startp, *endp;
4348 char *nstore = (char *) alloca (strlen (temp) + 3);
4349
4350 startp = endp = temp;
4351 while (1)
4352 {
4353 if (*endp == PATH_SEPARATOR || *endp == 0)
4354 {
4355 strncpy (nstore, startp, endp - startp);
4356 if (endp == startp)
4357 strcpy (nstore, concat (".", dir_separator_str, NULL));
4358 else if (!IS_DIR_SEPARATOR (endp[-1]))
4359 {
4360 nstore[endp - startp] = DIR_SEPARATOR;
4361 nstore[endp - startp + 1] = 0;
4362 }
4363 else
4364 nstore[endp - startp] = 0;
4365 add_prefix (&startfile_prefixes, nstore, NULL,
4366 PREFIX_PRIORITY_LAST, 0, 1);
4367 if (*endp == 0)
4368 break;
4369 endp = startp = endp + 1;
4370 }
4371 else
4372 endp++;
4373 }
4374 }
4375
4376 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
4377 temp = env.get ("LPATH");
4378 if (temp && *cross_compile == '0')
4379 {
4380 const char *startp, *endp;
4381 char *nstore = (char *) alloca (strlen (temp) + 3);
4382
4383 startp = endp = temp;
4384 while (1)
4385 {
4386 if (*endp == PATH_SEPARATOR || *endp == 0)
4387 {
4388 strncpy (nstore, startp, endp - startp);
4389 if (endp == startp)
4390 strcpy (nstore, concat (".", dir_separator_str, NULL));
4391 else if (!IS_DIR_SEPARATOR (endp[-1]))
4392 {
4393 nstore[endp - startp] = DIR_SEPARATOR;
4394 nstore[endp - startp + 1] = 0;
4395 }
4396 else
4397 nstore[endp - startp] = 0;
4398 add_prefix (&startfile_prefixes, nstore, NULL,
4399 PREFIX_PRIORITY_LAST, 0, 1);
4400 if (*endp == 0)
4401 break;
4402 endp = startp = endp + 1;
4403 }
4404 else
4405 endp++;
4406 }
4407 }
4408
4409 /* Process the options and store input files and switches in their
4410 vectors. */
4411
4412 last_language_n_infiles = -1;
4413
4414 set_option_handlers (&handlers);
4415
4416 for (j = 1; j < decoded_options_count; j++)
4417 {
4418 switch (decoded_options[j].opt_index)
4419 {
4420 case OPT_S:
4421 case OPT_c:
4422 case OPT_E:
4423 have_c = 1;
4424 break;
4425 }
4426 if (have_c)
4427 break;
4428 }
4429
4430 for (j = 1; j < decoded_options_count; j++)
4431 {
4432 if (decoded_options[j].opt_index == OPT_SPECIAL_input_file)
4433 {
4434 const char *arg = decoded_options[j].arg;
4435 const char *p = strrchr (arg, '@');
4436 char *fname;
4437 long offset;
4438 int consumed;
4439#ifdef HAVE_TARGET_OBJECT_SUFFIX
4440 arg = convert_filename (arg, 0, access (arg, F_OK));
4441#endif
4442 /* For LTO static archive support we handle input file
4443 specifications that are composed of a filename and
4444 an offset like FNAME@OFFSET. */
4445 if (p
4446 && p != arg
4447 && sscanf (p, "@%li%n", &offset, &consumed) >= 1
4448 && strlen (p) == (unsigned int)consumed)
4449 {
4450 fname = (char *)xmalloc (p - arg + 1);
4451 memcpy (fname, arg, p - arg);
4452 fname[p - arg] = '\0';
4453 /* Only accept non-stdin and existing FNAME parts, otherwise
4454 try with the full name. */
4455 if (strcmp (fname, "-") == 0 || access (fname, F_OK) < 0)
4456 {
4457 free (fname);
4458 fname = xstrdup (arg);
4459 }
4460 }
4461 else
4462 fname = xstrdup (arg);
4463
4464 if (strcmp (fname, "-") != 0 && access (fname, F_OK) < 0)
4465 {
4466 if (fname[0] == '@' && access (fname + 1, F_OK) < 0)
4467 perror_with_name (fname + 1);
4468 else
4469 perror_with_name (fname);
4470 }
4471 else
4472 add_infile (arg, spec_lang);
4473
4474 free (fname);
4475 continue;
4476 }
4477
4478 read_cmdline_option (&global_options, &global_options_set,
4479 decoded_options + j, UNKNOWN_LOCATION,
4480 CL_DRIVER, &handlers, global_dc);
4481 }
4482
4483 /* If the user didn't specify any, default to all configured offload
4484 targets. */
4485 if (ENABLE_OFFLOADING && offload_targets == NULL)
4486 handle_foffload_option (OFFLOAD_TARGETS);
4487
4488 if (output_file
4489 && strcmp (output_file, "-") != 0
4490 && strcmp (output_file, HOST_BIT_BUCKET) != 0)
4491 {
4492 int i;
4493 for (i = 0; i < n_infiles; i++)
4494 if ((!infiles[i].language || infiles[i].language[0] != '*')
4495 && canonical_filename_eq (infiles[i].name, output_file))
4496 fatal_error (input_location,
4497 "input file %qs is the same as output file",
4498 output_file);
4499 }
4500
4501 if (output_file != NULL && output_file[0] == '\0')
4502 fatal_error (input_location, "output filename may not be empty");
4503
4504 /* If -save-temps=obj and -o name, create the prefix to use for %b.
4505 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
4506 if (save_temps_flag == SAVE_TEMPS_OBJ && save_temps_prefix != NULL)
4507 {
4508 save_temps_length = strlen (save_temps_prefix);
4509 temp = strrchr (lbasename (save_temps_prefix), '.');
4510 if (temp)
4511 {
4512 save_temps_length -= strlen (temp);
4513 save_temps_prefix[save_temps_length] = '\0';
4514 }
4515
4516 }
4517 else if (save_temps_prefix != NULL)
4518 {
4519 free (save_temps_prefix);
4520 save_temps_prefix = NULL;
4521 }
4522
4523 if (save_temps_flag && use_pipes)
4524 {
4525 /* -save-temps overrides -pipe, so that temp files are produced */
4526 if (save_temps_flag)
4527 warning (0, "-pipe ignored because -save-temps specified");
4528 use_pipes = 0;
4529 }
4530
4531 if (!compare_debug)
4532 {
4533 const char *gcd = env.get ("GCC_COMPARE_DEBUG");
4534
4535 if (gcd && gcd[0] == '-')
4536 {
4537 compare_debug = 2;
4538 compare_debug_opt = gcd;
4539 }
4540 else if (gcd && *gcd && strcmp (gcd, "0"))
4541 {
4542 compare_debug = 3;
4543 compare_debug_opt = "-gtoggle";
4544 }
4545 }
4546 else if (compare_debug < 0)
4547 {
4548 compare_debug = 0;
4549 gcc_assert (!compare_debug_opt);
4550 }
4551
4552 /* Set up the search paths. We add directories that we expect to
4553 contain GNU Toolchain components before directories specified by
4554 the machine description so that we will find GNU components (like
4555 the GNU assembler) before those of the host system. */
4556
4557 /* If we don't know where the toolchain has been installed, use the
4558 configured-in locations. */
4559 if (!gcc_exec_prefix)
4560 {
4561#ifndef OS2
4562 add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC",
4563 PREFIX_PRIORITY_LAST, 1, 0);
4564 add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS",
4565 PREFIX_PRIORITY_LAST, 2, 0);
4566 add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
4567 PREFIX_PRIORITY_LAST, 2, 0);
4568#endif
4569 add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
4570 PREFIX_PRIORITY_LAST, 1, 0);
4571 }
4572
4573 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix));
4574 tooldir_prefix2 = concat (tooldir_base_prefix, spec_machine,
4575 dir_separator_str, NULL);
4576
4577 /* Look for tools relative to the location from which the driver is
4578 running, or, if that is not available, the configured prefix. */
4579 tooldir_prefix
4580 = concat (gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
4581 spec_host_machine, dir_separator_str, spec_version,
4582 accel_dir_suffix, dir_separator_str, tooldir_prefix2, NULL);
4583 free (tooldir_prefix2);
4584
4585 add_prefix (&exec_prefixes,
4586 concat (tooldir_prefix, "bin", dir_separator_str, NULL),
4587 "BINUTILS", PREFIX_PRIORITY_LAST, 0, 0);
4588 add_prefix (&startfile_prefixes,
4589 concat (tooldir_prefix, "lib", dir_separator_str, NULL),
4590 "BINUTILS", PREFIX_PRIORITY_LAST, 0, 1);
4591 free (tooldir_prefix);
4592
4593#if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
4594 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
4595 then consider it to relocate with the rest of the GCC installation
4596 if GCC_EXEC_PREFIX is set.
4597 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
4598 if (target_system_root && !target_system_root_changed && gcc_exec_prefix)
4599 {
4600 char *tmp_prefix = get_relative_prefix (decoded_options[0].arg,
4601 standard_bindir_prefix,
4602 target_system_root);
4603 if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0)
4604 {
4605 target_system_root = tmp_prefix;
4606 target_system_root_changed = 1;
4607 }
4608 }
4609#endif
4610
4611 /* More prefixes are enabled in main, after we read the specs file
4612 and determine whether this is cross-compilation or not. */
4613
4614 if (n_infiles == last_language_n_infiles && spec_lang != 0)
4615 warning (0, "%<-x %s%> after last input file has no effect", spec_lang);
4616
4617 /* Synthesize -fcompare-debug flag from the GCC_COMPARE_DEBUG
4618 environment variable. */
4619 if (compare_debug == 2 || compare_debug == 3)
4620 {
4621 const char *opt = concat ("-fcompare-debug=", compare_debug_opt, NULL);
4622 save_switch (opt, 0, NULL, false, true);
4623 compare_debug = 1;
4624 }
4625
4626 /* Ensure we only invoke each subprocess once. */
4627 if (print_subprocess_help || print_help_list || print_version)
4628 {
4629 n_infiles = 0;
4630
4631 /* Create a dummy input file, so that we can pass
4632 the help option on to the various sub-processes. */
4633 add_infile ("help-dummy", "c");
4634 }
4635
4636 /* Decide if undefined variable references are allowed in specs. */
4637
4638 /* -v alone is safe. --version and --help alone or together are safe. Note
4639 that -v would make them unsafe, as they'd then be run for subprocesses as
4640 well, the location of which might depend on variables possibly coming
4641 from self-specs. Note also that the command name is counted in
4642 decoded_options_count. */
4643
4644 unsigned help_version_count = 0;
4645
4646 if (print_version)
4647 help_version_count++;
4648
4649 if (print_help_list)
4650 help_version_count++;
4651
4652 spec_undefvar_allowed =
4653 ((verbose_flag && decoded_options_count == 2)
4654 || help_version_count == decoded_options_count - 1);
4655
4656 alloc_switch ();
4657 switches[n_switches].part1 = 0;
4658 alloc_infile ();
4659 infiles[n_infiles].name = 0;
4660}
4661
4662/* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4663 and place that in the environment. */
4664
4665static void
4666set_collect_gcc_options (void)
4667{
4668 int i;
4669 int first_time;
4670
4671 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4672 the compiler. */
4673 obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
4674 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4675
4676 first_time = TRUE;
4677 for (i = 0; (int) i < n_switches; i++)
4678 {
4679 const char *const *args;
4680 const char *p, *q;
4681 if (!first_time)
4682 obstack_grow (&collect_obstack, " ", 1);
4683
4684 first_time = FALSE;
4685
4686 /* Ignore elided switches. */
4687 if ((switches[i].live_cond
4688 & (SWITCH_IGNORE | SWITCH_KEEP_FOR_GCC))
4689 == SWITCH_IGNORE)
4690 continue;
4691
4692 obstack_grow (&collect_obstack, "'-", 2);
4693 q = switches[i].part1;
4694 while ((p = strchr (q, '\'')))
4695 {
4696 obstack_grow (&collect_obstack, q, p - q);
4697 obstack_grow (&collect_obstack, "'\\''", 4);
4698 q = ++p;
4699 }
4700 obstack_grow (&collect_obstack, q, strlen (q));
4701 obstack_grow (&collect_obstack, "'", 1);
4702
4703 for (args = switches[i].args; args && *args; args++)
4704 {
4705 obstack_grow (&collect_obstack, " '", 2);
4706 q = *args;
4707 while ((p = strchr (q, '\'')))
4708 {
4709 obstack_grow (&collect_obstack, q, p - q);
4710 obstack_grow (&collect_obstack, "'\\''", 4);
4711 q = ++p;
4712 }
4713 obstack_grow (&collect_obstack, q, strlen (q));
4714 obstack_grow (&collect_obstack, "'", 1);
4715 }
4716 }
4717 obstack_grow (&collect_obstack, "\0", 1);
4718 xputenv (XOBFINISH (&collect_obstack, char *));
4719}
4720
4721/* Process a spec string, accumulating and running commands. */
4722
4723/* These variables describe the input file name.
4724 input_file_number is the index on outfiles of this file,
4725 so that the output file name can be stored for later use by %o.
4726 input_basename is the start of the part of the input file
4727 sans all directory names, and basename_length is the number
4728 of characters starting there excluding the suffix .c or whatever. */
4729
4730static const char *gcc_input_filename;
4731static int input_file_number;
4732size_t input_filename_length;
4733static int basename_length;
4734static int suffixed_basename_length;
4735static const char *input_basename;
4736static const char *input_suffix;
4737#ifndef HOST_LACKS_INODE_NUMBERS
4738static struct stat input_stat;
4739#endif
4740static int input_stat_set;
4741
4742/* The compiler used to process the current input file. */
4743static struct compiler *input_file_compiler;
4744
4745/* These are variables used within do_spec and do_spec_1. */
4746
4747/* Nonzero if an arg has been started and not yet terminated
4748 (with space, tab or newline). */
4749static int arg_going;
4750
4751/* Nonzero means %d or %g has been seen; the next arg to be terminated
4752 is a temporary file name. */
4753static int delete_this_arg;
4754
4755/* Nonzero means %w has been seen; the next arg to be terminated
4756 is the output file name of this compilation. */
4757static int this_is_output_file;
4758
4759/* Nonzero means %s has been seen; the next arg to be terminated
4760 is the name of a library file and we should try the standard
4761 search dirs for it. */
4762static int this_is_library_file;
4763
4764/* Nonzero means %T has been seen; the next arg to be terminated
4765 is the name of a linker script and we should try all of the
4766 standard search dirs for it. If it is found insert a --script
4767 command line switch and then substitute the full path in place,
4768 otherwise generate an error message. */
4769static int this_is_linker_script;
4770
4771/* Nonzero means that the input of this command is coming from a pipe. */
4772static int input_from_pipe;
4773
4774/* Nonnull means substitute this for any suffix when outputting a switches
4775 arguments. */
4776static const char *suffix_subst;
4777
4778/* If there is an argument being accumulated, terminate it and store it. */
4779
4780static void
4781end_going_arg (void)
4782{
4783 if (arg_going)
4784 {
4785 const char *string;
4786
4787 obstack_1grow (&obstack, 0);
4788 string = XOBFINISH (&obstack, const char *);
4789 if (this_is_library_file)
4790 string = find_file (string);
4791 if (this_is_linker_script)
4792 {
4793 char * full_script_path = find_a_file (&startfile_prefixes, string, R_OK, true);
4794
4795 if (full_script_path == NULL)
4796 {
4797 error ("unable to locate default linker script %qs in the library search paths", string);
4798 /* Script was not found on search path. */
4799 return;
4800 }
4801 store_arg ("--script", false, false);
4802 string = full_script_path;
4803 }
4804 store_arg (string, delete_this_arg, this_is_output_file);
4805 if (this_is_output_file)
4806 outfiles[input_file_number] = string;
4807 arg_going = 0;
4808 }
4809}
4810
4811
4812/* Parse the WRAPPER string which is a comma separated list of the command line
4813 and insert them into the beginning of argbuf. */
4814
4815static void
4816insert_wrapper (const char *wrapper)
4817{
4818 int n = 0;
4819 int i;
4820 char *buf = xstrdup (wrapper);
4821 char *p = buf;
4822 unsigned int old_length = argbuf.length ();
4823
4824 do
4825 {
4826 n++;
4827 while (*p == ',')
4828 p++;
4829 }
4830 while ((p = strchr (p, ',')) != NULL);
4831
4832 argbuf.safe_grow (old_length + n);
4833 memmove (argbuf.address () + n,
4834 argbuf.address (),
4835 old_length * sizeof (const_char_p));
4836
4837 i = 0;
4838 p = buf;
4839 do
4840 {
4841 while (*p == ',')
4842 {
4843 *p = 0;
4844 p++;
4845 }
4846 argbuf[i] = p;
4847 i++;
4848 }
4849 while ((p = strchr (p, ',')) != NULL);
4850 gcc_assert (i == n);
4851}
4852
4853/* Process the spec SPEC and run the commands specified therein.
4854 Returns 0 if the spec is successfully processed; -1 if failed. */
4855
4856int
4857do_spec (const char *spec)
4858{
4859 int value;
4860
4861 value = do_spec_2 (spec);
4862
4863 /* Force out any unfinished command.
4864 If -pipe, this forces out the last command if it ended in `|'. */
4865 if (value == 0)
4866 {
4867 if (argbuf.length () > 0
4868 && !strcmp (argbuf.last (), "|"))
4869 argbuf.pop ();
4870
4871 set_collect_gcc_options ();
4872
4873 if (argbuf.length () > 0)
4874 value = execute ();
4875 }
4876
4877 return value;
4878}
4879
4880static int
4881do_spec_2 (const char *spec)
4882{
4883 int result;
4884
4885 clear_args ();
4886 arg_going = 0;
4887 delete_this_arg = 0;
4888 this_is_output_file = 0;
4889 this_is_library_file = 0;
4890 this_is_linker_script = 0;
4891 input_from_pipe = 0;
4892 suffix_subst = NULL;
4893
4894 result = do_spec_1 (spec, 0, NULL);
4895
4896 end_going_arg ();
4897
4898 return result;
4899}
4900
4901
4902/* Process the given spec string and add any new options to the end
4903 of the switches/n_switches array. */
4904
4905static void
4906do_option_spec (const char *name, const char *spec)
4907{
4908 unsigned int i, value_count, value_len;
4909 const char *p, *q, *value;
4910 char *tmp_spec, *tmp_spec_p;
4911
4912 if (configure_default_options[0].name == NULL)
4913 return;
4914
4915 for (i = 0; i < ARRAY_SIZE (configure_default_options); i++)
4916 if (strcmp (configure_default_options[i].name, name) == 0)
4917 break;
4918 if (i == ARRAY_SIZE (configure_default_options))
4919 return;
4920
4921 value = configure_default_options[i].value;
4922 value_len = strlen (value);
4923
4924 /* Compute the size of the final spec. */
4925 value_count = 0;
4926 p = spec;
4927 while ((p = strstr (p, "%(VALUE)")) != NULL)
4928 {
4929 p ++;
4930 value_count ++;
4931 }
4932
4933 /* Replace each %(VALUE) by the specified value. */
4934 tmp_spec = (char *) alloca (strlen (spec) + 1
4935 + value_count * (value_len - strlen ("%(VALUE)")));
4936 tmp_spec_p = tmp_spec;
4937 q = spec;
4938 while ((p = strstr (q, "%(VALUE)")) != NULL)
4939 {
4940 memcpy (tmp_spec_p, q, p - q);
4941 tmp_spec_p = tmp_spec_p + (p - q);
4942 memcpy (tmp_spec_p, value, value_len);
4943 tmp_spec_p += value_len;
4944 q = p + strlen ("%(VALUE)");
4945 }
4946 strcpy (tmp_spec_p, q);
4947
4948 do_self_spec (tmp_spec);
4949}
4950
4951/* Process the given spec string and add any new options to the end
4952 of the switches/n_switches array. */
4953
4954static void
4955do_self_spec (const char *spec)
4956{
4957 int i;
4958
4959 do_spec_2 (spec);
4960 do_spec_1 (" ", 0, NULL);
4961
4962 /* Mark %<S switches processed by do_self_spec to be ignored permanently.
4963 do_self_specs adds the replacements to switches array, so it shouldn't
4964 be processed afterwards. */
4965 for (i = 0; i < n_switches; i++)
4966 if ((switches[i].live_cond & SWITCH_IGNORE))
4967 switches[i].live_cond |= SWITCH_IGNORE_PERMANENTLY;
4968
4969 if (argbuf.length () > 0)
4970 {
4971 const char **argbuf_copy;
4972 struct cl_decoded_option *decoded_options;
4973 struct cl_option_handlers handlers;
4974 unsigned int decoded_options_count;
4975 unsigned int j;
4976
4977 /* Create a copy of argbuf with a dummy argv[0] entry for
4978 decode_cmdline_options_to_array. */
4979 argbuf_copy = XNEWVEC (const char *,
4980 argbuf.length () + 1);
4981 argbuf_copy[0] = "";
4982 memcpy (argbuf_copy + 1, argbuf.address (),
4983 argbuf.length () * sizeof (const char *));
4984
4985 decode_cmdline_options_to_array (argbuf.length () + 1,
4986 argbuf_copy,
4987 CL_DRIVER, &decoded_options,
4988 &decoded_options_count);
4989 free (argbuf_copy);
4990
4991 set_option_handlers (&handlers);
4992
4993 for (j = 1; j < decoded_options_count; j++)
4994 {
4995 switch (decoded_options[j].opt_index)
4996 {
4997 case OPT_SPECIAL_input_file:
4998 /* Specs should only generate options, not input
4999 files. */
5000 if (strcmp (decoded_options[j].arg, "-") != 0)
5001 fatal_error (input_location,
5002 "switch %qs does not start with %<-%>",
5003 decoded_options[j].arg);
5004 else
5005 fatal_error (input_location,
5006 "spec-generated switch is just %<-%>");
5007 break;
5008
5009 case OPT_fcompare_debug_second:
5010 case OPT_fcompare_debug:
5011 case OPT_fcompare_debug_:
5012 case OPT_o:
5013 /* Avoid duplicate processing of some options from
5014 compare-debug specs; just save them here. */
5015 save_switch (decoded_options[j].canonical_option[0],
5016 (decoded_options[j].canonical_option_num_elements
5017 - 1),
5018 &decoded_options[j].canonical_option[1], false, true);
5019 break;
5020
5021 default:
5022 read_cmdline_option (&global_options, &global_options_set,
5023 decoded_options + j, UNKNOWN_LOCATION,
5024 CL_DRIVER, &handlers, global_dc);
5025 break;
5026 }
5027 }
5028
5029 free (decoded_options);
5030
5031 alloc_switch ();
5032 switches[n_switches].part1 = 0;
5033 }
5034}
5035
5036/* Callback for processing %D and %I specs. */
5037
5038struct spec_path_info {
5039 const char *option;
5040 const char *append;
5041 size_t append_len;
5042 bool omit_relative;
5043 bool separate_options;
5044};
5045
5046static void *
5047spec_path (char *path, void *data)
5048{
5049 struct spec_path_info *info = (struct spec_path_info *) data;
5050 size_t len = 0;
5051 char save = 0;
5052
5053 if (info->omit_relative && !IS_ABSOLUTE_PATH (path))
5054 return NULL;
5055
5056 if (info->append_len != 0)
5057 {
5058 len = strlen (path);
5059 memcpy (path + len, info->append, info->append_len + 1);
5060 }
5061
5062 if (!is_directory (path, true))
5063 return NULL;
5064
5065 do_spec_1 (info->option, 1, NULL);
5066 if (info->separate_options)
5067 do_spec_1 (" ", 0, NULL);
5068
5069 if (info->append_len == 0)
5070 {
5071 len = strlen (path);
5072 save = path[len - 1];
5073 if (IS_DIR_SEPARATOR (path[len - 1]))
5074 path[len - 1] = '\0';
5075 }
5076
5077 do_spec_1 (path, 1, NULL);
5078 do_spec_1 (" ", 0, NULL);
5079
5080 /* Must not damage the original path. */
5081 if (info->append_len == 0)
5082 path[len - 1] = save;
5083
5084 return NULL;
5085}
5086
5087/* Create a temporary FILE with the contents of ARGV. Add @FILE to the
5088 argument list. */
5089
5090static void
5091create_at_file (char **argv)
5092{
5093 char *temp_file = make_temp_file ("");
5094 char *at_argument = concat ("@", temp_file, NULL);
5095 FILE *f = fopen (temp_file, "w");
5096 int status;
5097
5098 if (f == NULL)
5099 fatal_error (input_location, "could not open temporary response file %s",
5100 temp_file);
5101
5102 status = writeargv (argv, f);
5103
5104 if (status)
5105 fatal_error (input_location,
5106 "could not write to temporary response file %s",
5107 temp_file);
5108
5109 status = fclose (f);
5110
5111 if (EOF == status)
5112 fatal_error (input_location, "could not close temporary response file %s",
5113 temp_file);
5114
5115 store_arg (at_argument, 0, 0);
5116
5117 record_temp_file (temp_file, !save_temps_flag, !save_temps_flag);
5118}
5119
5120/* True if we should compile INFILE. */
5121
5122static bool
5123compile_input_file_p (struct infile *infile)
5124{
5125 if ((!infile->language) || (infile->language[0] != '*'))
5126 if (infile->incompiler == input_file_compiler)
5127 return true;
5128 return false;
5129}
5130
5131/* Process each member of VEC as a spec. */
5132
5133static void
5134do_specs_vec (vec<char_p> vec)
5135{
5136 unsigned ix;
5137 char *opt;
5138
5139 FOR_EACH_VEC_ELT (vec, ix, opt)
5140 {
5141 do_spec_1 (opt, 1, NULL);
5142 /* Make each accumulated option a separate argument. */
5143 do_spec_1 (" ", 0, NULL);
5144 }
5145}
5146
5147/* Process the sub-spec SPEC as a portion of a larger spec.
5148 This is like processing a whole spec except that we do
5149 not initialize at the beginning and we do not supply a
5150 newline by default at the end.
5151 INSWITCH nonzero means don't process %-sequences in SPEC;
5152 in this case, % is treated as an ordinary character.
5153 This is used while substituting switches.
5154 INSWITCH nonzero also causes SPC not to terminate an argument.
5155
5156 Value is zero unless a line was finished
5157 and the command on that line reported an error. */
5158
5159static int
5160do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
5161{
5162 const char *p = spec;
5163 int c;
5164 int i;
5165 int value;
5166
5167 /* If it's an empty string argument to a switch, keep it as is. */
5168 if (inswitch && !*p)
5169 arg_going = 1;
5170
5171 while ((c = *p++))
5172 /* If substituting a switch, treat all chars like letters.
5173 Otherwise, NL, SPC, TAB and % are special. */
5174 switch (inswitch ? 'a' : c)
5175 {
5176 case '\n':
5177 end_going_arg ();
5178
5179 if (argbuf.length () > 0
5180 && !strcmp (argbuf.last (), "|"))
5181 {
5182 /* A `|' before the newline means use a pipe here,
5183 but only if -pipe was specified.
5184 Otherwise, execute now and don't pass the `|' as an arg. */
5185 if (use_pipes)
5186 {
5187 input_from_pipe = 1;
5188 break;
5189 }
5190 else
5191 argbuf.pop ();
5192 }
5193
5194 set_collect_gcc_options ();
5195
5196 if (argbuf.length () > 0)
5197 {
5198 value = execute ();
5199 if (value)
5200 return value;
5201 }
5202 /* Reinitialize for a new command, and for a new argument. */
5203 clear_args ();
5204 arg_going = 0;
5205 delete_this_arg = 0;
5206 this_is_output_file = 0;
5207 this_is_library_file = 0;
5208 this_is_linker_script = 0;
5209 input_from_pipe = 0;
5210 break;
5211
5212 case '|':
5213 end_going_arg ();
5214
5215 /* Use pipe */
5216 obstack_1grow (&obstack, c);
5217 arg_going = 1;
5218 break;
5219
5220 case '\t':
5221 case ' ':
5222 end_going_arg ();
5223
5224 /* Reinitialize for a new argument. */
5225 delete_this_arg = 0;
5226 this_is_output_file = 0;
5227 this_is_library_file = 0;
5228 this_is_linker_script = 0;
5229 break;
5230
5231 case '%':
5232 switch (c = *p++)
5233 {
5234 case 0:
5235 fatal_error (input_location, "spec %qs invalid", spec);
5236
5237 case 'b':
5238 if (save_temps_length)
5239 obstack_grow (&obstack, save_temps_prefix, save_temps_length);
5240 else
5241 obstack_grow (&obstack, input_basename, basename_length);
5242 if (compare_debug < 0)
5243 obstack_grow (&obstack, ".gk", 3);
5244 arg_going = 1;
5245 break;
5246
5247 case 'B':
5248 if (save_temps_length)
5249 obstack_grow (&obstack, save_temps_prefix, save_temps_length);
5250 else
5251 obstack_grow (&obstack, input_basename, suffixed_basename_length);
5252 if (compare_debug < 0)
5253 obstack_grow (&obstack, ".gk", 3);
5254 arg_going = 1;
5255 break;
5256
5257 case 'd':
5258 delete_this_arg = 2;
5259 break;
5260
5261 /* Dump out the directories specified with LIBRARY_PATH,
5262 followed by the absolute directories
5263 that we search for startfiles. */
5264 case 'D':
5265 {
5266 struct spec_path_info info;
5267
5268 info.option = "-L";
5269 info.append_len = 0;
5270#ifdef RELATIVE_PREFIX_NOT_LINKDIR
5271 /* Used on systems which record the specified -L dirs
5272 and use them to search for dynamic linking.
5273 Relative directories always come from -B,
5274 and it is better not to use them for searching
5275 at run time. In particular, stage1 loses. */
5276 info.omit_relative = true;
5277#else
5278 info.omit_relative = false;
5279#endif
5280 info.separate_options = false;
5281
5282 for_each_path (&startfile_prefixes, true, 0, spec_path, &info);
5283 }
5284 break;
5285
5286 case 'e':
5287 /* %efoo means report an error with `foo' as error message
5288 and don't execute any more commands for this file. */
5289 {
5290 const char *q = p;
5291 char *buf;
5292 while (*p != 0 && *p != '\n')
5293 p++;
5294 buf = (char *) alloca (p - q + 1);
5295 strncpy (buf, q, p - q);
5296 buf[p - q] = 0;
5297 error ("%s", _(buf));
5298 return -1;
5299 }
5300 break;
5301 case 'n':
5302 /* %nfoo means report a notice with `foo' on stderr. */
5303 {
5304 const char *q = p;
5305 char *buf;
5306 while (*p != 0 && *p != '\n')
5307 p++;
5308 buf = (char *) alloca (p - q + 1);
5309 strncpy (buf, q, p - q);
5310 buf[p - q] = 0;
5311 inform (UNKNOWN_LOCATION, "%s", _(buf));
5312 if (*p)
5313 p++;
5314 }
5315 break;
5316
5317 case 'j':
5318 {
5319 struct stat st;
5320
5321 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
5322 defined, and it is not a directory, and it is
5323 writable, use it. Otherwise, treat this like any
5324 other temporary file. */
5325
5326 if ((!save_temps_flag)
5327 && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode))
5328 && (access (HOST_BIT_BUCKET, W_OK) == 0))
5329 {
5330 obstack_grow (&obstack, HOST_BIT_BUCKET,
5331 strlen (HOST_BIT_BUCKET));
5332 delete_this_arg = 0;
5333 arg_going = 1;
5334 break;
5335 }
5336 }
5337 goto create_temp_file;
5338 case '|':
5339 if (use_pipes)
5340 {
5341 obstack_1grow (&obstack, '-');
5342 delete_this_arg = 0;
5343 arg_going = 1;
5344
5345 /* consume suffix */
5346 while (*p == '.' || ISALNUM ((unsigned char) *p))
5347 p++;
5348 if (p[0] == '%' && p[1] == 'O')
5349 p += 2;
5350
5351 break;
5352 }
5353 goto create_temp_file;
5354 case 'm':
5355 if (use_pipes)
5356 {
5357 /* consume suffix */
5358 while (*p == '.' || ISALNUM ((unsigned char) *p))
5359 p++;
5360 if (p[0] == '%' && p[1] == 'O')
5361 p += 2;
5362
5363 break;
5364 }
5365 goto create_temp_file;
5366 case 'g':
5367 case 'u':
5368 case 'U':
5369 create_temp_file:
5370 {
5371 struct temp_name *t;
5372 int suffix_length;
5373 const char *suffix = p;
5374 char *saved_suffix = NULL;
5375
5376 while (*p == '.' || ISALNUM ((unsigned char) *p))
5377 p++;
5378 suffix_length = p - suffix;
5379 if (p[0] == '%' && p[1] == 'O')
5380 {
5381 p += 2;
5382 /* We don't support extra suffix characters after %O. */
5383 if (*p == '.' || ISALNUM ((unsigned char) *p))
5384 fatal_error (input_location,
5385 "spec %qs has invalid %<%%0%c%>", spec, *p);
5386 if (suffix_length == 0)
5387 suffix = TARGET_OBJECT_SUFFIX;
5388 else
5389 {
5390 saved_suffix
5391 = XNEWVEC (char, suffix_length
5392 + strlen (TARGET_OBJECT_SUFFIX) + 1);
5393 strncpy (saved_suffix, suffix, suffix_length);
5394 strcpy (saved_suffix + suffix_length,
5395 TARGET_OBJECT_SUFFIX);
5396 }
5397 suffix_length += strlen (TARGET_OBJECT_SUFFIX);
5398 }
5399
5400 if (compare_debug < 0)
5401 {
5402 suffix = concat (".gk", suffix, NULL);
5403 suffix_length += 3;
5404 }
5405
5406 /* If -save-temps=obj and -o were specified, use that for the
5407 temp file. */
5408 if (save_temps_length)
5409 {
5410 char *tmp;
5411 temp_filename_length
5412 = save_temps_length + suffix_length + 1;
5413 tmp = (char *) alloca (temp_filename_length);
5414 memcpy (tmp, save_temps_prefix, save_temps_length);
5415 memcpy (tmp + save_temps_length, suffix, suffix_length);
5416 tmp[save_temps_length + suffix_length] = '\0';
5417 temp_filename = save_string (tmp, save_temps_length
5418 + suffix_length);
5419 obstack_grow (&obstack, temp_filename,
5420 temp_filename_length);
5421 arg_going = 1;
5422 delete_this_arg = 0;
5423 break;
5424 }
5425
5426 /* If the gcc_input_filename has the same suffix specified
5427 for the %g, %u, or %U, and -save-temps is specified,
5428 we could end up using that file as an intermediate
5429 thus clobbering the user's source file (.e.g.,
5430 gcc -save-temps foo.s would clobber foo.s with the
5431 output of cpp0). So check for this condition and
5432 generate a temp file as the intermediate. */
5433
5434 if (save_temps_flag)
5435 {
5436 char *tmp;
5437 temp_filename_length = basename_length + suffix_length + 1;
5438 tmp = (char *) alloca (temp_filename_length);
5439 memcpy (tmp, input_basename, basename_length);
5440 memcpy (tmp + basename_length, suffix, suffix_length);
5441 tmp[basename_length + suffix_length] = '\0';
5442 temp_filename = tmp;
5443
5444 if (filename_cmp (temp_filename, gcc_input_filename) != 0)
5445 {
5446#ifndef HOST_LACKS_INODE_NUMBERS
5447 struct stat st_temp;
5448
5449 /* Note, set_input() resets input_stat_set to 0. */
5450 if (input_stat_set == 0)
5451 {
5452 input_stat_set = stat (gcc_input_filename,
5453 &input_stat);
5454 if (input_stat_set >= 0)
5455 input_stat_set = 1;
5456 }
5457
5458 /* If we have the stat for the gcc_input_filename
5459 and we can do the stat for the temp_filename
5460 then the they could still refer to the same
5461 file if st_dev/st_ino's are the same. */
5462 if (input_stat_set != 1
5463 || stat (temp_filename, &st_temp) < 0
5464 || input_stat.st_dev != st_temp.st_dev
5465 || input_stat.st_ino != st_temp.st_ino)
5466#else
5467 /* Just compare canonical pathnames. */
5468 char* input_realname = lrealpath (gcc_input_filename);
5469 char* temp_realname = lrealpath (temp_filename);
5470 bool files_differ = filename_cmp (input_realname, temp_realname);
5471 free (input_realname);
5472 free (temp_realname);
5473 if (files_differ)
5474#endif
5475 {
5476 temp_filename
5477 = save_string (temp_filename,
5478 temp_filename_length - 1);
5479 obstack_grow (&obstack, temp_filename,
5480 temp_filename_length);
5481 arg_going = 1;
5482 delete_this_arg = 0;
5483 break;
5484 }
5485 }
5486 }
5487
5488 /* See if we already have an association of %g/%u/%U and
5489 suffix. */
5490 for (t = temp_names; t; t = t->next)
5491 if (t->length == suffix_length
5492 && strncmp (t->suffix, suffix, suffix_length) == 0
5493 && t->unique == (c == 'u' || c == 'U' || c == 'j'))
5494 break;
5495
5496 /* Make a new association if needed. %u and %j
5497 require one. */
5498 if (t == 0 || c == 'u' || c == 'j')
5499 {
5500 if (t == 0)
5501 {
5502 t = XNEW (struct temp_name);
5503 t->next = temp_names;
5504 temp_names = t;
5505 }
5506 t->length = suffix_length;
5507 if (saved_suffix)
5508 {
5509 t->suffix = saved_suffix;
5510 saved_suffix = NULL;
5511 }
5512 else
5513 t->suffix = save_string (suffix, suffix_length);
5514 t->unique = (c == 'u' || c == 'U' || c == 'j');
5515 temp_filename = make_temp_file (t->suffix);
5516 temp_filename_length = strlen (temp_filename);
5517 t->filename = temp_filename;
5518 t->filename_length = temp_filename_length;
5519 }
5520
5521 free (saved_suffix);
5522
5523 obstack_grow (&obstack, t->filename, t->filename_length);
5524 delete_this_arg = 1;
5525 }
5526 arg_going = 1;
5527 break;
5528
5529 case 'i':
5530 if (combine_inputs)
5531 {
5532 if (at_file_supplied)
5533 {
5534 /* We are going to expand `%i' to `@FILE', where FILE
5535 is a newly-created temporary filename. The filenames
5536 that would usually be expanded in place of %o will be
5537 written to the temporary file. */
5538 char **argv;
5539 int n_files = 0;
5540 int j;
5541
5542 for (i = 0; i < n_infiles; i++)
5543 if (compile_input_file_p (&infiles[i]))
5544 n_files++;
5545
5546 argv = (char **) alloca (sizeof (char *) * (n_files + 1));
5547
5548 /* Copy the strings over. */
5549 for (i = 0, j = 0; i < n_infiles; i++)
5550 if (compile_input_file_p (&infiles[i]))
5551 {
5552 argv[j] = CONST_CAST (char *, infiles[i].name);
5553 infiles[i].compiled = true;
5554 j++;
5555 }
5556 argv[j] = NULL;
5557
5558 create_at_file (argv);
5559 }
5560 else
5561 for (i = 0; (int) i < n_infiles; i++)
5562 if (compile_input_file_p (&infiles[i]))
5563 {
5564 store_arg (infiles[i].name, 0, 0);
5565 infiles[i].compiled = true;
5566 }
5567 }
5568 else
5569 {
5570 obstack_grow (&obstack, gcc_input_filename,
5571 input_filename_length);
5572 arg_going = 1;
5573 }
5574 break;
5575
5576 case 'I':
5577 {
5578 struct spec_path_info info;
5579
5580 if (multilib_dir)
5581 {
5582 do_spec_1 ("-imultilib", 1, NULL);
5583 /* Make this a separate argument. */
5584 do_spec_1 (" ", 0, NULL);
5585 do_spec_1 (multilib_dir, 1, NULL);
5586 do_spec_1 (" ", 0, NULL);
5587 }
5588
5589 if (multiarch_dir)
5590 {
5591 do_spec_1 ("-imultiarch", 1, NULL);
5592 /* Make this a separate argument. */
5593 do_spec_1 (" ", 0, NULL);
5594 do_spec_1 (multiarch_dir, 1, NULL);
5595 do_spec_1 (" ", 0, NULL);
5596 }
5597
5598 if (gcc_exec_prefix)
5599 {
5600 do_spec_1 ("-iprefix", 1, NULL);
5601 /* Make this a separate argument. */
5602 do_spec_1 (" ", 0, NULL);
5603 do_spec_1 (gcc_exec_prefix, 1, NULL);
5604 do_spec_1 (" ", 0, NULL);
5605 }
5606
5607 if (target_system_root_changed ||
5608 (target_system_root && target_sysroot_hdrs_suffix))
5609 {
5610 do_spec_1 ("-isysroot", 1, NULL);
5611 /* Make this a separate argument. */
5612 do_spec_1 (" ", 0, NULL);
5613 do_spec_1 (target_system_root, 1, NULL);
5614 if (target_sysroot_hdrs_suffix)
5615 do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL);
5616 do_spec_1 (" ", 0, NULL);
5617 }
5618
5619 info.option = "-isystem";
5620 info.append = "include";
5621 info.append_len = strlen (info.append);
5622 info.omit_relative = false;
5623 info.separate_options = true;
5624
5625 for_each_path (&include_prefixes, false, info.append_len,
5626 spec_path, &info);
5627
5628 info.append = "include-fixed";
5629 if (*sysroot_hdrs_suffix_spec)
5630 info.append = concat (info.append, dir_separator_str,
5631 multilib_dir, NULL);
5632 info.append_len = strlen (info.append);
5633 for_each_path (&include_prefixes, false, info.append_len,
5634 spec_path, &info);
5635 }
5636 break;
5637
5638 case 'o':
5639 {
5640 int max = n_infiles;
5641 max += lang_specific_extra_outfiles;
5642
5643 if (HAVE_GNU_LD && at_file_supplied)
5644 {
5645 /* We are going to expand `%o' to `@FILE', where FILE
5646 is a newly-created temporary filename. The filenames
5647 that would usually be expanded in place of %o will be
5648 written to the temporary file. */
5649
5650 char **argv;
5651 int n_files, j;
5652
5653 /* Convert OUTFILES into a form suitable for writeargv. */
5654
5655 /* Determine how many are non-NULL. */
5656 for (n_files = 0, i = 0; i < max; i++)
5657 n_files += outfiles[i] != NULL;
5658
5659 argv = (char **) alloca (sizeof (char *) * (n_files + 1));
5660
5661 /* Copy the strings over. */
5662 for (i = 0, j = 0; i < max; i++)
5663 if (outfiles[i])
5664 {
5665 argv[j] = CONST_CAST (char *, outfiles[i]);
5666 j++;
5667 }
5668 argv[j] = NULL;
5669
5670 create_at_file (argv);
5671 }
5672 else
5673 for (i = 0; i < max; i++)
5674 if (outfiles[i])
5675 store_arg (outfiles[i], 0, 0);
5676 break;
5677 }
5678
5679 case 'O':
5680 obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
5681 arg_going = 1;
5682 break;
5683
5684 case 's':
5685 this_is_library_file = 1;
5686 break;
5687
5688 case 'T':
5689 this_is_linker_script = 1;
5690 break;
5691
5692 case 'V':
5693 outfiles[input_file_number] = NULL;
5694 break;
5695
5696 case 'w':
5697 this_is_output_file = 1;
5698 break;
5699
5700 case 'W':
5701 {
5702 unsigned int cur_index = argbuf.length ();
5703 /* Handle the {...} following the %W. */
5704 if (*p != '{')
5705 fatal_error (input_location,
5706 "spec %qs has invalid %<%%W%c%>", spec, *p);
5707 p = handle_braces (p + 1);
5708 if (p == 0)
5709 return -1;
5710 end_going_arg ();
5711 /* If any args were output, mark the last one for deletion
5712 on failure. */
5713 if (argbuf.length () != cur_index)
5714 record_temp_file (argbuf.last (), 0, 1);
5715 break;
5716 }
5717
5718 /* %x{OPTION} records OPTION for %X to output. */
5719 case 'x':
5720 {
5721 const char *p1 = p;
5722 char *string;
5723 char *opt;
5724 unsigned ix;
5725
5726 /* Skip past the option value and make a copy. */
5727 if (*p != '{')
5728 fatal_error (input_location,
5729 "spec %qs has invalid %<%%x%c%>", spec, *p);
5730 while (*p++ != '}')
5731 ;
5732 string = save_string (p1 + 1, p - p1 - 2);
5733
5734 /* See if we already recorded this option. */
5735 FOR_EACH_VEC_ELT (linker_options, ix, opt)
5736 if (! strcmp (string, opt))
5737 {
5738 free (string);
5739 return 0;
5740 }
5741
5742 /* This option is new; add it. */
5743 add_linker_option (string, strlen (string));
5744 free (string);
5745 }
5746 break;
5747
5748 /* Dump out the options accumulated previously using %x. */
5749 case 'X':
5750 do_specs_vec (linker_options);
5751 break;
5752
5753 /* Dump out the options accumulated previously using -Wa,. */
5754 case 'Y':
5755 do_specs_vec (assembler_options);
5756 break;
5757
5758 /* Dump out the options accumulated previously using -Wp,. */
5759 case 'Z':
5760 do_specs_vec (preprocessor_options);
5761 break;
5762
5763 /* Here are digits and numbers that just process
5764 a certain constant string as a spec. */
5765
5766 case '1':
5767 value = do_spec_1 (cc1_spec, 0,