1 /* Compiler driver program that can handle many languages.
2 Copyright (C) 1987-2013 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 /* Whether we should report subprocess execution times to a file. */
110 FILE *report_times_to_file
= NULL
;
112 /* Nonzero means place this string before uses of /, so that include
113 and library files can be found in an alternate location. */
115 #ifdef TARGET_SYSTEM_ROOT
116 static const char *target_system_root
= TARGET_SYSTEM_ROOT
;
118 static const char *target_system_root
= 0;
121 /* Nonzero means pass the updated target_system_root to the compiler. */
123 static int target_system_root_changed
;
125 /* Nonzero means append this string to target_system_root. */
127 static const char *target_sysroot_suffix
= 0;
129 /* Nonzero means append this string to target_system_root for headers. */
131 static const char *target_sysroot_hdrs_suffix
= 0;
133 /* Nonzero means write "temp" files in source directory
134 and use the source file's name in them, and don't delete them. */
136 static enum save_temps
{
137 SAVE_TEMPS_NONE
, /* no -save-temps */
138 SAVE_TEMPS_CWD
, /* -save-temps in current directory */
139 SAVE_TEMPS_OBJ
/* -save-temps in object directory */
142 /* Output file to use to get the object directory for -save-temps=obj */
143 static char *save_temps_prefix
= 0;
144 static size_t save_temps_length
= 0;
146 /* The compiler version. */
148 static const char *compiler_version
;
150 /* The target version. */
152 static const char *const spec_version
= DEFAULT_TARGET_VERSION
;
154 /* The target machine. */
156 static const char *spec_machine
= DEFAULT_TARGET_MACHINE
;
158 /* Nonzero if cross-compiling.
159 When -b is used, the value comes from the `specs' file. */
161 #ifdef CROSS_DIRECTORY_STRUCTURE
162 static const char *cross_compile
= "1";
164 static const char *cross_compile
= "0";
167 /* Greatest exit code of sub-processes that has been encountered up to
169 static int greatest_status
= 1;
171 /* This is the obstack which we use to allocate many strings. */
173 static struct obstack obstack
;
175 /* This is the obstack to build an environment variable to pass to
176 collect2 that describes all of the relevant switches of what to
177 pass the compiler in building the list of pointers to constructors
180 static struct obstack collect_obstack
;
182 /* Forward declaration for prototypes. */
186 static void init_spec (void);
187 static void store_arg (const char *, int, int);
188 static void insert_wrapper (const char *);
189 static char *load_specs (const char *);
190 static void read_specs (const char *, bool, bool);
191 static void set_spec (const char *, const char *, bool);
192 static struct compiler
*lookup_compiler (const char *, size_t, const char *);
193 static char *build_search_list (const struct path_prefix
*, const char *,
195 static void xputenv (const char *);
196 static void putenv_from_prefixes (const struct path_prefix
*, const char *,
198 static int access_check (const char *, int);
199 static char *find_a_file (const struct path_prefix
*, const char *, int, bool);
200 static void add_prefix (struct path_prefix
*, const char *, const char *,
202 static void add_sysrooted_prefix (struct path_prefix
*, const char *,
203 const char *, int, int, int);
204 static char *skip_whitespace (char *);
205 static void delete_if_ordinary (const char *);
206 static void delete_temp_files (void);
207 static void delete_failure_queue (void);
208 static void clear_failure_queue (void);
209 static int check_live_switch (int, int);
210 static const char *handle_braces (const char *);
211 static inline bool input_suffix_matches (const char *, const char *);
212 static inline bool switch_matches (const char *, const char *, int);
213 static inline void mark_matching_switches (const char *, const char *, int);
214 static inline void process_marked_switches (void);
215 static const char *process_brace_body (const char *, const char *, const char *, int, int);
216 static const struct spec_function
*lookup_spec_function (const char *);
217 static const char *eval_spec_function (const char *, const char *);
218 static const char *handle_spec_function (const char *);
219 static char *save_string (const char *, int);
220 static void set_collect_gcc_options (void);
221 static int do_spec_1 (const char *, int, const char *);
222 static int do_spec_2 (const char *);
223 static void do_option_spec (const char *, const char *);
224 static void do_self_spec (const char *);
225 static const char *find_file (const char *);
226 static int is_directory (const char *, bool);
227 static const char *validate_switches (const char *, bool);
228 static void validate_all_switches (void);
229 static inline void validate_switches_from_spec (const char *, bool);
230 static void give_switch (int, int);
231 static int used_arg (const char *, int);
232 static int default_arg (const char *, int);
233 static void set_multilib_dir (void);
234 static void print_multilib_info (void);
235 static void perror_with_name (const char *);
236 static void display_help (void);
237 static void add_preprocessor_option (const char *, int);
238 static void add_assembler_option (const char *, int);
239 static void add_linker_option (const char *, int);
240 static void process_command (unsigned int, struct cl_decoded_option
*);
241 static int execute (void);
242 static void alloc_args (void);
243 static void clear_args (void);
244 static void fatal_signal (int);
245 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
246 static void init_gcc_specs (struct obstack
*, const char *, const char *,
249 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
250 static const char *convert_filename (const char *, int, int);
253 static const char *getenv_spec_function (int, const char **);
254 static const char *if_exists_spec_function (int, const char **);
255 static const char *if_exists_else_spec_function (int, const char **);
256 static const char *replace_outfile_spec_function (int, const char **);
257 static const char *remove_outfile_spec_function (int, const char **);
258 static const char *version_compare_spec_function (int, const char **);
259 static const char *include_spec_function (int, const char **);
260 static const char *find_file_spec_function (int, const char **);
261 static const char *find_plugindir_spec_function (int, const char **);
262 static const char *print_asm_header_spec_function (int, const char **);
263 static const char *compare_debug_dump_opt_spec_function (int, const char **);
264 static const char *compare_debug_self_opt_spec_function (int, const char **);
265 static const char *compare_debug_auxbase_opt_spec_function (int, const char **);
266 static const char *pass_through_libs_spec_func (int, const char **);
267 static const char *replace_extension_spec_func (int, const char **);
269 /* The Specs Language
271 Specs are strings containing lines, each of which (if not blank)
272 is made up of a program name, and arguments separated by spaces.
273 The program name must be exact and start from root, since no path
274 is searched and it is unreliable to depend on the current working directory.
275 Redirection of input or output is not supported; the subprograms must
276 accept filenames saying what files to read and write.
278 In addition, the specs can contain %-sequences to substitute variable text
279 or for conditional text. Here is a table of all defined %-sequences.
280 Note that spaces are not generated automatically around the results of
281 expanding these sequences; therefore, you can concatenate them together
282 or with constant text in a single argument.
284 %% substitute one % into the program name or argument.
285 %i substitute the name of the input file being processed.
286 %b substitute the basename of the input file being processed.
287 This is the substring up to (and not including) the last period
288 and not including the directory unless -save-temps was specified
289 to put temporaries in a different location.
290 %B same as %b, but include the file suffix (text after the last period).
292 substitute a file name that has suffix SUFFIX and is chosen
293 once per compilation, and mark the argument a la %d. To reduce
294 exposure to denial-of-service attacks, the file name is now
295 chosen in a way that is hard to predict even when previously
296 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
297 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
298 the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
299 had been pre-processed. Previously, %g was simply substituted
300 with a file name chosen once per compilation, without regard
301 to any appended suffix (which was therefore treated just like
302 ordinary text), making such attacks more likely to succeed.
304 like %g, but if -pipe is in effect, expands simply to "-".
306 like %g, but if -pipe is in effect, expands to nothing. (We have both
307 %| and %m to accommodate differences between system assemblers; see
308 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
310 like %g, but generates a new temporary file name even if %uSUFFIX
313 substitutes the last file name generated with %uSUFFIX, generating a
314 new one if there is no such last file name. In the absence of any
315 %uSUFFIX, this is just like %gSUFFIX, except they don't share
316 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
317 would involve the generation of two distinct file names, one
318 for each `%g.s' and another for each `%U.s'. Previously, %U was
319 simply substituted with a file name chosen for the previous %u,
320 without regard to any appended suffix.
322 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
323 writable, and if save-temps is off; otherwise, substitute the name
324 of a temporary file, just like %u. This temporary file is not
325 meant for communication between processes, but rather as a junk
328 substitutes .SUFFIX for the suffixes of a matched switch's args when
329 it is subsequently output with %*. SUFFIX is terminated by the next
331 %d marks the argument containing or following the %d as a
332 temporary file name, so that that file will be deleted if GCC exits
333 successfully. Unlike %g, this contributes no text to the argument.
334 %w marks the argument containing or following the %w as the
335 "output file" of this compilation. This puts the argument
336 into the sequence of arguments that %o will substitute later.
337 %V indicates that this compilation produces no "output file".
339 like %{...} but mark last argument supplied within
340 as a file to be deleted on failure.
341 %o substitutes the names of all the output files, with spaces
342 automatically placed around them. You should write spaces
343 around the %o as well or the results are undefined.
344 %o is for use in the specs for running the linker.
345 Input files whose names have no recognized suffix are not compiled
346 at all, but they are included among the output files, so they will
348 %O substitutes the suffix for object files. Note that this is
349 handled specially when it immediately follows %g, %u, or %U
350 (with or without a suffix argument) because of the need for
351 those to form complete file names. The handling is such that
352 %O is treated exactly as if it had already been substituted,
353 except that %g, %u, and %U do not currently support additional
354 SUFFIX characters following %O as they would following, for
356 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
357 (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
358 and -B options) and -imultilib as necessary.
359 %s current argument is the name of a library or startup file of some sort.
360 Search for that file in a standard list of directories
361 and substitute the full name found.
362 %eSTR Print STR as an error message. STR is terminated by a newline.
363 Use this when inconsistent options are detected.
364 %nSTR Print STR as a notice. STR is terminated by a newline.
365 %x{OPTION} Accumulate an option for %X.
366 %X Output the accumulated linker options specified by compilations.
367 %Y Output the accumulated assembler options specified by compilations.
368 %Z Output the accumulated preprocessor options specified by compilations.
369 %a process ASM_SPEC as a spec.
370 This allows config.h to specify part of the spec for running as.
371 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
372 used here. This can be used to run a post-processor after the
373 assembler has done its job.
374 %D Dump out a -L option for each directory in startfile_prefixes.
375 If multilib_dir is set, extra entries are generated with it affixed.
376 %l process LINK_SPEC as a spec.
377 %L process LIB_SPEC as a spec.
378 %M Output multilib_os_dir.
379 %G process LIBGCC_SPEC as a spec.
380 %R Output the concatenation of target_system_root and
381 target_sysroot_suffix.
382 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
383 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
384 %C process CPP_SPEC as a spec.
385 %1 process CC1_SPEC as a spec.
386 %2 process CC1PLUS_SPEC as a spec.
387 %* substitute the variable part of a matched option. (See below.)
388 Note that each comma in the substituted string is replaced by
390 %<S remove all occurrences of -S from the command line.
391 Note - this command is position dependent. % commands in the
392 spec string before this one will see -S, % commands in the
393 spec string after this one will not.
394 %>S Similar to "%<S", but keep it in the GCC command line.
395 %<S* remove all occurrences of all switches beginning with -S from the
398 Call the named function FUNCTION, passing it ARGS. ARGS is
399 first processed as a nested spec string, then split into an
400 argument vector in the usual fashion. The function returns
401 a string which is processed as if it had appeared literally
402 as part of the current spec.
403 %{S} substitutes the -S switch, if that switch was given to GCC.
404 If that switch was not specified, this substitutes nothing.
405 Here S is a metasyntactic variable.
406 %{S*} substitutes all the switches specified to GCC whose names start
407 with -S. This is used for -o, -I, etc; switches that take
408 arguments. GCC considers `-o foo' as being one switch whose
409 name starts with `o'. %{o*} would substitute this text,
410 including the space; thus, two arguments would be generated.
411 %{S*&T*} likewise, but preserve order of S and T options (the order
412 of S and T in the spec is not significant). Can be any number
413 of ampersand-separated variables; for each the wild card is
414 optional. Useful for CPP as %{D*&U*&A*}.
416 %{S:X} substitutes X, if the -S switch was given to GCC.
417 %{!S:X} substitutes X, if the -S switch was NOT given to GCC.
418 %{S*:X} substitutes X if one or more switches whose names start
419 with -S was given to GCC. Normally X is substituted only
420 once, no matter how many such switches appeared. However,
421 if %* appears somewhere in X, then X will be substituted
422 once for each matching switch, with the %* replaced by the
423 part of that switch that matched the '*'.
424 %{.S:X} substitutes X, if processing a file with suffix S.
425 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
426 %{,S:X} substitutes X, if processing a file which will use spec S.
427 %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
429 %{S|T:X} substitutes X if either -S or -T was given to GCC. This may be
430 combined with '!', '.', ',', and '*' as above binding stronger
432 If %* appears in X, all of the alternatives must be starred, and
433 only the first matching alternative is substituted.
434 %{S:X; if S was given to GCC, substitutes X;
435 T:Y; else if T was given to GCC, substitutes Y;
436 :D} else substitutes D. There can be as many clauses as you need.
437 This may be combined with '.', '!', ',', '|', and '*' as above.
439 %(Spec) processes a specification defined in a specs file as *Spec:
441 The conditional text X in a %{S:X} or similar construct may contain
442 other nested % constructs or spaces, or even newlines. They are
443 processed as usual, as described above. Trailing white space in X is
444 ignored. White space may also appear anywhere on the left side of the
445 colon in these constructs, except between . or * and the corresponding
448 The -O, -f, -g, -m, and -W switches are handled specifically in these
449 constructs. If another value of -O or the negated form of a -f, -m, or
450 -W switch is found later in the command line, the earlier switch
451 value is ignored, except with {S*} where S is just one letter; this
452 passes all matching options.
454 The character | at the beginning of the predicate text is used to indicate
455 that a command should be piped to the following command, but only if -pipe
458 Note that it is built into GCC which switches take arguments and which
459 do not. You might think it would be useful to generalize this to
460 allow each compiler's spec to say which switches take arguments. But
461 this cannot be done in a consistent fashion. GCC cannot even decide
462 which input files have been specified without knowing which switches
463 take arguments, and it must know which input files to compile in order
464 to tell which compilers to run.
466 GCC also knows implicitly that arguments starting in `-l' are to be
467 treated as compiler output files, and passed to the linker in their
468 proper position among the other output files. */
470 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
472 /* config.h can define ASM_SPEC to provide extra args to the assembler
473 or extra switch-translations. */
478 /* config.h can define ASM_FINAL_SPEC to run a post processor after
479 the assembler has run. */
480 #ifndef ASM_FINAL_SPEC
481 #define ASM_FINAL_SPEC \
483 objcopy --extract-dwo \
484 %{c:%{o*:%*}%{!o*:%b%O}}%{!c:%U%O} \
485 %{c:%{o*:%:replace-extension(%{o*:%*} .dwo)}%{!o*:%b.dwo}}%{!c:%b.dwo} \n\
486 objcopy --strip-dwo \
487 %{c:%{o*:%*}%{!o*:%b%O}}%{!c:%U%O} \
491 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
492 or extra switch-translations. */
497 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
498 or extra switch-translations. */
503 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
504 or extra switch-translations. */
506 #define CC1PLUS_SPEC ""
509 /* config.h can define LINK_SPEC to provide extra args to the linker
510 or extra switch-translations. */
515 /* config.h can define LIB_SPEC to override the default libraries. */
517 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
522 /* XXX: valid only for GNU ld */
523 /* XXX: should exactly match hooks provided by libmudflap.a */
524 #define MFWRAP_SPEC " %{static: %{fmudflap|fmudflapth: \
525 --wrap=malloc --wrap=free --wrap=calloc --wrap=realloc\
526 --wrap=mmap --wrap=mmap64 --wrap=munmap --wrap=alloca\
527 } %{fmudflapth: --wrap=pthread_create\
528 }} %{fmudflap|fmudflapth: --wrap=main}"
531 #define MFLIB_SPEC "%{fmudflap|fmudflapth: -export-dynamic}"
534 /* When using -fsplit-stack we need to wrap pthread_create, in order
535 to initialize the stack guard. We always use wrapping, rather than
536 shared library ordering, and we keep the wrapper function in
537 libgcc. This is not yet a real spec, though it could become one;
538 it is currently just stuffed into LINK_SPEC. FIXME: This wrapping
539 only works with GNU ld and gold. FIXME: This is incompatible with
540 -fmudflap when linking statically, which wants to do its own
542 #define STACK_SPLIT_SPEC " %{fsplit-stack: --wrap=pthread_create}"
545 #ifdef STATIC_LIBASAN_LIBS
546 #define ADD_STATIC_LIBASAN_LIBS \
547 " %{static-libasan:" STATIC_LIBASAN_LIBS "}"
549 #define ADD_STATIC_LIBASAN_LIBS
551 #ifdef LIBASAN_EARLY_SPEC
552 #define LIBASAN_SPEC ADD_STATIC_LIBASAN_LIBS
553 #elif defined(HAVE_LD_STATIC_DYNAMIC)
554 #define LIBASAN_SPEC "%{static-libasan:" LD_STATIC_OPTION \
555 "} -lasan %{static-libasan:" LD_DYNAMIC_OPTION "}" \
556 ADD_STATIC_LIBASAN_LIBS
558 #define LIBASAN_SPEC "-lasan" ADD_STATIC_LIBASAN_LIBS
562 #ifndef LIBASAN_EARLY_SPEC
563 #define LIBASAN_EARLY_SPEC ""
567 #ifdef HAVE_LD_STATIC_DYNAMIC
568 #define LIBTSAN_SPEC "%{static-libtsan:" LD_STATIC_OPTION \
569 "} -ltsan %{static-libtsan:" LD_DYNAMIC_OPTION "}"
571 #define LIBTSAN_SPEC "-ltsan"
575 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
578 #if defined(REAL_LIBGCC_SPEC)
579 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
580 #elif defined(LINK_LIBGCC_SPECIAL_1)
581 /* Have gcc do the search for libgcc.a. */
582 #define LIBGCC_SPEC "libgcc.a%s"
584 #define LIBGCC_SPEC "-lgcc"
588 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
589 #ifndef STARTFILE_SPEC
590 #define STARTFILE_SPEC \
591 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
594 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
596 #define ENDFILE_SPEC ""
600 #define LINKER_NAME "collect2"
603 #ifdef HAVE_AS_DEBUG_PREFIX_MAP
604 #define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
609 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
611 #ifndef ASM_DEBUG_SPEC
612 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
613 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
614 # define ASM_DEBUG_SPEC \
615 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
616 ? "%{!g0:%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}}" ASM_MAP \
617 : "%{!g0:%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}}" ASM_MAP)
619 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
620 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gstabs}}" ASM_MAP
622 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
623 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gdwarf2}}" ASM_MAP
627 #ifndef ASM_DEBUG_SPEC
628 # define ASM_DEBUG_SPEC ""
631 /* Here is the spec for running the linker, after compiling all files. */
633 /* This is overridable by the target in case they need to specify the
634 -lgcc and -lc order specially, yet not require them to override all
635 of LINK_COMMAND_SPEC. */
636 #ifndef LINK_GCC_C_SEQUENCE_SPEC
637 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
640 #ifndef LINK_SSP_SPEC
641 #ifdef TARGET_LIBC_PROVIDES_SSP
642 #define LINK_SSP_SPEC "%{fstack-protector:}"
644 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all:-lssp_nonshared -lssp}"
648 #ifndef LINK_PIE_SPEC
650 #define LINK_PIE_SPEC "%{pie:-pie} "
652 #define LINK_PIE_SPEC "%{pie:} "
656 #ifndef LINK_BUILDID_SPEC
657 # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
658 # define LINK_BUILDID_SPEC "%{!r:--build-id} "
662 /* Conditional to test whether the LTO plugin is used or not.
663 FIXME: For slim LTO we will need to enable plugin unconditionally. This
664 still cause problems with PLUGIN_LD != LD and when plugin is built but
665 not useable. For GCC 4.6 we don't support slim LTO and thus we can enable
666 plugin only when LTO is enabled. We still honor explicit
667 -fuse-linker-plugin if the linker used understands -plugin. */
669 /* The linker has some plugin support. */
670 #if HAVE_LTO_PLUGIN > 0
671 /* The linker used has full plugin support, use LTO plugin by default. */
672 #if HAVE_LTO_PLUGIN == 2
673 #define PLUGIN_COND "!fno-use-linker-plugin:%{flto|flto=*|fuse-linker-plugin"
674 #define PLUGIN_COND_CLOSE "}"
676 /* The linker used has limited plugin support, use LTO plugin with explicit
677 -fuse-linker-plugin. */
678 #define PLUGIN_COND "fuse-linker-plugin"
679 #define PLUGIN_COND_CLOSE ""
681 #define LINK_PLUGIN_SPEC \
683 -plugin %(linker_plugin_file) \
684 -plugin-opt=%(lto_wrapper) \
685 -plugin-opt=-fresolution=%u.res \
686 %{!nostdlib:%{!nodefaultlibs:%:pass-through-libs(%(link_gcc_c_sequence))}} \
689 /* The linker used doesn't support -plugin, reject -fuse-linker-plugin. */
690 #define LINK_PLUGIN_SPEC "%{fuse-linker-plugin:\
691 %e-fuse-linker-plugin is not supported in this configuration}"
695 /* -u* was put back because both BSD and SysV seem to support it. */
696 /* %{static:} simply prevents an error message if the target machine
697 doesn't handle -static. */
698 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
699 scripts which exist in user specified directories, or in standard
701 /* We pass any -flto flags on to the linker, which is expected
702 to understand them. In practice, this means it had better be collect2. */
703 /* %{e*} includes -export-dynamic; see comment in common.opt. */
704 #ifndef LINK_COMMAND_SPEC
705 #define LINK_COMMAND_SPEC "\
706 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
709 "%{flto|flto=*:%<fcompare-debug*} \
710 %{flto} %{flto=*} %l " LINK_PIE_SPEC \
711 "%{fuse-ld=*:-fuse-ld=%*}\
712 %X %{o*} %{e*} %{N} %{n} %{r}\
713 %{s} %{t} %{u*} %{z} %{Z} %{!nostdlib:%{!nostartfiles:%S}}\
714 %{!nostdlib:%{!nostartfiles:%{fupc-link:%:include(upc-crtbegin.spec)%(upc_crtbegin)}}}\
715 %{static:} %{L*} %(mfwrap) %(link_libgcc) \
716 %{fsanitize=address:" LIBASAN_EARLY_SPEC "} %o\
717 %{fopenmp|ftree-parallelize-loops=*:%:include(libgomp.spec)%(link_gomp)}\
718 %{fgnu-tm:%:include(libitm.spec)%(link_itm)}\
719 %{fupc-link:%:include(libgupc.spec)%(link_upc)}\
720 %(mflib) " STACK_SPLIT_SPEC "\
721 %{fprofile-arcs|fprofile-generate*|coverage:-lgcov}\
722 %{fsanitize=address:" LIBASAN_SPEC "%{static:%ecannot specify -static with -fsanitize=address}}\
723 %{fsanitize=thread:" LIBTSAN_SPEC "}\
724 %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\
725 %{!nostdlib:%{!nostartfiles:%{fupc-link:%:include(upc-crtend.spec)%(upc_crtend)}}}\
726 %{!nostdlib:%{!nostartfiles:%E}} %{T*} }}}}}}"
729 #ifndef LINK_LIBGCC_SPEC
730 /* Generate -L options for startfile prefix list. */
731 # define LINK_LIBGCC_SPEC "%D"
734 #ifndef STARTFILE_PREFIX_SPEC
735 # define STARTFILE_PREFIX_SPEC ""
739 # define SYSROOT_SPEC "--sysroot=%R"
742 #ifndef SYSROOT_SUFFIX_SPEC
743 # define SYSROOT_SUFFIX_SPEC ""
746 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
747 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
750 static const char *asm_debug
= ASM_DEBUG_SPEC
;
751 static const char *cpp_spec
= CPP_SPEC
;
752 static const char *cc1_spec
= CC1_SPEC
;
753 static const char *cc1plus_spec
= CC1PLUS_SPEC
;
754 static const char *link_gcc_c_sequence_spec
= LINK_GCC_C_SEQUENCE_SPEC
;
755 static const char *link_ssp_spec
= LINK_SSP_SPEC
;
756 static const char *asm_spec
= ASM_SPEC
;
757 static const char *asm_final_spec
= ASM_FINAL_SPEC
;
758 static const char *link_spec
= LINK_SPEC
;
759 static const char *lib_spec
= LIB_SPEC
;
760 static const char *mfwrap_spec
= MFWRAP_SPEC
;
761 static const char *mflib_spec
= MFLIB_SPEC
;
762 static const char *link_gomp_spec
= "";
763 static const char *upc_crtbegin_spec
= "";
764 static const char *link_upc_spec
= "";
765 static const char *upc_crtend_spec
= "";
766 static const char *libgcc_spec
= LIBGCC_SPEC
;
767 static const char *endfile_spec
= ENDFILE_SPEC
;
768 static const char *startfile_spec
= STARTFILE_SPEC
;
769 static const char *linker_name_spec
= LINKER_NAME
;
770 static const char *linker_plugin_file_spec
= "";
771 static const char *lto_wrapper_spec
= "";
772 static const char *lto_gcc_spec
= "";
773 static const char *link_command_spec
= LINK_COMMAND_SPEC
;
774 static const char *link_libgcc_spec
= LINK_LIBGCC_SPEC
;
775 static const char *startfile_prefix_spec
= STARTFILE_PREFIX_SPEC
;
776 static const char *sysroot_spec
= SYSROOT_SPEC
;
777 static const char *sysroot_suffix_spec
= SYSROOT_SUFFIX_SPEC
;
778 static const char *sysroot_hdrs_suffix_spec
= SYSROOT_HEADERS_SUFFIX_SPEC
;
779 static const char *self_spec
= "";
781 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
782 There should be no need to override these in target dependent files,
783 but we need to copy them to the specs file so that newer versions
784 of the GCC driver can correctly drive older tool chains with the
785 appropriate -B options. */
787 /* When cpplib handles traditional preprocessing, get rid of this, and
788 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
789 that we default the front end language better. */
790 static const char *trad_capable_cpp
=
791 "cc1 -E %{traditional|traditional-cpp:-traditional-cpp}";
793 /* We don't wrap .d files in %W{} since a missing .d file, and
794 therefore no dependency entry, confuses make into thinking a .o
795 file that happens to exist is up-to-date. */
796 static const char *cpp_unique_options
=
797 "%{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\
798 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
799 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
800 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
801 %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
802 %{remap} %{g3|ggdb3|gstabs3|gcoff3|gxcoff3|gvms3:-dD}\
803 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
804 %{H} %C %{D*&U*&A*} %{i*} %Z %i\
805 %{fmudflap:-D_MUDFLAP -include mf-runtime.h}\
806 %{fmudflapth:-D_MUDFLAP -D_MUDFLAPTH -include mf-runtime.h}\
809 /* This contains cpp options which are common with cc1_options and are passed
810 only when preprocessing only to avoid duplication. We pass the cc1 spec
811 options to the preprocessor so that it the cc1 spec may manipulate
812 options used to set target flags. Those special target flags settings may
813 in turn cause preprocessor symbols to be defined specially. */
814 static const char *cpp_options
=
815 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
816 %{f*} %{g*:%{!g0:%{g*} %{!fno-working-directory:-fworking-directory}}} %{O*}\
817 %{undef} %{save-temps*:-fpch-preprocess}";
819 /* This contains cpp options which are not passed when the preprocessor
820 output will be used by another program. */
821 static const char *cpp_debug_options
= "%{d*}";
823 /* NB: This is shared amongst all front-ends, except for Ada. */
824 static const char *cc1_options
=
825 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
826 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
827 %1 %{!Q:-quiet} %{!dumpbase:-dumpbase %B} %{d*} %{m*} %{aux-info*}\
828 %{fcompare-debug-second:%:compare-debug-auxbase-opt(%b)} \
829 %{!fcompare-debug-second:%{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}}%{!c:%{!S:-auxbase %b}} \
830 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
831 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
832 %{Qn:-fno-ident} %{Qy:} %{-help:--help}\
833 %{-target-help:--target-help}\
834 %{-version:--version}\
835 %{-help=*:--help=%*}\
836 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
837 %{fsyntax-only:-o %j} %{-param*}\
838 %{fmudflap|fmudflapth:-fno-builtin -fno-merge-constants}\
839 %{coverage:-fprofile-arcs -ftest-coverage}";
841 static const char *upc_options
= "-lang-upc \
842 %{!fno-upc-pre-include:-include gcc-upc.h}";
844 static const char *asm_options
=
845 "%{-target-help:%:print-asm-header()} "
847 /* If GNU AS is used, then convert -w (no warnings), -I, and -v
848 to the assembler equivalents. */
849 "%{v} %{w:-W} %{I*} "
851 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
853 static const char *invoke_as
=
854 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
856 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
857 %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
861 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
862 %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
866 /* Some compilers have limits on line lengths, and the multilib_select
867 and/or multilib_matches strings can be very long, so we build them at
869 static struct obstack multilib_obstack
;
870 static const char *multilib_select
;
871 static const char *multilib_matches
;
872 static const char *multilib_defaults
;
873 static const char *multilib_exclusions
;
874 static const char *multilib_reuse
;
876 /* Check whether a particular argument is a default argument. */
878 #ifndef MULTILIB_DEFAULTS
879 #define MULTILIB_DEFAULTS { "" }
882 static const char *const multilib_defaults_raw
[] = MULTILIB_DEFAULTS
;
884 #ifndef DRIVER_SELF_SPECS
885 #define DRIVER_SELF_SPECS ""
888 /* Adding -fopenmp should imply pthreads. This is particularly important
889 for targets that use different start files and suchlike. */
890 #ifndef GOMP_SELF_SPECS
891 #define GOMP_SELF_SPECS "%{fopenmp|ftree-parallelize-loops=*: -pthread}"
894 /* Likewise for -fgnu-tm. */
895 #ifndef GTM_SELF_SPECS
896 #define GTM_SELF_SPECS "%{fgnu-tm: -pthread}"
899 static const char *const driver_self_specs
[] = {
900 "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
901 DRIVER_SELF_SPECS
, CONFIGURE_SPECS
, GOMP_SELF_SPECS
, GTM_SELF_SPECS
904 #ifndef OPTION_DEFAULT_SPECS
905 #define OPTION_DEFAULT_SPECS { "", "" }
914 static const struct default_spec
915 option_default_specs
[] = { OPTION_DEFAULT_SPECS
};
919 struct user_specs
*next
;
920 const char *filename
;
923 static struct user_specs
*user_specs_head
, *user_specs_tail
;
926 /* Record the mapping from file suffixes for compilation specs. */
930 const char *suffix
; /* Use this compiler for input files
931 whose names end in this suffix. */
933 const char *spec
; /* To use this compiler, run this spec. */
935 const char *cpp_spec
; /* If non-NULL, substitute this spec
936 for `%C', rather than the usual
938 const int combinable
; /* If nonzero, compiler can deal with
939 multiple source files at once (IMA). */
940 const int needs_preprocessing
; /* If nonzero, source files need to
941 be run through a preprocessor. */
944 /* Pointer to a vector of `struct compiler' that gives the spec for
945 compiling a file, based on its suffix.
946 A file that does not end in any of these suffixes will be passed
947 unchanged to the loader and nothing else will be done to it.
949 An entry containing two 0s is used to terminate the vector.
951 If multiple entries match a file, the last matching one is used. */
953 static struct compiler
*compilers
;
955 /* Number of entries in `compilers', not counting the null terminator. */
957 static int n_compilers
;
959 /* The default list of file name suffixes and their compilation specs. */
961 static const struct compiler default_compilers
[] =
963 /* Add lists of suffixes of known languages here. If those languages
964 were not present when we built the driver, we will hit these copies
965 and be given a more meaningful error than "file not used since
966 linking is not done". */
967 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0},
968 {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
969 {".mii", "#Objective-C++", 0, 0, 0},
970 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
971 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
972 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
973 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
974 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
975 {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
976 {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
977 {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
978 {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
979 {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
980 {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
981 {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
982 {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
983 {".r", "#Ratfor", 0, 0, 0},
984 {".p", "#Pascal", 0, 0, 0}, {".pas", "#Pascal", 0, 0, 0},
985 {".java", "#Java", 0, 0, 0}, {".class", "#Java", 0, 0, 0},
986 {".upc", "#UPC", 0, 0, 0},
987 {".zip", "#Java", 0, 0, 0}, {".jar", "#Java", 0, 0, 0},
988 {".go", "#Go", 0, 1, 0},
989 /* Next come the entries for C. */
990 {".c", "@c", 0, 0, 1},
992 /* cc1 has an integrated ISO C preprocessor. We should invoke the
993 external preprocessor if -save-temps is given. */
994 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
997 %eGNU C no longer supports -traditional without -E}\
998 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
999 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1000 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1002 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1003 cc1 %(cpp_unique_options) %(cc1_options)}}}\
1004 %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 1},
1006 "%{!E:%e-E or -x required when input is from standard input}\
1007 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
1008 {".h", "@c-header", 0, 0, 0},
1010 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1011 external preprocessor if -save-temps is given. */
1012 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1014 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1015 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1016 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1018 %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
1019 %W{o*:--output-pch=%*}}%V}\
1020 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1021 cc1 %(cpp_unique_options) %(cc1_options)\
1022 %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
1023 %W{o*:--output-pch=%*}}%V}}}}}}", 0, 0, 0},
1024 {".i", "@cpp-output", 0, 0, 0},
1026 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 0},
1027 {".s", "@assembler", 0, 0, 0},
1029 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 0, 0},
1030 {".sx", "@assembler-with-cpp", 0, 0, 0},
1031 {".S", "@assembler-with-cpp", 0, 0, 0},
1032 {"@assembler-with-cpp",
1033 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1034 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1035 %{E|M|MM:%(cpp_debug_options)}\
1036 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1037 as %(asm_debug) %(asm_options) %|.s %A }}}}"
1039 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1040 %{E|M|MM:%(cpp_debug_options)}\
1041 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1042 as %(asm_debug) %(asm_options) %m.s %A }}}}"
1047 /* Mark end of table. */
1051 /* Number of elements in default_compilers, not counting the terminator. */
1053 static const int n_default_compilers
= ARRAY_SIZE (default_compilers
) - 1;
1055 typedef char *char_p
; /* For DEF_VEC_P. */
1057 /* A vector of options to give to the linker.
1058 These options are accumulated by %x,
1059 and substituted into the linker command with %X. */
1060 static vec
<char_p
> linker_options
;
1062 /* A vector of options to give to the assembler.
1063 These options are accumulated by -Wa,
1064 and substituted into the assembler command with %Y. */
1065 static vec
<char_p
> assembler_options
;
1067 /* A vector of options to give to the preprocessor.
1068 These options are accumulated by -Wp,
1069 and substituted into the preprocessor command with %Z. */
1070 static vec
<char_p
> preprocessor_options
;
1073 skip_whitespace (char *p
)
1077 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1078 be considered whitespace. */
1079 if (p
[0] == '\n' && p
[1] == '\n' && p
[2] == '\n')
1081 else if (*p
== '\n' || *p
== ' ' || *p
== '\t')
1095 /* Structures to keep track of prefixes to try when looking for files. */
1099 const char *prefix
; /* String to prepend to the path. */
1100 struct prefix_list
*next
; /* Next in linked list. */
1101 int require_machine_suffix
; /* Don't use without machine_suffix. */
1102 /* 2 means try both machine_suffix and just_machine_suffix. */
1103 int priority
; /* Sort key - priority within list. */
1104 int os_multilib
; /* 1 if OS multilib scheme should be used,
1105 0 for GCC multilib scheme. */
1110 struct prefix_list
*plist
; /* List of prefixes to try */
1111 int max_len
; /* Max length of a prefix in PLIST */
1112 const char *name
; /* Name of this list (used in config stuff) */
1115 /* List of prefixes to try when looking for executables. */
1117 static struct path_prefix exec_prefixes
= { 0, 0, "exec" };
1119 /* List of prefixes to try when looking for startup (crt0) files. */
1121 static struct path_prefix startfile_prefixes
= { 0, 0, "startfile" };
1123 /* List of prefixes to try when looking for include files. */
1125 static struct path_prefix include_prefixes
= { 0, 0, "include" };
1127 /* Suffix to attach to directories searched for commands.
1128 This looks like `MACHINE/VERSION/'. */
1130 static const char *machine_suffix
= 0;
1132 /* Suffix to attach to directories searched for commands.
1133 This is just `MACHINE/'. */
1135 static const char *just_machine_suffix
= 0;
1137 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1139 static const char *gcc_exec_prefix
;
1141 /* Adjusted value of standard_libexec_prefix. */
1143 static const char *gcc_libexec_prefix
;
1145 /* Default prefixes to attach to command names. */
1147 #ifndef STANDARD_STARTFILE_PREFIX_1
1148 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1150 #ifndef STANDARD_STARTFILE_PREFIX_2
1151 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1154 #ifdef CROSS_DIRECTORY_STRUCTURE /* Don't use these prefixes for a cross compiler. */
1155 #undef MD_EXEC_PREFIX
1156 #undef MD_STARTFILE_PREFIX
1157 #undef MD_STARTFILE_PREFIX_1
1160 /* If no prefixes defined, use the null string, which will disable them. */
1161 #ifndef MD_EXEC_PREFIX
1162 #define MD_EXEC_PREFIX ""
1164 #ifndef MD_STARTFILE_PREFIX
1165 #define MD_STARTFILE_PREFIX ""
1167 #ifndef MD_STARTFILE_PREFIX_1
1168 #define MD_STARTFILE_PREFIX_1 ""
1171 /* These directories are locations set at configure-time based on the
1172 --prefix option provided to configure. Their initializers are
1173 defined in Makefile.in. These paths are not *directly* used when
1174 gcc_exec_prefix is set because, in that case, we know where the
1175 compiler has been installed, and use paths relative to that
1176 location instead. */
1177 static const char *const standard_exec_prefix
= STANDARD_EXEC_PREFIX
;
1178 static const char *const standard_libexec_prefix
= STANDARD_LIBEXEC_PREFIX
;
1179 static const char *const standard_bindir_prefix
= STANDARD_BINDIR_PREFIX
;
1180 static const char *const standard_startfile_prefix
= STANDARD_STARTFILE_PREFIX
;
1182 /* For native compilers, these are well-known paths containing
1183 components that may be provided by the system. For cross
1184 compilers, these paths are not used. */
1185 static const char *md_exec_prefix
= MD_EXEC_PREFIX
;
1186 static const char *md_startfile_prefix
= MD_STARTFILE_PREFIX
;
1187 static const char *md_startfile_prefix_1
= MD_STARTFILE_PREFIX_1
;
1188 static const char *const standard_startfile_prefix_1
1189 = STANDARD_STARTFILE_PREFIX_1
;
1190 static const char *const standard_startfile_prefix_2
1191 = STANDARD_STARTFILE_PREFIX_2
;
1193 /* A relative path to be used in finding the location of tools
1194 relative to the driver. */
1195 static const char *const tooldir_base_prefix
= TOOLDIR_BASE_PREFIX
;
1197 /* Subdirectory to use for locating libraries. Set by
1198 set_multilib_dir based on the compilation options. */
1200 static const char *multilib_dir
;
1202 /* Subdirectory to use for locating libraries in OS conventions. Set by
1203 set_multilib_dir based on the compilation options. */
1205 static const char *multilib_os_dir
;
1207 /* Subdirectory to use for locating libraries in multiarch conventions. Set by
1208 set_multilib_dir based on the compilation options. */
1210 static const char *multiarch_dir
;
1212 /* Structure to keep track of the specs that have been defined so far.
1213 These are accessed using %(specname) in a compiler or link
1218 /* The following 2 fields must be first */
1219 /* to allow EXTRA_SPECS to be initialized */
1220 const char *name
; /* name of the spec. */
1221 const char *ptr
; /* available ptr if no static pointer */
1223 /* The following fields are not initialized */
1224 /* by EXTRA_SPECS */
1225 const char **ptr_spec
; /* pointer to the spec itself. */
1226 struct spec_list
*next
; /* Next spec in linked list. */
1227 int name_len
; /* length of the name */
1228 bool user_p
; /* whether string come from file spec. */
1229 bool alloc_p
; /* whether string was allocated */
1232 #define INIT_STATIC_SPEC(NAME,PTR) \
1233 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, false, false }
1235 /* List of statically defined specs. */
1236 static struct spec_list static_specs
[] =
1238 INIT_STATIC_SPEC ("asm", &asm_spec
),
1239 INIT_STATIC_SPEC ("asm_debug", &asm_debug
),
1240 INIT_STATIC_SPEC ("asm_final", &asm_final_spec
),
1241 INIT_STATIC_SPEC ("asm_options", &asm_options
),
1242 INIT_STATIC_SPEC ("invoke_as", &invoke_as
),
1243 INIT_STATIC_SPEC ("cpp", &cpp_spec
),
1244 INIT_STATIC_SPEC ("cpp_options", &cpp_options
),
1245 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options
),
1246 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options
),
1247 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp
),
1248 INIT_STATIC_SPEC ("cc1", &cc1_spec
),
1249 INIT_STATIC_SPEC ("cc1_options", &cc1_options
),
1250 INIT_STATIC_SPEC ("upc_options", &upc_options
),
1251 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec
),
1252 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec
),
1253 INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec
),
1254 INIT_STATIC_SPEC ("endfile", &endfile_spec
),
1255 INIT_STATIC_SPEC ("link", &link_spec
),
1256 INIT_STATIC_SPEC ("lib", &lib_spec
),
1257 INIT_STATIC_SPEC ("mfwrap", &mfwrap_spec
),
1258 INIT_STATIC_SPEC ("mflib", &mflib_spec
),
1259 INIT_STATIC_SPEC ("link_gomp", &link_gomp_spec
),
1260 INIT_STATIC_SPEC ("upc_crtbegin", &upc_crtbegin_spec
),
1261 INIT_STATIC_SPEC ("link_upc", &link_upc_spec
),
1262 INIT_STATIC_SPEC ("upc_crtend", &upc_crtend_spec
),
1263 INIT_STATIC_SPEC ("libgcc", &libgcc_spec
),
1264 INIT_STATIC_SPEC ("startfile", &startfile_spec
),
1265 INIT_STATIC_SPEC ("cross_compile", &cross_compile
),
1266 INIT_STATIC_SPEC ("version", &compiler_version
),
1267 INIT_STATIC_SPEC ("multilib", &multilib_select
),
1268 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults
),
1269 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra
),
1270 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches
),
1271 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions
),
1272 INIT_STATIC_SPEC ("multilib_options", &multilib_options
),
1273 INIT_STATIC_SPEC ("multilib_reuse", &multilib_reuse
),
1274 INIT_STATIC_SPEC ("linker", &linker_name_spec
),
1275 INIT_STATIC_SPEC ("linker_plugin_file", &linker_plugin_file_spec
),
1276 INIT_STATIC_SPEC ("lto_wrapper", <o_wrapper_spec
),
1277 INIT_STATIC_SPEC ("lto_gcc", <o_gcc_spec
),
1278 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec
),
1279 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix
),
1280 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix
),
1281 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1
),
1282 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec
),
1283 INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec
),
1284 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec
),
1285 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec
),
1286 INIT_STATIC_SPEC ("self_spec", &self_spec
),
1289 #ifdef EXTRA_SPECS /* additional specs needed */
1290 /* Structure to keep track of just the first two args of a spec_list.
1291 That is all that the EXTRA_SPECS macro gives us. */
1294 const char *const name
;
1295 const char *const ptr
;
1298 static const struct spec_list_1 extra_specs_1
[] = { EXTRA_SPECS
};
1299 static struct spec_list
*extra_specs
= (struct spec_list
*) 0;
1302 /* List of dynamically allocates specs that have been defined so far. */
1304 static struct spec_list
*specs
= (struct spec_list
*) 0;
1306 /* List of static spec functions. */
1308 static const struct spec_function static_spec_functions
[] =
1310 { "getenv", getenv_spec_function
},
1311 { "if-exists", if_exists_spec_function
},
1312 { "if-exists-else", if_exists_else_spec_function
},
1313 { "replace-outfile", replace_outfile_spec_function
},
1314 { "remove-outfile", remove_outfile_spec_function
},
1315 { "version-compare", version_compare_spec_function
},
1316 { "include", include_spec_function
},
1317 { "find-file", find_file_spec_function
},
1318 { "find-plugindir", find_plugindir_spec_function
},
1319 { "print-asm-header", print_asm_header_spec_function
},
1320 { "compare-debug-dump-opt", compare_debug_dump_opt_spec_function
},
1321 { "compare-debug-self-opt", compare_debug_self_opt_spec_function
},
1322 { "compare-debug-auxbase-opt", compare_debug_auxbase_opt_spec_function
},
1323 { "pass-through-libs", pass_through_libs_spec_func
},
1324 { "replace-extension", replace_extension_spec_func
},
1325 #ifdef EXTRA_SPEC_FUNCTIONS
1326 EXTRA_SPEC_FUNCTIONS
1331 static int processing_spec_function
;
1333 /* Add appropriate libgcc specs to OBSTACK, taking into account
1334 various permutations of -shared-libgcc, -shared, and such. */
1336 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1338 #ifndef USE_LD_AS_NEEDED
1339 #define USE_LD_AS_NEEDED 0
1343 init_gcc_specs (struct obstack
*obstack
, const char *shared_name
,
1344 const char *static_name
, const char *eh_name
)
1348 buf
= concat ("%{static|static-libgcc:", static_name
, " ", eh_name
, "}"
1349 "%{!static:%{!static-libgcc:"
1350 #if USE_LD_AS_NEEDED
1351 "%{!shared-libgcc:",
1352 static_name
, " --as-needed ", shared_name
, " --no-as-needed"
1355 shared_name
, "%{!shared: ", static_name
, "}"
1359 "%{!shared-libgcc:", static_name
, " ", eh_name
, "}"
1360 "%{shared-libgcc:", shared_name
, " ", static_name
, "}"
1364 "%{shared-libgcc:", shared_name
, "}"
1365 "%{!shared-libgcc:", static_name
, "}"
1368 "%{shared:", shared_name
, "}"
1373 obstack_grow (obstack
, buf
, strlen (buf
));
1376 #endif /* ENABLE_SHARED_LIBGCC */
1378 /* Initialize the specs lookup routines. */
1383 struct spec_list
*next
= (struct spec_list
*) 0;
1384 struct spec_list
*sl
= (struct spec_list
*) 0;
1388 return; /* Already initialized. */
1391 fnotice (stderr
, "Using built-in specs.\n");
1394 extra_specs
= XCNEWVEC (struct spec_list
, ARRAY_SIZE (extra_specs_1
));
1396 for (i
= ARRAY_SIZE (extra_specs_1
) - 1; i
>= 0; i
--)
1398 sl
= &extra_specs
[i
];
1399 sl
->name
= extra_specs_1
[i
].name
;
1400 sl
->ptr
= extra_specs_1
[i
].ptr
;
1402 sl
->name_len
= strlen (sl
->name
);
1403 sl
->ptr_spec
= &sl
->ptr
;
1408 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1410 sl
= &static_specs
[i
];
1415 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1416 /* ??? If neither -shared-libgcc nor --static-libgcc was
1417 seen, then we should be making an educated guess. Some proposed
1418 heuristics for ELF include:
1420 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1421 program will be doing dynamic loading, which will likely
1422 need the shared libgcc.
1424 (2) If "-ldl", then it's also a fair bet that we're doing
1427 (3) For each ET_DYN we're linking against (either through -lfoo
1428 or /some/path/foo.so), check to see whether it or one of
1429 its dependencies depends on a shared libgcc.
1433 If the runtime is fixed to look for program headers instead
1434 of calling __register_frame_info at all, for each object,
1435 use the shared libgcc if any EH symbol referenced.
1437 If crtstuff is fixed to not invoke __register_frame_info
1438 automatically, for each object, use the shared libgcc if
1439 any non-empty unwind section found.
1441 Doing any of this probably requires invoking an external program to
1442 do the actual object file scanning. */
1444 const char *p
= libgcc_spec
;
1447 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1448 when given the proper command line arguments. */
1451 if (in_sep
&& *p
== '-' && strncmp (p
, "-lgcc", 5) == 0)
1453 init_gcc_specs (&obstack
,
1455 #ifdef USE_LIBUNWIND_EXCEPTIONS
1461 #ifdef USE_LIBUNWIND_EXCEPTIONS
1462 # ifdef HAVE_LD_STATIC_DYNAMIC
1463 " %{!static:" LD_STATIC_OPTION
"} -lunwind"
1464 " %{!static:" LD_DYNAMIC_OPTION
"}"
1474 else if (in_sep
&& *p
== 'l' && strncmp (p
, "libgcc.a%s", 10) == 0)
1476 /* Ug. We don't know shared library extensions. Hope that
1477 systems that use this form don't do shared libraries. */
1478 init_gcc_specs (&obstack
,
1482 #ifdef USE_LIBUNWIND_EXCEPTIONS
1491 obstack_1grow (&obstack
, *p
);
1492 in_sep
= (*p
== ' ');
1497 obstack_1grow (&obstack
, '\0');
1498 libgcc_spec
= XOBFINISH (&obstack
, const char *);
1501 #ifdef USE_AS_TRADITIONAL_FORMAT
1502 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1504 static const char tf
[] = "--traditional-format ";
1505 obstack_grow (&obstack
, tf
, sizeof(tf
) - 1);
1506 obstack_grow0 (&obstack
, asm_spec
, strlen (asm_spec
));
1507 asm_spec
= XOBFINISH (&obstack
, const char *);
1511 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC || \
1512 defined LINKER_HASH_STYLE
1513 # ifdef LINK_BUILDID_SPEC
1514 /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. */
1515 obstack_grow (&obstack
, LINK_BUILDID_SPEC
, sizeof(LINK_BUILDID_SPEC
) - 1);
1517 # ifdef LINK_EH_SPEC
1518 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1519 obstack_grow (&obstack
, LINK_EH_SPEC
, sizeof(LINK_EH_SPEC
) - 1);
1521 # ifdef LINKER_HASH_STYLE
1522 /* Prepend --hash-style=LINKER_HASH_STYLE to whatever link_spec we had
1525 static const char hash_style
[] = "--hash-style=";
1526 obstack_grow (&obstack
, hash_style
, sizeof(hash_style
) - 1);
1527 obstack_grow (&obstack
, LINKER_HASH_STYLE
, sizeof(LINKER_HASH_STYLE
) - 1);
1528 obstack_1grow (&obstack
, ' ');
1531 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
1532 link_spec
= XOBFINISH (&obstack
, const char *);
1538 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1539 removed; If the spec starts with a + then SPEC is added to the end of the
1543 set_spec (const char *name
, const char *spec
, bool user_p
)
1545 struct spec_list
*sl
;
1546 const char *old_spec
;
1547 int name_len
= strlen (name
);
1550 /* If this is the first call, initialize the statically allocated specs. */
1553 struct spec_list
*next
= (struct spec_list
*) 0;
1554 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1556 sl
= &static_specs
[i
];
1563 /* See if the spec already exists. */
1564 for (sl
= specs
; sl
; sl
= sl
->next
)
1565 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, name
))
1570 /* Not found - make it. */
1571 sl
= XNEW (struct spec_list
);
1572 sl
->name
= xstrdup (name
);
1573 sl
->name_len
= name_len
;
1574 sl
->ptr_spec
= &sl
->ptr
;
1576 *(sl
->ptr_spec
) = "";
1581 old_spec
= *(sl
->ptr_spec
);
1582 *(sl
->ptr_spec
) = ((spec
[0] == '+' && ISSPACE ((unsigned char)spec
[1]))
1583 ? concat (old_spec
, spec
+ 1, NULL
)
1588 fnotice (stderr
, "Setting spec %s to '%s'\n\n", name
, *(sl
->ptr_spec
));
1591 /* Free the old spec. */
1592 if (old_spec
&& sl
->alloc_p
)
1593 free (CONST_CAST(char *, old_spec
));
1595 sl
->user_p
= user_p
;
1599 /* Accumulate a command (program name and args), and run it. */
1601 typedef const char *const_char_p
; /* For DEF_VEC_P. */
1603 /* Vector of pointers to arguments in the current line of specifications. */
1605 static vec
<const_char_p
> argbuf
;
1607 /* Position in the argbuf vector containing the name of the output file
1608 (the value associated with the "-o" flag). */
1610 static int have_o_argbuf_index
= 0;
1612 /* Were the options -c, -S or -E passed. */
1613 static int have_c
= 0;
1615 /* Was the option -o passed. */
1616 static int have_o
= 0;
1618 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1619 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
1622 static struct temp_name
{
1623 const char *suffix
; /* suffix associated with the code. */
1624 int length
; /* strlen (suffix). */
1625 int unique
; /* Indicates whether %g or %u/%U was used. */
1626 const char *filename
; /* associated filename. */
1627 int filename_length
; /* strlen (filename). */
1628 struct temp_name
*next
;
1631 /* Number of commands executed so far. */
1633 static int execution_count
;
1635 /* Number of commands that exited with a signal. */
1637 static int signal_count
;
1639 /* Allocate the argument vector. */
1647 /* Clear out the vector of arguments (after a command is executed). */
1652 argbuf
.truncate (0);
1655 /* Add one argument to the vector at the end.
1656 This is done when a space is seen or at the end of the line.
1657 If DELETE_ALWAYS is nonzero, the arg is a filename
1658 and the file should be deleted eventually.
1659 If DELETE_FAILURE is nonzero, the arg is a filename
1660 and the file should be deleted if this compilation fails. */
1663 store_arg (const char *arg
, int delete_always
, int delete_failure
)
1665 argbuf
.safe_push (arg
);
1667 if (strcmp (arg
, "-o") == 0)
1668 have_o_argbuf_index
= argbuf
.length ();
1669 if (delete_always
|| delete_failure
)
1672 /* If the temporary file we should delete is specified as
1673 part of a joined argument extract the filename. */
1675 && (p
= strrchr (arg
, '=')))
1677 record_temp_file (arg
, delete_always
, delete_failure
);
1681 /* Load specs from a file name named FILENAME, replacing occurrences of
1682 various different types of line-endings, \r\n, \n\r and just \r, with
1686 load_specs (const char *filename
)
1690 struct stat statbuf
;
1697 fnotice (stderr
, "Reading specs from %s\n", filename
);
1699 /* Open and stat the file. */
1700 desc
= open (filename
, O_RDONLY
, 0);
1702 pfatal_with_name (filename
);
1703 if (stat (filename
, &statbuf
) < 0)
1704 pfatal_with_name (filename
);
1706 /* Read contents of file into BUFFER. */
1707 buffer
= XNEWVEC (char, statbuf
.st_size
+ 1);
1708 readlen
= read (desc
, buffer
, (unsigned) statbuf
.st_size
);
1710 pfatal_with_name (filename
);
1711 buffer
[readlen
] = 0;
1714 specs
= XNEWVEC (char, readlen
+ 1);
1716 for (buffer_p
= buffer
; buffer_p
&& *buffer_p
; buffer_p
++)
1722 if (buffer_p
> buffer
&& *(buffer_p
- 1) == '\n') /* \n\r */
1724 else if (*(buffer_p
+ 1) == '\n') /* \r\n */
1738 /* Read compilation specs from a file named FILENAME,
1739 replacing the default ones.
1741 A suffix which starts with `*' is a definition for
1742 one of the machine-specific sub-specs. The "suffix" should be
1743 *asm, *cc1, *cpp, *link, *startfile, etc.
1744 The corresponding spec is stored in asm_spec, etc.,
1745 rather than in the `compilers' vector.
1747 Anything invalid in the file is a fatal error. */
1750 read_specs (const char *filename
, bool main_p
, bool user_p
)
1755 buffer
= load_specs (filename
);
1757 /* Scan BUFFER for specs, putting them in the vector. */
1763 char *in
, *out
, *p1
, *p2
, *p3
;
1765 /* Advance P in BUFFER to the next nonblank nocomment line. */
1766 p
= skip_whitespace (p
);
1770 /* Is this a special command that starts with '%'? */
1771 /* Don't allow this for the main specs file, since it would
1772 encourage people to overwrite it. */
1773 if (*p
== '%' && !main_p
)
1776 while (*p
&& *p
!= '\n')
1782 if (!strncmp (p1
, "%include", sizeof ("%include") - 1)
1783 && (p1
[sizeof "%include" - 1] == ' '
1784 || p1
[sizeof "%include" - 1] == '\t'))
1788 p1
+= sizeof ("%include");
1789 while (*p1
== ' ' || *p1
== '\t')
1792 if (*p1
++ != '<' || p
[-2] != '>')
1793 fatal_error ("specs %%include syntax malformed after "
1795 (long) (p1
- buffer
+ 1));
1798 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
1799 read_specs (new_filename
? new_filename
: p1
, false, user_p
);
1802 else if (!strncmp (p1
, "%include_noerr", sizeof "%include_noerr" - 1)
1803 && (p1
[sizeof "%include_noerr" - 1] == ' '
1804 || p1
[sizeof "%include_noerr" - 1] == '\t'))
1808 p1
+= sizeof "%include_noerr";
1809 while (*p1
== ' ' || *p1
== '\t')
1812 if (*p1
++ != '<' || p
[-2] != '>')
1813 fatal_error ("specs %%include syntax malformed after "
1815 (long) (p1
- buffer
+ 1));
1818 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
1820 read_specs (new_filename
, false, user_p
);
1821 else if (verbose_flag
)
1822 fnotice (stderr
, "could not find specs file %s\n", p1
);
1825 else if (!strncmp (p1
, "%rename", sizeof "%rename" - 1)
1826 && (p1
[sizeof "%rename" - 1] == ' '
1827 || p1
[sizeof "%rename" - 1] == '\t'))
1830 struct spec_list
*sl
;
1831 struct spec_list
*newsl
;
1833 /* Get original name. */
1834 p1
+= sizeof "%rename";
1835 while (*p1
== ' ' || *p1
== '\t')
1838 if (! ISALPHA ((unsigned char) *p1
))
1839 fatal_error ("specs %%rename syntax malformed after "
1841 (long) (p1
- buffer
));
1844 while (*p2
&& !ISSPACE ((unsigned char) *p2
))
1847 if (*p2
!= ' ' && *p2
!= '\t')
1848 fatal_error ("specs %%rename syntax malformed after "
1850 (long) (p2
- buffer
));
1854 while (*p2
== ' ' || *p2
== '\t')
1857 if (! ISALPHA ((unsigned char) *p2
))
1858 fatal_error ("specs %%rename syntax malformed after "
1860 (long) (p2
- buffer
));
1862 /* Get new spec name. */
1864 while (*p3
&& !ISSPACE ((unsigned char) *p3
))
1868 fatal_error ("specs %%rename syntax malformed after "
1870 (long) (p3
- buffer
));
1873 for (sl
= specs
; sl
; sl
= sl
->next
)
1874 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, p1
))
1878 fatal_error ("specs %s spec was not found to be renamed", p1
);
1880 if (strcmp (p1
, p2
) == 0)
1883 for (newsl
= specs
; newsl
; newsl
= newsl
->next
)
1884 if (strcmp (newsl
->name
, p2
) == 0)
1885 fatal_error ("%s: attempt to rename spec %qs to "
1886 "already defined spec %qs",
1891 fnotice (stderr
, "rename spec %s to %s\n", p1
, p2
);
1893 fnotice (stderr
, "spec is '%s'\n\n", *(sl
->ptr_spec
));
1897 set_spec (p2
, *(sl
->ptr_spec
), user_p
);
1899 free (CONST_CAST (char *, *(sl
->ptr_spec
)));
1901 *(sl
->ptr_spec
) = "";
1906 fatal_error ("specs unknown %% command after %ld characters",
1907 (long) (p1
- buffer
));
1910 /* Find the colon that should end the suffix. */
1912 while (*p1
&& *p1
!= ':' && *p1
!= '\n')
1915 /* The colon shouldn't be missing. */
1917 fatal_error ("specs file malformed after %ld characters",
1918 (long) (p1
- buffer
));
1920 /* Skip back over trailing whitespace. */
1922 while (p2
> buffer
&& (p2
[-1] == ' ' || p2
[-1] == '\t'))
1925 /* Copy the suffix to a string. */
1926 suffix
= save_string (p
, p2
- p
);
1927 /* Find the next line. */
1928 p
= skip_whitespace (p1
+ 1);
1930 fatal_error ("specs file malformed after %ld characters",
1931 (long) (p
- buffer
));
1934 /* Find next blank line or end of string. */
1935 while (*p1
&& !(*p1
== '\n' && (p1
[1] == '\n' || p1
[1] == '\0')))
1938 /* Specs end at the blank line and do not include the newline. */
1939 spec
= save_string (p
, p1
- p
);
1942 /* Delete backslash-newline sequences from the spec. */
1947 if (in
[0] == '\\' && in
[1] == '\n')
1949 else if (in
[0] == '#')
1950 while (*in
&& *in
!= '\n')
1958 if (suffix
[0] == '*')
1960 if (! strcmp (suffix
, "*link_command"))
1961 link_command_spec
= spec
;
1963 set_spec (suffix
+ 1, spec
, user_p
);
1967 /* Add this pair to the vector. */
1969 = XRESIZEVEC (struct compiler
, compilers
, n_compilers
+ 2);
1971 compilers
[n_compilers
].suffix
= suffix
;
1972 compilers
[n_compilers
].spec
= spec
;
1974 memset (&compilers
[n_compilers
], 0, sizeof compilers
[n_compilers
]);
1978 link_command_spec
= spec
;
1981 if (link_command_spec
== 0)
1982 fatal_error ("spec file has no spec for linking");
1985 /* Record the names of temporary files we tell compilers to write,
1986 and delete them at the end of the run. */
1988 /* This is the common prefix we use to make temp file names.
1989 It is chosen once for each run of this program.
1990 It is substituted into a spec by %g or %j.
1991 Thus, all temp file names contain this prefix.
1992 In practice, all temp file names start with this prefix.
1994 This prefix comes from the envvar TMPDIR if it is defined;
1995 otherwise, from the P_tmpdir macro if that is defined;
1996 otherwise, in /usr/tmp or /tmp;
1997 or finally the current directory if all else fails. */
1999 static const char *temp_filename
;
2001 /* Length of the prefix. */
2003 static int temp_filename_length
;
2005 /* Define the list of temporary files to delete. */
2010 struct temp_file
*next
;
2013 /* Queue of files to delete on success or failure of compilation. */
2014 static struct temp_file
*always_delete_queue
;
2015 /* Queue of files to delete on failure of compilation. */
2016 static struct temp_file
*failure_delete_queue
;
2018 /* Record FILENAME as a file to be deleted automatically.
2019 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2020 otherwise delete it in any case.
2021 FAIL_DELETE nonzero means delete it if a compilation step fails;
2022 otherwise delete it in any case. */
2025 record_temp_file (const char *filename
, int always_delete
, int fail_delete
)
2027 char *const name
= xstrdup (filename
);
2031 struct temp_file
*temp
;
2032 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2033 if (! filename_cmp (name
, temp
->name
))
2036 temp
= XNEW (struct temp_file
);
2037 temp
->next
= always_delete_queue
;
2039 always_delete_queue
= temp
;
2046 struct temp_file
*temp
;
2047 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2048 if (! filename_cmp (name
, temp
->name
))
2054 temp
= XNEW (struct temp_file
);
2055 temp
->next
= failure_delete_queue
;
2057 failure_delete_queue
= temp
;
2063 /* Delete all the temporary files whose names we previously recorded. */
2065 #ifndef DELETE_IF_ORDINARY
2066 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2069 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2070 if (unlink (NAME) < 0) \
2072 perror_with_name (NAME); \
2077 delete_if_ordinary (const char *name
)
2083 printf ("Delete %s? (y or n) ", name
);
2087 while ((c
= getchar ()) != '\n' && c
!= EOF
)
2090 if (i
== 'y' || i
== 'Y')
2092 DELETE_IF_ORDINARY (name
, st
, verbose_flag
);
2096 delete_temp_files (void)
2098 struct temp_file
*temp
;
2100 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2101 delete_if_ordinary (temp
->name
);
2102 always_delete_queue
= 0;
2105 /* Delete all the files to be deleted on error. */
2108 delete_failure_queue (void)
2110 struct temp_file
*temp
;
2112 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2113 delete_if_ordinary (temp
->name
);
2117 clear_failure_queue (void)
2119 failure_delete_queue
= 0;
2122 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2124 If DO_MULTI is true iterate over the paths twice, first with multilib
2125 suffix then without, otherwise iterate over the paths once without
2126 adding a multilib suffix. When DO_MULTI is true, some attempt is made
2127 to avoid visiting the same path twice, but we could do better. For
2128 instance, /usr/lib/../lib is considered different from /usr/lib.
2129 At least EXTRA_SPACE chars past the end of the path passed to
2130 CALLBACK are available for use by the callback.
2131 CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2133 Returns the value returned by CALLBACK. */
2136 for_each_path (const struct path_prefix
*paths
,
2139 void *(*callback
) (char *, void *),
2140 void *callback_info
)
2142 struct prefix_list
*pl
;
2143 const char *multi_dir
= NULL
;
2144 const char *multi_os_dir
= NULL
;
2145 const char *multiarch_suffix
= NULL
;
2146 const char *multi_suffix
;
2147 const char *just_multi_suffix
;
2150 bool skip_multi_dir
= false;
2151 bool skip_multi_os_dir
= false;
2153 multi_suffix
= machine_suffix
;
2154 just_multi_suffix
= just_machine_suffix
;
2155 if (do_multi
&& multilib_dir
&& strcmp (multilib_dir
, ".") != 0)
2157 multi_dir
= concat (multilib_dir
, dir_separator_str
, NULL
);
2158 multi_suffix
= concat (multi_suffix
, multi_dir
, NULL
);
2159 just_multi_suffix
= concat (just_multi_suffix
, multi_dir
, NULL
);
2161 if (do_multi
&& multilib_os_dir
&& strcmp (multilib_os_dir
, ".") != 0)
2162 multi_os_dir
= concat (multilib_os_dir
, dir_separator_str
, NULL
);
2164 multiarch_suffix
= concat (multiarch_dir
, dir_separator_str
, NULL
);
2168 size_t multi_dir_len
= 0;
2169 size_t multi_os_dir_len
= 0;
2170 size_t multiarch_len
= 0;
2172 size_t just_suffix_len
;
2176 multi_dir_len
= strlen (multi_dir
);
2178 multi_os_dir_len
= strlen (multi_os_dir
);
2179 if (multiarch_suffix
)
2180 multiarch_len
= strlen (multiarch_suffix
);
2181 suffix_len
= strlen (multi_suffix
);
2182 just_suffix_len
= strlen (just_multi_suffix
);
2186 len
= paths
->max_len
+ extra_space
+ 1;
2187 len
+= MAX (MAX (suffix_len
, multi_os_dir_len
), multiarch_len
);
2188 path
= XNEWVEC (char, len
);
2191 for (pl
= paths
->plist
; pl
!= 0; pl
= pl
->next
)
2193 len
= strlen (pl
->prefix
);
2194 memcpy (path
, pl
->prefix
, len
);
2196 /* Look first in MACHINE/VERSION subdirectory. */
2197 if (!skip_multi_dir
)
2199 memcpy (path
+ len
, multi_suffix
, suffix_len
+ 1);
2200 ret
= callback (path
, callback_info
);
2205 /* Some paths are tried with just the machine (ie. target)
2206 subdir. This is used for finding as, ld, etc. */
2208 && pl
->require_machine_suffix
== 2)
2210 memcpy (path
+ len
, just_multi_suffix
, just_suffix_len
+ 1);
2211 ret
= callback (path
, callback_info
);
2216 /* Now try the multiarch path. */
2218 && !pl
->require_machine_suffix
&& multiarch_dir
)
2220 memcpy (path
+ len
, multiarch_suffix
, multiarch_len
+ 1);
2221 ret
= callback (path
, callback_info
);
2226 /* Now try the base path. */
2227 if (!pl
->require_machine_suffix
2228 && !(pl
->os_multilib
? skip_multi_os_dir
: skip_multi_dir
))
2230 const char *this_multi
;
2231 size_t this_multi_len
;
2233 if (pl
->os_multilib
)
2235 this_multi
= multi_os_dir
;
2236 this_multi_len
= multi_os_dir_len
;
2240 this_multi
= multi_dir
;
2241 this_multi_len
= multi_dir_len
;
2245 memcpy (path
+ len
, this_multi
, this_multi_len
+ 1);
2249 ret
= callback (path
, callback_info
);
2257 if (multi_dir
== NULL
&& multi_os_dir
== NULL
)
2260 /* Run through the paths again, this time without multilibs.
2261 Don't repeat any we have already seen. */
2264 free (CONST_CAST (char *, multi_dir
));
2266 free (CONST_CAST (char *, multi_suffix
));
2267 multi_suffix
= machine_suffix
;
2268 free (CONST_CAST (char *, just_multi_suffix
));
2269 just_multi_suffix
= just_machine_suffix
;
2272 skip_multi_dir
= true;
2275 free (CONST_CAST (char *, multi_os_dir
));
2276 multi_os_dir
= NULL
;
2279 skip_multi_os_dir
= true;
2284 free (CONST_CAST (char *, multi_dir
));
2285 free (CONST_CAST (char *, multi_suffix
));
2286 free (CONST_CAST (char *, just_multi_suffix
));
2289 free (CONST_CAST (char *, multi_os_dir
));
2295 /* Callback for build_search_list. Adds path to obstack being built. */
2297 struct add_to_obstack_info
{
2304 add_to_obstack (char *path
, void *data
)
2306 struct add_to_obstack_info
*info
= (struct add_to_obstack_info
*) data
;
2308 if (info
->check_dir
&& !is_directory (path
, false))
2311 if (!info
->first_time
)
2312 obstack_1grow (info
->ob
, PATH_SEPARATOR
);
2314 obstack_grow (info
->ob
, path
, strlen (path
));
2316 info
->first_time
= false;
2320 /* Add or change the value of an environment variable, outputting the
2321 change to standard error if in verbose mode. */
2323 xputenv (const char *string
)
2326 fnotice (stderr
, "%s\n", string
);
2327 putenv (CONST_CAST (char *, string
));
2330 /* Build a list of search directories from PATHS.
2331 PREFIX is a string to prepend to the list.
2332 If CHECK_DIR_P is true we ensure the directory exists.
2333 If DO_MULTI is true, multilib paths are output first, then
2335 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2336 It is also used by the --print-search-dirs flag. */
2339 build_search_list (const struct path_prefix
*paths
, const char *prefix
,
2340 bool check_dir
, bool do_multi
)
2342 struct add_to_obstack_info info
;
2344 info
.ob
= &collect_obstack
;
2345 info
.check_dir
= check_dir
;
2346 info
.first_time
= true;
2348 obstack_grow (&collect_obstack
, prefix
, strlen (prefix
));
2349 obstack_1grow (&collect_obstack
, '=');
2351 for_each_path (paths
, do_multi
, 0, add_to_obstack
, &info
);
2353 obstack_1grow (&collect_obstack
, '\0');
2354 return XOBFINISH (&collect_obstack
, char *);
2357 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2361 putenv_from_prefixes (const struct path_prefix
*paths
, const char *env_var
,
2364 xputenv (build_search_list (paths
, env_var
, true, do_multi
));
2367 /* Check whether NAME can be accessed in MODE. This is like access,
2368 except that it never considers directories to be executable. */
2371 access_check (const char *name
, int mode
)
2377 if (stat (name
, &st
) < 0
2378 || S_ISDIR (st
.st_mode
))
2382 return access (name
, mode
);
2385 /* Callback for find_a_file. Appends the file name to the directory
2386 path. If the resulting file exists in the right mode, return the
2387 full pathname to the file. */
2389 struct file_at_path_info
{
2398 file_at_path (char *path
, void *data
)
2400 struct file_at_path_info
*info
= (struct file_at_path_info
*) data
;
2401 size_t len
= strlen (path
);
2403 memcpy (path
+ len
, info
->name
, info
->name_len
);
2404 len
+= info
->name_len
;
2406 /* Some systems have a suffix for executable files.
2407 So try appending that first. */
2408 if (info
->suffix_len
)
2410 memcpy (path
+ len
, info
->suffix
, info
->suffix_len
+ 1);
2411 if (access_check (path
, info
->mode
) == 0)
2416 if (access_check (path
, info
->mode
) == 0)
2422 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2423 access to check permissions. If DO_MULTI is true, search multilib
2424 paths then non-multilib paths, otherwise do not search multilib paths.
2425 Return 0 if not found, otherwise return its name, allocated with malloc. */
2428 find_a_file (const struct path_prefix
*pprefix
, const char *name
, int mode
,
2431 struct file_at_path_info info
;
2433 #ifdef DEFAULT_ASSEMBLER
2434 if (! strcmp (name
, "as") && access (DEFAULT_ASSEMBLER
, mode
) == 0)
2435 return xstrdup (DEFAULT_ASSEMBLER
);
2438 #ifdef DEFAULT_LINKER
2439 if (! strcmp(name
, "ld") && access (DEFAULT_LINKER
, mode
) == 0)
2440 return xstrdup (DEFAULT_LINKER
);
2443 /* Determine the filename to execute (special case for absolute paths). */
2445 if (IS_ABSOLUTE_PATH (name
))
2447 if (access (name
, mode
) == 0)
2448 return xstrdup (name
);
2454 info
.suffix
= (mode
& X_OK
) != 0 ? HOST_EXECUTABLE_SUFFIX
: "";
2455 info
.name_len
= strlen (info
.name
);
2456 info
.suffix_len
= strlen (info
.suffix
);
2459 return (char*) for_each_path (pprefix
, do_multi
,
2460 info
.name_len
+ info
.suffix_len
,
2461 file_at_path
, &info
);
2464 /* Ranking of prefixes in the sort list. -B prefixes are put before
2467 enum path_prefix_priority
2469 PREFIX_PRIORITY_B_OPT
,
2470 PREFIX_PRIORITY_LAST
2473 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
2474 order according to PRIORITY. Within each PRIORITY, new entries are
2477 If WARN is nonzero, we will warn if no file is found
2478 through this prefix. WARN should point to an int
2479 which will be set to 1 if this entry is used.
2481 COMPONENT is the value to be passed to update_path.
2483 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2484 the complete value of machine_suffix.
2485 2 means try both machine_suffix and just_machine_suffix. */
2488 add_prefix (struct path_prefix
*pprefix
, const char *prefix
,
2489 const char *component
, /* enum prefix_priority */ int priority
,
2490 int require_machine_suffix
, int os_multilib
)
2492 struct prefix_list
*pl
, **prev
;
2495 for (prev
= &pprefix
->plist
;
2496 (*prev
) != NULL
&& (*prev
)->priority
<= priority
;
2497 prev
= &(*prev
)->next
)
2500 /* Keep track of the longest prefix. */
2502 prefix
= update_path (prefix
, component
);
2503 len
= strlen (prefix
);
2504 if (len
> pprefix
->max_len
)
2505 pprefix
->max_len
= len
;
2507 pl
= XNEW (struct prefix_list
);
2508 pl
->prefix
= prefix
;
2509 pl
->require_machine_suffix
= require_machine_suffix
;
2510 pl
->priority
= priority
;
2511 pl
->os_multilib
= os_multilib
;
2513 /* Insert after PREV. */
2518 /* Same as add_prefix, but prepending target_system_root to prefix. */
2519 /* The target_system_root prefix has been relocated by gcc_exec_prefix. */
2521 add_sysrooted_prefix (struct path_prefix
*pprefix
, const char *prefix
,
2522 const char *component
,
2523 /* enum prefix_priority */ int priority
,
2524 int require_machine_suffix
, int os_multilib
)
2526 if (!IS_ABSOLUTE_PATH (prefix
))
2527 fatal_error ("system path %qs is not absolute", prefix
);
2529 if (target_system_root
)
2531 char *sysroot_no_trailing_dir_separator
= xstrdup (target_system_root
);
2532 size_t sysroot_len
= strlen (target_system_root
);
2535 && target_system_root
[sysroot_len
- 1] == DIR_SEPARATOR
)
2536 sysroot_no_trailing_dir_separator
[sysroot_len
- 1] = '\0';
2538 if (target_sysroot_suffix
)
2539 prefix
= concat (sysroot_no_trailing_dir_separator
,
2540 target_sysroot_suffix
, prefix
, NULL
);
2542 prefix
= concat (sysroot_no_trailing_dir_separator
, prefix
, NULL
);
2544 free (sysroot_no_trailing_dir_separator
);
2546 /* We have to override this because GCC's notion of sysroot
2547 moves along with GCC. */
2551 add_prefix (pprefix
, prefix
, component
, priority
,
2552 require_machine_suffix
, os_multilib
);
2555 /* Execute the command specified by the arguments on the current line of spec.
2556 When using pipes, this includes several piped-together commands
2557 with `|' between them.
2559 Return 0 if successful, -1 if failed. */
2565 int n_commands
; /* # of command. */
2567 struct pex_obj
*pex
;
2570 const char *prog
; /* program name. */
2571 const char **argv
; /* vector of args. */
2575 struct command
*commands
; /* each command buffer with above info. */
2577 gcc_assert (!processing_spec_function
);
2581 string
= find_a_file (&exec_prefixes
,
2582 argbuf
[0], X_OK
, false);
2585 insert_wrapper (wrapper_string
);
2588 /* Count # of piped commands. */
2589 for (n_commands
= 1, i
= 0; argbuf
.iterate (i
, &arg
); i
++)
2590 if (strcmp (arg
, "|") == 0)
2593 /* Get storage for each command. */
2594 commands
= (struct command
*) alloca (n_commands
* sizeof (struct command
));
2596 /* Split argbuf into its separate piped processes,
2597 and record info about each one.
2598 Also search for the programs that are to be run. */
2600 argbuf
.safe_push (0);
2602 commands
[0].prog
= argbuf
[0]; /* first command. */
2603 commands
[0].argv
= argbuf
.address ();
2605 if (!wrapper_string
)
2607 string
= find_a_file (&exec_prefixes
, commands
[0].prog
, X_OK
, false);
2608 commands
[0].argv
[0] = (string
) ? string
: commands
[0].argv
[0];
2611 for (n_commands
= 1, i
= 0; argbuf
.iterate (i
, &arg
); i
++)
2612 if (arg
&& strcmp (arg
, "|") == 0)
2613 { /* each command. */
2614 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2615 fatal_error ("-pipe not supported");
2617 argbuf
[i
] = 0; /* Termination of
2619 commands
[n_commands
].prog
= argbuf
[i
+ 1];
2620 commands
[n_commands
].argv
2621 = &(argbuf
.address ())[i
+ 1];
2622 string
= find_a_file (&exec_prefixes
, commands
[n_commands
].prog
,
2625 commands
[n_commands
].argv
[0] = string
;
2629 /* If -v, print what we are about to do, and maybe query. */
2633 /* For help listings, put a blank line between sub-processes. */
2634 if (print_help_list
)
2635 fputc ('\n', stderr
);
2637 /* Print each piped command as a separate line. */
2638 for (i
= 0; i
< n_commands
; i
++)
2640 const char *const *j
;
2642 if (verbose_only_flag
)
2644 for (j
= commands
[i
].argv
; *j
; j
++)
2647 for (p
= *j
; *p
; ++p
)
2648 if (!ISALNUM ((unsigned char) *p
)
2649 && *p
!= '_' && *p
!= '/' && *p
!= '-' && *p
!= '.')
2653 fprintf (stderr
, " \"");
2654 for (p
= *j
; *p
; ++p
)
2656 if (*p
== '"' || *p
== '\\' || *p
== '$')
2657 fputc ('\\', stderr
);
2660 fputc ('"', stderr
);
2662 /* If it's empty, print "". */
2664 fprintf (stderr
, " \"\"");
2666 fprintf (stderr
, " %s", *j
);
2670 for (j
= commands
[i
].argv
; *j
; j
++)
2671 /* If it's empty, print "". */
2673 fprintf (stderr
, " \"\"");
2675 fprintf (stderr
, " %s", *j
);
2677 /* Print a pipe symbol after all but the last command. */
2678 if (i
+ 1 != n_commands
)
2679 fprintf (stderr
, " |");
2680 fprintf (stderr
, "\n");
2683 if (verbose_only_flag
!= 0)
2685 /* verbose_only_flag should act as if the spec was
2686 executed, so increment execution_count before
2687 returning. This prevents spurious warnings about
2688 unused linker input files, etc. */
2693 fnotice (stderr
, "\nGo ahead? (y or n) ");
2697 while (getchar () != '\n')
2700 if (i
!= 'y' && i
!= 'Y')
2705 #ifdef ENABLE_VALGRIND_CHECKING
2706 /* Run the each command through valgrind. To simplify prepending the
2707 path to valgrind and the option "-q" (for quiet operation unless
2708 something triggers), we allocate a separate argv array. */
2710 for (i
= 0; i
< n_commands
; i
++)
2716 for (argc
= 0; commands
[i
].argv
[argc
] != NULL
; argc
++)
2719 argv
= XALLOCAVEC (const char *, argc
+ 3);
2721 argv
[0] = VALGRIND_PATH
;
2723 for (j
= 2; j
< argc
+ 2; j
++)
2724 argv
[j
] = commands
[i
].argv
[j
- 2];
2727 commands
[i
].argv
= argv
;
2728 commands
[i
].prog
= argv
[0];
2732 /* Run each piped subprocess. */
2734 pex
= pex_init (PEX_USE_PIPES
| ((report_times
|| report_times_to_file
)
2735 ? PEX_RECORD_TIMES
: 0),
2736 progname
, temp_filename
);
2738 fatal_error ("pex_init failed: %m");
2740 for (i
= 0; i
< n_commands
; i
++)
2744 const char *string
= commands
[i
].argv
[0];
2746 errmsg
= pex_run (pex
,
2747 ((i
+ 1 == n_commands
? PEX_LAST
: 0)
2748 | (string
== commands
[i
].prog
? PEX_SEARCH
: 0)),
2749 string
, CONST_CAST (char **, commands
[i
].argv
),
2754 fatal_error (errmsg
);
2758 pfatal_with_name (errmsg
);
2762 if (string
!= commands
[i
].prog
)
2763 free (CONST_CAST (char *, string
));
2768 /* Wait for all the subprocesses to finish. */
2772 struct pex_time
*times
= NULL
;
2775 statuses
= (int *) alloca (n_commands
* sizeof (int));
2776 if (!pex_get_status (pex
, n_commands
, statuses
))
2777 fatal_error ("failed to get exit status: %m");
2779 if (report_times
|| report_times_to_file
)
2781 times
= (struct pex_time
*) alloca (n_commands
* sizeof (struct pex_time
));
2782 if (!pex_get_times (pex
, n_commands
, times
))
2783 fatal_error ("failed to get process times: %m");
2788 for (i
= 0; i
< n_commands
; ++i
)
2790 int status
= statuses
[i
];
2792 if (WIFSIGNALED (status
))
2795 /* SIGPIPE is a special case. It happens in -pipe mode
2796 when the compiler dies before the preprocessor is done,
2797 or the assembler dies before the compiler is done.
2798 There's generally been an error already, and this is
2799 just fallout. So don't generate another error unless
2800 we would otherwise have succeeded. */
2801 if (WTERMSIG (status
) == SIGPIPE
2802 && (signal_count
|| greatest_status
>= MIN_FATAL_STATUS
))
2809 internal_error ("%s (program %s)",
2810 strsignal (WTERMSIG (status
)), commands
[i
].prog
);
2812 else if (WIFEXITED (status
)
2813 && WEXITSTATUS (status
) >= MIN_FATAL_STATUS
)
2815 if (WEXITSTATUS (status
) > greatest_status
)
2816 greatest_status
= WEXITSTATUS (status
);
2820 if (report_times
|| report_times_to_file
)
2822 struct pex_time
*pt
= ×
[i
];
2825 ut
= ((double) pt
->user_seconds
2826 + (double) pt
->user_microseconds
/ 1.0e6
);
2827 st
= ((double) pt
->system_seconds
2828 + (double) pt
->system_microseconds
/ 1.0e6
);
2833 fnotice (stderr
, "# %s %.2f %.2f\n",
2834 commands
[i
].prog
, ut
, st
);
2836 if (report_times_to_file
)
2839 const char *const *j
;
2841 fprintf (report_times_to_file
, "%g %g", ut
, st
);
2843 for (j
= &commands
[i
].prog
; *j
; j
= &commands
[i
].argv
[++c
])
2846 for (p
= *j
; *p
; ++p
)
2847 if (*p
== '"' || *p
== '\\' || *p
== '$'
2853 fprintf (report_times_to_file
, " \"");
2854 for (p
= *j
; *p
; ++p
)
2856 if (*p
== '"' || *p
== '\\' || *p
== '$')
2857 fputc ('\\', report_times_to_file
);
2858 fputc (*p
, report_times_to_file
);
2860 fputc ('"', report_times_to_file
);
2863 fprintf (report_times_to_file
, " %s", *j
);
2866 fputc ('\n', report_times_to_file
);
2876 /* Find all the switches given to us
2877 and make a vector describing them.
2878 The elements of the vector are strings, one per switch given.
2879 If a switch uses following arguments, then the `part1' field
2880 is the switch itself and the `args' field
2881 is a null-terminated vector containing the following arguments.
2882 Bits in the `live_cond' field are:
2883 SWITCH_LIVE to indicate this switch is true in a conditional spec.
2884 SWITCH_FALSE to indicate this switch is overridden by a later switch.
2885 SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
2886 SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored
2887 in all do_spec calls afterwards. Used for %<S from self specs.
2888 The `validated' field is nonzero if any spec has looked at this switch;
2889 if it remains zero at the end of the run, it must be meaningless. */
2891 #define SWITCH_LIVE (1 << 0)
2892 #define SWITCH_FALSE (1 << 1)
2893 #define SWITCH_IGNORE (1 << 2)
2894 #define SWITCH_IGNORE_PERMANENTLY (1 << 3)
2895 #define SWITCH_KEEP_FOR_GCC (1 << 4)
2901 unsigned int live_cond
;
2907 static struct switchstr
*switches
;
2909 static int n_switches
;
2911 static int n_switches_alloc
;
2913 /* Set to zero if -fcompare-debug is disabled, positive if it's
2914 enabled and we're running the first compilation, negative if it's
2915 enabled and we're running the second compilation. For most of the
2916 time, it's in the range -1..1, but it can be temporarily set to 2
2917 or 3 to indicate that the -fcompare-debug flags didn't come from
2918 the command-line, but rather from the GCC_COMPARE_DEBUG environment
2919 variable, until a synthesized -fcompare-debug flag is added to the
2923 /* Set to nonzero if we've seen the -fcompare-debug-second flag. */
2924 int compare_debug_second
;
2926 /* Set to the flags that should be passed to the second compilation in
2927 a -fcompare-debug compilation. */
2928 const char *compare_debug_opt
;
2930 static struct switchstr
*switches_debug_check
[2];
2932 static int n_switches_debug_check
[2];
2934 static int n_switches_alloc_debug_check
[2];
2936 static char *debug_check_temp_file
[2];
2938 /* Language is one of three things:
2940 1) The name of a real programming language.
2941 2) NULL, indicating that no one has figured out
2943 3) '*', indicating that the file should be passed
2948 const char *language
;
2949 struct compiler
*incompiler
;
2954 /* Also a vector of input files specified. */
2956 static struct infile
*infiles
;
2960 static int n_infiles_alloc
;
2962 /* True if multiple input files are being compiled to a single
2965 static bool combine_inputs
;
2967 /* This counts the number of libraries added by lang_specific_driver, so that
2968 we can tell if there were any user supplied any files or libraries. */
2970 static int added_libraries
;
2972 /* And a vector of corresponding output files is made up later. */
2974 const char **outfiles
;
2976 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2978 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
2979 is true if we should look for an executable suffix. DO_OBJ
2980 is true if we should look for an object suffix. */
2983 convert_filename (const char *name
, int do_exe ATTRIBUTE_UNUSED
,
2984 int do_obj ATTRIBUTE_UNUSED
)
2986 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2994 len
= strlen (name
);
2996 #ifdef HAVE_TARGET_OBJECT_SUFFIX
2997 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
2998 if (do_obj
&& len
> 2
2999 && name
[len
- 2] == '.'
3000 && name
[len
- 1] == 'o')
3002 obstack_grow (&obstack
, name
, len
- 2);
3003 obstack_grow0 (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
3004 name
= XOBFINISH (&obstack
, const char *);
3008 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3009 /* If there is no filetype, make it the executable suffix (which includes
3010 the "."). But don't get confused if we have just "-o". */
3011 if (! do_exe
|| TARGET_EXECUTABLE_SUFFIX
[0] == 0 || (len
== 2 && name
[0] == '-'))
3014 for (i
= len
- 1; i
>= 0; i
--)
3015 if (IS_DIR_SEPARATOR (name
[i
]))
3018 for (i
++; i
< len
; i
++)
3022 obstack_grow (&obstack
, name
, len
);
3023 obstack_grow0 (&obstack
, TARGET_EXECUTABLE_SUFFIX
,
3024 strlen (TARGET_EXECUTABLE_SUFFIX
));
3025 name
= XOBFINISH (&obstack
, const char *);
3032 /* Display the command line switches accepted by gcc. */
3036 printf (_("Usage: %s [options] file...\n"), progname
);
3037 fputs (_("Options:\n"), stdout
);
3039 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout
);
3040 fputs (_(" --help Display this information\n"), stdout
);
3041 fputs (_(" --target-help Display target specific command line options\n"), stdout
);
3042 fputs (_(" --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...]\n"), stdout
);
3043 fputs (_(" Display specific types of command line options\n"), stdout
);
3045 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout
);
3046 fputs (_(" --version Display compiler version information\n"), stdout
);
3047 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout
);
3048 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout
);
3049 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout
);
3050 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout
);
3051 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout
);
3052 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout
);
3053 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout
);
3055 -print-multiarch Display the target's normalized GNU triplet, used as\n\
3056 a component in the library path\n"), stdout
);
3057 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout
);
3059 -print-multi-lib Display the mapping between command line options and\n\
3060 multiple library search directories\n"), stdout
);
3061 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries\n"), stdout
);
3062 fputs (_(" -print-sysroot Display the target libraries directory\n"), stdout
);
3063 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n"), stdout
);
3064 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout
);
3065 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout
);
3066 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout
);
3067 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler\n"), stdout
);
3068 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n"), stdout
);
3069 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout
);
3070 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout
);
3071 fputs (_(" -save-temps=<arg> Do not delete intermediate files\n"), stdout
);
3073 -no-canonical-prefixes Do not canonicalize paths when building relative\n\
3074 prefixes to other gcc components\n"), stdout
);
3075 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout
);
3076 fputs (_(" -time Time the execution of each subprocess\n"), stdout
);
3077 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout
);
3078 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout
);
3080 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3081 and libraries\n"), stdout
);
3082 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout
);
3083 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout
);
3084 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout
);
3085 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout
);
3086 fputs (_(" -S Compile only; do not assemble or link\n"), stdout
);
3087 fputs (_(" -c Compile and assemble, but do not link\n"), stdout
);
3088 fputs (_(" -o <file> Place the output into <file>\n"), stdout
);
3089 fputs (_(" -pie Create a position independent executable\n"), stdout
);
3090 fputs (_(" -shared Create a shared library\n"), stdout
);
3092 -x <language> Specify the language of the following input files\n\
3093 Permissible languages include: c c++ assembler none\n\
3094 'none' means revert to the default behavior of\n\
3095 guessing the language based on the file's extension\n\
3099 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3100 passed on to the various sub-processes invoked by %s. In order to pass\n\
3101 other options on to these processes the -W<letter> options must be used.\n\
3104 /* The rest of the options are displayed by invocations of the various
3109 add_preprocessor_option (const char *option
, int len
)
3111 preprocessor_options
.safe_push (save_string (option
, len
));
3115 add_assembler_option (const char *option
, int len
)
3117 assembler_options
.safe_push (save_string (option
, len
));
3121 add_linker_option (const char *option
, int len
)
3123 linker_options
.safe_push (save_string (option
, len
));
3126 /* Allocate space for an input file in infiles. */
3131 if (n_infiles_alloc
== 0)
3133 n_infiles_alloc
= 16;
3134 infiles
= XNEWVEC (struct infile
, n_infiles_alloc
);
3136 else if (n_infiles_alloc
== n_infiles
)
3138 n_infiles_alloc
*= 2;
3139 infiles
= XRESIZEVEC (struct infile
, infiles
, n_infiles_alloc
);
3143 /* Store an input file with the given NAME and LANGUAGE in
3147 add_infile (const char *name
, const char *language
)
3150 infiles
[n_infiles
].name
= name
;
3151 infiles
[n_infiles
++].language
= language
;
3154 /* Allocate space for a switch in switches. */
3159 if (n_switches_alloc
== 0)
3161 n_switches_alloc
= 16;
3162 switches
= XNEWVEC (struct switchstr
, n_switches_alloc
);
3164 else if (n_switches_alloc
== n_switches
)
3166 n_switches_alloc
*= 2;
3167 switches
= XRESIZEVEC (struct switchstr
, switches
, n_switches_alloc
);
3171 /* Save an option OPT with N_ARGS arguments in array ARGS, marking it
3172 as validated if VALIDATED and KNOWN if it is an internal switch. */
3175 save_switch (const char *opt
, size_t n_args
, const char *const *args
,
3176 bool validated
, bool known
)
3179 switches
[n_switches
].part1
= opt
+ 1;
3181 switches
[n_switches
].args
= 0;
3184 switches
[n_switches
].args
= XNEWVEC (const char *, n_args
+ 1);
3185 memcpy (switches
[n_switches
].args
, args
, n_args
* sizeof (const char *));
3186 switches
[n_switches
].args
[n_args
] = NULL
;
3189 switches
[n_switches
].live_cond
= 0;
3190 switches
[n_switches
].validated
= validated
;
3191 switches
[n_switches
].known
= known
;
3192 switches
[n_switches
].ordering
= 0;
3196 /* Handle an option DECODED that is unknown to the option-processing
3200 driver_unknown_option_callback (const struct cl_decoded_option
*decoded
)
3202 const char *opt
= decoded
->arg
;
3203 if (opt
[1] == 'W' && opt
[2] == 'n' && opt
[3] == 'o' && opt
[4] == '-'
3204 && !(decoded
->errors
& CL_ERR_NEGATIVE
))
3206 /* Leave unknown -Wno-* options for the compiler proper, to be
3207 diagnosed only if there are warnings. */
3208 save_switch (decoded
->canonical_option
[0],
3209 decoded
->canonical_option_num_elements
- 1,
3210 &decoded
->canonical_option
[1], false, true);
3213 if (decoded
->opt_index
== OPT_SPECIAL_unknown
)
3215 /* Give it a chance to define it a a spec file. */
3216 save_switch (decoded
->canonical_option
[0],
3217 decoded
->canonical_option_num_elements
- 1,
3218 &decoded
->canonical_option
[1], false, false);
3225 /* Handle an option DECODED that is not marked as CL_DRIVER.
3226 LANG_MASK will always be CL_DRIVER. */
3229 driver_wrong_lang_callback (const struct cl_decoded_option
*decoded
,
3230 unsigned int lang_mask ATTRIBUTE_UNUSED
)
3232 /* At this point, non-driver options are accepted (and expected to
3233 be passed down by specs) unless marked to be rejected by the
3234 driver. Options to be rejected by the driver but accepted by the
3235 compilers proper are treated just like completely unknown
3237 const struct cl_option
*option
= &cl_options
[decoded
->opt_index
];
3239 if (option
->cl_reject_driver
)
3240 error ("unrecognized command line option %qs",
3241 decoded
->orig_option_with_args_text
);
3243 save_switch (decoded
->canonical_option
[0],
3244 decoded
->canonical_option_num_elements
- 1,
3245 &decoded
->canonical_option
[1], false, true);
3248 static const char *spec_lang
= 0;
3249 static int last_language_n_infiles
;
3251 /* Handle a driver option; arguments and return value as for
3255 driver_handle_option (struct gcc_options
*opts
,
3256 struct gcc_options
*opts_set
,
3257 const struct cl_decoded_option
*decoded
,
3258 unsigned int lang_mask ATTRIBUTE_UNUSED
, int kind
,
3260 const struct cl_option_handlers
*handlers ATTRIBUTE_UNUSED
,
3261 diagnostic_context
*dc
)
3263 size_t opt_index
= decoded
->opt_index
;
3264 const char *arg
= decoded
->arg
;
3265 const char *compare_debug_replacement_opt
;
3266 int value
= decoded
->value
;
3267 bool validated
= false;
3268 bool do_save
= true;
3270 gcc_assert (opts
== &global_options
);
3271 gcc_assert (opts_set
== &global_options_set
);
3272 gcc_assert (kind
== DK_UNSPECIFIED
);
3273 gcc_assert (loc
== UNKNOWN_LOCATION
);
3274 gcc_assert (dc
== global_dc
);
3280 struct spec_list
*sl
;
3282 for (sl
= specs
; sl
; sl
= sl
->next
)
3283 printf ("*%s:\n%s\n\n", sl
->name
, *(sl
->ptr_spec
));
3284 if (link_command_spec
)
3285 printf ("*link_command:\n%s\n\n", link_command_spec
);
3289 case OPT_dumpversion
:
3290 printf ("%s\n", spec_version
);
3293 case OPT_dumpmachine
:
3294 printf ("%s\n", spec_machine
);
3300 /* CPP driver cannot obtain switch from cc1_options. */
3302 add_preprocessor_option ("--version", strlen ("--version"));
3303 add_assembler_option ("--version", strlen ("--version"));
3304 add_linker_option ("--version", strlen ("--version"));
3308 print_help_list
= 1;
3310 /* CPP driver cannot obtain switch from cc1_options. */
3312 add_preprocessor_option ("--help", 6);
3313 add_assembler_option ("--help", 6);
3314 add_linker_option ("--help", 6);
3318 print_subprocess_help
= 2;
3321 case OPT__target_help
:
3322 print_subprocess_help
= 1;
3324 /* CPP driver cannot obtain switch from cc1_options. */
3326 add_preprocessor_option ("--target-help", 13);
3327 add_assembler_option ("--target-help", 13);
3328 add_linker_option ("--target-help", 13);
3331 case OPT__no_sysroot_suffix
:
3332 case OPT_pass_exit_codes
:
3333 case OPT_print_search_dirs
:
3334 case OPT_print_file_name_
:
3335 case OPT_print_prog_name_
:
3336 case OPT_print_multi_lib
:
3337 case OPT_print_multi_directory
:
3338 case OPT_print_sysroot
:
3339 case OPT_print_multi_os_directory
:
3340 case OPT_print_multiarch
:
3341 case OPT_print_sysroot_headers_suffix
:
3344 /* These options set the variables specified in common.opt
3345 automatically, and do not need to be saved for spec
3350 case OPT_print_libgcc_file_name
:
3351 print_file_name
= "libgcc.a";
3355 case OPT_fcompare_debug_second
:
3356 compare_debug_second
= 1;
3359 case OPT_fcompare_debug
:
3363 compare_debug_replacement_opt
= "-fcompare-debug=";
3365 goto compare_debug_with_arg
;
3368 compare_debug_replacement_opt
= "-fcompare-debug=-gtoggle";
3370 goto compare_debug_with_arg
;
3377 case OPT_fcompare_debug_
:
3378 compare_debug_replacement_opt
= decoded
->canonical_option
[0];
3379 compare_debug_with_arg
:
3380 gcc_assert (decoded
->canonical_option_num_elements
== 1);
3381 gcc_assert (arg
!= NULL
);
3386 if (compare_debug
< 0)
3387 compare_debug_opt
= NULL
;
3389 compare_debug_opt
= arg
;
3390 save_switch (compare_debug_replacement_opt
, 0, NULL
, validated
, true);
3396 /* Pass the rest of this option to the assembler. */
3398 /* Split the argument at commas. */
3400 for (j
= 0; arg
[j
]; j
++)
3403 add_assembler_option (arg
+ prev
, j
- prev
);
3407 /* Record the part after the last comma. */
3408 add_assembler_option (arg
+ prev
, j
- prev
);
3416 /* Pass the rest of this option to the preprocessor. */
3418 /* Split the argument at commas. */
3420 for (j
= 0; arg
[j
]; j
++)
3423 add_preprocessor_option (arg
+ prev
, j
- prev
);
3427 /* Record the part after the last comma. */
3428 add_preprocessor_option (arg
+ prev
, j
- prev
);
3436 /* Split the argument at commas. */
3438 for (j
= 0; arg
[j
]; j
++)
3441 add_infile (save_string (arg
+ prev
, j
- prev
), "*");
3444 /* Record the part after the last comma. */
3445 add_infile (arg
+ prev
, "*");
3451 add_infile (arg
, "*");
3455 case OPT_Xpreprocessor
:
3456 add_preprocessor_option (arg
, strlen (arg
));
3460 case OPT_Xassembler
:
3461 add_assembler_option (arg
, strlen (arg
));
3466 /* POSIX allows separation of -l and the lib arg; canonicalize
3467 by concatenating -l with its arg */
3468 add_infile (concat ("-l", arg
, NULL
), "*");
3473 /* Similarly, canonicalize -L for linkers that may not accept
3474 separate arguments. */
3475 save_switch (concat ("-L", arg
, NULL
), 0, NULL
, validated
, true);
3480 save_switch (concat ("-F", arg
, NULL
), 0, NULL
, validated
, true);
3483 case OPT_save_temps
:
3484 save_temps_flag
= SAVE_TEMPS_CWD
;
3488 case OPT_save_temps_
:
3489 if (strcmp (arg
, "cwd") == 0)
3490 save_temps_flag
= SAVE_TEMPS_CWD
;
3491 else if (strcmp (arg
, "obj") == 0
3492 || strcmp (arg
, "object") == 0)
3493 save_temps_flag
= SAVE_TEMPS_OBJ
;
3495 fatal_error ("%qs is an unknown -save-temps option",
3496 decoded
->orig_option_with_args_text
);
3499 case OPT_no_canonical_prefixes
:
3500 /* Already handled as a special case, so ignored here. */
3506 /* These options set the variables specified in common.opt
3507 automatically, but do need to be saved for spec
3513 struct user_specs
*user
= XNEW (struct user_specs
);
3515 user
->next
= (struct user_specs
*) 0;
3516 user
->filename
= arg
;
3517 if (user_specs_tail
)
3518 user_specs_tail
->next
= user
;
3520 user_specs_head
= user
;
3521 user_specs_tail
= user
;
3527 target_system_root
= arg
;
3528 target_system_root_changed
= 1;
3533 if (report_times_to_file
)
3534 fclose (report_times_to_file
);
3535 report_times_to_file
= fopen (arg
, "a");
3541 This is similar to -v except that there is no execution
3542 of the commands and the echoed arguments are quoted. It
3543 is intended for use in shell scripts to capture the
3544 driver-generated command line. */
3545 verbose_only_flag
++;
3552 size_t len
= strlen (arg
);
3554 /* Catch the case where the user has forgotten to append a
3555 directory separator to the path. Note, they may be using
3556 -B to add an executable name prefix, eg "i386-elf-", in
3557 order to distinguish between multiple installations of
3558 GCC in the same directory. Hence we must check to see
3559 if appending a directory separator actually makes a
3560 valid directory name. */
3561 if (!IS_DIR_SEPARATOR (arg
[len
- 1])
3562 && is_directory (arg
, false))
3564 char *tmp
= XNEWVEC (char, len
+ 2);
3566 tmp
[len
] = DIR_SEPARATOR
;
3571 add_prefix (&exec_prefixes
, arg
, NULL
,
3572 PREFIX_PRIORITY_B_OPT
, 0, 0);
3573 add_prefix (&startfile_prefixes
, arg
, NULL
,
3574 PREFIX_PRIORITY_B_OPT
, 0, 0);
3575 add_prefix (&include_prefixes
, arg
, NULL
,
3576 PREFIX_PRIORITY_B_OPT
, 0, 0);
3583 if (!strcmp (spec_lang
, "none"))
3584 /* Suppress the warning if -xnone comes after the last input
3585 file, because alternate command interfaces like g++ might
3586 find it useful to place -xnone after each input file. */
3589 last_language_n_infiles
= n_infiles
;
3595 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3596 arg
= convert_filename (arg
, ! have_c
, 0);
3598 /* Save the output name in case -save-temps=obj was used. */
3599 save_temps_prefix
= xstrdup (arg
);
3600 /* On some systems, ld cannot handle "-o" without a space. So
3601 split the option from its argument. */
3602 save_switch ("-o", 1, &arg
, validated
, true);
3605 case OPT_static_libgcc
:
3606 case OPT_shared_libgcc
:
3607 case OPT_static_libgfortran
:
3608 case OPT_static_libstdc__
:
3609 /* These are always valid, since gcc.c itself understands the
3610 first two, gfortranspec.c understands -static-libgfortran and
3611 g++spec.c understands -static-libstdc++ */
3616 /* Various driver options need no special processing at this
3617 point, having been handled in a prescan above or being
3618 handled by specs. */
3623 save_switch (decoded
->canonical_option
[0],
3624 decoded
->canonical_option_num_elements
- 1,
3625 &decoded
->canonical_option
[1], validated
, true);
3629 /* Put the driver's standard set of option handlers in *HANDLERS. */
3632 set_option_handlers (struct cl_option_handlers
*handlers
)
3634 handlers
->unknown_option_callback
= driver_unknown_option_callback
;
3635 handlers
->wrong_lang_callback
= driver_wrong_lang_callback
;
3636 handlers
->num_handlers
= 3;
3637 handlers
->handlers
[0].handler
= driver_handle_option
;
3638 handlers
->handlers
[0].mask
= CL_DRIVER
;
3639 handlers
->handlers
[1].handler
= common_handle_option
;
3640 handlers
->handlers
[1].mask
= CL_COMMON
;
3641 handlers
->handlers
[2].handler
= target_handle_option
;
3642 handlers
->handlers
[2].mask
= CL_TARGET
;
3645 /* Create the vector `switches' and its contents.
3646 Store its length in `n_switches'. */
3649 process_command (unsigned int decoded_options_count
,
3650 struct cl_decoded_option
*decoded_options
)
3654 char *tooldir_prefix
, *tooldir_prefix2
;
3655 char *(*get_relative_prefix
) (const char *, const char *,
3656 const char *) = NULL
;
3657 struct cl_option_handlers handlers
;
3660 gcc_exec_prefix
= getenv ("GCC_EXEC_PREFIX");
3664 added_libraries
= 0;
3666 /* Figure compiler version from version string. */
3668 compiler_version
= temp1
= xstrdup (version_string
);
3670 for (; *temp1
; ++temp1
)
3679 /* Handle any -no-canonical-prefixes flag early, to assign the function
3680 that builds relative prefixes. This function creates default search
3681 paths that are needed later in normal option handling. */
3683 for (j
= 1; j
< decoded_options_count
; j
++)
3685 if (decoded_options
[j
].opt_index
== OPT_no_canonical_prefixes
)
3687 get_relative_prefix
= make_relative_prefix_ignore_links
;
3691 if (! get_relative_prefix
)
3692 get_relative_prefix
= make_relative_prefix
;
3694 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
3695 see if we can create it from the pathname specified in
3696 decoded_options[0].arg. */
3698 gcc_libexec_prefix
= standard_libexec_prefix
;
3700 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
3701 if (!gcc_exec_prefix
)
3703 gcc_exec_prefix
= get_relative_prefix (decoded_options
[0].arg
,
3704 standard_bindir_prefix
,
3705 standard_exec_prefix
);
3706 gcc_libexec_prefix
= get_relative_prefix (decoded_options
[0].arg
,
3707 standard_bindir_prefix
,
3708 standard_libexec_prefix
);
3709 if (gcc_exec_prefix
)
3710 xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix
, NULL
));
3714 /* make_relative_prefix requires a program name, but
3715 GCC_EXEC_PREFIX is typically a directory name with a trailing
3716 / (which is ignored by make_relative_prefix), so append a
3718 char *tmp_prefix
= concat (gcc_exec_prefix
, "gcc", NULL
);
3719 gcc_libexec_prefix
= get_relative_prefix (tmp_prefix
,
3720 standard_exec_prefix
,
3721 standard_libexec_prefix
);
3723 /* The path is unrelocated, so fallback to the original setting. */
3724 if (!gcc_libexec_prefix
)
3725 gcc_libexec_prefix
= standard_libexec_prefix
;
3731 /* From this point onward, gcc_exec_prefix is non-null if the toolchain
3732 is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
3733 or an automatically created GCC_EXEC_PREFIX from
3734 decoded_options[0].arg. */
3736 /* Do language-specific adjustment/addition of flags. */
3737 lang_specific_driver (&decoded_options
, &decoded_options_count
,
3740 if (gcc_exec_prefix
)
3742 int len
= strlen (gcc_exec_prefix
);
3744 if (len
> (int) sizeof ("/lib/gcc/") - 1
3745 && (IS_DIR_SEPARATOR (gcc_exec_prefix
[len
-1])))
3747 temp
= gcc_exec_prefix
+ len
- sizeof ("/lib/gcc/") + 1;
3748 if (IS_DIR_SEPARATOR (*temp
)
3749 && filename_ncmp (temp
+ 1, "lib", 3) == 0
3750 && IS_DIR_SEPARATOR (temp
[4])
3751 && filename_ncmp (temp
+ 5, "gcc", 3) == 0)
3752 len
-= sizeof ("/lib/gcc/") - 1;
3755 set_std_prefix (gcc_exec_prefix
, len
);
3756 add_prefix (&exec_prefixes
, gcc_libexec_prefix
, "GCC",
3757 PREFIX_PRIORITY_LAST
, 0, 0);
3758 add_prefix (&startfile_prefixes
, gcc_exec_prefix
, "GCC",
3759 PREFIX_PRIORITY_LAST
, 0, 0);
3762 /* COMPILER_PATH and LIBRARY_PATH have values
3763 that are lists of directory names with colons. */
3765 temp
= getenv ("COMPILER_PATH");
3768 const char *startp
, *endp
;
3769 char *nstore
= (char *) alloca (strlen (temp
) + 3);
3771 startp
= endp
= temp
;
3774 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
3776 strncpy (nstore
, startp
, endp
- startp
);
3778 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
3779 else if (!IS_DIR_SEPARATOR (endp
[-1]))
3781 nstore
[endp
- startp
] = DIR_SEPARATOR
;
3782 nstore
[endp
- startp
+ 1] = 0;
3785 nstore
[endp
- startp
] = 0;
3786 add_prefix (&exec_prefixes
, nstore
, 0,
3787 PREFIX_PRIORITY_LAST
, 0, 0);
3788 add_prefix (&include_prefixes
, nstore
, 0,
3789 PREFIX_PRIORITY_LAST
, 0, 0);
3792 endp
= startp
= endp
+ 1;
3799 temp
= getenv (LIBRARY_PATH_ENV
);
3800 if (temp
&& *cross_compile
== '0')
3802 const char *startp
, *endp
;
3803 char *nstore
= (char *) alloca (strlen (temp
) + 3);
3805 startp
= endp
= temp
;
3808 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
3810 strncpy (nstore
, startp
, endp
- startp
);
3812 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
3813 else if (!IS_DIR_SEPARATOR (endp
[-1]))
3815 nstore
[endp
- startp
] = DIR_SEPARATOR
;
3816 nstore
[endp
- startp
+ 1] = 0;
3819 nstore
[endp
- startp
] = 0;
3820 add_prefix (&startfile_prefixes
, nstore
, NULL
,
3821 PREFIX_PRIORITY_LAST
, 0, 1);
3824 endp
= startp
= endp
+ 1;
3831 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
3832 temp
= getenv ("LPATH");
3833 if (temp
&& *cross_compile
== '0')
3835 const char *startp
, *endp
;
3836 char *nstore
= (char *) alloca (strlen (temp
) + 3);
3838 startp
= endp
= temp
;
3841 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
3843 strncpy (nstore
, startp
, endp
- startp
);
3845 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
3846 else if (!IS_DIR_SEPARATOR (endp
[-1]))
3848 nstore
[endp
- startp
] = DIR_SEPARATOR
;
3849 nstore
[endp
- startp
+ 1] = 0;
3852 nstore
[endp
- startp
] = 0;
3853 add_prefix (&startfile_prefixes
, nstore
, NULL
,
3854 PREFIX_PRIORITY_LAST
, 0, 1);
3857 endp
= startp
= endp
+ 1;
3864 /* Process the options and store input files and switches in their
3867 last_language_n_infiles
= -1;
3869 set_option_handlers (&handlers
);
3871 for (j
= 1; j
< decoded_options_count
; j
++)
3873 switch (decoded_options
[j
].opt_index
)
3885 for (j
= 1; j
< decoded_options_count
; j
++)
3887 if (decoded_options
[j
].opt_index
== OPT_SPECIAL_input_file
)
3889 const char *arg
= decoded_options
[j
].arg
;
3890 const char *p
= strrchr (arg
, '@');
3894 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3895 arg
= convert_filename (arg
, 0, access (arg
, F_OK
));
3897 /* For LTO static archive support we handle input file
3898 specifications that are composed of a filename and
3899 an offset like FNAME@OFFSET. */
3902 && sscanf (p
, "@%li%n", &offset
, &consumed
) >= 1
3903 && strlen (p
) == (unsigned int)consumed
)
3905 fname
= (char *)xmalloc (p
- arg
+ 1);
3906 memcpy (fname
, arg
, p
- arg
);
3907 fname
[p
- arg
] = '\0';
3908 /* Only accept non-stdin and existing FNAME parts, otherwise
3909 try with the full name. */
3910 if (strcmp (fname
, "-") == 0 || access (fname
, F_OK
) < 0)
3913 fname
= xstrdup (arg
);
3917 fname
= xstrdup (arg
);
3919 if (strcmp (fname
, "-") != 0 && access (fname
, F_OK
) < 0)
3920 perror_with_name (fname
);
3922 add_infile (arg
, spec_lang
);
3928 read_cmdline_option (&global_options
, &global_options_set
,
3929 decoded_options
+ j
, UNKNOWN_LOCATION
,
3930 CL_DRIVER
, &handlers
, global_dc
);
3933 /* If -save-temps=obj and -o name, create the prefix to use for %b.
3934 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
3935 if (save_temps_flag
== SAVE_TEMPS_OBJ
&& save_temps_prefix
!= NULL
)
3937 save_temps_length
= strlen (save_temps_prefix
);
3938 temp
= strrchr (lbasename (save_temps_prefix
), '.');
3941 save_temps_length
-= strlen (temp
);
3942 save_temps_prefix
[save_temps_length
] = '\0';
3946 else if (save_temps_prefix
!= NULL
)
3948 free (save_temps_prefix
);
3949 save_temps_prefix
= NULL
;
3952 if (save_temps_flag
&& use_pipes
)
3954 /* -save-temps overrides -pipe, so that temp files are produced */
3955 if (save_temps_flag
)
3956 warning (0, "-pipe ignored because -save-temps specified");
3962 const char *gcd
= getenv ("GCC_COMPARE_DEBUG");
3964 if (gcd
&& gcd
[0] == '-')
3967 compare_debug_opt
= gcd
;
3969 else if (gcd
&& *gcd
&& strcmp (gcd
, "0"))
3972 compare_debug_opt
= "-gtoggle";
3975 else if (compare_debug
< 0)
3978 gcc_assert (!compare_debug_opt
);
3981 /* Set up the search paths. We add directories that we expect to
3982 contain GNU Toolchain components before directories specified by
3983 the machine description so that we will find GNU components (like
3984 the GNU assembler) before those of the host system. */
3986 /* If we don't know where the toolchain has been installed, use the
3987 configured-in locations. */
3988 if (!gcc_exec_prefix
)
3991 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "GCC",
3992 PREFIX_PRIORITY_LAST
, 1, 0);
3993 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "BINUTILS",
3994 PREFIX_PRIORITY_LAST
, 2, 0);
3995 add_prefix (&exec_prefixes
, standard_exec_prefix
, "BINUTILS",
3996 PREFIX_PRIORITY_LAST
, 2, 0);
3998 add_prefix (&startfile_prefixes
, standard_exec_prefix
, "BINUTILS",
3999 PREFIX_PRIORITY_LAST
, 1, 0);
4002 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix
));
4003 tooldir_prefix2
= concat (tooldir_base_prefix
, spec_machine
,
4004 dir_separator_str
, NULL
);
4006 /* Look for tools relative to the location from which the driver is
4007 running, or, if that is not available, the configured prefix. */
4009 = concat (gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
4010 spec_machine
, dir_separator_str
,
4011 spec_version
, dir_separator_str
, tooldir_prefix2
, NULL
);
4012 free (tooldir_prefix2
);
4014 add_prefix (&exec_prefixes
,
4015 concat (tooldir_prefix
, "bin", dir_separator_str
, NULL
),
4016 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 0);
4017 add_prefix (&startfile_prefixes
,
4018 concat (tooldir_prefix
, "lib", dir_separator_str
, NULL
),
4019 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 1);
4020 free (tooldir_prefix
);
4022 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
4023 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
4024 then consider it to relocate with the rest of the GCC installation
4025 if GCC_EXEC_PREFIX is set.
4026 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
4027 if (target_system_root
&& !target_system_root_changed
&& gcc_exec_prefix
)
4029 char *tmp_prefix
= get_relative_prefix (decoded_options
[0].arg
,
4030 standard_bindir_prefix
,
4031 target_system_root
);
4032 if (tmp_prefix
&& access_check (tmp_prefix
, F_OK
) == 0)
4034 target_system_root
= tmp_prefix
;
4035 target_system_root_changed
= 1;
4040 /* More prefixes are enabled in main, after we read the specs file
4041 and determine whether this is cross-compilation or not. */
4043 if (n_infiles
== last_language_n_infiles
&& spec_lang
!= 0)
4044 warning (0, "%<-x %s%> after last input file has no effect", spec_lang
);
4046 /* Synthesize -fcompare-debug flag from the GCC_COMPARE_DEBUG
4047 environment variable. */
4048 if (compare_debug
== 2 || compare_debug
== 3)
4050 const char *opt
= concat ("-fcompare-debug=", compare_debug_opt
, NULL
);
4051 save_switch (opt
, 0, NULL
, false, true);
4055 /* Ensure we only invoke each subprocess once. */
4056 if (print_subprocess_help
|| print_help_list
|| print_version
)
4060 /* Create a dummy input file, so that we can pass
4061 the help option on to the various sub-processes. */
4062 add_infile ("help-dummy", "c");
4066 switches
[n_switches
].part1
= 0;
4068 infiles
[n_infiles
].name
= 0;
4071 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4072 and place that in the environment. */
4075 set_collect_gcc_options (void)
4080 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4082 obstack_grow (&collect_obstack
, "COLLECT_GCC_OPTIONS=",
4083 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4086 for (i
= 0; (int) i
< n_switches
; i
++)
4088 const char *const *args
;
4091 obstack_grow (&collect_obstack
, " ", 1);
4095 /* Ignore elided switches. */
4096 if ((switches
[i
].live_cond
4097 & (SWITCH_IGNORE
| SWITCH_KEEP_FOR_GCC
))
4101 obstack_grow (&collect_obstack
, "'-", 2);
4102 q
= switches
[i
].part1
;
4103 while ((p
= strchr (q
, '\'')))
4105 obstack_grow (&collect_obstack
, q
, p
- q
);
4106 obstack_grow (&collect_obstack
, "'\\''", 4);
4109 obstack_grow (&collect_obstack
, q
, strlen (q
));
4110 obstack_grow (&collect_obstack
, "'", 1);
4112 for (args
= switches
[i
].args
; args
&& *args
; args
++)
4114 obstack_grow (&collect_obstack
, " '", 2);
4116 while ((p
= strchr (q
, '\'')))
4118 obstack_grow (&collect_obstack
, q
, p
- q
);
4119 obstack_grow (&collect_obstack
, "'\\''", 4);
4122 obstack_grow (&collect_obstack
, q
, strlen (q
));
4123 obstack_grow (&collect_obstack
, "'", 1);
4126 obstack_grow (&collect_obstack
, "\0", 1);
4127 xputenv (XOBFINISH (&collect_obstack
, char *));
4130 /* Process a spec string, accumulating and running commands. */
4132 /* These variables describe the input file name.
4133 input_file_number is the index on outfiles of this file,
4134 so that the output file name can be stored for later use by %o.
4135 input_basename is the start of the part of the input file
4136 sans all directory names, and basename_length is the number
4137 of characters starting there excluding the suffix .c or whatever. */
4139 static const char *gcc_input_filename
;
4140 static int input_file_number
;
4141 size_t input_filename_length
;
4142 static int basename_length
;
4143 static int suffixed_basename_length
;
4144 static const char *input_basename
;
4145 static const char *input_suffix
;
4146 #ifndef HOST_LACKS_INODE_NUMBERS
4147 static struct stat input_stat
;
4149 static int input_stat_set
;
4151 /* The compiler used to process the current input file. */
4152 static struct compiler
*input_file_compiler
;
4154 /* These are variables used within do_spec and do_spec_1. */
4156 /* Nonzero if an arg has been started and not yet terminated
4157 (with space, tab or newline). */
4158 static int arg_going
;
4160 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4161 is a temporary file name. */
4162 static int delete_this_arg
;
4164 /* Nonzero means %w has been seen; the next arg to be terminated
4165 is the output file name of this compilation. */
4166 static int this_is_output_file
;
4168 /* Nonzero means %s has been seen; the next arg to be terminated
4169 is the name of a library file and we should try the standard
4170 search dirs for it. */
4171 static int this_is_library_file
;
4173 /* Nonzero means %T has been seen; the next arg to be terminated
4174 is the name of a linker script and we should try all of the
4175 standard search dirs for it. If it is found insert a --script
4176 command line switch and then substitute the full path in place,
4177 otherwise generate an error message. */
4178 static int this_is_linker_script
;
4180 /* Nonzero means that the input of this command is coming from a pipe. */
4181 static int input_from_pipe
;
4183 /* Nonnull means substitute this for any suffix when outputting a switches
4185 static const char *suffix_subst
;
4187 /* If there is an argument being accumulated, terminate it and store it. */
4190 end_going_arg (void)
4196 obstack_1grow (&obstack
, 0);
4197 string
= XOBFINISH (&obstack
, const char *);
4198 if (this_is_library_file
)
4199 string
= find_file (string
);
4200 if (this_is_linker_script
)
4202 char * full_script_path
= find_a_file (&startfile_prefixes
, string
, R_OK
, true);
4204 if (full_script_path
== NULL
)
4206 error ("unable to locate default linker script %qs in the library search paths", string
);
4207 /* Script was not found on search path. */
4210 store_arg ("--script", false, false);
4211 string
= full_script_path
;
4213 store_arg (string
, delete_this_arg
, this_is_output_file
);
4214 if (this_is_output_file
)
4215 outfiles
[input_file_number
] = string
;
4221 /* Parse the WRAPPER string which is a comma separated list of the command line
4222 and insert them into the beginning of argbuf. */
4225 insert_wrapper (const char *wrapper
)
4229 char *buf
= xstrdup (wrapper
);
4231 unsigned int old_length
= argbuf
.length ();
4239 while ((p
= strchr (p
, ',')) != NULL
);
4241 argbuf
.safe_grow (old_length
+ n
);
4242 memmove (argbuf
.address () + n
,
4244 old_length
* sizeof (const_char_p
));
4258 while ((p
= strchr (p
, ',')) != NULL
);
4259 gcc_assert (i
== n
);
4262 /* Process the spec SPEC and run the commands specified therein.
4263 Returns 0 if the spec is successfully processed; -1 if failed. */
4266 do_spec (const char *spec
)
4270 value
= do_spec_2 (spec
);
4272 /* Force out any unfinished command.
4273 If -pipe, this forces out the last command if it ended in `|'. */
4276 if (argbuf
.length () > 0
4277 && !strcmp (argbuf
.last (), "|"))
4280 set_collect_gcc_options ();
4282 if (argbuf
.length () > 0)
4290 do_spec_2 (const char *spec
)
4296 delete_this_arg
= 0;
4297 this_is_output_file
= 0;
4298 this_is_library_file
= 0;
4299 this_is_linker_script
= 0;
4300 input_from_pipe
= 0;
4301 suffix_subst
= NULL
;
4303 result
= do_spec_1 (spec
, 0, NULL
);
4311 /* Process the given spec string and add any new options to the end
4312 of the switches/n_switches array. */
4315 do_option_spec (const char *name
, const char *spec
)
4317 unsigned int i
, value_count
, value_len
;
4318 const char *p
, *q
, *value
;
4319 char *tmp_spec
, *tmp_spec_p
;
4321 if (configure_default_options
[0].name
== NULL
)
4324 for (i
= 0; i
< ARRAY_SIZE (configure_default_options
); i
++)
4325 if (strcmp (configure_default_options
[i
].name
, name
) == 0)
4327 if (i
== ARRAY_SIZE (configure_default_options
))
4330 value
= configure_default_options
[i
].value
;
4331 value_len
= strlen (value
);
4333 /* Compute the size of the final spec. */
4336 while ((p
= strstr (p
, "%(VALUE)")) != NULL
)
4342 /* Replace each %(VALUE) by the specified value. */
4343 tmp_spec
= (char *) alloca (strlen (spec
) + 1
4344 + value_count
* (value_len
- strlen ("%(VALUE)")));
4345 tmp_spec_p
= tmp_spec
;
4347 while ((p
= strstr (q
, "%(VALUE)")) != NULL
)
4349 memcpy (tmp_spec_p
, q
, p
- q
);
4350 tmp_spec_p
= tmp_spec_p
+ (p
- q
);
4351 memcpy (tmp_spec_p
, value
, value_len
);
4352 tmp_spec_p
+= value_len
;
4353 q
= p
+ strlen ("%(VALUE)");
4355 strcpy (tmp_spec_p
, q
);
4357 do_self_spec (tmp_spec
);
4360 /* Process the given spec string and add any new options to the end
4361 of the switches/n_switches array. */
4364 do_self_spec (const char *spec
)
4369 do_spec_1 (" ", 0, NULL
);
4371 /* Mark %<S switches processed by do_self_spec to be ignored permanently.
4372 do_self_specs adds the replacements to switches array, so it shouldn't
4373 be processed afterwards. */
4374 for (i
= 0; i
< n_switches
; i
++)
4375 if ((switches
[i
].live_cond
& SWITCH_IGNORE
))
4376 switches
[i
].live_cond
|= SWITCH_IGNORE_PERMANENTLY
;
4378 if (argbuf
.length () > 0)
4380 const char **argbuf_copy
;
4381 struct cl_decoded_option
*decoded_options
;
4382 struct cl_option_handlers handlers
;
4383 unsigned int decoded_options_count
;
4386 /* Create a copy of argbuf with a dummy argv[0] entry for
4387 decode_cmdline_options_to_array. */
4388 argbuf_copy
= XNEWVEC (const char *,
4389 argbuf
.length () + 1);
4390 argbuf_copy
[0] = "";
4391 memcpy (argbuf_copy
+ 1, argbuf
.address (),
4392 argbuf
.length () * sizeof (const char *));
4394 decode_cmdline_options_to_array (argbuf
.length () + 1,
4396 CL_DRIVER
, &decoded_options
,
4397 &decoded_options_count
);
4400 set_option_handlers (&handlers
);
4402 for (j
= 1; j
< decoded_options_count
; j
++)
4404 switch (decoded_options
[j
].opt_index
)
4406 case OPT_SPECIAL_input_file
:
4407 /* Specs should only generate options, not input
4409 if (strcmp (decoded_options
[j
].arg
, "-") != 0)
4410 fatal_error ("switch %qs does not start with %<-%>",
4411 decoded_options
[j
].arg
);
4413 fatal_error ("spec-generated switch is just %<-%>");
4416 case OPT_fcompare_debug_second
:
4417 case OPT_fcompare_debug
:
4418 case OPT_fcompare_debug_
:
4420 /* Avoid duplicate processing of some options from
4421 compare-debug specs; just save them here. */
4422 save_switch (decoded_options
[j
].canonical_option
[0],
4423 (decoded_options
[j
].canonical_option_num_elements
4425 &decoded_options
[j
].canonical_option
[1], false, true);
4429 read_cmdline_option (&global_options
, &global_options_set
,
4430 decoded_options
+ j
, UNKNOWN_LOCATION
,
4431 CL_DRIVER
, &handlers
, global_dc
);
4437 switches
[n_switches
].part1
= 0;
4441 /* Callback for processing %D and %I specs. */
4443 struct spec_path_info
{
4448 bool separate_options
;
4452 spec_path (char *path
, void *data
)
4454 struct spec_path_info
*info
= (struct spec_path_info
*) data
;
4458 if (info
->omit_relative
&& !IS_ABSOLUTE_PATH (path
))
4461 if (info
->append_len
!= 0)
4463 len
= strlen (path
);
4464 memcpy (path
+ len
, info
->append
, info
->append_len
+ 1);
4467 if (!is_directory (path
, true))
4470 do_spec_1 (info
->option
, 1, NULL
);
4471 if (info
->separate_options
)
4472 do_spec_1 (" ", 0, NULL
);
4474 if (info
->append_len
== 0)
4476 len
= strlen (path
);
4477 save
= path
[len
- 1];
4478 if (IS_DIR_SEPARATOR (path
[len
- 1]))
4479 path
[len
- 1] = '\0';
4482 do_spec_1 (path
, 1, NULL
);
4483 do_spec_1 (" ", 0, NULL
);
4485 /* Must not damage the original path. */
4486 if (info
->append_len
== 0)
4487 path
[len
- 1] = save
;
4492 /* Create a temporary FILE with the contents of ARGV. Add @FILE to the
4496 create_at_file (char **argv
)
4498 char *temp_file
= make_temp_file ("");
4499 char *at_argument
= concat ("@", temp_file
, NULL
);
4500 FILE *f
= fopen (temp_file
, "w");
4504 fatal_error ("could not open temporary response file %s",
4507 status
= writeargv (argv
, f
);
4510 fatal_error ("could not write to temporary response file %s",
4513 status
= fclose (f
);
4516 fatal_error ("could not close temporary response file %s",
4519 store_arg (at_argument
, 0, 0);
4521 record_temp_file (temp_file
, !save_temps_flag
, !save_temps_flag
);
4524 /* True if we should compile INFILE. */
4527 compile_input_file_p (struct infile
*infile
)
4529 if ((!infile
->language
) || (infile
->language
[0] != '*'))
4530 if (infile
->incompiler
== input_file_compiler
)
4535 /* Process each member of VEC as a spec. */
4538 do_specs_vec (vec
<char_p
> vec
)
4543 FOR_EACH_VEC_ELT (vec
, ix
, opt
)
4545 do_spec_1 (opt
, 1, NULL
);
4546 /* Make each accumulated option a separate argument. */
4547 do_spec_1 (" ", 0, NULL
);
4551 /* Process the sub-spec SPEC as a portion of a larger spec.
4552 This is like processing a whole spec except that we do
4553 not initialize at the beginning and we do not supply a
4554 newline by default at the end.
4555 INSWITCH nonzero means don't process %-sequences in SPEC;
4556 in this case, % is treated as an ordinary character.
4557 This is used while substituting switches.
4558 INSWITCH nonzero also causes SPC not to terminate an argument.
4560 Value is zero unless a line was finished
4561 and the command on that line reported an error. */
4564 do_spec_1 (const char *spec
, int inswitch
, const char *soft_matched_part
)
4566 const char *p
= spec
;
4571 /* If it's an empty string argument to a switch, keep it as is. */
4572 if (inswitch
&& !*p
)
4576 /* If substituting a switch, treat all chars like letters.
4577 Otherwise, NL, SPC, TAB and % are special. */
4578 switch (inswitch
? 'a' : c
)
4583 if (argbuf
.length () > 0
4584 && !strcmp (argbuf
.last (), "|"))
4586 /* A `|' before the newline means use a pipe here,
4587 but only if -pipe was specified.
4588 Otherwise, execute now and don't pass the `|' as an arg. */
4591 input_from_pipe
= 1;
4598 set_collect_gcc_options ();
4600 if (argbuf
.length () > 0)
4606 /* Reinitialize for a new command, and for a new argument. */
4609 delete_this_arg
= 0;
4610 this_is_output_file
= 0;
4611 this_is_library_file
= 0;
4612 this_is_linker_script
= 0;
4613 input_from_pipe
= 0;
4620 obstack_1grow (&obstack
, c
);
4628 /* Reinitialize for a new argument. */
4629 delete_this_arg
= 0;
4630 this_is_output_file
= 0;
4631 this_is_library_file
= 0;
4632 this_is_linker_script
= 0;
4639 fatal_error ("spec %qs invalid", spec
);
4642 if (save_temps_length
)
4643 obstack_grow (&obstack
, save_temps_prefix
, save_temps_length
);
4645 obstack_grow (&obstack
, input_basename
, basename_length
);
4646 if (compare_debug
< 0)
4647 obstack_grow (&obstack
, ".gk", 3);
4652 if (save_temps_length
)
4653 obstack_grow (&obstack
, save_temps_prefix
, save_temps_length
);
4655 obstack_grow (&obstack
, input_basename
, suffixed_basename_length
);
4656 if (compare_debug
< 0)
4657 obstack_grow (&obstack
, ".gk", 3);
4662 delete_this_arg
= 2;
4665 /* Dump out the directories specified with LIBRARY_PATH,
4666 followed by the absolute directories
4667 that we search for startfiles. */
4670 struct spec_path_info info
;
4673 info
.append_len
= 0;
4674 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
4675 /* Used on systems which record the specified -L dirs
4676 and use them to search for dynamic linking.
4677 Relative directories always come from -B,
4678 and it is better not to use them for searching
4679 at run time. In particular, stage1 loses. */
4680 info
.omit_relative
= true;
4682 info
.omit_relative
= false;
4684 info
.separate_options
= false;
4686 for_each_path (&startfile_prefixes
, true, 0, spec_path
, &info
);
4691 /* %efoo means report an error with `foo' as error message
4692 and don't execute any more commands for this file. */
4696 while (*p
!= 0 && *p
!= '\n')
4698 buf
= (char *) alloca (p
- q
+ 1);
4699 strncpy (buf
, q
, p
- q
);
4701 error ("%s", _(buf
));
4706 /* %nfoo means report a notice with `foo' on stderr. */
4710 while (*p
!= 0 && *p
!= '\n')
4712 buf
= (char *) alloca (p
- q
+ 1);
4713 strncpy (buf
, q
, p
- q
);
4715 inform (0, "%s", _(buf
));
4725 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
4726 defined, and it is not a directory, and it is
4727 writable, use it. Otherwise, treat this like any
4728 other temporary file. */
4730 if ((!save_temps_flag
)
4731 && (stat (HOST_BIT_BUCKET
, &st
) == 0) && (!S_ISDIR (st
.st_mode
))
4732 && (access (HOST_BIT_BUCKET
, W_OK
) == 0))
4734 obstack_grow (&obstack
, HOST_BIT_BUCKET
,
4735 strlen (HOST_BIT_BUCKET
));
4736 delete_this_arg
= 0;
4741 goto create_temp_file
;
4745 obstack_1grow (&obstack
, '-');
4746 delete_this_arg
= 0;
4749 /* consume suffix */
4750 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
4752 if (p
[0] == '%' && p
[1] == 'O')
4757 goto create_temp_file
;
4761 /* consume suffix */
4762 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
4764 if (p
[0] == '%' && p
[1] == 'O')
4769 goto create_temp_file
;
4775 struct temp_name
*t
;
4777 const char *suffix
= p
;
4778 char *saved_suffix
= NULL
;
4780 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
4782 suffix_length
= p
- suffix
;
4783 if (p
[0] == '%' && p
[1] == 'O')
4786 /* We don't support extra suffix characters after %O. */
4787 if (*p
== '.' || ISALNUM ((unsigned char) *p
))
4788 fatal_error ("spec %qs has invalid %<%%0%c%>", spec
, *p
);
4789 if (suffix_length
== 0)
4790 suffix
= TARGET_OBJECT_SUFFIX
;
4794 = XNEWVEC (char, suffix_length
4795 + strlen (TARGET_OBJECT_SUFFIX
));
4796 strncpy (saved_suffix
, suffix
, suffix_length
);
4797 strcpy (saved_suffix
+ suffix_length
,
4798 TARGET_OBJECT_SUFFIX
);
4800 suffix_length
+= strlen (TARGET_OBJECT_SUFFIX
);
4803 if (compare_debug
< 0)
4805 suffix
= concat (".gk", suffix
, NULL
);
4809 /* If -save-temps=obj and -o were specified, use that for the
4811 if (save_temps_length
)
4814 temp_filename_length
4815 = save_temps_length
+ suffix_length
+ 1;
4816 tmp
= (char *) alloca (temp_filename_length
);
4817 memcpy (tmp
, save_temps_prefix
, save_temps_length
);
4818 memcpy (tmp
+ save_temps_length
, suffix
, suffix_length
);
4819 tmp
[save_temps_length
+ suffix_length
] = '\0';
4820 temp_filename
= save_string (tmp
, save_temps_length
4822 obstack_grow (&obstack
, temp_filename
,
4823 temp_filename_length
);
4825 delete_this_arg
= 0;
4829 /* If the gcc_input_filename has the same suffix specified
4830 for the %g, %u, or %U, and -save-temps is specified,
4831 we could end up using that file as an intermediate
4832 thus clobbering the user's source file (.e.g.,
4833 gcc -save-temps foo.s would clobber foo.s with the
4834 output of cpp0). So check for this condition and
4835 generate a temp file as the intermediate. */
4837 if (save_temps_flag
)
4840 temp_filename_length
= basename_length
+ suffix_length
+ 1;
4841 tmp
= (char *) alloca (temp_filename_length
);
4842 memcpy (tmp
, input_basename
, basename_length
);
4843 memcpy (tmp
+ basename_length
, suffix
, suffix_length
);
4844 tmp
[basename_length
+ suffix_length
] = '\0';
4845 temp_filename
= tmp
;
4847 if (filename_cmp (temp_filename
, gcc_input_filename
) != 0)
4849 #ifndef HOST_LACKS_INODE_NUMBERS
4850 struct stat st_temp
;
4852 /* Note, set_input() resets input_stat_set to 0. */
4853 if (input_stat_set
== 0)
4855 input_stat_set
= stat (gcc_input_filename
,
4857 if (input_stat_set
>= 0)
4861 /* If we have the stat for the gcc_input_filename
4862 and we can do the stat for the temp_filename
4863 then the they could still refer to the same
4864 file if st_dev/st_ino's are the same. */
4865 if (input_stat_set
!= 1
4866 || stat (temp_filename
, &st_temp
) < 0
4867 || input_stat
.st_dev
!= st_temp
.st_dev
4868 || input_stat
.st_ino
!= st_temp
.st_ino
)
4870 /* Just compare canonical pathnames. */
4871 char* input_realname
= lrealpath (gcc_input_filename
);
4872 char* temp_realname
= lrealpath (temp_filename
);
4873 bool files_differ
= filename_cmp (input_realname
, temp_realname
);
4874 free (input_realname
);
4875 free (temp_realname
);
4879 temp_filename
= save_string (temp_filename
,
4880 temp_filename_length
+ 1);
4881 obstack_grow (&obstack
, temp_filename
,
4882 temp_filename_length
);
4884 delete_this_arg
= 0;
4890 /* See if we already have an association of %g/%u/%U and
4892 for (t
= temp_names
; t
; t
= t
->next
)
4893 if (t
->length
== suffix_length
4894 && strncmp (t
->suffix
, suffix
, suffix_length
) == 0
4895 && t
->unique
== (c
== 'u' || c
== 'U' || c
== 'j'))
4898 /* Make a new association if needed. %u and %j
4900 if (t
== 0 || c
== 'u' || c
== 'j')
4904 t
= XNEW (struct temp_name
);
4905 t
->next
= temp_names
;
4908 t
->length
= suffix_length
;
4911 t
->suffix
= saved_suffix
;
4912 saved_suffix
= NULL
;
4915 t
->suffix
= save_string (suffix
, suffix_length
);
4916 t
->unique
= (c
== 'u' || c
== 'U' || c
== 'j');
4917 temp_filename
= make_temp_file (t
->suffix
);
4918 temp_filename_length
= strlen (temp_filename
);
4919 t
->filename
= temp_filename
;
4920 t
->filename_length
= temp_filename_length
;
4923 free (saved_suffix
);
4925 obstack_grow (&obstack
, t
->filename
, t
->filename_length
);
4926 delete_this_arg
= 1;
4934 if (at_file_supplied
)
4936 /* We are going to expand `%i' to `@FILE', where FILE
4937 is a newly-created temporary filename. The filenames
4938 that would usually be expanded in place of %o will be
4939 written to the temporary file. */
4944 for (i
= 0; i
< n_infiles
; i
++)
4945 if (compile_input_file_p (&infiles
[i
]))
4948 argv
= (char **) alloca (sizeof (char *) * (n_files
+ 1));
4950 /* Copy the strings over. */
4951 for (i
= 0, j
= 0; i
< n_infiles
; i
++)
4952 if (compile_input_file_p (&infiles
[i
]))
4954 argv
[j
] = CONST_CAST (char *, infiles
[i
].name
);
4955 infiles
[i
].compiled
= true;
4960 create_at_file (argv
);
4963 for (i
= 0; (int) i
< n_infiles
; i
++)
4964 if (compile_input_file_p (&infiles
[i
]))
4966 store_arg (infiles
[i
].name
, 0, 0);
4967 infiles
[i
].compiled
= true;
4972 obstack_grow (&obstack
, gcc_input_filename
,
4973 input_filename_length
);
4980 struct spec_path_info info
;
4984 do_spec_1 ("-imultilib", 1, NULL
);
4985 /* Make this a separate argument. */
4986 do_spec_1 (" ", 0, NULL
);
4987 do_spec_1 (multilib_dir
, 1, NULL
);
4988 do_spec_1 (" ", 0, NULL
);
4993 do_spec_1 ("-imultiarch", 1, NULL
);
4994 /* Make this a separate argument. */
4995 do_spec_1 (" ", 0, NULL
);
4996 do_spec_1 (multiarch_dir
, 1, NULL
);
4997 do_spec_1 (" ", 0, NULL
);
5000 if (gcc_exec_prefix
)
5002 do_spec_1 ("-iprefix", 1, NULL
);
5003 /* Make this a separate argument. */
5004 do_spec_1 (" ", 0, NULL
);
5005 do_spec_1 (gcc_exec_prefix
, 1, NULL
);
5006 do_spec_1 (" ", 0, NULL
);
5009 if (target_system_root_changed
||
5010 (target_system_root
&& target_sysroot_hdrs_suffix
))
5012 do_spec_1 ("-isysroot", 1, NULL
);
5013 /* Make this a separate argument. */
5014 do_spec_1 (" ", 0, NULL
);
5015 do_spec_1 (target_system_root
, 1, NULL
);
5016 if (target_sysroot_hdrs_suffix
)
5017 do_spec_1 (target_sysroot_hdrs_suffix
, 1, NULL
);
5018 do_spec_1 (" ", 0, NULL
);
5021 info
.option
= "-isystem";
5022 info
.append
= "include";
5023 info
.append_len
= strlen (info
.append
);
5024 info
.omit_relative
= false;
5025 info
.separate_options
= true;
5027 for_each_path (&include_prefixes
, false, info
.append_len
,
5030 info
.append
= "include-fixed";
5031 if (*sysroot_hdrs_suffix_spec
)
5032 info
.append
= concat (info
.append
, dir_separator_str
,
5033 multilib_dir
, NULL
);
5034 info
.append_len
= strlen (info
.append
);
5035 for_each_path (&include_prefixes
, false, info
.append_len
,
5042 int max
= n_infiles
;
5043 max
+= lang_specific_extra_outfiles
;
5045 if (HAVE_GNU_LD
&& at_file_supplied
)
5047 /* We are going to expand `%o' to `@FILE', where FILE
5048 is a newly-created temporary filename. The filenames
5049 that would usually be expanded in place of %o will be
5050 written to the temporary file. */
5055 /* Convert OUTFILES into a form suitable for writeargv. */
5057 /* Determine how many are non-NULL. */
5058 for (n_files
= 0, i
= 0; i
< max
; i
++)
5059 n_files
+= outfiles
[i
] != NULL
;
5061 argv
= (char **) alloca (sizeof (char *) * (n_files
+ 1));
5063 /* Copy the strings over. */
5064 for (i
= 0, j
= 0; i
< max
; i
++)
5067 argv
[j
] = CONST_CAST (char *, outfiles
[i
]);
5072 create_at_file (argv
);
5075 for (i
= 0; i
< max
; i
++)
5077 store_arg (outfiles
[i
], 0, 0);
5082 obstack_grow (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
5087 this_is_library_file
= 1;
5091 this_is_linker_script
= 1;
5095 outfiles
[input_file_number
] = NULL
;
5099 this_is_output_file
= 1;
5104 unsigned int cur_index
= argbuf
.length ();
5105 /* Handle the {...} following the %W. */
5107 fatal_error ("spec %qs has invalid %<%%W%c%>", spec
, *p
);
5108 p
= handle_braces (p
+ 1);
5112 /* If any args were output, mark the last one for deletion
5114 if (argbuf
.length () != cur_index
)
5115 record_temp_file (argbuf
.last (), 0, 1);
5119 /* %x{OPTION} records OPTION for %X to output. */
5127 /* Skip past the option value and make a copy. */
5129 fatal_error ("spec %qs has invalid %<%%x%c%>", spec
, *p
);
5132 string
= save_string (p1
+ 1, p
- p1
- 2);
5134 /* See if we already recorded this option. */
5135 FOR_EACH_VEC_ELT (linker_options
, ix
, opt
)
5136 if (! strcmp (string
, opt
))
5142 /* This option is new; add it. */
5143 add_linker_option (string
, strlen (string
));
5148 /* Dump out the options accumulated previously using %x. */
5150 do_specs_vec (linker_options
);
5153 /* Dump out the options accumulated previously using -Wa,. */
5155 do_specs_vec (assembler_options
);
5158 /* Dump out the options accumulated previously using -Wp,. */
5160 do_specs_vec (preprocessor_options
);
5163 /* Here are digits and numbers that just process
5164 a certain constant string as a spec. */
5167 value
= do_spec_1 (cc1_spec
, 0, NULL
);
5173 value
= do_spec_1 (cc1plus_spec
, 0, NULL
);
5179 value
= do_spec_1 (asm_spec
, 0, NULL
);
5185 value
= do_spec_1 (asm_final_spec
, 0, NULL
);
5192 const char *const spec
5193 = (input_file_compiler
->cpp_spec
5194 ? input_file_compiler
->cpp_spec
5196 value
= do_spec_1 (spec
, 0, NULL
);
5203 value
= do_spec_1 (endfile_spec
, 0, NULL
);
5209 value
= do_spec_1 (link_spec
, 0, NULL
);
5215 value
= do_spec_1 (lib_spec
, 0, NULL
);
5221 if (multilib_os_dir
== NULL
)
5222 obstack_1grow (&obstack
, '.');
5224 obstack_grow (&obstack
, multilib_os_dir
,
5225 strlen (multilib_os_dir
));
5229 value
= do_spec_1 (libgcc_spec
, 0, NULL
);
5235 /* We assume there is a directory
5236 separator at the end of this string. */
5237 if (target_system_root
)
5239 obstack_grow (&obstack
, target_system_root
,
5240 strlen (target_system_root
));
5241 if (target_sysroot_suffix
)
5242 obstack_grow (&obstack
, target_sysroot_suffix
,
5243 strlen (target_sysroot_suffix
));
5248 value
= do_spec_1 (startfile_spec
, 0, NULL
);
5253 /* Here we define characters other than letters and digits. */
5256 p
= handle_braces (p
);
5262 p
= handle_spec_function (p
);
5268 obstack_1grow (&obstack
, '%');
5275 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '%')
5277 suffix_subst
= save_string (p
- 1, len
+ 1);
5282 /* Henceforth ignore the option(s) matching the pattern
5288 int have_wildcard
= 0;
5293 switch_option
= SWITCH_IGNORE
| SWITCH_KEEP_FOR_GCC
;
5295 switch_option
= SWITCH_IGNORE
;
5297 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '\t')
5300 if (p
[len
-1] == '*')
5303 for (i
= 0; i
< n_switches
; i
++)
5304 if (!strncmp (switches
[i
].part1
, p
, len
- have_wildcard
)
5305 && (have_wildcard
|| switches
[i
].part1
[len
] == '\0'))
5307 switches
[i
].live_cond
|= switch_option
;
5308 /* User switch be validated from validate_all_switches.
5309 when the definition is seen from the spec file.
5310 If not defined anywhere, will be rejected. */
5311 if (switches
[i
].known
)
5312 switches
[i
].validated
= true;
5320 if (soft_matched_part
)
5322 if (soft_matched_part
[0])
5323 do_spec_1 (soft_matched_part
, 1, NULL
);
5324 do_spec_1 (" ", 0, NULL
);
5327 /* Catch the case where a spec string contains something like
5328 '%{foo:%*}'. i.e. there is no * in the pattern on the left
5329 hand side of the :. */
5330 error ("spec failure: %<%%*%> has not been initialized by pattern match");
5333 /* Process a string found as the value of a spec given by name.
5334 This feature allows individual machine descriptions
5335 to add and use their own specs. */
5338 const char *name
= p
;
5339 struct spec_list
*sl
;
5342 /* The string after the S/P is the name of a spec that is to be
5344 while (*p
&& *p
!= ')')
5347 /* See if it's in the list. */
5348 for (len
= p
- name
, sl
= specs
; sl
; sl
= sl
->next
)
5349 if (sl
->name_len
== len
&& !strncmp (sl
->name
, name
, len
))
5351 name
= *(sl
->ptr_spec
);
5353 fnotice (stderr
, "Processing spec (%s), which is '%s'\n",
5361 value
= do_spec_1 (name
, 0, NULL
);
5366 /* Discard the closing paren. */
5373 error ("spec failure: unrecognized spec option %qc", c
);
5379 /* Backslash: treat next character as ordinary. */
5384 /* Ordinary character: put it into the current argument. */
5385 obstack_1grow (&obstack
, c
);
5389 /* End of string. If we are processing a spec function, we need to
5390 end any pending argument. */
5391 if (processing_spec_function
)
5397 /* Look up a spec function. */
5399 static const struct spec_function
*
5400 lookup_spec_function (const char *name
)
5402 const struct spec_function
*sf
;
5404 for (sf
= static_spec_functions
; sf
->name
!= NULL
; sf
++)
5405 if (strcmp (sf
->name
, name
) == 0)
5411 /* Evaluate a spec function. */
5414 eval_spec_function (const char *func
, const char *args
)
5416 const struct spec_function
*sf
;
5417 const char *funcval
;
5419 /* Saved spec processing context. */
5420 vec
<const_char_p
> save_argbuf
;
5423 int save_delete_this_arg
;
5424 int save_this_is_output_file
;
5425 int save_this_is_library_file
;
5426 int save_input_from_pipe
;
5427 int save_this_is_linker_script
;
5428 const char *save_suffix_subst
;
5430 int save_growing_size
;
5431 void *save_growing_value
;
5433 sf
= lookup_spec_function (func
);
5435 fatal_error ("unknown spec function %qs", func
);
5437 /* Push the spec processing context. */
5438 save_argbuf
= argbuf
;
5440 save_arg_going
= arg_going
;
5441 save_delete_this_arg
= delete_this_arg
;
5442 save_this_is_output_file
= this_is_output_file
;
5443 save_this_is_library_file
= this_is_library_file
;
5444 save_this_is_linker_script
= this_is_linker_script
;
5445 save_input_from_pipe
= input_from_pipe
;
5446 save_suffix_subst
= suffix_subst
;
5448 /* If we have some object growing now, finalize it so the args and function
5449 eval proceed from a cleared context. This is needed to prevent the first
5450 constructed arg from mistakenly including the growing value. We'll push
5451 this value back on the obstack once the function evaluation is done, to
5452 restore a consistent processing context for our caller. This is fine as
5453 the address of growing objects isn't guaranteed to remain stable until
5454 they are finalized, and we expect this situation to be rare enough for
5455 the extra copy not to be an issue. */
5456 save_growing_size
= obstack_object_size (&obstack
);
5457 if (save_growing_size
> 0)
5458 save_growing_value
= obstack_finish (&obstack
);
5460 /* Create a new spec processing context, and build the function
5464 if (do_spec_2 (args
) < 0)
5465 fatal_error ("error in args to spec function %qs", func
);
5467 /* argbuf_index is an index for the next argument to be inserted, and
5468 so contains the count of the args already inserted. */
5470 funcval
= (*sf
->func
) (argbuf
.length (),
5473 /* Pop the spec processing context. */
5475 argbuf
= save_argbuf
;
5477 arg_going
= save_arg_going
;
5478 delete_this_arg
= save_delete_this_arg
;
5479 this_is_output_file
= save_this_is_output_file
;
5480 this_is_library_file
= save_this_is_library_file
;
5481 this_is_linker_script
= save_this_is_linker_script
;
5482 input_from_pipe
= save_input_from_pipe
;
5483 suffix_subst
= save_suffix_subst
;
5485 if (save_growing_size
> 0)
5486 obstack_grow (&obstack
, save_growing_value
, save_growing_size
);
5491 /* Handle a spec function call of the form:
5495 ARGS is processed as a spec in a separate context and split into an
5496 argument vector in the normal fashion. The function returns a string
5497 containing a spec which we then process in the caller's context, or
5498 NULL if no processing is required. */
5501 handle_spec_function (const char *p
)
5504 const char *endp
, *funcval
;
5507 processing_spec_function
++;
5509 /* Get the function name. */
5510 for (endp
= p
; *endp
!= '\0'; endp
++)
5512 if (*endp
== '(') /* ) */
5514 /* Only allow [A-Za-z0-9], -, and _ in function names. */
5515 if (!ISALNUM (*endp
) && !(*endp
== '-' || *endp
== '_'))
5516 fatal_error ("malformed spec function name");
5518 if (*endp
!= '(') /* ) */
5519 fatal_error ("no arguments for spec function");
5520 func
= save_string (p
, endp
- p
);
5523 /* Get the arguments. */
5524 for (count
= 0; *endp
!= '\0'; endp
++)
5533 else if (*endp
== '(') /* ) */
5538 fatal_error ("malformed spec function arguments");
5539 args
= save_string (p
, endp
- p
);
5542 /* p now points to just past the end of the spec function expression. */
5544 funcval
= eval_spec_function (func
, args
);
5545 if (funcval
!= NULL
&& do_spec_1 (funcval
, 0, NULL
) < 0)
5551 processing_spec_function
--;
5556 /* Inline subroutine of handle_braces. Returns true if the current
5557 input suffix matches the atom bracketed by ATOM and END_ATOM. */
5559 input_suffix_matches (const char *atom
, const char *end_atom
)
5561 return (input_suffix
5562 && !strncmp (input_suffix
, atom
, end_atom
- atom
)
5563 && input_suffix
[end_atom
- atom
] == '\0');
5566 /* Subroutine of handle_braces. Returns true if the current
5567 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
5569 input_spec_matches (const char *atom
, const char *end_atom
)
5571 return (input_file_compiler
5572 && input_file_compiler
->suffix
5573 && input_file_compiler
->suffix
[0] != '\0'
5574 && !strncmp (input_file_compiler
->suffix
+ 1, atom
,
5576 && input_file_compiler
->suffix
[end_atom
- atom
+ 1] == '\0');
5579 /* Subroutine of handle_braces. Returns true if a switch
5580 matching the atom bracketed by ATOM and END_ATOM appeared on the
5583 switch_matches (const char *atom
, const char *end_atom
, int starred
)
5586 int len
= end_atom
- atom
;
5587 int plen
= starred
? len
: -1;
5589 for (i
= 0; i
< n_switches
; i
++)
5590 if (!strncmp (switches
[i
].part1
, atom
, len
)
5591 && (starred
|| switches
[i
].part1
[len
] == '\0')
5592 && check_live_switch (i
, plen
))
5595 /* Check if a switch with separated form matching the atom.
5596 We check -D and -U switches. */
5597 else if (switches
[i
].args
!= 0)
5599 if ((*switches
[i
].part1
== 'D' || *switches
[i
].part1
== 'U')
5600 && *switches
[i
].part1
== atom
[0])
5602 if (!strncmp (switches
[i
].args
[0], &atom
[1], len
- 1)
5603 && (starred
|| (switches
[i
].part1
[1] == '\0'
5604 && switches
[i
].args
[0][len
- 1] == '\0'))
5605 && check_live_switch (i
, (starred
? 1 : -1)))
5613 /* Inline subroutine of handle_braces. Mark all of the switches which
5614 match ATOM (extends to END_ATOM; STARRED indicates whether there
5615 was a star after the atom) for later processing. */
5617 mark_matching_switches (const char *atom
, const char *end_atom
, int starred
)
5620 int len
= end_atom
- atom
;
5621 int plen
= starred
? len
: -1;
5623 for (i
= 0; i
< n_switches
; i
++)
5624 if (!strncmp (switches
[i
].part1
, atom
, len
)
5625 && (starred
|| switches
[i
].part1
[len
] == '\0')
5626 && check_live_switch (i
, plen
))
5627 switches
[i
].ordering
= 1;
5630 /* Inline subroutine of handle_braces. Process all the currently
5631 marked switches through give_switch, and clear the marks. */
5633 process_marked_switches (void)
5637 for (i
= 0; i
< n_switches
; i
++)
5638 if (switches
[i
].ordering
== 1)
5640 switches
[i
].ordering
= 0;
5645 /* Handle a %{ ... } construct. P points just inside the leading {.
5646 Returns a pointer one past the end of the brace block, or 0
5647 if we call do_spec_1 and that returns -1. */
5650 handle_braces (const char *p
)
5652 const char *atom
, *end_atom
;
5653 const char *d_atom
= NULL
, *d_end_atom
= NULL
;
5654 const char *orig
= p
;
5662 bool a_must_be_last
= false;
5663 bool ordered_set
= false;
5664 bool disjunct_set
= false;
5665 bool disj_matched
= false;
5666 bool disj_starred
= true;
5667 bool n_way_choice
= false;
5668 bool n_way_matched
= false;
5670 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
5677 /* Scan one "atom" (S in the description above of %{}, possibly
5678 with '!', '.', '@', ',', or '*' modifiers). */
5680 a_is_suffix
= false;
5681 a_is_starred
= false;
5682 a_is_negated
= false;
5683 a_is_spectype
= false;
5687 p
++, a_is_negated
= true;
5691 p
++, a_is_suffix
= true;
5693 p
++, a_is_spectype
= true;
5696 while (ISIDNUM(*p
) || *p
== '-' || *p
== '+' || *p
== '='
5697 || *p
== ',' || *p
== '.' || *p
== '@')
5702 p
++, a_is_starred
= 1;
5708 /* Substitute the switch(es) indicated by the current atom. */
5710 if (disjunct_set
|| n_way_choice
|| a_is_negated
|| a_is_suffix
5711 || a_is_spectype
|| atom
== end_atom
)
5714 mark_matching_switches (atom
, end_atom
, a_is_starred
);
5717 process_marked_switches ();
5721 /* Substitute some text if the current atom appears as a switch
5723 disjunct_set
= true;
5727 if (atom
== end_atom
)
5729 if (!n_way_choice
|| disj_matched
|| *p
== '|'
5730 || a_is_negated
|| a_is_suffix
|| a_is_spectype
5734 /* An empty term may appear as the last choice of an
5735 N-way choice set; it means "otherwise". */
5736 a_must_be_last
= true;
5737 disj_matched
= !n_way_matched
;
5738 disj_starred
= false;
5742 if ((a_is_suffix
|| a_is_spectype
) && a_is_starred
)
5746 disj_starred
= false;
5748 /* Don't bother testing this atom if we already have a
5750 if (!disj_matched
&& !n_way_matched
)
5753 a_matched
= input_suffix_matches (atom
, end_atom
);
5754 else if (a_is_spectype
)
5755 a_matched
= input_spec_matches (atom
, end_atom
);
5757 a_matched
= switch_matches (atom
, end_atom
, a_is_starred
);
5759 if (a_matched
!= a_is_negated
)
5761 disj_matched
= true;
5763 d_end_atom
= end_atom
;
5770 /* Found the body, that is, the text to substitute if the
5771 current disjunction matches. */
5772 p
= process_brace_body (p
+ 1, d_atom
, d_end_atom
, disj_starred
,
5773 disj_matched
&& !n_way_matched
);
5777 /* If we have an N-way choice, reset state for the next
5781 n_way_choice
= true;
5782 n_way_matched
|= disj_matched
;
5783 disj_matched
= false;
5784 disj_starred
= true;
5785 d_atom
= d_end_atom
= NULL
;
5794 while (*p
++ != '}');
5799 fatal_error ("braced spec %qs is invalid at %qc", orig
, *p
);
5804 /* Subroutine of handle_braces. Scan and process a brace substitution body
5805 (X in the description of %{} syntax). P points one past the colon;
5806 ATOM and END_ATOM bracket the first atom which was found to be true
5807 (present) in the current disjunction; STARRED indicates whether all
5808 the atoms in the current disjunction were starred (for syntax validation);
5809 MATCHED indicates whether the disjunction matched or not, and therefore
5810 whether or not the body is to be processed through do_spec_1 or just
5811 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
5815 process_brace_body (const char *p
, const char *atom
, const char *end_atom
,
5816 int starred
, int matched
)
5818 const char *body
, *end_body
;
5819 unsigned int nesting_level
;
5820 bool have_subst
= false;
5822 /* Locate the closing } or ;, honoring nested braces.
5823 Trim trailing whitespace. */
5832 if (!--nesting_level
)
5835 else if (*p
== ';' && nesting_level
== 1)
5837 else if (*p
== '%' && p
[1] == '*' && nesting_level
== 1)
5839 else if (*p
== '\0')
5845 while (end_body
[-1] == ' ' || end_body
[-1] == '\t')
5848 if (have_subst
&& !starred
)
5853 /* Copy the substitution body to permanent storage and execute it.
5854 If have_subst is false, this is a simple matter of running the
5855 body through do_spec_1... */
5856 char *string
= save_string (body
, end_body
- body
);
5859 if (do_spec_1 (string
, 0, NULL
) < 0)
5864 /* ... but if have_subst is true, we have to process the
5865 body once for each matching switch, with %* set to the
5866 variant part of the switch. */
5867 unsigned int hard_match_len
= end_atom
- atom
;
5870 for (i
= 0; i
< n_switches
; i
++)
5871 if (!strncmp (switches
[i
].part1
, atom
, hard_match_len
)
5872 && check_live_switch (i
, hard_match_len
))
5874 if (do_spec_1 (string
, 0,
5875 &switches
[i
].part1
[hard_match_len
]) < 0)
5877 /* Pass any arguments this switch has. */
5879 suffix_subst
= NULL
;
5887 fatal_error ("braced spec body %qs is invalid", body
);
5890 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
5891 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
5892 spec, or -1 if either exact match or %* is used.
5894 A -O switch is obsoleted by a later -O switch. A -f, -g, -m, or -W switch
5895 whose value does not begin with "no-" is obsoleted by the same value
5896 with the "no-", similarly for a switch with the "no-" prefix. */
5899 check_live_switch (int switchnum
, int prefix_length
)
5901 const char *name
= switches
[switchnum
].part1
;
5904 /* If we already processed this switch and determined if it was
5905 live or not, return our past determination. */
5906 if (switches
[switchnum
].live_cond
!= 0)
5907 return ((switches
[switchnum
].live_cond
& SWITCH_LIVE
) != 0
5908 && (switches
[switchnum
].live_cond
& SWITCH_FALSE
) == 0
5909 && (switches
[switchnum
].live_cond
& SWITCH_IGNORE_PERMANENTLY
)
5912 /* In the common case of {<at-most-one-letter>*}, a negating
5913 switch would always match, so ignore that case. We will just
5914 send the conflicting switches to the compiler phase. */
5915 if (prefix_length
>= 0 && prefix_length
<= 1)
5918 /* Now search for duplicate in a manner that depends on the name. */
5922 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
5923 if (switches
[i
].part1
[0] == 'O')
5925 switches
[switchnum
].validated
= true;
5926 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
5931 case 'W': case 'f': case 'm': case 'g':
5932 if (! strncmp (name
+ 1, "no-", 3))
5934 /* We have Xno-YYY, search for XYYY. */
5935 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
5936 if (switches
[i
].part1
[0] == name
[0]
5937 && ! strcmp (&switches
[i
].part1
[1], &name
[4]))
5939 /* --specs are validated with the validate_switches mechanism. */
5940 if (switches
[switchnum
].known
)
5941 switches
[switchnum
].validated
= true;
5942 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
5948 /* We have XYYY, search for Xno-YYY. */
5949 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
5950 if (switches
[i
].part1
[0] == name
[0]
5951 && switches
[i
].part1
[1] == 'n'
5952 && switches
[i
].part1
[2] == 'o'
5953 && switches
[i
].part1
[3] == '-'
5954 && !strcmp (&switches
[i
].part1
[4], &name
[1]))
5956 /* --specs are validated with the validate_switches mechanism. */
5957 if (switches
[switchnum
].known
)
5958 switches
[switchnum
].validated
= true;
5959 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
5966 /* Otherwise the switch is live. */
5967 switches
[switchnum
].live_cond
|= SWITCH_LIVE
;
5971 /* Pass a switch to the current accumulating command
5972 in the same form that we received it.
5973 SWITCHNUM identifies the switch; it is an index into
5974 the vector of switches gcc received, which is `switches'.
5975 This cannot fail since it never finishes a command line.
5977 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
5980 give_switch (int switchnum
, int omit_first_word
)
5982 if ((switches
[switchnum
].live_cond
& SWITCH_IGNORE
) != 0)
5985 if (!omit_first_word
)
5987 do_spec_1 ("-", 0, NULL
);
5988 do_spec_1 (switches
[switchnum
].part1
, 1, NULL
);
5991 if (switches
[switchnum
].args
!= 0)
5994 for (p
= switches
[switchnum
].args
; *p
; p
++)
5996 const char *arg
= *p
;
5998 do_spec_1 (" ", 0, NULL
);
6001 unsigned length
= strlen (arg
);
6004 while (length
-- && !IS_DIR_SEPARATOR (arg
[length
]))
6005 if (arg
[length
] == '.')
6007 (CONST_CAST(char *, arg
))[length
] = 0;
6011 do_spec_1 (arg
, 1, NULL
);
6013 (CONST_CAST(char *, arg
))[length
] = '.';
6014 do_spec_1 (suffix_subst
, 1, NULL
);
6017 do_spec_1 (arg
, 1, NULL
);
6021 do_spec_1 (" ", 0, NULL
);
6022 switches
[switchnum
].validated
= true;
6025 /* Search for a file named NAME trying various prefixes including the
6026 user's -B prefix and some standard ones.
6027 Return the absolute file name found. If nothing is found, return NAME. */
6030 find_file (const char *name
)
6032 char *newname
= find_a_file (&startfile_prefixes
, name
, R_OK
, true);
6033 return newname
? newname
: name
;
6036 /* Determine whether a directory exists. If LINKER, return 0 for
6037 certain fixed names not needed by the linker. */
6040 is_directory (const char *path1
, bool linker
)
6047 /* Ensure the string ends with "/.". The resulting path will be a
6048 directory even if the given path is a symbolic link. */
6049 len1
= strlen (path1
);
6050 path
= (char *) alloca (3 + len1
);
6051 memcpy (path
, path1
, len1
);
6053 if (!IS_DIR_SEPARATOR (cp
[-1]))
6054 *cp
++ = DIR_SEPARATOR
;
6058 /* Exclude directories that the linker is known to search. */
6060 && IS_DIR_SEPARATOR (path
[0])
6062 && filename_ncmp (path
+ 1, "lib", 3) == 0)
6064 && filename_ncmp (path
+ 1, "usr", 3) == 0
6065 && IS_DIR_SEPARATOR (path
[4])
6066 && filename_ncmp (path
+ 5, "lib", 3) == 0)))
6069 return (stat (path
, &st
) >= 0 && S_ISDIR (st
.st_mode
));
6072 /* Set up the various global variables to indicate that we're processing
6073 the input file named FILENAME. */
6076 set_input (const char *filename
)
6080 gcc_input_filename
= filename
;
6081 input_filename_length
= strlen (gcc_input_filename
);
6082 input_basename
= lbasename (gcc_input_filename
);
6084 /* Find a suffix starting with the last period,
6085 and set basename_length to exclude that suffix. */
6086 basename_length
= strlen (input_basename
);
6087 suffixed_basename_length
= basename_length
;
6088 p
= input_basename
+ basename_length
;
6089 while (p
!= input_basename
&& *p
!= '.')
6091 if (*p
== '.' && p
!= input_basename
)
6093 basename_length
= p
- input_basename
;
6094 input_suffix
= p
+ 1;
6099 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
6100 we will need to do a stat on the gcc_input_filename. The
6101 INPUT_STAT_SET signals that the stat is needed. */
6105 /* On fatal signals, delete all the temporary files. */
6108 fatal_signal (int signum
)
6110 signal (signum
, SIG_DFL
);
6111 delete_failure_queue ();
6112 delete_temp_files ();
6113 /* Get the same signal again, this time not handled,
6114 so its normal effect occurs. */
6115 kill (getpid (), signum
);
6118 /* Compare the contents of the two files named CMPFILE[0] and
6119 CMPFILE[1]. Return zero if they're identical, nonzero
6123 compare_files (char *cmpfile
[])
6126 FILE *temp
[2] = { NULL
, NULL
};
6132 void *map
[2] = { NULL
, NULL
};
6134 for (i
= 0; i
< 2; i
++)
6138 if (stat (cmpfile
[i
], &st
) < 0 || !S_ISREG (st
.st_mode
))
6140 error ("%s: could not determine length of compare-debug file %s",
6141 gcc_input_filename
, cmpfile
[i
]);
6146 length
[i
] = st
.st_size
;
6149 if (!ret
&& length
[0] != length
[1])
6151 error ("%s: -fcompare-debug failure (length)", gcc_input_filename
);
6156 for (i
= 0; i
< 2; i
++)
6158 int fd
= open (cmpfile
[i
], O_RDONLY
);
6161 error ("%s: could not open compare-debug file %s",
6162 gcc_input_filename
, cmpfile
[i
]);
6167 map
[i
] = mmap (NULL
, length
[i
], PROT_READ
, MAP_PRIVATE
, fd
, 0);
6170 if (map
[i
] == (void *) MAP_FAILED
)
6179 if (memcmp (map
[0], map
[1], length
[0]) != 0)
6181 error ("%s: -fcompare-debug failure", gcc_input_filename
);
6186 for (i
= 0; i
< 2; i
++)
6188 munmap ((caddr_t
) map
[i
], length
[i
]);
6197 for (i
= 0; i
< 2; i
++)
6199 temp
[i
] = fopen (cmpfile
[i
], "r");
6202 error ("%s: could not open compare-debug file %s",
6203 gcc_input_filename
, cmpfile
[i
]);
6209 if (!ret
&& temp
[0] && temp
[1])
6213 c0
= fgetc (temp
[0]);
6214 c1
= fgetc (temp
[1]);
6218 error ("%s: -fcompare-debug failure",
6219 gcc_input_filename
);
6228 for (i
= 1; i
>= 0; i
--)
6237 extern int main (int, char **);
6240 main (int argc
, char **argv
)
6244 int linker_was_run
= 0;
6245 int lang_n_infiles
= 0;
6246 int num_linker_inputs
= 0;
6247 char *explicit_link_files
;
6249 char *lto_wrapper_file
;
6251 struct user_specs
*uptr
;
6252 char **old_argv
= argv
;
6253 struct cl_decoded_option
*decoded_options
;
6254 unsigned int decoded_options_count
;
6256 p
= argv
[0] + strlen (argv
[0]);
6257 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
6261 xmalloc_set_program_name (progname
);
6263 expandargv (&argc
, &argv
);
6265 /* Determine if any expansions were made. */
6266 if (argv
!= old_argv
)
6267 at_file_supplied
= true;
6269 /* Register the language-independent parameters. */
6270 global_init_params ();
6273 init_options_struct (&global_options
, &global_options_set
);
6275 decode_cmdline_options_to_array (argc
, CONST_CAST2 (const char **, char **,
6278 &decoded_options
, &decoded_options_count
);
6280 /* Unlock the stdio streams. */
6281 unlock_std_streams ();
6283 gcc_init_libintl ();
6285 diagnostic_initialize (global_dc
, 0);
6287 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6288 /* Perform host dependent initialization when needed. */
6289 GCC_DRIVER_HOST_INITIALIZATION
;
6292 if (atexit (delete_temp_files
) != 0)
6293 fatal_error ("atexit failed");
6295 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
6296 signal (SIGINT
, fatal_signal
);
6298 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
6299 signal (SIGHUP
, fatal_signal
);
6301 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
6302 signal (SIGTERM
, fatal_signal
);
6304 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
6305 signal (SIGPIPE
, fatal_signal
);
6308 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6309 receive the signal. A different setting is inheritable */
6310 signal (SIGCHLD
, SIG_DFL
);
6313 /* Parsing and gimplification sometimes need quite large stack.
6314 Increase stack size limits if possible. */
6315 stack_limit_increase (64 * 1024 * 1024);
6317 /* Allocate the argument vector. */
6320 obstack_init (&obstack
);
6322 /* Build multilib_select, et. al from the separate lines that make up each
6323 multilib selection. */
6325 const char *const *q
= multilib_raw
;
6328 obstack_init (&multilib_obstack
);
6329 while ((p
= *q
++) != (char *) 0)
6330 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6332 obstack_1grow (&multilib_obstack
, 0);
6333 multilib_select
= XOBFINISH (&multilib_obstack
, const char *);
6335 q
= multilib_matches_raw
;
6336 while ((p
= *q
++) != (char *) 0)
6337 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6339 obstack_1grow (&multilib_obstack
, 0);
6340 multilib_matches
= XOBFINISH (&multilib_obstack
, const char *);
6342 q
= multilib_exclusions_raw
;
6343 while ((p
= *q
++) != (char *) 0)
6344 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6346 obstack_1grow (&multilib_obstack
, 0);
6347 multilib_exclusions
= XOBFINISH (&multilib_obstack
, const char *);
6349 q
= multilib_reuse_raw
;
6350 while ((p
= *q
++) != (char *) 0)
6351 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6353 obstack_1grow (&multilib_obstack
, 0);
6354 multilib_reuse
= XOBFINISH (&multilib_obstack
, const char *);
6357 for (i
= 0; i
< ARRAY_SIZE (multilib_defaults_raw
); i
++)
6360 obstack_1grow (&multilib_obstack
, ' ');
6361 obstack_grow (&multilib_obstack
,
6362 multilib_defaults_raw
[i
],
6363 strlen (multilib_defaults_raw
[i
]));
6367 obstack_1grow (&multilib_obstack
, 0);
6368 multilib_defaults
= XOBFINISH (&multilib_obstack
, const char *);
6371 #ifdef INIT_ENVIRONMENT
6372 /* Set up any other necessary machine specific environment variables. */
6373 xputenv (INIT_ENVIRONMENT
);
6376 /* Make a table of what switches there are (switches, n_switches).
6377 Make a table of specified input files (infiles, n_infiles).
6378 Decode switches that are handled locally. */
6380 process_command (decoded_options_count
, decoded_options
);
6382 /* Initialize the vector of specs to just the default.
6383 This means one element containing 0s, as a terminator. */
6385 compilers
= XNEWVAR (struct compiler
, sizeof default_compilers
);
6386 memcpy (compilers
, default_compilers
, sizeof default_compilers
);
6387 n_compilers
= n_default_compilers
;
6389 /* Read specs from a file if there is one. */
6391 machine_suffix
= concat (spec_machine
, dir_separator_str
,
6392 spec_version
, dir_separator_str
, NULL
);
6393 just_machine_suffix
= concat (spec_machine
, dir_separator_str
, NULL
);
6395 specs_file
= find_a_file (&startfile_prefixes
, "specs", R_OK
, true);
6396 /* Read the specs file unless it is a default one. */
6397 if (specs_file
!= 0 && strcmp (specs_file
, "specs"))
6398 read_specs (specs_file
, true, false);
6402 /* We need to check standard_exec_prefix/just_machine_suffix/specs
6403 for any override of as, ld and libraries. */
6404 specs_file
= (char *) alloca (strlen (standard_exec_prefix
)
6405 + strlen (just_machine_suffix
) + sizeof ("specs"));
6407 strcpy (specs_file
, standard_exec_prefix
);
6408 strcat (specs_file
, just_machine_suffix
);
6409 strcat (specs_file
, "specs");
6410 if (access (specs_file
, R_OK
) == 0)
6411 read_specs (specs_file
, true, false);
6413 /* Process any configure-time defaults specified for the command line
6414 options, via OPTION_DEFAULT_SPECS. */
6415 for (i
= 0; i
< ARRAY_SIZE (option_default_specs
); i
++)
6416 do_option_spec (option_default_specs
[i
].name
,
6417 option_default_specs
[i
].spec
);
6419 /* Process DRIVER_SELF_SPECS, adding any new options to the end
6420 of the command line. */
6422 for (i
= 0; i
< ARRAY_SIZE (driver_self_specs
); i
++)
6423 do_self_spec (driver_self_specs
[i
]);
6425 /* If not cross-compiling, look for executables in the standard
6427 if (*cross_compile
== '0')
6429 if (*md_exec_prefix
)
6431 add_prefix (&exec_prefixes
, md_exec_prefix
, "GCC",
6432 PREFIX_PRIORITY_LAST
, 0, 0);
6436 /* Process sysroot_suffix_spec. */
6437 if (*sysroot_suffix_spec
!= 0
6438 && !no_sysroot_suffix
6439 && do_spec_2 (sysroot_suffix_spec
) == 0)
6441 if (argbuf
.length () > 1)
6442 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
6443 else if (argbuf
.length () == 1)
6444 target_sysroot_suffix
= xstrdup (argbuf
.last ());
6447 #ifdef HAVE_LD_SYSROOT
6448 /* Pass the --sysroot option to the linker, if it supports that. If
6449 there is a sysroot_suffix_spec, it has already been processed by
6450 this point, so target_system_root really is the system root we
6452 if (target_system_root
)
6454 obstack_grow (&obstack
, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
6455 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
6456 set_spec ("link", XOBFINISH (&obstack
, const char *), false);
6460 /* Process sysroot_hdrs_suffix_spec. */
6461 if (*sysroot_hdrs_suffix_spec
!= 0
6462 && !no_sysroot_suffix
6463 && do_spec_2 (sysroot_hdrs_suffix_spec
) == 0)
6465 if (argbuf
.length () > 1)
6466 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
6467 else if (argbuf
.length () == 1)
6468 target_sysroot_hdrs_suffix
= xstrdup (argbuf
.last ());
6471 /* Look for startfiles in the standard places. */
6472 if (*startfile_prefix_spec
!= 0
6473 && do_spec_2 (startfile_prefix_spec
) == 0
6474 && do_spec_1 (" ", 0, NULL
) == 0)
6478 FOR_EACH_VEC_ELT (argbuf
, ndx
, arg
)
6479 add_sysrooted_prefix (&startfile_prefixes
, arg
, "BINUTILS",
6480 PREFIX_PRIORITY_LAST
, 0, 1);
6482 /* We should eventually get rid of all these and stick to
6483 startfile_prefix_spec exclusively. */
6484 else if (*cross_compile
== '0' || target_system_root
)
6486 if (*md_startfile_prefix
)
6487 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix
,
6488 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
6490 if (*md_startfile_prefix_1
)
6491 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix_1
,
6492 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
6494 /* If standard_startfile_prefix is relative, base it on
6495 standard_exec_prefix. This lets us move the installed tree
6496 as a unit. If GCC_EXEC_PREFIX is defined, base
6497 standard_startfile_prefix on that as well.
6499 If the prefix is relative, only search it for native compilers;
6500 otherwise we will search a directory containing host libraries. */
6501 if (IS_ABSOLUTE_PATH (standard_startfile_prefix
))
6502 add_sysrooted_prefix (&startfile_prefixes
,
6503 standard_startfile_prefix
, "BINUTILS",
6504 PREFIX_PRIORITY_LAST
, 0, 1);
6505 else if (*cross_compile
== '0')
6507 add_prefix (&startfile_prefixes
,
6508 concat (gcc_exec_prefix
6509 ? gcc_exec_prefix
: standard_exec_prefix
,
6511 standard_startfile_prefix
, NULL
),
6512 NULL
, PREFIX_PRIORITY_LAST
, 0, 1);
6515 /* Sysrooted prefixes are relocated because target_system_root is
6516 also relocated by gcc_exec_prefix. */
6517 if (*standard_startfile_prefix_1
)
6518 add_sysrooted_prefix (&startfile_prefixes
,
6519 standard_startfile_prefix_1
, "BINUTILS",
6520 PREFIX_PRIORITY_LAST
, 0, 1);
6521 if (*standard_startfile_prefix_2
)
6522 add_sysrooted_prefix (&startfile_prefixes
,
6523 standard_startfile_prefix_2
, "BINUTILS",
6524 PREFIX_PRIORITY_LAST
, 0, 1);
6527 /* Process any user specified specs in the order given on the command
6529 for (uptr
= user_specs_head
; uptr
; uptr
= uptr
->next
)
6531 char *filename
= find_a_file (&startfile_prefixes
, uptr
->filename
,
6533 read_specs (filename
? filename
: uptr
->filename
, false, true);
6536 /* Process any user self specs. */
6538 struct spec_list
*sl
;
6539 for (sl
= specs
; sl
; sl
= sl
->next
)
6540 if (sl
->name_len
== sizeof "self_spec" - 1
6541 && !strcmp (sl
->name
, "self_spec"))
6542 do_self_spec (*sl
->ptr_spec
);
6547 enum save_temps save
;
6549 if (!compare_debug_second
)
6551 n_switches_debug_check
[1] = n_switches
;
6552 n_switches_alloc_debug_check
[1] = n_switches_alloc
;
6553 switches_debug_check
[1] = XDUPVEC (struct switchstr
, switches
,
6556 do_self_spec ("%:compare-debug-self-opt()");
6557 n_switches_debug_check
[0] = n_switches
;
6558 n_switches_alloc_debug_check
[0] = n_switches_alloc
;
6559 switches_debug_check
[0] = switches
;
6561 n_switches
= n_switches_debug_check
[1];
6562 n_switches_alloc
= n_switches_alloc_debug_check
[1];
6563 switches
= switches_debug_check
[1];
6566 /* Avoid crash when computing %j in this early. */
6567 save
= save_temps_flag
;
6568 save_temps_flag
= SAVE_TEMPS_NONE
;
6570 compare_debug
= -compare_debug
;
6571 do_self_spec ("%:compare-debug-self-opt()");
6573 save_temps_flag
= save
;
6575 if (!compare_debug_second
)
6577 n_switches_debug_check
[1] = n_switches
;
6578 n_switches_alloc_debug_check
[1] = n_switches_alloc
;
6579 switches_debug_check
[1] = switches
;
6580 compare_debug
= -compare_debug
;
6581 n_switches
= n_switches_debug_check
[0];
6582 n_switches_alloc
= n_switches_debug_check
[0];
6583 switches
= switches_debug_check
[0];
6588 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
6589 if (gcc_exec_prefix
)
6590 gcc_exec_prefix
= concat (gcc_exec_prefix
, spec_machine
, dir_separator_str
,
6591 spec_version
, dir_separator_str
, NULL
);
6593 /* Now we have the specs.
6594 Set the `valid' bits for switches that match anything in any spec. */
6596 validate_all_switches ();
6598 /* Now that we have the switches and the specs, set
6599 the subdirectory based on the options. */
6600 set_multilib_dir ();
6602 /* Set up to remember the pathname of gcc and any options
6603 needed for collect. We use argv[0] instead of progname because
6604 we need the complete pathname. */
6605 obstack_init (&collect_obstack
);
6606 obstack_grow (&collect_obstack
, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
6607 obstack_grow (&collect_obstack
, argv
[0], strlen (argv
[0]) + 1);
6608 xputenv (XOBFINISH (&collect_obstack
, char *));
6610 /* Set up to remember the pathname of the lto wrapper. */
6613 lto_wrapper_file
= NULL
;
6615 lto_wrapper_file
= find_a_file (&exec_prefixes
, "lto-wrapper",
6617 if (lto_wrapper_file
)
6619 lto_wrapper_spec
= lto_wrapper_file
;
6620 obstack_init (&collect_obstack
);
6621 obstack_grow (&collect_obstack
, "COLLECT_LTO_WRAPPER=",
6622 sizeof ("COLLECT_LTO_WRAPPER=") - 1);
6623 obstack_grow (&collect_obstack
, lto_wrapper_spec
,
6624 strlen (lto_wrapper_spec
) + 1);
6625 xputenv (XOBFINISH (&collect_obstack
, char *));
6628 /* Reject switches that no pass was interested in. */
6630 for (i
= 0; (int) i
< n_switches
; i
++)
6631 if (! switches
[i
].validated
)
6632 error ("unrecognized command line option %<-%s%>", switches
[i
].part1
);
6634 /* Obey some of the options. */
6636 if (print_search_dirs
)
6638 printf (_("install: %s%s\n"),
6639 gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
6640 gcc_exec_prefix
? "" : machine_suffix
);
6641 printf (_("programs: %s\n"),
6642 build_search_list (&exec_prefixes
, "", false, false));
6643 printf (_("libraries: %s\n"),
6644 build_search_list (&startfile_prefixes
, "", false, true));
6648 if (print_file_name
)
6650 printf ("%s\n", find_file (print_file_name
));
6654 if (print_prog_name
)
6656 char *newname
= find_a_file (&exec_prefixes
, print_prog_name
, X_OK
, 0);
6657 printf ("%s\n", (newname
? newname
: print_prog_name
));
6661 if (print_multi_lib
)
6663 print_multilib_info ();
6667 if (print_multi_directory
)
6669 if (multilib_dir
== NULL
)
6672 printf ("%s\n", multilib_dir
);
6676 if (print_multiarch
)
6678 if (multiarch_dir
== NULL
)
6681 printf ("%s\n", multiarch_dir
);
6687 if (target_system_root
)
6689 if (target_sysroot_suffix
)
6690 printf ("%s%s\n", target_system_root
, target_sysroot_suffix
);
6692 printf ("%s\n", target_system_root
);
6697 if (print_multi_os_directory
)
6699 if (multilib_os_dir
== NULL
)
6702 printf ("%s\n", multilib_os_dir
);
6706 if (print_sysroot_headers_suffix
)
6708 if (*sysroot_hdrs_suffix_spec
)
6710 printf("%s\n", (target_sysroot_hdrs_suffix
6711 ? target_sysroot_hdrs_suffix
6716 /* The error status indicates that only one set of fixed
6717 headers should be built. */
6718 fatal_error ("not configured with sysroot headers suffix");
6721 if (print_help_list
)
6727 printf (_("\nFor bug reporting instructions, please see:\n"));
6728 printf ("%s.\n", bug_report_url
);
6733 /* We do not exit here. Instead we have created a fake input file
6734 called 'help-dummy' which needs to be compiled, and we pass this
6735 on the various sub-processes, along with the --help switch.
6736 Ensure their output appears after ours. */
6737 fputc ('\n', stdout
);
6743 printf (_("%s %s%s\n"), progname
, pkgversion_string
,
6745 printf ("Copyright %s 2013 Free Software Foundation, Inc.\n",
6747 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
6748 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
6753 /* We do not exit here. We use the same mechanism of --help to print
6754 the version of the sub-processes. */
6755 fputc ('\n', stdout
);
6764 fnotice (stderr
, "Target: %s\n", spec_machine
);
6765 fnotice (stderr
, "Configured with: %s\n", configuration_arguments
);
6767 #ifdef THREAD_MODEL_SPEC
6768 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
6769 but there's no point in doing all this processing just to get
6770 thread_model back. */
6771 obstack_init (&obstack
);
6772 do_spec_1 (THREAD_MODEL_SPEC
, 0, thread_model
);
6773 obstack_1grow (&obstack
, '\0');
6774 thrmod
= XOBFINISH (&obstack
, const char *);
6776 thrmod
= thread_model
;
6779 fnotice (stderr
, "Thread model: %s\n", thrmod
);
6781 /* compiler_version is truncated at the first space when initialized
6782 from version string, so truncate version_string at the first space
6783 before comparing. */
6784 for (n
= 0; version_string
[n
]; n
++)
6785 if (version_string
[n
] == ' ')
6788 if (! strncmp (version_string
, compiler_version
, n
)
6789 && compiler_version
[n
] == 0)
6790 fnotice (stderr
, "gcc version %s %s\n", version_string
,
6793 fnotice (stderr
, "gcc driver version %s %sexecuting gcc version %s\n",
6794 version_string
, pkgversion_string
, compiler_version
);
6800 if (n_infiles
== added_libraries
)
6801 fatal_error ("no input files");
6806 /* Make a place to record the compiler output file names
6807 that correspond to the input files. */
6810 i
+= lang_specific_extra_outfiles
;
6811 outfiles
= XCNEWVEC (const char *, i
);
6813 /* Record which files were specified explicitly as link input. */
6815 explicit_link_files
= XCNEWVEC (char, n_infiles
);
6817 combine_inputs
= have_o
|| flag_wpa
;
6819 for (i
= 0; (int) i
< n_infiles
; i
++)
6821 const char *name
= infiles
[i
].name
;
6822 struct compiler
*compiler
= lookup_compiler (name
,
6824 infiles
[i
].language
);
6826 if (compiler
&& !(compiler
->combinable
))
6827 combine_inputs
= false;
6829 if (lang_n_infiles
> 0 && compiler
!= input_file_compiler
6830 && infiles
[i
].language
&& infiles
[i
].language
[0] != '*')
6831 infiles
[i
].incompiler
= compiler
;
6835 input_file_compiler
= compiler
;
6836 infiles
[i
].incompiler
= compiler
;
6840 /* Since there is no compiler for this input file, assume it is a
6842 explicit_link_files
[i
] = 1;
6843 infiles
[i
].incompiler
= NULL
;
6845 infiles
[i
].compiled
= false;
6846 infiles
[i
].preprocessed
= false;
6849 if (!combine_inputs
&& have_c
&& have_o
&& lang_n_infiles
> 1)
6850 fatal_error ("cannot specify -o with -c, -S or -E with multiple files");
6852 for (i
= 0; (int) i
< n_infiles
; i
++)
6854 int this_file_error
= 0;
6856 /* Tell do_spec what to substitute for %i. */
6858 input_file_number
= i
;
6859 set_input (infiles
[i
].name
);
6861 if (infiles
[i
].compiled
)
6864 /* Use the same thing in %o, unless cp->spec says otherwise. */
6866 outfiles
[i
] = gcc_input_filename
;
6868 /* Figure out which compiler from the file's suffix. */
6871 = lookup_compiler (infiles
[i
].name
, input_filename_length
,
6872 infiles
[i
].language
);
6874 if (input_file_compiler
)
6876 /* Ok, we found an applicable compiler. Run its spec. */
6878 if (input_file_compiler
->spec
[0] == '#')
6880 error ("%s: %s compiler not installed on this system",
6881 gcc_input_filename
, &input_file_compiler
->spec
[1]);
6882 this_file_error
= 1;
6888 free (debug_check_temp_file
[0]);
6889 debug_check_temp_file
[0] = NULL
;
6891 free (debug_check_temp_file
[1]);
6892 debug_check_temp_file
[1] = NULL
;
6895 value
= do_spec (input_file_compiler
->spec
);
6896 infiles
[i
].compiled
= true;
6898 this_file_error
= 1;
6899 else if (compare_debug
&& debug_check_temp_file
[0])
6902 inform (0, "recompiling with -fcompare-debug");
6904 compare_debug
= -compare_debug
;
6905 n_switches
= n_switches_debug_check
[1];
6906 n_switches_alloc
= n_switches_alloc_debug_check
[1];
6907 switches
= switches_debug_check
[1];
6909 value
= do_spec (input_file_compiler
->spec
);
6911 compare_debug
= -compare_debug
;
6912 n_switches
= n_switches_debug_check
[0];
6913 n_switches_alloc
= n_switches_alloc_debug_check
[0];
6914 switches
= switches_debug_check
[0];
6918 error ("during -fcompare-debug recompilation");
6919 this_file_error
= 1;
6922 gcc_assert (debug_check_temp_file
[1]
6923 && filename_cmp (debug_check_temp_file
[0],
6924 debug_check_temp_file
[1]));
6927 inform (0, "comparing final insns dumps");
6929 if (compare_files (debug_check_temp_file
))
6930 this_file_error
= 1;
6935 free (debug_check_temp_file
[0]);
6936 debug_check_temp_file
[0] = NULL
;
6938 free (debug_check_temp_file
[1]);
6939 debug_check_temp_file
[1] = NULL
;
6944 /* If this file's name does not contain a recognized suffix,
6945 record it as explicit linker input. */
6948 explicit_link_files
[i
] = 1;
6950 /* Clear the delete-on-failure queue, deleting the files in it
6951 if this compilation failed. */
6953 if (this_file_error
)
6955 delete_failure_queue ();
6958 /* If this compilation succeeded, don't delete those files later. */
6959 clear_failure_queue ();
6962 /* Reset the input file name to the first compile/object file name, for use
6963 with %b in LINK_SPEC. We use the first input file that we can find
6964 a compiler to compile it instead of using infiles.language since for
6965 languages other than C we use aliases that we then lookup later. */
6970 for (i
= 0; i
< n_infiles
; i
++)
6971 if (infiles
[i
].incompiler
6972 || (infiles
[i
].language
&& infiles
[i
].language
[0] != '*'))
6974 set_input (infiles
[i
].name
);
6981 /* Make sure INPUT_FILE_NUMBER points to first available open
6983 input_file_number
= n_infiles
;
6984 if (lang_specific_pre_link ())
6988 /* Determine if there are any linker input files. */
6989 num_linker_inputs
= 0;
6990 for (i
= 0; (int) i
< n_infiles
; i
++)
6991 if (explicit_link_files
[i
] || outfiles
[i
] != NULL
)
6992 num_linker_inputs
++;
6994 /* Run ld to link all the compiler output files. */
6996 if (num_linker_inputs
> 0 && !seen_error () && print_subprocess_help
< 2)
6998 int tmp
= execution_count
;
7002 #if HAVE_LTO_PLUGIN > 0
7003 #if HAVE_LTO_PLUGIN == 2
7004 const char *fno_use_linker_plugin
= "fno-use-linker-plugin";
7006 const char *fuse_linker_plugin
= "fuse-linker-plugin";
7010 /* We'll use ld if we can't find collect2. */
7011 if (! strcmp (linker_name_spec
, "collect2"))
7013 char *s
= find_a_file (&exec_prefixes
, "collect2", X_OK
, false);
7015 linker_name_spec
= "ld";
7018 #if HAVE_LTO_PLUGIN > 0
7019 #if HAVE_LTO_PLUGIN == 2
7020 if (!switch_matches (fno_use_linker_plugin
,
7021 fno_use_linker_plugin
7022 + strlen (fno_use_linker_plugin
), 0))
7024 if (switch_matches (fuse_linker_plugin
,
7026 + strlen (fuse_linker_plugin
), 0))
7029 linker_plugin_file_spec
= find_a_file (&exec_prefixes
,
7030 LTOPLUGINSONAME
, R_OK
,
7032 if (!linker_plugin_file_spec
)
7033 fatal_error ("-fuse-linker-plugin, but %s not found",
7037 lto_gcc_spec
= argv
[0];
7040 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
7042 putenv_from_prefixes (&exec_prefixes
, "COMPILER_PATH", false);
7043 putenv_from_prefixes (&startfile_prefixes
, LIBRARY_PATH_ENV
, true);
7045 if (print_subprocess_help
== 1)
7047 printf (_("\nLinker options\n==============\n\n"));
7048 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
7049 " to the linker.\n\n"));
7052 value
= do_spec (link_command_spec
);
7055 linker_was_run
= (tmp
!= execution_count
);
7058 /* If options said don't run linker,
7059 complain about input files to be given to the linker. */
7061 if (! linker_was_run
&& !seen_error ())
7062 for (i
= 0; (int) i
< n_infiles
; i
++)
7063 if (explicit_link_files
[i
]
7064 && !(infiles
[i
].language
&& infiles
[i
].language
[0] == '*'))
7065 warning (0, "%s: linker input file unused because linking not done",
7068 /* Delete some or all of the temporary files we made. */
7071 delete_failure_queue ();
7072 delete_temp_files ();
7074 if (print_help_list
)
7076 printf (("\nFor bug reporting instructions, please see:\n"));
7077 printf ("%s\n", bug_report_url
);
7081 return (signal_count
!= 0 ? 2
7082 : seen_error () ? (pass_exit_codes
? greatest_status
: 1)
7086 /* Find the proper compilation spec for the file name NAME,
7087 whose length is LENGTH. LANGUAGE is the specified language,
7088 or 0 if this file is to be passed to the linker. */
7090 static struct compiler
*
7091 lookup_compiler (const char *name
, size_t length
, const char *language
)
7093 struct compiler
*cp
;
7095 /* If this was specified by the user to be a linker input, indicate that. */
7096 if (language
!= 0 && language
[0] == '*')
7099 /* Otherwise, look for the language, if one is spec'd. */
7102 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
7103 if (cp
->suffix
[0] == '@' && !strcmp (cp
->suffix
+ 1, language
))
7106 error ("language %s not recognized", language
);
7110 /* Look for a suffix. */
7111 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
7113 if (/* The suffix `-' matches only the file name `-'. */
7114 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
7115 || (strlen (cp
->suffix
) < length
7116 /* See if the suffix matches the end of NAME. */
7117 && !strcmp (cp
->suffix
,
7118 name
+ length
- strlen (cp
->suffix
))
7123 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
7124 /* Look again, but case-insensitively this time. */
7126 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
7128 if (/* The suffix `-' matches only the file name `-'. */
7129 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
7130 || (strlen (cp
->suffix
) < length
7131 /* See if the suffix matches the end of NAME. */
7132 && ((!strcmp (cp
->suffix
,
7133 name
+ length
- strlen (cp
->suffix
))
7134 || !strpbrk (cp
->suffix
, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
7135 && !strcasecmp (cp
->suffix
,
7136 name
+ length
- strlen (cp
->suffix
)))
7142 if (cp
>= compilers
)
7144 if (cp
->spec
[0] != '@')
7145 /* A non-alias entry: return it. */
7148 /* An alias entry maps a suffix to a language.
7149 Search for the language; pass 0 for NAME and LENGTH
7150 to avoid infinite recursion if language not found. */
7151 return lookup_compiler (NULL
, 0, cp
->spec
+ 1);
7157 save_string (const char *s
, int len
)
7159 char *result
= XNEWVEC (char, len
+ 1);
7161 memcpy (result
, s
, len
);
7167 pfatal_with_name (const char *name
)
7169 perror_with_name (name
);
7170 delete_temp_files ();
7175 perror_with_name (const char *name
)
7177 error ("%s: %m", name
);
7181 validate_switches_from_spec (const char *spec
, bool user
)
7183 const char *p
= spec
;
7186 if (c
== '%' && (*p
== '{' || *p
== '<' || (*p
== 'W' && *++p
== '{')))
7187 /* We have a switch spec. */
7188 p
= validate_switches (p
+ 1, user
);
7192 validate_all_switches (void)
7194 struct compiler
*comp
;
7195 struct spec_list
*spec
;
7197 for (comp
= compilers
; comp
->spec
; comp
++)
7198 validate_switches_from_spec (comp
->spec
, false);
7200 /* Look through the linked list of specs read from the specs file. */
7201 for (spec
= specs
; spec
; spec
= spec
->next
)
7202 validate_switches_from_spec (*spec
->ptr_spec
, spec
->user_p
);
7204 validate_switches_from_spec (link_command_spec
, false);
7207 /* Look at the switch-name that comes after START
7208 and mark as valid all supplied switches that match it. */
7211 validate_switches (const char *start
, bool user_spec
)
7213 const char *p
= start
;
7217 bool suffix
= false;
7218 bool starred
= false;
7220 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7229 if (*p
== '.' || *p
== ',')
7233 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
7234 || *p
== ',' || *p
== '.' || *p
== '@')
7239 starred
= true, p
++;
7245 /* Mark all matching switches as valid. */
7246 for (i
= 0; i
< n_switches
; i
++)
7247 if (!strncmp (switches
[i
].part1
, atom
, len
)
7248 && (starred
|| switches
[i
].part1
[len
] == '\0')
7249 && (switches
[i
].known
|| user_spec
))
7250 switches
[i
].validated
= true;
7254 if (*p
&& (p
[-1] == '|' || p
[-1] == '&'))
7257 if (*p
&& p
[-1] == ':')
7259 while (*p
&& *p
!= ';' && *p
!= '}')
7264 if (*p
== '{' || *p
== '<')
7265 p
= validate_switches (p
+1, user_spec
);
7266 else if (p
[0] == 'W' && p
[1] == '{')
7267 p
= validate_switches (p
+2, user_spec
);
7274 if (*p
&& p
[-1] == ';')
7288 static struct mdswitchstr
*mdswitches
;
7289 static int n_mdswitches
;
7291 /* Check whether a particular argument was used. The first time we
7292 canonicalize the switches to keep only the ones we care about. */
7295 used_arg (const char *p
, int len
)
7300 const char *replace
;
7305 static struct mswitchstr
*mswitches
;
7306 static int n_mswitches
;
7311 struct mswitchstr
*matches
;
7315 /* Break multilib_matches into the component strings of string
7316 and replacement string. */
7317 for (q
= multilib_matches
; *q
!= '\0'; q
++)
7322 = (struct mswitchstr
*) alloca ((sizeof (struct mswitchstr
)) * cnt
);
7324 q
= multilib_matches
;
7333 fatal_error ("multilib spec %qs is invalid",
7338 matches
[i
].len
= q
- matches
[i
].str
;
7340 matches
[i
].replace
= ++q
;
7341 while (*q
!= ';' && *q
!= '\0')
7344 goto invalid_matches
;
7347 matches
[i
].rep_len
= q
- matches
[i
].replace
;
7353 /* Now build a list of the replacement string for switches that we care
7354 about. Make sure we allocate at least one entry. This prevents
7355 xmalloc from calling fatal, and prevents us from re-executing this
7358 = XNEWVEC (struct mswitchstr
, n_mdswitches
+ (n_switches
? n_switches
: 1));
7359 for (i
= 0; i
< n_switches
; i
++)
7360 if ((switches
[i
].live_cond
& SWITCH_IGNORE
) == 0)
7362 int xlen
= strlen (switches
[i
].part1
);
7363 for (j
= 0; j
< cnt
; j
++)
7364 if (xlen
== matches
[j
].len
7365 && ! strncmp (switches
[i
].part1
, matches
[j
].str
, xlen
))
7367 mswitches
[n_mswitches
].str
= matches
[j
].replace
;
7368 mswitches
[n_mswitches
].len
= matches
[j
].rep_len
;
7369 mswitches
[n_mswitches
].replace
= (char *) 0;
7370 mswitches
[n_mswitches
].rep_len
= 0;
7376 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
7377 on the command line nor any options mutually incompatible with
7379 for (i
= 0; i
< n_mdswitches
; i
++)
7383 for (q
= multilib_options
; *q
!= '\0'; q
++)
7389 while (strncmp (q
, mdswitches
[i
].str
, mdswitches
[i
].len
) != 0
7390 || strchr (" /", q
[mdswitches
[i
].len
]) == NULL
)
7392 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
7399 if (*q
!= ' ' && *q
!= '\0')
7401 while (*r
!= ' ' && *r
!= '\0')
7404 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
7407 if (used_arg (r
, q
- r
))
7412 mswitches
[n_mswitches
].str
= mdswitches
[i
].str
;
7413 mswitches
[n_mswitches
].len
= mdswitches
[i
].len
;
7414 mswitches
[n_mswitches
].replace
= (char *) 0;
7415 mswitches
[n_mswitches
].rep_len
= 0;
7428 for (i
= 0; i
< n_mswitches
; i
++)
7429 if (len
== mswitches
[i
].len
&& ! strncmp (p
, mswitches
[i
].str
, len
))
7436 default_arg (const char *p
, int len
)
7440 for (i
= 0; i
< n_mdswitches
; i
++)
7441 if (len
== mdswitches
[i
].len
&& ! strncmp (p
, mdswitches
[i
].str
, len
))
7447 /* Work out the subdirectory to use based on the options. The format of
7448 multilib_select is a list of elements. Each element is a subdirectory
7449 name followed by a list of options followed by a semicolon. The format
7450 of multilib_exclusions is the same, but without the preceding
7451 directory. First gcc will check the exclusions, if none of the options
7452 beginning with an exclamation point are present, and all of the other
7453 options are present, then we will ignore this completely. Passing
7454 that, gcc will consider each multilib_select in turn using the same
7455 rules for matching the options. If a match is found, that subdirectory
7457 A subdirectory name is optionally followed by a colon and the corresponding
7461 set_multilib_dir (void)
7464 unsigned int this_path_len
;
7465 const char *this_path
, *this_arg
;
7466 const char *start
, *end
;
7468 int ok
, ndfltok
, first
;
7471 start
= multilib_defaults
;
7472 while (*start
== ' ' || *start
== '\t')
7474 while (*start
!= '\0')
7477 while (*start
!= ' ' && *start
!= '\t' && *start
!= '\0')
7479 while (*start
== ' ' || *start
== '\t')
7487 mdswitches
= XNEWVEC (struct mdswitchstr
, n_mdswitches
);
7488 for (start
= multilib_defaults
; *start
!= '\0'; start
= end
+ 1)
7490 while (*start
== ' ' || *start
== '\t')
7496 for (end
= start
+ 1;
7497 *end
!= ' ' && *end
!= '\t' && *end
!= '\0'; end
++)
7500 obstack_grow (&multilib_obstack
, start
, end
- start
);
7501 obstack_1grow (&multilib_obstack
, 0);
7502 mdswitches
[i
].str
= XOBFINISH (&multilib_obstack
, const char *);
7503 mdswitches
[i
++].len
= end
- start
;
7510 p
= multilib_exclusions
;
7513 /* Ignore newlines. */
7520 /* Check the arguments. */
7527 fatal_error ("multilib exclusions %qs is invalid",
7528 multilib_exclusions
);
7538 while (*p
!= ' ' && *p
!= ';')
7541 goto invalid_exclusions
;
7545 if (*this_arg
!= '!')
7553 ok
= used_arg (this_arg
, p
- this_arg
);
7568 p
= multilib_select
;
7570 /* Append multilib reuse rules if any. With those rules, we can reuse
7571 one multilib for certain different options sets. */
7572 if (strlen (multilib_reuse
) > 0)
7573 p
= concat (p
, multilib_reuse
, NULL
);
7577 /* Ignore newlines. */
7584 /* Get the initial path. */
7591 fatal_error ("multilib select %qs %qs is invalid",
7592 multilib_select
, multilib_reuse
);
7596 this_path_len
= p
- this_path
;
7598 /* Check the arguments. */
7605 goto invalid_select
;
7614 while (*p
!= ' ' && *p
!= ';')
7617 goto invalid_select
;
7621 if (*this_arg
!= '!')
7629 /* If this is a default argument, we can just ignore it.
7630 This is true even if this_arg begins with '!'. Beginning
7631 with '!' does not mean that this argument is necessarily
7632 inappropriate for this library: it merely means that
7633 there is a more specific library which uses this
7634 argument. If this argument is a default, we need not
7635 consider that more specific library. */
7636 ok
= used_arg (this_arg
, p
- this_arg
);
7643 if (default_arg (this_arg
, p
- this_arg
))
7652 if (this_path_len
!= 1
7653 || this_path
[0] != '.')
7655 char *new_multilib_dir
= XNEWVEC (char, this_path_len
+ 1);
7658 strncpy (new_multilib_dir
, this_path
, this_path_len
);
7659 new_multilib_dir
[this_path_len
] = '\0';
7660 q
= strchr (new_multilib_dir
, ':');
7663 multilib_dir
= new_multilib_dir
;
7670 const char *q
= this_path
, *end
= this_path
+ this_path_len
;
7672 while (q
< end
&& *q
!= ':')
7676 const char *q2
= q
+ 1, *ml_end
= end
;
7677 char *new_multilib_os_dir
;
7679 while (q2
< end
&& *q2
!= ':')
7683 new_multilib_os_dir
= XNEWVEC (char, ml_end
- q
);
7684 memcpy (new_multilib_os_dir
, q
+ 1, ml_end
- q
- 1);
7685 new_multilib_os_dir
[ml_end
- q
- 1] = '\0';
7686 multilib_os_dir
= *new_multilib_os_dir
? new_multilib_os_dir
: ".";
7688 if (q2
< end
&& *q2
== ':')
7690 char *new_multiarch_dir
= XNEWVEC (char, end
- q2
);
7691 memcpy (new_multiarch_dir
, q2
+ 1, end
- q2
- 1);
7692 new_multiarch_dir
[end
- q2
- 1] = '\0';
7693 multiarch_dir
= new_multiarch_dir
;
7702 if (multilib_dir
== NULL
&& multilib_os_dir
!= NULL
7703 && strcmp (multilib_os_dir
, ".") == 0)
7705 free (CONST_CAST (char *, multilib_os_dir
));
7706 multilib_os_dir
= NULL
;
7708 else if (multilib_dir
!= NULL
&& multilib_os_dir
== NULL
)
7709 multilib_os_dir
= multilib_dir
;
7712 /* Print out the multiple library subdirectory selection
7713 information. This prints out a series of lines. Each line looks
7714 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
7715 required. Only the desired options are printed out, the negative
7716 matches. The options are print without a leading dash. There are
7717 no spaces to make it easy to use the information in the shell.
7718 Each subdirectory is printed only once. This assumes the ordering
7719 generated by the genmultilib script. Also, we leave out ones that match
7723 print_multilib_info (void)
7725 const char *p
= multilib_select
;
7726 const char *last_path
= 0, *this_path
;
7728 unsigned int last_path_len
= 0;
7733 /* Ignore newlines. */
7740 /* Get the initial path. */
7747 fatal_error ("multilib select %qs is invalid", multilib_select
);
7753 /* When --disable-multilib was used but target defines
7754 MULTILIB_OSDIRNAMES, entries starting with .: (and not starting
7755 with .:: for multiarch configurations) are there just to find
7756 multilib_os_dir, so skip them from output. */
7757 if (this_path
[0] == '.' && this_path
[1] == ':' && this_path
[2] != ':')
7760 /* Check for matches with the multilib_exclusions. We don't bother
7761 with the '!' in either list. If any of the exclusion rules match
7762 all of its options with the select rule, we skip it. */
7764 const char *e
= multilib_exclusions
;
7765 const char *this_arg
;
7770 /* Ignore newlines. */
7777 /* Check the arguments. */
7786 fatal_error ("multilib exclusion %qs is invalid",
7787 multilib_exclusions
);
7798 while (*e
!= ' ' && *e
!= ';')
7801 goto invalid_exclusion
;
7809 int len
= e
- this_arg
;
7812 goto invalid_select
;
7816 while (*q
!= ' ' && *q
!= ';')
7819 goto invalid_select
;
7823 if (! strncmp (arg
, this_arg
,
7824 (len
< q
- arg
) ? q
- arg
: len
)
7825 || default_arg (this_arg
, e
- this_arg
))
7855 /* If this is a duplicate, skip it. */
7856 skip
= (last_path
!= 0
7857 && (unsigned int) (p
- this_path
) == last_path_len
7858 && ! filename_ncmp (last_path
, this_path
, last_path_len
));
7860 last_path
= this_path
;
7861 last_path_len
= p
- this_path
;
7864 /* If this directory requires any default arguments, we can skip
7865 it. We will already have printed a directory identical to
7866 this one which does not require that default argument. */
7877 goto invalid_select
;
7884 while (*q
!= ' ' && *q
!= ';')
7887 goto invalid_select
;
7892 && default_arg (arg
, q
- arg
))
7907 for (p1
= last_path
; p1
< p
&& *p1
!= ':'; p1
++)
7918 goto invalid_select
;
7926 use_arg
= *p
!= '!';
7931 while (*p
!= ' ' && *p
!= ';')
7934 goto invalid_select
;
7946 /* If there are extra options, print them now. */
7947 if (multilib_extra
&& *multilib_extra
)
7949 int print_at
= TRUE
;
7952 for (q
= multilib_extra
; *q
!= '\0'; q
++)
7973 /* getenv built-in spec function.
7975 Returns the value of the environment variable given by its first
7976 argument, concatenated with the second argument. If the
7977 environment variable is not defined, a fatal error is issued. */
7980 getenv_spec_function (int argc
, const char **argv
)
7990 value
= getenv (argv
[0]);
7992 fatal_error ("environment variable %qs not defined", argv
[0]);
7994 /* We have to escape every character of the environment variable so
7995 they are not interpreted as active spec characters. A
7996 particularly painful case is when we are reading a variable
7997 holding a windows path complete with \ separators. */
7998 len
= strlen (value
) * 2 + strlen (argv
[1]) + 1;
7999 result
= XNEWVAR (char, len
);
8000 for (ptr
= result
; *value
; ptr
+= 2)
8006 strcpy (ptr
, argv
[1]);
8011 /* if-exists built-in spec function.
8013 Checks to see if the file specified by the absolute pathname in
8014 ARGS exists. Returns that pathname if found.
8016 The usual use for this function is to check for a library file
8017 (whose name has been expanded with %s). */
8020 if_exists_spec_function (int argc
, const char **argv
)
8022 /* Must have only one argument. */
8023 if (argc
== 1 && IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
8029 /* if-exists-else built-in spec function.
8031 This is like if-exists, but takes an additional argument which
8032 is returned if the first argument does not exist. */
8035 if_exists_else_spec_function (int argc
, const char **argv
)
8037 /* Must have exactly two arguments. */
8041 if (IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
8047 /* replace-outfile built-in spec function.
8049 This looks for the first argument in the outfiles array's name and
8050 replaces it with the second argument. */
8053 replace_outfile_spec_function (int argc
, const char **argv
)
8056 /* Must have exactly two arguments. */
8060 for (i
= 0; i
< n_infiles
; i
++)
8062 if (outfiles
[i
] && !filename_cmp (outfiles
[i
], argv
[0]))
8063 outfiles
[i
] = xstrdup (argv
[1]);
8068 /* remove-outfile built-in spec function.
8070 * This looks for the first argument in the outfiles array's name and
8074 remove_outfile_spec_function (int argc
, const char **argv
)
8077 /* Must have exactly one argument. */
8081 for (i
= 0; i
< n_infiles
; i
++)
8083 if (outfiles
[i
] && !filename_cmp (outfiles
[i
], argv
[0]))
8089 /* Given two version numbers, compares the two numbers.
8090 A version number must match the regular expression
8091 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
8094 compare_version_strings (const char *v1
, const char *v2
)
8099 if (regcomp (&r
, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
8100 REG_EXTENDED
| REG_NOSUB
) != 0)
8102 rresult
= regexec (&r
, v1
, 0, NULL
, 0);
8103 if (rresult
== REG_NOMATCH
)
8104 fatal_error ("invalid version number %qs", v1
);
8105 else if (rresult
!= 0)
8107 rresult
= regexec (&r
, v2
, 0, NULL
, 0);
8108 if (rresult
== REG_NOMATCH
)
8109 fatal_error ("invalid version number %qs", v2
);
8110 else if (rresult
!= 0)
8113 return strverscmp (v1
, v2
);
8117 /* version_compare built-in spec function.
8119 This takes an argument of the following form:
8121 <comparison-op> <arg1> [<arg2>] <switch> <result>
8123 and produces "result" if the comparison evaluates to true,
8124 and nothing if it doesn't.
8126 The supported <comparison-op> values are:
8128 >= true if switch is a later (or same) version than arg1
8130 < true if switch is an earlier version than arg1
8132 >< true if switch is arg1 or later, and earlier than arg2
8133 <> true if switch is earlier than arg1 or is arg2 or later
8135 If the switch is not present, the condition is false unless
8136 the first character of the <comparison-op> is '!'.
8139 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
8140 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
8143 version_compare_spec_function (int argc
, const char **argv
)
8147 const char *switch_value
= NULL
;
8152 fatal_error ("too few arguments to %%:version-compare");
8153 if (argv
[0][0] == '\0')
8155 if ((argv
[0][1] == '<' || argv
[0][1] == '>') && argv
[0][0] != '!')
8157 if (argc
!= nargs
+ 3)
8158 fatal_error ("too many arguments to %%:version-compare");
8160 switch_len
= strlen (argv
[nargs
+ 1]);
8161 for (i
= 0; i
< n_switches
; i
++)
8162 if (!strncmp (switches
[i
].part1
, argv
[nargs
+ 1], switch_len
)
8163 && check_live_switch (i
, switch_len
))
8164 switch_value
= switches
[i
].part1
+ switch_len
;
8166 if (switch_value
== NULL
)
8170 comp1
= compare_version_strings (switch_value
, argv
[1]);
8172 comp2
= compare_version_strings (switch_value
, argv
[2]);
8174 comp2
= -1; /* This value unused. */
8177 switch (argv
[0][0] << 8 | argv
[0][1])
8179 case '>' << 8 | '=':
8180 result
= comp1
>= 0;
8182 case '!' << 8 | '<':
8183 result
= comp1
>= 0 || switch_value
== NULL
;
8188 case '!' << 8 | '>':
8189 result
= comp1
< 0 || switch_value
== NULL
;
8191 case '>' << 8 | '<':
8192 result
= comp1
>= 0 && comp2
< 0;
8194 case '<' << 8 | '>':
8195 result
= comp1
< 0 || comp2
>= 0;
8199 fatal_error ("unknown operator %qs in %%:version-compare", argv
[0]);
8204 return argv
[nargs
+ 2];
8207 /* %:include builtin spec function. This differs from %include in that it
8208 can be nested inside a spec, and thus be conditionalized. It takes
8209 one argument, the filename, and looks for it in the startfile path.
8210 The result is always NULL, i.e. an empty expansion. */
8213 include_spec_function (int argc
, const char **argv
)
8220 file
= find_a_file (&startfile_prefixes
, argv
[0], R_OK
, true);
8221 read_specs (file
? file
: argv
[0], false, false);
8226 /* %:find-file spec function. This function replaces its argument by
8227 the file found through find_file, that is the -print-file-name gcc
8230 find_file_spec_function (int argc
, const char **argv
)
8237 file
= find_file (argv
[0]);
8242 /* %:find-plugindir spec function. This function replaces its argument
8243 by the -iplugindir=<dir> option. `dir' is found through find_file, that
8244 is the -print-file-name gcc program option. */
8246 find_plugindir_spec_function (int argc
, const char **argv ATTRIBUTE_UNUSED
)
8253 option
= concat ("-iplugindir=", find_file ("plugin"), NULL
);
8258 /* %:print-asm-header spec function. Print a banner to say that the
8259 following output is from the assembler. */
8262 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED
,
8263 const char **argv ATTRIBUTE_UNUSED
)
8265 printf (_("Assembler options\n=================\n\n"));
8266 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
8271 /* Get a random number for -frandom-seed */
8273 static unsigned HOST_WIDE_INT
8274 get_random_number (void)
8276 unsigned HOST_WIDE_INT ret
= 0;
8279 fd
= open ("/dev/urandom", O_RDONLY
);
8282 read (fd
, &ret
, sizeof (HOST_WIDE_INT
));
8288 /* Get some more or less random data. */
8289 #ifdef HAVE_GETTIMEOFDAY
8293 gettimeofday (&tv
, NULL
);
8294 ret
= tv
.tv_sec
* 1000 + tv
.tv_usec
/ 1000;
8298 time_t now
= time (NULL
);
8300 if (now
!= (time_t)-1)
8301 ret
= (unsigned) now
;
8305 return ret
^ getpid();
8308 /* %:compare-debug-dump-opt spec function. Save the last argument,
8309 expected to be the last -fdump-final-insns option, or generate a
8313 compare_debug_dump_opt_spec_function (int arg
,
8314 const char **argv ATTRIBUTE_UNUSED
)
8319 static char random_seed
[HOST_BITS_PER_WIDE_INT
/ 4 + 3];
8322 fatal_error ("too many arguments to %%:compare-debug-dump-opt");
8324 do_spec_2 ("%{fdump-final-insns=*:%*}");
8325 do_spec_1 (" ", 0, NULL
);
8327 if (argbuf
.length () > 0
8328 && strcmp (argv
[argbuf
.length () - 1], "."))
8333 name
= xstrdup (argv
[argbuf
.length () - 1]);
8338 const char *ext
= NULL
;
8340 if (argbuf
.length () > 0)
8342 do_spec_2 ("%{o*:%*}%{!o:%{!S:%b%O}%{S:%b.s}}");
8345 else if (!compare_debug
)
8348 do_spec_2 ("%g.gkd");
8350 do_spec_1 (" ", 0, NULL
);
8352 gcc_assert (argbuf
.length () > 0);
8354 name
= concat (argbuf
.last (), ext
, NULL
);
8356 ret
= concat ("-fdump-final-insns=", name
, NULL
);
8359 which
= compare_debug
< 0;
8360 debug_check_temp_file
[which
] = name
;
8364 unsigned HOST_WIDE_INT value
= get_random_number ();
8366 sprintf (random_seed
, HOST_WIDE_INT_PRINT_HEX
, value
);
8372 ret
= concat ("%{!frandom-seed=*:-frandom-seed=", random_seed
, "} ",
8383 static const char *debug_auxbase_opt
;
8385 /* %:compare-debug-self-opt spec function. Expands to the options
8386 that are to be passed in the second compilation of
8390 compare_debug_self_opt_spec_function (int arg
,
8391 const char **argv ATTRIBUTE_UNUSED
)
8394 fatal_error ("too many arguments to %%:compare-debug-self-opt");
8396 if (compare_debug
>= 0)
8399 do_spec_2 ("%{c|S:%{o*:%*}}");
8400 do_spec_1 (" ", 0, NULL
);
8402 if (argbuf
.length () > 0)
8403 debug_auxbase_opt
= concat ("-auxbase-strip ",
8407 debug_auxbase_opt
= NULL
;
8410 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
8411 %<fdump-final-insns=* -w -S -o %j \
8412 %{!fcompare-debug-second:-fcompare-debug-second} \
8413 ", compare_debug_opt
, NULL
);
8416 /* %:compare-debug-auxbase-opt spec function. Expands to the auxbase
8417 options that are to be passed in the second compilation of
8418 compare-debug. It expects, as an argument, the basename of the
8419 current input file name, with the .gk suffix appended to it. */
8422 compare_debug_auxbase_opt_spec_function (int arg
,
8429 fatal_error ("too few arguments to %%:compare-debug-auxbase-opt");
8432 fatal_error ("too many arguments to %%:compare-debug-auxbase-opt");
8434 if (compare_debug
>= 0)
8437 len
= strlen (argv
[0]);
8438 if (len
< 3 || strcmp (argv
[0] + len
- 3, ".gk") != 0)
8439 fatal_error ("argument to %%:compare-debug-auxbase-opt "
8440 "does not end in .gk");
8442 if (debug_auxbase_opt
)
8443 return debug_auxbase_opt
;
8445 #define OPT "-auxbase "
8448 name
= (char*) xmalloc (sizeof (OPT
) + len
);
8449 memcpy (name
, OPT
, sizeof (OPT
) - 1);
8450 memcpy (name
+ sizeof (OPT
) - 1, argv
[0], len
);
8451 name
[sizeof (OPT
) - 1 + len
] = '\0';
8458 /* %:pass-through-libs spec function. Finds all -l options and input
8459 file names in the lib spec passed to it, and makes a list of them
8460 prepended with the plugin option to cause them to be passed through
8461 to the final link after all the new object files have been added. */
8464 pass_through_libs_spec_func (int argc
, const char **argv
)
8466 char *prepended
= xstrdup (" ");
8468 /* Shlemiel the painter's algorithm. Innately horrible, but at least
8469 we know that there will never be more than a handful of strings to
8470 concat, and it's only once per run, so it's not worth optimising. */
8471 for (n
= 0; n
< argc
; n
++)
8473 char *old
= prepended
;
8474 /* Anything that isn't an option is a full path to an output
8475 file; pass it through if it ends in '.a'. Among options,
8477 if (argv
[n
][0] == '-' && argv
[n
][1] == 'l')
8479 const char *lopt
= argv
[n
] + 2;
8480 /* Handle both joined and non-joined -l options. If for any
8481 reason there's a trailing -l with no joined or following
8482 arg just discard it. */
8483 if (!*lopt
&& ++n
>= argc
)
8487 prepended
= concat (prepended
, "-plugin-opt=-pass-through=-l",
8490 else if (!strcmp (".a", argv
[n
] + strlen (argv
[n
]) - 2))
8492 prepended
= concat (prepended
, "-plugin-opt=-pass-through=",
8493 argv
[n
], " ", NULL
);
8495 if (prepended
!= old
)
8501 /* %:replace-extension spec function. Replaces the extension of the
8502 first argument with the second argument. */
8505 replace_extension_spec_func (int argc
, const char **argv
)
8513 fatal_error ("too few arguments to %%:replace-extension");
8515 name
= xstrdup (argv
[0]);
8517 for (i
= strlen(name
) - 1; i
>= 0; i
--)
8518 if (IS_DIR_SEPARATOR (name
[i
]))
8521 p
= strrchr (name
+ i
+ 1, '.');
8525 result
= concat (name
, argv
[1], NULL
);