1 /* Compiler driver program that can handle many languages.
2 Copyright (C) 1987-2014 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 /* This program is the user interface to the C compiler and possibly to
21 other compilers. It is used because compilation is a complicated procedure
22 which involves running several programs and passing temporary files between
23 them, forwarding the users switches to those programs selectively,
24 and deleting the temporary files at the end.
26 CC recognizes how to compile each input file by suffixes in the file names.
27 Once it knows which kind of compilation to perform, the procedure for
28 compilation is specified by a string called a "spec". */
32 #include "coretypes.h"
33 #include "multilib.h" /* before tm.h */
40 #include "diagnostic.h"
45 #include "filenames.h"
47 /* By default there is no special suffix for target executables. */
48 /* FIXME: when autoconf is fixed, remove the host check - dj */
49 #if defined(TARGET_EXECUTABLE_SUFFIX) && defined(HOST_EXECUTABLE_SUFFIX)
50 #define HAVE_TARGET_EXECUTABLE_SUFFIX
53 /* By default there is no special suffix for host executables. */
54 #ifdef HOST_EXECUTABLE_SUFFIX
55 #define HAVE_HOST_EXECUTABLE_SUFFIX
57 #define HOST_EXECUTABLE_SUFFIX ""
60 /* By default, the suffix for target object files is ".o". */
61 #ifdef TARGET_OBJECT_SUFFIX
62 #define HAVE_TARGET_OBJECT_SUFFIX
64 #define TARGET_OBJECT_SUFFIX ".o"
67 static const char dir_separator_str
[] = { DIR_SEPARATOR
, 0 };
69 /* Most every one is fine with LIBRARY_PATH. For some, it conflicts. */
70 #ifndef LIBRARY_PATH_ENV
71 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
74 /* If a stage of compilation returns an exit status >= 1,
75 compilation of that file ceases. */
77 #define MIN_FATAL_STATUS 1
79 /* Flag set by cppspec.c to 1. */
82 /* Flag set to nonzero if an @file argument has been supplied to gcc. */
83 static bool at_file_supplied
;
85 /* Definition of string containing the arguments given to configure. */
86 #include "configargs.h"
88 /* Flag saying to print the command line options understood by gcc and its
91 static int print_help_list
;
93 /* Flag saying to print the version of gcc and its sub-processes. */
95 static int print_version
;
97 /* Flag indicating whether we should ONLY print the command and
98 arguments (like verbose_flag) without executing the command.
99 Displayed arguments are quoted so that the generated command
100 line is suitable for execution. This is intended for use in
101 shell scripts to capture the driver-generated command line. */
102 static int verbose_only_flag
;
104 /* Flag indicating how to print command line options of sub-processes. */
106 static int print_subprocess_help
;
108 /* Linker suffix passed to -fuse-ld=... */
109 static const char *use_ld
;
111 /* Whether we should report subprocess execution times to a file. */
113 FILE *report_times_to_file
= NULL
;
115 /* Nonzero means place this string before uses of /, so that include
116 and library files can be found in an alternate location. */
118 #ifdef TARGET_SYSTEM_ROOT
119 static const char *target_system_root
= TARGET_SYSTEM_ROOT
;
121 static const char *target_system_root
= 0;
124 /* Nonzero means pass the updated target_system_root to the compiler. */
126 static int target_system_root_changed
;
128 /* Nonzero means append this string to target_system_root. */
130 static const char *target_sysroot_suffix
= 0;
132 /* Nonzero means append this string to target_system_root for headers. */
134 static const char *target_sysroot_hdrs_suffix
= 0;
136 /* Nonzero means write "temp" files in source directory
137 and use the source file's name in them, and don't delete them. */
139 static enum save_temps
{
140 SAVE_TEMPS_NONE
, /* no -save-temps */
141 SAVE_TEMPS_CWD
, /* -save-temps in current directory */
142 SAVE_TEMPS_OBJ
/* -save-temps in object directory */
145 /* Output file to use to get the object directory for -save-temps=obj */
146 static char *save_temps_prefix
= 0;
147 static size_t save_temps_length
= 0;
149 /* The compiler version. */
151 static const char *compiler_version
;
153 /* The target version. */
155 static const char *const spec_version
= DEFAULT_TARGET_VERSION
;
157 /* The target machine. */
159 static const char *spec_machine
= DEFAULT_TARGET_MACHINE
;
161 /* Nonzero if cross-compiling.
162 When -b is used, the value comes from the `specs' file. */
164 #ifdef CROSS_DIRECTORY_STRUCTURE
165 static const char *cross_compile
= "1";
167 static const char *cross_compile
= "0";
170 /* Greatest exit code of sub-processes that has been encountered up to
172 static int greatest_status
= 1;
174 /* This is the obstack which we use to allocate many strings. */
176 static struct obstack obstack
;
178 /* This is the obstack to build an environment variable to pass to
179 collect2 that describes all of the relevant switches of what to
180 pass the compiler in building the list of pointers to constructors
183 static struct obstack collect_obstack
;
185 /* Forward declaration for prototypes. */
189 static void init_spec (void);
190 static void store_arg (const char *, int, int);
191 static void insert_wrapper (const char *);
192 static char *load_specs (const char *);
193 static void read_specs (const char *, bool, bool);
194 static void set_spec (const char *, const char *, bool);
195 static struct compiler
*lookup_compiler (const char *, size_t, const char *);
196 static char *build_search_list (const struct path_prefix
*, const char *,
198 static void xputenv (const char *);
199 static void putenv_from_prefixes (const struct path_prefix
*, const char *,
201 static int access_check (const char *, int);
202 static char *find_a_file (const struct path_prefix
*, const char *, int, bool);
203 static void add_prefix (struct path_prefix
*, const char *, const char *,
205 static void add_sysrooted_prefix (struct path_prefix
*, const char *,
206 const char *, int, int, int);
207 static char *skip_whitespace (char *);
208 static void delete_if_ordinary (const char *);
209 static void delete_temp_files (void);
210 static void delete_failure_queue (void);
211 static void clear_failure_queue (void);
212 static int check_live_switch (int, int);
213 static const char *handle_braces (const char *);
214 static inline bool input_suffix_matches (const char *, const char *);
215 static inline bool switch_matches (const char *, const char *, int);
216 static inline void mark_matching_switches (const char *, const char *, int);
217 static inline void process_marked_switches (void);
218 static const char *process_brace_body (const char *, const char *, const char *, int, int);
219 static const struct spec_function
*lookup_spec_function (const char *);
220 static const char *eval_spec_function (const char *, const char *);
221 static const char *handle_spec_function (const char *, bool *);
222 static char *save_string (const char *, int);
223 static void set_collect_gcc_options (void);
224 static int do_spec_1 (const char *, int, const char *);
225 static int do_spec_2 (const char *);
226 static void do_option_spec (const char *, const char *);
227 static void do_self_spec (const char *);
228 static const char *find_file (const char *);
229 static int is_directory (const char *, bool);
230 static const char *validate_switches (const char *, bool);
231 static void validate_all_switches (void);
232 static inline void validate_switches_from_spec (const char *, bool);
233 static void give_switch (int, int);
234 static int used_arg (const char *, int);
235 static int default_arg (const char *, int);
236 static void set_multilib_dir (void);
237 static void print_multilib_info (void);
238 static void perror_with_name (const char *);
239 static void display_help (void);
240 static void add_preprocessor_option (const char *, int);
241 static void add_assembler_option (const char *, int);
242 static void add_linker_option (const char *, int);
243 static void process_command (unsigned int, struct cl_decoded_option
*);
244 static int execute (void);
245 static void alloc_args (void);
246 static void clear_args (void);
247 static void fatal_signal (int);
248 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
249 static void init_gcc_specs (struct obstack
*, const char *, const char *,
252 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
253 static const char *convert_filename (const char *, int, int);
256 static void try_generate_repro (const char **argv
);
257 static const char *getenv_spec_function (int, const char **);
258 static const char *if_exists_spec_function (int, const char **);
259 static const char *if_exists_else_spec_function (int, const char **);
260 static const char *sanitize_spec_function (int, const char **);
261 static const char *replace_outfile_spec_function (int, const char **);
262 static const char *remove_outfile_spec_function (int, const char **);
263 static const char *version_compare_spec_function (int, const char **);
264 static const char *include_spec_function (int, const char **);
265 static const char *find_file_spec_function (int, const char **);
266 static const char *find_plugindir_spec_function (int, const char **);
267 static const char *print_asm_header_spec_function (int, const char **);
268 static const char *compare_debug_dump_opt_spec_function (int, const char **);
269 static const char *compare_debug_self_opt_spec_function (int, const char **);
270 static const char *compare_debug_auxbase_opt_spec_function (int, const char **);
271 static const char *pass_through_libs_spec_func (int, const char **);
272 static const char *replace_extension_spec_func (int, const char **);
273 static char *convert_white_space (char *);
275 /* The Specs Language
277 Specs are strings containing lines, each of which (if not blank)
278 is made up of a program name, and arguments separated by spaces.
279 The program name must be exact and start from root, since no path
280 is searched and it is unreliable to depend on the current working directory.
281 Redirection of input or output is not supported; the subprograms must
282 accept filenames saying what files to read and write.
284 In addition, the specs can contain %-sequences to substitute variable text
285 or for conditional text. Here is a table of all defined %-sequences.
286 Note that spaces are not generated automatically around the results of
287 expanding these sequences; therefore, you can concatenate them together
288 or with constant text in a single argument.
290 %% substitute one % into the program name or argument.
291 %i substitute the name of the input file being processed.
292 %b substitute the basename of the input file being processed.
293 This is the substring up to (and not including) the last period
294 and not including the directory unless -save-temps was specified
295 to put temporaries in a different location.
296 %B same as %b, but include the file suffix (text after the last period).
298 substitute a file name that has suffix SUFFIX and is chosen
299 once per compilation, and mark the argument a la %d. To reduce
300 exposure to denial-of-service attacks, the file name is now
301 chosen in a way that is hard to predict even when previously
302 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
303 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
304 the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
305 had been pre-processed. Previously, %g was simply substituted
306 with a file name chosen once per compilation, without regard
307 to any appended suffix (which was therefore treated just like
308 ordinary text), making such attacks more likely to succeed.
310 like %g, but if -pipe is in effect, expands simply to "-".
312 like %g, but if -pipe is in effect, expands to nothing. (We have both
313 %| and %m to accommodate differences between system assemblers; see
314 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
316 like %g, but generates a new temporary file name even if %uSUFFIX
319 substitutes the last file name generated with %uSUFFIX, generating a
320 new one if there is no such last file name. In the absence of any
321 %uSUFFIX, this is just like %gSUFFIX, except they don't share
322 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
323 would involve the generation of two distinct file names, one
324 for each `%g.s' and another for each `%U.s'. Previously, %U was
325 simply substituted with a file name chosen for the previous %u,
326 without regard to any appended suffix.
328 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
329 writable, and if save-temps is off; otherwise, substitute the name
330 of a temporary file, just like %u. This temporary file is not
331 meant for communication between processes, but rather as a junk
334 substitutes .SUFFIX for the suffixes of a matched switch's args when
335 it is subsequently output with %*. SUFFIX is terminated by the next
337 %d marks the argument containing or following the %d as a
338 temporary file name, so that that file will be deleted if GCC exits
339 successfully. Unlike %g, this contributes no text to the argument.
340 %w marks the argument containing or following the %w as the
341 "output file" of this compilation. This puts the argument
342 into the sequence of arguments that %o will substitute later.
343 %V indicates that this compilation produces no "output file".
345 like %{...} but mark last argument supplied within
346 as a file to be deleted on failure.
347 %o substitutes the names of all the output files, with spaces
348 automatically placed around them. You should write spaces
349 around the %o as well or the results are undefined.
350 %o is for use in the specs for running the linker.
351 Input files whose names have no recognized suffix are not compiled
352 at all, but they are included among the output files, so they will
354 %O substitutes the suffix for object files. Note that this is
355 handled specially when it immediately follows %g, %u, or %U
356 (with or without a suffix argument) because of the need for
357 those to form complete file names. The handling is such that
358 %O is treated exactly as if it had already been substituted,
359 except that %g, %u, and %U do not currently support additional
360 SUFFIX characters following %O as they would following, for
362 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
363 (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
364 and -B options) and -imultilib as necessary.
365 %s current argument is the name of a library or startup file of some sort.
366 Search for that file in a standard list of directories
367 and substitute the full name found.
368 %eSTR Print STR as an error message. STR is terminated by a newline.
369 Use this when inconsistent options are detected.
370 %nSTR Print STR as a notice. STR is terminated by a newline.
371 %x{OPTION} Accumulate an option for %X.
372 %X Output the accumulated linker options specified by compilations.
373 %Y Output the accumulated assembler options specified by compilations.
374 %Z Output the accumulated preprocessor options specified by compilations.
375 %a process ASM_SPEC as a spec.
376 This allows config.h to specify part of the spec for running as.
377 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
378 used here. This can be used to run a post-processor after the
379 assembler has done its job.
380 %D Dump out a -L option for each directory in startfile_prefixes.
381 If multilib_dir is set, extra entries are generated with it affixed.
382 %l process LINK_SPEC as a spec.
383 %L process LIB_SPEC as a spec.
384 %M Output multilib_os_dir.
385 %G process LIBGCC_SPEC as a spec.
386 %R Output the concatenation of target_system_root and
387 target_sysroot_suffix.
388 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
389 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
390 %C process CPP_SPEC as a spec.
391 %1 process CC1_SPEC as a spec.
392 %2 process CC1PLUS_SPEC as a spec.
393 %* substitute the variable part of a matched option. (See below.)
394 Note that each comma in the substituted string is replaced by
395 a single space. A space is appended after the last substition
396 unless there is more text in current sequence.
397 %<S remove all occurrences of -S from the command line.
398 Note - this command is position dependent. % commands in the
399 spec string before this one will see -S, % commands in the
400 spec string after this one will not.
401 %>S Similar to "%<S", but keep it in the GCC command line.
402 %<S* remove all occurrences of all switches beginning with -S from the
405 Call the named function FUNCTION, passing it ARGS. ARGS is
406 first processed as a nested spec string, then split into an
407 argument vector in the usual fashion. The function returns
408 a string which is processed as if it had appeared literally
409 as part of the current spec.
410 %{S} substitutes the -S switch, if that switch was given to GCC.
411 If that switch was not specified, this substitutes nothing.
412 Here S is a metasyntactic variable.
413 %{S*} substitutes all the switches specified to GCC whose names start
414 with -S. This is used for -o, -I, etc; switches that take
415 arguments. GCC considers `-o foo' as being one switch whose
416 name starts with `o'. %{o*} would substitute this text,
417 including the space; thus, two arguments would be generated.
418 %{S*&T*} likewise, but preserve order of S and T options (the order
419 of S and T in the spec is not significant). Can be any number
420 of ampersand-separated variables; for each the wild card is
421 optional. Useful for CPP as %{D*&U*&A*}.
423 %{S:X} substitutes X, if the -S switch was given to GCC.
424 %{!S:X} substitutes X, if the -S switch was NOT given to GCC.
425 %{S*:X} substitutes X if one or more switches whose names start
426 with -S was given to GCC. Normally X is substituted only
427 once, no matter how many such switches appeared. However,
428 if %* appears somewhere in X, then X will be substituted
429 once for each matching switch, with the %* replaced by the
430 part of that switch that matched the '*'. A space will be
431 appended after the last substition unless there is more
432 text in current sequence.
433 %{.S:X} substitutes X, if processing a file with suffix S.
434 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
435 %{,S:X} substitutes X, if processing a file which will use spec S.
436 %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
438 %{S|T:X} substitutes X if either -S or -T was given to GCC. This may be
439 combined with '!', '.', ',', and '*' as above binding stronger
441 If %* appears in X, all of the alternatives must be starred, and
442 only the first matching alternative is substituted.
443 %{%:function(args):X}
444 Call function named FUNCTION with args ARGS. If the function
445 returns non-NULL, then X is substituted, if it returns
446 NULL, it isn't substituted.
447 %{S:X; if S was given to GCC, substitutes X;
448 T:Y; else if T was given to GCC, substitutes Y;
449 :D} else substitutes D. There can be as many clauses as you need.
450 This may be combined with '.', '!', ',', '|', and '*' as above.
452 %(Spec) processes a specification defined in a specs file as *Spec:
454 The conditional text X in a %{S:X} or similar construct may contain
455 other nested % constructs or spaces, or even newlines. They are
456 processed as usual, as described above. Trailing white space in X is
457 ignored. White space may also appear anywhere on the left side of the
458 colon in these constructs, except between . or * and the corresponding
461 The -O, -f, -g, -m, and -W switches are handled specifically in these
462 constructs. If another value of -O or the negated form of a -f, -m, or
463 -W switch is found later in the command line, the earlier switch
464 value is ignored, except with {S*} where S is just one letter; this
465 passes all matching options.
467 The character | at the beginning of the predicate text is used to indicate
468 that a command should be piped to the following command, but only if -pipe
471 Note that it is built into GCC which switches take arguments and which
472 do not. You might think it would be useful to generalize this to
473 allow each compiler's spec to say which switches take arguments. But
474 this cannot be done in a consistent fashion. GCC cannot even decide
475 which input files have been specified without knowing which switches
476 take arguments, and it must know which input files to compile in order
477 to tell which compilers to run.
479 GCC also knows implicitly that arguments starting in `-l' are to be
480 treated as compiler output files, and passed to the linker in their
481 proper position among the other output files. */
483 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
485 /* config.h can define ASM_SPEC to provide extra args to the assembler
486 or extra switch-translations. */
491 /* config.h can define ASM_FINAL_SPEC to run a post processor after
492 the assembler has run. */
493 #ifndef ASM_FINAL_SPEC
494 #define ASM_FINAL_SPEC \
496 objcopy --extract-dwo \
497 %{c:%{o*:%*}%{!o*:%b%O}}%{!c:%U%O} \
498 %{c:%{o*:%:replace-extension(%{o*:%*} .dwo)}%{!o*:%b.dwo}}%{!c:%b.dwo} \n\
499 objcopy --strip-dwo \
500 %{c:%{o*:%*}%{!o*:%b%O}}%{!c:%U%O} \
504 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
505 or extra switch-translations. */
510 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
511 or extra switch-translations. */
516 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
517 or extra switch-translations. */
519 #define CC1PLUS_SPEC ""
522 /* config.h can define LINK_SPEC to provide extra args to the linker
523 or extra switch-translations. */
528 /* config.h can define LIB_SPEC to override the default libraries. */
530 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
533 /* When using -fsplit-stack we need to wrap pthread_create, in order
534 to initialize the stack guard. We always use wrapping, rather than
535 shared library ordering, and we keep the wrapper function in
536 libgcc. This is not yet a real spec, though it could become one;
537 it is currently just stuffed into LINK_SPEC. FIXME: This wrapping
538 only works with GNU ld and gold. */
539 #define STACK_SPLIT_SPEC " %{fsplit-stack: --wrap=pthread_create}"
542 #define STATIC_LIBASAN_LIBS \
543 " %{static-libasan:%:include(libsanitizer.spec)%(link_libasan)}"
544 #ifdef LIBASAN_EARLY_SPEC
545 #define LIBASAN_SPEC STATIC_LIBASAN_LIBS
546 #elif defined(HAVE_LD_STATIC_DYNAMIC)
547 #define LIBASAN_SPEC "%{static-libasan:" LD_STATIC_OPTION \
548 "} -lasan %{static-libasan:" LD_DYNAMIC_OPTION "}" \
551 #define LIBASAN_SPEC "-lasan" STATIC_LIBASAN_LIBS
555 #ifndef LIBASAN_EARLY_SPEC
556 #define LIBASAN_EARLY_SPEC ""
560 #define STATIC_LIBTSAN_LIBS \
561 " %{static-libtsan:%:include(libsanitizer.spec)%(link_libtsan)}"
562 #ifdef LIBTSAN_EARLY_SPEC
563 #define LIBTSAN_SPEC STATIC_LIBTSAN_LIBS
564 #elif defined(HAVE_LD_STATIC_DYNAMIC)
565 #define LIBTSAN_SPEC "%{static-libtsan:" LD_STATIC_OPTION \
566 "} -ltsan %{static-libtsan:" LD_DYNAMIC_OPTION "}" \
569 #define LIBTSAN_SPEC "-ltsan" STATIC_LIBTSAN_LIBS
573 #ifndef LIBTSAN_EARLY_SPEC
574 #define LIBTSAN_EARLY_SPEC ""
578 #define STATIC_LIBLSAN_LIBS \
579 " %{static-liblsan:%:include(libsanitizer.spec)%(link_liblsan)}"
580 #ifdef LIBLSAN_EARLY_SPEC
581 #define LIBLSAN_SPEC STATIC_LIBLSAN_LIBS
582 #elif defined(HAVE_LD_STATIC_DYNAMIC)
583 #define LIBLSAN_SPEC "%{static-liblsan:" LD_STATIC_OPTION \
584 "} -llsan %{static-liblsan:" LD_DYNAMIC_OPTION "}" \
587 #define LIBLSAN_SPEC "-llsan" STATIC_LIBLSAN_LIBS
591 #ifndef LIBLSAN_EARLY_SPEC
592 #define LIBLSAN_EARLY_SPEC ""
595 #ifndef LIBUBSAN_SPEC
596 #define STATIC_LIBUBSAN_LIBS \
597 " %{static-libubsan:%:include(libsanitizer.spec)%(link_libubsan)}"
598 #ifdef HAVE_LD_STATIC_DYNAMIC
599 #define LIBUBSAN_SPEC "%{static-libubsan:" LD_STATIC_OPTION \
600 "} -lubsan %{static-libubsan:" LD_DYNAMIC_OPTION "}" \
603 #define LIBUBSAN_SPEC "-lubsan" STATIC_LIBUBSAN_LIBS
607 /* Linker options for compressed debug sections. */
608 #if HAVE_LD_COMPRESS_DEBUG == 0
609 /* No linker support. */
610 #define LINK_COMPRESS_DEBUG_SPEC \
611 " %{gz*:%e-gz is not supported in this configuration} "
612 #elif HAVE_LD_COMPRESS_DEBUG == 1
613 /* GNU style on input, GNU ld options. Reject, not useful. */
614 #define LINK_COMPRESS_DEBUG_SPEC \
615 " %{gz*:%e-gz is not supported in this configuration} "
616 #elif HAVE_LD_COMPRESS_DEBUG == 2
617 /* GNU style, GNU gold options. */
618 #define LINK_COMPRESS_DEBUG_SPEC \
619 " %{gz|gz=zlib-gnu:" LD_COMPRESS_DEBUG_OPTION "=zlib}" \
620 " %{gz=none:" LD_COMPRESS_DEBUG_OPTION "=none}" \
621 " %{gz=zlib:%e-gz=zlib is not supported in this configuration} "
622 #elif HAVE_LD_COMPRESS_DEBUG == 3
623 /* ELF gABI style. */
624 #define LINK_COMPRESS_DEBUG_SPEC \
625 " %{gz|gz=zlib:" LD_COMPRESS_DEBUG_OPTION "=zlib}" \
626 " %{gz=none:" LD_COMPRESS_DEBUG_OPTION "=none}" \
627 " %{gz=zlib-gnu:" LD_COMPRESS_DEBUG_OPTION "=zlib-gnu} "
629 #error Unknown value for HAVE_LD_COMPRESS_DEBUG.
632 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
635 #if defined(REAL_LIBGCC_SPEC)
636 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
637 #elif defined(LINK_LIBGCC_SPECIAL_1)
638 /* Have gcc do the search for libgcc.a. */
639 #define LIBGCC_SPEC "libgcc.a%s"
641 #define LIBGCC_SPEC "-lgcc"
645 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
646 #ifndef STARTFILE_SPEC
647 #define STARTFILE_SPEC \
648 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
651 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
653 #define ENDFILE_SPEC ""
657 #define LINKER_NAME "collect2"
660 #ifdef HAVE_AS_DEBUG_PREFIX_MAP
661 #define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
666 /* Assembler options for compressed debug sections. */
667 #if HAVE_LD_COMPRESS_DEBUG < 2
668 /* Reject if the linker cannot write compressed debug sections. */
669 #define ASM_COMPRESS_DEBUG_SPEC \
670 " %{gz*:%e-gz is not supported in this configuration} "
671 #else /* HAVE_LD_COMPRESS_DEBUG >= 2 */
672 #if HAVE_AS_COMPRESS_DEBUG == 0
673 /* No assembler support. Ignore silently. */
674 #define ASM_COMPRESS_DEBUG_SPEC \
676 #elif HAVE_AS_COMPRESS_DEBUG == 1
677 /* GNU style, GNU as options. */
678 #define ASM_COMPRESS_DEBUG_SPEC \
679 " %{gz|gz=zlib-gnu:" AS_COMPRESS_DEBUG_OPTION "}" \
680 " %{gz=none:" AS_NO_COMPRESS_DEBUG_OPTION "}" \
681 " %{gz=zlib:%e-gz=zlib is not supported in this configuration} "
682 #elif HAVE_AS_COMPRESS_DEBUG == 2
683 /* ELF gABI style. */
684 #define ASM_COMPRESS_DEBUG_SPEC \
685 " %{gz|gz=zlib:" AS_COMPRESS_DEBUG_OPTION "=zlib}" \
686 " %{gz=none:" AS_COMPRESS_DEBUG_OPTION "=none}" \
687 " %{gz=zlib-gnu:" AS_COMPRESS_DEBUG_OPTION "=zlib-gnu} "
689 #error Unknown value for HAVE_AS_COMPRESS_DEBUG.
691 #endif /* HAVE_LD_COMPRESS_DEBUG >= 2 */
693 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
695 #ifndef ASM_DEBUG_SPEC
696 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
697 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
698 # define ASM_DEBUG_SPEC \
699 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
700 ? "%{!g0:%{gdwarf*:--gdwarf2}%{!gdwarf*:%{g*:--gstabs}}}" ASM_MAP \
701 : "%{!g0:%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}}" ASM_MAP)
703 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
704 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gstabs}}" ASM_MAP
706 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
707 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gdwarf2}}" ASM_MAP
711 #ifndef ASM_DEBUG_SPEC
712 # define ASM_DEBUG_SPEC ""
715 /* Here is the spec for running the linker, after compiling all files. */
717 /* This is overridable by the target in case they need to specify the
718 -lgcc and -lc order specially, yet not require them to override all
719 of LINK_COMMAND_SPEC. */
720 #ifndef LINK_GCC_C_SEQUENCE_SPEC
721 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
724 #ifndef LINK_SSP_SPEC
725 #ifdef TARGET_LIBC_PROVIDES_SSP
726 #define LINK_SSP_SPEC "%{fstack-protector:}"
728 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-strong|fstack-protector-all:-lssp_nonshared -lssp}"
732 #ifndef LINK_PIE_SPEC
734 #define LINK_PIE_SPEC "%{pie:-pie} "
736 #define LINK_PIE_SPEC "%{pie:} "
740 #ifndef LINK_BUILDID_SPEC
741 # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
742 # define LINK_BUILDID_SPEC "%{!r:--build-id} "
746 /* Conditional to test whether the LTO plugin is used or not.
747 FIXME: For slim LTO we will need to enable plugin unconditionally. This
748 still cause problems with PLUGIN_LD != LD and when plugin is built but
749 not useable. For GCC 4.6 we don't support slim LTO and thus we can enable
750 plugin only when LTO is enabled. We still honor explicit
751 -fuse-linker-plugin if the linker used understands -plugin. */
753 /* The linker has some plugin support. */
754 #if HAVE_LTO_PLUGIN > 0
755 /* The linker used has full plugin support, use LTO plugin by default. */
756 #if HAVE_LTO_PLUGIN == 2
757 #define PLUGIN_COND "!fno-use-linker-plugin:%{!fno-lto"
758 #define PLUGIN_COND_CLOSE "}"
760 /* The linker used has limited plugin support, use LTO plugin with explicit
761 -fuse-linker-plugin. */
762 #define PLUGIN_COND "fuse-linker-plugin"
763 #define PLUGIN_COND_CLOSE ""
765 #define LINK_PLUGIN_SPEC \
767 -plugin %(linker_plugin_file) \
768 -plugin-opt=%(lto_wrapper) \
769 -plugin-opt=-fresolution=%u.res \
770 %{!nostdlib:%{!nodefaultlibs:%:pass-through-libs(%(link_gcc_c_sequence))}} \
773 /* The linker used doesn't support -plugin, reject -fuse-linker-plugin. */
774 #define LINK_PLUGIN_SPEC "%{fuse-linker-plugin:\
775 %e-fuse-linker-plugin is not supported in this configuration}"
778 /* Linker command line options for -fsanitize= early on the command line. */
779 #ifndef SANITIZER_EARLY_SPEC
780 #define SANITIZER_EARLY_SPEC "\
781 %{!nostdlib:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_EARLY_SPEC "} \
782 %{%:sanitize(thread):" LIBTSAN_EARLY_SPEC "} \
783 %{%:sanitize(leak):" LIBLSAN_EARLY_SPEC "}}}"
786 /* Linker command line options for -fsanitize= late on the command line. */
787 #ifndef SANITIZER_SPEC
788 #define SANITIZER_SPEC "\
789 %{!nostdlib:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_SPEC "\
790 %{static:%ecannot specify -static with -fsanitize=address}}\
791 %{%:sanitize(thread):" LIBTSAN_SPEC "\
792 %{!pie:%{!shared:%e-fsanitize=thread linking must be done with -pie or -shared}}}\
793 %{%:sanitize(undefined):" LIBUBSAN_SPEC "}\
794 %{%:sanitize(leak):" LIBLSAN_SPEC "}}}"
797 /* This is the spec to use, once the code for creating the vtable
798 verification runtime library, libvtv.so, has been created. Currently
799 the vtable verification runtime functions are in libstdc++, so we use
800 the spec just below this one. */
801 #ifndef VTABLE_VERIFICATION_SPEC
802 #define VTABLE_VERIFICATION_SPEC "\
803 %{!nostdlib:%{fvtable-verify=std: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}\
804 %{fvtable-verify=preinit: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}}"
807 /* -u* was put back because both BSD and SysV seem to support it. */
808 /* %{static:} simply prevents an error message if the target machine
809 doesn't handle -static. */
810 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
811 scripts which exist in user specified directories, or in standard
813 /* We pass any -flto flags on to the linker, which is expected
814 to understand them. In practice, this means it had better be collect2. */
815 /* %{e*} includes -export-dynamic; see comment in common.opt. */
816 #ifndef LINK_COMMAND_SPEC
817 #define LINK_COMMAND_SPEC "\
818 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
821 "%{flto|flto=*:%<fcompare-debug*} \
822 %{flto} %{fno-lto} %{flto=*} %l " LINK_PIE_SPEC \
823 "%{fuse-ld=*:-fuse-ld=%*} " LINK_COMPRESS_DEBUG_SPEC \
824 "%X %{o*} %{e*} %{N} %{n} %{r}\
825 %{s} %{t} %{u*} %{z} %{Z} %{!nostdlib:%{!nostartfiles:%S}} " VTABLE_VERIFICATION_SPEC " \
826 %{static:} %{L*} %(mfwrap) %(link_libgcc) " SANITIZER_EARLY_SPEC " %o\
827 %{fopenmp|ftree-parallelize-loops=*:%:include(libgomp.spec)%(link_gomp)}\
828 %{fcilkplus:%:include(libcilkrts.spec)%(link_cilkrts)}\
829 %{fgnu-tm:%:include(libitm.spec)%(link_itm)}\
830 %(mflib) " STACK_SPLIT_SPEC "\
831 %{fprofile-arcs|fprofile-generate*|coverage:-lgcov} " SANITIZER_SPEC " \
832 %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\
833 %{!nostdlib:%{!nostartfiles:%E}} %{T*} }}}}}}"
836 #ifndef LINK_LIBGCC_SPEC
837 /* Generate -L options for startfile prefix list. */
838 # define LINK_LIBGCC_SPEC "%D"
841 #ifndef STARTFILE_PREFIX_SPEC
842 # define STARTFILE_PREFIX_SPEC ""
846 # define SYSROOT_SPEC "--sysroot=%R"
849 #ifndef SYSROOT_SUFFIX_SPEC
850 # define SYSROOT_SUFFIX_SPEC ""
853 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
854 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
857 static const char *asm_debug
= ASM_DEBUG_SPEC
;
858 static const char *cpp_spec
= CPP_SPEC
;
859 static const char *cc1_spec
= CC1_SPEC
;
860 static const char *cc1plus_spec
= CC1PLUS_SPEC
;
861 static const char *link_gcc_c_sequence_spec
= LINK_GCC_C_SEQUENCE_SPEC
;
862 static const char *link_ssp_spec
= LINK_SSP_SPEC
;
863 static const char *asm_spec
= ASM_SPEC
;
864 static const char *asm_final_spec
= ASM_FINAL_SPEC
;
865 static const char *link_spec
= LINK_SPEC
;
866 static const char *lib_spec
= LIB_SPEC
;
867 static const char *link_gomp_spec
= "";
868 static const char *libgcc_spec
= LIBGCC_SPEC
;
869 static const char *endfile_spec
= ENDFILE_SPEC
;
870 static const char *startfile_spec
= STARTFILE_SPEC
;
871 static const char *linker_name_spec
= LINKER_NAME
;
872 static const char *linker_plugin_file_spec
= "";
873 static const char *lto_wrapper_spec
= "";
874 static const char *lto_gcc_spec
= "";
875 static const char *link_command_spec
= LINK_COMMAND_SPEC
;
876 static const char *link_libgcc_spec
= LINK_LIBGCC_SPEC
;
877 static const char *startfile_prefix_spec
= STARTFILE_PREFIX_SPEC
;
878 static const char *sysroot_spec
= SYSROOT_SPEC
;
879 static const char *sysroot_suffix_spec
= SYSROOT_SUFFIX_SPEC
;
880 static const char *sysroot_hdrs_suffix_spec
= SYSROOT_HEADERS_SUFFIX_SPEC
;
881 static const char *self_spec
= "";
883 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
884 There should be no need to override these in target dependent files,
885 but we need to copy them to the specs file so that newer versions
886 of the GCC driver can correctly drive older tool chains with the
887 appropriate -B options. */
889 /* When cpplib handles traditional preprocessing, get rid of this, and
890 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
891 that we default the front end language better. */
892 static const char *trad_capable_cpp
=
893 "cc1 -E %{traditional|traditional-cpp:-traditional-cpp}";
895 /* We don't wrap .d files in %W{} since a missing .d file, and
896 therefore no dependency entry, confuses make into thinking a .o
897 file that happens to exist is up-to-date. */
898 static const char *cpp_unique_options
=
899 "%{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\
900 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
901 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
902 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
903 %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
904 %{remap} %{g3|ggdb3|gstabs3|gcoff3|gxcoff3|gvms3:-dD}\
905 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
906 %{H} %C %{D*&U*&A*} %{i*} %Z %i\
909 /* This contains cpp options which are common with cc1_options and are passed
910 only when preprocessing only to avoid duplication. We pass the cc1 spec
911 options to the preprocessor so that it the cc1 spec may manipulate
912 options used to set target flags. Those special target flags settings may
913 in turn cause preprocessor symbols to be defined specially. */
914 static const char *cpp_options
=
915 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
916 %{f*} %{g*:%{!g0:%{g*} %{!fno-working-directory:-fworking-directory}}} %{O*}\
917 %{undef} %{save-temps*:-fpch-preprocess}";
919 /* This contains cpp options which are not passed when the preprocessor
920 output will be used by another program. */
921 static const char *cpp_debug_options
= "%{d*}";
923 /* NB: This is shared amongst all front-ends, except for Ada. */
924 static const char *cc1_options
=
925 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
926 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
927 %1 %{!Q:-quiet} %{!dumpbase:-dumpbase %B} %{d*} %{m*} %{aux-info*}\
928 %{fcompare-debug-second:%:compare-debug-auxbase-opt(%b)} \
929 %{!fcompare-debug-second:%{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}}%{!c:%{!S:-auxbase %b}} \
930 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
931 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
932 %{Qn:-fno-ident} %{Qy:} %{-help:--help}\
933 %{-target-help:--target-help}\
934 %{-version:--version}\
935 %{-help=*:--help=%*}\
936 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
937 %{fsyntax-only:-o %j} %{-param*}\
938 %{coverage:-fprofile-arcs -ftest-coverage}";
940 static const char *asm_options
=
941 "%{-target-help:%:print-asm-header()} "
943 /* If GNU AS is used, then convert -w (no warnings), -I, and -v
944 to the assembler equivalents. */
945 "%{v} %{w:-W} %{I*} "
947 ASM_COMPRESS_DEBUG_SPEC
948 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
950 static const char *invoke_as
=
951 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
953 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
954 %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
958 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
959 %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
963 /* Some compilers have limits on line lengths, and the multilib_select
964 and/or multilib_matches strings can be very long, so we build them at
966 static struct obstack multilib_obstack
;
967 static const char *multilib_select
;
968 static const char *multilib_matches
;
969 static const char *multilib_defaults
;
970 static const char *multilib_exclusions
;
971 static const char *multilib_reuse
;
973 /* Check whether a particular argument is a default argument. */
975 #ifndef MULTILIB_DEFAULTS
976 #define MULTILIB_DEFAULTS { "" }
979 static const char *const multilib_defaults_raw
[] = MULTILIB_DEFAULTS
;
981 #ifndef DRIVER_SELF_SPECS
982 #define DRIVER_SELF_SPECS ""
985 /* Linking to libgomp implies pthreads. This is particularly important
986 for targets that use different start files and suchlike. */
987 #ifndef GOMP_SELF_SPECS
988 #define GOMP_SELF_SPECS "%{fopenmp|ftree-parallelize-loops=*: -pthread}"
991 /* Likewise for -fgnu-tm. */
992 #ifndef GTM_SELF_SPECS
993 #define GTM_SELF_SPECS "%{fgnu-tm: -pthread}"
996 /* Likewise for -fcilkplus. */
997 #ifndef CILK_SELF_SPECS
998 #define CILK_SELF_SPECS "%{fcilkplus: -pthread}"
1001 static const char *const driver_self_specs
[] = {
1002 "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
1003 DRIVER_SELF_SPECS
, CONFIGURE_SPECS
, GOMP_SELF_SPECS
, GTM_SELF_SPECS
,
1007 #ifndef OPTION_DEFAULT_SPECS
1008 #define OPTION_DEFAULT_SPECS { "", "" }
1017 static const struct default_spec
1018 option_default_specs
[] = { OPTION_DEFAULT_SPECS
};
1022 struct user_specs
*next
;
1023 const char *filename
;
1026 static struct user_specs
*user_specs_head
, *user_specs_tail
;
1029 /* Record the mapping from file suffixes for compilation specs. */
1033 const char *suffix
; /* Use this compiler for input files
1034 whose names end in this suffix. */
1036 const char *spec
; /* To use this compiler, run this spec. */
1038 const char *cpp_spec
; /* If non-NULL, substitute this spec
1039 for `%C', rather than the usual
1041 const int combinable
; /* If nonzero, compiler can deal with
1042 multiple source files at once (IMA). */
1043 const int needs_preprocessing
; /* If nonzero, source files need to
1044 be run through a preprocessor. */
1047 /* Pointer to a vector of `struct compiler' that gives the spec for
1048 compiling a file, based on its suffix.
1049 A file that does not end in any of these suffixes will be passed
1050 unchanged to the loader and nothing else will be done to it.
1052 An entry containing two 0s is used to terminate the vector.
1054 If multiple entries match a file, the last matching one is used. */
1056 static struct compiler
*compilers
;
1058 /* Number of entries in `compilers', not counting the null terminator. */
1060 static int n_compilers
;
1062 /* The default list of file name suffixes and their compilation specs. */
1064 static const struct compiler default_compilers
[] =
1066 /* Add lists of suffixes of known languages here. If those languages
1067 were not present when we built the driver, we will hit these copies
1068 and be given a more meaningful error than "file not used since
1069 linking is not done". */
1070 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0},
1071 {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
1072 {".mii", "#Objective-C++", 0, 0, 0},
1073 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
1074 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
1075 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
1076 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
1077 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
1078 {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
1079 {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
1080 {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
1081 {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
1082 {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
1083 {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
1084 {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
1085 {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
1086 {".r", "#Ratfor", 0, 0, 0},
1087 {".p", "#Pascal", 0, 0, 0}, {".pas", "#Pascal", 0, 0, 0},
1088 {".java", "#Java", 0, 0, 0}, {".class", "#Java", 0, 0, 0},
1089 {".zip", "#Java", 0, 0, 0}, {".jar", "#Java", 0, 0, 0},
1090 {".go", "#Go", 0, 1, 0},
1091 /* Next come the entries for C. */
1092 {".c", "@c", 0, 0, 1},
1094 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1095 external preprocessor if -save-temps is given. */
1096 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1099 %eGNU C no longer supports -traditional without -E}\
1100 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1101 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1102 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1104 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1105 cc1 %(cpp_unique_options) %(cc1_options)}}}\
1106 %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 1},
1108 "%{!E:%e-E or -x required when input is from standard input}\
1109 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
1110 {".h", "@c-header", 0, 0, 0},
1112 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1113 external preprocessor if -save-temps is given. */
1114 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1116 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1117 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1118 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1120 %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
1121 %W{o*:--output-pch=%*}}%V}\
1122 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1123 cc1 %(cpp_unique_options) %(cc1_options)\
1124 %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
1125 %W{o*:--output-pch=%*}}%V}}}}}}", 0, 0, 0},
1126 {".i", "@cpp-output", 0, 0, 0},
1128 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 0},
1129 {".s", "@assembler", 0, 0, 0},
1131 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 0, 0},
1132 {".sx", "@assembler-with-cpp", 0, 0, 0},
1133 {".S", "@assembler-with-cpp", 0, 0, 0},
1134 {"@assembler-with-cpp",
1135 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1136 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1137 %{E|M|MM:%(cpp_debug_options)}\
1138 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1139 as %(asm_debug) %(asm_options) %|.s %A }}}}"
1141 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1142 %{E|M|MM:%(cpp_debug_options)}\
1143 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1144 as %(asm_debug) %(asm_options) %m.s %A }}}}"
1149 /* Mark end of table. */
1153 /* Number of elements in default_compilers, not counting the terminator. */
1155 static const int n_default_compilers
= ARRAY_SIZE (default_compilers
) - 1;
1157 typedef char *char_p
; /* For DEF_VEC_P. */
1159 /* A vector of options to give to the linker.
1160 These options are accumulated by %x,
1161 and substituted into the linker command with %X. */
1162 static vec
<char_p
> linker_options
;
1164 /* A vector of options to give to the assembler.
1165 These options are accumulated by -Wa,
1166 and substituted into the assembler command with %Y. */
1167 static vec
<char_p
> assembler_options
;
1169 /* A vector of options to give to the preprocessor.
1170 These options are accumulated by -Wp,
1171 and substituted into the preprocessor command with %Z. */
1172 static vec
<char_p
> preprocessor_options
;
1175 skip_whitespace (char *p
)
1179 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1180 be considered whitespace. */
1181 if (p
[0] == '\n' && p
[1] == '\n' && p
[2] == '\n')
1183 else if (*p
== '\n' || *p
== ' ' || *p
== '\t')
1197 /* Structures to keep track of prefixes to try when looking for files. */
1201 const char *prefix
; /* String to prepend to the path. */
1202 struct prefix_list
*next
; /* Next in linked list. */
1203 int require_machine_suffix
; /* Don't use without machine_suffix. */
1204 /* 2 means try both machine_suffix and just_machine_suffix. */
1205 int priority
; /* Sort key - priority within list. */
1206 int os_multilib
; /* 1 if OS multilib scheme should be used,
1207 0 for GCC multilib scheme. */
1212 struct prefix_list
*plist
; /* List of prefixes to try */
1213 int max_len
; /* Max length of a prefix in PLIST */
1214 const char *name
; /* Name of this list (used in config stuff) */
1217 /* List of prefixes to try when looking for executables. */
1219 static struct path_prefix exec_prefixes
= { 0, 0, "exec" };
1221 /* List of prefixes to try when looking for startup (crt0) files. */
1223 static struct path_prefix startfile_prefixes
= { 0, 0, "startfile" };
1225 /* List of prefixes to try when looking for include files. */
1227 static struct path_prefix include_prefixes
= { 0, 0, "include" };
1229 /* Suffix to attach to directories searched for commands.
1230 This looks like `MACHINE/VERSION/'. */
1232 static const char *machine_suffix
= 0;
1234 /* Suffix to attach to directories searched for commands.
1235 This is just `MACHINE/'. */
1237 static const char *just_machine_suffix
= 0;
1239 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1241 static const char *gcc_exec_prefix
;
1243 /* Adjusted value of standard_libexec_prefix. */
1245 static const char *gcc_libexec_prefix
;
1247 /* Default prefixes to attach to command names. */
1249 #ifndef STANDARD_STARTFILE_PREFIX_1
1250 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1252 #ifndef STANDARD_STARTFILE_PREFIX_2
1253 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1256 #ifdef CROSS_DIRECTORY_STRUCTURE /* Don't use these prefixes for a cross compiler. */
1257 #undef MD_EXEC_PREFIX
1258 #undef MD_STARTFILE_PREFIX
1259 #undef MD_STARTFILE_PREFIX_1
1262 /* If no prefixes defined, use the null string, which will disable them. */
1263 #ifndef MD_EXEC_PREFIX
1264 #define MD_EXEC_PREFIX ""
1266 #ifndef MD_STARTFILE_PREFIX
1267 #define MD_STARTFILE_PREFIX ""
1269 #ifndef MD_STARTFILE_PREFIX_1
1270 #define MD_STARTFILE_PREFIX_1 ""
1273 /* These directories are locations set at configure-time based on the
1274 --prefix option provided to configure. Their initializers are
1275 defined in Makefile.in. These paths are not *directly* used when
1276 gcc_exec_prefix is set because, in that case, we know where the
1277 compiler has been installed, and use paths relative to that
1278 location instead. */
1279 static const char *const standard_exec_prefix
= STANDARD_EXEC_PREFIX
;
1280 static const char *const standard_libexec_prefix
= STANDARD_LIBEXEC_PREFIX
;
1281 static const char *const standard_bindir_prefix
= STANDARD_BINDIR_PREFIX
;
1282 static const char *const standard_startfile_prefix
= STANDARD_STARTFILE_PREFIX
;
1284 /* For native compilers, these are well-known paths containing
1285 components that may be provided by the system. For cross
1286 compilers, these paths are not used. */
1287 static const char *md_exec_prefix
= MD_EXEC_PREFIX
;
1288 static const char *md_startfile_prefix
= MD_STARTFILE_PREFIX
;
1289 static const char *md_startfile_prefix_1
= MD_STARTFILE_PREFIX_1
;
1290 static const char *const standard_startfile_prefix_1
1291 = STANDARD_STARTFILE_PREFIX_1
;
1292 static const char *const standard_startfile_prefix_2
1293 = STANDARD_STARTFILE_PREFIX_2
;
1295 /* A relative path to be used in finding the location of tools
1296 relative to the driver. */
1297 static const char *const tooldir_base_prefix
= TOOLDIR_BASE_PREFIX
;
1299 /* Subdirectory to use for locating libraries. Set by
1300 set_multilib_dir based on the compilation options. */
1302 static const char *multilib_dir
;
1304 /* Subdirectory to use for locating libraries in OS conventions. Set by
1305 set_multilib_dir based on the compilation options. */
1307 static const char *multilib_os_dir
;
1309 /* Subdirectory to use for locating libraries in multiarch conventions. Set by
1310 set_multilib_dir based on the compilation options. */
1312 static const char *multiarch_dir
;
1314 /* Structure to keep track of the specs that have been defined so far.
1315 These are accessed using %(specname) in a compiler or link
1320 /* The following 2 fields must be first */
1321 /* to allow EXTRA_SPECS to be initialized */
1322 const char *name
; /* name of the spec. */
1323 const char *ptr
; /* available ptr if no static pointer */
1325 /* The following fields are not initialized */
1326 /* by EXTRA_SPECS */
1327 const char **ptr_spec
; /* pointer to the spec itself. */
1328 struct spec_list
*next
; /* Next spec in linked list. */
1329 int name_len
; /* length of the name */
1330 bool user_p
; /* whether string come from file spec. */
1331 bool alloc_p
; /* whether string was allocated */
1334 #define INIT_STATIC_SPEC(NAME,PTR) \
1335 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, false, false }
1337 /* List of statically defined specs. */
1338 static struct spec_list static_specs
[] =
1340 INIT_STATIC_SPEC ("asm", &asm_spec
),
1341 INIT_STATIC_SPEC ("asm_debug", &asm_debug
),
1342 INIT_STATIC_SPEC ("asm_final", &asm_final_spec
),
1343 INIT_STATIC_SPEC ("asm_options", &asm_options
),
1344 INIT_STATIC_SPEC ("invoke_as", &invoke_as
),
1345 INIT_STATIC_SPEC ("cpp", &cpp_spec
),
1346 INIT_STATIC_SPEC ("cpp_options", &cpp_options
),
1347 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options
),
1348 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options
),
1349 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp
),
1350 INIT_STATIC_SPEC ("cc1", &cc1_spec
),
1351 INIT_STATIC_SPEC ("cc1_options", &cc1_options
),
1352 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec
),
1353 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec
),
1354 INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec
),
1355 INIT_STATIC_SPEC ("endfile", &endfile_spec
),
1356 INIT_STATIC_SPEC ("link", &link_spec
),
1357 INIT_STATIC_SPEC ("lib", &lib_spec
),
1358 INIT_STATIC_SPEC ("link_gomp", &link_gomp_spec
),
1359 INIT_STATIC_SPEC ("libgcc", &libgcc_spec
),
1360 INIT_STATIC_SPEC ("startfile", &startfile_spec
),
1361 INIT_STATIC_SPEC ("cross_compile", &cross_compile
),
1362 INIT_STATIC_SPEC ("version", &compiler_version
),
1363 INIT_STATIC_SPEC ("multilib", &multilib_select
),
1364 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults
),
1365 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra
),
1366 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches
),
1367 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions
),
1368 INIT_STATIC_SPEC ("multilib_options", &multilib_options
),
1369 INIT_STATIC_SPEC ("multilib_reuse", &multilib_reuse
),
1370 INIT_STATIC_SPEC ("linker", &linker_name_spec
),
1371 INIT_STATIC_SPEC ("linker_plugin_file", &linker_plugin_file_spec
),
1372 INIT_STATIC_SPEC ("lto_wrapper", <o_wrapper_spec
),
1373 INIT_STATIC_SPEC ("lto_gcc", <o_gcc_spec
),
1374 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec
),
1375 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix
),
1376 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix
),
1377 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1
),
1378 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec
),
1379 INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec
),
1380 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec
),
1381 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec
),
1382 INIT_STATIC_SPEC ("self_spec", &self_spec
),
1385 #ifdef EXTRA_SPECS /* additional specs needed */
1386 /* Structure to keep track of just the first two args of a spec_list.
1387 That is all that the EXTRA_SPECS macro gives us. */
1390 const char *const name
;
1391 const char *const ptr
;
1394 static const struct spec_list_1 extra_specs_1
[] = { EXTRA_SPECS
};
1395 static struct spec_list
*extra_specs
= (struct spec_list
*) 0;
1398 /* List of dynamically allocates specs that have been defined so far. */
1400 static struct spec_list
*specs
= (struct spec_list
*) 0;
1402 /* List of static spec functions. */
1404 static const struct spec_function static_spec_functions
[] =
1406 { "getenv", getenv_spec_function
},
1407 { "if-exists", if_exists_spec_function
},
1408 { "if-exists-else", if_exists_else_spec_function
},
1409 { "sanitize", sanitize_spec_function
},
1410 { "replace-outfile", replace_outfile_spec_function
},
1411 { "remove-outfile", remove_outfile_spec_function
},
1412 { "version-compare", version_compare_spec_function
},
1413 { "include", include_spec_function
},
1414 { "find-file", find_file_spec_function
},
1415 { "find-plugindir", find_plugindir_spec_function
},
1416 { "print-asm-header", print_asm_header_spec_function
},
1417 { "compare-debug-dump-opt", compare_debug_dump_opt_spec_function
},
1418 { "compare-debug-self-opt", compare_debug_self_opt_spec_function
},
1419 { "compare-debug-auxbase-opt", compare_debug_auxbase_opt_spec_function
},
1420 { "pass-through-libs", pass_through_libs_spec_func
},
1421 { "replace-extension", replace_extension_spec_func
},
1422 #ifdef EXTRA_SPEC_FUNCTIONS
1423 EXTRA_SPEC_FUNCTIONS
1428 static int processing_spec_function
;
1430 /* Add appropriate libgcc specs to OBSTACK, taking into account
1431 various permutations of -shared-libgcc, -shared, and such. */
1433 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1435 #ifndef USE_LD_AS_NEEDED
1436 #define USE_LD_AS_NEEDED 0
1440 init_gcc_specs (struct obstack
*obstack
, const char *shared_name
,
1441 const char *static_name
, const char *eh_name
)
1445 buf
= concat ("%{static|static-libgcc:", static_name
, " ", eh_name
, "}"
1446 "%{!static:%{!static-libgcc:"
1447 #if USE_LD_AS_NEEDED
1448 "%{!shared-libgcc:",
1449 static_name
, " " LD_AS_NEEDED_OPTION
" ",
1450 shared_name
, " " LD_NO_AS_NEEDED_OPTION
1453 shared_name
, "%{!shared: ", static_name
, "}"
1457 "%{!shared-libgcc:", static_name
, " ", eh_name
, "}"
1458 "%{shared-libgcc:", shared_name
, " ", static_name
, "}"
1462 "%{shared-libgcc:", shared_name
, "}"
1463 "%{!shared-libgcc:", static_name
, "}"
1466 "%{shared:", shared_name
, "}"
1471 obstack_grow (obstack
, buf
, strlen (buf
));
1474 #endif /* ENABLE_SHARED_LIBGCC */
1476 /* Initialize the specs lookup routines. */
1481 struct spec_list
*next
= (struct spec_list
*) 0;
1482 struct spec_list
*sl
= (struct spec_list
*) 0;
1486 return; /* Already initialized. */
1489 fnotice (stderr
, "Using built-in specs.\n");
1492 extra_specs
= XCNEWVEC (struct spec_list
, ARRAY_SIZE (extra_specs_1
));
1494 for (i
= ARRAY_SIZE (extra_specs_1
) - 1; i
>= 0; i
--)
1496 sl
= &extra_specs
[i
];
1497 sl
->name
= extra_specs_1
[i
].name
;
1498 sl
->ptr
= extra_specs_1
[i
].ptr
;
1500 sl
->name_len
= strlen (sl
->name
);
1501 sl
->ptr_spec
= &sl
->ptr
;
1506 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1508 sl
= &static_specs
[i
];
1513 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1514 /* ??? If neither -shared-libgcc nor --static-libgcc was
1515 seen, then we should be making an educated guess. Some proposed
1516 heuristics for ELF include:
1518 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1519 program will be doing dynamic loading, which will likely
1520 need the shared libgcc.
1522 (2) If "-ldl", then it's also a fair bet that we're doing
1525 (3) For each ET_DYN we're linking against (either through -lfoo
1526 or /some/path/foo.so), check to see whether it or one of
1527 its dependencies depends on a shared libgcc.
1531 If the runtime is fixed to look for program headers instead
1532 of calling __register_frame_info at all, for each object,
1533 use the shared libgcc if any EH symbol referenced.
1535 If crtstuff is fixed to not invoke __register_frame_info
1536 automatically, for each object, use the shared libgcc if
1537 any non-empty unwind section found.
1539 Doing any of this probably requires invoking an external program to
1540 do the actual object file scanning. */
1542 const char *p
= libgcc_spec
;
1545 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1546 when given the proper command line arguments. */
1549 if (in_sep
&& *p
== '-' && strncmp (p
, "-lgcc", 5) == 0)
1551 init_gcc_specs (&obstack
,
1553 #ifdef USE_LIBUNWIND_EXCEPTIONS
1559 #ifdef USE_LIBUNWIND_EXCEPTIONS
1560 # ifdef HAVE_LD_STATIC_DYNAMIC
1561 " %{!static:" LD_STATIC_OPTION
"} -lunwind"
1562 " %{!static:" LD_DYNAMIC_OPTION
"}"
1572 else if (in_sep
&& *p
== 'l' && strncmp (p
, "libgcc.a%s", 10) == 0)
1574 /* Ug. We don't know shared library extensions. Hope that
1575 systems that use this form don't do shared libraries. */
1576 init_gcc_specs (&obstack
,
1580 #ifdef USE_LIBUNWIND_EXCEPTIONS
1589 obstack_1grow (&obstack
, *p
);
1590 in_sep
= (*p
== ' ');
1595 obstack_1grow (&obstack
, '\0');
1596 libgcc_spec
= XOBFINISH (&obstack
, const char *);
1599 #ifdef USE_AS_TRADITIONAL_FORMAT
1600 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1602 static const char tf
[] = "--traditional-format ";
1603 obstack_grow (&obstack
, tf
, sizeof (tf
) - 1);
1604 obstack_grow0 (&obstack
, asm_spec
, strlen (asm_spec
));
1605 asm_spec
= XOBFINISH (&obstack
, const char *);
1609 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC || \
1610 defined LINKER_HASH_STYLE
1611 # ifdef LINK_BUILDID_SPEC
1612 /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. */
1613 obstack_grow (&obstack
, LINK_BUILDID_SPEC
, sizeof (LINK_BUILDID_SPEC
) - 1);
1615 # ifdef LINK_EH_SPEC
1616 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1617 obstack_grow (&obstack
, LINK_EH_SPEC
, sizeof (LINK_EH_SPEC
) - 1);
1619 # ifdef LINKER_HASH_STYLE
1620 /* Prepend --hash-style=LINKER_HASH_STYLE to whatever link_spec we had
1623 static const char hash_style
[] = "--hash-style=";
1624 obstack_grow (&obstack
, hash_style
, sizeof (hash_style
) - 1);
1625 obstack_grow (&obstack
, LINKER_HASH_STYLE
, sizeof (LINKER_HASH_STYLE
) - 1);
1626 obstack_1grow (&obstack
, ' ');
1629 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
1630 link_spec
= XOBFINISH (&obstack
, const char *);
1636 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1637 removed; If the spec starts with a + then SPEC is added to the end of the
1641 set_spec (const char *name
, const char *spec
, bool user_p
)
1643 struct spec_list
*sl
;
1644 const char *old_spec
;
1645 int name_len
= strlen (name
);
1648 /* If this is the first call, initialize the statically allocated specs. */
1651 struct spec_list
*next
= (struct spec_list
*) 0;
1652 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1654 sl
= &static_specs
[i
];
1661 /* See if the spec already exists. */
1662 for (sl
= specs
; sl
; sl
= sl
->next
)
1663 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, name
))
1668 /* Not found - make it. */
1669 sl
= XNEW (struct spec_list
);
1670 sl
->name
= xstrdup (name
);
1671 sl
->name_len
= name_len
;
1672 sl
->ptr_spec
= &sl
->ptr
;
1674 *(sl
->ptr_spec
) = "";
1679 old_spec
= *(sl
->ptr_spec
);
1680 *(sl
->ptr_spec
) = ((spec
[0] == '+' && ISSPACE ((unsigned char)spec
[1]))
1681 ? concat (old_spec
, spec
+ 1, NULL
)
1686 fnotice (stderr
, "Setting spec %s to '%s'\n\n", name
, *(sl
->ptr_spec
));
1689 /* Free the old spec. */
1690 if (old_spec
&& sl
->alloc_p
)
1691 free (CONST_CAST (char *, old_spec
));
1693 sl
->user_p
= user_p
;
1697 /* Accumulate a command (program name and args), and run it. */
1699 typedef const char *const_char_p
; /* For DEF_VEC_P. */
1701 /* Vector of pointers to arguments in the current line of specifications. */
1703 static vec
<const_char_p
> argbuf
;
1705 /* Were the options -c, -S or -E passed. */
1706 static int have_c
= 0;
1708 /* Was the option -o passed. */
1709 static int have_o
= 0;
1711 /* Pointer to output file name passed in with -o. */
1712 static const char *output_file
= 0;
1714 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1715 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
1718 static struct temp_name
{
1719 const char *suffix
; /* suffix associated with the code. */
1720 int length
; /* strlen (suffix). */
1721 int unique
; /* Indicates whether %g or %u/%U was used. */
1722 const char *filename
; /* associated filename. */
1723 int filename_length
; /* strlen (filename). */
1724 struct temp_name
*next
;
1727 /* Number of commands executed so far. */
1729 static int execution_count
;
1731 /* Number of commands that exited with a signal. */
1733 static int signal_count
;
1735 /* Allocate the argument vector. */
1743 /* Clear out the vector of arguments (after a command is executed). */
1748 argbuf
.truncate (0);
1751 /* Add one argument to the vector at the end.
1752 This is done when a space is seen or at the end of the line.
1753 If DELETE_ALWAYS is nonzero, the arg is a filename
1754 and the file should be deleted eventually.
1755 If DELETE_FAILURE is nonzero, the arg is a filename
1756 and the file should be deleted if this compilation fails. */
1759 store_arg (const char *arg
, int delete_always
, int delete_failure
)
1761 argbuf
.safe_push (arg
);
1763 if (delete_always
|| delete_failure
)
1766 /* If the temporary file we should delete is specified as
1767 part of a joined argument extract the filename. */
1769 && (p
= strrchr (arg
, '=')))
1771 record_temp_file (arg
, delete_always
, delete_failure
);
1775 /* Load specs from a file name named FILENAME, replacing occurrences of
1776 various different types of line-endings, \r\n, \n\r and just \r, with
1780 load_specs (const char *filename
)
1784 struct stat statbuf
;
1791 fnotice (stderr
, "Reading specs from %s\n", filename
);
1793 /* Open and stat the file. */
1794 desc
= open (filename
, O_RDONLY
, 0);
1796 pfatal_with_name (filename
);
1797 if (stat (filename
, &statbuf
) < 0)
1798 pfatal_with_name (filename
);
1800 /* Read contents of file into BUFFER. */
1801 buffer
= XNEWVEC (char, statbuf
.st_size
+ 1);
1802 readlen
= read (desc
, buffer
, (unsigned) statbuf
.st_size
);
1804 pfatal_with_name (filename
);
1805 buffer
[readlen
] = 0;
1808 specs
= XNEWVEC (char, readlen
+ 1);
1810 for (buffer_p
= buffer
; buffer_p
&& *buffer_p
; buffer_p
++)
1816 if (buffer_p
> buffer
&& *(buffer_p
- 1) == '\n') /* \n\r */
1818 else if (*(buffer_p
+ 1) == '\n') /* \r\n */
1832 /* Read compilation specs from a file named FILENAME,
1833 replacing the default ones.
1835 A suffix which starts with `*' is a definition for
1836 one of the machine-specific sub-specs. The "suffix" should be
1837 *asm, *cc1, *cpp, *link, *startfile, etc.
1838 The corresponding spec is stored in asm_spec, etc.,
1839 rather than in the `compilers' vector.
1841 Anything invalid in the file is a fatal error. */
1844 read_specs (const char *filename
, bool main_p
, bool user_p
)
1849 buffer
= load_specs (filename
);
1851 /* Scan BUFFER for specs, putting them in the vector. */
1857 char *in
, *out
, *p1
, *p2
, *p3
;
1859 /* Advance P in BUFFER to the next nonblank nocomment line. */
1860 p
= skip_whitespace (p
);
1864 /* Is this a special command that starts with '%'? */
1865 /* Don't allow this for the main specs file, since it would
1866 encourage people to overwrite it. */
1867 if (*p
== '%' && !main_p
)
1870 while (*p
&& *p
!= '\n')
1876 if (!strncmp (p1
, "%include", sizeof ("%include") - 1)
1877 && (p1
[sizeof "%include" - 1] == ' '
1878 || p1
[sizeof "%include" - 1] == '\t'))
1882 p1
+= sizeof ("%include");
1883 while (*p1
== ' ' || *p1
== '\t')
1886 if (*p1
++ != '<' || p
[-2] != '>')
1887 fatal_error ("specs %%include syntax malformed after "
1889 (long) (p1
- buffer
+ 1));
1892 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
1893 read_specs (new_filename
? new_filename
: p1
, false, user_p
);
1896 else if (!strncmp (p1
, "%include_noerr", sizeof "%include_noerr" - 1)
1897 && (p1
[sizeof "%include_noerr" - 1] == ' '
1898 || p1
[sizeof "%include_noerr" - 1] == '\t'))
1902 p1
+= sizeof "%include_noerr";
1903 while (*p1
== ' ' || *p1
== '\t')
1906 if (*p1
++ != '<' || p
[-2] != '>')
1907 fatal_error ("specs %%include syntax malformed after "
1909 (long) (p1
- buffer
+ 1));
1912 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
1914 read_specs (new_filename
, false, user_p
);
1915 else if (verbose_flag
)
1916 fnotice (stderr
, "could not find specs file %s\n", p1
);
1919 else if (!strncmp (p1
, "%rename", sizeof "%rename" - 1)
1920 && (p1
[sizeof "%rename" - 1] == ' '
1921 || p1
[sizeof "%rename" - 1] == '\t'))
1924 struct spec_list
*sl
;
1925 struct spec_list
*newsl
;
1927 /* Get original name. */
1928 p1
+= sizeof "%rename";
1929 while (*p1
== ' ' || *p1
== '\t')
1932 if (! ISALPHA ((unsigned char) *p1
))
1933 fatal_error ("specs %%rename syntax malformed after "
1935 (long) (p1
- buffer
));
1938 while (*p2
&& !ISSPACE ((unsigned char) *p2
))
1941 if (*p2
!= ' ' && *p2
!= '\t')
1942 fatal_error ("specs %%rename syntax malformed after "
1944 (long) (p2
- buffer
));
1948 while (*p2
== ' ' || *p2
== '\t')
1951 if (! ISALPHA ((unsigned char) *p2
))
1952 fatal_error ("specs %%rename syntax malformed after "
1954 (long) (p2
- buffer
));
1956 /* Get new spec name. */
1958 while (*p3
&& !ISSPACE ((unsigned char) *p3
))
1962 fatal_error ("specs %%rename syntax malformed after "
1964 (long) (p3
- buffer
));
1967 for (sl
= specs
; sl
; sl
= sl
->next
)
1968 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, p1
))
1972 fatal_error ("specs %s spec was not found to be renamed", p1
);
1974 if (strcmp (p1
, p2
) == 0)
1977 for (newsl
= specs
; newsl
; newsl
= newsl
->next
)
1978 if (strcmp (newsl
->name
, p2
) == 0)
1979 fatal_error ("%s: attempt to rename spec %qs to "
1980 "already defined spec %qs",
1985 fnotice (stderr
, "rename spec %s to %s\n", p1
, p2
);
1987 fnotice (stderr
, "spec is '%s'\n\n", *(sl
->ptr_spec
));
1991 set_spec (p2
, *(sl
->ptr_spec
), user_p
);
1993 free (CONST_CAST (char *, *(sl
->ptr_spec
)));
1995 *(sl
->ptr_spec
) = "";
2000 fatal_error ("specs unknown %% command after %ld characters",
2001 (long) (p1
- buffer
));
2004 /* Find the colon that should end the suffix. */
2006 while (*p1
&& *p1
!= ':' && *p1
!= '\n')
2009 /* The colon shouldn't be missing. */
2011 fatal_error ("specs file malformed after %ld characters",
2012 (long) (p1
- buffer
));
2014 /* Skip back over trailing whitespace. */
2016 while (p2
> buffer
&& (p2
[-1] == ' ' || p2
[-1] == '\t'))
2019 /* Copy the suffix to a string. */
2020 suffix
= save_string (p
, p2
- p
);
2021 /* Find the next line. */
2022 p
= skip_whitespace (p1
+ 1);
2024 fatal_error ("specs file malformed after %ld characters",
2025 (long) (p
- buffer
));
2028 /* Find next blank line or end of string. */
2029 while (*p1
&& !(*p1
== '\n' && (p1
[1] == '\n' || p1
[1] == '\0')))
2032 /* Specs end at the blank line and do not include the newline. */
2033 spec
= save_string (p
, p1
- p
);
2036 /* Delete backslash-newline sequences from the spec. */
2041 if (in
[0] == '\\' && in
[1] == '\n')
2043 else if (in
[0] == '#')
2044 while (*in
&& *in
!= '\n')
2052 if (suffix
[0] == '*')
2054 if (! strcmp (suffix
, "*link_command"))
2055 link_command_spec
= spec
;
2057 set_spec (suffix
+ 1, spec
, user_p
);
2061 /* Add this pair to the vector. */
2063 = XRESIZEVEC (struct compiler
, compilers
, n_compilers
+ 2);
2065 compilers
[n_compilers
].suffix
= suffix
;
2066 compilers
[n_compilers
].spec
= spec
;
2068 memset (&compilers
[n_compilers
], 0, sizeof compilers
[n_compilers
]);
2072 link_command_spec
= spec
;
2075 if (link_command_spec
== 0)
2076 fatal_error ("spec file has no spec for linking");
2079 /* Record the names of temporary files we tell compilers to write,
2080 and delete them at the end of the run. */
2082 /* This is the common prefix we use to make temp file names.
2083 It is chosen once for each run of this program.
2084 It is substituted into a spec by %g or %j.
2085 Thus, all temp file names contain this prefix.
2086 In practice, all temp file names start with this prefix.
2088 This prefix comes from the envvar TMPDIR if it is defined;
2089 otherwise, from the P_tmpdir macro if that is defined;
2090 otherwise, in /usr/tmp or /tmp;
2091 or finally the current directory if all else fails. */
2093 static const char *temp_filename
;
2095 /* Length of the prefix. */
2097 static int temp_filename_length
;
2099 /* Define the list of temporary files to delete. */
2104 struct temp_file
*next
;
2107 /* Queue of files to delete on success or failure of compilation. */
2108 static struct temp_file
*always_delete_queue
;
2109 /* Queue of files to delete on failure of compilation. */
2110 static struct temp_file
*failure_delete_queue
;
2112 /* Record FILENAME as a file to be deleted automatically.
2113 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2114 otherwise delete it in any case.
2115 FAIL_DELETE nonzero means delete it if a compilation step fails;
2116 otherwise delete it in any case. */
2119 record_temp_file (const char *filename
, int always_delete
, int fail_delete
)
2121 char *const name
= xstrdup (filename
);
2125 struct temp_file
*temp
;
2126 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2127 if (! filename_cmp (name
, temp
->name
))
2130 temp
= XNEW (struct temp_file
);
2131 temp
->next
= always_delete_queue
;
2133 always_delete_queue
= temp
;
2140 struct temp_file
*temp
;
2141 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2142 if (! filename_cmp (name
, temp
->name
))
2148 temp
= XNEW (struct temp_file
);
2149 temp
->next
= failure_delete_queue
;
2151 failure_delete_queue
= temp
;
2157 /* Delete all the temporary files whose names we previously recorded. */
2159 #ifndef DELETE_IF_ORDINARY
2160 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2163 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2164 if (unlink (NAME) < 0) \
2166 perror_with_name (NAME); \
2171 delete_if_ordinary (const char *name
)
2177 printf ("Delete %s? (y or n) ", name
);
2181 while ((c
= getchar ()) != '\n' && c
!= EOF
)
2184 if (i
== 'y' || i
== 'Y')
2186 DELETE_IF_ORDINARY (name
, st
, verbose_flag
);
2190 delete_temp_files (void)
2192 struct temp_file
*temp
;
2194 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2195 delete_if_ordinary (temp
->name
);
2196 always_delete_queue
= 0;
2199 /* Delete all the files to be deleted on error. */
2202 delete_failure_queue (void)
2204 struct temp_file
*temp
;
2206 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2207 delete_if_ordinary (temp
->name
);
2211 clear_failure_queue (void)
2213 failure_delete_queue
= 0;
2216 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2218 If DO_MULTI is true iterate over the paths twice, first with multilib
2219 suffix then without, otherwise iterate over the paths once without
2220 adding a multilib suffix. When DO_MULTI is true, some attempt is made
2221 to avoid visiting the same path twice, but we could do better. For
2222 instance, /usr/lib/../lib is considered different from /usr/lib.
2223 At least EXTRA_SPACE chars past the end of the path passed to
2224 CALLBACK are available for use by the callback.
2225 CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2227 Returns the value returned by CALLBACK. */
2230 for_each_path (const struct path_prefix
*paths
,
2233 void *(*callback
) (char *, void *),
2234 void *callback_info
)
2236 struct prefix_list
*pl
;
2237 const char *multi_dir
= NULL
;
2238 const char *multi_os_dir
= NULL
;
2239 const char *multiarch_suffix
= NULL
;
2240 const char *multi_suffix
;
2241 const char *just_multi_suffix
;
2244 bool skip_multi_dir
= false;
2245 bool skip_multi_os_dir
= false;
2247 multi_suffix
= machine_suffix
;
2248 just_multi_suffix
= just_machine_suffix
;
2249 if (do_multi
&& multilib_dir
&& strcmp (multilib_dir
, ".") != 0)
2251 multi_dir
= concat (multilib_dir
, dir_separator_str
, NULL
);
2252 multi_suffix
= concat (multi_suffix
, multi_dir
, NULL
);
2253 just_multi_suffix
= concat (just_multi_suffix
, multi_dir
, NULL
);
2255 if (do_multi
&& multilib_os_dir
&& strcmp (multilib_os_dir
, ".") != 0)
2256 multi_os_dir
= concat (multilib_os_dir
, dir_separator_str
, NULL
);
2258 multiarch_suffix
= concat (multiarch_dir
, dir_separator_str
, NULL
);
2262 size_t multi_dir_len
= 0;
2263 size_t multi_os_dir_len
= 0;
2264 size_t multiarch_len
= 0;
2266 size_t just_suffix_len
;
2270 multi_dir_len
= strlen (multi_dir
);
2272 multi_os_dir_len
= strlen (multi_os_dir
);
2273 if (multiarch_suffix
)
2274 multiarch_len
= strlen (multiarch_suffix
);
2275 suffix_len
= strlen (multi_suffix
);
2276 just_suffix_len
= strlen (just_multi_suffix
);
2280 len
= paths
->max_len
+ extra_space
+ 1;
2281 len
+= MAX (MAX (suffix_len
, multi_os_dir_len
), multiarch_len
);
2282 path
= XNEWVEC (char, len
);
2285 for (pl
= paths
->plist
; pl
!= 0; pl
= pl
->next
)
2287 len
= strlen (pl
->prefix
);
2288 memcpy (path
, pl
->prefix
, len
);
2290 /* Look first in MACHINE/VERSION subdirectory. */
2291 if (!skip_multi_dir
)
2293 memcpy (path
+ len
, multi_suffix
, suffix_len
+ 1);
2294 ret
= callback (path
, callback_info
);
2299 /* Some paths are tried with just the machine (ie. target)
2300 subdir. This is used for finding as, ld, etc. */
2302 && pl
->require_machine_suffix
== 2)
2304 memcpy (path
+ len
, just_multi_suffix
, just_suffix_len
+ 1);
2305 ret
= callback (path
, callback_info
);
2310 /* Now try the multiarch path. */
2312 && !pl
->require_machine_suffix
&& multiarch_dir
)
2314 memcpy (path
+ len
, multiarch_suffix
, multiarch_len
+ 1);
2315 ret
= callback (path
, callback_info
);
2320 /* Now try the base path. */
2321 if (!pl
->require_machine_suffix
2322 && !(pl
->os_multilib
? skip_multi_os_dir
: skip_multi_dir
))
2324 const char *this_multi
;
2325 size_t this_multi_len
;
2327 if (pl
->os_multilib
)
2329 this_multi
= multi_os_dir
;
2330 this_multi_len
= multi_os_dir_len
;
2334 this_multi
= multi_dir
;
2335 this_multi_len
= multi_dir_len
;
2339 memcpy (path
+ len
, this_multi
, this_multi_len
+ 1);
2343 ret
= callback (path
, callback_info
);
2351 if (multi_dir
== NULL
&& multi_os_dir
== NULL
)
2354 /* Run through the paths again, this time without multilibs.
2355 Don't repeat any we have already seen. */
2358 free (CONST_CAST (char *, multi_dir
));
2360 free (CONST_CAST (char *, multi_suffix
));
2361 multi_suffix
= machine_suffix
;
2362 free (CONST_CAST (char *, just_multi_suffix
));
2363 just_multi_suffix
= just_machine_suffix
;
2366 skip_multi_dir
= true;
2369 free (CONST_CAST (char *, multi_os_dir
));
2370 multi_os_dir
= NULL
;
2373 skip_multi_os_dir
= true;
2378 free (CONST_CAST (char *, multi_dir
));
2379 free (CONST_CAST (char *, multi_suffix
));
2380 free (CONST_CAST (char *, just_multi_suffix
));
2383 free (CONST_CAST (char *, multi_os_dir
));
2389 /* Callback for build_search_list. Adds path to obstack being built. */
2391 struct add_to_obstack_info
{
2398 add_to_obstack (char *path
, void *data
)
2400 struct add_to_obstack_info
*info
= (struct add_to_obstack_info
*) data
;
2402 if (info
->check_dir
&& !is_directory (path
, false))
2405 if (!info
->first_time
)
2406 obstack_1grow (info
->ob
, PATH_SEPARATOR
);
2408 obstack_grow (info
->ob
, path
, strlen (path
));
2410 info
->first_time
= false;
2414 /* Add or change the value of an environment variable, outputting the
2415 change to standard error if in verbose mode. */
2417 xputenv (const char *string
)
2420 fnotice (stderr
, "%s\n", string
);
2421 putenv (CONST_CAST (char *, string
));
2424 /* Build a list of search directories from PATHS.
2425 PREFIX is a string to prepend to the list.
2426 If CHECK_DIR_P is true we ensure the directory exists.
2427 If DO_MULTI is true, multilib paths are output first, then
2429 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2430 It is also used by the --print-search-dirs flag. */
2433 build_search_list (const struct path_prefix
*paths
, const char *prefix
,
2434 bool check_dir
, bool do_multi
)
2436 struct add_to_obstack_info info
;
2438 info
.ob
= &collect_obstack
;
2439 info
.check_dir
= check_dir
;
2440 info
.first_time
= true;
2442 obstack_grow (&collect_obstack
, prefix
, strlen (prefix
));
2443 obstack_1grow (&collect_obstack
, '=');
2445 for_each_path (paths
, do_multi
, 0, add_to_obstack
, &info
);
2447 obstack_1grow (&collect_obstack
, '\0');
2448 return XOBFINISH (&collect_obstack
, char *);
2451 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2455 putenv_from_prefixes (const struct path_prefix
*paths
, const char *env_var
,
2458 xputenv (build_search_list (paths
, env_var
, true, do_multi
));
2461 /* Check whether NAME can be accessed in MODE. This is like access,
2462 except that it never considers directories to be executable. */
2465 access_check (const char *name
, int mode
)
2471 if (stat (name
, &st
) < 0
2472 || S_ISDIR (st
.st_mode
))
2476 return access (name
, mode
);
2479 /* Callback for find_a_file. Appends the file name to the directory
2480 path. If the resulting file exists in the right mode, return the
2481 full pathname to the file. */
2483 struct file_at_path_info
{
2492 file_at_path (char *path
, void *data
)
2494 struct file_at_path_info
*info
= (struct file_at_path_info
*) data
;
2495 size_t len
= strlen (path
);
2497 memcpy (path
+ len
, info
->name
, info
->name_len
);
2498 len
+= info
->name_len
;
2500 /* Some systems have a suffix for executable files.
2501 So try appending that first. */
2502 if (info
->suffix_len
)
2504 memcpy (path
+ len
, info
->suffix
, info
->suffix_len
+ 1);
2505 if (access_check (path
, info
->mode
) == 0)
2510 if (access_check (path
, info
->mode
) == 0)
2516 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2517 access to check permissions. If DO_MULTI is true, search multilib
2518 paths then non-multilib paths, otherwise do not search multilib paths.
2519 Return 0 if not found, otherwise return its name, allocated with malloc. */
2522 find_a_file (const struct path_prefix
*pprefix
, const char *name
, int mode
,
2525 struct file_at_path_info info
;
2527 #ifdef DEFAULT_ASSEMBLER
2528 if (! strcmp (name
, "as") && access (DEFAULT_ASSEMBLER
, mode
) == 0)
2529 return xstrdup (DEFAULT_ASSEMBLER
);
2532 #ifdef DEFAULT_LINKER
2533 if (! strcmp (name
, "ld") && access (DEFAULT_LINKER
, mode
) == 0)
2534 return xstrdup (DEFAULT_LINKER
);
2537 /* Determine the filename to execute (special case for absolute paths). */
2539 if (IS_ABSOLUTE_PATH (name
))
2541 if (access (name
, mode
) == 0)
2542 return xstrdup (name
);
2548 info
.suffix
= (mode
& X_OK
) != 0 ? HOST_EXECUTABLE_SUFFIX
: "";
2549 info
.name_len
= strlen (info
.name
);
2550 info
.suffix_len
= strlen (info
.suffix
);
2553 return (char*) for_each_path (pprefix
, do_multi
,
2554 info
.name_len
+ info
.suffix_len
,
2555 file_at_path
, &info
);
2558 /* Ranking of prefixes in the sort list. -B prefixes are put before
2561 enum path_prefix_priority
2563 PREFIX_PRIORITY_B_OPT
,
2564 PREFIX_PRIORITY_LAST
2567 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
2568 order according to PRIORITY. Within each PRIORITY, new entries are
2571 If WARN is nonzero, we will warn if no file is found
2572 through this prefix. WARN should point to an int
2573 which will be set to 1 if this entry is used.
2575 COMPONENT is the value to be passed to update_path.
2577 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2578 the complete value of machine_suffix.
2579 2 means try both machine_suffix and just_machine_suffix. */
2582 add_prefix (struct path_prefix
*pprefix
, const char *prefix
,
2583 const char *component
, /* enum prefix_priority */ int priority
,
2584 int require_machine_suffix
, int os_multilib
)
2586 struct prefix_list
*pl
, **prev
;
2589 for (prev
= &pprefix
->plist
;
2590 (*prev
) != NULL
&& (*prev
)->priority
<= priority
;
2591 prev
= &(*prev
)->next
)
2594 /* Keep track of the longest prefix. */
2596 prefix
= update_path (prefix
, component
);
2597 len
= strlen (prefix
);
2598 if (len
> pprefix
->max_len
)
2599 pprefix
->max_len
= len
;
2601 pl
= XNEW (struct prefix_list
);
2602 pl
->prefix
= prefix
;
2603 pl
->require_machine_suffix
= require_machine_suffix
;
2604 pl
->priority
= priority
;
2605 pl
->os_multilib
= os_multilib
;
2607 /* Insert after PREV. */
2612 /* Same as add_prefix, but prepending target_system_root to prefix. */
2613 /* The target_system_root prefix has been relocated by gcc_exec_prefix. */
2615 add_sysrooted_prefix (struct path_prefix
*pprefix
, const char *prefix
,
2616 const char *component
,
2617 /* enum prefix_priority */ int priority
,
2618 int require_machine_suffix
, int os_multilib
)
2620 if (!IS_ABSOLUTE_PATH (prefix
))
2621 fatal_error ("system path %qs is not absolute", prefix
);
2623 if (target_system_root
)
2625 char *sysroot_no_trailing_dir_separator
= xstrdup (target_system_root
);
2626 size_t sysroot_len
= strlen (target_system_root
);
2629 && target_system_root
[sysroot_len
- 1] == DIR_SEPARATOR
)
2630 sysroot_no_trailing_dir_separator
[sysroot_len
- 1] = '\0';
2632 if (target_sysroot_suffix
)
2633 prefix
= concat (sysroot_no_trailing_dir_separator
,
2634 target_sysroot_suffix
, prefix
, NULL
);
2636 prefix
= concat (sysroot_no_trailing_dir_separator
, prefix
, NULL
);
2638 free (sysroot_no_trailing_dir_separator
);
2640 /* We have to override this because GCC's notion of sysroot
2641 moves along with GCC. */
2645 add_prefix (pprefix
, prefix
, component
, priority
,
2646 require_machine_suffix
, os_multilib
);
2649 /* Execute the command specified by the arguments on the current line of spec.
2650 When using pipes, this includes several piped-together commands
2651 with `|' between them.
2653 Return 0 if successful, -1 if failed. */
2659 int n_commands
; /* # of command. */
2661 struct pex_obj
*pex
;
2664 const char *prog
; /* program name. */
2665 const char **argv
; /* vector of args. */
2669 struct command
*commands
; /* each command buffer with above info. */
2671 gcc_assert (!processing_spec_function
);
2675 string
= find_a_file (&exec_prefixes
,
2676 argbuf
[0], X_OK
, false);
2679 insert_wrapper (wrapper_string
);
2682 /* Count # of piped commands. */
2683 for (n_commands
= 1, i
= 0; argbuf
.iterate (i
, &arg
); i
++)
2684 if (strcmp (arg
, "|") == 0)
2687 /* Get storage for each command. */
2688 commands
= (struct command
*) alloca (n_commands
* sizeof (struct command
));
2690 /* Split argbuf into its separate piped processes,
2691 and record info about each one.
2692 Also search for the programs that are to be run. */
2694 argbuf
.safe_push (0);
2696 commands
[0].prog
= argbuf
[0]; /* first command. */
2697 commands
[0].argv
= argbuf
.address ();
2699 if (!wrapper_string
)
2701 string
= find_a_file (&exec_prefixes
, commands
[0].prog
, X_OK
, false);
2702 commands
[0].argv
[0] = (string
) ? string
: commands
[0].argv
[0];
2705 for (n_commands
= 1, i
= 0; argbuf
.iterate (i
, &arg
); i
++)
2706 if (arg
&& strcmp (arg
, "|") == 0)
2707 { /* each command. */
2708 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2709 fatal_error ("-pipe not supported");
2711 argbuf
[i
] = 0; /* Termination of
2713 commands
[n_commands
].prog
= argbuf
[i
+ 1];
2714 commands
[n_commands
].argv
2715 = &(argbuf
.address ())[i
+ 1];
2716 string
= find_a_file (&exec_prefixes
, commands
[n_commands
].prog
,
2719 commands
[n_commands
].argv
[0] = string
;
2723 /* If -v, print what we are about to do, and maybe query. */
2727 /* For help listings, put a blank line between sub-processes. */
2728 if (print_help_list
)
2729 fputc ('\n', stderr
);
2731 /* Print each piped command as a separate line. */
2732 for (i
= 0; i
< n_commands
; i
++)
2734 const char *const *j
;
2736 if (verbose_only_flag
)
2738 for (j
= commands
[i
].argv
; *j
; j
++)
2741 for (p
= *j
; *p
; ++p
)
2742 if (!ISALNUM ((unsigned char) *p
)
2743 && *p
!= '_' && *p
!= '/' && *p
!= '-' && *p
!= '.')
2747 fprintf (stderr
, " \"");
2748 for (p
= *j
; *p
; ++p
)
2750 if (*p
== '"' || *p
== '\\' || *p
== '$')
2751 fputc ('\\', stderr
);
2754 fputc ('"', stderr
);
2756 /* If it's empty, print "". */
2758 fprintf (stderr
, " \"\"");
2760 fprintf (stderr
, " %s", *j
);
2764 for (j
= commands
[i
].argv
; *j
; j
++)
2765 /* If it's empty, print "". */
2767 fprintf (stderr
, " \"\"");
2769 fprintf (stderr
, " %s", *j
);
2771 /* Print a pipe symbol after all but the last command. */
2772 if (i
+ 1 != n_commands
)
2773 fprintf (stderr
, " |");
2774 fprintf (stderr
, "\n");
2777 if (verbose_only_flag
!= 0)
2779 /* verbose_only_flag should act as if the spec was
2780 executed, so increment execution_count before
2781 returning. This prevents spurious warnings about
2782 unused linker input files, etc. */
2787 fnotice (stderr
, "\nGo ahead? (y or n) ");
2791 while (getchar () != '\n')
2794 if (i
!= 'y' && i
!= 'Y')
2799 #ifdef ENABLE_VALGRIND_CHECKING
2800 /* Run the each command through valgrind. To simplify prepending the
2801 path to valgrind and the option "-q" (for quiet operation unless
2802 something triggers), we allocate a separate argv array. */
2804 for (i
= 0; i
< n_commands
; i
++)
2810 for (argc
= 0; commands
[i
].argv
[argc
] != NULL
; argc
++)
2813 argv
= XALLOCAVEC (const char *, argc
+ 3);
2815 argv
[0] = VALGRIND_PATH
;
2817 for (j
= 2; j
< argc
+ 2; j
++)
2818 argv
[j
] = commands
[i
].argv
[j
- 2];
2821 commands
[i
].argv
= argv
;
2822 commands
[i
].prog
= argv
[0];
2826 /* Run each piped subprocess. */
2828 pex
= pex_init (PEX_USE_PIPES
| ((report_times
|| report_times_to_file
)
2829 ? PEX_RECORD_TIMES
: 0),
2830 progname
, temp_filename
);
2832 fatal_error ("pex_init failed: %m");
2834 for (i
= 0; i
< n_commands
; i
++)
2838 const char *string
= commands
[i
].argv
[0];
2840 errmsg
= pex_run (pex
,
2841 ((i
+ 1 == n_commands
? PEX_LAST
: 0)
2842 | (string
== commands
[i
].prog
? PEX_SEARCH
: 0)),
2843 string
, CONST_CAST (char **, commands
[i
].argv
),
2848 fatal_error (errmsg
);
2852 pfatal_with_name (errmsg
);
2856 if (i
&& string
!= commands
[i
].prog
)
2857 free (CONST_CAST (char *, string
));
2862 /* Wait for all the subprocesses to finish. */
2866 struct pex_time
*times
= NULL
;
2869 statuses
= (int *) alloca (n_commands
* sizeof (int));
2870 if (!pex_get_status (pex
, n_commands
, statuses
))
2871 fatal_error ("failed to get exit status: %m");
2873 if (report_times
|| report_times_to_file
)
2875 times
= (struct pex_time
*) alloca (n_commands
* sizeof (struct pex_time
));
2876 if (!pex_get_times (pex
, n_commands
, times
))
2877 fatal_error ("failed to get process times: %m");
2882 for (i
= 0; i
< n_commands
; ++i
)
2884 int status
= statuses
[i
];
2886 if (WIFSIGNALED (status
))
2889 /* SIGPIPE is a special case. It happens in -pipe mode
2890 when the compiler dies before the preprocessor is done,
2891 or the assembler dies before the compiler is done.
2892 There's generally been an error already, and this is
2893 just fallout. So don't generate another error unless
2894 we would otherwise have succeeded. */
2895 if (WTERMSIG (status
) == SIGPIPE
2896 && (signal_count
|| greatest_status
>= MIN_FATAL_STATUS
))
2903 internal_error ("%s (program %s)",
2904 strsignal (WTERMSIG (status
)), commands
[i
].prog
);
2906 else if (WIFEXITED (status
)
2907 && WEXITSTATUS (status
) >= MIN_FATAL_STATUS
)
2909 /* For ICEs in cc1, cc1obj, cc1plus see if it is
2910 reproducible or not. */
2913 && WEXITSTATUS (status
) == ICE_EXIT_CODE
2915 && (p
= strrchr (commands
[0].argv
[0], DIR_SEPARATOR
))
2916 && ! strncmp (p
+ 1, "cc1", 3))
2917 try_generate_repro (commands
[0].argv
);
2918 if (WEXITSTATUS (status
) > greatest_status
)
2919 greatest_status
= WEXITSTATUS (status
);
2923 if (report_times
|| report_times_to_file
)
2925 struct pex_time
*pt
= ×
[i
];
2928 ut
= ((double) pt
->user_seconds
2929 + (double) pt
->user_microseconds
/ 1.0e6
);
2930 st
= ((double) pt
->system_seconds
2931 + (double) pt
->system_microseconds
/ 1.0e6
);
2936 fnotice (stderr
, "# %s %.2f %.2f\n",
2937 commands
[i
].prog
, ut
, st
);
2939 if (report_times_to_file
)
2942 const char *const *j
;
2944 fprintf (report_times_to_file
, "%g %g", ut
, st
);
2946 for (j
= &commands
[i
].prog
; *j
; j
= &commands
[i
].argv
[++c
])
2949 for (p
= *j
; *p
; ++p
)
2950 if (*p
== '"' || *p
== '\\' || *p
== '$'
2956 fprintf (report_times_to_file
, " \"");
2957 for (p
= *j
; *p
; ++p
)
2959 if (*p
== '"' || *p
== '\\' || *p
== '$')
2960 fputc ('\\', report_times_to_file
);
2961 fputc (*p
, report_times_to_file
);
2963 fputc ('"', report_times_to_file
);
2966 fprintf (report_times_to_file
, " %s", *j
);
2969 fputc ('\n', report_times_to_file
);
2975 if (commands
[0].argv
[0] != commands
[0].prog
)
2976 free (CONST_CAST (char *, commands
[0].argv
[0]));
2982 /* Find all the switches given to us
2983 and make a vector describing them.
2984 The elements of the vector are strings, one per switch given.
2985 If a switch uses following arguments, then the `part1' field
2986 is the switch itself and the `args' field
2987 is a null-terminated vector containing the following arguments.
2988 Bits in the `live_cond' field are:
2989 SWITCH_LIVE to indicate this switch is true in a conditional spec.
2990 SWITCH_FALSE to indicate this switch is overridden by a later switch.
2991 SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
2992 SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored
2993 in all do_spec calls afterwards. Used for %<S from self specs.
2994 The `validated' field is nonzero if any spec has looked at this switch;
2995 if it remains zero at the end of the run, it must be meaningless. */
2997 #define SWITCH_LIVE (1 << 0)
2998 #define SWITCH_FALSE (1 << 1)
2999 #define SWITCH_IGNORE (1 << 2)
3000 #define SWITCH_IGNORE_PERMANENTLY (1 << 3)
3001 #define SWITCH_KEEP_FOR_GCC (1 << 4)
3007 unsigned int live_cond
;
3013 static struct switchstr
*switches
;
3015 static int n_switches
;
3017 static int n_switches_alloc
;
3019 /* Set to zero if -fcompare-debug is disabled, positive if it's
3020 enabled and we're running the first compilation, negative if it's
3021 enabled and we're running the second compilation. For most of the
3022 time, it's in the range -1..1, but it can be temporarily set to 2
3023 or 3 to indicate that the -fcompare-debug flags didn't come from
3024 the command-line, but rather from the GCC_COMPARE_DEBUG environment
3025 variable, until a synthesized -fcompare-debug flag is added to the
3029 /* Set to nonzero if we've seen the -fcompare-debug-second flag. */
3030 int compare_debug_second
;
3032 /* Set to the flags that should be passed to the second compilation in
3033 a -fcompare-debug compilation. */
3034 const char *compare_debug_opt
;
3036 static struct switchstr
*switches_debug_check
[2];
3038 static int n_switches_debug_check
[2];
3040 static int n_switches_alloc_debug_check
[2];
3042 static char *debug_check_temp_file
[2];
3044 /* Language is one of three things:
3046 1) The name of a real programming language.
3047 2) NULL, indicating that no one has figured out
3049 3) '*', indicating that the file should be passed
3054 const char *language
;
3055 struct compiler
*incompiler
;
3060 /* Also a vector of input files specified. */
3062 static struct infile
*infiles
;
3066 static int n_infiles_alloc
;
3068 /* True if multiple input files are being compiled to a single
3071 static bool combine_inputs
;
3073 /* This counts the number of libraries added by lang_specific_driver, so that
3074 we can tell if there were any user supplied any files or libraries. */
3076 static int added_libraries
;
3078 /* And a vector of corresponding output files is made up later. */
3080 const char **outfiles
;
3082 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3084 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
3085 is true if we should look for an executable suffix. DO_OBJ
3086 is true if we should look for an object suffix. */
3089 convert_filename (const char *name
, int do_exe ATTRIBUTE_UNUSED
,
3090 int do_obj ATTRIBUTE_UNUSED
)
3092 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3100 len
= strlen (name
);
3102 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3103 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
3104 if (do_obj
&& len
> 2
3105 && name
[len
- 2] == '.'
3106 && name
[len
- 1] == 'o')
3108 obstack_grow (&obstack
, name
, len
- 2);
3109 obstack_grow0 (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
3110 name
= XOBFINISH (&obstack
, const char *);
3114 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3115 /* If there is no filetype, make it the executable suffix (which includes
3116 the "."). But don't get confused if we have just "-o". */
3117 if (! do_exe
|| TARGET_EXECUTABLE_SUFFIX
[0] == 0 || (len
== 2 && name
[0] == '-'))
3120 for (i
= len
- 1; i
>= 0; i
--)
3121 if (IS_DIR_SEPARATOR (name
[i
]))
3124 for (i
++; i
< len
; i
++)
3128 obstack_grow (&obstack
, name
, len
);
3129 obstack_grow0 (&obstack
, TARGET_EXECUTABLE_SUFFIX
,
3130 strlen (TARGET_EXECUTABLE_SUFFIX
));
3131 name
= XOBFINISH (&obstack
, const char *);
3138 /* Display the command line switches accepted by gcc. */
3142 printf (_("Usage: %s [options] file...\n"), progname
);
3143 fputs (_("Options:\n"), stdout
);
3145 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout
);
3146 fputs (_(" --help Display this information\n"), stdout
);
3147 fputs (_(" --target-help Display target specific command line options\n"), stdout
);
3148 fputs (_(" --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...]\n"), stdout
);
3149 fputs (_(" Display specific types of command line options\n"), stdout
);
3151 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout
);
3152 fputs (_(" --version Display compiler version information\n"), stdout
);
3153 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout
);
3154 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout
);
3155 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout
);
3156 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout
);
3157 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout
);
3158 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout
);
3159 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout
);
3161 -print-multiarch Display the target's normalized GNU triplet, used as\n\
3162 a component in the library path\n"), stdout
);
3163 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout
);
3165 -print-multi-lib Display the mapping between command line options and\n\
3166 multiple library search directories\n"), stdout
);
3167 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries\n"), stdout
);
3168 fputs (_(" -print-sysroot Display the target libraries directory\n"), stdout
);
3169 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n"), stdout
);
3170 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout
);
3171 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout
);
3172 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout
);
3173 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler\n"), stdout
);
3174 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n"), stdout
);
3175 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout
);
3176 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout
);
3177 fputs (_(" -save-temps=<arg> Do not delete intermediate files\n"), stdout
);
3179 -no-canonical-prefixes Do not canonicalize paths when building relative\n\
3180 prefixes to other gcc components\n"), stdout
);
3181 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout
);
3182 fputs (_(" -time Time the execution of each subprocess\n"), stdout
);
3183 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout
);
3184 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout
);
3186 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3187 and libraries\n"), stdout
);
3188 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout
);
3189 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout
);
3190 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout
);
3191 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout
);
3192 fputs (_(" -S Compile only; do not assemble or link\n"), stdout
);
3193 fputs (_(" -c Compile and assemble, but do not link\n"), stdout
);
3194 fputs (_(" -o <file> Place the output into <file>\n"), stdout
);
3195 fputs (_(" -pie Create a position independent executable\n"), stdout
);
3196 fputs (_(" -shared Create a shared library\n"), stdout
);
3198 -x <language> Specify the language of the following input files\n\
3199 Permissible languages include: c c++ assembler none\n\
3200 'none' means revert to the default behavior of\n\
3201 guessing the language based on the file's extension\n\
3205 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3206 passed on to the various sub-processes invoked by %s. In order to pass\n\
3207 other options on to these processes the -W<letter> options must be used.\n\
3210 /* The rest of the options are displayed by invocations of the various
3215 add_preprocessor_option (const char *option
, int len
)
3217 preprocessor_options
.safe_push (save_string (option
, len
));
3221 add_assembler_option (const char *option
, int len
)
3223 assembler_options
.safe_push (save_string (option
, len
));
3227 add_linker_option (const char *option
, int len
)
3229 linker_options
.safe_push (save_string (option
, len
));
3232 /* Allocate space for an input file in infiles. */
3237 if (n_infiles_alloc
== 0)
3239 n_infiles_alloc
= 16;
3240 infiles
= XNEWVEC (struct infile
, n_infiles_alloc
);
3242 else if (n_infiles_alloc
== n_infiles
)
3244 n_infiles_alloc
*= 2;
3245 infiles
= XRESIZEVEC (struct infile
, infiles
, n_infiles_alloc
);
3249 /* Store an input file with the given NAME and LANGUAGE in
3253 add_infile (const char *name
, const char *language
)
3256 infiles
[n_infiles
].name
= name
;
3257 infiles
[n_infiles
++].language
= language
;
3260 /* Allocate space for a switch in switches. */
3265 if (n_switches_alloc
== 0)
3267 n_switches_alloc
= 16;
3268 switches
= XNEWVEC (struct switchstr
, n_switches_alloc
);
3270 else if (n_switches_alloc
== n_switches
)
3272 n_switches_alloc
*= 2;
3273 switches
= XRESIZEVEC (struct switchstr
, switches
, n_switches_alloc
);
3277 /* Save an option OPT with N_ARGS arguments in array ARGS, marking it
3278 as validated if VALIDATED and KNOWN if it is an internal switch. */
3281 save_switch (const char *opt
, size_t n_args
, const char *const *args
,
3282 bool validated
, bool known
)
3285 switches
[n_switches
].part1
= opt
+ 1;
3287 switches
[n_switches
].args
= 0;
3290 switches
[n_switches
].args
= XNEWVEC (const char *, n_args
+ 1);
3291 memcpy (switches
[n_switches
].args
, args
, n_args
* sizeof (const char *));
3292 switches
[n_switches
].args
[n_args
] = NULL
;
3295 switches
[n_switches
].live_cond
= 0;
3296 switches
[n_switches
].validated
= validated
;
3297 switches
[n_switches
].known
= known
;
3298 switches
[n_switches
].ordering
= 0;
3302 /* Handle an option DECODED that is unknown to the option-processing
3306 driver_unknown_option_callback (const struct cl_decoded_option
*decoded
)
3308 const char *opt
= decoded
->arg
;
3309 if (opt
[1] == 'W' && opt
[2] == 'n' && opt
[3] == 'o' && opt
[4] == '-'
3310 && !(decoded
->errors
& CL_ERR_NEGATIVE
))
3312 /* Leave unknown -Wno-* options for the compiler proper, to be
3313 diagnosed only if there are warnings. */
3314 save_switch (decoded
->canonical_option
[0],
3315 decoded
->canonical_option_num_elements
- 1,
3316 &decoded
->canonical_option
[1], false, true);
3319 if (decoded
->opt_index
== OPT_SPECIAL_unknown
)
3321 /* Give it a chance to define it a a spec file. */
3322 save_switch (decoded
->canonical_option
[0],
3323 decoded
->canonical_option_num_elements
- 1,
3324 &decoded
->canonical_option
[1], false, false);
3331 /* Handle an option DECODED that is not marked as CL_DRIVER.
3332 LANG_MASK will always be CL_DRIVER. */
3335 driver_wrong_lang_callback (const struct cl_decoded_option
*decoded
,
3336 unsigned int lang_mask ATTRIBUTE_UNUSED
)
3338 /* At this point, non-driver options are accepted (and expected to
3339 be passed down by specs) unless marked to be rejected by the
3340 driver. Options to be rejected by the driver but accepted by the
3341 compilers proper are treated just like completely unknown
3343 const struct cl_option
*option
= &cl_options
[decoded
->opt_index
];
3345 if (option
->cl_reject_driver
)
3346 error ("unrecognized command line option %qs",
3347 decoded
->orig_option_with_args_text
);
3349 save_switch (decoded
->canonical_option
[0],
3350 decoded
->canonical_option_num_elements
- 1,
3351 &decoded
->canonical_option
[1], false, true);
3354 static const char *spec_lang
= 0;
3355 static int last_language_n_infiles
;
3357 /* Handle a driver option; arguments and return value as for
3361 driver_handle_option (struct gcc_options
*opts
,
3362 struct gcc_options
*opts_set
,
3363 const struct cl_decoded_option
*decoded
,
3364 unsigned int lang_mask ATTRIBUTE_UNUSED
, int kind
,
3366 const struct cl_option_handlers
*handlers ATTRIBUTE_UNUSED
,
3367 diagnostic_context
*dc
)
3369 size_t opt_index
= decoded
->opt_index
;
3370 const char *arg
= decoded
->arg
;
3371 const char *compare_debug_replacement_opt
;
3372 int value
= decoded
->value
;
3373 bool validated
= false;
3374 bool do_save
= true;
3376 gcc_assert (opts
== &global_options
);
3377 gcc_assert (opts_set
== &global_options_set
);
3378 gcc_assert (kind
== DK_UNSPECIFIED
);
3379 gcc_assert (loc
== UNKNOWN_LOCATION
);
3380 gcc_assert (dc
== global_dc
);
3386 struct spec_list
*sl
;
3388 for (sl
= specs
; sl
; sl
= sl
->next
)
3389 printf ("*%s:\n%s\n\n", sl
->name
, *(sl
->ptr_spec
));
3390 if (link_command_spec
)
3391 printf ("*link_command:\n%s\n\n", link_command_spec
);
3395 case OPT_dumpversion
:
3396 printf ("%s\n", spec_version
);
3399 case OPT_dumpmachine
:
3400 printf ("%s\n", spec_machine
);
3406 /* CPP driver cannot obtain switch from cc1_options. */
3408 add_preprocessor_option ("--version", strlen ("--version"));
3409 add_assembler_option ("--version", strlen ("--version"));
3410 add_linker_option ("--version", strlen ("--version"));
3414 print_help_list
= 1;
3416 /* CPP driver cannot obtain switch from cc1_options. */
3418 add_preprocessor_option ("--help", 6);
3419 add_assembler_option ("--help", 6);
3420 add_linker_option ("--help", 6);
3424 print_subprocess_help
= 2;
3427 case OPT__target_help
:
3428 print_subprocess_help
= 1;
3430 /* CPP driver cannot obtain switch from cc1_options. */
3432 add_preprocessor_option ("--target-help", 13);
3433 add_assembler_option ("--target-help", 13);
3434 add_linker_option ("--target-help", 13);
3437 case OPT__no_sysroot_suffix
:
3438 case OPT_pass_exit_codes
:
3439 case OPT_print_search_dirs
:
3440 case OPT_print_file_name_
:
3441 case OPT_print_prog_name_
:
3442 case OPT_print_multi_lib
:
3443 case OPT_print_multi_directory
:
3444 case OPT_print_sysroot
:
3445 case OPT_print_multi_os_directory
:
3446 case OPT_print_multiarch
:
3447 case OPT_print_sysroot_headers_suffix
:
3450 /* These options set the variables specified in common.opt
3451 automatically, and do not need to be saved for spec
3456 case OPT_print_libgcc_file_name
:
3457 print_file_name
= "libgcc.a";
3461 case OPT_fuse_ld_bfd
:
3465 case OPT_fuse_ld_gold
:
3469 case OPT_fcompare_debug_second
:
3470 compare_debug_second
= 1;
3473 case OPT_fcompare_debug
:
3477 compare_debug_replacement_opt
= "-fcompare-debug=";
3479 goto compare_debug_with_arg
;
3482 compare_debug_replacement_opt
= "-fcompare-debug=-gtoggle";
3484 goto compare_debug_with_arg
;
3491 case OPT_fcompare_debug_
:
3492 compare_debug_replacement_opt
= decoded
->canonical_option
[0];
3493 compare_debug_with_arg
:
3494 gcc_assert (decoded
->canonical_option_num_elements
== 1);
3495 gcc_assert (arg
!= NULL
);
3500 if (compare_debug
< 0)
3501 compare_debug_opt
= NULL
;
3503 compare_debug_opt
= arg
;
3504 save_switch (compare_debug_replacement_opt
, 0, NULL
, validated
, true);
3510 /* Pass the rest of this option to the assembler. */
3512 /* Split the argument at commas. */
3514 for (j
= 0; arg
[j
]; j
++)
3517 add_assembler_option (arg
+ prev
, j
- prev
);
3521 /* Record the part after the last comma. */
3522 add_assembler_option (arg
+ prev
, j
- prev
);
3530 /* Pass the rest of this option to the preprocessor. */
3532 /* Split the argument at commas. */
3534 for (j
= 0; arg
[j
]; j
++)
3537 add_preprocessor_option (arg
+ prev
, j
- prev
);
3541 /* Record the part after the last comma. */
3542 add_preprocessor_option (arg
+ prev
, j
- prev
);
3550 /* Split the argument at commas. */
3552 for (j
= 0; arg
[j
]; j
++)
3555 add_infile (save_string (arg
+ prev
, j
- prev
), "*");
3558 /* Record the part after the last comma. */
3559 add_infile (arg
+ prev
, "*");
3565 add_infile (arg
, "*");
3569 case OPT_Xpreprocessor
:
3570 add_preprocessor_option (arg
, strlen (arg
));
3574 case OPT_Xassembler
:
3575 add_assembler_option (arg
, strlen (arg
));
3580 /* POSIX allows separation of -l and the lib arg; canonicalize
3581 by concatenating -l with its arg */
3582 add_infile (concat ("-l", arg
, NULL
), "*");
3587 /* Similarly, canonicalize -L for linkers that may not accept
3588 separate arguments. */
3589 save_switch (concat ("-L", arg
, NULL
), 0, NULL
, validated
, true);
3594 save_switch (concat ("-F", arg
, NULL
), 0, NULL
, validated
, true);
3597 case OPT_save_temps
:
3598 save_temps_flag
= SAVE_TEMPS_CWD
;
3602 case OPT_save_temps_
:
3603 if (strcmp (arg
, "cwd") == 0)
3604 save_temps_flag
= SAVE_TEMPS_CWD
;
3605 else if (strcmp (arg
, "obj") == 0
3606 || strcmp (arg
, "object") == 0)
3607 save_temps_flag
= SAVE_TEMPS_OBJ
;
3609 fatal_error ("%qs is an unknown -save-temps option",
3610 decoded
->orig_option_with_args_text
);
3613 case OPT_no_canonical_prefixes
:
3614 /* Already handled as a special case, so ignored here. */
3620 /* These options set the variables specified in common.opt
3621 automatically, but do need to be saved for spec
3627 struct user_specs
*user
= XNEW (struct user_specs
);
3629 user
->next
= (struct user_specs
*) 0;
3630 user
->filename
= arg
;
3631 if (user_specs_tail
)
3632 user_specs_tail
->next
= user
;
3634 user_specs_head
= user
;
3635 user_specs_tail
= user
;
3641 target_system_root
= arg
;
3642 target_system_root_changed
= 1;
3647 if (report_times_to_file
)
3648 fclose (report_times_to_file
);
3649 report_times_to_file
= fopen (arg
, "a");
3655 This is similar to -v except that there is no execution
3656 of the commands and the echoed arguments are quoted. It
3657 is intended for use in shell scripts to capture the
3658 driver-generated command line. */
3659 verbose_only_flag
++;
3666 size_t len
= strlen (arg
);
3668 /* Catch the case where the user has forgotten to append a
3669 directory separator to the path. Note, they may be using
3670 -B to add an executable name prefix, eg "i386-elf-", in
3671 order to distinguish between multiple installations of
3672 GCC in the same directory. Hence we must check to see
3673 if appending a directory separator actually makes a
3674 valid directory name. */
3675 if (!IS_DIR_SEPARATOR (arg
[len
- 1])
3676 && is_directory (arg
, false))
3678 char *tmp
= XNEWVEC (char, len
+ 2);
3680 tmp
[len
] = DIR_SEPARATOR
;
3685 add_prefix (&exec_prefixes
, arg
, NULL
,
3686 PREFIX_PRIORITY_B_OPT
, 0, 0);
3687 add_prefix (&startfile_prefixes
, arg
, NULL
,
3688 PREFIX_PRIORITY_B_OPT
, 0, 0);
3689 add_prefix (&include_prefixes
, arg
, NULL
,
3690 PREFIX_PRIORITY_B_OPT
, 0, 0);
3697 if (!strcmp (spec_lang
, "none"))
3698 /* Suppress the warning if -xnone comes after the last input
3699 file, because alternate command interfaces like g++ might
3700 find it useful to place -xnone after each input file. */
3703 last_language_n_infiles
= n_infiles
;
3709 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3710 arg
= convert_filename (arg
, ! have_c
, 0);
3713 /* Save the output name in case -save-temps=obj was used. */
3714 save_temps_prefix
= xstrdup (arg
);
3715 /* On some systems, ld cannot handle "-o" without a space. So
3716 split the option from its argument. */
3717 save_switch ("-o", 1, &arg
, validated
, true);
3720 case OPT_static_libgcc
:
3721 case OPT_shared_libgcc
:
3722 case OPT_static_libgfortran
:
3723 case OPT_static_libstdc__
:
3724 /* These are always valid, since gcc.c itself understands the
3725 first two, gfortranspec.c understands -static-libgfortran and
3726 g++spec.c understands -static-libstdc++ */
3735 /* Various driver options need no special processing at this
3736 point, having been handled in a prescan above or being
3737 handled by specs. */
3742 save_switch (decoded
->canonical_option
[0],
3743 decoded
->canonical_option_num_elements
- 1,
3744 &decoded
->canonical_option
[1], validated
, true);
3748 /* Put the driver's standard set of option handlers in *HANDLERS. */
3751 set_option_handlers (struct cl_option_handlers
*handlers
)
3753 handlers
->unknown_option_callback
= driver_unknown_option_callback
;
3754 handlers
->wrong_lang_callback
= driver_wrong_lang_callback
;
3755 handlers
->num_handlers
= 3;
3756 handlers
->handlers
[0].handler
= driver_handle_option
;
3757 handlers
->handlers
[0].mask
= CL_DRIVER
;
3758 handlers
->handlers
[1].handler
= common_handle_option
;
3759 handlers
->handlers
[1].mask
= CL_COMMON
;
3760 handlers
->handlers
[2].handler
= target_handle_option
;
3761 handlers
->handlers
[2].mask
= CL_TARGET
;
3764 /* Create the vector `switches' and its contents.
3765 Store its length in `n_switches'. */
3768 process_command (unsigned int decoded_options_count
,
3769 struct cl_decoded_option
*decoded_options
)
3773 char *tooldir_prefix
, *tooldir_prefix2
;
3774 char *(*get_relative_prefix
) (const char *, const char *,
3775 const char *) = NULL
;
3776 struct cl_option_handlers handlers
;
3779 gcc_exec_prefix
= getenv ("GCC_EXEC_PREFIX");
3783 added_libraries
= 0;
3785 /* Figure compiler version from version string. */
3787 compiler_version
= temp1
= xstrdup (version_string
);
3789 for (; *temp1
; ++temp1
)
3798 /* Handle any -no-canonical-prefixes flag early, to assign the function
3799 that builds relative prefixes. This function creates default search
3800 paths that are needed later in normal option handling. */
3802 for (j
= 1; j
< decoded_options_count
; j
++)
3804 if (decoded_options
[j
].opt_index
== OPT_no_canonical_prefixes
)
3806 get_relative_prefix
= make_relative_prefix_ignore_links
;
3810 if (! get_relative_prefix
)
3811 get_relative_prefix
= make_relative_prefix
;
3813 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
3814 see if we can create it from the pathname specified in
3815 decoded_options[0].arg. */
3817 gcc_libexec_prefix
= standard_libexec_prefix
;
3819 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
3820 if (!gcc_exec_prefix
)
3822 gcc_exec_prefix
= get_relative_prefix (decoded_options
[0].arg
,
3823 standard_bindir_prefix
,
3824 standard_exec_prefix
);
3825 gcc_libexec_prefix
= get_relative_prefix (decoded_options
[0].arg
,
3826 standard_bindir_prefix
,
3827 standard_libexec_prefix
);
3828 if (gcc_exec_prefix
)
3829 xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix
, NULL
));
3833 /* make_relative_prefix requires a program name, but
3834 GCC_EXEC_PREFIX is typically a directory name with a trailing
3835 / (which is ignored by make_relative_prefix), so append a
3837 char *tmp_prefix
= concat (gcc_exec_prefix
, "gcc", NULL
);
3838 gcc_libexec_prefix
= get_relative_prefix (tmp_prefix
,
3839 standard_exec_prefix
,
3840 standard_libexec_prefix
);
3842 /* The path is unrelocated, so fallback to the original setting. */
3843 if (!gcc_libexec_prefix
)
3844 gcc_libexec_prefix
= standard_libexec_prefix
;
3850 /* From this point onward, gcc_exec_prefix is non-null if the toolchain
3851 is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
3852 or an automatically created GCC_EXEC_PREFIX from
3853 decoded_options[0].arg. */
3855 /* Do language-specific adjustment/addition of flags. */
3856 lang_specific_driver (&decoded_options
, &decoded_options_count
,
3859 if (gcc_exec_prefix
)
3861 int len
= strlen (gcc_exec_prefix
);
3863 if (len
> (int) sizeof ("/lib/gcc/") - 1
3864 && (IS_DIR_SEPARATOR (gcc_exec_prefix
[len
-1])))
3866 temp
= gcc_exec_prefix
+ len
- sizeof ("/lib/gcc/") + 1;
3867 if (IS_DIR_SEPARATOR (*temp
)
3868 && filename_ncmp (temp
+ 1, "lib", 3) == 0
3869 && IS_DIR_SEPARATOR (temp
[4])
3870 && filename_ncmp (temp
+ 5, "gcc", 3) == 0)
3871 len
-= sizeof ("/lib/gcc/") - 1;
3874 set_std_prefix (gcc_exec_prefix
, len
);
3875 add_prefix (&exec_prefixes
, gcc_libexec_prefix
, "GCC",
3876 PREFIX_PRIORITY_LAST
, 0, 0);
3877 add_prefix (&startfile_prefixes
, gcc_exec_prefix
, "GCC",
3878 PREFIX_PRIORITY_LAST
, 0, 0);
3881 /* COMPILER_PATH and LIBRARY_PATH have values
3882 that are lists of directory names with colons. */
3884 temp
= getenv ("COMPILER_PATH");
3887 const char *startp
, *endp
;
3888 char *nstore
= (char *) alloca (strlen (temp
) + 3);
3890 startp
= endp
= temp
;
3893 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
3895 strncpy (nstore
, startp
, endp
- startp
);
3897 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
3898 else if (!IS_DIR_SEPARATOR (endp
[-1]))
3900 nstore
[endp
- startp
] = DIR_SEPARATOR
;
3901 nstore
[endp
- startp
+ 1] = 0;
3904 nstore
[endp
- startp
] = 0;
3905 add_prefix (&exec_prefixes
, nstore
, 0,
3906 PREFIX_PRIORITY_LAST
, 0, 0);
3907 add_prefix (&include_prefixes
, nstore
, 0,
3908 PREFIX_PRIORITY_LAST
, 0, 0);
3911 endp
= startp
= endp
+ 1;
3918 temp
= getenv (LIBRARY_PATH_ENV
);
3919 if (temp
&& *cross_compile
== '0')
3921 const char *startp
, *endp
;
3922 char *nstore
= (char *) alloca (strlen (temp
) + 3);
3924 startp
= endp
= temp
;
3927 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
3929 strncpy (nstore
, startp
, endp
- startp
);
3931 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
3932 else if (!IS_DIR_SEPARATOR (endp
[-1]))
3934 nstore
[endp
- startp
] = DIR_SEPARATOR
;
3935 nstore
[endp
- startp
+ 1] = 0;
3938 nstore
[endp
- startp
] = 0;
3939 add_prefix (&startfile_prefixes
, nstore
, NULL
,
3940 PREFIX_PRIORITY_LAST
, 0, 1);
3943 endp
= startp
= endp
+ 1;
3950 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
3951 temp
= getenv ("LPATH");
3952 if (temp
&& *cross_compile
== '0')
3954 const char *startp
, *endp
;
3955 char *nstore
= (char *) alloca (strlen (temp
) + 3);
3957 startp
= endp
= temp
;
3960 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
3962 strncpy (nstore
, startp
, endp
- startp
);
3964 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
3965 else if (!IS_DIR_SEPARATOR (endp
[-1]))
3967 nstore
[endp
- startp
] = DIR_SEPARATOR
;
3968 nstore
[endp
- startp
+ 1] = 0;
3971 nstore
[endp
- startp
] = 0;
3972 add_prefix (&startfile_prefixes
, nstore
, NULL
,
3973 PREFIX_PRIORITY_LAST
, 0, 1);
3976 endp
= startp
= endp
+ 1;
3983 /* Process the options and store input files and switches in their
3986 last_language_n_infiles
= -1;
3988 set_option_handlers (&handlers
);
3990 for (j
= 1; j
< decoded_options_count
; j
++)
3992 switch (decoded_options
[j
].opt_index
)
4004 for (j
= 1; j
< decoded_options_count
; j
++)
4006 if (decoded_options
[j
].opt_index
== OPT_SPECIAL_input_file
)
4008 const char *arg
= decoded_options
[j
].arg
;
4009 const char *p
= strrchr (arg
, '@');
4013 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4014 arg
= convert_filename (arg
, 0, access (arg
, F_OK
));
4016 /* For LTO static archive support we handle input file
4017 specifications that are composed of a filename and
4018 an offset like FNAME@OFFSET. */
4021 && sscanf (p
, "@%li%n", &offset
, &consumed
) >= 1
4022 && strlen (p
) == (unsigned int)consumed
)
4024 fname
= (char *)xmalloc (p
- arg
+ 1);
4025 memcpy (fname
, arg
, p
- arg
);
4026 fname
[p
- arg
] = '\0';
4027 /* Only accept non-stdin and existing FNAME parts, otherwise
4028 try with the full name. */
4029 if (strcmp (fname
, "-") == 0 || access (fname
, F_OK
) < 0)
4032 fname
= xstrdup (arg
);
4036 fname
= xstrdup (arg
);
4038 if (strcmp (fname
, "-") != 0 && access (fname
, F_OK
) < 0)
4039 perror_with_name (fname
);
4041 add_infile (arg
, spec_lang
);
4047 read_cmdline_option (&global_options
, &global_options_set
,
4048 decoded_options
+ j
, UNKNOWN_LOCATION
,
4049 CL_DRIVER
, &handlers
, global_dc
);
4052 if (output_file
&& strcmp (output_file
, "-"))
4055 for (i
= 0; i
< n_infiles
; i
++)
4056 if ((!infiles
[i
].language
|| infiles
[i
].language
[0] != '*')
4057 && canonical_filename_eq (infiles
[i
].name
, output_file
))
4058 fatal_error ("input file %qs is the same as output file",
4062 /* If -save-temps=obj and -o name, create the prefix to use for %b.
4063 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
4064 if (save_temps_flag
== SAVE_TEMPS_OBJ
&& save_temps_prefix
!= NULL
)
4066 save_temps_length
= strlen (save_temps_prefix
);
4067 temp
= strrchr (lbasename (save_temps_prefix
), '.');
4070 save_temps_length
-= strlen (temp
);
4071 save_temps_prefix
[save_temps_length
] = '\0';
4075 else if (save_temps_prefix
!= NULL
)
4077 free (save_temps_prefix
);
4078 save_temps_prefix
= NULL
;
4081 if (save_temps_flag
&& use_pipes
)
4083 /* -save-temps overrides -pipe, so that temp files are produced */
4084 if (save_temps_flag
)
4085 warning (0, "-pipe ignored because -save-temps specified");
4091 const char *gcd
= getenv ("GCC_COMPARE_DEBUG");
4093 if (gcd
&& gcd
[0] == '-')
4096 compare_debug_opt
= gcd
;
4098 else if (gcd
&& *gcd
&& strcmp (gcd
, "0"))
4101 compare_debug_opt
= "-gtoggle";
4104 else if (compare_debug
< 0)
4107 gcc_assert (!compare_debug_opt
);
4110 /* Set up the search paths. We add directories that we expect to
4111 contain GNU Toolchain components before directories specified by
4112 the machine description so that we will find GNU components (like
4113 the GNU assembler) before those of the host system. */
4115 /* If we don't know where the toolchain has been installed, use the
4116 configured-in locations. */
4117 if (!gcc_exec_prefix
)
4120 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "GCC",
4121 PREFIX_PRIORITY_LAST
, 1, 0);
4122 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "BINUTILS",
4123 PREFIX_PRIORITY_LAST
, 2, 0);
4124 add_prefix (&exec_prefixes
, standard_exec_prefix
, "BINUTILS",
4125 PREFIX_PRIORITY_LAST
, 2, 0);
4127 add_prefix (&startfile_prefixes
, standard_exec_prefix
, "BINUTILS",
4128 PREFIX_PRIORITY_LAST
, 1, 0);
4131 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix
));
4132 tooldir_prefix2
= concat (tooldir_base_prefix
, spec_machine
,
4133 dir_separator_str
, NULL
);
4135 /* Look for tools relative to the location from which the driver is
4136 running, or, if that is not available, the configured prefix. */
4138 = concat (gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
4139 spec_machine
, dir_separator_str
,
4140 spec_version
, dir_separator_str
, tooldir_prefix2
, NULL
);
4141 free (tooldir_prefix2
);
4143 add_prefix (&exec_prefixes
,
4144 concat (tooldir_prefix
, "bin", dir_separator_str
, NULL
),
4145 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 0);
4146 add_prefix (&startfile_prefixes
,
4147 concat (tooldir_prefix
, "lib", dir_separator_str
, NULL
),
4148 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 1);
4149 free (tooldir_prefix
);
4151 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
4152 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
4153 then consider it to relocate with the rest of the GCC installation
4154 if GCC_EXEC_PREFIX is set.
4155 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
4156 if (target_system_root
&& !target_system_root_changed
&& gcc_exec_prefix
)
4158 char *tmp_prefix
= get_relative_prefix (decoded_options
[0].arg
,
4159 standard_bindir_prefix
,
4160 target_system_root
);
4161 if (tmp_prefix
&& access_check (tmp_prefix
, F_OK
) == 0)
4163 target_system_root
= tmp_prefix
;
4164 target_system_root_changed
= 1;
4169 /* More prefixes are enabled in main, after we read the specs file
4170 and determine whether this is cross-compilation or not. */
4172 if (n_infiles
== last_language_n_infiles
&& spec_lang
!= 0)
4173 warning (0, "%<-x %s%> after last input file has no effect", spec_lang
);
4175 /* Synthesize -fcompare-debug flag from the GCC_COMPARE_DEBUG
4176 environment variable. */
4177 if (compare_debug
== 2 || compare_debug
== 3)
4179 const char *opt
= concat ("-fcompare-debug=", compare_debug_opt
, NULL
);
4180 save_switch (opt
, 0, NULL
, false, true);
4184 /* Ensure we only invoke each subprocess once. */
4185 if (print_subprocess_help
|| print_help_list
|| print_version
)
4189 /* Create a dummy input file, so that we can pass
4190 the help option on to the various sub-processes. */
4191 add_infile ("help-dummy", "c");
4195 switches
[n_switches
].part1
= 0;
4197 infiles
[n_infiles
].name
= 0;
4200 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4201 and place that in the environment. */
4204 set_collect_gcc_options (void)
4209 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4211 obstack_grow (&collect_obstack
, "COLLECT_GCC_OPTIONS=",
4212 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4215 for (i
= 0; (int) i
< n_switches
; i
++)
4217 const char *const *args
;
4220 obstack_grow (&collect_obstack
, " ", 1);
4224 /* Ignore elided switches. */
4225 if ((switches
[i
].live_cond
4226 & (SWITCH_IGNORE
| SWITCH_KEEP_FOR_GCC
))
4230 obstack_grow (&collect_obstack
, "'-", 2);
4231 q
= switches
[i
].part1
;
4232 while ((p
= strchr (q
, '\'')))
4234 obstack_grow (&collect_obstack
, q
, p
- q
);
4235 obstack_grow (&collect_obstack
, "'\\''", 4);
4238 obstack_grow (&collect_obstack
, q
, strlen (q
));
4239 obstack_grow (&collect_obstack
, "'", 1);
4241 for (args
= switches
[i
].args
; args
&& *args
; args
++)
4243 obstack_grow (&collect_obstack
, " '", 2);
4245 while ((p
= strchr (q
, '\'')))
4247 obstack_grow (&collect_obstack
, q
, p
- q
);
4248 obstack_grow (&collect_obstack
, "'\\''", 4);
4251 obstack_grow (&collect_obstack
, q
, strlen (q
));
4252 obstack_grow (&collect_obstack
, "'", 1);
4255 obstack_grow (&collect_obstack
, "\0", 1);
4256 xputenv (XOBFINISH (&collect_obstack
, char *));
4259 /* Process a spec string, accumulating and running commands. */
4261 /* These variables describe the input file name.
4262 input_file_number is the index on outfiles of this file,
4263 so that the output file name can be stored for later use by %o.
4264 input_basename is the start of the part of the input file
4265 sans all directory names, and basename_length is the number
4266 of characters starting there excluding the suffix .c or whatever. */
4268 static const char *gcc_input_filename
;
4269 static int input_file_number
;
4270 size_t input_filename_length
;
4271 static int basename_length
;
4272 static int suffixed_basename_length
;
4273 static const char *input_basename
;
4274 static const char *input_suffix
;
4275 #ifndef HOST_LACKS_INODE_NUMBERS
4276 static struct stat input_stat
;
4278 static int input_stat_set
;
4280 /* The compiler used to process the current input file. */
4281 static struct compiler
*input_file_compiler
;
4283 /* These are variables used within do_spec and do_spec_1. */
4285 /* Nonzero if an arg has been started and not yet terminated
4286 (with space, tab or newline). */
4287 static int arg_going
;
4289 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4290 is a temporary file name. */
4291 static int delete_this_arg
;
4293 /* Nonzero means %w has been seen; the next arg to be terminated
4294 is the output file name of this compilation. */
4295 static int this_is_output_file
;
4297 /* Nonzero means %s has been seen; the next arg to be terminated
4298 is the name of a library file and we should try the standard
4299 search dirs for it. */
4300 static int this_is_library_file
;
4302 /* Nonzero means %T has been seen; the next arg to be terminated
4303 is the name of a linker script and we should try all of the
4304 standard search dirs for it. If it is found insert a --script
4305 command line switch and then substitute the full path in place,
4306 otherwise generate an error message. */
4307 static int this_is_linker_script
;
4309 /* Nonzero means that the input of this command is coming from a pipe. */
4310 static int input_from_pipe
;
4312 /* Nonnull means substitute this for any suffix when outputting a switches
4314 static const char *suffix_subst
;
4316 /* If there is an argument being accumulated, terminate it and store it. */
4319 end_going_arg (void)
4325 obstack_1grow (&obstack
, 0);
4326 string
= XOBFINISH (&obstack
, const char *);
4327 if (this_is_library_file
)
4328 string
= find_file (string
);
4329 if (this_is_linker_script
)
4331 char * full_script_path
= find_a_file (&startfile_prefixes
, string
, R_OK
, true);
4333 if (full_script_path
== NULL
)
4335 error ("unable to locate default linker script %qs in the library search paths", string
);
4336 /* Script was not found on search path. */
4339 store_arg ("--script", false, false);
4340 string
= full_script_path
;
4342 store_arg (string
, delete_this_arg
, this_is_output_file
);
4343 if (this_is_output_file
)
4344 outfiles
[input_file_number
] = string
;
4350 /* Parse the WRAPPER string which is a comma separated list of the command line
4351 and insert them into the beginning of argbuf. */
4354 insert_wrapper (const char *wrapper
)
4358 char *buf
= xstrdup (wrapper
);
4360 unsigned int old_length
= argbuf
.length ();
4368 while ((p
= strchr (p
, ',')) != NULL
);
4370 argbuf
.safe_grow (old_length
+ n
);
4371 memmove (argbuf
.address () + n
,
4373 old_length
* sizeof (const_char_p
));
4387 while ((p
= strchr (p
, ',')) != NULL
);
4388 gcc_assert (i
== n
);
4391 /* Process the spec SPEC and run the commands specified therein.
4392 Returns 0 if the spec is successfully processed; -1 if failed. */
4395 do_spec (const char *spec
)
4399 value
= do_spec_2 (spec
);
4401 /* Force out any unfinished command.
4402 If -pipe, this forces out the last command if it ended in `|'. */
4405 if (argbuf
.length () > 0
4406 && !strcmp (argbuf
.last (), "|"))
4409 set_collect_gcc_options ();
4411 if (argbuf
.length () > 0)
4419 do_spec_2 (const char *spec
)
4425 delete_this_arg
= 0;
4426 this_is_output_file
= 0;
4427 this_is_library_file
= 0;
4428 this_is_linker_script
= 0;
4429 input_from_pipe
= 0;
4430 suffix_subst
= NULL
;
4432 result
= do_spec_1 (spec
, 0, NULL
);
4440 /* Process the given spec string and add any new options to the end
4441 of the switches/n_switches array. */
4444 do_option_spec (const char *name
, const char *spec
)
4446 unsigned int i
, value_count
, value_len
;
4447 const char *p
, *q
, *value
;
4448 char *tmp_spec
, *tmp_spec_p
;
4450 if (configure_default_options
[0].name
== NULL
)
4453 for (i
= 0; i
< ARRAY_SIZE (configure_default_options
); i
++)
4454 if (strcmp (configure_default_options
[i
].name
, name
) == 0)
4456 if (i
== ARRAY_SIZE (configure_default_options
))
4459 value
= configure_default_options
[i
].value
;
4460 value_len
= strlen (value
);
4462 /* Compute the size of the final spec. */
4465 while ((p
= strstr (p
, "%(VALUE)")) != NULL
)
4471 /* Replace each %(VALUE) by the specified value. */
4472 tmp_spec
= (char *) alloca (strlen (spec
) + 1
4473 + value_count
* (value_len
- strlen ("%(VALUE)")));
4474 tmp_spec_p
= tmp_spec
;
4476 while ((p
= strstr (q
, "%(VALUE)")) != NULL
)
4478 memcpy (tmp_spec_p
, q
, p
- q
);
4479 tmp_spec_p
= tmp_spec_p
+ (p
- q
);
4480 memcpy (tmp_spec_p
, value
, value_len
);
4481 tmp_spec_p
+= value_len
;
4482 q
= p
+ strlen ("%(VALUE)");
4484 strcpy (tmp_spec_p
, q
);
4486 do_self_spec (tmp_spec
);
4489 /* Process the given spec string and add any new options to the end
4490 of the switches/n_switches array. */
4493 do_self_spec (const char *spec
)
4498 do_spec_1 (" ", 0, NULL
);
4500 /* Mark %<S switches processed by do_self_spec to be ignored permanently.
4501 do_self_specs adds the replacements to switches array, so it shouldn't
4502 be processed afterwards. */
4503 for (i
= 0; i
< n_switches
; i
++)
4504 if ((switches
[i
].live_cond
& SWITCH_IGNORE
))
4505 switches
[i
].live_cond
|= SWITCH_IGNORE_PERMANENTLY
;
4507 if (argbuf
.length () > 0)
4509 const char **argbuf_copy
;
4510 struct cl_decoded_option
*decoded_options
;
4511 struct cl_option_handlers handlers
;
4512 unsigned int decoded_options_count
;
4515 /* Create a copy of argbuf with a dummy argv[0] entry for
4516 decode_cmdline_options_to_array. */
4517 argbuf_copy
= XNEWVEC (const char *,
4518 argbuf
.length () + 1);
4519 argbuf_copy
[0] = "";
4520 memcpy (argbuf_copy
+ 1, argbuf
.address (),
4521 argbuf
.length () * sizeof (const char *));
4523 decode_cmdline_options_to_array (argbuf
.length () + 1,
4525 CL_DRIVER
, &decoded_options
,
4526 &decoded_options_count
);
4529 set_option_handlers (&handlers
);
4531 for (j
= 1; j
< decoded_options_count
; j
++)
4533 switch (decoded_options
[j
].opt_index
)
4535 case OPT_SPECIAL_input_file
:
4536 /* Specs should only generate options, not input
4538 if (strcmp (decoded_options
[j
].arg
, "-") != 0)
4539 fatal_error ("switch %qs does not start with %<-%>",
4540 decoded_options
[j
].arg
);
4542 fatal_error ("spec-generated switch is just %<-%>");
4545 case OPT_fcompare_debug_second
:
4546 case OPT_fcompare_debug
:
4547 case OPT_fcompare_debug_
:
4549 /* Avoid duplicate processing of some options from
4550 compare-debug specs; just save them here. */
4551 save_switch (decoded_options
[j
].canonical_option
[0],
4552 (decoded_options
[j
].canonical_option_num_elements
4554 &decoded_options
[j
].canonical_option
[1], false, true);
4558 read_cmdline_option (&global_options
, &global_options_set
,
4559 decoded_options
+ j
, UNKNOWN_LOCATION
,
4560 CL_DRIVER
, &handlers
, global_dc
);
4566 switches
[n_switches
].part1
= 0;
4570 /* Callback for processing %D and %I specs. */
4572 struct spec_path_info
{
4577 bool separate_options
;
4581 spec_path (char *path
, void *data
)
4583 struct spec_path_info
*info
= (struct spec_path_info
*) data
;
4587 if (info
->omit_relative
&& !IS_ABSOLUTE_PATH (path
))
4590 if (info
->append_len
!= 0)
4592 len
= strlen (path
);
4593 memcpy (path
+ len
, info
->append
, info
->append_len
+ 1);
4596 if (!is_directory (path
, true))
4599 do_spec_1 (info
->option
, 1, NULL
);
4600 if (info
->separate_options
)
4601 do_spec_1 (" ", 0, NULL
);
4603 if (info
->append_len
== 0)
4605 len
= strlen (path
);
4606 save
= path
[len
- 1];
4607 if (IS_DIR_SEPARATOR (path
[len
- 1]))
4608 path
[len
- 1] = '\0';
4611 do_spec_1 (path
, 1, NULL
);
4612 do_spec_1 (" ", 0, NULL
);
4614 /* Must not damage the original path. */
4615 if (info
->append_len
== 0)
4616 path
[len
- 1] = save
;
4621 /* Create a temporary FILE with the contents of ARGV. Add @FILE to the
4625 create_at_file (char **argv
)
4627 char *temp_file
= make_temp_file ("");
4628 char *at_argument
= concat ("@", temp_file
, NULL
);
4629 FILE *f
= fopen (temp_file
, "w");
4633 fatal_error ("could not open temporary response file %s",
4636 status
= writeargv (argv
, f
);
4639 fatal_error ("could not write to temporary response file %s",
4642 status
= fclose (f
);
4645 fatal_error ("could not close temporary response file %s",
4648 store_arg (at_argument
, 0, 0);
4650 record_temp_file (temp_file
, !save_temps_flag
, !save_temps_flag
);
4653 /* True if we should compile INFILE. */
4656 compile_input_file_p (struct infile
*infile
)
4658 if ((!infile
->language
) || (infile
->language
[0] != '*'))
4659 if (infile
->incompiler
== input_file_compiler
)
4664 /* Process each member of VEC as a spec. */
4667 do_specs_vec (vec
<char_p
> vec
)
4672 FOR_EACH_VEC_ELT (vec
, ix
, opt
)
4674 do_spec_1 (opt
, 1, NULL
);
4675 /* Make each accumulated option a separate argument. */
4676 do_spec_1 (" ", 0, NULL
);
4680 /* Process the sub-spec SPEC as a portion of a larger spec.
4681 This is like processing a whole spec except that we do
4682 not initialize at the beginning and we do not supply a
4683 newline by default at the end.
4684 INSWITCH nonzero means don't process %-sequences in SPEC;
4685 in this case, % is treated as an ordinary character.
4686 This is used while substituting switches.
4687 INSWITCH nonzero also causes SPC not to terminate an argument.
4689 Value is zero unless a line was finished
4690 and the command on that line reported an error. */
4693 do_spec_1 (const char *spec
, int inswitch
, const char *soft_matched_part
)
4695 const char *p
= spec
;
4700 /* If it's an empty string argument to a switch, keep it as is. */
4701 if (inswitch
&& !*p
)
4705 /* If substituting a switch, treat all chars like letters.
4706 Otherwise, NL, SPC, TAB and % are special. */
4707 switch (inswitch
? 'a' : c
)
4712 if (argbuf
.length () > 0
4713 && !strcmp (argbuf
.last (), "|"))
4715 /* A `|' before the newline means use a pipe here,
4716 but only if -pipe was specified.
4717 Otherwise, execute now and don't pass the `|' as an arg. */
4720 input_from_pipe
= 1;
4727 set_collect_gcc_options ();
4729 if (argbuf
.length () > 0)
4735 /* Reinitialize for a new command, and for a new argument. */
4738 delete_this_arg
= 0;
4739 this_is_output_file
= 0;
4740 this_is_library_file
= 0;
4741 this_is_linker_script
= 0;
4742 input_from_pipe
= 0;
4749 obstack_1grow (&obstack
, c
);
4757 /* Reinitialize for a new argument. */
4758 delete_this_arg
= 0;
4759 this_is_output_file
= 0;
4760 this_is_library_file
= 0;
4761 this_is_linker_script
= 0;
4768 fatal_error ("spec %qs invalid", spec
);
4771 if (save_temps_length
)
4772 obstack_grow (&obstack
, save_temps_prefix
, save_temps_length
);
4774 obstack_grow (&obstack
, input_basename
, basename_length
);
4775 if (compare_debug
< 0)
4776 obstack_grow (&obstack
, ".gk", 3);
4781 if (save_temps_length
)
4782 obstack_grow (&obstack
, save_temps_prefix
, save_temps_length
);
4784 obstack_grow (&obstack
, input_basename
, suffixed_basename_length
);
4785 if (compare_debug
< 0)
4786 obstack_grow (&obstack
, ".gk", 3);
4791 delete_this_arg
= 2;
4794 /* Dump out the directories specified with LIBRARY_PATH,
4795 followed by the absolute directories
4796 that we search for startfiles. */
4799 struct spec_path_info info
;
4802 info
.append_len
= 0;
4803 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
4804 /* Used on systems which record the specified -L dirs
4805 and use them to search for dynamic linking.
4806 Relative directories always come from -B,
4807 and it is better not to use them for searching
4808 at run time. In particular, stage1 loses. */
4809 info
.omit_relative
= true;
4811 info
.omit_relative
= false;
4813 info
.separate_options
= false;
4815 for_each_path (&startfile_prefixes
, true, 0, spec_path
, &info
);
4820 /* %efoo means report an error with `foo' as error message
4821 and don't execute any more commands for this file. */
4825 while (*p
!= 0 && *p
!= '\n')
4827 buf
= (char *) alloca (p
- q
+ 1);
4828 strncpy (buf
, q
, p
- q
);
4830 error ("%s", _(buf
));
4835 /* %nfoo means report a notice with `foo' on stderr. */
4839 while (*p
!= 0 && *p
!= '\n')
4841 buf
= (char *) alloca (p
- q
+ 1);
4842 strncpy (buf
, q
, p
- q
);
4844 inform (0, "%s", _(buf
));
4854 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
4855 defined, and it is not a directory, and it is
4856 writable, use it. Otherwise, treat this like any
4857 other temporary file. */
4859 if ((!save_temps_flag
)
4860 && (stat (HOST_BIT_BUCKET
, &st
) == 0) && (!S_ISDIR (st
.st_mode
))
4861 && (access (HOST_BIT_BUCKET
, W_OK
) == 0))
4863 obstack_grow (&obstack
, HOST_BIT_BUCKET
,
4864 strlen (HOST_BIT_BUCKET
));
4865 delete_this_arg
= 0;
4870 goto create_temp_file
;
4874 obstack_1grow (&obstack
, '-');
4875 delete_this_arg
= 0;
4878 /* consume suffix */
4879 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
4881 if (p
[0] == '%' && p
[1] == 'O')
4886 goto create_temp_file
;
4890 /* consume suffix */
4891 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
4893 if (p
[0] == '%' && p
[1] == 'O')
4898 goto create_temp_file
;
4904 struct temp_name
*t
;
4906 const char *suffix
= p
;
4907 char *saved_suffix
= NULL
;
4909 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
4911 suffix_length
= p
- suffix
;
4912 if (p
[0] == '%' && p
[1] == 'O')
4915 /* We don't support extra suffix characters after %O. */
4916 if (*p
== '.' || ISALNUM ((unsigned char) *p
))
4917 fatal_error ("spec %qs has invalid %<%%0%c%>", spec
, *p
);
4918 if (suffix_length
== 0)
4919 suffix
= TARGET_OBJECT_SUFFIX
;
4923 = XNEWVEC (char, suffix_length
4924 + strlen (TARGET_OBJECT_SUFFIX
) + 1);
4925 strncpy (saved_suffix
, suffix
, suffix_length
);
4926 strcpy (saved_suffix
+ suffix_length
,
4927 TARGET_OBJECT_SUFFIX
);
4929 suffix_length
+= strlen (TARGET_OBJECT_SUFFIX
);
4932 if (compare_debug
< 0)
4934 suffix
= concat (".gk", suffix
, NULL
);
4938 /* If -save-temps=obj and -o were specified, use that for the
4940 if (save_temps_length
)
4943 temp_filename_length
4944 = save_temps_length
+ suffix_length
+ 1;
4945 tmp
= (char *) alloca (temp_filename_length
);
4946 memcpy (tmp
, save_temps_prefix
, save_temps_length
);
4947 memcpy (tmp
+ save_temps_length
, suffix
, suffix_length
);
4948 tmp
[save_temps_length
+ suffix_length
] = '\0';
4949 temp_filename
= save_string (tmp
, save_temps_length
4951 obstack_grow (&obstack
, temp_filename
,
4952 temp_filename_length
);
4954 delete_this_arg
= 0;
4958 /* If the gcc_input_filename has the same suffix specified
4959 for the %g, %u, or %U, and -save-temps is specified,
4960 we could end up using that file as an intermediate
4961 thus clobbering the user's source file (.e.g.,
4962 gcc -save-temps foo.s would clobber foo.s with the
4963 output of cpp0). So check for this condition and
4964 generate a temp file as the intermediate. */
4966 if (save_temps_flag
)
4969 temp_filename_length
= basename_length
+ suffix_length
+ 1;
4970 tmp
= (char *) alloca (temp_filename_length
);
4971 memcpy (tmp
, input_basename
, basename_length
);
4972 memcpy (tmp
+ basename_length
, suffix
, suffix_length
);
4973 tmp
[basename_length
+ suffix_length
] = '\0';
4974 temp_filename
= tmp
;
4976 if (filename_cmp (temp_filename
, gcc_input_filename
) != 0)
4978 #ifndef HOST_LACKS_INODE_NUMBERS
4979 struct stat st_temp
;
4981 /* Note, set_input() resets input_stat_set to 0. */
4982 if (input_stat_set
== 0)
4984 input_stat_set
= stat (gcc_input_filename
,
4986 if (input_stat_set
>= 0)
4990 /* If we have the stat for the gcc_input_filename
4991 and we can do the stat for the temp_filename
4992 then the they could still refer to the same
4993 file if st_dev/st_ino's are the same. */
4994 if (input_stat_set
!= 1
4995 || stat (temp_filename
, &st_temp
) < 0
4996 || input_stat
.st_dev
!= st_temp
.st_dev
4997 || input_stat
.st_ino
!= st_temp
.st_ino
)
4999 /* Just compare canonical pathnames. */
5000 char* input_realname
= lrealpath (gcc_input_filename
);
5001 char* temp_realname
= lrealpath (temp_filename
);
5002 bool files_differ
= filename_cmp (input_realname
, temp_realname
);
5003 free (input_realname
);
5004 free (temp_realname
);
5008 temp_filename
= save_string (temp_filename
,
5009 temp_filename_length
+ 1);
5010 obstack_grow (&obstack
, temp_filename
,
5011 temp_filename_length
);
5013 delete_this_arg
= 0;
5019 /* See if we already have an association of %g/%u/%U and
5021 for (t
= temp_names
; t
; t
= t
->next
)
5022 if (t
->length
== suffix_length
5023 && strncmp (t
->suffix
, suffix
, suffix_length
) == 0
5024 && t
->unique
== (c
== 'u' || c
== 'U' || c
== 'j'))
5027 /* Make a new association if needed. %u and %j
5029 if (t
== 0 || c
== 'u' || c
== 'j')
5033 t
= XNEW (struct temp_name
);
5034 t
->next
= temp_names
;
5037 t
->length
= suffix_length
;
5040 t
->suffix
= saved_suffix
;
5041 saved_suffix
= NULL
;
5044 t
->suffix
= save_string (suffix
, suffix_length
);
5045 t
->unique
= (c
== 'u' || c
== 'U' || c
== 'j');
5046 temp_filename
= make_temp_file (t
->suffix
);
5047 temp_filename_length
= strlen (temp_filename
);
5048 t
->filename
= temp_filename
;
5049 t
->filename_length
= temp_filename_length
;
5052 free (saved_suffix
);
5054 obstack_grow (&obstack
, t
->filename
, t
->filename_length
);
5055 delete_this_arg
= 1;
5063 if (at_file_supplied
)
5065 /* We are going to expand `%i' to `@FILE', where FILE
5066 is a newly-created temporary filename. The filenames
5067 that would usually be expanded in place of %o will be
5068 written to the temporary file. */
5073 for (i
= 0; i
< n_infiles
; i
++)
5074 if (compile_input_file_p (&infiles
[i
]))
5077 argv
= (char **) alloca (sizeof (char *) * (n_files
+ 1));
5079 /* Copy the strings over. */
5080 for (i
= 0, j
= 0; i
< n_infiles
; i
++)
5081 if (compile_input_file_p (&infiles
[i
]))
5083 argv
[j
] = CONST_CAST (char *, infiles
[i
].name
);
5084 infiles
[i
].compiled
= true;
5089 create_at_file (argv
);
5092 for (i
= 0; (int) i
< n_infiles
; i
++)
5093 if (compile_input_file_p (&infiles
[i
]))
5095 store_arg (infiles
[i
].name
, 0, 0);
5096 infiles
[i
].compiled
= true;
5101 obstack_grow (&obstack
, gcc_input_filename
,
5102 input_filename_length
);
5109 struct spec_path_info info
;
5113 do_spec_1 ("-imultilib", 1, NULL
);
5114 /* Make this a separate argument. */
5115 do_spec_1 (" ", 0, NULL
);
5116 do_spec_1 (multilib_dir
, 1, NULL
);
5117 do_spec_1 (" ", 0, NULL
);
5122 do_spec_1 ("-imultiarch", 1, NULL
);
5123 /* Make this a separate argument. */
5124 do_spec_1 (" ", 0, NULL
);
5125 do_spec_1 (multiarch_dir
, 1, NULL
);
5126 do_spec_1 (" ", 0, NULL
);
5129 if (gcc_exec_prefix
)
5131 do_spec_1 ("-iprefix", 1, NULL
);
5132 /* Make this a separate argument. */
5133 do_spec_1 (" ", 0, NULL
);
5134 do_spec_1 (gcc_exec_prefix
, 1, NULL
);
5135 do_spec_1 (" ", 0, NULL
);
5138 if (target_system_root_changed
||
5139 (target_system_root
&& target_sysroot_hdrs_suffix
))
5141 do_spec_1 ("-isysroot", 1, NULL
);
5142 /* Make this a separate argument. */
5143 do_spec_1 (" ", 0, NULL
);
5144 do_spec_1 (target_system_root
, 1, NULL
);
5145 if (target_sysroot_hdrs_suffix
)
5146 do_spec_1 (target_sysroot_hdrs_suffix
, 1, NULL
);
5147 do_spec_1 (" ", 0, NULL
);
5150 info
.option
= "-isystem";
5151 info
.append
= "include";
5152 info
.append_len
= strlen (info
.append
);
5153 info
.omit_relative
= false;
5154 info
.separate_options
= true;
5156 for_each_path (&include_prefixes
, false, info
.append_len
,
5159 info
.append
= "include-fixed";
5160 if (*sysroot_hdrs_suffix_spec
)
5161 info
.append
= concat (info
.append
, dir_separator_str
,
5162 multilib_dir
, NULL
);
5163 info
.append_len
= strlen (info
.append
);
5164 for_each_path (&include_prefixes
, false, info
.append_len
,
5171 int max
= n_infiles
;
5172 max
+= lang_specific_extra_outfiles
;
5174 if (HAVE_GNU_LD
&& at_file_supplied
)
5176 /* We are going to expand `%o' to `@FILE', where FILE
5177 is a newly-created temporary filename. The filenames
5178 that would usually be expanded in place of %o will be
5179 written to the temporary file. */
5184 /* Convert OUTFILES into a form suitable for writeargv. */
5186 /* Determine how many are non-NULL. */
5187 for (n_files
= 0, i
= 0; i
< max
; i
++)
5188 n_files
+= outfiles
[i
] != NULL
;
5190 argv
= (char **) alloca (sizeof (char *) * (n_files
+ 1));
5192 /* Copy the strings over. */
5193 for (i
= 0, j
= 0; i
< max
; i
++)
5196 argv
[j
] = CONST_CAST (char *, outfiles
[i
]);
5201 create_at_file (argv
);
5204 for (i
= 0; i
< max
; i
++)
5206 store_arg (outfiles
[i
], 0, 0);
5211 obstack_grow (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
5216 this_is_library_file
= 1;
5220 this_is_linker_script
= 1;
5224 outfiles
[input_file_number
] = NULL
;
5228 this_is_output_file
= 1;
5233 unsigned int cur_index
= argbuf
.length ();
5234 /* Handle the {...} following the %W. */
5236 fatal_error ("spec %qs has invalid %<%%W%c%>", spec
, *p
);
5237 p
= handle_braces (p
+ 1);
5241 /* If any args were output, mark the last one for deletion
5243 if (argbuf
.length () != cur_index
)
5244 record_temp_file (argbuf
.last (), 0, 1);
5248 /* %x{OPTION} records OPTION for %X to output. */
5256 /* Skip past the option value and make a copy. */
5258 fatal_error ("spec %qs has invalid %<%%x%c%>", spec
, *p
);
5261 string
= save_string (p1
+ 1, p
- p1
- 2);
5263 /* See if we already recorded this option. */
5264 FOR_EACH_VEC_ELT (linker_options
, ix
, opt
)
5265 if (! strcmp (string
, opt
))
5271 /* This option is new; add it. */
5272 add_linker_option (string
, strlen (string
));
5277 /* Dump out the options accumulated previously using %x. */
5279 do_specs_vec (linker_options
);
5282 /* Dump out the options accumulated previously using -Wa,. */
5284 do_specs_vec (assembler_options
);
5287 /* Dump out the options accumulated previously using -Wp,. */
5289 do_specs_vec (preprocessor_options
);
5292 /* Here are digits and numbers that just process
5293 a certain constant string as a spec. */
5296 value
= do_spec_1 (cc1_spec
, 0, NULL
);
5302 value
= do_spec_1 (cc1plus_spec
, 0, NULL
);
5308 value
= do_spec_1 (asm_spec
, 0, NULL
);
5314 value
= do_spec_1 (asm_final_spec
, 0, NULL
);
5321 const char *const spec
5322 = (input_file_compiler
->cpp_spec
5323 ? input_file_compiler
->cpp_spec
5325 value
= do_spec_1 (spec
, 0, NULL
);
5332 value
= do_spec_1 (endfile_spec
, 0, NULL
);
5338 value
= do_spec_1 (link_spec
, 0, NULL
);
5344 value
= do_spec_1 (lib_spec
, 0, NULL
);
5350 if (multilib_os_dir
== NULL
)
5351 obstack_1grow (&obstack
, '.');
5353 obstack_grow (&obstack
, multilib_os_dir
,
5354 strlen (multilib_os_dir
));
5358 value
= do_spec_1 (libgcc_spec
, 0, NULL
);
5364 /* We assume there is a directory
5365 separator at the end of this string. */
5366 if (target_system_root
)
5368 obstack_grow (&obstack
, target_system_root
,
5369 strlen (target_system_root
));
5370 if (target_sysroot_suffix
)
5371 obstack_grow (&obstack
, target_sysroot_suffix
,
5372 strlen (target_sysroot_suffix
));
5377 value
= do_spec_1 (startfile_spec
, 0, NULL
);
5382 /* Here we define characters other than letters and digits. */
5385 p
= handle_braces (p
);
5391 p
= handle_spec_function (p
, NULL
);
5397 obstack_1grow (&obstack
, '%');
5404 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '%')
5406 suffix_subst
= save_string (p
- 1, len
+ 1);
5411 /* Henceforth ignore the option(s) matching the pattern
5417 int have_wildcard
= 0;
5422 switch_option
= SWITCH_IGNORE
| SWITCH_KEEP_FOR_GCC
;
5424 switch_option
= SWITCH_IGNORE
;
5426 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '\t')
5429 if (p
[len
-1] == '*')
5432 for (i
= 0; i
< n_switches
; i
++)
5433 if (!strncmp (switches
[i
].part1
, p
, len
- have_wildcard
)
5434 && (have_wildcard
|| switches
[i
].part1
[len
] == '\0'))
5436 switches
[i
].live_cond
|= switch_option
;
5437 /* User switch be validated from validate_all_switches.
5438 when the definition is seen from the spec file.
5439 If not defined anywhere, will be rejected. */
5440 if (switches
[i
].known
)
5441 switches
[i
].validated
= true;
5449 if (soft_matched_part
)
5451 if (soft_matched_part
[0])
5452 do_spec_1 (soft_matched_part
, 1, NULL
);
5453 /* Only insert a space after the substitution if it is at the
5454 end of the current sequence. So if:
5456 "%{foo=*:bar%*}%{foo=*:one%*two}"
5458 matches -foo=hello then it will produce:
5460 barhello onehellotwo
5462 if (*p
== 0 || *p
== '}')
5463 do_spec_1 (" ", 0, NULL
);
5466 /* Catch the case where a spec string contains something like
5467 '%{foo:%*}'. i.e. there is no * in the pattern on the left
5468 hand side of the :. */
5469 error ("spec failure: %<%%*%> has not been initialized by pattern match");
5472 /* Process a string found as the value of a spec given by name.
5473 This feature allows individual machine descriptions
5474 to add and use their own specs. */
5477 const char *name
= p
;
5478 struct spec_list
*sl
;
5481 /* The string after the S/P is the name of a spec that is to be
5483 while (*p
&& *p
!= ')')
5486 /* See if it's in the list. */
5487 for (len
= p
- name
, sl
= specs
; sl
; sl
= sl
->next
)
5488 if (sl
->name_len
== len
&& !strncmp (sl
->name
, name
, len
))
5490 name
= *(sl
->ptr_spec
);
5492 fnotice (stderr
, "Processing spec (%s), which is '%s'\n",
5500 value
= do_spec_1 (name
, 0, NULL
);
5505 /* Discard the closing paren. */
5512 error ("spec failure: unrecognized spec option %qc", c
);
5518 /* Backslash: treat next character as ordinary. */
5523 /* Ordinary character: put it into the current argument. */
5524 obstack_1grow (&obstack
, c
);
5528 /* End of string. If we are processing a spec function, we need to
5529 end any pending argument. */
5530 if (processing_spec_function
)
5536 /* Look up a spec function. */
5538 static const struct spec_function
*
5539 lookup_spec_function (const char *name
)
5541 const struct spec_function
*sf
;
5543 for (sf
= static_spec_functions
; sf
->name
!= NULL
; sf
++)
5544 if (strcmp (sf
->name
, name
) == 0)
5550 /* Evaluate a spec function. */
5553 eval_spec_function (const char *func
, const char *args
)
5555 const struct spec_function
*sf
;
5556 const char *funcval
;
5558 /* Saved spec processing context. */
5559 vec
<const_char_p
> save_argbuf
;
5562 int save_delete_this_arg
;
5563 int save_this_is_output_file
;
5564 int save_this_is_library_file
;
5565 int save_input_from_pipe
;
5566 int save_this_is_linker_script
;
5567 const char *save_suffix_subst
;
5569 int save_growing_size
;
5570 void *save_growing_value
= NULL
;
5572 sf
= lookup_spec_function (func
);
5574 fatal_error ("unknown spec function %qs", func
);
5576 /* Push the spec processing context. */
5577 save_argbuf
= argbuf
;
5579 save_arg_going
= arg_going
;
5580 save_delete_this_arg
= delete_this_arg
;
5581 save_this_is_output_file
= this_is_output_file
;
5582 save_this_is_library_file
= this_is_library_file
;
5583 save_this_is_linker_script
= this_is_linker_script
;
5584 save_input_from_pipe
= input_from_pipe
;
5585 save_suffix_subst
= suffix_subst
;
5587 /* If we have some object growing now, finalize it so the args and function
5588 eval proceed from a cleared context. This is needed to prevent the first
5589 constructed arg from mistakenly including the growing value. We'll push
5590 this value back on the obstack once the function evaluation is done, to
5591 restore a consistent processing context for our caller. This is fine as
5592 the address of growing objects isn't guaranteed to remain stable until
5593 they are finalized, and we expect this situation to be rare enough for
5594 the extra copy not to be an issue. */
5595 save_growing_size
= obstack_object_size (&obstack
);
5596 if (save_growing_size
> 0)
5597 save_growing_value
= obstack_finish (&obstack
);
5599 /* Create a new spec processing context, and build the function
5603 if (do_spec_2 (args
) < 0)
5604 fatal_error ("error in args to spec function %qs", func
);
5606 /* argbuf_index is an index for the next argument to be inserted, and
5607 so contains the count of the args already inserted. */
5609 funcval
= (*sf
->func
) (argbuf
.length (),
5612 /* Pop the spec processing context. */
5614 argbuf
= save_argbuf
;
5616 arg_going
= save_arg_going
;
5617 delete_this_arg
= save_delete_this_arg
;
5618 this_is_output_file
= save_this_is_output_file
;
5619 this_is_library_file
= save_this_is_library_file
;
5620 this_is_linker_script
= save_this_is_linker_script
;
5621 input_from_pipe
= save_input_from_pipe
;
5622 suffix_subst
= save_suffix_subst
;
5624 if (save_growing_size
> 0)
5625 obstack_grow (&obstack
, save_growing_value
, save_growing_size
);
5630 /* Handle a spec function call of the form:
5634 ARGS is processed as a spec in a separate context and split into an
5635 argument vector in the normal fashion. The function returns a string
5636 containing a spec which we then process in the caller's context, or
5637 NULL if no processing is required.
5639 If RETVAL_NONNULL is not NULL, then store a bool whether function
5640 returned non-NULL. */
5643 handle_spec_function (const char *p
, bool *retval_nonnull
)
5646 const char *endp
, *funcval
;
5649 processing_spec_function
++;
5651 /* Get the function name. */
5652 for (endp
= p
; *endp
!= '\0'; endp
++)
5654 if (*endp
== '(') /* ) */
5656 /* Only allow [A-Za-z0-9], -, and _ in function names. */
5657 if (!ISALNUM (*endp
) && !(*endp
== '-' || *endp
== '_'))
5658 fatal_error ("malformed spec function name");
5660 if (*endp
!= '(') /* ) */
5661 fatal_error ("no arguments for spec function");
5662 func
= save_string (p
, endp
- p
);
5665 /* Get the arguments. */
5666 for (count
= 0; *endp
!= '\0'; endp
++)
5675 else if (*endp
== '(') /* ) */
5680 fatal_error ("malformed spec function arguments");
5681 args
= save_string (p
, endp
- p
);
5684 /* p now points to just past the end of the spec function expression. */
5686 funcval
= eval_spec_function (func
, args
);
5687 if (funcval
!= NULL
&& do_spec_1 (funcval
, 0, NULL
) < 0)
5690 *retval_nonnull
= funcval
!= NULL
;
5695 processing_spec_function
--;
5700 /* Inline subroutine of handle_braces. Returns true if the current
5701 input suffix matches the atom bracketed by ATOM and END_ATOM. */
5703 input_suffix_matches (const char *atom
, const char *end_atom
)
5705 return (input_suffix
5706 && !strncmp (input_suffix
, atom
, end_atom
- atom
)
5707 && input_suffix
[end_atom
- atom
] == '\0');
5710 /* Subroutine of handle_braces. Returns true if the current
5711 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
5713 input_spec_matches (const char *atom
, const char *end_atom
)
5715 return (input_file_compiler
5716 && input_file_compiler
->suffix
5717 && input_file_compiler
->suffix
[0] != '\0'
5718 && !strncmp (input_file_compiler
->suffix
+ 1, atom
,
5720 && input_file_compiler
->suffix
[end_atom
- atom
+ 1] == '\0');
5723 /* Subroutine of handle_braces. Returns true if a switch
5724 matching the atom bracketed by ATOM and END_ATOM appeared on the
5727 switch_matches (const char *atom
, const char *end_atom
, int starred
)
5730 int len
= end_atom
- atom
;
5731 int plen
= starred
? len
: -1;
5733 for (i
= 0; i
< n_switches
; i
++)
5734 if (!strncmp (switches
[i
].part1
, atom
, len
)
5735 && (starred
|| switches
[i
].part1
[len
] == '\0')
5736 && check_live_switch (i
, plen
))
5739 /* Check if a switch with separated form matching the atom.
5740 We check -D and -U switches. */
5741 else if (switches
[i
].args
!= 0)
5743 if ((*switches
[i
].part1
== 'D' || *switches
[i
].part1
== 'U')
5744 && *switches
[i
].part1
== atom
[0])
5746 if (!strncmp (switches
[i
].args
[0], &atom
[1], len
- 1)
5747 && (starred
|| (switches
[i
].part1
[1] == '\0'
5748 && switches
[i
].args
[0][len
- 1] == '\0'))
5749 && check_live_switch (i
, (starred
? 1 : -1)))
5757 /* Inline subroutine of handle_braces. Mark all of the switches which
5758 match ATOM (extends to END_ATOM; STARRED indicates whether there
5759 was a star after the atom) for later processing. */
5761 mark_matching_switches (const char *atom
, const char *end_atom
, int starred
)
5764 int len
= end_atom
- atom
;
5765 int plen
= starred
? len
: -1;
5767 for (i
= 0; i
< n_switches
; i
++)
5768 if (!strncmp (switches
[i
].part1
, atom
, len
)
5769 && (starred
|| switches
[i
].part1
[len
] == '\0')
5770 && check_live_switch (i
, plen
))
5771 switches
[i
].ordering
= 1;
5774 /* Inline subroutine of handle_braces. Process all the currently
5775 marked switches through give_switch, and clear the marks. */
5777 process_marked_switches (void)
5781 for (i
= 0; i
< n_switches
; i
++)
5782 if (switches
[i
].ordering
== 1)
5784 switches
[i
].ordering
= 0;
5789 /* Handle a %{ ... } construct. P points just inside the leading {.
5790 Returns a pointer one past the end of the brace block, or 0
5791 if we call do_spec_1 and that returns -1. */
5794 handle_braces (const char *p
)
5796 const char *atom
, *end_atom
;
5797 const char *d_atom
= NULL
, *d_end_atom
= NULL
;
5798 const char *orig
= p
;
5806 bool a_must_be_last
= false;
5807 bool ordered_set
= false;
5808 bool disjunct_set
= false;
5809 bool disj_matched
= false;
5810 bool disj_starred
= true;
5811 bool n_way_choice
= false;
5812 bool n_way_matched
= false;
5814 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
5821 /* Scan one "atom" (S in the description above of %{}, possibly
5822 with '!', '.', '@', ',', or '*' modifiers). */
5824 a_is_suffix
= false;
5825 a_is_starred
= false;
5826 a_is_negated
= false;
5827 a_is_spectype
= false;
5831 p
++, a_is_negated
= true;
5834 if (*p
== '%' && p
[1] == ':')
5838 p
= handle_spec_function (p
+ 2, &a_matched
);
5843 p
++, a_is_suffix
= true;
5845 p
++, a_is_spectype
= true;
5848 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
5849 || *p
== ',' || *p
== '.' || *p
== '@')
5854 p
++, a_is_starred
= 1;
5861 /* Substitute the switch(es) indicated by the current atom. */
5863 if (disjunct_set
|| n_way_choice
|| a_is_negated
|| a_is_suffix
5864 || a_is_spectype
|| atom
== end_atom
)
5867 mark_matching_switches (atom
, end_atom
, a_is_starred
);
5870 process_marked_switches ();
5874 /* Substitute some text if the current atom appears as a switch
5876 disjunct_set
= true;
5880 if (atom
&& atom
== end_atom
)
5882 if (!n_way_choice
|| disj_matched
|| *p
== '|'
5883 || a_is_negated
|| a_is_suffix
|| a_is_spectype
5887 /* An empty term may appear as the last choice of an
5888 N-way choice set; it means "otherwise". */
5889 a_must_be_last
= true;
5890 disj_matched
= !n_way_matched
;
5891 disj_starred
= false;
5895 if ((a_is_suffix
|| a_is_spectype
) && a_is_starred
)
5899 disj_starred
= false;
5901 /* Don't bother testing this atom if we already have a
5903 if (!disj_matched
&& !n_way_matched
)
5906 /* a_matched is already set by handle_spec_function. */;
5907 else if (a_is_suffix
)
5908 a_matched
= input_suffix_matches (atom
, end_atom
);
5909 else if (a_is_spectype
)
5910 a_matched
= input_spec_matches (atom
, end_atom
);
5912 a_matched
= switch_matches (atom
, end_atom
, a_is_starred
);
5914 if (a_matched
!= a_is_negated
)
5916 disj_matched
= true;
5918 d_end_atom
= end_atom
;
5925 /* Found the body, that is, the text to substitute if the
5926 current disjunction matches. */
5927 p
= process_brace_body (p
+ 1, d_atom
, d_end_atom
, disj_starred
,
5928 disj_matched
&& !n_way_matched
);
5932 /* If we have an N-way choice, reset state for the next
5936 n_way_choice
= true;
5937 n_way_matched
|= disj_matched
;
5938 disj_matched
= false;
5939 disj_starred
= true;
5940 d_atom
= d_end_atom
= NULL
;
5949 while (*p
++ != '}');
5954 fatal_error ("braced spec %qs is invalid at %qc", orig
, *p
);
5959 /* Subroutine of handle_braces. Scan and process a brace substitution body
5960 (X in the description of %{} syntax). P points one past the colon;
5961 ATOM and END_ATOM bracket the first atom which was found to be true
5962 (present) in the current disjunction; STARRED indicates whether all
5963 the atoms in the current disjunction were starred (for syntax validation);
5964 MATCHED indicates whether the disjunction matched or not, and therefore
5965 whether or not the body is to be processed through do_spec_1 or just
5966 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
5970 process_brace_body (const char *p
, const char *atom
, const char *end_atom
,
5971 int starred
, int matched
)
5973 const char *body
, *end_body
;
5974 unsigned int nesting_level
;
5975 bool have_subst
= false;
5977 /* Locate the closing } or ;, honoring nested braces.
5978 Trim trailing whitespace. */
5987 if (!--nesting_level
)
5990 else if (*p
== ';' && nesting_level
== 1)
5992 else if (*p
== '%' && p
[1] == '*' && nesting_level
== 1)
5994 else if (*p
== '\0')
6000 while (end_body
[-1] == ' ' || end_body
[-1] == '\t')
6003 if (have_subst
&& !starred
)
6008 /* Copy the substitution body to permanent storage and execute it.
6009 If have_subst is false, this is a simple matter of running the
6010 body through do_spec_1... */
6011 char *string
= save_string (body
, end_body
- body
);
6014 if (do_spec_1 (string
, 0, NULL
) < 0)
6019 /* ... but if have_subst is true, we have to process the
6020 body once for each matching switch, with %* set to the
6021 variant part of the switch. */
6022 unsigned int hard_match_len
= end_atom
- atom
;
6025 for (i
= 0; i
< n_switches
; i
++)
6026 if (!strncmp (switches
[i
].part1
, atom
, hard_match_len
)
6027 && check_live_switch (i
, hard_match_len
))
6029 if (do_spec_1 (string
, 0,
6030 &switches
[i
].part1
[hard_match_len
]) < 0)
6032 /* Pass any arguments this switch has. */
6034 suffix_subst
= NULL
;
6042 fatal_error ("braced spec body %qs is invalid", body
);
6045 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
6046 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
6047 spec, or -1 if either exact match or %* is used.
6049 A -O switch is obsoleted by a later -O switch. A -f, -g, -m, or -W switch
6050 whose value does not begin with "no-" is obsoleted by the same value
6051 with the "no-", similarly for a switch with the "no-" prefix. */
6054 check_live_switch (int switchnum
, int prefix_length
)
6056 const char *name
= switches
[switchnum
].part1
;
6059 /* If we already processed this switch and determined if it was
6060 live or not, return our past determination. */
6061 if (switches
[switchnum
].live_cond
!= 0)
6062 return ((switches
[switchnum
].live_cond
& SWITCH_LIVE
) != 0
6063 && (switches
[switchnum
].live_cond
& SWITCH_FALSE
) == 0
6064 && (switches
[switchnum
].live_cond
& SWITCH_IGNORE_PERMANENTLY
)
6067 /* In the common case of {<at-most-one-letter>*}, a negating
6068 switch would always match, so ignore that case. We will just
6069 send the conflicting switches to the compiler phase. */
6070 if (prefix_length
>= 0 && prefix_length
<= 1)
6073 /* Now search for duplicate in a manner that depends on the name. */
6077 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
6078 if (switches
[i
].part1
[0] == 'O')
6080 switches
[switchnum
].validated
= true;
6081 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
6086 case 'W': case 'f': case 'm': case 'g':
6087 if (! strncmp (name
+ 1, "no-", 3))
6089 /* We have Xno-YYY, search for XYYY. */
6090 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
6091 if (switches
[i
].part1
[0] == name
[0]
6092 && ! strcmp (&switches
[i
].part1
[1], &name
[4]))
6094 /* --specs are validated with the validate_switches mechanism. */
6095 if (switches
[switchnum
].known
)
6096 switches
[switchnum
].validated
= true;
6097 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
6103 /* We have XYYY, search for Xno-YYY. */
6104 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
6105 if (switches
[i
].part1
[0] == name
[0]
6106 && switches
[i
].part1
[1] == 'n'
6107 && switches
[i
].part1
[2] == 'o'
6108 && switches
[i
].part1
[3] == '-'
6109 && !strcmp (&switches
[i
].part1
[4], &name
[1]))
6111 /* --specs are validated with the validate_switches mechanism. */
6112 if (switches
[switchnum
].known
)
6113 switches
[switchnum
].validated
= true;
6114 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
6121 /* Otherwise the switch is live. */
6122 switches
[switchnum
].live_cond
|= SWITCH_LIVE
;
6126 /* Pass a switch to the current accumulating command
6127 in the same form that we received it.
6128 SWITCHNUM identifies the switch; it is an index into
6129 the vector of switches gcc received, which is `switches'.
6130 This cannot fail since it never finishes a command line.
6132 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
6135 give_switch (int switchnum
, int omit_first_word
)
6137 if ((switches
[switchnum
].live_cond
& SWITCH_IGNORE
) != 0)
6140 if (!omit_first_word
)
6142 do_spec_1 ("-", 0, NULL
);
6143 do_spec_1 (switches
[switchnum
].part1
, 1, NULL
);
6146 if (switches
[switchnum
].args
!= 0)
6149 for (p
= switches
[switchnum
].args
; *p
; p
++)
6151 const char *arg
= *p
;
6153 do_spec_1 (" ", 0, NULL
);
6156 unsigned length
= strlen (arg
);
6159 while (length
-- && !IS_DIR_SEPARATOR (arg
[length
]))
6160 if (arg
[length
] == '.')
6162 (CONST_CAST (char *, arg
))[length
] = 0;
6166 do_spec_1 (arg
, 1, NULL
);
6168 (CONST_CAST (char *, arg
))[length
] = '.';
6169 do_spec_1 (suffix_subst
, 1, NULL
);
6172 do_spec_1 (arg
, 1, NULL
);
6176 do_spec_1 (" ", 0, NULL
);
6177 switches
[switchnum
].validated
= true;
6180 /* Print GCC configuration (e.g. version, thread model, target,
6181 configuration_arguments) to a given FILE. */
6184 print_configuration (FILE *file
)
6189 fnotice (file
, "Target: %s\n", spec_machine
);
6190 fnotice (file
, "Configured with: %s\n", configuration_arguments
);
6192 #ifdef THREAD_MODEL_SPEC
6193 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
6194 but there's no point in doing all this processing just to get
6195 thread_model back. */
6196 obstack_init (&obstack
);
6197 do_spec_1 (THREAD_MODEL_SPEC
, 0, thread_model
);
6198 obstack_1grow (&obstack
, '\0');
6199 thrmod
= XOBFINISH (&obstack
, const char *);
6201 thrmod
= thread_model
;
6204 fnotice (file
, "Thread model: %s\n", thrmod
);
6206 /* compiler_version is truncated at the first space when initialized
6207 from version string, so truncate version_string at the first space
6208 before comparing. */
6209 for (n
= 0; version_string
[n
]; n
++)
6210 if (version_string
[n
] == ' ')
6213 if (! strncmp (version_string
, compiler_version
, n
)
6214 && compiler_version
[n
] == 0)
6215 fnotice (file
, "gcc version %s %s\n\n", version_string
,
6218 fnotice (file
, "gcc driver version %s %sexecuting gcc version %s\n\n",
6219 version_string
, pkgversion_string
, compiler_version
);
6223 #define RETRY_ICE_ATTEMPTS 3
6225 /* Returns true if FILE1 and FILE2 contain equivalent data, 0 otherwise. */
6228 files_equal_p (char *file1
, char *file2
)
6230 struct stat st1
, st2
;
6233 const int bufsize
= 8192;
6234 char *buf
= XNEWVEC (char, bufsize
);
6236 fd1
= open (file1
, O_RDONLY
);
6237 fd2
= open (file2
, O_RDONLY
);
6239 if (fd1
< 0 || fd2
< 0)
6242 if (fstat (fd1
, &st1
) < 0 || fstat (fd2
, &st2
) < 0)
6245 if (st1
.st_size
!= st2
.st_size
)
6248 for (n
= st1
.st_size
; n
; n
-= len
)
6251 if ((int) len
> bufsize
/ 2)
6254 if (read (fd1
, buf
, len
) != (int) len
6255 || read (fd2
, buf
+ bufsize
/ 2, len
) != (int) len
)
6260 if (memcmp (buf
, buf
+ bufsize
/ 2, len
) != 0)
6277 /* Check that compiler's output doesn't differ across runs.
6278 TEMP_STDOUT_FILES and TEMP_STDERR_FILES are arrays of files, containing
6279 stdout and stderr for each compiler run. Return true if all of
6280 TEMP_STDOUT_FILES and TEMP_STDERR_FILES are equivalent. */
6283 check_repro (char **temp_stdout_files
, char **temp_stderr_files
)
6286 for (i
= 0; i
< RETRY_ICE_ATTEMPTS
- 2; ++i
)
6288 if (!files_equal_p (temp_stdout_files
[i
], temp_stdout_files
[i
+ 1])
6289 || !files_equal_p (temp_stderr_files
[i
], temp_stderr_files
[i
+ 1]))
6291 fnotice (stderr
, "The bug is not reproducible, so it is"
6292 " likely a hardware or OS problem.\n");
6296 return i
== RETRY_ICE_ATTEMPTS
- 2;
6299 enum attempt_status
{
6300 ATTEMPT_STATUS_FAIL_TO_RUN
,
6301 ATTEMPT_STATUS_SUCCESS
,
6306 /* Run compiler with arguments NEW_ARGV to reproduce the ICE, storing stdout
6307 to OUT_TEMP and stderr to ERR_TEMP. If APPEND is TRUE, append to OUT_TEMP
6308 and ERR_TEMP instead of truncating. If EMIT_SYSTEM_INFO is TRUE, also write
6309 GCC configuration into to ERR_TEMP. Return ATTEMPT_STATUS_FAIL_TO_RUN if
6310 compiler failed to run, ATTEMPT_STATUS_ICE if compiled ICE-ed and
6311 ATTEMPT_STATUS_SUCCESS otherwise. */
6313 static enum attempt_status
6314 run_attempt (const char **new_argv
, const char *out_temp
,
6315 const char *err_temp
, int emit_system_info
, int append
)
6318 if (emit_system_info
)
6320 FILE *file_out
= fopen (err_temp
, "a");
6321 print_configuration (file_out
);
6327 struct pex_obj
*pex
;
6329 int pex_flags
= PEX_USE_PIPES
| PEX_LAST
;
6330 enum attempt_status status
= ATTEMPT_STATUS_FAIL_TO_RUN
;
6333 pex_flags
|= PEX_STDOUT_APPEND
| PEX_STDERR_APPEND
;
6335 pex
= pex_init (PEX_USE_PIPES
, new_argv
[0], NULL
);
6337 fatal_error ("pex_init failed: %m");
6339 errmsg
= pex_run (pex
, pex_flags
, new_argv
[0],
6340 CONST_CAST2 (char *const *, const char **, &new_argv
[1]), out_temp
,
6345 fatal_error (errmsg
);
6349 pfatal_with_name (errmsg
);
6353 if (!pex_get_status (pex
, 1, &exit_status
))
6356 switch (WEXITSTATUS (exit_status
))
6359 status
= ATTEMPT_STATUS_ICE
;
6362 case SUCCESS_EXIT_CODE
:
6363 status
= ATTEMPT_STATUS_SUCCESS
;
6375 /* This routine adds preprocessed source code into the given ERR_FILE.
6376 To do this, it adds "-E" to NEW_ARGV and execute RUN_ATTEMPT routine to
6377 add information in report file. RUN_ATTEMPT should return
6378 ATTEMPT_STATUS_SUCCESS, in other case we cannot generate the report. */
6381 do_report_bug (const char **new_argv
, const int nargs
,
6382 char **out_file
, char **err_file
)
6385 int fd
= open (*out_file
, O_RDWR
| O_APPEND
);
6388 write (fd
, "\n//", 3);
6389 for (i
= 0; i
< nargs
; i
++)
6392 write (fd
, new_argv
[i
], strlen (new_argv
[i
]));
6394 write (fd
, "\n\n", 2);
6396 new_argv
[nargs
] = "-E";
6397 new_argv
[nargs
+ 1] = NULL
;
6399 status
= run_attempt (new_argv
, *out_file
, *err_file
, 0, 1);
6401 if (status
== ATTEMPT_STATUS_SUCCESS
)
6403 fnotice (stderr
, "Preprocessed source stored into %s file,"
6404 " please attach this to your bugreport.\n", *out_file
);
6405 /* Make sure it is not deleted. */
6411 /* Append string STR to file FILE. */
6414 append_text (char *file
, const char *str
)
6416 int fd
= open (file
, O_RDWR
| O_APPEND
);
6420 write (fd
, str
, strlen (str
));
6424 /* Try to reproduce ICE. If bug is reproducible, generate report .err file
6425 containing GCC configuration, backtrace, compiler's command line options
6426 and preprocessed source code. */
6429 try_generate_repro (const char **argv
)
6431 int i
, nargs
, out_arg
= -1, quiet
= 0, attempt
;
6432 const char **new_argv
;
6433 char *temp_files
[RETRY_ICE_ATTEMPTS
* 2];
6434 char **temp_stdout_files
= &temp_files
[0];
6435 char **temp_stderr_files
= &temp_files
[RETRY_ICE_ATTEMPTS
];
6437 if (gcc_input_filename
== NULL
|| ! strcmp (gcc_input_filename
, "-"))
6440 for (nargs
= 0; argv
[nargs
] != NULL
; ++nargs
)
6441 /* Only retry compiler ICEs, not preprocessor ones. */
6442 if (! strcmp (argv
[nargs
], "-E"))
6444 else if (argv
[nargs
][0] == '-' && argv
[nargs
][1] == 'o')
6451 /* If the compiler is going to output any time information,
6452 it might varry between invocations. */
6453 else if (! strcmp (argv
[nargs
], "-quiet"))
6455 else if (! strcmp (argv
[nargs
], "-ftime-report"))
6458 if (out_arg
== -1 || !quiet
)
6461 memset (temp_files
, '\0', sizeof (temp_files
));
6462 new_argv
= XALLOCAVEC (const char *, nargs
+ 4);
6463 memcpy (new_argv
, argv
, (nargs
+ 1) * sizeof (const char *));
6464 new_argv
[nargs
++] = "-frandom-seed=0";
6465 new_argv
[nargs
++] = "-fdump-noaddr";
6466 new_argv
[nargs
] = NULL
;
6467 if (new_argv
[out_arg
][2] == '\0')
6468 new_argv
[out_arg
+ 1] = "-";
6470 new_argv
[out_arg
] = "-o-";
6473 for (attempt
= 0; attempt
< RETRY_ICE_ATTEMPTS
; ++attempt
)
6475 int emit_system_info
= 0;
6477 temp_stdout_files
[attempt
] = make_temp_file (".out");
6478 temp_stderr_files
[attempt
] = make_temp_file (".err");
6480 if (attempt
== RETRY_ICE_ATTEMPTS
- 1)
6483 emit_system_info
= 1;
6486 if (emit_system_info
)
6487 append_text (temp_stderr_files
[attempt
], "/*\n");
6489 status
= run_attempt (new_argv
, temp_stdout_files
[attempt
],
6490 temp_stderr_files
[attempt
], emit_system_info
,
6493 if (emit_system_info
)
6494 append_text (temp_stderr_files
[attempt
], "*/\n");
6496 if (status
!= ATTEMPT_STATUS_ICE
)
6498 fnotice (stderr
, "The bug is not reproducible, so it is"
6499 " likely a hardware or OS problem.\n");
6504 if (!check_repro (temp_stdout_files
, temp_stderr_files
))
6507 /* In final attempt we append compiler options and preprocesssed code to last
6508 generated .err file with configuration and backtrace. */
6509 do_report_bug (new_argv
, nargs
,
6510 &temp_stderr_files
[RETRY_ICE_ATTEMPTS
- 1],
6511 &temp_stdout_files
[RETRY_ICE_ATTEMPTS
- 1]);
6514 for (i
= 0; i
< RETRY_ICE_ATTEMPTS
* 2; i
++)
6517 unlink (temp_stdout_files
[i
]);
6518 free (temp_stdout_files
[i
]);
6522 /* Search for a file named NAME trying various prefixes including the
6523 user's -B prefix and some standard ones.
6524 Return the absolute file name found. If nothing is found, return NAME. */
6527 find_file (const char *name
)
6529 char *newname
= find_a_file (&startfile_prefixes
, name
, R_OK
, true);
6530 return newname
? newname
: name
;
6533 /* Determine whether a directory exists. If LINKER, return 0 for
6534 certain fixed names not needed by the linker. */
6537 is_directory (const char *path1
, bool linker
)
6544 /* Ensure the string ends with "/.". The resulting path will be a
6545 directory even if the given path is a symbolic link. */
6546 len1
= strlen (path1
);
6547 path
= (char *) alloca (3 + len1
);
6548 memcpy (path
, path1
, len1
);
6550 if (!IS_DIR_SEPARATOR (cp
[-1]))
6551 *cp
++ = DIR_SEPARATOR
;
6555 /* Exclude directories that the linker is known to search. */
6557 && IS_DIR_SEPARATOR (path
[0])
6559 && filename_ncmp (path
+ 1, "lib", 3) == 0)
6561 && filename_ncmp (path
+ 1, "usr", 3) == 0
6562 && IS_DIR_SEPARATOR (path
[4])
6563 && filename_ncmp (path
+ 5, "lib", 3) == 0)))
6566 return (stat (path
, &st
) >= 0 && S_ISDIR (st
.st_mode
));
6569 /* Set up the various global variables to indicate that we're processing
6570 the input file named FILENAME. */
6573 set_input (const char *filename
)
6577 gcc_input_filename
= filename
;
6578 input_filename_length
= strlen (gcc_input_filename
);
6579 input_basename
= lbasename (gcc_input_filename
);
6581 /* Find a suffix starting with the last period,
6582 and set basename_length to exclude that suffix. */
6583 basename_length
= strlen (input_basename
);
6584 suffixed_basename_length
= basename_length
;
6585 p
= input_basename
+ basename_length
;
6586 while (p
!= input_basename
&& *p
!= '.')
6588 if (*p
== '.' && p
!= input_basename
)
6590 basename_length
= p
- input_basename
;
6591 input_suffix
= p
+ 1;
6596 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
6597 we will need to do a stat on the gcc_input_filename. The
6598 INPUT_STAT_SET signals that the stat is needed. */
6602 /* On fatal signals, delete all the temporary files. */
6605 fatal_signal (int signum
)
6607 signal (signum
, SIG_DFL
);
6608 delete_failure_queue ();
6609 delete_temp_files ();
6610 /* Get the same signal again, this time not handled,
6611 so its normal effect occurs. */
6612 kill (getpid (), signum
);
6615 /* Compare the contents of the two files named CMPFILE[0] and
6616 CMPFILE[1]. Return zero if they're identical, nonzero
6620 compare_files (char *cmpfile
[])
6623 FILE *temp
[2] = { NULL
, NULL
};
6629 void *map
[2] = { NULL
, NULL
};
6631 for (i
= 0; i
< 2; i
++)
6635 if (stat (cmpfile
[i
], &st
) < 0 || !S_ISREG (st
.st_mode
))
6637 error ("%s: could not determine length of compare-debug file %s",
6638 gcc_input_filename
, cmpfile
[i
]);
6643 length
[i
] = st
.st_size
;
6646 if (!ret
&& length
[0] != length
[1])
6648 error ("%s: -fcompare-debug failure (length)", gcc_input_filename
);
6653 for (i
= 0; i
< 2; i
++)
6655 int fd
= open (cmpfile
[i
], O_RDONLY
);
6658 error ("%s: could not open compare-debug file %s",
6659 gcc_input_filename
, cmpfile
[i
]);
6664 map
[i
] = mmap (NULL
, length
[i
], PROT_READ
, MAP_PRIVATE
, fd
, 0);
6667 if (map
[i
] == (void *) MAP_FAILED
)
6676 if (memcmp (map
[0], map
[1], length
[0]) != 0)
6678 error ("%s: -fcompare-debug failure", gcc_input_filename
);
6683 for (i
= 0; i
< 2; i
++)
6685 munmap ((caddr_t
) map
[i
], length
[i
]);
6694 for (i
= 0; i
< 2; i
++)
6696 temp
[i
] = fopen (cmpfile
[i
], "r");
6699 error ("%s: could not open compare-debug file %s",
6700 gcc_input_filename
, cmpfile
[i
]);
6706 if (!ret
&& temp
[0] && temp
[1])
6710 c0
= fgetc (temp
[0]);
6711 c1
= fgetc (temp
[1]);
6715 error ("%s: -fcompare-debug failure",
6716 gcc_input_filename
);
6725 for (i
= 1; i
>= 0; i
--)
6734 /* The top-level "main" within the driver would be ~1000 lines long.
6735 This class breaks it up into smaller functions and contains some
6736 state shared by them. */
6741 int main (int argc
, char **argv
);
6744 void set_progname (const char *argv0
) const;
6745 void expand_at_files (int *argc
, char ***argv
) const;
6746 void decode_argv (int argc
, const char **argv
);
6747 void global_initializations ();
6748 void build_multilib_strings () const;
6749 void set_up_specs () const;
6750 void putenv_COLLECT_GCC (const char *argv0
) const;
6751 void maybe_putenv_COLLECT_LTO_WRAPPER () const;
6752 void handle_unrecognized_options () const;
6753 int maybe_print_and_exit () const;
6754 bool prepare_infiles ();
6755 void do_spec_on_infiles () const;
6756 void maybe_run_linker (const char *argv0
) const;
6757 void final_actions () const;
6758 int get_exit_code () const;
6761 char *explicit_link_files
;
6762 struct cl_decoded_option
*decoded_options
;
6763 unsigned int decoded_options_count
;
6766 /* Implement the top-level "main" within the driver in terms of
6769 extern int main (int, char **);
6772 main (int argc
, char **argv
)
6776 return d
.main (argc
, argv
);
6779 /* driver::main is implemented as a series of driver:: method calls. */
6782 driver::main (int argc
, char **argv
)
6786 set_progname (argv
[0]);
6787 expand_at_files (&argc
, &argv
);
6788 decode_argv (argc
, const_cast <const char **> (argv
));
6789 global_initializations ();
6790 build_multilib_strings ();
6792 putenv_COLLECT_GCC (argv
[0]);
6793 maybe_putenv_COLLECT_LTO_WRAPPER ();
6794 handle_unrecognized_options ();
6796 if (!maybe_print_and_exit ())
6799 early_exit
= prepare_infiles ();
6801 return get_exit_code ();
6803 do_spec_on_infiles ();
6804 maybe_run_linker (argv
[0]);
6806 return get_exit_code ();
6809 /* Locate the final component of argv[0] after any leading path, and set
6810 the program name accordingly. */
6813 driver::set_progname (const char *argv0
) const
6815 const char *p
= argv0
+ strlen (argv0
);
6816 while (p
!= argv0
&& !IS_DIR_SEPARATOR (p
[-1]))
6820 xmalloc_set_program_name (progname
);
6823 /* Expand any @ files within the command-line args,
6824 setting at_file_supplied if any were expanded. */
6827 driver::expand_at_files (int *argc
, char ***argv
) const
6829 char **old_argv
= *argv
;
6831 expandargv (argc
, argv
);
6833 /* Determine if any expansions were made. */
6834 if (*argv
!= old_argv
)
6835 at_file_supplied
= true;
6838 /* Decode the command-line arguments from argc/argv into the
6839 decoded_options array. */
6842 driver::decode_argv (int argc
, const char **argv
)
6844 /* Register the language-independent parameters. */
6845 global_init_params ();
6848 init_options_struct (&global_options
, &global_options_set
);
6850 decode_cmdline_options_to_array (argc
, argv
,
6852 &decoded_options
, &decoded_options_count
);
6855 /* Perform various initializations and setup. */
6858 driver::global_initializations ()
6860 /* Unlock the stdio streams. */
6861 unlock_std_streams ();
6863 gcc_init_libintl ();
6865 diagnostic_initialize (global_dc
, 0);
6867 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6868 /* Perform host dependent initialization when needed. */
6869 GCC_DRIVER_HOST_INITIALIZATION
;
6872 if (atexit (delete_temp_files
) != 0)
6873 fatal_error ("atexit failed");
6875 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
6876 signal (SIGINT
, fatal_signal
);
6878 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
6879 signal (SIGHUP
, fatal_signal
);
6881 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
6882 signal (SIGTERM
, fatal_signal
);
6884 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
6885 signal (SIGPIPE
, fatal_signal
);
6888 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6889 receive the signal. A different setting is inheritable */
6890 signal (SIGCHLD
, SIG_DFL
);
6893 /* Parsing and gimplification sometimes need quite large stack.
6894 Increase stack size limits if possible. */
6895 stack_limit_increase (64 * 1024 * 1024);
6897 /* Allocate the argument vector. */
6900 obstack_init (&obstack
);
6903 /* Build multilib_select, et. al from the separate lines that make up each
6904 multilib selection. */
6907 driver::build_multilib_strings () const
6911 const char *const *q
= multilib_raw
;
6914 obstack_init (&multilib_obstack
);
6915 while ((p
= *q
++) != (char *) 0)
6916 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6918 obstack_1grow (&multilib_obstack
, 0);
6919 multilib_select
= XOBFINISH (&multilib_obstack
, const char *);
6921 q
= multilib_matches_raw
;
6922 while ((p
= *q
++) != (char *) 0)
6923 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6925 obstack_1grow (&multilib_obstack
, 0);
6926 multilib_matches
= XOBFINISH (&multilib_obstack
, const char *);
6928 q
= multilib_exclusions_raw
;
6929 while ((p
= *q
++) != (char *) 0)
6930 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6932 obstack_1grow (&multilib_obstack
, 0);
6933 multilib_exclusions
= XOBFINISH (&multilib_obstack
, const char *);
6935 q
= multilib_reuse_raw
;
6936 while ((p
= *q
++) != (char *) 0)
6937 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6939 obstack_1grow (&multilib_obstack
, 0);
6940 multilib_reuse
= XOBFINISH (&multilib_obstack
, const char *);
6943 for (size_t i
= 0; i
< ARRAY_SIZE (multilib_defaults_raw
); i
++)
6946 obstack_1grow (&multilib_obstack
, ' ');
6947 obstack_grow (&multilib_obstack
,
6948 multilib_defaults_raw
[i
],
6949 strlen (multilib_defaults_raw
[i
]));
6953 obstack_1grow (&multilib_obstack
, 0);
6954 multilib_defaults
= XOBFINISH (&multilib_obstack
, const char *);
6958 /* Set up the spec-handling machinery. */
6961 driver::set_up_specs () const
6966 #ifdef INIT_ENVIRONMENT
6967 /* Set up any other necessary machine specific environment variables. */
6968 xputenv (INIT_ENVIRONMENT
);
6971 /* Make a table of what switches there are (switches, n_switches).
6972 Make a table of specified input files (infiles, n_infiles).
6973 Decode switches that are handled locally. */
6975 process_command (decoded_options_count
, decoded_options
);
6977 /* Initialize the vector of specs to just the default.
6978 This means one element containing 0s, as a terminator. */
6980 compilers
= XNEWVAR (struct compiler
, sizeof default_compilers
);
6981 memcpy (compilers
, default_compilers
, sizeof default_compilers
);
6982 n_compilers
= n_default_compilers
;
6984 /* Read specs from a file if there is one. */
6986 machine_suffix
= concat (spec_machine
, dir_separator_str
,
6987 spec_version
, dir_separator_str
, NULL
);
6988 just_machine_suffix
= concat (spec_machine
, dir_separator_str
, NULL
);
6990 specs_file
= find_a_file (&startfile_prefixes
, "specs", R_OK
, true);
6991 /* Read the specs file unless it is a default one. */
6992 if (specs_file
!= 0 && strcmp (specs_file
, "specs"))
6993 read_specs (specs_file
, true, false);
6997 /* We need to check standard_exec_prefix/just_machine_suffix/specs
6998 for any override of as, ld and libraries. */
6999 specs_file
= (char *) alloca (strlen (standard_exec_prefix
)
7000 + strlen (just_machine_suffix
) + sizeof ("specs"));
7002 strcpy (specs_file
, standard_exec_prefix
);
7003 strcat (specs_file
, just_machine_suffix
);
7004 strcat (specs_file
, "specs");
7005 if (access (specs_file
, R_OK
) == 0)
7006 read_specs (specs_file
, true, false);
7008 /* Process any configure-time defaults specified for the command line
7009 options, via OPTION_DEFAULT_SPECS. */
7010 for (i
= 0; i
< ARRAY_SIZE (option_default_specs
); i
++)
7011 do_option_spec (option_default_specs
[i
].name
,
7012 option_default_specs
[i
].spec
);
7014 /* Process DRIVER_SELF_SPECS, adding any new options to the end
7015 of the command line. */
7017 for (i
= 0; i
< ARRAY_SIZE (driver_self_specs
); i
++)
7018 do_self_spec (driver_self_specs
[i
]);
7020 /* If not cross-compiling, look for executables in the standard
7022 if (*cross_compile
== '0')
7024 if (*md_exec_prefix
)
7026 add_prefix (&exec_prefixes
, md_exec_prefix
, "GCC",
7027 PREFIX_PRIORITY_LAST
, 0, 0);
7031 /* Process sysroot_suffix_spec. */
7032 if (*sysroot_suffix_spec
!= 0
7033 && !no_sysroot_suffix
7034 && do_spec_2 (sysroot_suffix_spec
) == 0)
7036 if (argbuf
.length () > 1)
7037 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
7038 else if (argbuf
.length () == 1)
7039 target_sysroot_suffix
= xstrdup (argbuf
.last ());
7042 #ifdef HAVE_LD_SYSROOT
7043 /* Pass the --sysroot option to the linker, if it supports that. If
7044 there is a sysroot_suffix_spec, it has already been processed by
7045 this point, so target_system_root really is the system root we
7047 if (target_system_root
)
7049 obstack_grow (&obstack
, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
7050 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
7051 set_spec ("link", XOBFINISH (&obstack
, const char *), false);
7055 /* Process sysroot_hdrs_suffix_spec. */
7056 if (*sysroot_hdrs_suffix_spec
!= 0
7057 && !no_sysroot_suffix
7058 && do_spec_2 (sysroot_hdrs_suffix_spec
) == 0)
7060 if (argbuf
.length () > 1)
7061 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
7062 else if (argbuf
.length () == 1)
7063 target_sysroot_hdrs_suffix
= xstrdup (argbuf
.last ());
7066 /* Look for startfiles in the standard places. */
7067 if (*startfile_prefix_spec
!= 0
7068 && do_spec_2 (startfile_prefix_spec
) == 0
7069 && do_spec_1 (" ", 0, NULL
) == 0)
7073 FOR_EACH_VEC_ELT (argbuf
, ndx
, arg
)
7074 add_sysrooted_prefix (&startfile_prefixes
, arg
, "BINUTILS",
7075 PREFIX_PRIORITY_LAST
, 0, 1);
7077 /* We should eventually get rid of all these and stick to
7078 startfile_prefix_spec exclusively. */
7079 else if (*cross_compile
== '0' || target_system_root
)
7081 if (*md_startfile_prefix
)
7082 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix
,
7083 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
7085 if (*md_startfile_prefix_1
)
7086 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix_1
,
7087 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
7089 /* If standard_startfile_prefix is relative, base it on
7090 standard_exec_prefix. This lets us move the installed tree
7091 as a unit. If GCC_EXEC_PREFIX is defined, base
7092 standard_startfile_prefix on that as well.
7094 If the prefix is relative, only search it for native compilers;
7095 otherwise we will search a directory containing host libraries. */
7096 if (IS_ABSOLUTE_PATH (standard_startfile_prefix
))
7097 add_sysrooted_prefix (&startfile_prefixes
,
7098 standard_startfile_prefix
, "BINUTILS",
7099 PREFIX_PRIORITY_LAST
, 0, 1);
7100 else if (*cross_compile
== '0')
7102 add_prefix (&startfile_prefixes
,
7103 concat (gcc_exec_prefix
7104 ? gcc_exec_prefix
: standard_exec_prefix
,
7106 standard_startfile_prefix
, NULL
),
7107 NULL
, PREFIX_PRIORITY_LAST
, 0, 1);
7110 /* Sysrooted prefixes are relocated because target_system_root is
7111 also relocated by gcc_exec_prefix. */
7112 if (*standard_startfile_prefix_1
)
7113 add_sysrooted_prefix (&startfile_prefixes
,
7114 standard_startfile_prefix_1
, "BINUTILS",
7115 PREFIX_PRIORITY_LAST
, 0, 1);
7116 if (*standard_startfile_prefix_2
)
7117 add_sysrooted_prefix (&startfile_prefixes
,
7118 standard_startfile_prefix_2
, "BINUTILS",
7119 PREFIX_PRIORITY_LAST
, 0, 1);
7122 /* Process any user specified specs in the order given on the command
7124 for (struct user_specs
*uptr
= user_specs_head
; uptr
; uptr
= uptr
->next
)
7126 char *filename
= find_a_file (&startfile_prefixes
, uptr
->filename
,
7128 read_specs (filename
? filename
: uptr
->filename
, false, true);
7131 /* Process any user self specs. */
7133 struct spec_list
*sl
;
7134 for (sl
= specs
; sl
; sl
= sl
->next
)
7135 if (sl
->name_len
== sizeof "self_spec" - 1
7136 && !strcmp (sl
->name
, "self_spec"))
7137 do_self_spec (*sl
->ptr_spec
);
7142 enum save_temps save
;
7144 if (!compare_debug_second
)
7146 n_switches_debug_check
[1] = n_switches
;
7147 n_switches_alloc_debug_check
[1] = n_switches_alloc
;
7148 switches_debug_check
[1] = XDUPVEC (struct switchstr
, switches
,
7151 do_self_spec ("%:compare-debug-self-opt()");
7152 n_switches_debug_check
[0] = n_switches
;
7153 n_switches_alloc_debug_check
[0] = n_switches_alloc
;
7154 switches_debug_check
[0] = switches
;
7156 n_switches
= n_switches_debug_check
[1];
7157 n_switches_alloc
= n_switches_alloc_debug_check
[1];
7158 switches
= switches_debug_check
[1];
7161 /* Avoid crash when computing %j in this early. */
7162 save
= save_temps_flag
;
7163 save_temps_flag
= SAVE_TEMPS_NONE
;
7165 compare_debug
= -compare_debug
;
7166 do_self_spec ("%:compare-debug-self-opt()");
7168 save_temps_flag
= save
;
7170 if (!compare_debug_second
)
7172 n_switches_debug_check
[1] = n_switches
;
7173 n_switches_alloc_debug_check
[1] = n_switches_alloc
;
7174 switches_debug_check
[1] = switches
;
7175 compare_debug
= -compare_debug
;
7176 n_switches
= n_switches_debug_check
[0];
7177 n_switches_alloc
= n_switches_debug_check
[0];
7178 switches
= switches_debug_check
[0];
7183 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
7184 if (gcc_exec_prefix
)
7185 gcc_exec_prefix
= concat (gcc_exec_prefix
, spec_machine
, dir_separator_str
,
7186 spec_version
, dir_separator_str
, NULL
);
7188 /* Now we have the specs.
7189 Set the `valid' bits for switches that match anything in any spec. */
7191 validate_all_switches ();
7193 /* Now that we have the switches and the specs, set
7194 the subdirectory based on the options. */
7195 set_multilib_dir ();
7198 /* Set up to remember the pathname of gcc and any options
7199 needed for collect. We use argv[0] instead of progname because
7200 we need the complete pathname. */
7203 driver::putenv_COLLECT_GCC (const char *argv0
) const
7205 obstack_init (&collect_obstack
);
7206 obstack_grow (&collect_obstack
, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
7207 obstack_grow (&collect_obstack
, argv0
, strlen (argv0
) + 1);
7208 xputenv (XOBFINISH (&collect_obstack
, char *));
7211 /* Set up to remember the pathname of the lto wrapper. */
7214 driver::maybe_putenv_COLLECT_LTO_WRAPPER () const
7216 char *lto_wrapper_file
;
7219 lto_wrapper_file
= NULL
;
7221 lto_wrapper_file
= find_a_file (&exec_prefixes
, "lto-wrapper",
7223 if (lto_wrapper_file
)
7225 lto_wrapper_file
= convert_white_space (lto_wrapper_file
);
7226 lto_wrapper_spec
= lto_wrapper_file
;
7227 obstack_init (&collect_obstack
);
7228 obstack_grow (&collect_obstack
, "COLLECT_LTO_WRAPPER=",
7229 sizeof ("COLLECT_LTO_WRAPPER=") - 1);
7230 obstack_grow (&collect_obstack
, lto_wrapper_spec
,
7231 strlen (lto_wrapper_spec
) + 1);
7232 xputenv (XOBFINISH (&collect_obstack
, char *));
7237 /* Reject switches that no pass was interested in. */
7240 driver::handle_unrecognized_options () const
7242 for (size_t i
= 0; (int) i
< n_switches
; i
++)
7243 if (! switches
[i
].validated
)
7244 error ("unrecognized command line option %<-%s%>", switches
[i
].part1
);
7247 /* Handle the various -print-* options, returning 0 if the driver
7248 should exit, or nonzero if the driver should continue. */
7251 driver::maybe_print_and_exit () const
7253 if (print_search_dirs
)
7255 printf (_("install: %s%s\n"),
7256 gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
7257 gcc_exec_prefix
? "" : machine_suffix
);
7258 printf (_("programs: %s\n"),
7259 build_search_list (&exec_prefixes
, "", false, false));
7260 printf (_("libraries: %s\n"),
7261 build_search_list (&startfile_prefixes
, "", false, true));
7265 if (print_file_name
)
7267 printf ("%s\n", find_file (print_file_name
));
7271 if (print_prog_name
)
7273 if (use_ld
!= NULL
&& ! strcmp (print_prog_name
, "ld"))
7275 /* Append USE_LD to to the default linker. */
7276 #ifdef DEFAULT_LINKER
7278 # ifdef HAVE_HOST_EXECUTABLE_SUFFIX
7279 int len
= (sizeof (DEFAULT_LINKER
)
7280 - sizeof (HOST_EXECUTABLE_SUFFIX
));
7284 char *default_linker
= xstrdup (DEFAULT_LINKER
);
7285 /* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains
7286 HOST_EXECUTABLE_SUFFIX. */
7287 if (! strcmp (&default_linker
[len
], HOST_EXECUTABLE_SUFFIX
))
7289 default_linker
[len
] = '\0';
7290 ld
= concat (default_linker
, use_ld
,
7291 HOST_EXECUTABLE_SUFFIX
, NULL
);
7296 ld
= concat (DEFAULT_LINKER
, use_ld
, NULL
);
7297 if (access (ld
, X_OK
) == 0)
7299 printf ("%s\n", ld
);
7303 print_prog_name
= concat (print_prog_name
, use_ld
, NULL
);
7305 char *newname
= find_a_file (&exec_prefixes
, print_prog_name
, X_OK
, 0);
7306 printf ("%s\n", (newname
? newname
: print_prog_name
));
7310 if (print_multi_lib
)
7312 print_multilib_info ();
7316 if (print_multi_directory
)
7318 if (multilib_dir
== NULL
)
7321 printf ("%s\n", multilib_dir
);
7325 if (print_multiarch
)
7327 if (multiarch_dir
== NULL
)
7330 printf ("%s\n", multiarch_dir
);
7336 if (target_system_root
)
7338 if (target_sysroot_suffix
)
7339 printf ("%s%s\n", target_system_root
, target_sysroot_suffix
);
7341 printf ("%s\n", target_system_root
);
7346 if (print_multi_os_directory
)
7348 if (multilib_os_dir
== NULL
)
7351 printf ("%s\n", multilib_os_dir
);
7355 if (print_sysroot_headers_suffix
)
7357 if (*sysroot_hdrs_suffix_spec
)
7359 printf("%s\n", (target_sysroot_hdrs_suffix
7360 ? target_sysroot_hdrs_suffix
7365 /* The error status indicates that only one set of fixed
7366 headers should be built. */
7367 fatal_error ("not configured with sysroot headers suffix");
7370 if (print_help_list
)
7376 printf (_("\nFor bug reporting instructions, please see:\n"));
7377 printf ("%s.\n", bug_report_url
);
7382 /* We do not exit here. Instead we have created a fake input file
7383 called 'help-dummy' which needs to be compiled, and we pass this
7384 on the various sub-processes, along with the --help switch.
7385 Ensure their output appears after ours. */
7386 fputc ('\n', stdout
);
7392 printf (_("%s %s%s\n"), progname
, pkgversion_string
,
7394 printf ("Copyright %s 2014 Free Software Foundation, Inc.\n",
7396 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
7397 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
7402 /* We do not exit here. We use the same mechanism of --help to print
7403 the version of the sub-processes. */
7404 fputc ('\n', stdout
);
7410 print_configuration (stderr
);
7418 /* Figure out what to do with each input file.
7419 Return true if we need to exit early from "main", false otherwise. */
7422 driver::prepare_infiles ()
7425 int lang_n_infiles
= 0;
7427 if (n_infiles
== added_libraries
)
7428 fatal_error ("no input files");
7431 /* Early exit needed from main. */
7434 /* Make a place to record the compiler output file names
7435 that correspond to the input files. */
7438 i
+= lang_specific_extra_outfiles
;
7439 outfiles
= XCNEWVEC (const char *, i
);
7441 /* Record which files were specified explicitly as link input. */
7443 explicit_link_files
= XCNEWVEC (char, n_infiles
);
7445 combine_inputs
= have_o
|| flag_wpa
;
7447 for (i
= 0; (int) i
< n_infiles
; i
++)
7449 const char *name
= infiles
[i
].name
;
7450 struct compiler
*compiler
= lookup_compiler (name
,
7452 infiles
[i
].language
);
7454 if (compiler
&& !(compiler
->combinable
))
7455 combine_inputs
= false;
7457 if (lang_n_infiles
> 0 && compiler
!= input_file_compiler
7458 && infiles
[i
].language
&& infiles
[i
].language
[0] != '*')
7459 infiles
[i
].incompiler
= compiler
;
7463 input_file_compiler
= compiler
;
7464 infiles
[i
].incompiler
= compiler
;
7468 /* Since there is no compiler for this input file, assume it is a
7470 explicit_link_files
[i
] = 1;
7471 infiles
[i
].incompiler
= NULL
;
7473 infiles
[i
].compiled
= false;
7474 infiles
[i
].preprocessed
= false;
7477 if (!combine_inputs
&& have_c
&& have_o
&& lang_n_infiles
> 1)
7478 fatal_error ("cannot specify -o with -c, -S or -E with multiple files");
7480 /* No early exit needed from main; we can continue. */
7484 /* Run the spec machinery on each input file. */
7487 driver::do_spec_on_infiles () const
7491 for (i
= 0; (int) i
< n_infiles
; i
++)
7493 int this_file_error
= 0;
7495 /* Tell do_spec what to substitute for %i. */
7497 input_file_number
= i
;
7498 set_input (infiles
[i
].name
);
7500 if (infiles
[i
].compiled
)
7503 /* Use the same thing in %o, unless cp->spec says otherwise. */
7505 outfiles
[i
] = gcc_input_filename
;
7507 /* Figure out which compiler from the file's suffix. */
7510 = lookup_compiler (infiles
[i
].name
, input_filename_length
,
7511 infiles
[i
].language
);
7513 if (input_file_compiler
)
7515 /* Ok, we found an applicable compiler. Run its spec. */
7517 if (input_file_compiler
->spec
[0] == '#')
7519 error ("%s: %s compiler not installed on this system",
7520 gcc_input_filename
, &input_file_compiler
->spec
[1]);
7521 this_file_error
= 1;
7529 free (debug_check_temp_file
[0]);
7530 debug_check_temp_file
[0] = NULL
;
7532 free (debug_check_temp_file
[1]);
7533 debug_check_temp_file
[1] = NULL
;
7536 value
= do_spec (input_file_compiler
->spec
);
7537 infiles
[i
].compiled
= true;
7539 this_file_error
= 1;
7540 else if (compare_debug
&& debug_check_temp_file
[0])
7543 inform (0, "recompiling with -fcompare-debug");
7545 compare_debug
= -compare_debug
;
7546 n_switches
= n_switches_debug_check
[1];
7547 n_switches_alloc
= n_switches_alloc_debug_check
[1];
7548 switches
= switches_debug_check
[1];
7550 value
= do_spec (input_file_compiler
->spec
);
7552 compare_debug
= -compare_debug
;
7553 n_switches
= n_switches_debug_check
[0];
7554 n_switches_alloc
= n_switches_alloc_debug_check
[0];
7555 switches
= switches_debug_check
[0];
7559 error ("during -fcompare-debug recompilation");
7560 this_file_error
= 1;
7563 gcc_assert (debug_check_temp_file
[1]
7564 && filename_cmp (debug_check_temp_file
[0],
7565 debug_check_temp_file
[1]));
7568 inform (0, "comparing final insns dumps");
7570 if (compare_files (debug_check_temp_file
))
7571 this_file_error
= 1;
7576 free (debug_check_temp_file
[0]);
7577 debug_check_temp_file
[0] = NULL
;
7579 free (debug_check_temp_file
[1]);
7580 debug_check_temp_file
[1] = NULL
;
7585 /* If this file's name does not contain a recognized suffix,
7586 record it as explicit linker input. */
7589 explicit_link_files
[i
] = 1;
7591 /* Clear the delete-on-failure queue, deleting the files in it
7592 if this compilation failed. */
7594 if (this_file_error
)
7596 delete_failure_queue ();
7599 /* If this compilation succeeded, don't delete those files later. */
7600 clear_failure_queue ();
7603 /* Reset the input file name to the first compile/object file name, for use
7604 with %b in LINK_SPEC. We use the first input file that we can find
7605 a compiler to compile it instead of using infiles.language since for
7606 languages other than C we use aliases that we then lookup later. */
7611 for (i
= 0; i
< n_infiles
; i
++)
7612 if (infiles
[i
].incompiler
7613 || (infiles
[i
].language
&& infiles
[i
].language
[0] != '*'))
7615 set_input (infiles
[i
].name
);
7622 /* Make sure INPUT_FILE_NUMBER points to first available open
7624 input_file_number
= n_infiles
;
7625 if (lang_specific_pre_link ())
7630 /* If we have to run the linker, do it now. */
7633 driver::maybe_run_linker (const char *argv0
) const
7636 int linker_was_run
= 0;
7637 int num_linker_inputs
;
7639 /* Determine if there are any linker input files. */
7640 num_linker_inputs
= 0;
7641 for (i
= 0; (int) i
< n_infiles
; i
++)
7642 if (explicit_link_files
[i
] || outfiles
[i
] != NULL
)
7643 num_linker_inputs
++;
7645 /* Run ld to link all the compiler output files. */
7647 if (num_linker_inputs
> 0 && !seen_error () && print_subprocess_help
< 2)
7649 int tmp
= execution_count
;
7653 #if HAVE_LTO_PLUGIN > 0
7654 #if HAVE_LTO_PLUGIN == 2
7655 const char *fno_use_linker_plugin
= "fno-use-linker-plugin";
7657 const char *fuse_linker_plugin
= "fuse-linker-plugin";
7661 /* We'll use ld if we can't find collect2. */
7662 if (! strcmp (linker_name_spec
, "collect2"))
7664 char *s
= find_a_file (&exec_prefixes
, "collect2", X_OK
, false);
7666 linker_name_spec
= "ld";
7669 #if HAVE_LTO_PLUGIN > 0
7670 #if HAVE_LTO_PLUGIN == 2
7671 if (!switch_matches (fno_use_linker_plugin
,
7672 fno_use_linker_plugin
7673 + strlen (fno_use_linker_plugin
), 0))
7675 if (switch_matches (fuse_linker_plugin
,
7677 + strlen (fuse_linker_plugin
), 0))
7680 char *temp_spec
= find_a_file (&exec_prefixes
,
7681 LTOPLUGINSONAME
, R_OK
,
7684 fatal_error ("-fuse-linker-plugin, but %s not found",
7686 linker_plugin_file_spec
= convert_white_space (temp_spec
);
7689 lto_gcc_spec
= argv0
;
7692 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
7694 putenv_from_prefixes (&exec_prefixes
, "COMPILER_PATH", false);
7695 putenv_from_prefixes (&startfile_prefixes
, LIBRARY_PATH_ENV
, true);
7697 if (print_subprocess_help
== 1)
7699 printf (_("\nLinker options\n==============\n\n"));
7700 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
7701 " to the linker.\n\n"));
7704 int value
= do_spec (link_command_spec
);
7707 linker_was_run
= (tmp
!= execution_count
);
7710 /* If options said don't run linker,
7711 complain about input files to be given to the linker. */
7713 if (! linker_was_run
&& !seen_error ())
7714 for (i
= 0; (int) i
< n_infiles
; i
++)
7715 if (explicit_link_files
[i
]
7716 && !(infiles
[i
].language
&& infiles
[i
].language
[0] == '*'))
7717 warning (0, "%s: linker input file unused because linking not done",
7721 /* The end of "main". */
7724 driver::final_actions () const
7726 /* Delete some or all of the temporary files we made. */
7729 delete_failure_queue ();
7730 delete_temp_files ();
7732 if (print_help_list
)
7734 printf (("\nFor bug reporting instructions, please see:\n"));
7735 printf ("%s\n", bug_report_url
);
7739 /* Determine what the exit code of the driver should be. */
7742 driver::get_exit_code () const
7744 return (signal_count
!= 0 ? 2
7745 : seen_error () ? (pass_exit_codes
? greatest_status
: 1)
7749 /* Find the proper compilation spec for the file name NAME,
7750 whose length is LENGTH. LANGUAGE is the specified language,
7751 or 0 if this file is to be passed to the linker. */
7753 static struct compiler
*
7754 lookup_compiler (const char *name
, size_t length
, const char *language
)
7756 struct compiler
*cp
;
7758 /* If this was specified by the user to be a linker input, indicate that. */
7759 if (language
!= 0 && language
[0] == '*')
7762 /* Otherwise, look for the language, if one is spec'd. */
7765 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
7766 if (cp
->suffix
[0] == '@' && !strcmp (cp
->suffix
+ 1, language
))
7769 error ("language %s not recognized", language
);
7773 /* Look for a suffix. */
7774 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
7776 if (/* The suffix `-' matches only the file name `-'. */
7777 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
7778 || (strlen (cp
->suffix
) < length
7779 /* See if the suffix matches the end of NAME. */
7780 && !strcmp (cp
->suffix
,
7781 name
+ length
- strlen (cp
->suffix
))
7786 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
7787 /* Look again, but case-insensitively this time. */
7789 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
7791 if (/* The suffix `-' matches only the file name `-'. */
7792 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
7793 || (strlen (cp
->suffix
) < length
7794 /* See if the suffix matches the end of NAME. */
7795 && ((!strcmp (cp
->suffix
,
7796 name
+ length
- strlen (cp
->suffix
))
7797 || !strpbrk (cp
->suffix
, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
7798 && !strcasecmp (cp
->suffix
,
7799 name
+ length
- strlen (cp
->suffix
)))
7805 if (cp
>= compilers
)
7807 if (cp
->spec
[0] != '@')
7808 /* A non-alias entry: return it. */
7811 /* An alias entry maps a suffix to a language.
7812 Search for the language; pass 0 for NAME and LENGTH
7813 to avoid infinite recursion if language not found. */
7814 return lookup_compiler (NULL
, 0, cp
->spec
+ 1);
7820 save_string (const char *s
, int len
)
7822 char *result
= XNEWVEC (char, len
+ 1);
7824 memcpy (result
, s
, len
);
7830 pfatal_with_name (const char *name
)
7832 perror_with_name (name
);
7833 delete_temp_files ();
7838 perror_with_name (const char *name
)
7840 error ("%s: %m", name
);
7844 validate_switches_from_spec (const char *spec
, bool user
)
7846 const char *p
= spec
;
7849 if (c
== '%' && (*p
== '{' || *p
== '<' || (*p
== 'W' && *++p
== '{')))
7850 /* We have a switch spec. */
7851 p
= validate_switches (p
+ 1, user
);
7855 validate_all_switches (void)
7857 struct compiler
*comp
;
7858 struct spec_list
*spec
;
7860 for (comp
= compilers
; comp
->spec
; comp
++)
7861 validate_switches_from_spec (comp
->spec
, false);
7863 /* Look through the linked list of specs read from the specs file. */
7864 for (spec
= specs
; spec
; spec
= spec
->next
)
7865 validate_switches_from_spec (*spec
->ptr_spec
, spec
->user_p
);
7867 validate_switches_from_spec (link_command_spec
, false);
7870 /* Look at the switch-name that comes after START
7871 and mark as valid all supplied switches that match it. */
7874 validate_switches (const char *start
, bool user_spec
)
7876 const char *p
= start
;
7880 bool suffix
= false;
7881 bool starred
= false;
7883 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7892 if (*p
== '.' || *p
== ',')
7896 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
7897 || *p
== ',' || *p
== '.' || *p
== '@')
7902 starred
= true, p
++;
7908 /* Mark all matching switches as valid. */
7909 for (i
= 0; i
< n_switches
; i
++)
7910 if (!strncmp (switches
[i
].part1
, atom
, len
)
7911 && (starred
|| switches
[i
].part1
[len
] == '\0')
7912 && (switches
[i
].known
|| user_spec
))
7913 switches
[i
].validated
= true;
7917 if (*p
&& (p
[-1] == '|' || p
[-1] == '&'))
7920 if (*p
&& p
[-1] == ':')
7922 while (*p
&& *p
!= ';' && *p
!= '}')
7927 if (*p
== '{' || *p
== '<')
7928 p
= validate_switches (p
+1, user_spec
);
7929 else if (p
[0] == 'W' && p
[1] == '{')
7930 p
= validate_switches (p
+2, user_spec
);
7937 if (*p
&& p
[-1] == ';')
7951 static struct mdswitchstr
*mdswitches
;
7952 static int n_mdswitches
;
7954 /* Check whether a particular argument was used. The first time we
7955 canonicalize the switches to keep only the ones we care about. */
7958 used_arg (const char *p
, int len
)
7963 const char *replace
;
7968 static struct mswitchstr
*mswitches
;
7969 static int n_mswitches
;
7974 struct mswitchstr
*matches
;
7978 /* Break multilib_matches into the component strings of string
7979 and replacement string. */
7980 for (q
= multilib_matches
; *q
!= '\0'; q
++)
7985 = (struct mswitchstr
*) alloca ((sizeof (struct mswitchstr
)) * cnt
);
7987 q
= multilib_matches
;
7996 fatal_error ("multilib spec %qs is invalid",
8001 matches
[i
].len
= q
- matches
[i
].str
;
8003 matches
[i
].replace
= ++q
;
8004 while (*q
!= ';' && *q
!= '\0')
8007 goto invalid_matches
;
8010 matches
[i
].rep_len
= q
- matches
[i
].replace
;
8016 /* Now build a list of the replacement string for switches that we care
8017 about. Make sure we allocate at least one entry. This prevents
8018 xmalloc from calling fatal, and prevents us from re-executing this
8021 = XNEWVEC (struct mswitchstr
, n_mdswitches
+ (n_switches
? n_switches
: 1));
8022 for (i
= 0; i
< n_switches
; i
++)
8023 if ((switches
[i
].live_cond
& SWITCH_IGNORE
) == 0)
8025 int xlen
= strlen (switches
[i
].part1
);
8026 for (j
= 0; j
< cnt
; j
++)
8027 if (xlen
== matches
[j
].len
8028 && ! strncmp (switches
[i
].part1
, matches
[j
].str
, xlen
))
8030 mswitches
[n_mswitches
].str
= matches
[j
].replace
;
8031 mswitches
[n_mswitches
].len
= matches
[j
].rep_len
;
8032 mswitches
[n_mswitches
].replace
= (char *) 0;
8033 mswitches
[n_mswitches
].rep_len
= 0;
8039 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
8040 on the command line nor any options mutually incompatible with
8042 for (i
= 0; i
< n_mdswitches
; i
++)
8046 for (q
= multilib_options
; *q
!= '\0'; *q
&& q
++)
8052 while (strncmp (q
, mdswitches
[i
].str
, mdswitches
[i
].len
) != 0
8053 || strchr (" /", q
[mdswitches
[i
].len
]) == NULL
)
8055 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
8062 if (*q
!= ' ' && *q
!= '\0')
8064 while (*r
!= ' ' && *r
!= '\0')
8067 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
8070 if (used_arg (r
, q
- r
))
8075 mswitches
[n_mswitches
].str
= mdswitches
[i
].str
;
8076 mswitches
[n_mswitches
].len
= mdswitches
[i
].len
;
8077 mswitches
[n_mswitches
].replace
= (char *) 0;
8078 mswitches
[n_mswitches
].rep_len
= 0;
8091 for (i
= 0; i
< n_mswitches
; i
++)
8092 if (len
== mswitches
[i
].len
&& ! strncmp (p
, mswitches
[i
].str
, len
))
8099 default_arg (const char *p
, int len
)
8103 for (i
= 0; i
< n_mdswitches
; i
++)
8104 if (len
== mdswitches
[i
].len
&& ! strncmp (p
, mdswitches
[i
].str
, len
))
8110 /* Work out the subdirectory to use based on the options. The format of
8111 multilib_select is a list of elements. Each element is a subdirectory
8112 name followed by a list of options followed by a semicolon. The format
8113 of multilib_exclusions is the same, but without the preceding
8114 directory. First gcc will check the exclusions, if none of the options
8115 beginning with an exclamation point are present, and all of the other
8116 options are present, then we will ignore this completely. Passing
8117 that, gcc will consider each multilib_select in turn using the same
8118 rules for matching the options. If a match is found, that subdirectory
8120 A subdirectory name is optionally followed by a colon and the corresponding
8124 set_multilib_dir (void)
8127 unsigned int this_path_len
;
8128 const char *this_path
, *this_arg
;
8129 const char *start
, *end
;
8131 int ok
, ndfltok
, first
;
8134 start
= multilib_defaults
;
8135 while (*start
== ' ' || *start
== '\t')
8137 while (*start
!= '\0')
8140 while (*start
!= ' ' && *start
!= '\t' && *start
!= '\0')
8142 while (*start
== ' ' || *start
== '\t')
8150 mdswitches
= XNEWVEC (struct mdswitchstr
, n_mdswitches
);
8151 for (start
= multilib_defaults
; *start
!= '\0'; start
= end
+ 1)
8153 while (*start
== ' ' || *start
== '\t')
8159 for (end
= start
+ 1;
8160 *end
!= ' ' && *end
!= '\t' && *end
!= '\0'; end
++)
8163 obstack_grow (&multilib_obstack
, start
, end
- start
);
8164 obstack_1grow (&multilib_obstack
, 0);
8165 mdswitches
[i
].str
= XOBFINISH (&multilib_obstack
, const char *);
8166 mdswitches
[i
++].len
= end
- start
;
8173 p
= multilib_exclusions
;
8176 /* Ignore newlines. */
8183 /* Check the arguments. */
8190 fatal_error ("multilib exclusions %qs is invalid",
8191 multilib_exclusions
);
8201 while (*p
!= ' ' && *p
!= ';')
8204 goto invalid_exclusions
;
8208 if (*this_arg
!= '!')
8216 ok
= used_arg (this_arg
, p
- this_arg
);
8231 p
= multilib_select
;
8233 /* Append multilib reuse rules if any. With those rules, we can reuse
8234 one multilib for certain different options sets. */
8235 if (strlen (multilib_reuse
) > 0)
8236 p
= concat (p
, multilib_reuse
, NULL
);
8240 /* Ignore newlines. */
8247 /* Get the initial path. */
8254 fatal_error ("multilib select %qs %qs is invalid",
8255 multilib_select
, multilib_reuse
);
8259 this_path_len
= p
- this_path
;
8261 /* Check the arguments. */
8268 goto invalid_select
;
8277 while (*p
!= ' ' && *p
!= ';')
8280 goto invalid_select
;
8284 if (*this_arg
!= '!')
8292 /* If this is a default argument, we can just ignore it.
8293 This is true even if this_arg begins with '!'. Beginning
8294 with '!' does not mean that this argument is necessarily
8295 inappropriate for this library: it merely means that
8296 there is a more specific library which uses this
8297 argument. If this argument is a default, we need not
8298 consider that more specific library. */
8299 ok
= used_arg (this_arg
, p
- this_arg
);
8306 if (default_arg (this_arg
, p
- this_arg
))
8315 if (this_path_len
!= 1
8316 || this_path
[0] != '.')
8318 char *new_multilib_dir
= XNEWVEC (char, this_path_len
+ 1);
8321 strncpy (new_multilib_dir
, this_path
, this_path_len
);
8322 new_multilib_dir
[this_path_len
] = '\0';
8323 q
= strchr (new_multilib_dir
, ':');
8326 multilib_dir
= new_multilib_dir
;
8333 const char *q
= this_path
, *end
= this_path
+ this_path_len
;
8335 while (q
< end
&& *q
!= ':')
8339 const char *q2
= q
+ 1, *ml_end
= end
;
8340 char *new_multilib_os_dir
;
8342 while (q2
< end
&& *q2
!= ':')
8346 if (ml_end
- q
== 1)
8347 multilib_os_dir
= xstrdup (".");
8350 new_multilib_os_dir
= XNEWVEC (char, ml_end
- q
);
8351 memcpy (new_multilib_os_dir
, q
+ 1, ml_end
- q
- 1);
8352 new_multilib_os_dir
[ml_end
- q
- 1] = '\0';
8353 multilib_os_dir
= new_multilib_os_dir
;
8356 if (q2
< end
&& *q2
== ':')
8358 char *new_multiarch_dir
= XNEWVEC (char, end
- q2
);
8359 memcpy (new_multiarch_dir
, q2
+ 1, end
- q2
- 1);
8360 new_multiarch_dir
[end
- q2
- 1] = '\0';
8361 multiarch_dir
= new_multiarch_dir
;
8370 if (multilib_dir
== NULL
&& multilib_os_dir
!= NULL
8371 && strcmp (multilib_os_dir
, ".") == 0)
8373 free (CONST_CAST (char *, multilib_os_dir
));
8374 multilib_os_dir
= NULL
;
8376 else if (multilib_dir
!= NULL
&& multilib_os_dir
== NULL
)
8377 multilib_os_dir
= multilib_dir
;
8380 /* Print out the multiple library subdirectory selection
8381 information. This prints out a series of lines. Each line looks
8382 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
8383 required. Only the desired options are printed out, the negative
8384 matches. The options are print without a leading dash. There are
8385 no spaces to make it easy to use the information in the shell.
8386 Each subdirectory is printed only once. This assumes the ordering
8387 generated by the genmultilib script. Also, we leave out ones that match
8391 print_multilib_info (void)
8393 const char *p
= multilib_select
;
8394 const char *last_path
= 0, *this_path
;
8396 unsigned int last_path_len
= 0;
8401 /* Ignore newlines. */
8408 /* Get the initial path. */
8415 fatal_error ("multilib select %qs is invalid", multilib_select
);
8421 /* When --disable-multilib was used but target defines
8422 MULTILIB_OSDIRNAMES, entries starting with .: (and not starting
8423 with .:: for multiarch configurations) are there just to find
8424 multilib_os_dir, so skip them from output. */
8425 if (this_path
[0] == '.' && this_path
[1] == ':' && this_path
[2] != ':')
8428 /* Check for matches with the multilib_exclusions. We don't bother
8429 with the '!' in either list. If any of the exclusion rules match
8430 all of its options with the select rule, we skip it. */
8432 const char *e
= multilib_exclusions
;
8433 const char *this_arg
;
8438 /* Ignore newlines. */
8445 /* Check the arguments. */
8454 fatal_error ("multilib exclusion %qs is invalid",
8455 multilib_exclusions
);
8466 while (*e
!= ' ' && *e
!= ';')
8469 goto invalid_exclusion
;
8477 int len
= e
- this_arg
;
8480 goto invalid_select
;
8484 while (*q
!= ' ' && *q
!= ';')
8487 goto invalid_select
;
8491 if (! strncmp (arg
, this_arg
,
8492 (len
< q
- arg
) ? q
- arg
: len
)
8493 || default_arg (this_arg
, e
- this_arg
))
8523 /* If this is a duplicate, skip it. */
8524 skip
= (last_path
!= 0
8525 && (unsigned int) (p
- this_path
) == last_path_len
8526 && ! filename_ncmp (last_path
, this_path
, last_path_len
));
8528 last_path
= this_path
;
8529 last_path_len
= p
- this_path
;
8532 /* If this directory requires any default arguments, we can skip
8533 it. We will already have printed a directory identical to
8534 this one which does not require that default argument. */
8545 goto invalid_select
;
8552 while (*q
!= ' ' && *q
!= ';')
8555 goto invalid_select
;
8560 && default_arg (arg
, q
- arg
))
8575 for (p1
= last_path
; p1
< p
&& *p1
!= ':'; p1
++)
8586 goto invalid_select
;
8594 use_arg
= *p
!= '!';
8599 while (*p
!= ' ' && *p
!= ';')
8602 goto invalid_select
;
8614 /* If there are extra options, print them now. */
8615 if (multilib_extra
&& *multilib_extra
)
8617 int print_at
= TRUE
;
8620 for (q
= multilib_extra
; *q
!= '\0'; q
++)
8641 /* getenv built-in spec function.
8643 Returns the value of the environment variable given by its first
8644 argument, concatenated with the second argument. If the
8645 environment variable is not defined, a fatal error is issued. */
8648 getenv_spec_function (int argc
, const char **argv
)
8658 value
= getenv (argv
[0]);
8660 fatal_error ("environment variable %qs not defined", argv
[0]);
8662 /* We have to escape every character of the environment variable so
8663 they are not interpreted as active spec characters. A
8664 particularly painful case is when we are reading a variable
8665 holding a windows path complete with \ separators. */
8666 len
= strlen (value
) * 2 + strlen (argv
[1]) + 1;
8667 result
= XNEWVAR (char, len
);
8668 for (ptr
= result
; *value
; ptr
+= 2)
8674 strcpy (ptr
, argv
[1]);
8679 /* if-exists built-in spec function.
8681 Checks to see if the file specified by the absolute pathname in
8682 ARGS exists. Returns that pathname if found.
8684 The usual use for this function is to check for a library file
8685 (whose name has been expanded with %s). */
8688 if_exists_spec_function (int argc
, const char **argv
)
8690 /* Must have only one argument. */
8691 if (argc
== 1 && IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
8697 /* if-exists-else built-in spec function.
8699 This is like if-exists, but takes an additional argument which
8700 is returned if the first argument does not exist. */
8703 if_exists_else_spec_function (int argc
, const char **argv
)
8705 /* Must have exactly two arguments. */
8709 if (IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
8715 /* sanitize built-in spec function.
8717 This returns non-NULL, if sanitizing address, thread or
8718 any of the undefined behavior sanitizers. */
8721 sanitize_spec_function (int argc
, const char **argv
)
8726 if (strcmp (argv
[0], "address") == 0)
8727 return (flag_sanitize
& SANITIZE_USER_ADDRESS
) ? "" : NULL
;
8728 if (strcmp (argv
[0], "kernel-address") == 0)
8729 return (flag_sanitize
& SANITIZE_KERNEL_ADDRESS
) ? "" : NULL
;
8730 if (strcmp (argv
[0], "thread") == 0)
8731 return (flag_sanitize
& SANITIZE_THREAD
) ? "" : NULL
;
8732 if (strcmp (argv
[0], "undefined") == 0)
8733 return ((flag_sanitize
& (SANITIZE_UNDEFINED
| SANITIZE_NONDEFAULT
))
8734 && !flag_sanitize_undefined_trap_on_error
) ? "" : NULL
;
8735 if (strcmp (argv
[0], "leak") == 0)
8736 return ((flag_sanitize
8737 & (SANITIZE_ADDRESS
| SANITIZE_LEAK
| SANITIZE_THREAD
))
8738 == SANITIZE_LEAK
) ? "" : NULL
;
8742 /* replace-outfile built-in spec function.
8744 This looks for the first argument in the outfiles array's name and
8745 replaces it with the second argument. */
8748 replace_outfile_spec_function (int argc
, const char **argv
)
8751 /* Must have exactly two arguments. */
8755 for (i
= 0; i
< n_infiles
; i
++)
8757 if (outfiles
[i
] && !filename_cmp (outfiles
[i
], argv
[0]))
8758 outfiles
[i
] = xstrdup (argv
[1]);
8763 /* remove-outfile built-in spec function.
8765 * This looks for the first argument in the outfiles array's name and
8769 remove_outfile_spec_function (int argc
, const char **argv
)
8772 /* Must have exactly one argument. */
8776 for (i
= 0; i
< n_infiles
; i
++)
8778 if (outfiles
[i
] && !filename_cmp (outfiles
[i
], argv
[0]))
8784 /* Given two version numbers, compares the two numbers.
8785 A version number must match the regular expression
8786 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
8789 compare_version_strings (const char *v1
, const char *v2
)
8794 if (regcomp (&r
, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
8795 REG_EXTENDED
| REG_NOSUB
) != 0)
8797 rresult
= regexec (&r
, v1
, 0, NULL
, 0);
8798 if (rresult
== REG_NOMATCH
)
8799 fatal_error ("invalid version number %qs", v1
);
8800 else if (rresult
!= 0)
8802 rresult
= regexec (&r
, v2
, 0, NULL
, 0);
8803 if (rresult
== REG_NOMATCH
)
8804 fatal_error ("invalid version number %qs", v2
);
8805 else if (rresult
!= 0)
8808 return strverscmp (v1
, v2
);
8812 /* version_compare built-in spec function.
8814 This takes an argument of the following form:
8816 <comparison-op> <arg1> [<arg2>] <switch> <result>
8818 and produces "result" if the comparison evaluates to true,
8819 and nothing if it doesn't.
8821 The supported <comparison-op> values are:
8823 >= true if switch is a later (or same) version than arg1
8825 < true if switch is an earlier version than arg1
8827 >< true if switch is arg1 or later, and earlier than arg2
8828 <> true if switch is earlier than arg1 or is arg2 or later
8830 If the switch is not present, the condition is false unless
8831 the first character of the <comparison-op> is '!'.
8834 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
8835 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
8838 version_compare_spec_function (int argc
, const char **argv
)
8842 const char *switch_value
= NULL
;
8847 fatal_error ("too few arguments to %%:version-compare");
8848 if (argv
[0][0] == '\0')
8850 if ((argv
[0][1] == '<' || argv
[0][1] == '>') && argv
[0][0] != '!')
8852 if (argc
!= nargs
+ 3)
8853 fatal_error ("too many arguments to %%:version-compare");
8855 switch_len
= strlen (argv
[nargs
+ 1]);
8856 for (i
= 0; i
< n_switches
; i
++)
8857 if (!strncmp (switches
[i
].part1
, argv
[nargs
+ 1], switch_len
)
8858 && check_live_switch (i
, switch_len
))
8859 switch_value
= switches
[i
].part1
+ switch_len
;
8861 if (switch_value
== NULL
)
8865 comp1
= compare_version_strings (switch_value
, argv
[1]);
8867 comp2
= compare_version_strings (switch_value
, argv
[2]);
8869 comp2
= -1; /* This value unused. */
8872 switch (argv
[0][0] << 8 | argv
[0][1])
8874 case '>' << 8 | '=':
8875 result
= comp1
>= 0;
8877 case '!' << 8 | '<':
8878 result
= comp1
>= 0 || switch_value
== NULL
;
8883 case '!' << 8 | '>':
8884 result
= comp1
< 0 || switch_value
== NULL
;
8886 case '>' << 8 | '<':
8887 result
= comp1
>= 0 && comp2
< 0;
8889 case '<' << 8 | '>':
8890 result
= comp1
< 0 || comp2
>= 0;
8894 fatal_error ("unknown operator %qs in %%:version-compare", argv
[0]);
8899 return argv
[nargs
+ 2];
8902 /* %:include builtin spec function. This differs from %include in that it
8903 can be nested inside a spec, and thus be conditionalized. It takes
8904 one argument, the filename, and looks for it in the startfile path.
8905 The result is always NULL, i.e. an empty expansion. */
8908 include_spec_function (int argc
, const char **argv
)
8915 file
= find_a_file (&startfile_prefixes
, argv
[0], R_OK
, true);
8916 read_specs (file
? file
: argv
[0], false, false);
8921 /* %:find-file spec function. This function replaces its argument by
8922 the file found through find_file, that is the -print-file-name gcc
8925 find_file_spec_function (int argc
, const char **argv
)
8932 file
= find_file (argv
[0]);
8937 /* %:find-plugindir spec function. This function replaces its argument
8938 by the -iplugindir=<dir> option. `dir' is found through find_file, that
8939 is the -print-file-name gcc program option. */
8941 find_plugindir_spec_function (int argc
, const char **argv ATTRIBUTE_UNUSED
)
8948 option
= concat ("-iplugindir=", find_file ("plugin"), NULL
);
8953 /* %:print-asm-header spec function. Print a banner to say that the
8954 following output is from the assembler. */
8957 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED
,
8958 const char **argv ATTRIBUTE_UNUSED
)
8960 printf (_("Assembler options\n=================\n\n"));
8961 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
8966 /* Get a random number for -frandom-seed */
8968 static unsigned HOST_WIDE_INT
8969 get_random_number (void)
8971 unsigned HOST_WIDE_INT ret
= 0;
8974 fd
= open ("/dev/urandom", O_RDONLY
);
8977 read (fd
, &ret
, sizeof (HOST_WIDE_INT
));
8983 /* Get some more or less random data. */
8984 #ifdef HAVE_GETTIMEOFDAY
8988 gettimeofday (&tv
, NULL
);
8989 ret
= tv
.tv_sec
* 1000 + tv
.tv_usec
/ 1000;
8993 time_t now
= time (NULL
);
8995 if (now
!= (time_t)-1)
8996 ret
= (unsigned) now
;
9000 return ret
^ getpid ();
9003 /* %:compare-debug-dump-opt spec function. Save the last argument,
9004 expected to be the last -fdump-final-insns option, or generate a
9008 compare_debug_dump_opt_spec_function (int arg
,
9009 const char **argv ATTRIBUTE_UNUSED
)
9014 static char random_seed
[HOST_BITS_PER_WIDE_INT
/ 4 + 3];
9017 fatal_error ("too many arguments to %%:compare-debug-dump-opt");
9019 do_spec_2 ("%{fdump-final-insns=*:%*}");
9020 do_spec_1 (" ", 0, NULL
);
9022 if (argbuf
.length () > 0
9023 && strcmp (argv
[argbuf
.length () - 1], "."))
9028 name
= xstrdup (argv
[argbuf
.length () - 1]);
9033 const char *ext
= NULL
;
9035 if (argbuf
.length () > 0)
9037 do_spec_2 ("%{o*:%*}%{!o:%{!S:%b%O}%{S:%b.s}}");
9040 else if (!compare_debug
)
9043 do_spec_2 ("%g.gkd");
9045 do_spec_1 (" ", 0, NULL
);
9047 gcc_assert (argbuf
.length () > 0);
9049 name
= concat (argbuf
.last (), ext
, NULL
);
9051 ret
= concat ("-fdump-final-insns=", name
, NULL
);
9054 which
= compare_debug
< 0;
9055 debug_check_temp_file
[which
] = name
;
9059 unsigned HOST_WIDE_INT value
= get_random_number ();
9061 sprintf (random_seed
, HOST_WIDE_INT_PRINT_HEX
, value
);
9067 ret
= concat ("%{!frandom-seed=*:-frandom-seed=", random_seed
, "} ",
9078 static const char *debug_auxbase_opt
;
9080 /* %:compare-debug-self-opt spec function. Expands to the options
9081 that are to be passed in the second compilation of
9085 compare_debug_self_opt_spec_function (int arg
,
9086 const char **argv ATTRIBUTE_UNUSED
)
9089 fatal_error ("too many arguments to %%:compare-debug-self-opt");
9091 if (compare_debug
>= 0)
9094 do_spec_2 ("%{c|S:%{o*:%*}}");
9095 do_spec_1 (" ", 0, NULL
);
9097 if (argbuf
.length () > 0)
9098 debug_auxbase_opt
= concat ("-auxbase-strip ",
9102 debug_auxbase_opt
= NULL
;
9105 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
9106 %<fdump-final-insns=* -w -S -o %j \
9107 %{!fcompare-debug-second:-fcompare-debug-second} \
9108 ", compare_debug_opt
, NULL
);
9111 /* %:compare-debug-auxbase-opt spec function. Expands to the auxbase
9112 options that are to be passed in the second compilation of
9113 compare-debug. It expects, as an argument, the basename of the
9114 current input file name, with the .gk suffix appended to it. */
9117 compare_debug_auxbase_opt_spec_function (int arg
,
9124 fatal_error ("too few arguments to %%:compare-debug-auxbase-opt");
9127 fatal_error ("too many arguments to %%:compare-debug-auxbase-opt");
9129 if (compare_debug
>= 0)
9132 len
= strlen (argv
[0]);
9133 if (len
< 3 || strcmp (argv
[0] + len
- 3, ".gk") != 0)
9134 fatal_error ("argument to %%:compare-debug-auxbase-opt "
9135 "does not end in .gk");
9137 if (debug_auxbase_opt
)
9138 return debug_auxbase_opt
;
9140 #define OPT "-auxbase "
9143 name
= (char*) xmalloc (sizeof (OPT
) + len
);
9144 memcpy (name
, OPT
, sizeof (OPT
) - 1);
9145 memcpy (name
+ sizeof (OPT
) - 1, argv
[0], len
);
9146 name
[sizeof (OPT
) - 1 + len
] = '\0';
9153 /* %:pass-through-libs spec function. Finds all -l options and input
9154 file names in the lib spec passed to it, and makes a list of them
9155 prepended with the plugin option to cause them to be passed through
9156 to the final link after all the new object files have been added. */
9159 pass_through_libs_spec_func (int argc
, const char **argv
)
9161 char *prepended
= xstrdup (" ");
9163 /* Shlemiel the painter's algorithm. Innately horrible, but at least
9164 we know that there will never be more than a handful of strings to
9165 concat, and it's only once per run, so it's not worth optimising. */
9166 for (n
= 0; n
< argc
; n
++)
9168 char *old
= prepended
;
9169 /* Anything that isn't an option is a full path to an output
9170 file; pass it through if it ends in '.a'. Among options,
9172 if (argv
[n
][0] == '-' && argv
[n
][1] == 'l')
9174 const char *lopt
= argv
[n
] + 2;
9175 /* Handle both joined and non-joined -l options. If for any
9176 reason there's a trailing -l with no joined or following
9177 arg just discard it. */
9178 if (!*lopt
&& ++n
>= argc
)
9182 prepended
= concat (prepended
, "-plugin-opt=-pass-through=-l",
9185 else if (!strcmp (".a", argv
[n
] + strlen (argv
[n
]) - 2))
9187 prepended
= concat (prepended
, "-plugin-opt=-pass-through=",
9188 argv
[n
], " ", NULL
);
9190 if (prepended
!= old
)
9196 /* %:replace-extension spec function. Replaces the extension of the
9197 first argument with the second argument. */
9200 replace_extension_spec_func (int argc
, const char **argv
)
9208 fatal_error ("too few arguments to %%:replace-extension");
9210 name
= xstrdup (argv
[0]);
9212 for (i
= strlen (name
) - 1; i
>= 0; i
--)
9213 if (IS_DIR_SEPARATOR (name
[i
]))
9216 p
= strrchr (name
+ i
+ 1, '.');
9220 result
= concat (name
, argv
[1], NULL
);
9226 /* Insert backslash before spaces in ORIG (usually a file path), to
9227 avoid being broken by spec parser.
9229 This function is needed as do_spec_1 treats white space (' ' and '\t')
9230 as the end of an argument. But in case of -plugin /usr/gcc install/xxx.so,
9231 the file name should be treated as a single argument rather than being
9232 broken into multiple. Solution is to insert '\\' before the space in a
9235 This function converts and only converts all occurrence of ' '
9236 to '\\' + ' ' and '\t' to '\\' + '\t'. For example:
9240 "a\\ b" -> "a\\\\ b"
9242 orig: input null-terminating string that was allocated by xalloc. The
9243 memory it points to might be freed in this function. Behavior undefined
9244 if ORIG wasn't xalloced or was freed already at entry.
9246 Return: ORIG if no conversion needed. Otherwise a newly allocated string
9247 that was converted from ORIG. */
9250 convert_white_space (char *orig
)
9252 int len
, number_of_space
= 0;
9254 for (len
= 0; orig
[len
]; len
++)
9255 if (orig
[len
] == ' ' || orig
[len
] == '\t') number_of_space
++;
9257 if (number_of_space
)
9259 char *new_spec
= (char *) xmalloc (len
+ number_of_space
+ 1);
9261 for (j
= 0, k
= 0; j
<= len
; j
++, k
++)
9263 if (orig
[j
] == ' ' || orig
[j
] == '\t')
9264 new_spec
[k
++] = '\\';
9265 new_spec
[k
] = orig
[j
];