1 /* Compiler driver program that can handle many languages.
2 Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
5 Free Software Foundation, Inc.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 /* This program is the user interface to the C compiler and possibly to
24 other compilers. It is used because compilation is a complicated procedure
25 which involves running several programs and passing temporary files between
26 them, forwarding the users switches to those programs selectively,
27 and deleting the temporary files at the end.
29 CC recognizes how to compile each input file by suffixes in the file names.
30 Once it knows which kind of compilation to perform, the procedure for
31 compilation is specified by a string called a "spec". */
35 #include "coretypes.h"
36 #include "multilib.h" /* before tm.h */
43 #include "diagnostic.h"
48 #include "filenames.h"
50 /* By default there is no special suffix for target executables. */
51 /* FIXME: when autoconf is fixed, remove the host check - dj */
52 #if defined(TARGET_EXECUTABLE_SUFFIX) && defined(HOST_EXECUTABLE_SUFFIX)
53 #define HAVE_TARGET_EXECUTABLE_SUFFIX
56 /* By default there is no special suffix for host executables. */
57 #ifdef HOST_EXECUTABLE_SUFFIX
58 #define HAVE_HOST_EXECUTABLE_SUFFIX
60 #define HOST_EXECUTABLE_SUFFIX ""
63 /* By default, the suffix for target object files is ".o". */
64 #ifdef TARGET_OBJECT_SUFFIX
65 #define HAVE_TARGET_OBJECT_SUFFIX
67 #define TARGET_OBJECT_SUFFIX ".o"
70 static const char dir_separator_str
[] = { DIR_SEPARATOR
, 0 };
72 /* Most every one is fine with LIBRARY_PATH. For some, it conflicts. */
73 #ifndef LIBRARY_PATH_ENV
74 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
77 /* If a stage of compilation returns an exit status >= 1,
78 compilation of that file ceases. */
80 #define MIN_FATAL_STATUS 1
82 /* Flag set by cppspec.c to 1. */
85 /* Flag set to nonzero if an @file argument has been supplied to gcc. */
86 static bool at_file_supplied
;
88 /* Definition of string containing the arguments given to configure. */
89 #include "configargs.h"
91 /* Flag saying to print the command line options understood by gcc and its
94 static int print_help_list
;
96 /* Flag saying to print the version of gcc and its sub-processes. */
98 static int print_version
;
100 /* Flag indicating whether we should ONLY print the command and
101 arguments (like verbose_flag) without executing the command.
102 Displayed arguments are quoted so that the generated command
103 line is suitable for execution. This is intended for use in
104 shell scripts to capture the driver-generated command line. */
105 static int verbose_only_flag
;
107 /* Flag indicating how to print command line options of sub-processes. */
109 static int print_subprocess_help
;
111 /* Whether we should report subprocess execution times to a file. */
113 FILE *report_times_to_file
= NULL
;
115 /* Nonzero means place this string before uses of /, so that include
116 and library files can be found in an alternate location. */
118 #ifdef TARGET_SYSTEM_ROOT
119 static const char *target_system_root
= TARGET_SYSTEM_ROOT
;
121 static const char *target_system_root
= 0;
124 /* Nonzero means pass the updated target_system_root to the compiler. */
126 static int target_system_root_changed
;
128 /* Nonzero means append this string to target_system_root. */
130 static const char *target_sysroot_suffix
= 0;
132 /* Nonzero means append this string to target_system_root for headers. */
134 static const char *target_sysroot_hdrs_suffix
= 0;
136 /* Nonzero means write "temp" files in source directory
137 and use the source file's name in them, and don't delete them. */
139 static enum save_temps
{
140 SAVE_TEMPS_NONE
, /* no -save-temps */
141 SAVE_TEMPS_CWD
, /* -save-temps in current directory */
142 SAVE_TEMPS_OBJ
/* -save-temps in object directory */
145 /* Output file to use to get the object directory for -save-temps=obj */
146 static char *save_temps_prefix
= 0;
147 static size_t save_temps_length
= 0;
149 /* The compiler version. */
151 static const char *compiler_version
;
153 /* The target version. */
155 static const char *const spec_version
= DEFAULT_TARGET_VERSION
;
157 /* The target machine. */
159 static const char *spec_machine
= DEFAULT_TARGET_MACHINE
;
161 /* Nonzero if cross-compiling.
162 When -b is used, the value comes from the `specs' file. */
164 #ifdef CROSS_DIRECTORY_STRUCTURE
165 static const char *cross_compile
= "1";
167 static const char *cross_compile
= "0";
170 /* Greatest exit code of sub-processes that has been encountered up to
172 static int greatest_status
= 1;
174 /* This is the obstack which we use to allocate many strings. */
176 static struct obstack obstack
;
178 /* This is the obstack to build an environment variable to pass to
179 collect2 that describes all of the relevant switches of what to
180 pass the compiler in building the list of pointers to constructors
183 static struct obstack collect_obstack
;
185 /* Forward declaration for prototypes. */
189 static void init_spec (void);
190 static void store_arg (const char *, int, int);
191 static void insert_wrapper (const char *);
192 static char *load_specs (const char *);
193 static void read_specs (const char *, int);
194 static void set_spec (const char *, const char *);
195 static struct compiler
*lookup_compiler (const char *, size_t, const char *);
196 static char *build_search_list (const struct path_prefix
*, const char *,
198 static void xputenv (const char *);
199 static void putenv_from_prefixes (const struct path_prefix
*, const char *,
201 static int access_check (const char *, int);
202 static char *find_a_file (const struct path_prefix
*, const char *, int, bool);
203 static void add_prefix (struct path_prefix
*, const char *, const char *,
205 static void add_sysrooted_prefix (struct path_prefix
*, const char *,
206 const char *, int, int, int);
207 static char *skip_whitespace (char *);
208 static void delete_if_ordinary (const char *);
209 static void delete_temp_files (void);
210 static void delete_failure_queue (void);
211 static void clear_failure_queue (void);
212 static int check_live_switch (int, int);
213 static const char *handle_braces (const char *);
214 static inline bool input_suffix_matches (const char *, const char *);
215 static inline bool switch_matches (const char *, const char *, int);
216 static inline void mark_matching_switches (const char *, const char *, int);
217 static inline void process_marked_switches (void);
218 static const char *process_brace_body (const char *, const char *, const char *, int, int);
219 static const struct spec_function
*lookup_spec_function (const char *);
220 static const char *eval_spec_function (const char *, const char *);
221 static const char *handle_spec_function (const char *);
222 static char *save_string (const char *, int);
223 static void set_collect_gcc_options (void);
224 static int do_spec_1 (const char *, int, const char *);
225 static int do_spec_2 (const char *);
226 static void do_option_spec (const char *, const char *);
227 static void do_self_spec (const char *);
228 static const char *find_file (const char *);
229 static int is_directory (const char *, bool);
230 static const char *validate_switches (const char *);
231 static void validate_all_switches (void);
232 static inline void validate_switches_from_spec (const char *);
233 static void give_switch (int, int);
234 static int used_arg (const char *, int);
235 static int default_arg (const char *, int);
236 static void set_multilib_dir (void);
237 static void print_multilib_info (void);
238 static void perror_with_name (const char *);
239 static void display_help (void);
240 static void add_preprocessor_option (const char *, int);
241 static void add_assembler_option (const char *, int);
242 static void add_linker_option (const char *, int);
243 static void process_command (unsigned int, struct cl_decoded_option
*);
244 static int execute (void);
245 static void alloc_args (void);
246 static void clear_args (void);
247 static void fatal_signal (int);
248 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
249 static void init_gcc_specs (struct obstack
*, const char *, const char *,
252 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
253 static const char *convert_filename (const char *, int, int);
256 static const char *getenv_spec_function (int, const char **);
257 static const char *if_exists_spec_function (int, const char **);
258 static const char *if_exists_else_spec_function (int, const char **);
259 static const char *replace_outfile_spec_function (int, const char **);
260 static const char *remove_outfile_spec_function (int, const char **);
261 static const char *version_compare_spec_function (int, const char **);
262 static const char *include_spec_function (int, const char **);
263 static const char *find_file_spec_function (int, const char **);
264 static const char *find_plugindir_spec_function (int, const char **);
265 static const char *print_asm_header_spec_function (int, const char **);
266 static const char *compare_debug_dump_opt_spec_function (int, const char **);
267 static const char *compare_debug_self_opt_spec_function (int, const char **);
268 static const char *compare_debug_auxbase_opt_spec_function (int, const char **);
269 static const char *pass_through_libs_spec_func (int, const char **);
270 static char *convert_white_space (char *);
272 /* The Specs Language
274 Specs are strings containing lines, each of which (if not blank)
275 is made up of a program name, and arguments separated by spaces.
276 The program name must be exact and start from root, since no path
277 is searched and it is unreliable to depend on the current working directory.
278 Redirection of input or output is not supported; the subprograms must
279 accept filenames saying what files to read and write.
281 In addition, the specs can contain %-sequences to substitute variable text
282 or for conditional text. Here is a table of all defined %-sequences.
283 Note that spaces are not generated automatically around the results of
284 expanding these sequences; therefore, you can concatenate them together
285 or with constant text in a single argument.
287 %% substitute one % into the program name or argument.
288 %i substitute the name of the input file being processed.
289 %b substitute the basename of the input file being processed.
290 This is the substring up to (and not including) the last period
291 and not including the directory unless -save-temps was specified
292 to put temporaries in a different location.
293 %B same as %b, but include the file suffix (text after the last period).
295 substitute a file name that has suffix SUFFIX and is chosen
296 once per compilation, and mark the argument a la %d. To reduce
297 exposure to denial-of-service attacks, the file name is now
298 chosen in a way that is hard to predict even when previously
299 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
300 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
301 the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
302 had been pre-processed. Previously, %g was simply substituted
303 with a file name chosen once per compilation, without regard
304 to any appended suffix (which was therefore treated just like
305 ordinary text), making such attacks more likely to succeed.
307 like %g, but if -pipe is in effect, expands simply to "-".
309 like %g, but if -pipe is in effect, expands to nothing. (We have both
310 %| and %m to accommodate differences between system assemblers; see
311 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
313 like %g, but generates a new temporary file name even if %uSUFFIX
316 substitutes the last file name generated with %uSUFFIX, generating a
317 new one if there is no such last file name. In the absence of any
318 %uSUFFIX, this is just like %gSUFFIX, except they don't share
319 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
320 would involve the generation of two distinct file names, one
321 for each `%g.s' and another for each `%U.s'. Previously, %U was
322 simply substituted with a file name chosen for the previous %u,
323 without regard to any appended suffix.
325 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
326 writable, and if save-temps is off; otherwise, substitute the name
327 of a temporary file, just like %u. This temporary file is not
328 meant for communication between processes, but rather as a junk
331 substitutes .SUFFIX for the suffixes of a matched switch's args when
332 it is subsequently output with %*. SUFFIX is terminated by the next
334 %d marks the argument containing or following the %d as a
335 temporary file name, so that that file will be deleted if GCC exits
336 successfully. Unlike %g, this contributes no text to the argument.
337 %w marks the argument containing or following the %w as the
338 "output file" of this compilation. This puts the argument
339 into the sequence of arguments that %o will substitute later.
340 %V indicates that this compilation produces no "output file".
342 like %{...} but mark last argument supplied within
343 as a file to be deleted on failure.
344 %o substitutes the names of all the output files, with spaces
345 automatically placed around them. You should write spaces
346 around the %o as well or the results are undefined.
347 %o is for use in the specs for running the linker.
348 Input files whose names have no recognized suffix are not compiled
349 at all, but they are included among the output files, so they will
351 %O substitutes the suffix for object files. Note that this is
352 handled specially when it immediately follows %g, %u, or %U
353 (with or without a suffix argument) because of the need for
354 those to form complete file names. The handling is such that
355 %O is treated exactly as if it had already been substituted,
356 except that %g, %u, and %U do not currently support additional
357 SUFFIX characters following %O as they would following, for
359 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
360 (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
361 and -B options) and -imultilib as necessary.
362 %s current argument is the name of a library or startup file of some sort.
363 Search for that file in a standard list of directories
364 and substitute the full name found.
365 %eSTR Print STR as an error message. STR is terminated by a newline.
366 Use this when inconsistent options are detected.
367 %nSTR Print STR as a notice. STR is terminated by a newline.
368 %x{OPTION} Accumulate an option for %X.
369 %X Output the accumulated linker options specified by compilations.
370 %Y Output the accumulated assembler options specified by compilations.
371 %Z Output the accumulated preprocessor options specified by compilations.
372 %a process ASM_SPEC as a spec.
373 This allows config.h to specify part of the spec for running as.
374 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
375 used here. This can be used to run a post-processor after the
376 assembler has done its job.
377 %D Dump out a -L option for each directory in startfile_prefixes.
378 If multilib_dir is set, extra entries are generated with it affixed.
379 %l process LINK_SPEC as a spec.
380 %L process LIB_SPEC as a spec.
381 %G process LIBGCC_SPEC as a spec.
382 %R Output the concatenation of target_system_root and
383 target_sysroot_suffix.
384 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
385 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
386 %C process CPP_SPEC as a spec.
387 %1 process CC1_SPEC as a spec.
388 %2 process CC1PLUS_SPEC as a spec.
389 %* substitute the variable part of a matched option. (See below.)
390 Note that each comma in the substituted string is replaced by
392 %<S remove all occurrences of -S from the command line.
393 Note - this command is position dependent. % commands in the
394 spec string before this one will see -S, % commands in the
395 spec string after this one will not.
396 %>S Similar to "%<S", but keep it in the GCC command line.
397 %<S* remove all occurrences of all switches beginning with -S from the
400 Call the named function FUNCTION, passing it ARGS. ARGS is
401 first processed as a nested spec string, then split into an
402 argument vector in the usual fashion. The function returns
403 a string which is processed as if it had appeared literally
404 as part of the current spec.
405 %{S} substitutes the -S switch, if that switch was given to GCC.
406 If that switch was not specified, this substitutes nothing.
407 Here S is a metasyntactic variable.
408 %{S*} substitutes all the switches specified to GCC whose names start
409 with -S. This is used for -o, -I, etc; switches that take
410 arguments. GCC considers `-o foo' as being one switch whose
411 name starts with `o'. %{o*} would substitute this text,
412 including the space; thus, two arguments would be generated.
413 %{S*&T*} likewise, but preserve order of S and T options (the order
414 of S and T in the spec is not significant). Can be any number
415 of ampersand-separated variables; for each the wild card is
416 optional. Useful for CPP as %{D*&U*&A*}.
418 %{S:X} substitutes X, if the -S switch was given to GCC.
419 %{!S:X} substitutes X, if the -S switch was NOT given to GCC.
420 %{S*:X} substitutes X if one or more switches whose names start
421 with -S was given to GCC. Normally X is substituted only
422 once, no matter how many such switches appeared. However,
423 if %* appears somewhere in X, then X will be substituted
424 once for each matching switch, with the %* replaced by the
425 part of that switch that matched the '*'.
426 %{.S:X} substitutes X, if processing a file with suffix S.
427 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
428 %{,S:X} substitutes X, if processing a file which will use spec S.
429 %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
431 %{S|T:X} substitutes X if either -S or -T was given to GCC. This may be
432 combined with '!', '.', ',', and '*' as above binding stronger
434 If %* appears in X, all of the alternatives must be starred, and
435 only the first matching alternative is substituted.
436 %{S:X; if S was given to GCC, substitutes X;
437 T:Y; else if T was given to GCC, substitutes Y;
438 :D} else substitutes D. There can be as many clauses as you need.
439 This may be combined with '.', '!', ',', '|', and '*' as above.
441 %(Spec) processes a specification defined in a specs file as *Spec:
443 The conditional text X in a %{S:X} or similar construct may contain
444 other nested % constructs or spaces, or even newlines. They are
445 processed as usual, as described above. Trailing white space in X is
446 ignored. White space may also appear anywhere on the left side of the
447 colon in these constructs, except between . or * and the corresponding
450 The -O, -f, -m, and -W switches are handled specifically in these
451 constructs. If another value of -O or the negated form of a -f, -m, or
452 -W switch is found later in the command line, the earlier switch
453 value is ignored, except with {S*} where S is just one letter; this
454 passes all matching options.
456 The character | at the beginning of the predicate text is used to indicate
457 that a command should be piped to the following command, but only if -pipe
460 Note that it is built into GCC which switches take arguments and which
461 do not. You might think it would be useful to generalize this to
462 allow each compiler's spec to say which switches take arguments. But
463 this cannot be done in a consistent fashion. GCC cannot even decide
464 which input files have been specified without knowing which switches
465 take arguments, and it must know which input files to compile in order
466 to tell which compilers to run.
468 GCC also knows implicitly that arguments starting in `-l' are to be
469 treated as compiler output files, and passed to the linker in their
470 proper position among the other output files. */
472 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
474 /* config.h can define ASM_SPEC to provide extra args to the assembler
475 or extra switch-translations. */
480 /* config.h can define ASM_FINAL_SPEC to run a post processor after
481 the assembler has run. */
482 #ifndef ASM_FINAL_SPEC
483 #define ASM_FINAL_SPEC ""
486 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
487 or extra switch-translations. */
492 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
493 or extra switch-translations. */
498 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
499 or extra switch-translations. */
501 #define CC1PLUS_SPEC ""
504 /* config.h can define LINK_SPEC to provide extra args to the linker
505 or extra switch-translations. */
510 /* config.h can define LIB_SPEC to override the default libraries. */
512 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
517 /* XXX: valid only for GNU ld */
518 /* XXX: should exactly match hooks provided by libmudflap.a */
519 #define MFWRAP_SPEC " %{static: %{fmudflap|fmudflapth: \
520 --wrap=malloc --wrap=free --wrap=calloc --wrap=realloc\
521 --wrap=mmap --wrap=mmap64 --wrap=munmap --wrap=alloca\
522 } %{fmudflapth: --wrap=pthread_create\
523 }} %{fmudflap|fmudflapth: --wrap=main}"
526 #define MFLIB_SPEC "%{fmudflap|fmudflapth: -export-dynamic}"
529 /* When using -fsplit-stack we need to wrap pthread_create, in order
530 to initialize the stack guard. We always use wrapping, rather than
531 shared library ordering, and we keep the wrapper function in
532 libgcc. This is not yet a real spec, though it could become one;
533 it is currently just stuffed into LINK_SPEC. FIXME: This wrapping
534 only works with GNU ld and gold. FIXME: This is incompatible with
535 -fmudflap when linking statically, which wants to do its own
537 #define STACK_SPLIT_SPEC " %{fsplit-stack: --wrap=pthread_create}"
539 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
542 #if defined(REAL_LIBGCC_SPEC)
543 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
544 #elif defined(LINK_LIBGCC_SPECIAL_1)
545 /* Have gcc do the search for libgcc.a. */
546 #define LIBGCC_SPEC "libgcc.a%s"
548 #define LIBGCC_SPEC "-lgcc"
552 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
553 #ifndef STARTFILE_SPEC
554 #define STARTFILE_SPEC \
555 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
558 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
560 #define ENDFILE_SPEC ""
564 #define LINKER_NAME "collect2"
567 #ifdef HAVE_AS_DEBUG_PREFIX_MAP
568 #define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
573 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
575 #ifndef ASM_DEBUG_SPEC
576 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
577 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
578 # define ASM_DEBUG_SPEC \
579 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
580 ? "%{!g0:%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}}" ASM_MAP \
581 : "%{!g0:%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}}" ASM_MAP)
583 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
584 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gstabs}}" ASM_MAP
586 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
587 # define ASM_DEBUG_SPEC "%{g*:%{!g0:--gdwarf2}}" ASM_MAP
591 #ifndef ASM_DEBUG_SPEC
592 # define ASM_DEBUG_SPEC ""
595 /* Here is the spec for running the linker, after compiling all files. */
597 /* This is overridable by the target in case they need to specify the
598 -lgcc and -lc order specially, yet not require them to override all
599 of LINK_COMMAND_SPEC. */
600 #ifndef LINK_GCC_C_SEQUENCE_SPEC
601 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
604 #ifndef LINK_SSP_SPEC
605 #ifdef TARGET_LIBC_PROVIDES_SSP
606 #define LINK_SSP_SPEC "%{fstack-protector:}"
608 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all:-lssp_nonshared -lssp}"
612 #ifndef LINK_PIE_SPEC
614 #define LINK_PIE_SPEC "%{pie:-pie} "
616 #define LINK_PIE_SPEC "%{pie:} "
620 #ifndef LINK_BUILDID_SPEC
621 # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
622 # define LINK_BUILDID_SPEC "%{!r:--build-id} "
626 /* Conditional to test whether the LTO plugin is used or not.
627 FIXME: For slim LTO we will need to enable plugin unconditionally. This
628 still cause problems with PLUGIN_LD != LD and when plugin is built but
629 not useable. For GCC 4.6 we don't support slim LTO and thus we can enable
630 plugin only when LTO is enabled. We still honor explicit
631 -fuse-linker-plugin if the linker used understands -plugin. */
633 /* The linker has some plugin support. */
634 #if HAVE_LTO_PLUGIN > 0
635 /* The linker used has full plugin support, use LTO plugin by default. */
636 #if HAVE_LTO_PLUGIN == 2
637 #define PLUGIN_COND "!fno-use-linker-plugin:%{flto|flto=*|fuse-linker-plugin"
638 #define PLUGIN_COND_CLOSE "}"
640 /* The linker used has limited plugin support, use LTO plugin with explicit
641 -fuse-linker-plugin. */
642 #define PLUGIN_COND "fuse-linker-plugin"
643 #define PLUGIN_COND_CLOSE ""
645 #define LINK_PLUGIN_SPEC \
647 -plugin %(linker_plugin_file) \
648 -plugin-opt=%(lto_wrapper) \
649 -plugin-opt=-fresolution=%u.res \
650 %{!nostdlib:%{!nodefaultlibs:%:pass-through-libs(%(link_gcc_c_sequence))}} \
653 /* The linker used doesn't support -plugin, reject -fuse-linker-plugin. */
654 #define LINK_PLUGIN_SPEC "%{fuse-linker-plugin:\
655 %e-fuse-linker-plugin is not supported in this configuration}"
659 /* -u* was put back because both BSD and SysV seem to support it. */
660 /* %{static:} simply prevents an error message if the target machine
661 doesn't handle -static. */
662 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
663 scripts which exist in user specified directories, or in standard
665 /* We pass any -flto flags on to the linker, which is expected
666 to understand them. In practice, this means it had better be collect2. */
667 /* %{e*} includes -export-dynamic; see comment in common.opt. */
668 #ifndef LINK_COMMAND_SPEC
669 #define LINK_COMMAND_SPEC "\
670 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
673 "%{flto|flto=*:%<fcompare-debug*} \
674 %{flto} %{flto=*} %l " LINK_PIE_SPEC \
675 "%X %{o*} %{e*} %{N} %{n} %{r}\
676 %{s} %{t} %{u*} %{z} %{Z} %{!nostdlib:%{!nostartfiles:%S}}\
677 %{static:} %{L*} %(mfwrap) %(link_libgcc) %o\
678 %{fopenmp|ftree-parallelize-loops=*:%:include(libgomp.spec)%(link_gomp)}\
679 %{fgnu-tm:%:include(libitm.spec)%(link_itm)}\
680 %(mflib) " STACK_SPLIT_SPEC "\
681 %{fprofile-arcs|fprofile-generate*|coverage:-lgcov}\
682 %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\
683 %{!nostdlib:%{!nostartfiles:%E}} %{T*} }}}}}}"
686 #ifndef LINK_LIBGCC_SPEC
687 /* Generate -L options for startfile prefix list. */
688 # define LINK_LIBGCC_SPEC "%D"
691 #ifndef STARTFILE_PREFIX_SPEC
692 # define STARTFILE_PREFIX_SPEC ""
696 # define SYSROOT_SPEC "--sysroot=%R"
699 #ifndef SYSROOT_SUFFIX_SPEC
700 # define SYSROOT_SUFFIX_SPEC ""
703 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
704 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
707 static const char *asm_debug
;
708 static const char *cpp_spec
= CPP_SPEC
;
709 static const char *cc1_spec
= CC1_SPEC
;
710 static const char *cc1plus_spec
= CC1PLUS_SPEC
;
711 static const char *link_gcc_c_sequence_spec
= LINK_GCC_C_SEQUENCE_SPEC
;
712 static const char *link_ssp_spec
= LINK_SSP_SPEC
;
713 static const char *asm_spec
= ASM_SPEC
;
714 static const char *asm_final_spec
= ASM_FINAL_SPEC
;
715 static const char *link_spec
= LINK_SPEC
;
716 static const char *lib_spec
= LIB_SPEC
;
717 static const char *mfwrap_spec
= MFWRAP_SPEC
;
718 static const char *mflib_spec
= MFLIB_SPEC
;
719 static const char *link_gomp_spec
= "";
720 static const char *libgcc_spec
= LIBGCC_SPEC
;
721 static const char *endfile_spec
= ENDFILE_SPEC
;
722 static const char *startfile_spec
= STARTFILE_SPEC
;
723 static const char *linker_name_spec
= LINKER_NAME
;
724 static const char *linker_plugin_file_spec
= "";
725 static const char *lto_wrapper_spec
= "";
726 static const char *lto_gcc_spec
= "";
727 static const char *link_command_spec
= LINK_COMMAND_SPEC
;
728 static const char *link_libgcc_spec
= LINK_LIBGCC_SPEC
;
729 static const char *startfile_prefix_spec
= STARTFILE_PREFIX_SPEC
;
730 static const char *sysroot_spec
= SYSROOT_SPEC
;
731 static const char *sysroot_suffix_spec
= SYSROOT_SUFFIX_SPEC
;
732 static const char *sysroot_hdrs_suffix_spec
= SYSROOT_HEADERS_SUFFIX_SPEC
;
733 static const char *self_spec
= "";
735 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
736 There should be no need to override these in target dependent files,
737 but we need to copy them to the specs file so that newer versions
738 of the GCC driver can correctly drive older tool chains with the
739 appropriate -B options. */
741 /* When cpplib handles traditional preprocessing, get rid of this, and
742 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
743 that we default the front end language better. */
744 static const char *trad_capable_cpp
=
745 "cc1 -E %{traditional|traditional-cpp:-traditional-cpp}";
747 /* We don't wrap .d files in %W{} since a missing .d file, and
748 therefore no dependency entry, confuses make into thinking a .o
749 file that happens to exist is up-to-date. */
750 static const char *cpp_unique_options
=
751 "%{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\
752 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
753 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
754 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
755 %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
756 %{remap} %{g3|ggdb3|gstabs3|gcoff3|gxcoff3|gvms3:-dD}\
757 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
758 %{H} %C %{D*&U*&A*} %{i*} %Z %i\
759 %{fmudflap:-D_MUDFLAP -include mf-runtime.h}\
760 %{fmudflapth:-D_MUDFLAP -D_MUDFLAPTH -include mf-runtime.h}\
763 /* This contains cpp options which are common with cc1_options and are passed
764 only when preprocessing only to avoid duplication. We pass the cc1 spec
765 options to the preprocessor so that it the cc1 spec may manipulate
766 options used to set target flags. Those special target flags settings may
767 in turn cause preprocessor symbols to be defined specially. */
768 static const char *cpp_options
=
769 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
770 %{f*} %{g*:%{!g0:%{g*} %{!fno-working-directory:-fworking-directory}}} %{O*}\
771 %{undef} %{save-temps*:-fpch-preprocess}";
773 /* This contains cpp options which are not passed when the preprocessor
774 output will be used by another program. */
775 static const char *cpp_debug_options
= "%{d*}";
777 /* NB: This is shared amongst all front-ends, except for Ada. */
778 static const char *cc1_options
=
779 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
780 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
781 %1 %{!Q:-quiet} %{!dumpbase:-dumpbase %B} %{d*} %{m*} %{aux-info*}\
782 %{fcompare-debug-second:%:compare-debug-auxbase-opt(%b)} \
783 %{!fcompare-debug-second:%{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}}%{!c:%{!S:-auxbase %b}} \
784 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
785 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
786 %{Qn:-fno-ident} %{Qy:} %{-help:--help}\
787 %{-target-help:--target-help}\
788 %{-version:--version}\
789 %{-help=*:--help=%*}\
790 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
791 %{fsyntax-only:-o %j} %{-param*}\
792 %{fmudflap|fmudflapth:-fno-builtin -fno-merge-constants}\
793 %{coverage:-fprofile-arcs -ftest-coverage}";
795 static const char *asm_options
=
796 "%{-target-help:%:print-asm-header()} "
798 /* If GNU AS is used, then convert -w (no warnings), -I, and -v
799 to the assembler equivalents. */
800 "%{v} %{w:-W} %{I*} "
802 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
804 static const char *invoke_as
=
805 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
807 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
808 %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
812 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
813 %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
817 /* Some compilers have limits on line lengths, and the multilib_select
818 and/or multilib_matches strings can be very long, so we build them at
820 static struct obstack multilib_obstack
;
821 static const char *multilib_select
;
822 static const char *multilib_matches
;
823 static const char *multilib_defaults
;
824 static const char *multilib_exclusions
;
826 /* Check whether a particular argument is a default argument. */
828 #ifndef MULTILIB_DEFAULTS
829 #define MULTILIB_DEFAULTS { "" }
832 static const char *const multilib_defaults_raw
[] = MULTILIB_DEFAULTS
;
834 #ifndef DRIVER_SELF_SPECS
835 #define DRIVER_SELF_SPECS ""
838 /* Adding -fopenmp should imply pthreads. This is particularly important
839 for targets that use different start files and suchlike. */
840 #ifndef GOMP_SELF_SPECS
841 #define GOMP_SELF_SPECS "%{fopenmp|ftree-parallelize-loops=*: -pthread}"
844 /* Likewise for -fgnu-tm. */
845 #ifndef GTM_SELF_SPECS
846 #define GTM_SELF_SPECS "%{fgnu-tm: -pthread}"
849 static const char *const driver_self_specs
[] = {
850 "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
851 DRIVER_SELF_SPECS
, CONFIGURE_SPECS
, GOMP_SELF_SPECS
, GTM_SELF_SPECS
854 #ifndef OPTION_DEFAULT_SPECS
855 #define OPTION_DEFAULT_SPECS { "", "" }
864 static const struct default_spec
865 option_default_specs
[] = { OPTION_DEFAULT_SPECS
};
869 struct user_specs
*next
;
870 const char *filename
;
873 static struct user_specs
*user_specs_head
, *user_specs_tail
;
876 /* Record the mapping from file suffixes for compilation specs. */
880 const char *suffix
; /* Use this compiler for input files
881 whose names end in this suffix. */
883 const char *spec
; /* To use this compiler, run this spec. */
885 const char *cpp_spec
; /* If non-NULL, substitute this spec
886 for `%C', rather than the usual
888 const int combinable
; /* If nonzero, compiler can deal with
889 multiple source files at once (IMA). */
890 const int needs_preprocessing
; /* If nonzero, source files need to
891 be run through a preprocessor. */
894 /* Pointer to a vector of `struct compiler' that gives the spec for
895 compiling a file, based on its suffix.
896 A file that does not end in any of these suffixes will be passed
897 unchanged to the loader and nothing else will be done to it.
899 An entry containing two 0s is used to terminate the vector.
901 If multiple entries match a file, the last matching one is used. */
903 static struct compiler
*compilers
;
905 /* Number of entries in `compilers', not counting the null terminator. */
907 static int n_compilers
;
909 /* The default list of file name suffixes and their compilation specs. */
911 static const struct compiler default_compilers
[] =
913 /* Add lists of suffixes of known languages here. If those languages
914 were not present when we built the driver, we will hit these copies
915 and be given a more meaningful error than "file not used since
916 linking is not done". */
917 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0},
918 {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
919 {".mii", "#Objective-C++", 0, 0, 0},
920 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
921 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
922 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
923 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
924 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
925 {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
926 {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
927 {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
928 {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
929 {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
930 {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
931 {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
932 {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
933 {".r", "#Ratfor", 0, 0, 0},
934 {".p", "#Pascal", 0, 0, 0}, {".pas", "#Pascal", 0, 0, 0},
935 {".java", "#Java", 0, 0, 0}, {".class", "#Java", 0, 0, 0},
936 {".zip", "#Java", 0, 0, 0}, {".jar", "#Java", 0, 0, 0},
937 {".go", "#Go", 0, 1, 0},
938 /* Next come the entries for C. */
939 {".c", "@c", 0, 0, 1},
941 /* cc1 has an integrated ISO C preprocessor. We should invoke the
942 external preprocessor if -save-temps is given. */
943 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
946 %eGNU C no longer supports -traditional without -E}\
947 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
948 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
949 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
951 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
952 cc1 %(cpp_unique_options) %(cc1_options)}}}\
953 %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 1},
955 "%{!E:%e-E or -x required when input is from standard input}\
956 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
957 {".h", "@c-header", 0, 0, 0},
959 /* cc1 has an integrated ISO C preprocessor. We should invoke the
960 external preprocessor if -save-temps is given. */
961 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
963 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
964 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
965 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
967 %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
968 %W{o*:--output-pch=%*}}%V}\
969 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
970 cc1 %(cpp_unique_options) %(cc1_options)\
971 %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
972 %W{o*:--output-pch=%*}}%V}}}}}}", 0, 0, 0},
973 {".i", "@cpp-output", 0, 0, 0},
975 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 0},
976 {".s", "@assembler", 0, 0, 0},
978 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 0, 0},
979 {".sx", "@assembler-with-cpp", 0, 0, 0},
980 {".S", "@assembler-with-cpp", 0, 0, 0},
981 {"@assembler-with-cpp",
982 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
983 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
984 %{E|M|MM:%(cpp_debug_options)}\
985 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
986 as %(asm_debug) %(asm_options) %|.s %A }}}}"
988 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
989 %{E|M|MM:%(cpp_debug_options)}\
990 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
991 as %(asm_debug) %(asm_options) %m.s %A }}}}"
996 /* Mark end of table. */
1000 /* Number of elements in default_compilers, not counting the terminator. */
1002 static const int n_default_compilers
= ARRAY_SIZE (default_compilers
) - 1;
1004 typedef char *char_p
; /* For DEF_VEC_P. */
1006 DEF_VEC_ALLOC_P(char_p
,heap
);
1008 /* A vector of options to give to the linker.
1009 These options are accumulated by %x,
1010 and substituted into the linker command with %X. */
1011 static VEC(char_p
,heap
) *linker_options
;
1013 /* A vector of options to give to the assembler.
1014 These options are accumulated by -Wa,
1015 and substituted into the assembler command with %Y. */
1016 static VEC(char_p
,heap
) *assembler_options
;
1018 /* A vector of options to give to the preprocessor.
1019 These options are accumulated by -Wp,
1020 and substituted into the preprocessor command with %Z. */
1021 static VEC(char_p
,heap
) *preprocessor_options
;
1024 skip_whitespace (char *p
)
1028 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1029 be considered whitespace. */
1030 if (p
[0] == '\n' && p
[1] == '\n' && p
[2] == '\n')
1032 else if (*p
== '\n' || *p
== ' ' || *p
== '\t')
1046 /* Structures to keep track of prefixes to try when looking for files. */
1050 const char *prefix
; /* String to prepend to the path. */
1051 struct prefix_list
*next
; /* Next in linked list. */
1052 int require_machine_suffix
; /* Don't use without machine_suffix. */
1053 /* 2 means try both machine_suffix and just_machine_suffix. */
1054 int priority
; /* Sort key - priority within list. */
1055 int os_multilib
; /* 1 if OS multilib scheme should be used,
1056 0 for GCC multilib scheme. */
1061 struct prefix_list
*plist
; /* List of prefixes to try */
1062 int max_len
; /* Max length of a prefix in PLIST */
1063 const char *name
; /* Name of this list (used in config stuff) */
1066 /* List of prefixes to try when looking for executables. */
1068 static struct path_prefix exec_prefixes
= { 0, 0, "exec" };
1070 /* List of prefixes to try when looking for startup (crt0) files. */
1072 static struct path_prefix startfile_prefixes
= { 0, 0, "startfile" };
1074 /* List of prefixes to try when looking for include files. */
1076 static struct path_prefix include_prefixes
= { 0, 0, "include" };
1078 /* Suffix to attach to directories searched for commands.
1079 This looks like `MACHINE/VERSION/'. */
1081 static const char *machine_suffix
= 0;
1083 /* Suffix to attach to directories searched for commands.
1084 This is just `MACHINE/'. */
1086 static const char *just_machine_suffix
= 0;
1088 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1090 static const char *gcc_exec_prefix
;
1092 /* Adjusted value of standard_libexec_prefix. */
1094 static const char *gcc_libexec_prefix
;
1096 /* Default prefixes to attach to command names. */
1098 #ifndef STANDARD_STARTFILE_PREFIX_1
1099 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1101 #ifndef STANDARD_STARTFILE_PREFIX_2
1102 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1105 #ifdef CROSS_DIRECTORY_STRUCTURE /* Don't use these prefixes for a cross compiler. */
1106 #undef MD_EXEC_PREFIX
1107 #undef MD_STARTFILE_PREFIX
1108 #undef MD_STARTFILE_PREFIX_1
1111 /* If no prefixes defined, use the null string, which will disable them. */
1112 #ifndef MD_EXEC_PREFIX
1113 #define MD_EXEC_PREFIX ""
1115 #ifndef MD_STARTFILE_PREFIX
1116 #define MD_STARTFILE_PREFIX ""
1118 #ifndef MD_STARTFILE_PREFIX_1
1119 #define MD_STARTFILE_PREFIX_1 ""
1122 /* These directories are locations set at configure-time based on the
1123 --prefix option provided to configure. Their initializers are
1124 defined in Makefile.in. These paths are not *directly* used when
1125 gcc_exec_prefix is set because, in that case, we know where the
1126 compiler has been installed, and use paths relative to that
1127 location instead. */
1128 static const char *const standard_exec_prefix
= STANDARD_EXEC_PREFIX
;
1129 static const char *const standard_libexec_prefix
= STANDARD_LIBEXEC_PREFIX
;
1130 static const char *const standard_bindir_prefix
= STANDARD_BINDIR_PREFIX
;
1131 static const char *const standard_startfile_prefix
= STANDARD_STARTFILE_PREFIX
;
1133 /* For native compilers, these are well-known paths containing
1134 components that may be provided by the system. For cross
1135 compilers, these paths are not used. */
1136 static const char *md_exec_prefix
= MD_EXEC_PREFIX
;
1137 static const char *md_startfile_prefix
= MD_STARTFILE_PREFIX
;
1138 static const char *md_startfile_prefix_1
= MD_STARTFILE_PREFIX_1
;
1139 static const char *const standard_startfile_prefix_1
1140 = STANDARD_STARTFILE_PREFIX_1
;
1141 static const char *const standard_startfile_prefix_2
1142 = STANDARD_STARTFILE_PREFIX_2
;
1144 /* A relative path to be used in finding the location of tools
1145 relative to the driver. */
1146 static const char *const tooldir_base_prefix
= TOOLDIR_BASE_PREFIX
;
1148 /* Subdirectory to use for locating libraries. Set by
1149 set_multilib_dir based on the compilation options. */
1151 static const char *multilib_dir
;
1153 /* Subdirectory to use for locating libraries in OS conventions. Set by
1154 set_multilib_dir based on the compilation options. */
1156 static const char *multilib_os_dir
;
1158 /* Subdirectory to use for locating libraries in multiarch conventions. Set by
1159 set_multilib_dir based on the compilation options. */
1161 static const char *multiarch_dir
;
1163 /* Structure to keep track of the specs that have been defined so far.
1164 These are accessed using %(specname) in a compiler or link
1169 /* The following 2 fields must be first */
1170 /* to allow EXTRA_SPECS to be initialized */
1171 const char *name
; /* name of the spec. */
1172 const char *ptr
; /* available ptr if no static pointer */
1174 /* The following fields are not initialized */
1175 /* by EXTRA_SPECS */
1176 const char **ptr_spec
; /* pointer to the spec itself. */
1177 struct spec_list
*next
; /* Next spec in linked list. */
1178 int name_len
; /* length of the name */
1179 int alloc_p
; /* whether string was allocated */
1182 #define INIT_STATIC_SPEC(NAME,PTR) \
1183 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 }
1185 /* List of statically defined specs. */
1186 static struct spec_list static_specs
[] =
1188 INIT_STATIC_SPEC ("asm", &asm_spec
),
1189 INIT_STATIC_SPEC ("asm_debug", &asm_debug
),
1190 INIT_STATIC_SPEC ("asm_final", &asm_final_spec
),
1191 INIT_STATIC_SPEC ("asm_options", &asm_options
),
1192 INIT_STATIC_SPEC ("invoke_as", &invoke_as
),
1193 INIT_STATIC_SPEC ("cpp", &cpp_spec
),
1194 INIT_STATIC_SPEC ("cpp_options", &cpp_options
),
1195 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options
),
1196 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options
),
1197 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp
),
1198 INIT_STATIC_SPEC ("cc1", &cc1_spec
),
1199 INIT_STATIC_SPEC ("cc1_options", &cc1_options
),
1200 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec
),
1201 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec
),
1202 INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec
),
1203 INIT_STATIC_SPEC ("endfile", &endfile_spec
),
1204 INIT_STATIC_SPEC ("link", &link_spec
),
1205 INIT_STATIC_SPEC ("lib", &lib_spec
),
1206 INIT_STATIC_SPEC ("mfwrap", &mfwrap_spec
),
1207 INIT_STATIC_SPEC ("mflib", &mflib_spec
),
1208 INIT_STATIC_SPEC ("link_gomp", &link_gomp_spec
),
1209 INIT_STATIC_SPEC ("libgcc", &libgcc_spec
),
1210 INIT_STATIC_SPEC ("startfile", &startfile_spec
),
1211 INIT_STATIC_SPEC ("cross_compile", &cross_compile
),
1212 INIT_STATIC_SPEC ("version", &compiler_version
),
1213 INIT_STATIC_SPEC ("multilib", &multilib_select
),
1214 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults
),
1215 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra
),
1216 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches
),
1217 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions
),
1218 INIT_STATIC_SPEC ("multilib_options", &multilib_options
),
1219 INIT_STATIC_SPEC ("linker", &linker_name_spec
),
1220 INIT_STATIC_SPEC ("linker_plugin_file", &linker_plugin_file_spec
),
1221 INIT_STATIC_SPEC ("lto_wrapper", <o_wrapper_spec
),
1222 INIT_STATIC_SPEC ("lto_gcc", <o_gcc_spec
),
1223 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec
),
1224 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix
),
1225 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix
),
1226 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1
),
1227 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec
),
1228 INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec
),
1229 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec
),
1230 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec
),
1231 INIT_STATIC_SPEC ("self_spec", &self_spec
),
1234 #ifdef EXTRA_SPECS /* additional specs needed */
1235 /* Structure to keep track of just the first two args of a spec_list.
1236 That is all that the EXTRA_SPECS macro gives us. */
1239 const char *const name
;
1240 const char *const ptr
;
1243 static const struct spec_list_1 extra_specs_1
[] = { EXTRA_SPECS
};
1244 static struct spec_list
*extra_specs
= (struct spec_list
*) 0;
1247 /* List of dynamically allocates specs that have been defined so far. */
1249 static struct spec_list
*specs
= (struct spec_list
*) 0;
1251 /* List of static spec functions. */
1253 static const struct spec_function static_spec_functions
[] =
1255 { "getenv", getenv_spec_function
},
1256 { "if-exists", if_exists_spec_function
},
1257 { "if-exists-else", if_exists_else_spec_function
},
1258 { "replace-outfile", replace_outfile_spec_function
},
1259 { "remove-outfile", remove_outfile_spec_function
},
1260 { "version-compare", version_compare_spec_function
},
1261 { "include", include_spec_function
},
1262 { "find-file", find_file_spec_function
},
1263 { "find-plugindir", find_plugindir_spec_function
},
1264 { "print-asm-header", print_asm_header_spec_function
},
1265 { "compare-debug-dump-opt", compare_debug_dump_opt_spec_function
},
1266 { "compare-debug-self-opt", compare_debug_self_opt_spec_function
},
1267 { "compare-debug-auxbase-opt", compare_debug_auxbase_opt_spec_function
},
1268 { "pass-through-libs", pass_through_libs_spec_func
},
1269 #ifdef EXTRA_SPEC_FUNCTIONS
1270 EXTRA_SPEC_FUNCTIONS
1275 static int processing_spec_function
;
1277 /* Add appropriate libgcc specs to OBSTACK, taking into account
1278 various permutations of -shared-libgcc, -shared, and such. */
1280 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1282 #ifndef USE_LD_AS_NEEDED
1283 #define USE_LD_AS_NEEDED 0
1287 init_gcc_specs (struct obstack
*obstack
, const char *shared_name
,
1288 const char *static_name
, const char *eh_name
)
1292 buf
= concat ("%{static|static-libgcc:", static_name
, " ", eh_name
, "}"
1293 "%{!static:%{!static-libgcc:"
1294 #if USE_LD_AS_NEEDED
1295 "%{!shared-libgcc:",
1296 static_name
, " --as-needed ", shared_name
, " --no-as-needed"
1299 shared_name
, "%{!shared: ", static_name
, "}"
1303 "%{!shared-libgcc:", static_name
, " ", eh_name
, "}"
1304 "%{shared-libgcc:", shared_name
, " ", static_name
, "}"
1308 "%{shared-libgcc:", shared_name
, "}"
1309 "%{!shared-libgcc:", static_name
, "}"
1312 "%{shared:", shared_name
, "}"
1317 obstack_grow (obstack
, buf
, strlen (buf
));
1320 #endif /* ENABLE_SHARED_LIBGCC */
1322 /* Initialize the specs lookup routines. */
1327 struct spec_list
*next
= (struct spec_list
*) 0;
1328 struct spec_list
*sl
= (struct spec_list
*) 0;
1332 return; /* Already initialized. */
1335 fnotice (stderr
, "Using built-in specs.\n");
1338 extra_specs
= XCNEWVEC (struct spec_list
, ARRAY_SIZE (extra_specs_1
));
1340 for (i
= ARRAY_SIZE (extra_specs_1
) - 1; i
>= 0; i
--)
1342 sl
= &extra_specs
[i
];
1343 sl
->name
= extra_specs_1
[i
].name
;
1344 sl
->ptr
= extra_specs_1
[i
].ptr
;
1346 sl
->name_len
= strlen (sl
->name
);
1347 sl
->ptr_spec
= &sl
->ptr
;
1352 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1354 sl
= &static_specs
[i
];
1359 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1360 /* ??? If neither -shared-libgcc nor --static-libgcc was
1361 seen, then we should be making an educated guess. Some proposed
1362 heuristics for ELF include:
1364 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1365 program will be doing dynamic loading, which will likely
1366 need the shared libgcc.
1368 (2) If "-ldl", then it's also a fair bet that we're doing
1371 (3) For each ET_DYN we're linking against (either through -lfoo
1372 or /some/path/foo.so), check to see whether it or one of
1373 its dependencies depends on a shared libgcc.
1377 If the runtime is fixed to look for program headers instead
1378 of calling __register_frame_info at all, for each object,
1379 use the shared libgcc if any EH symbol referenced.
1381 If crtstuff is fixed to not invoke __register_frame_info
1382 automatically, for each object, use the shared libgcc if
1383 any non-empty unwind section found.
1385 Doing any of this probably requires invoking an external program to
1386 do the actual object file scanning. */
1388 const char *p
= libgcc_spec
;
1391 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1392 when given the proper command line arguments. */
1395 if (in_sep
&& *p
== '-' && strncmp (p
, "-lgcc", 5) == 0)
1397 init_gcc_specs (&obstack
,
1399 #ifdef USE_LIBUNWIND_EXCEPTIONS
1405 #ifdef USE_LIBUNWIND_EXCEPTIONS
1406 # ifdef HAVE_LD_STATIC_DYNAMIC
1407 " %{!static:" LD_STATIC_OPTION
"} -lunwind"
1408 " %{!static:" LD_DYNAMIC_OPTION
"}"
1418 else if (in_sep
&& *p
== 'l' && strncmp (p
, "libgcc.a%s", 10) == 0)
1420 /* Ug. We don't know shared library extensions. Hope that
1421 systems that use this form don't do shared libraries. */
1422 init_gcc_specs (&obstack
,
1426 #ifdef USE_LIBUNWIND_EXCEPTIONS
1435 obstack_1grow (&obstack
, *p
);
1436 in_sep
= (*p
== ' ');
1441 obstack_1grow (&obstack
, '\0');
1442 libgcc_spec
= XOBFINISH (&obstack
, const char *);
1445 #ifdef USE_AS_TRADITIONAL_FORMAT
1446 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1448 static const char tf
[] = "--traditional-format ";
1449 obstack_grow (&obstack
, tf
, sizeof(tf
) - 1);
1450 obstack_grow0 (&obstack
, asm_spec
, strlen (asm_spec
));
1451 asm_spec
= XOBFINISH (&obstack
, const char *);
1455 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC || \
1456 defined LINKER_HASH_STYLE
1457 # ifdef LINK_BUILDID_SPEC
1458 /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. */
1459 obstack_grow (&obstack
, LINK_BUILDID_SPEC
, sizeof(LINK_BUILDID_SPEC
) - 1);
1461 # ifdef LINK_EH_SPEC
1462 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1463 obstack_grow (&obstack
, LINK_EH_SPEC
, sizeof(LINK_EH_SPEC
) - 1);
1465 # ifdef LINKER_HASH_STYLE
1466 /* Prepend --hash-style=LINKER_HASH_STYLE to whatever link_spec we had
1469 static const char hash_style
[] = "--hash-style=";
1470 obstack_grow (&obstack
, hash_style
, sizeof(hash_style
) - 1);
1471 obstack_grow (&obstack
, LINKER_HASH_STYLE
, sizeof(LINKER_HASH_STYLE
) - 1);
1472 obstack_1grow (&obstack
, ' ');
1475 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
1476 link_spec
= XOBFINISH (&obstack
, const char *);
1482 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1483 removed; If the spec starts with a + then SPEC is added to the end of the
1487 set_spec (const char *name
, const char *spec
)
1489 struct spec_list
*sl
;
1490 const char *old_spec
;
1491 int name_len
= strlen (name
);
1494 /* If this is the first call, initialize the statically allocated specs. */
1497 struct spec_list
*next
= (struct spec_list
*) 0;
1498 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1500 sl
= &static_specs
[i
];
1507 /* See if the spec already exists. */
1508 for (sl
= specs
; sl
; sl
= sl
->next
)
1509 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, name
))
1514 /* Not found - make it. */
1515 sl
= XNEW (struct spec_list
);
1516 sl
->name
= xstrdup (name
);
1517 sl
->name_len
= name_len
;
1518 sl
->ptr_spec
= &sl
->ptr
;
1520 *(sl
->ptr_spec
) = "";
1525 old_spec
= *(sl
->ptr_spec
);
1526 *(sl
->ptr_spec
) = ((spec
[0] == '+' && ISSPACE ((unsigned char)spec
[1]))
1527 ? concat (old_spec
, spec
+ 1, NULL
)
1532 fnotice (stderr
, "Setting spec %s to '%s'\n\n", name
, *(sl
->ptr_spec
));
1535 /* Free the old spec. */
1536 if (old_spec
&& sl
->alloc_p
)
1537 free (CONST_CAST(char *, old_spec
));
1542 /* Accumulate a command (program name and args), and run it. */
1544 typedef const char *const_char_p
; /* For DEF_VEC_P. */
1545 DEF_VEC_P(const_char_p
);
1546 DEF_VEC_ALLOC_P(const_char_p
,heap
);
1548 /* Vector of pointers to arguments in the current line of specifications. */
1550 static VEC(const_char_p
,heap
) *argbuf
;
1552 /* Position in the argbuf vector containing the name of the output file
1553 (the value associated with the "-o" flag). */
1555 static int have_o_argbuf_index
= 0;
1557 /* Were the options -c, -S or -E passed. */
1558 static int have_c
= 0;
1560 /* Was the option -o passed. */
1561 static int have_o
= 0;
1563 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1564 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
1567 static struct temp_name
{
1568 const char *suffix
; /* suffix associated with the code. */
1569 int length
; /* strlen (suffix). */
1570 int unique
; /* Indicates whether %g or %u/%U was used. */
1571 const char *filename
; /* associated filename. */
1572 int filename_length
; /* strlen (filename). */
1573 struct temp_name
*next
;
1576 /* Number of commands executed so far. */
1578 static int execution_count
;
1580 /* Number of commands that exited with a signal. */
1582 static int signal_count
;
1584 /* Allocate the argument vector. */
1589 argbuf
= VEC_alloc (const_char_p
, heap
, 10);
1592 /* Clear out the vector of arguments (after a command is executed). */
1597 VEC_truncate (const_char_p
, argbuf
, 0);
1600 /* Add one argument to the vector at the end.
1601 This is done when a space is seen or at the end of the line.
1602 If DELETE_ALWAYS is nonzero, the arg is a filename
1603 and the file should be deleted eventually.
1604 If DELETE_FAILURE is nonzero, the arg is a filename
1605 and the file should be deleted if this compilation fails. */
1608 store_arg (const char *arg
, int delete_always
, int delete_failure
)
1610 VEC_safe_push (const_char_p
, heap
, argbuf
, arg
);
1612 if (strcmp (arg
, "-o") == 0)
1613 have_o_argbuf_index
= VEC_length (const_char_p
, argbuf
);
1614 if (delete_always
|| delete_failure
)
1617 /* If the temporary file we should delete is specified as
1618 part of a joined argument extract the filename. */
1620 && (p
= strrchr (arg
, '=')))
1622 record_temp_file (arg
, delete_always
, delete_failure
);
1626 /* Load specs from a file name named FILENAME, replacing occurrences of
1627 various different types of line-endings, \r\n, \n\r and just \r, with
1631 load_specs (const char *filename
)
1635 struct stat statbuf
;
1642 fnotice (stderr
, "Reading specs from %s\n", filename
);
1644 /* Open and stat the file. */
1645 desc
= open (filename
, O_RDONLY
, 0);
1647 pfatal_with_name (filename
);
1648 if (stat (filename
, &statbuf
) < 0)
1649 pfatal_with_name (filename
);
1651 /* Read contents of file into BUFFER. */
1652 buffer
= XNEWVEC (char, statbuf
.st_size
+ 1);
1653 readlen
= read (desc
, buffer
, (unsigned) statbuf
.st_size
);
1655 pfatal_with_name (filename
);
1656 buffer
[readlen
] = 0;
1659 specs
= XNEWVEC (char, readlen
+ 1);
1661 for (buffer_p
= buffer
; buffer_p
&& *buffer_p
; buffer_p
++)
1667 if (buffer_p
> buffer
&& *(buffer_p
- 1) == '\n') /* \n\r */
1669 else if (*(buffer_p
+ 1) == '\n') /* \r\n */
1683 /* Read compilation specs from a file named FILENAME,
1684 replacing the default ones.
1686 A suffix which starts with `*' is a definition for
1687 one of the machine-specific sub-specs. The "suffix" should be
1688 *asm, *cc1, *cpp, *link, *startfile, etc.
1689 The corresponding spec is stored in asm_spec, etc.,
1690 rather than in the `compilers' vector.
1692 Anything invalid in the file is a fatal error. */
1695 read_specs (const char *filename
, int main_p
)
1700 buffer
= load_specs (filename
);
1702 /* Scan BUFFER for specs, putting them in the vector. */
1708 char *in
, *out
, *p1
, *p2
, *p3
;
1710 /* Advance P in BUFFER to the next nonblank nocomment line. */
1711 p
= skip_whitespace (p
);
1715 /* Is this a special command that starts with '%'? */
1716 /* Don't allow this for the main specs file, since it would
1717 encourage people to overwrite it. */
1718 if (*p
== '%' && !main_p
)
1721 while (*p
&& *p
!= '\n')
1727 if (!strncmp (p1
, "%include", sizeof ("%include") - 1)
1728 && (p1
[sizeof "%include" - 1] == ' '
1729 || p1
[sizeof "%include" - 1] == '\t'))
1733 p1
+= sizeof ("%include");
1734 while (*p1
== ' ' || *p1
== '\t')
1737 if (*p1
++ != '<' || p
[-2] != '>')
1738 fatal_error ("specs %%include syntax malformed after "
1740 (long) (p1
- buffer
+ 1));
1743 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
1744 read_specs (new_filename
? new_filename
: p1
, FALSE
);
1747 else if (!strncmp (p1
, "%include_noerr", sizeof "%include_noerr" - 1)
1748 && (p1
[sizeof "%include_noerr" - 1] == ' '
1749 || p1
[sizeof "%include_noerr" - 1] == '\t'))
1753 p1
+= sizeof "%include_noerr";
1754 while (*p1
== ' ' || *p1
== '\t')
1757 if (*p1
++ != '<' || p
[-2] != '>')
1758 fatal_error ("specs %%include syntax malformed after "
1760 (long) (p1
- buffer
+ 1));
1763 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, true);
1765 read_specs (new_filename
, FALSE
);
1766 else if (verbose_flag
)
1767 fnotice (stderr
, "could not find specs file %s\n", p1
);
1770 else if (!strncmp (p1
, "%rename", sizeof "%rename" - 1)
1771 && (p1
[sizeof "%rename" - 1] == ' '
1772 || p1
[sizeof "%rename" - 1] == '\t'))
1775 struct spec_list
*sl
;
1776 struct spec_list
*newsl
;
1778 /* Get original name. */
1779 p1
+= sizeof "%rename";
1780 while (*p1
== ' ' || *p1
== '\t')
1783 if (! ISALPHA ((unsigned char) *p1
))
1784 fatal_error ("specs %%rename syntax malformed after "
1786 (long) (p1
- buffer
));
1789 while (*p2
&& !ISSPACE ((unsigned char) *p2
))
1792 if (*p2
!= ' ' && *p2
!= '\t')
1793 fatal_error ("specs %%rename syntax malformed after "
1795 (long) (p2
- buffer
));
1799 while (*p2
== ' ' || *p2
== '\t')
1802 if (! ISALPHA ((unsigned char) *p2
))
1803 fatal_error ("specs %%rename syntax malformed after "
1805 (long) (p2
- buffer
));
1807 /* Get new spec name. */
1809 while (*p3
&& !ISSPACE ((unsigned char) *p3
))
1813 fatal_error ("specs %%rename syntax malformed after "
1815 (long) (p3
- buffer
));
1818 for (sl
= specs
; sl
; sl
= sl
->next
)
1819 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, p1
))
1823 fatal_error ("specs %s spec was not found to be renamed", p1
);
1825 if (strcmp (p1
, p2
) == 0)
1828 for (newsl
= specs
; newsl
; newsl
= newsl
->next
)
1829 if (strcmp (newsl
->name
, p2
) == 0)
1830 fatal_error ("%s: attempt to rename spec %qs to "
1831 "already defined spec %qs",
1836 fnotice (stderr
, "rename spec %s to %s\n", p1
, p2
);
1838 fnotice (stderr
, "spec is '%s'\n\n", *(sl
->ptr_spec
));
1842 set_spec (p2
, *(sl
->ptr_spec
));
1844 free (CONST_CAST (char *, *(sl
->ptr_spec
)));
1846 *(sl
->ptr_spec
) = "";
1851 fatal_error ("specs unknown %% command after %ld characters",
1852 (long) (p1
- buffer
));
1855 /* Find the colon that should end the suffix. */
1857 while (*p1
&& *p1
!= ':' && *p1
!= '\n')
1860 /* The colon shouldn't be missing. */
1862 fatal_error ("specs file malformed after %ld characters",
1863 (long) (p1
- buffer
));
1865 /* Skip back over trailing whitespace. */
1867 while (p2
> buffer
&& (p2
[-1] == ' ' || p2
[-1] == '\t'))
1870 /* Copy the suffix to a string. */
1871 suffix
= save_string (p
, p2
- p
);
1872 /* Find the next line. */
1873 p
= skip_whitespace (p1
+ 1);
1875 fatal_error ("specs file malformed after %ld characters",
1876 (long) (p
- buffer
));
1879 /* Find next blank line or end of string. */
1880 while (*p1
&& !(*p1
== '\n' && (p1
[1] == '\n' || p1
[1] == '\0')))
1883 /* Specs end at the blank line and do not include the newline. */
1884 spec
= save_string (p
, p1
- p
);
1887 /* Delete backslash-newline sequences from the spec. */
1892 if (in
[0] == '\\' && in
[1] == '\n')
1894 else if (in
[0] == '#')
1895 while (*in
&& *in
!= '\n')
1903 if (suffix
[0] == '*')
1905 if (! strcmp (suffix
, "*link_command"))
1906 link_command_spec
= spec
;
1908 set_spec (suffix
+ 1, spec
);
1912 /* Add this pair to the vector. */
1914 = XRESIZEVEC (struct compiler
, compilers
, n_compilers
+ 2);
1916 compilers
[n_compilers
].suffix
= suffix
;
1917 compilers
[n_compilers
].spec
= spec
;
1919 memset (&compilers
[n_compilers
], 0, sizeof compilers
[n_compilers
]);
1923 link_command_spec
= spec
;
1926 if (link_command_spec
== 0)
1927 fatal_error ("spec file has no spec for linking");
1930 /* Record the names of temporary files we tell compilers to write,
1931 and delete them at the end of the run. */
1933 /* This is the common prefix we use to make temp file names.
1934 It is chosen once for each run of this program.
1935 It is substituted into a spec by %g or %j.
1936 Thus, all temp file names contain this prefix.
1937 In practice, all temp file names start with this prefix.
1939 This prefix comes from the envvar TMPDIR if it is defined;
1940 otherwise, from the P_tmpdir macro if that is defined;
1941 otherwise, in /usr/tmp or /tmp;
1942 or finally the current directory if all else fails. */
1944 static const char *temp_filename
;
1946 /* Length of the prefix. */
1948 static int temp_filename_length
;
1950 /* Define the list of temporary files to delete. */
1955 struct temp_file
*next
;
1958 /* Queue of files to delete on success or failure of compilation. */
1959 static struct temp_file
*always_delete_queue
;
1960 /* Queue of files to delete on failure of compilation. */
1961 static struct temp_file
*failure_delete_queue
;
1963 /* Record FILENAME as a file to be deleted automatically.
1964 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
1965 otherwise delete it in any case.
1966 FAIL_DELETE nonzero means delete it if a compilation step fails;
1967 otherwise delete it in any case. */
1970 record_temp_file (const char *filename
, int always_delete
, int fail_delete
)
1972 char *const name
= xstrdup (filename
);
1976 struct temp_file
*temp
;
1977 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
1978 if (! filename_cmp (name
, temp
->name
))
1981 temp
= XNEW (struct temp_file
);
1982 temp
->next
= always_delete_queue
;
1984 always_delete_queue
= temp
;
1991 struct temp_file
*temp
;
1992 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
1993 if (! filename_cmp (name
, temp
->name
))
1996 temp
= XNEW (struct temp_file
);
1997 temp
->next
= failure_delete_queue
;
1999 failure_delete_queue
= temp
;
2005 /* Delete all the temporary files whose names we previously recorded. */
2007 #ifndef DELETE_IF_ORDINARY
2008 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2011 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2012 if (unlink (NAME) < 0) \
2014 perror_with_name (NAME); \
2019 delete_if_ordinary (const char *name
)
2025 printf ("Delete %s? (y or n) ", name
);
2029 while ((c
= getchar ()) != '\n' && c
!= EOF
)
2032 if (i
== 'y' || i
== 'Y')
2034 DELETE_IF_ORDINARY (name
, st
, verbose_flag
);
2038 delete_temp_files (void)
2040 struct temp_file
*temp
;
2042 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2043 delete_if_ordinary (temp
->name
);
2044 always_delete_queue
= 0;
2047 /* Delete all the files to be deleted on error. */
2050 delete_failure_queue (void)
2052 struct temp_file
*temp
;
2054 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2055 delete_if_ordinary (temp
->name
);
2059 clear_failure_queue (void)
2061 failure_delete_queue
= 0;
2064 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2066 If DO_MULTI is true iterate over the paths twice, first with multilib
2067 suffix then without, otherwise iterate over the paths once without
2068 adding a multilib suffix. When DO_MULTI is true, some attempt is made
2069 to avoid visiting the same path twice, but we could do better. For
2070 instance, /usr/lib/../lib is considered different from /usr/lib.
2071 At least EXTRA_SPACE chars past the end of the path passed to
2072 CALLBACK are available for use by the callback.
2073 CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2075 Returns the value returned by CALLBACK. */
2078 for_each_path (const struct path_prefix
*paths
,
2081 void *(*callback
) (char *, void *),
2082 void *callback_info
)
2084 struct prefix_list
*pl
;
2085 const char *multi_dir
= NULL
;
2086 const char *multi_os_dir
= NULL
;
2087 const char *multiarch_suffix
= NULL
;
2088 const char *multi_suffix
;
2089 const char *just_multi_suffix
;
2092 bool skip_multi_dir
= false;
2093 bool skip_multi_os_dir
= false;
2095 multi_suffix
= machine_suffix
;
2096 just_multi_suffix
= just_machine_suffix
;
2097 if (do_multi
&& multilib_dir
&& strcmp (multilib_dir
, ".") != 0)
2099 multi_dir
= concat (multilib_dir
, dir_separator_str
, NULL
);
2100 multi_suffix
= concat (multi_suffix
, multi_dir
, NULL
);
2101 just_multi_suffix
= concat (just_multi_suffix
, multi_dir
, NULL
);
2103 if (do_multi
&& multilib_os_dir
&& strcmp (multilib_os_dir
, ".") != 0)
2104 multi_os_dir
= concat (multilib_os_dir
, dir_separator_str
, NULL
);
2106 multiarch_suffix
= concat (multiarch_dir
, dir_separator_str
, NULL
);
2110 size_t multi_dir_len
= 0;
2111 size_t multi_os_dir_len
= 0;
2112 size_t multiarch_len
= 0;
2114 size_t just_suffix_len
;
2118 multi_dir_len
= strlen (multi_dir
);
2120 multi_os_dir_len
= strlen (multi_os_dir
);
2121 if (multiarch_suffix
)
2122 multiarch_len
= strlen (multiarch_suffix
);
2123 suffix_len
= strlen (multi_suffix
);
2124 just_suffix_len
= strlen (just_multi_suffix
);
2128 len
= paths
->max_len
+ extra_space
+ 1;
2129 len
+= MAX (MAX (suffix_len
, multi_os_dir_len
), multiarch_len
);
2130 path
= XNEWVEC (char, len
);
2133 for (pl
= paths
->plist
; pl
!= 0; pl
= pl
->next
)
2135 len
= strlen (pl
->prefix
);
2136 memcpy (path
, pl
->prefix
, len
);
2138 #if 0 /* MACHINE/VERSION isn't used anywhere DragonFly */
2139 /* Look first in MACHINE/VERSION subdirectory. */
2140 if (!skip_multi_dir
)
2142 memcpy (path
+ len
, multi_suffix
, suffix_len
+ 1);
2143 ret
= callback (path
, callback_info
);
2149 /* Some paths are tried with just the machine (ie. target)
2150 subdir. This is used for finding as, ld, etc. */
2152 && pl
->require_machine_suffix
== 2)
2154 memcpy (path
+ len
, just_multi_suffix
, just_suffix_len
+ 1);
2155 ret
= callback (path
, callback_info
);
2160 /* Now try the multiarch path. */
2162 && !pl
->require_machine_suffix
&& multiarch_dir
)
2164 memcpy (path
+ len
, multiarch_suffix
, multiarch_len
+ 1);
2165 ret
= callback (path
, callback_info
);
2170 /* Now try the base path. */
2171 if (!pl
->require_machine_suffix
2172 && !(pl
->os_multilib
? skip_multi_os_dir
: skip_multi_dir
))
2174 const char *this_multi
;
2175 size_t this_multi_len
;
2177 if (pl
->os_multilib
)
2179 this_multi
= multi_os_dir
;
2180 this_multi_len
= multi_os_dir_len
;
2184 this_multi
= multi_dir
;
2185 this_multi_len
= multi_dir_len
;
2189 memcpy (path
+ len
, this_multi
, this_multi_len
+ 1);
2193 ret
= callback (path
, callback_info
);
2201 if (multi_dir
== NULL
&& multi_os_dir
== NULL
)
2204 /* Run through the paths again, this time without multilibs.
2205 Don't repeat any we have already seen. */
2208 free (CONST_CAST (char *, multi_dir
));
2210 free (CONST_CAST (char *, multi_suffix
));
2211 multi_suffix
= machine_suffix
;
2212 free (CONST_CAST (char *, just_multi_suffix
));
2213 just_multi_suffix
= just_machine_suffix
;
2216 skip_multi_dir
= true;
2219 free (CONST_CAST (char *, multi_os_dir
));
2220 multi_os_dir
= NULL
;
2223 skip_multi_os_dir
= true;
2228 free (CONST_CAST (char *, multi_dir
));
2229 free (CONST_CAST (char *, multi_suffix
));
2230 free (CONST_CAST (char *, just_multi_suffix
));
2233 free (CONST_CAST (char *, multi_os_dir
));
2239 /* Callback for build_search_list. Adds path to obstack being built. */
2241 struct add_to_obstack_info
{
2248 add_to_obstack (char *path
, void *data
)
2250 struct add_to_obstack_info
*info
= (struct add_to_obstack_info
*) data
;
2252 if (info
->check_dir
&& !is_directory (path
, false))
2255 if (!info
->first_time
)
2256 obstack_1grow (info
->ob
, PATH_SEPARATOR
);
2258 obstack_grow (info
->ob
, path
, strlen (path
));
2260 info
->first_time
= false;
2264 /* Add or change the value of an environment variable, outputting the
2265 change to standard error if in verbose mode. */
2267 xputenv (const char *string
)
2270 fnotice (stderr
, "%s\n", string
);
2271 putenv (CONST_CAST (char *, string
));
2274 /* Build a list of search directories from PATHS.
2275 PREFIX is a string to prepend to the list.
2276 If CHECK_DIR_P is true we ensure the directory exists.
2277 If DO_MULTI is true, multilib paths are output first, then
2279 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2280 It is also used by the --print-search-dirs flag. */
2283 build_search_list (const struct path_prefix
*paths
, const char *prefix
,
2284 bool check_dir
, bool do_multi
)
2286 struct add_to_obstack_info info
;
2288 info
.ob
= &collect_obstack
;
2289 info
.check_dir
= check_dir
;
2290 info
.first_time
= true;
2292 obstack_grow (&collect_obstack
, prefix
, strlen (prefix
));
2293 obstack_1grow (&collect_obstack
, '=');
2295 for_each_path (paths
, do_multi
, 0, add_to_obstack
, &info
);
2297 obstack_1grow (&collect_obstack
, '\0');
2298 return XOBFINISH (&collect_obstack
, char *);
2301 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2305 putenv_from_prefixes (const struct path_prefix
*paths
, const char *env_var
,
2308 xputenv (build_search_list (paths
, env_var
, true, do_multi
));
2311 /* Check whether NAME can be accessed in MODE. This is like access,
2312 except that it never considers directories to be executable. */
2315 access_check (const char *name
, int mode
)
2321 if (stat (name
, &st
) < 0
2322 || S_ISDIR (st
.st_mode
))
2326 return access (name
, mode
);
2329 /* Callback for find_a_file. Appends the file name to the directory
2330 path. If the resulting file exists in the right mode, return the
2331 full pathname to the file. */
2333 struct file_at_path_info
{
2342 file_at_path (char *path
, void *data
)
2344 struct file_at_path_info
*info
= (struct file_at_path_info
*) data
;
2345 size_t len
= strlen (path
);
2347 memcpy (path
+ len
, info
->name
, info
->name_len
);
2348 len
+= info
->name_len
;
2350 /* Some systems have a suffix for executable files.
2351 So try appending that first. */
2352 if (info
->suffix_len
)
2354 memcpy (path
+ len
, info
->suffix
, info
->suffix_len
+ 1);
2355 if (access_check (path
, info
->mode
) == 0)
2360 if (access_check (path
, info
->mode
) == 0)
2366 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2367 access to check permissions. If DO_MULTI is true, search multilib
2368 paths then non-multilib paths, otherwise do not search multilib paths.
2369 Return 0 if not found, otherwise return its name, allocated with malloc. */
2372 find_a_file (const struct path_prefix
*pprefix
, const char *name
, int mode
,
2375 struct file_at_path_info info
;
2377 #ifdef DEFAULT_ASSEMBLER
2378 if (! strcmp (name
, "as") && access (DEFAULT_ASSEMBLER
, mode
) == 0)
2379 return xstrdup (DEFAULT_ASSEMBLER
);
2382 #ifdef DEFAULT_LINKER
2383 if (! strcmp(name
, "ld") && access (DEFAULT_LINKER
, mode
) == 0)
2384 return xstrdup (DEFAULT_LINKER
);
2387 /* Determine the filename to execute (special case for absolute paths). */
2389 if (IS_ABSOLUTE_PATH (name
))
2391 if (access (name
, mode
) == 0)
2392 return xstrdup (name
);
2398 info
.suffix
= (mode
& X_OK
) != 0 ? HOST_EXECUTABLE_SUFFIX
: "";
2399 info
.name_len
= strlen (info
.name
);
2400 info
.suffix_len
= strlen (info
.suffix
);
2403 return (char*) for_each_path (pprefix
, do_multi
,
2404 info
.name_len
+ info
.suffix_len
,
2405 file_at_path
, &info
);
2408 /* Ranking of prefixes in the sort list. -B prefixes are put before
2411 enum path_prefix_priority
2413 PREFIX_PRIORITY_B_OPT
,
2414 PREFIX_PRIORITY_LAST
2417 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
2418 order according to PRIORITY. Within each PRIORITY, new entries are
2421 If WARN is nonzero, we will warn if no file is found
2422 through this prefix. WARN should point to an int
2423 which will be set to 1 if this entry is used.
2425 COMPONENT is the value to be passed to update_path.
2427 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2428 the complete value of machine_suffix.
2429 2 means try both machine_suffix and just_machine_suffix. */
2432 add_prefix (struct path_prefix
*pprefix
, const char *prefix
,
2433 const char *component
, /* enum prefix_priority */ int priority
,
2434 int require_machine_suffix
, int os_multilib
)
2436 struct prefix_list
*pl
, **prev
;
2439 for (prev
= &pprefix
->plist
;
2440 (*prev
) != NULL
&& (*prev
)->priority
<= priority
;
2441 prev
= &(*prev
)->next
)
2444 /* Keep track of the longest prefix. */
2446 prefix
= update_path (prefix
, component
);
2447 len
= strlen (prefix
);
2448 if (len
> pprefix
->max_len
)
2449 pprefix
->max_len
= len
;
2451 pl
= XNEW (struct prefix_list
);
2452 pl
->prefix
= prefix
;
2453 pl
->require_machine_suffix
= require_machine_suffix
;
2454 pl
->priority
= priority
;
2455 pl
->os_multilib
= os_multilib
;
2457 /* Insert after PREV. */
2462 /* Same as add_prefix, but prepending target_system_root to prefix. */
2463 /* The target_system_root prefix has been relocated by gcc_exec_prefix. */
2465 add_sysrooted_prefix (struct path_prefix
*pprefix
, const char *prefix
,
2466 const char *component
,
2467 /* enum prefix_priority */ int priority
,
2468 int require_machine_suffix
, int os_multilib
)
2470 if (!IS_ABSOLUTE_PATH (prefix
))
2471 fatal_error ("system path %qs is not absolute", prefix
);
2473 if (target_system_root
)
2475 char *sysroot_no_trailing_dir_separator
= xstrdup (target_system_root
);
2476 size_t sysroot_len
= strlen (target_system_root
);
2479 && target_system_root
[sysroot_len
- 1] == DIR_SEPARATOR
)
2480 sysroot_no_trailing_dir_separator
[sysroot_len
- 1] = '\0';
2482 if (target_sysroot_suffix
)
2483 prefix
= concat (target_sysroot_suffix
, prefix
, NULL
);
2484 prefix
= concat (sysroot_no_trailing_dir_separator
, prefix
, NULL
);
2485 free (sysroot_no_trailing_dir_separator
);
2487 /* We have to override this because GCC's notion of sysroot
2488 moves along with GCC. */
2492 add_prefix (pprefix
, prefix
, component
, priority
,
2493 require_machine_suffix
, os_multilib
);
2496 /* Execute the command specified by the arguments on the current line of spec.
2497 When using pipes, this includes several piped-together commands
2498 with `|' between them.
2500 Return 0 if successful, -1 if failed. */
2506 int n_commands
; /* # of command. */
2508 struct pex_obj
*pex
;
2511 const char *prog
; /* program name. */
2512 const char **argv
; /* vector of args. */
2516 struct command
*commands
; /* each command buffer with above info. */
2518 gcc_assert (!processing_spec_function
);
2522 string
= find_a_file (&exec_prefixes
,
2523 VEC_index (const_char_p
, argbuf
, 0), X_OK
, false);
2525 VEC_replace (const_char_p
, argbuf
, 0, string
);
2526 insert_wrapper (wrapper_string
);
2529 /* Count # of piped commands. */
2530 for (n_commands
= 1, i
= 0; VEC_iterate (const_char_p
, argbuf
, i
, arg
); i
++)
2531 if (strcmp (arg
, "|") == 0)
2534 /* Get storage for each command. */
2535 commands
= (struct command
*) alloca (n_commands
* sizeof (struct command
));
2537 /* Split argbuf into its separate piped processes,
2538 and record info about each one.
2539 Also search for the programs that are to be run. */
2541 VEC_safe_push (const_char_p
, heap
, argbuf
, 0);
2543 commands
[0].prog
= VEC_index (const_char_p
, argbuf
, 0); /* first command. */
2544 commands
[0].argv
= VEC_address (const_char_p
, argbuf
);
2546 if (!wrapper_string
)
2548 string
= find_a_file (&exec_prefixes
, commands
[0].prog
, X_OK
, false);
2549 commands
[0].argv
[0] = (string
) ? string
: commands
[0].argv
[0];
2552 for (n_commands
= 1, i
= 0; VEC_iterate (const_char_p
, argbuf
, i
, arg
); i
++)
2553 if (arg
&& strcmp (arg
, "|") == 0)
2554 { /* each command. */
2555 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2556 fatal_error ("-pipe not supported");
2558 VEC_replace (const_char_p
, argbuf
, i
, 0); /* Termination of
2560 commands
[n_commands
].prog
= VEC_index (const_char_p
, argbuf
, i
+ 1);
2561 commands
[n_commands
].argv
2562 = &(VEC_address (const_char_p
, argbuf
))[i
+ 1];
2563 string
= find_a_file (&exec_prefixes
, commands
[n_commands
].prog
,
2566 commands
[n_commands
].argv
[0] = string
;
2570 /* If -v, print what we are about to do, and maybe query. */
2574 /* For help listings, put a blank line between sub-processes. */
2575 if (print_help_list
)
2576 fputc ('\n', stderr
);
2578 /* Print each piped command as a separate line. */
2579 for (i
= 0; i
< n_commands
; i
++)
2581 const char *const *j
;
2583 if (verbose_only_flag
)
2585 for (j
= commands
[i
].argv
; *j
; j
++)
2588 for (p
= *j
; *p
; ++p
)
2589 if (!ISALNUM ((unsigned char) *p
)
2590 && *p
!= '_' && *p
!= '/' && *p
!= '-' && *p
!= '.')
2594 fprintf (stderr
, " \"");
2595 for (p
= *j
; *p
; ++p
)
2597 if (*p
== '"' || *p
== '\\' || *p
== '$')
2598 fputc ('\\', stderr
);
2601 fputc ('"', stderr
);
2603 /* If it's empty, print "". */
2605 fprintf (stderr
, " \"\"");
2607 fprintf (stderr
, " %s", *j
);
2611 for (j
= commands
[i
].argv
; *j
; j
++)
2612 /* If it's empty, print "". */
2614 fprintf (stderr
, " \"\"");
2616 fprintf (stderr
, " %s", *j
);
2618 /* Print a pipe symbol after all but the last command. */
2619 if (i
+ 1 != n_commands
)
2620 fprintf (stderr
, " |");
2621 fprintf (stderr
, "\n");
2624 if (verbose_only_flag
!= 0)
2626 /* verbose_only_flag should act as if the spec was
2627 executed, so increment execution_count before
2628 returning. This prevents spurious warnings about
2629 unused linker input files, etc. */
2634 fnotice (stderr
, "\nGo ahead? (y or n) ");
2638 while (getchar () != '\n')
2641 if (i
!= 'y' && i
!= 'Y')
2646 #ifdef ENABLE_VALGRIND_CHECKING
2647 /* Run the each command through valgrind. To simplify prepending the
2648 path to valgrind and the option "-q" (for quiet operation unless
2649 something triggers), we allocate a separate argv array. */
2651 for (i
= 0; i
< n_commands
; i
++)
2657 for (argc
= 0; commands
[i
].argv
[argc
] != NULL
; argc
++)
2660 argv
= XALLOCAVEC (const char *, argc
+ 3);
2662 argv
[0] = VALGRIND_PATH
;
2664 for (j
= 2; j
< argc
+ 2; j
++)
2665 argv
[j
] = commands
[i
].argv
[j
- 2];
2668 commands
[i
].argv
= argv
;
2669 commands
[i
].prog
= argv
[0];
2673 /* Run each piped subprocess. */
2675 pex
= pex_init (PEX_USE_PIPES
| ((report_times
|| report_times_to_file
)
2676 ? PEX_RECORD_TIMES
: 0),
2677 progname
, temp_filename
);
2679 fatal_error ("pex_init failed: %m");
2681 for (i
= 0; i
< n_commands
; i
++)
2685 const char *string
= commands
[i
].argv
[0];
2687 errmsg
= pex_run (pex
,
2688 ((i
+ 1 == n_commands
? PEX_LAST
: 0)
2689 | (string
== commands
[i
].prog
? PEX_SEARCH
: 0)),
2690 string
, CONST_CAST (char **, commands
[i
].argv
),
2695 fatal_error (errmsg
);
2699 pfatal_with_name (errmsg
);
2703 if (string
!= commands
[i
].prog
)
2704 free (CONST_CAST (char *, string
));
2709 /* Wait for all the subprocesses to finish. */
2713 struct pex_time
*times
= NULL
;
2716 statuses
= (int *) alloca (n_commands
* sizeof (int));
2717 if (!pex_get_status (pex
, n_commands
, statuses
))
2718 fatal_error ("failed to get exit status: %m");
2720 if (report_times
|| report_times_to_file
)
2722 times
= (struct pex_time
*) alloca (n_commands
* sizeof (struct pex_time
));
2723 if (!pex_get_times (pex
, n_commands
, times
))
2724 fatal_error ("failed to get process times: %m");
2729 for (i
= 0; i
< n_commands
; ++i
)
2731 int status
= statuses
[i
];
2733 if (WIFSIGNALED (status
))
2736 /* SIGPIPE is a special case. It happens in -pipe mode
2737 when the compiler dies before the preprocessor is done,
2738 or the assembler dies before the compiler is done.
2739 There's generally been an error already, and this is
2740 just fallout. So don't generate another error unless
2741 we would otherwise have succeeded. */
2742 if (WTERMSIG (status
) == SIGPIPE
2743 && (signal_count
|| greatest_status
>= MIN_FATAL_STATUS
))
2750 internal_error ("%s (program %s)",
2751 strsignal (WTERMSIG (status
)), commands
[i
].prog
);
2753 else if (WIFEXITED (status
)
2754 && WEXITSTATUS (status
) >= MIN_FATAL_STATUS
)
2756 if (WEXITSTATUS (status
) > greatest_status
)
2757 greatest_status
= WEXITSTATUS (status
);
2761 if (report_times
|| report_times_to_file
)
2763 struct pex_time
*pt
= ×
[i
];
2766 ut
= ((double) pt
->user_seconds
2767 + (double) pt
->user_microseconds
/ 1.0e6
);
2768 st
= ((double) pt
->system_seconds
2769 + (double) pt
->system_microseconds
/ 1.0e6
);
2774 fnotice (stderr
, "# %s %.2f %.2f\n",
2775 commands
[i
].prog
, ut
, st
);
2777 if (report_times_to_file
)
2780 const char *const *j
;
2782 fprintf (report_times_to_file
, "%g %g", ut
, st
);
2784 for (j
= &commands
[i
].prog
; *j
; j
= &commands
[i
].argv
[++c
])
2787 for (p
= *j
; *p
; ++p
)
2788 if (*p
== '"' || *p
== '\\' || *p
== '$'
2794 fprintf (report_times_to_file
, " \"");
2795 for (p
= *j
; *p
; ++p
)
2797 if (*p
== '"' || *p
== '\\' || *p
== '$')
2798 fputc ('\\', report_times_to_file
);
2799 fputc (*p
, report_times_to_file
);
2801 fputc ('"', report_times_to_file
);
2804 fprintf (report_times_to_file
, " %s", *j
);
2807 fputc ('\n', report_times_to_file
);
2817 /* Find all the switches given to us
2818 and make a vector describing them.
2819 The elements of the vector are strings, one per switch given.
2820 If a switch uses following arguments, then the `part1' field
2821 is the switch itself and the `args' field
2822 is a null-terminated vector containing the following arguments.
2823 Bits in the `live_cond' field are:
2824 SWITCH_LIVE to indicate this switch is true in a conditional spec.
2825 SWITCH_FALSE to indicate this switch is overridden by a later switch.
2826 SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
2827 SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored
2828 in all do_spec calls afterwards. Used for %<S from self specs.
2829 The `validated' field is nonzero if any spec has looked at this switch;
2830 if it remains zero at the end of the run, it must be meaningless. */
2832 #define SWITCH_LIVE (1 << 0)
2833 #define SWITCH_FALSE (1 << 1)
2834 #define SWITCH_IGNORE (1 << 2)
2835 #define SWITCH_IGNORE_PERMANENTLY (1 << 3)
2836 #define SWITCH_KEEP_FOR_GCC (1 << 4)
2842 unsigned int live_cond
;
2843 unsigned char validated
;
2844 unsigned char ordering
;
2847 static struct switchstr
*switches
;
2849 static int n_switches
;
2851 static int n_switches_alloc
;
2853 /* Set to zero if -fcompare-debug is disabled, positive if it's
2854 enabled and we're running the first compilation, negative if it's
2855 enabled and we're running the second compilation. For most of the
2856 time, it's in the range -1..1, but it can be temporarily set to 2
2857 or 3 to indicate that the -fcompare-debug flags didn't come from
2858 the command-line, but rather from the GCC_COMPARE_DEBUG environment
2859 variable, until a synthesized -fcompare-debug flag is added to the
2863 /* Set to nonzero if we've seen the -fcompare-debug-second flag. */
2864 int compare_debug_second
;
2866 /* Set to the flags that should be passed to the second compilation in
2867 a -fcompare-debug compilation. */
2868 const char *compare_debug_opt
;
2870 static struct switchstr
*switches_debug_check
[2];
2872 static int n_switches_debug_check
[2];
2874 static int n_switches_alloc_debug_check
[2];
2876 static char *debug_check_temp_file
[2];
2878 /* Language is one of three things:
2880 1) The name of a real programming language.
2881 2) NULL, indicating that no one has figured out
2883 3) '*', indicating that the file should be passed
2888 const char *language
;
2889 struct compiler
*incompiler
;
2894 /* Also a vector of input files specified. */
2896 static struct infile
*infiles
;
2900 static int n_infiles_alloc
;
2902 /* True if multiple input files are being compiled to a single
2905 static bool combine_inputs
;
2907 /* This counts the number of libraries added by lang_specific_driver, so that
2908 we can tell if there were any user supplied any files or libraries. */
2910 static int added_libraries
;
2912 /* And a vector of corresponding output files is made up later. */
2914 const char **outfiles
;
2916 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2918 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
2919 is true if we should look for an executable suffix. DO_OBJ
2920 is true if we should look for an object suffix. */
2923 convert_filename (const char *name
, int do_exe ATTRIBUTE_UNUSED
,
2924 int do_obj ATTRIBUTE_UNUSED
)
2926 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2934 len
= strlen (name
);
2936 #ifdef HAVE_TARGET_OBJECT_SUFFIX
2937 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
2938 if (do_obj
&& len
> 2
2939 && name
[len
- 2] == '.'
2940 && name
[len
- 1] == 'o')
2942 obstack_grow (&obstack
, name
, len
- 2);
2943 obstack_grow0 (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
2944 name
= XOBFINISH (&obstack
, const char *);
2948 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2949 /* If there is no filetype, make it the executable suffix (which includes
2950 the "."). But don't get confused if we have just "-o". */
2951 if (! do_exe
|| TARGET_EXECUTABLE_SUFFIX
[0] == 0 || (len
== 2 && name
[0] == '-'))
2954 for (i
= len
- 1; i
>= 0; i
--)
2955 if (IS_DIR_SEPARATOR (name
[i
]))
2958 for (i
++; i
< len
; i
++)
2962 obstack_grow (&obstack
, name
, len
);
2963 obstack_grow0 (&obstack
, TARGET_EXECUTABLE_SUFFIX
,
2964 strlen (TARGET_EXECUTABLE_SUFFIX
));
2965 name
= XOBFINISH (&obstack
, const char *);
2972 /* Display the command line switches accepted by gcc. */
2976 printf (_("Usage: %s [options] file...\n"), progname
);
2977 fputs (_("Options:\n"), stdout
);
2979 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout
);
2980 fputs (_(" --help Display this information\n"), stdout
);
2981 fputs (_(" --target-help Display target specific command line options\n"), stdout
);
2982 fputs (_(" --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...]\n"), stdout
);
2983 fputs (_(" Display specific types of command line options\n"), stdout
);
2985 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout
);
2986 fputs (_(" --version Display compiler version information\n"), stdout
);
2987 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout
);
2988 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout
);
2989 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout
);
2990 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout
);
2991 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout
);
2992 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout
);
2993 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout
);
2995 -print-multiarch Display the target's normalized GNU triplet, used as\n\
2996 a component in the library path\n"), stdout
);
2997 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout
);
2999 -print-multi-lib Display the mapping between command line options and\n\
3000 multiple library search directories\n"), stdout
);
3001 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries\n"), stdout
);
3002 fputs (_(" -print-sysroot Display the target libraries directory\n"), stdout
);
3003 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n"), stdout
);
3004 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout
);
3005 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout
);
3006 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout
);
3007 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler\n"), stdout
);
3008 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n"), stdout
);
3009 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout
);
3010 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout
);
3011 fputs (_(" -save-temps=<arg> Do not delete intermediate files\n"), stdout
);
3013 -no-canonical-prefixes Do not canonicalize paths when building relative\n\
3014 prefixes to other gcc components\n"), stdout
);
3015 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout
);
3016 fputs (_(" -time Time the execution of each subprocess\n"), stdout
);
3017 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout
);
3018 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout
);
3020 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3021 and libraries\n"), stdout
);
3022 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout
);
3023 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout
);
3024 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout
);
3025 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout
);
3026 fputs (_(" -S Compile only; do not assemble or link\n"), stdout
);
3027 fputs (_(" -c Compile and assemble, but do not link\n"), stdout
);
3028 fputs (_(" -o <file> Place the output into <file>\n"), stdout
);
3029 fputs (_(" -pie Create a position independent executable\n"), stdout
);
3030 fputs (_(" -shared Create a shared library\n"), stdout
);
3032 -x <language> Specify the language of the following input files\n\
3033 Permissible languages include: c c++ assembler none\n\
3034 'none' means revert to the default behavior of\n\
3035 guessing the language based on the file's extension\n\
3039 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3040 passed on to the various sub-processes invoked by %s. In order to pass\n\
3041 other options on to these processes the -W<letter> options must be used.\n\
3044 /* The rest of the options are displayed by invocations of the various
3049 add_preprocessor_option (const char *option
, int len
)
3051 VEC_safe_push (char_p
, heap
, preprocessor_options
,
3052 save_string (option
, len
));
3056 add_assembler_option (const char *option
, int len
)
3058 VEC_safe_push (char_p
, heap
, assembler_options
, save_string (option
, len
));
3062 add_linker_option (const char *option
, int len
)
3064 VEC_safe_push (char_p
, heap
, linker_options
, save_string (option
, len
));
3067 /* Allocate space for an input file in infiles. */
3072 if (n_infiles_alloc
== 0)
3074 n_infiles_alloc
= 16;
3075 infiles
= XNEWVEC (struct infile
, n_infiles_alloc
);
3077 else if (n_infiles_alloc
== n_infiles
)
3079 n_infiles_alloc
*= 2;
3080 infiles
= XRESIZEVEC (struct infile
, infiles
, n_infiles_alloc
);
3084 /* Store an input file with the given NAME and LANGUAGE in
3088 add_infile (const char *name
, const char *language
)
3091 infiles
[n_infiles
].name
= name
;
3092 infiles
[n_infiles
++].language
= language
;
3095 /* Allocate space for a switch in switches. */
3100 if (n_switches_alloc
== 0)
3102 n_switches_alloc
= 16;
3103 switches
= XNEWVEC (struct switchstr
, n_switches_alloc
);
3105 else if (n_switches_alloc
== n_switches
)
3107 n_switches_alloc
*= 2;
3108 switches
= XRESIZEVEC (struct switchstr
, switches
, n_switches_alloc
);
3112 /* Save an option OPT with N_ARGS arguments in array ARGS, marking it
3113 as validated if VALIDATED. */
3116 save_switch (const char *opt
, size_t n_args
, const char *const *args
,
3120 switches
[n_switches
].part1
= opt
+ 1;
3122 switches
[n_switches
].args
= 0;
3125 switches
[n_switches
].args
= XNEWVEC (const char *, n_args
+ 1);
3126 memcpy (switches
[n_switches
].args
, args
, n_args
* sizeof (const char *));
3127 switches
[n_switches
].args
[n_args
] = NULL
;
3130 switches
[n_switches
].live_cond
= 0;
3131 switches
[n_switches
].validated
= validated
;
3132 switches
[n_switches
].ordering
= 0;
3136 /* Handle an option DECODED that is unknown to the option-processing
3140 driver_unknown_option_callback (const struct cl_decoded_option
*decoded
)
3142 const char *opt
= decoded
->arg
;
3143 if (opt
[1] == 'W' && opt
[2] == 'n' && opt
[3] == 'o' && opt
[4] == '-'
3144 && !(decoded
->errors
& CL_ERR_NEGATIVE
))
3146 /* Leave unknown -Wno-* options for the compiler proper, to be
3147 diagnosed only if there are warnings. */
3148 save_switch (decoded
->canonical_option
[0],
3149 decoded
->canonical_option_num_elements
- 1,
3150 &decoded
->canonical_option
[1], false);
3157 /* Handle an option DECODED that is not marked as CL_DRIVER.
3158 LANG_MASK will always be CL_DRIVER. */
3161 driver_wrong_lang_callback (const struct cl_decoded_option
*decoded
,
3162 unsigned int lang_mask ATTRIBUTE_UNUSED
)
3164 /* At this point, non-driver options are accepted (and expected to
3165 be passed down by specs) unless marked to be rejected by the
3166 driver. Options to be rejected by the driver but accepted by the
3167 compilers proper are treated just like completely unknown
3169 const struct cl_option
*option
= &cl_options
[decoded
->opt_index
];
3171 if (option
->cl_reject_driver
)
3172 error ("unrecognized command line option %qs",
3173 decoded
->orig_option_with_args_text
);
3175 save_switch (decoded
->canonical_option
[0],
3176 decoded
->canonical_option_num_elements
- 1,
3177 &decoded
->canonical_option
[1], false);
3180 static const char *spec_lang
= 0;
3181 static int last_language_n_infiles
;
3183 /* Handle a driver option; arguments and return value as for
3187 driver_handle_option (struct gcc_options
*opts
,
3188 struct gcc_options
*opts_set
,
3189 const struct cl_decoded_option
*decoded
,
3190 unsigned int lang_mask ATTRIBUTE_UNUSED
, int kind
,
3192 const struct cl_option_handlers
*handlers ATTRIBUTE_UNUSED
,
3193 diagnostic_context
*dc
)
3195 size_t opt_index
= decoded
->opt_index
;
3196 const char *arg
= decoded
->arg
;
3197 const char *compare_debug_replacement_opt
;
3198 int value
= decoded
->value
;
3199 bool validated
= false;
3200 bool do_save
= true;
3202 gcc_assert (opts
== &global_options
);
3203 gcc_assert (opts_set
== &global_options_set
);
3204 gcc_assert (kind
== DK_UNSPECIFIED
);
3205 gcc_assert (loc
== UNKNOWN_LOCATION
);
3206 gcc_assert (dc
== global_dc
);
3212 struct spec_list
*sl
;
3214 for (sl
= specs
; sl
; sl
= sl
->next
)
3215 printf ("*%s:\n%s\n\n", sl
->name
, *(sl
->ptr_spec
));
3216 if (link_command_spec
)
3217 printf ("*link_command:\n%s\n\n", link_command_spec
);
3221 case OPT_dumpversion
:
3222 printf ("%s\n", spec_version
);
3225 case OPT_dumpmachine
:
3226 printf ("%s\n", spec_machine
);
3232 /* CPP driver cannot obtain switch from cc1_options. */
3234 add_preprocessor_option ("--version", strlen ("--version"));
3235 add_assembler_option ("--version", strlen ("--version"));
3236 add_linker_option ("--version", strlen ("--version"));
3240 print_help_list
= 1;
3242 /* CPP driver cannot obtain switch from cc1_options. */
3244 add_preprocessor_option ("--help", 6);
3245 add_assembler_option ("--help", 6);
3246 add_linker_option ("--help", 6);
3250 print_subprocess_help
= 2;
3253 case OPT__target_help
:
3254 print_subprocess_help
= 1;
3256 /* CPP driver cannot obtain switch from cc1_options. */
3258 add_preprocessor_option ("--target-help", 13);
3259 add_assembler_option ("--target-help", 13);
3260 add_linker_option ("--target-help", 13);
3263 case OPT_pass_exit_codes
:
3264 case OPT_print_search_dirs
:
3265 case OPT_print_file_name_
:
3266 case OPT_print_prog_name_
:
3267 case OPT_print_multi_lib
:
3268 case OPT_print_multi_directory
:
3269 case OPT_print_sysroot
:
3270 case OPT_print_multi_os_directory
:
3271 case OPT_print_multiarch
:
3272 case OPT_print_sysroot_headers_suffix
:
3275 /* These options set the variables specified in common.opt
3276 automatically, and do not need to be saved for spec
3281 case OPT_print_libgcc_file_name
:
3282 print_file_name
= "libgcc.a";
3286 case OPT_fcompare_debug_second
:
3287 compare_debug_second
= 1;
3290 case OPT_fcompare_debug
:
3294 compare_debug_replacement_opt
= "-fcompare-debug=";
3296 goto compare_debug_with_arg
;
3299 compare_debug_replacement_opt
= "-fcompare-debug=-gtoggle";
3301 goto compare_debug_with_arg
;
3308 case OPT_fcompare_debug_
:
3309 compare_debug_replacement_opt
= decoded
->canonical_option
[0];
3310 compare_debug_with_arg
:
3311 gcc_assert (decoded
->canonical_option_num_elements
== 1);
3312 gcc_assert (arg
!= NULL
);
3317 if (compare_debug
< 0)
3318 compare_debug_opt
= NULL
;
3320 compare_debug_opt
= arg
;
3321 save_switch (compare_debug_replacement_opt
, 0, NULL
, validated
);
3327 /* Pass the rest of this option to the assembler. */
3329 /* Split the argument at commas. */
3331 for (j
= 0; arg
[j
]; j
++)
3334 add_assembler_option (arg
+ prev
, j
- prev
);
3338 /* Record the part after the last comma. */
3339 add_assembler_option (arg
+ prev
, j
- prev
);
3347 /* Pass the rest of this option to the preprocessor. */
3349 /* Split the argument at commas. */
3351 for (j
= 0; arg
[j
]; j
++)
3354 add_preprocessor_option (arg
+ prev
, j
- prev
);
3358 /* Record the part after the last comma. */
3359 add_preprocessor_option (arg
+ prev
, j
- prev
);
3367 /* Split the argument at commas. */
3369 for (j
= 0; arg
[j
]; j
++)
3372 add_infile (save_string (arg
+ prev
, j
- prev
), "*");
3375 /* Record the part after the last comma. */
3376 add_infile (arg
+ prev
, "*");
3382 add_infile (arg
, "*");
3386 case OPT_Xpreprocessor
:
3387 add_preprocessor_option (arg
, strlen (arg
));
3391 case OPT_Xassembler
:
3392 add_assembler_option (arg
, strlen (arg
));
3397 /* POSIX allows separation of -l and the lib arg; canonicalize
3398 by concatenating -l with its arg */
3399 add_infile (concat ("-l", arg
, NULL
), "*");
3404 /* Similarly, canonicalize -L for linkers that may not accept
3405 separate arguments. */
3406 save_switch (concat ("-L", arg
, NULL
), 0, NULL
, validated
);
3411 save_switch (concat ("-F", arg
, NULL
), 0, NULL
, validated
);
3414 case OPT_save_temps
:
3415 save_temps_flag
= SAVE_TEMPS_CWD
;
3419 case OPT_save_temps_
:
3420 if (strcmp (arg
, "cwd") == 0)
3421 save_temps_flag
= SAVE_TEMPS_CWD
;
3422 else if (strcmp (arg
, "obj") == 0
3423 || strcmp (arg
, "object") == 0)
3424 save_temps_flag
= SAVE_TEMPS_OBJ
;
3426 fatal_error ("%qs is an unknown -save-temps option",
3427 decoded
->orig_option_with_args_text
);
3430 case OPT_no_canonical_prefixes
:
3431 /* Already handled as a special case, so ignored here. */
3437 /* These options set the variables specified in common.opt
3438 automatically, but do need to be saved for spec
3444 struct user_specs
*user
= XNEW (struct user_specs
);
3446 user
->next
= (struct user_specs
*) 0;
3447 user
->filename
= arg
;
3448 if (user_specs_tail
)
3449 user_specs_tail
->next
= user
;
3451 user_specs_head
= user
;
3452 user_specs_tail
= user
;
3458 target_system_root
= arg
;
3459 target_system_root_changed
= 1;
3464 if (report_times_to_file
)
3465 fclose (report_times_to_file
);
3466 report_times_to_file
= fopen (arg
, "a");
3472 This is similar to -v except that there is no execution
3473 of the commands and the echoed arguments are quoted. It
3474 is intended for use in shell scripts to capture the
3475 driver-generated command line. */
3476 verbose_only_flag
++;
3483 size_t len
= strlen (arg
);
3485 /* Catch the case where the user has forgotten to append a
3486 directory separator to the path. Note, they may be using
3487 -B to add an executable name prefix, eg "i386-elf-", in
3488 order to distinguish between multiple installations of
3489 GCC in the same directory. Hence we must check to see
3490 if appending a directory separator actually makes a
3491 valid directory name. */
3492 if (!IS_DIR_SEPARATOR (arg
[len
- 1])
3493 && is_directory (arg
, false))
3495 char *tmp
= XNEWVEC (char, len
+ 2);
3497 tmp
[len
] = DIR_SEPARATOR
;
3502 add_prefix (&exec_prefixes
, arg
, NULL
,
3503 PREFIX_PRIORITY_B_OPT
, 0, 0);
3504 add_prefix (&startfile_prefixes
, arg
, NULL
,
3505 PREFIX_PRIORITY_B_OPT
, 0, 0);
3506 add_prefix (&include_prefixes
, arg
, NULL
,
3507 PREFIX_PRIORITY_B_OPT
, 0, 0);
3514 if (!strcmp (spec_lang
, "none"))
3515 /* Suppress the warning if -xnone comes after the last input
3516 file, because alternate command interfaces like g++ might
3517 find it useful to place -xnone after each input file. */
3520 last_language_n_infiles
= n_infiles
;
3526 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3527 arg
= convert_filename (arg
, ! have_c
, 0);
3529 /* Save the output name in case -save-temps=obj was used. */
3530 save_temps_prefix
= xstrdup (arg
);
3531 /* On some systems, ld cannot handle "-o" without a space. So
3532 split the option from its argument. */
3533 save_switch ("-o", 1, &arg
, validated
);
3536 case OPT_static_libgcc
:
3537 case OPT_shared_libgcc
:
3538 case OPT_static_libgfortran
:
3539 case OPT_static_libstdc__
:
3540 /* These are always valid, since gcc.c itself understands the
3541 first two, gfortranspec.c understands -static-libgfortran and
3542 g++spec.c understands -static-libstdc++ */
3547 /* Various driver options need no special processing at this
3548 point, having been handled in a prescan above or being
3549 handled by specs. */
3554 save_switch (decoded
->canonical_option
[0],
3555 decoded
->canonical_option_num_elements
- 1,
3556 &decoded
->canonical_option
[1], validated
);
3560 /* Put the driver's standard set of option handlers in *HANDLERS. */
3563 set_option_handlers (struct cl_option_handlers
*handlers
)
3565 handlers
->unknown_option_callback
= driver_unknown_option_callback
;
3566 handlers
->wrong_lang_callback
= driver_wrong_lang_callback
;
3567 handlers
->num_handlers
= 3;
3568 handlers
->handlers
[0].handler
= driver_handle_option
;
3569 handlers
->handlers
[0].mask
= CL_DRIVER
;
3570 handlers
->handlers
[1].handler
= common_handle_option
;
3571 handlers
->handlers
[1].mask
= CL_COMMON
;
3572 handlers
->handlers
[2].handler
= target_handle_option
;
3573 handlers
->handlers
[2].mask
= CL_TARGET
;
3576 /* Create the vector `switches' and its contents.
3577 Store its length in `n_switches'. */
3580 process_command (unsigned int decoded_options_count
,
3581 struct cl_decoded_option
*decoded_options
)
3585 const char *tooldir_prefix
;
3586 char *(*get_relative_prefix
) (const char *, const char *,
3587 const char *) = NULL
;
3588 struct cl_option_handlers handlers
;
3591 gcc_exec_prefix
= getenv ("GCC_EXEC_PREFIX");
3595 added_libraries
= 0;
3597 /* Figure compiler version from version string. */
3599 compiler_version
= temp1
= xstrdup (version_string
);
3601 for (; *temp1
; ++temp1
)
3610 /* Handle any -no-canonical-prefixes flag early, to assign the function
3611 that builds relative prefixes. This function creates default search
3612 paths that are needed later in normal option handling. */
3614 for (j
= 1; j
< decoded_options_count
; j
++)
3616 if (decoded_options
[j
].opt_index
== OPT_no_canonical_prefixes
)
3618 get_relative_prefix
= make_relative_prefix_ignore_links
;
3622 if (! get_relative_prefix
)
3623 get_relative_prefix
= make_relative_prefix
;
3625 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
3626 see if we can create it from the pathname specified in
3627 decoded_options[0].arg. */
3629 gcc_libexec_prefix
= standard_libexec_prefix
;
3631 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
3632 if (!gcc_exec_prefix
)
3634 #if 0 /* Never use relative prefix (not bootstrapped) */
3635 gcc_exec_prefix
= get_relative_prefix (decoded_options
[0].arg
,
3636 standard_bindir_prefix
,
3637 standard_exec_prefix
);
3638 gcc_libexec_prefix
= get_relative_prefix (decoded_options
[0].arg
,
3639 standard_bindir_prefix
,
3640 standard_libexec_prefix
);
3641 if (gcc_exec_prefix
)
3642 xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix
, NULL
));
3647 /* make_relative_prefix requires a program name, but
3648 GCC_EXEC_PREFIX is typically a directory name with a trailing
3649 / (which is ignored by make_relative_prefix), so append a
3651 char *tmp_prefix
= concat (gcc_exec_prefix
, "gcc", NULL
);
3652 gcc_libexec_prefix
= get_relative_prefix (tmp_prefix
,
3653 standard_exec_prefix
,
3654 standard_libexec_prefix
);
3656 /* The path is unrelocated, so fallback to the original setting. */
3657 if (!gcc_libexec_prefix
)
3658 gcc_libexec_prefix
= standard_libexec_prefix
;
3664 /* From this point onward, gcc_exec_prefix is non-null if the toolchain
3665 is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
3666 or an automatically created GCC_EXEC_PREFIX from
3667 decoded_options[0].arg. */
3669 /* Do language-specific adjustment/addition of flags. */
3670 lang_specific_driver (&decoded_options
, &decoded_options_count
,
3673 if (gcc_exec_prefix
)
3675 int len
= strlen (gcc_exec_prefix
);
3677 if (len
> (int) sizeof ("/lib/gcc/") - 1
3678 && (IS_DIR_SEPARATOR (gcc_exec_prefix
[len
-1])))
3680 temp
= gcc_exec_prefix
+ len
- sizeof ("/lib/gcc/") + 1;
3681 if (IS_DIR_SEPARATOR (*temp
)
3682 && filename_ncmp (temp
+ 1, "lib", 3) == 0
3683 && IS_DIR_SEPARATOR (temp
[4])
3684 && filename_ncmp (temp
+ 5, "gcc", 3) == 0)
3685 len
-= sizeof ("/lib/gcc/") - 1;
3688 #if 0 /* Bad Paths */
3689 set_std_prefix (gcc_exec_prefix
, len
);
3690 add_prefix (&exec_prefixes
, gcc_libexec_prefix
, "GCC",
3691 PREFIX_PRIORITY_LAST
, 0, 0);
3692 add_prefix (&startfile_prefixes
, gcc_exec_prefix
, "GCC",
3693 PREFIX_PRIORITY_LAST
, 0, 0);
3697 /* COMPILER_PATH and LIBRARY_PATH have values
3698 that are lists of directory names with colons. */
3700 temp
= getenv ("COMPILER_PATH");
3703 const char *startp
, *endp
;
3704 char *nstore
= (char *) alloca (strlen (temp
) + 3);
3706 startp
= endp
= temp
;
3709 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
3711 strncpy (nstore
, startp
, endp
- startp
);
3713 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
3714 else if (!IS_DIR_SEPARATOR (endp
[-1]))
3716 nstore
[endp
- startp
] = DIR_SEPARATOR
;
3717 nstore
[endp
- startp
+ 1] = 0;
3720 nstore
[endp
- startp
] = 0;
3721 add_prefix (&exec_prefixes
, nstore
, 0,
3722 PREFIX_PRIORITY_LAST
, 0, 0);
3723 add_prefix (&include_prefixes
, nstore
, 0,
3724 PREFIX_PRIORITY_LAST
, 0, 0);
3727 endp
= startp
= endp
+ 1;
3734 temp
= getenv (LIBRARY_PATH_ENV
);
3735 if (temp
&& *cross_compile
== '0')
3737 const char *startp
, *endp
;
3738 char *nstore
= (char *) alloca (strlen (temp
) + 3);
3740 startp
= endp
= temp
;
3743 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
3745 strncpy (nstore
, startp
, endp
- startp
);
3747 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
3748 else if (!IS_DIR_SEPARATOR (endp
[-1]))
3750 nstore
[endp
- startp
] = DIR_SEPARATOR
;
3751 nstore
[endp
- startp
+ 1] = 0;
3754 nstore
[endp
- startp
] = 0;
3755 add_prefix (&startfile_prefixes
, nstore
, NULL
,
3756 PREFIX_PRIORITY_LAST
, 0, 1);
3759 endp
= startp
= endp
+ 1;
3766 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
3767 temp
= getenv ("LPATH");
3768 if (temp
&& *cross_compile
== '0')
3770 const char *startp
, *endp
;
3771 char *nstore
= (char *) alloca (strlen (temp
) + 3);
3773 startp
= endp
= temp
;
3776 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
3778 strncpy (nstore
, startp
, endp
- startp
);
3780 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
3781 else if (!IS_DIR_SEPARATOR (endp
[-1]))
3783 nstore
[endp
- startp
] = DIR_SEPARATOR
;
3784 nstore
[endp
- startp
+ 1] = 0;
3787 nstore
[endp
- startp
] = 0;
3788 add_prefix (&startfile_prefixes
, nstore
, NULL
,
3789 PREFIX_PRIORITY_LAST
, 0, 1);
3792 endp
= startp
= endp
+ 1;
3799 /* Process the options and store input files and switches in their
3802 last_language_n_infiles
= -1;
3804 set_option_handlers (&handlers
);
3806 for (j
= 1; j
< decoded_options_count
; j
++)
3808 switch (decoded_options
[j
].opt_index
)
3820 for (j
= 1; j
< decoded_options_count
; j
++)
3822 if (decoded_options
[j
].opt_index
== OPT_SPECIAL_input_file
)
3824 const char *arg
= decoded_options
[j
].arg
;
3825 const char *p
= strrchr (arg
, '@');
3829 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3830 arg
= convert_filename (arg
, 0, access (arg
, F_OK
));
3832 /* For LTO static archive support we handle input file
3833 specifications that are composed of a filename and
3834 an offset like FNAME@OFFSET. */
3837 && sscanf (p
, "@%li%n", &offset
, &consumed
) >= 1
3838 && strlen (p
) == (unsigned int)consumed
)
3840 fname
= (char *)xmalloc (p
- arg
+ 1);
3841 memcpy (fname
, arg
, p
- arg
);
3842 fname
[p
- arg
] = '\0';
3843 /* Only accept non-stdin and existing FNAME parts, otherwise
3844 try with the full name. */
3845 if (strcmp (fname
, "-") == 0 || access (fname
, F_OK
) < 0)
3848 fname
= xstrdup (arg
);
3852 fname
= xstrdup (arg
);
3854 if (strcmp (fname
, "-") != 0 && access (fname
, F_OK
) < 0)
3855 perror_with_name (fname
);
3857 add_infile (arg
, spec_lang
);
3863 read_cmdline_option (&global_options
, &global_options_set
,
3864 decoded_options
+ j
, UNKNOWN_LOCATION
,
3865 CL_DRIVER
, &handlers
, global_dc
);
3868 /* If -save-temps=obj and -o name, create the prefix to use for %b.
3869 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
3870 if (save_temps_flag
== SAVE_TEMPS_OBJ
&& save_temps_prefix
!= NULL
)
3872 save_temps_length
= strlen (save_temps_prefix
);
3873 temp
= strrchr (lbasename (save_temps_prefix
), '.');
3876 save_temps_length
-= strlen (temp
);
3877 save_temps_prefix
[save_temps_length
] = '\0';
3881 else if (save_temps_prefix
!= NULL
)
3883 free (save_temps_prefix
);
3884 save_temps_prefix
= NULL
;
3887 if (save_temps_flag
&& use_pipes
)
3889 /* -save-temps overrides -pipe, so that temp files are produced */
3890 if (save_temps_flag
)
3891 warning (0, "-pipe ignored because -save-temps specified");
3897 const char *gcd
= getenv ("GCC_COMPARE_DEBUG");
3899 if (gcd
&& gcd
[0] == '-')
3902 compare_debug_opt
= gcd
;
3904 else if (gcd
&& *gcd
&& strcmp (gcd
, "0"))
3907 compare_debug_opt
= "-gtoggle";
3910 else if (compare_debug
< 0)
3913 gcc_assert (!compare_debug_opt
);
3916 /* Set up the search paths. We add directories that we expect to
3917 contain GNU Toolchain components before directories specified by
3918 the machine description so that we will find GNU components (like
3919 the GNU assembler) before those of the host system. */
3921 /* If we don't know where the toolchain has been installed, use the
3922 configured-in locations. */
3923 if (!gcc_exec_prefix
)
3926 add_prefix (&exec_prefixes
, standard_libexec_prefix
, NULL
,
3927 PREFIX_PRIORITY_LAST
, 0, 0);
3928 #if 0 /* Bad paths */
3929 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "GCC",
3930 PREFIX_PRIORITY_LAST
, 1, 0);
3931 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "BINUTILS",
3932 PREFIX_PRIORITY_LAST
, 2, 0);
3933 add_prefix (&exec_prefixes
, standard_exec_prefix
, "BINUTILS",
3934 PREFIX_PRIORITY_LAST
, 2, 0);
3937 #if 0 /* Bad paths */
3938 add_prefix (&startfile_prefixes
, standard_exec_prefix
, "BINUTILS",
3939 PREFIX_PRIORITY_LAST
, 1, 0);
3943 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix
));
3944 tooldir_prefix
= concat (tooldir_base_prefix
, spec_machine
,
3945 dir_separator_str
, NULL
);
3947 /* Look for tools relative to the location from which the driver is
3948 running, or, if that is not available, the configured prefix. */
3950 = concat (gcc_exec_prefix
? gcc_exec_prefix
: standard_exec_prefix
,
3951 spec_machine
, dir_separator_str
,
3952 spec_version
, dir_separator_str
, tooldir_prefix
, NULL
);
3954 #if 0 /* Bad paths */
3955 add_prefix (&exec_prefixes
,
3956 concat (tooldir_prefix
, "bin", dir_separator_str
, NULL
),
3957 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 0);
3958 add_prefix (&startfile_prefixes
,
3959 concat (tooldir_prefix
, "lib", dir_separator_str
, NULL
),
3960 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 1);
3963 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
3964 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
3965 then consider it to relocate with the rest of the GCC installation
3966 if GCC_EXEC_PREFIX is set.
3967 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
3968 if (target_system_root
&& !target_system_root_changed
&& gcc_exec_prefix
)
3970 char *tmp_prefix
= get_relative_prefix (decoded_options
[0].arg
,
3971 standard_bindir_prefix
,
3972 target_system_root
);
3973 if (tmp_prefix
&& access_check (tmp_prefix
, F_OK
) == 0)
3975 target_system_root
= tmp_prefix
;
3976 target_system_root_changed
= 1;
3981 /* More prefixes are enabled in main, after we read the specs file
3982 and determine whether this is cross-compilation or not. */
3984 if (n_infiles
== last_language_n_infiles
&& spec_lang
!= 0)
3985 warning (0, "%<-x %s%> after last input file has no effect", spec_lang
);
3987 if (compare_debug
== 2 || compare_debug
== 3)
3990 switches
[n_switches
].part1
= concat ("fcompare-debug=",
3993 switches
[n_switches
].args
= 0;
3994 switches
[n_switches
].live_cond
= 0;
3995 switches
[n_switches
].validated
= 0;
3996 switches
[n_switches
].ordering
= 0;
4001 /* Ensure we only invoke each subprocess once. */
4002 if (print_subprocess_help
|| print_help_list
|| print_version
)
4006 /* Create a dummy input file, so that we can pass
4007 the help option on to the various sub-processes. */
4008 add_infile ("help-dummy", "c");
4012 switches
[n_switches
].part1
= 0;
4014 infiles
[n_infiles
].name
= 0;
4017 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4018 and place that in the environment. */
4021 set_collect_gcc_options (void)
4026 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4028 obstack_grow (&collect_obstack
, "COLLECT_GCC_OPTIONS=",
4029 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4032 for (i
= 0; (int) i
< n_switches
; i
++)
4034 const char *const *args
;
4037 obstack_grow (&collect_obstack
, " ", 1);
4041 /* Ignore elided switches. */
4042 if ((switches
[i
].live_cond
4043 & (SWITCH_IGNORE
| SWITCH_KEEP_FOR_GCC
))
4047 obstack_grow (&collect_obstack
, "'-", 2);
4048 q
= switches
[i
].part1
;
4049 while ((p
= strchr (q
, '\'')))
4051 obstack_grow (&collect_obstack
, q
, p
- q
);
4052 obstack_grow (&collect_obstack
, "'\\''", 4);
4055 obstack_grow (&collect_obstack
, q
, strlen (q
));
4056 obstack_grow (&collect_obstack
, "'", 1);
4058 for (args
= switches
[i
].args
; args
&& *args
; args
++)
4060 obstack_grow (&collect_obstack
, " '", 2);
4062 while ((p
= strchr (q
, '\'')))
4064 obstack_grow (&collect_obstack
, q
, p
- q
);
4065 obstack_grow (&collect_obstack
, "'\\''", 4);
4068 obstack_grow (&collect_obstack
, q
, strlen (q
));
4069 obstack_grow (&collect_obstack
, "'", 1);
4072 obstack_grow (&collect_obstack
, "\0", 1);
4073 xputenv (XOBFINISH (&collect_obstack
, char *));
4076 /* Process a spec string, accumulating and running commands. */
4078 /* These variables describe the input file name.
4079 input_file_number is the index on outfiles of this file,
4080 so that the output file name can be stored for later use by %o.
4081 input_basename is the start of the part of the input file
4082 sans all directory names, and basename_length is the number
4083 of characters starting there excluding the suffix .c or whatever. */
4085 static const char *gcc_input_filename
;
4086 static int input_file_number
;
4087 size_t input_filename_length
;
4088 static int basename_length
;
4089 static int suffixed_basename_length
;
4090 static const char *input_basename
;
4091 static const char *input_suffix
;
4092 #ifndef HOST_LACKS_INODE_NUMBERS
4093 static struct stat input_stat
;
4095 static int input_stat_set
;
4097 /* The compiler used to process the current input file. */
4098 static struct compiler
*input_file_compiler
;
4100 /* These are variables used within do_spec and do_spec_1. */
4102 /* Nonzero if an arg has been started and not yet terminated
4103 (with space, tab or newline). */
4104 static int arg_going
;
4106 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4107 is a temporary file name. */
4108 static int delete_this_arg
;
4110 /* Nonzero means %w has been seen; the next arg to be terminated
4111 is the output file name of this compilation. */
4112 static int this_is_output_file
;
4114 /* Nonzero means %s has been seen; the next arg to be terminated
4115 is the name of a library file and we should try the standard
4116 search dirs for it. */
4117 static int this_is_library_file
;
4119 /* Nonzero means %T has been seen; the next arg to be terminated
4120 is the name of a linker script and we should try all of the
4121 standard search dirs for it. If it is found insert a --script
4122 command line switch and then substitute the full path in place,
4123 otherwise generate an error message. */
4124 static int this_is_linker_script
;
4126 /* Nonzero means that the input of this command is coming from a pipe. */
4127 static int input_from_pipe
;
4129 /* Nonnull means substitute this for any suffix when outputting a switches
4131 static const char *suffix_subst
;
4133 /* If there is an argument being accumulated, terminate it and store it. */
4136 end_going_arg (void)
4142 obstack_1grow (&obstack
, 0);
4143 string
= XOBFINISH (&obstack
, const char *);
4144 if (this_is_library_file
)
4145 string
= find_file (string
);
4146 if (this_is_linker_script
)
4148 char * full_script_path
= find_a_file (&startfile_prefixes
, string
, R_OK
, true);
4150 if (full_script_path
== NULL
)
4152 error ("unable to locate default linker script %qs in the library search paths", string
);
4153 /* Script was not found on search path. */
4156 store_arg ("--script", false, false);
4157 string
= full_script_path
;
4159 store_arg (string
, delete_this_arg
, this_is_output_file
);
4160 if (this_is_output_file
)
4161 outfiles
[input_file_number
] = string
;
4167 /* Parse the WRAPPER string which is a comma separated list of the command line
4168 and insert them into the beginning of argbuf. */
4171 insert_wrapper (const char *wrapper
)
4175 char *buf
= xstrdup (wrapper
);
4177 unsigned int old_length
= VEC_length (const_char_p
, argbuf
);
4185 while ((p
= strchr (p
, ',')) != NULL
);
4187 VEC_safe_grow (const_char_p
, heap
, argbuf
, old_length
+ n
);
4188 memmove (VEC_address (const_char_p
, argbuf
) + n
,
4189 VEC_address (const_char_p
, argbuf
),
4190 old_length
* sizeof (const_char_p
));
4201 VEC_replace (const_char_p
, argbuf
, i
, p
);
4204 while ((p
= strchr (p
, ',')) != NULL
);
4205 gcc_assert (i
== n
);
4208 /* Process the spec SPEC and run the commands specified therein.
4209 Returns 0 if the spec is successfully processed; -1 if failed. */
4212 do_spec (const char *spec
)
4216 value
= do_spec_2 (spec
);
4218 /* Force out any unfinished command.
4219 If -pipe, this forces out the last command if it ended in `|'. */
4222 if (VEC_length (const_char_p
, argbuf
) > 0
4223 && !strcmp (VEC_last (const_char_p
, argbuf
), "|"))
4224 VEC_pop (const_char_p
, argbuf
);
4226 set_collect_gcc_options ();
4228 if (VEC_length (const_char_p
, argbuf
) > 0)
4236 do_spec_2 (const char *spec
)
4242 delete_this_arg
= 0;
4243 this_is_output_file
= 0;
4244 this_is_library_file
= 0;
4245 this_is_linker_script
= 0;
4246 input_from_pipe
= 0;
4247 suffix_subst
= NULL
;
4249 result
= do_spec_1 (spec
, 0, NULL
);
4257 /* Process the given spec string and add any new options to the end
4258 of the switches/n_switches array. */
4261 do_option_spec (const char *name
, const char *spec
)
4263 unsigned int i
, value_count
, value_len
;
4264 const char *p
, *q
, *value
;
4265 char *tmp_spec
, *tmp_spec_p
;
4267 if (configure_default_options
[0].name
== NULL
)
4270 for (i
= 0; i
< ARRAY_SIZE (configure_default_options
); i
++)
4271 if (strcmp (configure_default_options
[i
].name
, name
) == 0)
4273 if (i
== ARRAY_SIZE (configure_default_options
))
4276 value
= configure_default_options
[i
].value
;
4277 value_len
= strlen (value
);
4279 /* Compute the size of the final spec. */
4282 while ((p
= strstr (p
, "%(VALUE)")) != NULL
)
4288 /* Replace each %(VALUE) by the specified value. */
4289 tmp_spec
= (char *) alloca (strlen (spec
) + 1
4290 + value_count
* (value_len
- strlen ("%(VALUE)")));
4291 tmp_spec_p
= tmp_spec
;
4293 while ((p
= strstr (q
, "%(VALUE)")) != NULL
)
4295 memcpy (tmp_spec_p
, q
, p
- q
);
4296 tmp_spec_p
= tmp_spec_p
+ (p
- q
);
4297 memcpy (tmp_spec_p
, value
, value_len
);
4298 tmp_spec_p
+= value_len
;
4299 q
= p
+ strlen ("%(VALUE)");
4301 strcpy (tmp_spec_p
, q
);
4303 do_self_spec (tmp_spec
);
4306 /* Process the given spec string and add any new options to the end
4307 of the switches/n_switches array. */
4310 do_self_spec (const char *spec
)
4315 do_spec_1 (" ", 0, NULL
);
4317 /* Mark %<S switches processed by do_self_spec to be ignored permanently.
4318 do_self_specs adds the replacements to switches array, so it shouldn't
4319 be processed afterwards. */
4320 for (i
= 0; i
< n_switches
; i
++)
4321 if ((switches
[i
].live_cond
& SWITCH_IGNORE
))
4322 switches
[i
].live_cond
|= SWITCH_IGNORE_PERMANENTLY
;
4324 if (VEC_length (const_char_p
, argbuf
) > 0)
4326 const char **argbuf_copy
;
4327 struct cl_decoded_option
*decoded_options
;
4328 struct cl_option_handlers handlers
;
4329 unsigned int decoded_options_count
;
4332 /* Create a copy of argbuf with a dummy argv[0] entry for
4333 decode_cmdline_options_to_array. */
4334 argbuf_copy
= XNEWVEC (const char *,
4335 VEC_length (const_char_p
, argbuf
) + 1);
4336 argbuf_copy
[0] = "";
4337 memcpy (argbuf_copy
+ 1, VEC_address (const_char_p
, argbuf
),
4338 VEC_length (const_char_p
, argbuf
) * sizeof (const char *));
4340 decode_cmdline_options_to_array (VEC_length (const_char_p
, argbuf
) + 1,
4342 CL_DRIVER
, &decoded_options
,
4343 &decoded_options_count
);
4345 set_option_handlers (&handlers
);
4347 for (j
= 1; j
< decoded_options_count
; j
++)
4349 switch (decoded_options
[j
].opt_index
)
4351 case OPT_SPECIAL_input_file
:
4352 /* Specs should only generate options, not input
4354 if (strcmp (decoded_options
[j
].arg
, "-") != 0)
4355 fatal_error ("switch %qs does not start with %<-%>",
4356 decoded_options
[j
].arg
);
4358 fatal_error ("spec-generated switch is just %<-%>");
4361 case OPT_fcompare_debug_second
:
4362 case OPT_fcompare_debug
:
4363 case OPT_fcompare_debug_
:
4365 /* Avoid duplicate processing of some options from
4366 compare-debug specs; just save them here. */
4367 save_switch (decoded_options
[j
].canonical_option
[0],
4368 (decoded_options
[j
].canonical_option_num_elements
4370 &decoded_options
[j
].canonical_option
[1], false);
4374 read_cmdline_option (&global_options
, &global_options_set
,
4375 decoded_options
+ j
, UNKNOWN_LOCATION
,
4376 CL_DRIVER
, &handlers
, global_dc
);
4382 switches
[n_switches
].part1
= 0;
4386 /* Callback for processing %D and %I specs. */
4388 struct spec_path_info
{
4393 bool separate_options
;
4397 spec_path (char *path
, void *data
)
4399 struct spec_path_info
*info
= (struct spec_path_info
*) data
;
4403 if (info
->omit_relative
&& !IS_ABSOLUTE_PATH (path
))
4406 if (info
->append_len
!= 0)
4408 len
= strlen (path
);
4409 memcpy (path
+ len
, info
->append
, info
->append_len
+ 1);
4412 if (!is_directory (path
, true))
4415 do_spec_1 (info
->option
, 1, NULL
);
4416 if (info
->separate_options
)
4417 do_spec_1 (" ", 0, NULL
);
4419 if (info
->append_len
== 0)
4421 len
= strlen (path
);
4422 save
= path
[len
- 1];
4423 if (IS_DIR_SEPARATOR (path
[len
- 1]))
4424 path
[len
- 1] = '\0';
4427 do_spec_1 (path
, 1, NULL
);
4428 do_spec_1 (" ", 0, NULL
);
4430 /* Must not damage the original path. */
4431 if (info
->append_len
== 0)
4432 path
[len
- 1] = save
;
4437 /* Create a temporary FILE with the contents of ARGV. Add @FILE to the
4441 create_at_file (char **argv
)
4443 char *temp_file
= make_temp_file ("");
4444 char *at_argument
= concat ("@", temp_file
, NULL
);
4445 FILE *f
= fopen (temp_file
, "w");
4449 fatal_error ("could not open temporary response file %s",
4452 status
= writeargv (argv
, f
);
4455 fatal_error ("could not write to temporary response file %s",
4458 status
= fclose (f
);
4461 fatal_error ("could not close temporary response file %s",
4464 store_arg (at_argument
, 0, 0);
4466 record_temp_file (temp_file
, !save_temps_flag
, !save_temps_flag
);
4469 /* True if we should compile INFILE. */
4472 compile_input_file_p (struct infile
*infile
)
4474 if ((!infile
->language
) || (infile
->language
[0] != '*'))
4475 if (infile
->incompiler
== input_file_compiler
)
4480 /* Process each member of VEC as a spec. */
4483 do_specs_vec (VEC(char_p
,heap
) *vec
)
4488 FOR_EACH_VEC_ELT (char_p
, vec
, ix
, opt
)
4490 do_spec_1 (opt
, 1, NULL
);
4491 /* Make each accumulated option a separate argument. */
4492 do_spec_1 (" ", 0, NULL
);
4496 /* Process the sub-spec SPEC as a portion of a larger spec.
4497 This is like processing a whole spec except that we do
4498 not initialize at the beginning and we do not supply a
4499 newline by default at the end.
4500 INSWITCH nonzero means don't process %-sequences in SPEC;
4501 in this case, % is treated as an ordinary character.
4502 This is used while substituting switches.
4503 INSWITCH nonzero also causes SPC not to terminate an argument.
4505 Value is zero unless a line was finished
4506 and the command on that line reported an error. */
4509 do_spec_1 (const char *spec
, int inswitch
, const char *soft_matched_part
)
4511 const char *p
= spec
;
4516 /* If it's an empty string argument to a switch, keep it as is. */
4517 if (inswitch
&& !*p
)
4521 /* If substituting a switch, treat all chars like letters.
4522 Otherwise, NL, SPC, TAB and % are special. */
4523 switch (inswitch
? 'a' : c
)
4528 if (VEC_length (const_char_p
, argbuf
) > 0
4529 && !strcmp (VEC_last (const_char_p
, argbuf
), "|"))
4531 /* A `|' before the newline means use a pipe here,
4532 but only if -pipe was specified.
4533 Otherwise, execute now and don't pass the `|' as an arg. */
4536 input_from_pipe
= 1;
4540 VEC_pop (const_char_p
, argbuf
);
4543 set_collect_gcc_options ();
4545 if (VEC_length (const_char_p
, argbuf
) > 0)
4551 /* Reinitialize for a new command, and for a new argument. */
4554 delete_this_arg
= 0;
4555 this_is_output_file
= 0;
4556 this_is_library_file
= 0;
4557 this_is_linker_script
= 0;
4558 input_from_pipe
= 0;
4565 obstack_1grow (&obstack
, c
);
4573 /* Reinitialize for a new argument. */
4574 delete_this_arg
= 0;
4575 this_is_output_file
= 0;
4576 this_is_library_file
= 0;
4577 this_is_linker_script
= 0;
4584 fatal_error ("spec %qs invalid", spec
);
4587 if (save_temps_length
)
4588 obstack_grow (&obstack
, save_temps_prefix
, save_temps_length
);
4590 obstack_grow (&obstack
, input_basename
, basename_length
);
4591 if (compare_debug
< 0)
4592 obstack_grow (&obstack
, ".gk", 3);
4597 if (save_temps_length
)
4598 obstack_grow (&obstack
, save_temps_prefix
, save_temps_length
);
4600 obstack_grow (&obstack
, input_basename
, suffixed_basename_length
);
4601 if (compare_debug
< 0)
4602 obstack_grow (&obstack
, ".gk", 3);
4607 delete_this_arg
= 2;
4610 /* Dump out the directories specified with LIBRARY_PATH,
4611 followed by the absolute directories
4612 that we search for startfiles. */
4615 struct spec_path_info info
;
4618 info
.append_len
= 0;
4619 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
4620 /* Used on systems which record the specified -L dirs
4621 and use them to search for dynamic linking.
4622 Relative directories always come from -B,
4623 and it is better not to use them for searching
4624 at run time. In particular, stage1 loses. */
4625 info
.omit_relative
= true;
4627 info
.omit_relative
= false;
4629 info
.separate_options
= false;
4631 for_each_path (&startfile_prefixes
, true, 0, spec_path
, &info
);
4636 /* %efoo means report an error with `foo' as error message
4637 and don't execute any more commands for this file. */
4641 while (*p
!= 0 && *p
!= '\n')
4643 buf
= (char *) alloca (p
- q
+ 1);
4644 strncpy (buf
, q
, p
- q
);
4646 error ("%s", _(buf
));
4651 /* %nfoo means report a notice with `foo' on stderr. */
4655 while (*p
!= 0 && *p
!= '\n')
4657 buf
= (char *) alloca (p
- q
+ 1);
4658 strncpy (buf
, q
, p
- q
);
4660 inform (0, "%s", _(buf
));
4670 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
4671 defined, and it is not a directory, and it is
4672 writable, use it. Otherwise, treat this like any
4673 other temporary file. */
4675 if ((!save_temps_flag
)
4676 && (stat (HOST_BIT_BUCKET
, &st
) == 0) && (!S_ISDIR (st
.st_mode
))
4677 && (access (HOST_BIT_BUCKET
, W_OK
) == 0))
4679 obstack_grow (&obstack
, HOST_BIT_BUCKET
,
4680 strlen (HOST_BIT_BUCKET
));
4681 delete_this_arg
= 0;
4686 goto create_temp_file
;
4690 obstack_1grow (&obstack
, '-');
4691 delete_this_arg
= 0;
4694 /* consume suffix */
4695 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
4697 if (p
[0] == '%' && p
[1] == 'O')
4702 goto create_temp_file
;
4706 /* consume suffix */
4707 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
4709 if (p
[0] == '%' && p
[1] == 'O')
4714 goto create_temp_file
;
4720 struct temp_name
*t
;
4722 const char *suffix
= p
;
4723 char *saved_suffix
= NULL
;
4725 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
4727 suffix_length
= p
- suffix
;
4728 if (p
[0] == '%' && p
[1] == 'O')
4731 /* We don't support extra suffix characters after %O. */
4732 if (*p
== '.' || ISALNUM ((unsigned char) *p
))
4733 fatal_error ("spec %qs has invalid %<%%0%c%>", spec
, *p
);
4734 if (suffix_length
== 0)
4735 suffix
= TARGET_OBJECT_SUFFIX
;
4739 = XNEWVEC (char, suffix_length
4740 + strlen (TARGET_OBJECT_SUFFIX
));
4741 strncpy (saved_suffix
, suffix
, suffix_length
);
4742 strcpy (saved_suffix
+ suffix_length
,
4743 TARGET_OBJECT_SUFFIX
);
4745 suffix_length
+= strlen (TARGET_OBJECT_SUFFIX
);
4748 if (compare_debug
< 0)
4750 suffix
= concat (".gk", suffix
, NULL
);
4754 /* If -save-temps=obj and -o were specified, use that for the
4756 if (save_temps_length
)
4759 temp_filename_length
4760 = save_temps_length
+ suffix_length
+ 1;
4761 tmp
= (char *) alloca (temp_filename_length
);
4762 memcpy (tmp
, save_temps_prefix
, save_temps_length
);
4763 memcpy (tmp
+ save_temps_length
, suffix
, suffix_length
);
4764 tmp
[save_temps_length
+ suffix_length
] = '\0';
4765 temp_filename
= save_string (tmp
,
4766 temp_filename_length
+ 1);
4767 obstack_grow (&obstack
, temp_filename
,
4768 temp_filename_length
);
4770 delete_this_arg
= 0;
4774 /* If the gcc_input_filename has the same suffix specified
4775 for the %g, %u, or %U, and -save-temps is specified,
4776 we could end up using that file as an intermediate
4777 thus clobbering the user's source file (.e.g.,
4778 gcc -save-temps foo.s would clobber foo.s with the
4779 output of cpp0). So check for this condition and
4780 generate a temp file as the intermediate. */
4782 if (save_temps_flag
)
4785 temp_filename_length
= basename_length
+ suffix_length
+ 1;
4786 tmp
= (char *) alloca (temp_filename_length
);
4787 memcpy (tmp
, input_basename
, basename_length
);
4788 memcpy (tmp
+ basename_length
, suffix
, suffix_length
);
4789 tmp
[basename_length
+ suffix_length
] = '\0';
4790 temp_filename
= tmp
;
4792 if (filename_cmp (temp_filename
, gcc_input_filename
) != 0)
4794 #ifndef HOST_LACKS_INODE_NUMBERS
4795 struct stat st_temp
;
4797 /* Note, set_input() resets input_stat_set to 0. */
4798 if (input_stat_set
== 0)
4800 input_stat_set
= stat (gcc_input_filename
,
4802 if (input_stat_set
>= 0)
4806 /* If we have the stat for the gcc_input_filename
4807 and we can do the stat for the temp_filename
4808 then the they could still refer to the same
4809 file if st_dev/st_ino's are the same. */
4810 if (input_stat_set
!= 1
4811 || stat (temp_filename
, &st_temp
) < 0
4812 || input_stat
.st_dev
!= st_temp
.st_dev
4813 || input_stat
.st_ino
!= st_temp
.st_ino
)
4815 /* Just compare canonical pathnames. */
4816 char* input_realname
= lrealpath (gcc_input_filename
);
4817 char* temp_realname
= lrealpath (temp_filename
);
4818 bool files_differ
= filename_cmp (input_realname
, temp_realname
);
4819 free (input_realname
);
4820 free (temp_realname
);
4824 temp_filename
= save_string (temp_filename
,
4825 temp_filename_length
+ 1);
4826 obstack_grow (&obstack
, temp_filename
,
4827 temp_filename_length
);
4829 delete_this_arg
= 0;
4835 /* See if we already have an association of %g/%u/%U and
4837 for (t
= temp_names
; t
; t
= t
->next
)
4838 if (t
->length
== suffix_length
4839 && strncmp (t
->suffix
, suffix
, suffix_length
) == 0
4840 && t
->unique
== (c
== 'u' || c
== 'U' || c
== 'j'))
4843 /* Make a new association if needed. %u and %j
4845 if (t
== 0 || c
== 'u' || c
== 'j')
4849 t
= XNEW (struct temp_name
);
4850 t
->next
= temp_names
;
4853 t
->length
= suffix_length
;
4856 t
->suffix
= saved_suffix
;
4857 saved_suffix
= NULL
;
4860 t
->suffix
= save_string (suffix
, suffix_length
);
4861 t
->unique
= (c
== 'u' || c
== 'U' || c
== 'j');
4862 temp_filename
= make_temp_file (t
->suffix
);
4863 temp_filename_length
= strlen (temp_filename
);
4864 t
->filename
= temp_filename
;
4865 t
->filename_length
= temp_filename_length
;
4868 free (saved_suffix
);
4870 obstack_grow (&obstack
, t
->filename
, t
->filename_length
);
4871 delete_this_arg
= 1;
4879 if (at_file_supplied
)
4881 /* We are going to expand `%i' to `@FILE', where FILE
4882 is a newly-created temporary filename. The filenames
4883 that would usually be expanded in place of %o will be
4884 written to the temporary file. */
4889 for (i
= 0; i
< n_infiles
; i
++)
4890 if (compile_input_file_p (&infiles
[i
]))
4893 argv
= (char **) alloca (sizeof (char *) * (n_files
+ 1));
4895 /* Copy the strings over. */
4896 for (i
= 0, j
= 0; i
< n_infiles
; i
++)
4897 if (compile_input_file_p (&infiles
[i
]))
4899 argv
[j
] = CONST_CAST (char *, infiles
[i
].name
);
4900 infiles
[i
].compiled
= true;
4905 create_at_file (argv
);
4908 for (i
= 0; (int) i
< n_infiles
; i
++)
4909 if (compile_input_file_p (&infiles
[i
]))
4911 store_arg (infiles
[i
].name
, 0, 0);
4912 infiles
[i
].compiled
= true;
4917 obstack_grow (&obstack
, gcc_input_filename
,
4918 input_filename_length
);
4925 struct spec_path_info info
;
4929 do_spec_1 ("-imultilib", 1, NULL
);
4930 /* Make this a separate argument. */
4931 do_spec_1 (" ", 0, NULL
);
4932 do_spec_1 (multilib_dir
, 1, NULL
);
4933 do_spec_1 (" ", 0, NULL
);
4938 do_spec_1 ("-imultiarch", 1, NULL
);
4939 /* Make this a separate argument. */
4940 do_spec_1 (" ", 0, NULL
);
4941 do_spec_1 (multiarch_dir
, 1, NULL
);
4942 do_spec_1 (" ", 0, NULL
);
4945 if (gcc_exec_prefix
)
4947 do_spec_1 ("-iprefix", 1, NULL
);
4948 /* Make this a separate argument. */
4949 do_spec_1 (" ", 0, NULL
);
4950 do_spec_1 (gcc_exec_prefix
, 1, NULL
);
4951 do_spec_1 (" ", 0, NULL
);
4954 if (target_system_root_changed
||
4955 (target_system_root
&& target_sysroot_hdrs_suffix
))
4957 do_spec_1 ("-isysroot", 1, NULL
);
4958 /* Make this a separate argument. */
4959 do_spec_1 (" ", 0, NULL
);
4960 do_spec_1 (target_system_root
, 1, NULL
);
4961 if (target_sysroot_hdrs_suffix
)
4962 do_spec_1 (target_sysroot_hdrs_suffix
, 1, NULL
);
4963 do_spec_1 (" ", 0, NULL
);
4966 info
.option
= "-isystem";
4967 info
.append
= "include";
4968 info
.append_len
= strlen (info
.append
);
4969 info
.omit_relative
= false;
4970 info
.separate_options
= true;
4972 for_each_path (&include_prefixes
, false, info
.append_len
,
4975 info
.append
= "include-fixed";
4976 if (*sysroot_hdrs_suffix_spec
)
4977 info
.append
= concat (info
.append
, dir_separator_str
,
4978 multilib_dir
, NULL
);
4979 info
.append_len
= strlen (info
.append
);
4980 for_each_path (&include_prefixes
, false, info
.append_len
,
4987 int max
= n_infiles
;
4988 max
+= lang_specific_extra_outfiles
;
4990 if (HAVE_GNU_LD
&& at_file_supplied
)
4992 /* We are going to expand `%o' to `@FILE', where FILE
4993 is a newly-created temporary filename. The filenames
4994 that would usually be expanded in place of %o will be
4995 written to the temporary file. */
5000 /* Convert OUTFILES into a form suitable for writeargv. */
5002 /* Determine how many are non-NULL. */
5003 for (n_files
= 0, i
= 0; i
< max
; i
++)
5004 n_files
+= outfiles
[i
] != NULL
;
5006 argv
= (char **) alloca (sizeof (char *) * (n_files
+ 1));
5008 /* Copy the strings over. */
5009 for (i
= 0, j
= 0; i
< max
; i
++)
5012 argv
[j
] = CONST_CAST (char *, outfiles
[i
]);
5017 create_at_file (argv
);
5020 for (i
= 0; i
< max
; i
++)
5022 store_arg (outfiles
[i
], 0, 0);
5027 obstack_grow (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
5032 this_is_library_file
= 1;
5036 this_is_linker_script
= 1;
5040 outfiles
[input_file_number
] = NULL
;
5044 this_is_output_file
= 1;
5049 unsigned int cur_index
= VEC_length (const_char_p
, argbuf
);
5050 /* Handle the {...} following the %W. */
5052 fatal_error ("spec %qs has invalid %<%%W%c%>", spec
, *p
);
5053 p
= handle_braces (p
+ 1);
5057 /* If any args were output, mark the last one for deletion
5059 if (VEC_length (const_char_p
, argbuf
) != cur_index
)
5060 record_temp_file (VEC_last (const_char_p
, argbuf
), 0, 1);
5064 /* %x{OPTION} records OPTION for %X to output. */
5072 /* Skip past the option value and make a copy. */
5074 fatal_error ("spec %qs has invalid %<%%x%c%>", spec
, *p
);
5077 string
= save_string (p1
+ 1, p
- p1
- 2);
5079 /* See if we already recorded this option. */
5080 FOR_EACH_VEC_ELT (char_p
, linker_options
, ix
, opt
)
5081 if (! strcmp (string
, opt
))
5087 /* This option is new; add it. */
5088 add_linker_option (string
, strlen (string
));
5092 /* Dump out the options accumulated previously using %x. */
5094 do_specs_vec (linker_options
);
5097 /* Dump out the options accumulated previously using -Wa,. */
5099 do_specs_vec (assembler_options
);
5102 /* Dump out the options accumulated previously using -Wp,. */
5104 do_specs_vec (preprocessor_options
);
5107 /* Here are digits and numbers that just process
5108 a certain constant string as a spec. */
5111 value
= do_spec_1 (cc1_spec
, 0, NULL
);
5117 value
= do_spec_1 (cc1plus_spec
, 0, NULL
);
5123 value
= do_spec_1 (asm_spec
, 0, NULL
);
5129 value
= do_spec_1 (asm_final_spec
, 0, NULL
);
5136 const char *const spec
5137 = (input_file_compiler
->cpp_spec
5138 ? input_file_compiler
->cpp_spec
5140 value
= do_spec_1 (spec
, 0, NULL
);
5147 value
= do_spec_1 (endfile_spec
, 0, NULL
);
5153 value
= do_spec_1 (link_spec
, 0, NULL
);
5159 value
= do_spec_1 (lib_spec
, 0, NULL
);
5165 value
= do_spec_1 (libgcc_spec
, 0, NULL
);
5171 /* We assume there is a directory
5172 separator at the end of this string. */
5173 if (target_system_root
)
5175 obstack_grow (&obstack
, target_system_root
,
5176 strlen (target_system_root
));
5177 if (target_sysroot_suffix
)
5178 obstack_grow (&obstack
, target_sysroot_suffix
,
5179 strlen (target_sysroot_suffix
));
5184 value
= do_spec_1 (startfile_spec
, 0, NULL
);
5189 /* Here we define characters other than letters and digits. */
5192 p
= handle_braces (p
);
5198 p
= handle_spec_function (p
);
5204 obstack_1grow (&obstack
, '%');
5211 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '%')
5213 suffix_subst
= save_string (p
- 1, len
+ 1);
5218 /* Henceforth ignore the option(s) matching the pattern
5224 int have_wildcard
= 0;
5229 switch_option
= SWITCH_IGNORE
| SWITCH_KEEP_FOR_GCC
;
5231 switch_option
= SWITCH_IGNORE
;
5233 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '\t')
5236 if (p
[len
-1] == '*')
5239 for (i
= 0; i
< n_switches
; i
++)
5240 if (!strncmp (switches
[i
].part1
, p
, len
- have_wildcard
)
5241 && (have_wildcard
|| switches
[i
].part1
[len
] == '\0'))
5243 switches
[i
].live_cond
|= switch_option
;
5244 switches
[i
].validated
= 1;
5252 if (soft_matched_part
)
5254 if (soft_matched_part
[0])
5255 do_spec_1 (soft_matched_part
, 1, NULL
);
5256 do_spec_1 (" ", 0, NULL
);
5259 /* Catch the case where a spec string contains something like
5260 '%{foo:%*}'. i.e. there is no * in the pattern on the left
5261 hand side of the :. */
5262 error ("spec failure: %<%%*%> has not been initialized by pattern match");
5265 /* Process a string found as the value of a spec given by name.
5266 This feature allows individual machine descriptions
5267 to add and use their own specs. */
5270 const char *name
= p
;
5271 struct spec_list
*sl
;
5274 /* The string after the S/P is the name of a spec that is to be
5276 while (*p
&& *p
!= ')')
5279 /* See if it's in the list. */
5280 for (len
= p
- name
, sl
= specs
; sl
; sl
= sl
->next
)
5281 if (sl
->name_len
== len
&& !strncmp (sl
->name
, name
, len
))
5283 name
= *(sl
->ptr_spec
);
5285 fnotice (stderr
, "Processing spec (%s), which is '%s'\n",
5293 value
= do_spec_1 (name
, 0, NULL
);
5298 /* Discard the closing paren. */
5305 error ("spec failure: unrecognized spec option %qc", c
);
5311 /* Backslash: treat next character as ordinary. */
5316 /* Ordinary character: put it into the current argument. */
5317 obstack_1grow (&obstack
, c
);
5321 /* End of string. If we are processing a spec function, we need to
5322 end any pending argument. */
5323 if (processing_spec_function
)
5329 /* Look up a spec function. */
5331 static const struct spec_function
*
5332 lookup_spec_function (const char *name
)
5334 const struct spec_function
*sf
;
5336 for (sf
= static_spec_functions
; sf
->name
!= NULL
; sf
++)
5337 if (strcmp (sf
->name
, name
) == 0)
5343 /* Evaluate a spec function. */
5346 eval_spec_function (const char *func
, const char *args
)
5348 const struct spec_function
*sf
;
5349 const char *funcval
;
5351 /* Saved spec processing context. */
5352 VEC(const_char_p
,heap
) *save_argbuf
;
5355 int save_delete_this_arg
;
5356 int save_this_is_output_file
;
5357 int save_this_is_library_file
;
5358 int save_input_from_pipe
;
5359 int save_this_is_linker_script
;
5360 const char *save_suffix_subst
;
5363 sf
= lookup_spec_function (func
);
5365 fatal_error ("unknown spec function %qs", func
);
5367 /* Push the spec processing context. */
5368 save_argbuf
= argbuf
;
5370 save_arg_going
= arg_going
;
5371 save_delete_this_arg
= delete_this_arg
;
5372 save_this_is_output_file
= this_is_output_file
;
5373 save_this_is_library_file
= this_is_library_file
;
5374 save_this_is_linker_script
= this_is_linker_script
;
5375 save_input_from_pipe
= input_from_pipe
;
5376 save_suffix_subst
= suffix_subst
;
5378 /* Create a new spec processing context, and build the function
5382 if (do_spec_2 (args
) < 0)
5383 fatal_error ("error in args to spec function %qs", func
);
5385 /* argbuf_index is an index for the next argument to be inserted, and
5386 so contains the count of the args already inserted. */
5388 funcval
= (*sf
->func
) (VEC_length (const_char_p
, argbuf
),
5389 VEC_address (const_char_p
, argbuf
));
5391 /* Pop the spec processing context. */
5392 VEC_free (const_char_p
, heap
, argbuf
);
5393 argbuf
= save_argbuf
;
5395 arg_going
= save_arg_going
;
5396 delete_this_arg
= save_delete_this_arg
;
5397 this_is_output_file
= save_this_is_output_file
;
5398 this_is_library_file
= save_this_is_library_file
;
5399 this_is_linker_script
= save_this_is_linker_script
;
5400 input_from_pipe
= save_input_from_pipe
;
5401 suffix_subst
= save_suffix_subst
;
5406 /* Handle a spec function call of the form:
5410 ARGS is processed as a spec in a separate context and split into an
5411 argument vector in the normal fashion. The function returns a string
5412 containing a spec which we then process in the caller's context, or
5413 NULL if no processing is required. */
5416 handle_spec_function (const char *p
)
5419 const char *endp
, *funcval
;
5422 processing_spec_function
++;
5424 /* Get the function name. */
5425 for (endp
= p
; *endp
!= '\0'; endp
++)
5427 if (*endp
== '(') /* ) */
5429 /* Only allow [A-Za-z0-9], -, and _ in function names. */
5430 if (!ISALNUM (*endp
) && !(*endp
== '-' || *endp
== '_'))
5431 fatal_error ("malformed spec function name");
5433 if (*endp
!= '(') /* ) */
5434 fatal_error ("no arguments for spec function");
5435 func
= save_string (p
, endp
- p
);
5438 /* Get the arguments. */
5439 for (count
= 0; *endp
!= '\0'; endp
++)
5448 else if (*endp
== '(') /* ) */
5453 fatal_error ("malformed spec function arguments");
5454 args
= save_string (p
, endp
- p
);
5457 /* p now points to just past the end of the spec function expression. */
5459 funcval
= eval_spec_function (func
, args
);
5460 if (funcval
!= NULL
&& do_spec_1 (funcval
, 0, NULL
) < 0)
5466 processing_spec_function
--;
5471 /* Inline subroutine of handle_braces. Returns true if the current
5472 input suffix matches the atom bracketed by ATOM and END_ATOM. */
5474 input_suffix_matches (const char *atom
, const char *end_atom
)
5476 return (input_suffix
5477 && !strncmp (input_suffix
, atom
, end_atom
- atom
)
5478 && input_suffix
[end_atom
- atom
] == '\0');
5481 /* Subroutine of handle_braces. Returns true if the current
5482 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
5484 input_spec_matches (const char *atom
, const char *end_atom
)
5486 return (input_file_compiler
5487 && input_file_compiler
->suffix
5488 && input_file_compiler
->suffix
[0] != '\0'
5489 && !strncmp (input_file_compiler
->suffix
+ 1, atom
,
5491 && input_file_compiler
->suffix
[end_atom
- atom
+ 1] == '\0');
5494 /* Subroutine of handle_braces. Returns true if a switch
5495 matching the atom bracketed by ATOM and END_ATOM appeared on the
5498 switch_matches (const char *atom
, const char *end_atom
, int starred
)
5501 int len
= end_atom
- atom
;
5502 int plen
= starred
? len
: -1;
5504 for (i
= 0; i
< n_switches
; i
++)
5505 if (!strncmp (switches
[i
].part1
, atom
, len
)
5506 && (starred
|| switches
[i
].part1
[len
] == '\0')
5507 && check_live_switch (i
, plen
))
5510 /* Check if a switch with separated form matching the atom.
5511 We check -D and -U switches. */
5512 else if (switches
[i
].args
!= 0)
5514 if ((*switches
[i
].part1
== 'D' || *switches
[i
].part1
== 'U')
5515 && *switches
[i
].part1
== atom
[0])
5517 if (!strncmp (switches
[i
].args
[0], &atom
[1], len
- 1)
5518 && (starred
|| (switches
[i
].part1
[1] == '\0'
5519 && switches
[i
].args
[0][len
- 1] == '\0'))
5520 && check_live_switch (i
, (starred
? 1 : -1)))
5528 /* Inline subroutine of handle_braces. Mark all of the switches which
5529 match ATOM (extends to END_ATOM; STARRED indicates whether there
5530 was a star after the atom) for later processing. */
5532 mark_matching_switches (const char *atom
, const char *end_atom
, int starred
)
5535 int len
= end_atom
- atom
;
5536 int plen
= starred
? len
: -1;
5538 for (i
= 0; i
< n_switches
; i
++)
5539 if (!strncmp (switches
[i
].part1
, atom
, len
)
5540 && (starred
|| switches
[i
].part1
[len
] == '\0')
5541 && check_live_switch (i
, plen
))
5542 switches
[i
].ordering
= 1;
5545 /* Inline subroutine of handle_braces. Process all the currently
5546 marked switches through give_switch, and clear the marks. */
5548 process_marked_switches (void)
5552 for (i
= 0; i
< n_switches
; i
++)
5553 if (switches
[i
].ordering
== 1)
5555 switches
[i
].ordering
= 0;
5560 /* Handle a %{ ... } construct. P points just inside the leading {.
5561 Returns a pointer one past the end of the brace block, or 0
5562 if we call do_spec_1 and that returns -1. */
5565 handle_braces (const char *p
)
5567 const char *atom
, *end_atom
;
5568 const char *d_atom
= NULL
, *d_end_atom
= NULL
;
5569 const char *orig
= p
;
5577 bool a_must_be_last
= false;
5578 bool ordered_set
= false;
5579 bool disjunct_set
= false;
5580 bool disj_matched
= false;
5581 bool disj_starred
= true;
5582 bool n_way_choice
= false;
5583 bool n_way_matched
= false;
5585 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
5592 /* Scan one "atom" (S in the description above of %{}, possibly
5593 with '!', '.', '@', ',', or '*' modifiers). */
5595 a_is_suffix
= false;
5596 a_is_starred
= false;
5597 a_is_negated
= false;
5598 a_is_spectype
= false;
5602 p
++, a_is_negated
= true;
5606 p
++, a_is_suffix
= true;
5608 p
++, a_is_spectype
= true;
5611 while (ISIDNUM(*p
) || *p
== '-' || *p
== '+' || *p
== '='
5612 || *p
== ',' || *p
== '.' || *p
== '@')
5617 p
++, a_is_starred
= 1;
5623 /* Substitute the switch(es) indicated by the current atom. */
5625 if (disjunct_set
|| n_way_choice
|| a_is_negated
|| a_is_suffix
5626 || a_is_spectype
|| atom
== end_atom
)
5629 mark_matching_switches (atom
, end_atom
, a_is_starred
);
5632 process_marked_switches ();
5636 /* Substitute some text if the current atom appears as a switch
5638 disjunct_set
= true;
5642 if (atom
== end_atom
)
5644 if (!n_way_choice
|| disj_matched
|| *p
== '|'
5645 || a_is_negated
|| a_is_suffix
|| a_is_spectype
5649 /* An empty term may appear as the last choice of an
5650 N-way choice set; it means "otherwise". */
5651 a_must_be_last
= true;
5652 disj_matched
= !n_way_matched
;
5653 disj_starred
= false;
5657 if ((a_is_suffix
|| a_is_spectype
) && a_is_starred
)
5661 disj_starred
= false;
5663 /* Don't bother testing this atom if we already have a
5665 if (!disj_matched
&& !n_way_matched
)
5668 a_matched
= input_suffix_matches (atom
, end_atom
);
5669 else if (a_is_spectype
)
5670 a_matched
= input_spec_matches (atom
, end_atom
);
5672 a_matched
= switch_matches (atom
, end_atom
, a_is_starred
);
5674 if (a_matched
!= a_is_negated
)
5676 disj_matched
= true;
5678 d_end_atom
= end_atom
;
5685 /* Found the body, that is, the text to substitute if the
5686 current disjunction matches. */
5687 p
= process_brace_body (p
+ 1, d_atom
, d_end_atom
, disj_starred
,
5688 disj_matched
&& !n_way_matched
);
5692 /* If we have an N-way choice, reset state for the next
5696 n_way_choice
= true;
5697 n_way_matched
|= disj_matched
;
5698 disj_matched
= false;
5699 disj_starred
= true;
5700 d_atom
= d_end_atom
= NULL
;
5709 while (*p
++ != '}');
5714 fatal_error ("braced spec %qs is invalid at %qc", orig
, *p
);
5719 /* Subroutine of handle_braces. Scan and process a brace substitution body
5720 (X in the description of %{} syntax). P points one past the colon;
5721 ATOM and END_ATOM bracket the first atom which was found to be true
5722 (present) in the current disjunction; STARRED indicates whether all
5723 the atoms in the current disjunction were starred (for syntax validation);
5724 MATCHED indicates whether the disjunction matched or not, and therefore
5725 whether or not the body is to be processed through do_spec_1 or just
5726 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
5730 process_brace_body (const char *p
, const char *atom
, const char *end_atom
,
5731 int starred
, int matched
)
5733 const char *body
, *end_body
;
5734 unsigned int nesting_level
;
5735 bool have_subst
= false;
5737 /* Locate the closing } or ;, honoring nested braces.
5738 Trim trailing whitespace. */
5747 if (!--nesting_level
)
5750 else if (*p
== ';' && nesting_level
== 1)
5752 else if (*p
== '%' && p
[1] == '*' && nesting_level
== 1)
5754 else if (*p
== '\0')
5760 while (end_body
[-1] == ' ' || end_body
[-1] == '\t')
5763 if (have_subst
&& !starred
)
5768 /* Copy the substitution body to permanent storage and execute it.
5769 If have_subst is false, this is a simple matter of running the
5770 body through do_spec_1... */
5771 char *string
= save_string (body
, end_body
- body
);
5774 if (do_spec_1 (string
, 0, NULL
) < 0)
5779 /* ... but if have_subst is true, we have to process the
5780 body once for each matching switch, with %* set to the
5781 variant part of the switch. */
5782 unsigned int hard_match_len
= end_atom
- atom
;
5785 for (i
= 0; i
< n_switches
; i
++)
5786 if (!strncmp (switches
[i
].part1
, atom
, hard_match_len
)
5787 && check_live_switch (i
, hard_match_len
))
5789 if (do_spec_1 (string
, 0,
5790 &switches
[i
].part1
[hard_match_len
]) < 0)
5792 /* Pass any arguments this switch has. */
5794 suffix_subst
= NULL
;
5802 fatal_error ("braced spec body %qs is invalid", body
);
5805 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
5806 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
5807 spec, or -1 if either exact match or %* is used.
5809 A -O switch is obsoleted by a later -O switch. A -f, -m, or -W switch
5810 whose value does not begin with "no-" is obsoleted by the same value
5811 with the "no-", similarly for a switch with the "no-" prefix. */
5814 check_live_switch (int switchnum
, int prefix_length
)
5816 const char *name
= switches
[switchnum
].part1
;
5819 /* If we already processed this switch and determined if it was
5820 live or not, return our past determination. */
5821 if (switches
[switchnum
].live_cond
!= 0)
5822 return ((switches
[switchnum
].live_cond
& SWITCH_LIVE
) != 0
5823 && (switches
[switchnum
].live_cond
& SWITCH_FALSE
) == 0
5824 && (switches
[switchnum
].live_cond
& SWITCH_IGNORE_PERMANENTLY
)
5827 /* In the common case of {<at-most-one-letter>*}, a negating
5828 switch would always match, so ignore that case. We will just
5829 send the conflicting switches to the compiler phase. */
5830 if (prefix_length
>= 0 && prefix_length
<= 1)
5833 /* Now search for duplicate in a manner that depends on the name. */
5837 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
5838 if (switches
[i
].part1
[0] == 'O')
5840 switches
[switchnum
].validated
= 1;
5841 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
5846 case 'W': case 'f': case 'm':
5847 if (! strncmp (name
+ 1, "no-", 3))
5849 /* We have Xno-YYY, search for XYYY. */
5850 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
5851 if (switches
[i
].part1
[0] == name
[0]
5852 && ! strcmp (&switches
[i
].part1
[1], &name
[4]))
5854 switches
[switchnum
].validated
= 1;
5855 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
5861 /* We have XYYY, search for Xno-YYY. */
5862 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
5863 if (switches
[i
].part1
[0] == name
[0]
5864 && switches
[i
].part1
[1] == 'n'
5865 && switches
[i
].part1
[2] == 'o'
5866 && switches
[i
].part1
[3] == '-'
5867 && !strcmp (&switches
[i
].part1
[4], &name
[1]))
5869 switches
[switchnum
].validated
= 1;
5870 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
5877 /* Otherwise the switch is live. */
5878 switches
[switchnum
].live_cond
|= SWITCH_LIVE
;
5882 /* Pass a switch to the current accumulating command
5883 in the same form that we received it.
5884 SWITCHNUM identifies the switch; it is an index into
5885 the vector of switches gcc received, which is `switches'.
5886 This cannot fail since it never finishes a command line.
5888 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
5891 give_switch (int switchnum
, int omit_first_word
)
5893 if ((switches
[switchnum
].live_cond
& SWITCH_IGNORE
) != 0)
5896 if (!omit_first_word
)
5898 do_spec_1 ("-", 0, NULL
);
5899 do_spec_1 (switches
[switchnum
].part1
, 1, NULL
);
5902 if (switches
[switchnum
].args
!= 0)
5905 for (p
= switches
[switchnum
].args
; *p
; p
++)
5907 const char *arg
= *p
;
5909 do_spec_1 (" ", 0, NULL
);
5912 unsigned length
= strlen (arg
);
5915 while (length
-- && !IS_DIR_SEPARATOR (arg
[length
]))
5916 if (arg
[length
] == '.')
5918 (CONST_CAST(char *, arg
))[length
] = 0;
5922 do_spec_1 (arg
, 1, NULL
);
5924 (CONST_CAST(char *, arg
))[length
] = '.';
5925 do_spec_1 (suffix_subst
, 1, NULL
);
5928 do_spec_1 (arg
, 1, NULL
);
5932 do_spec_1 (" ", 0, NULL
);
5933 switches
[switchnum
].validated
= 1;
5936 /* Search for a file named NAME trying various prefixes including the
5937 user's -B prefix and some standard ones.
5938 Return the absolute file name found. If nothing is found, return NAME. */
5941 find_file (const char *name
)
5943 char *newname
= find_a_file (&startfile_prefixes
, name
, R_OK
, true);
5944 return newname
? newname
: name
;
5947 /* Determine whether a directory exists. If LINKER, return 0 for
5948 certain fixed names not needed by the linker. */
5951 is_directory (const char *path1
, bool linker
)
5958 /* Ensure the string ends with "/.". The resulting path will be a
5959 directory even if the given path is a symbolic link. */
5960 len1
= strlen (path1
);
5961 path
= (char *) alloca (3 + len1
);
5962 memcpy (path
, path1
, len1
);
5964 if (!IS_DIR_SEPARATOR (cp
[-1]))
5965 *cp
++ = DIR_SEPARATOR
;
5969 /* Exclude directories that the linker is known to search. */
5971 && IS_DIR_SEPARATOR (path
[0])
5973 && filename_ncmp (path
+ 1, "lib", 3) == 0)
5975 && filename_ncmp (path
+ 1, "usr", 3) == 0
5976 && IS_DIR_SEPARATOR (path
[4])
5977 && filename_ncmp (path
+ 5, "lib", 3) == 0)))
5980 return (stat (path
, &st
) >= 0 && S_ISDIR (st
.st_mode
));
5983 /* Set up the various global variables to indicate that we're processing
5984 the input file named FILENAME. */
5987 set_input (const char *filename
)
5991 gcc_input_filename
= filename
;
5992 input_filename_length
= strlen (gcc_input_filename
);
5993 input_basename
= lbasename (gcc_input_filename
);
5995 /* Find a suffix starting with the last period,
5996 and set basename_length to exclude that suffix. */
5997 basename_length
= strlen (input_basename
);
5998 suffixed_basename_length
= basename_length
;
5999 p
= input_basename
+ basename_length
;
6000 while (p
!= input_basename
&& *p
!= '.')
6002 if (*p
== '.' && p
!= input_basename
)
6004 basename_length
= p
- input_basename
;
6005 input_suffix
= p
+ 1;
6010 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
6011 we will need to do a stat on the gcc_input_filename. The
6012 INPUT_STAT_SET signals that the stat is needed. */
6016 /* On fatal signals, delete all the temporary files. */
6019 fatal_signal (int signum
)
6021 signal (signum
, SIG_DFL
);
6022 delete_failure_queue ();
6023 delete_temp_files ();
6024 /* Get the same signal again, this time not handled,
6025 so its normal effect occurs. */
6026 kill (getpid (), signum
);
6029 /* Compare the contents of the two files named CMPFILE[0] and
6030 CMPFILE[1]. Return zero if they're identical, nonzero
6034 compare_files (char *cmpfile
[])
6037 FILE *temp
[2] = { NULL
, NULL
};
6043 void *map
[2] = { NULL
, NULL
};
6045 for (i
= 0; i
< 2; i
++)
6049 if (stat (cmpfile
[i
], &st
) < 0 || !S_ISREG (st
.st_mode
))
6051 error ("%s: could not determine length of compare-debug file %s",
6052 gcc_input_filename
, cmpfile
[i
]);
6057 length
[i
] = st
.st_size
;
6060 if (!ret
&& length
[0] != length
[1])
6062 error ("%s: -fcompare-debug failure (length)", gcc_input_filename
);
6067 for (i
= 0; i
< 2; i
++)
6069 int fd
= open (cmpfile
[i
], O_RDONLY
);
6072 error ("%s: could not open compare-debug file %s",
6073 gcc_input_filename
, cmpfile
[i
]);
6078 map
[i
] = mmap (NULL
, length
[i
], PROT_READ
, MAP_PRIVATE
, fd
, 0);
6081 if (map
[i
] == (void *) MAP_FAILED
)
6090 if (memcmp (map
[0], map
[1], length
[0]) != 0)
6092 error ("%s: -fcompare-debug failure", gcc_input_filename
);
6097 for (i
= 0; i
< 2; i
++)
6099 munmap ((caddr_t
) map
[i
], length
[i
]);
6108 for (i
= 0; i
< 2; i
++)
6110 temp
[i
] = fopen (cmpfile
[i
], "r");
6113 error ("%s: could not open compare-debug file %s",
6114 gcc_input_filename
, cmpfile
[i
]);
6120 if (!ret
&& temp
[0] && temp
[1])
6124 c0
= fgetc (temp
[0]);
6125 c1
= fgetc (temp
[1]);
6129 error ("%s: -fcompare-debug failure",
6130 gcc_input_filename
);
6139 for (i
= 1; i
>= 0; i
--)
6148 extern int main (int, char **);
6151 main (int argc
, char **argv
)
6155 int linker_was_run
= 0;
6156 int lang_n_infiles
= 0;
6157 int num_linker_inputs
= 0;
6158 char *explicit_link_files
;
6160 char *lto_wrapper_file
;
6162 struct user_specs
*uptr
;
6163 char **old_argv
= argv
;
6164 struct cl_decoded_option
*decoded_options
;
6165 unsigned int decoded_options_count
;
6167 /* Initialize here, not in definition. The IRIX 6 O32 cc sometimes chokes
6168 on ?: in file-scope variable initializations. */
6169 asm_debug
= ASM_DEBUG_SPEC
;
6171 p
= argv
[0] + strlen (argv
[0]);
6172 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
6176 xmalloc_set_program_name (progname
);
6178 expandargv (&argc
, &argv
);
6180 /* Determine if any expansions were made. */
6181 if (argv
!= old_argv
)
6182 at_file_supplied
= true;
6184 /* Register the language-independent parameters. */
6185 global_init_params ();
6188 init_options_struct (&global_options
, &global_options_set
);
6190 decode_cmdline_options_to_array (argc
, CONST_CAST2 (const char **, char **,
6193 &decoded_options
, &decoded_options_count
);
6195 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6196 /* Perform host dependent initialization when needed. */
6197 GCC_DRIVER_HOST_INITIALIZATION
;
6200 /* Unlock the stdio streams. */
6201 unlock_std_streams ();
6203 gcc_init_libintl ();
6205 diagnostic_initialize (global_dc
, 0);
6206 if (atexit (delete_temp_files
) != 0)
6207 fatal_error ("atexit failed");
6209 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
6210 signal (SIGINT
, fatal_signal
);
6212 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
6213 signal (SIGHUP
, fatal_signal
);
6215 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
6216 signal (SIGTERM
, fatal_signal
);
6218 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
6219 signal (SIGPIPE
, fatal_signal
);
6222 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6223 receive the signal. A different setting is inheritable */
6224 signal (SIGCHLD
, SIG_DFL
);
6227 /* Parsing and gimplification sometimes need quite large stack.
6228 Increase stack size limits if possible. */
6229 stack_limit_increase (64 * 1024 * 1024);
6231 /* Allocate the argument vector. */
6234 obstack_init (&obstack
);
6236 /* Build multilib_select, et. al from the separate lines that make up each
6237 multilib selection. */
6239 const char *const *q
= multilib_raw
;
6242 obstack_init (&multilib_obstack
);
6243 while ((p
= *q
++) != (char *) 0)
6244 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6246 obstack_1grow (&multilib_obstack
, 0);
6247 multilib_select
= XOBFINISH (&multilib_obstack
, const char *);
6249 q
= multilib_matches_raw
;
6250 while ((p
= *q
++) != (char *) 0)
6251 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6253 obstack_1grow (&multilib_obstack
, 0);
6254 multilib_matches
= XOBFINISH (&multilib_obstack
, const char *);
6256 q
= multilib_exclusions_raw
;
6257 while ((p
= *q
++) != (char *) 0)
6258 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6260 obstack_1grow (&multilib_obstack
, 0);
6261 multilib_exclusions
= XOBFINISH (&multilib_obstack
, const char *);
6264 for (i
= 0; i
< ARRAY_SIZE (multilib_defaults_raw
); i
++)
6267 obstack_1grow (&multilib_obstack
, ' ');
6268 obstack_grow (&multilib_obstack
,
6269 multilib_defaults_raw
[i
],
6270 strlen (multilib_defaults_raw
[i
]));
6274 obstack_1grow (&multilib_obstack
, 0);
6275 multilib_defaults
= XOBFINISH (&multilib_obstack
, const char *);
6278 #ifdef INIT_ENVIRONMENT
6279 /* Set up any other necessary machine specific environment variables. */
6280 xputenv (INIT_ENVIRONMENT
);
6283 /* Make a table of what switches there are (switches, n_switches).
6284 Make a table of specified input files (infiles, n_infiles).
6285 Decode switches that are handled locally. */
6287 process_command (decoded_options_count
, decoded_options
);
6289 /* Initialize the vector of specs to just the default.
6290 This means one element containing 0s, as a terminator. */
6292 compilers
= XNEWVAR (struct compiler
, sizeof default_compilers
);
6293 memcpy (compilers
, default_compilers
, sizeof default_compilers
);
6294 n_compilers
= n_default_compilers
;
6296 /* Read specs from a file if there is one. */
6298 machine_suffix
= concat (spec_machine
, dir_separator_str
,
6299 spec_version
, dir_separator_str
, NULL
);
6300 just_machine_suffix
= concat (spec_machine
, dir_separator_str
, NULL
);
6302 specs_file
= find_a_file (&startfile_prefixes
, "specs", R_OK
, true);
6303 /* Read the specs file unless it is a default one. */
6304 if (specs_file
!= 0 && strcmp (specs_file
, "specs"))
6305 read_specs (specs_file
, TRUE
);
6309 /* We need to check standard_exec_prefix/just_machine_suffix/specs
6310 for any override of as, ld and libraries. */
6311 specs_file
= (char *) alloca (strlen (standard_exec_prefix
)
6312 + strlen (just_machine_suffix
) + sizeof ("specs"));
6314 strcpy (specs_file
, standard_exec_prefix
);
6315 strcat (specs_file
, just_machine_suffix
);
6316 strcat (specs_file
, "specs");
6317 if (access (specs_file
, R_OK
) == 0)
6318 read_specs (specs_file
, TRUE
);
6320 /* Process any configure-time defaults specified for the command line
6321 options, via OPTION_DEFAULT_SPECS. */
6322 for (i
= 0; i
< ARRAY_SIZE (option_default_specs
); i
++)
6323 do_option_spec (option_default_specs
[i
].name
,
6324 option_default_specs
[i
].spec
);
6326 /* Process DRIVER_SELF_SPECS, adding any new options to the end
6327 of the command line. */
6329 for (i
= 0; i
< ARRAY_SIZE (driver_self_specs
); i
++)
6330 do_self_spec (driver_self_specs
[i
]);
6332 /* If not cross-compiling, look for executables in the standard
6334 if (*cross_compile
== '0')
6336 if (*md_exec_prefix
)
6338 add_prefix (&exec_prefixes
, md_exec_prefix
, "GCC",
6339 PREFIX_PRIORITY_LAST
, 0, 0);
6343 /* Process sysroot_suffix_spec. */
6344 if (*sysroot_suffix_spec
!= 0
6345 && do_spec_2 (sysroot_suffix_spec
) == 0)
6347 if (VEC_length (const_char_p
, argbuf
) > 1)
6348 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
6349 else if (VEC_length (const_char_p
, argbuf
) == 1)
6350 target_sysroot_suffix
= xstrdup (VEC_last (const_char_p
, argbuf
));
6353 #ifdef HAVE_LD_SYSROOT
6354 /* Pass the --sysroot option to the linker, if it supports that. If
6355 there is a sysroot_suffix_spec, it has already been processed by
6356 this point, so target_system_root really is the system root we
6358 if (target_system_root
)
6360 obstack_grow (&obstack
, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
6361 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
6362 set_spec ("link", XOBFINISH (&obstack
, const char *));
6366 /* Process sysroot_hdrs_suffix_spec. */
6367 if (*sysroot_hdrs_suffix_spec
!= 0
6368 && do_spec_2 (sysroot_hdrs_suffix_spec
) == 0)
6370 if (VEC_length (const_char_p
, argbuf
) > 1)
6371 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
6372 else if (VEC_length (const_char_p
, argbuf
) == 1)
6373 target_sysroot_hdrs_suffix
= xstrdup (VEC_last (const_char_p
, argbuf
));
6376 /* Look for startfiles in the standard places. */
6377 if (*startfile_prefix_spec
!= 0
6378 && do_spec_2 (startfile_prefix_spec
) == 0
6379 && do_spec_1 (" ", 0, NULL
) == 0)
6383 FOR_EACH_VEC_ELT (const_char_p
, argbuf
, ndx
, arg
)
6384 add_sysrooted_prefix (&startfile_prefixes
, arg
, "BINUTILS",
6385 PREFIX_PRIORITY_LAST
, 0, 1);
6387 /* We should eventually get rid of all these and stick to
6388 startfile_prefix_spec exclusively. */
6389 else if (*cross_compile
== '0' || target_system_root
)
6391 if (*md_startfile_prefix
)
6392 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix
,
6393 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
6395 if (*md_startfile_prefix_1
)
6396 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix_1
,
6397 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
6399 /* If standard_startfile_prefix is relative, base it on
6400 standard_exec_prefix. This lets us move the installed tree
6401 as a unit. If GCC_EXEC_PREFIX is defined, base
6402 standard_startfile_prefix on that as well.
6404 If the prefix is relative, only search it for native compilers;
6405 otherwise we will search a directory containing host libraries. */
6406 if (IS_ABSOLUTE_PATH (standard_startfile_prefix
))
6407 add_sysrooted_prefix (&startfile_prefixes
,
6408 standard_startfile_prefix
, "BINUTILS",
6409 PREFIX_PRIORITY_LAST
, 0, 1);
6410 else if (*cross_compile
== '0')
6412 add_prefix (&startfile_prefixes
,
6413 concat (gcc_exec_prefix
6414 ? gcc_exec_prefix
: standard_exec_prefix
,
6416 standard_startfile_prefix
, NULL
),
6417 NULL
, PREFIX_PRIORITY_LAST
, 0, 1);
6420 /* Sysrooted prefixes are relocated because target_system_root is
6421 also relocated by gcc_exec_prefix. */
6422 if (*standard_startfile_prefix_1
)
6423 add_sysrooted_prefix (&startfile_prefixes
,
6424 standard_startfile_prefix_1
, "BINUTILS",
6425 PREFIX_PRIORITY_LAST
, 0, 1);
6426 if (*standard_startfile_prefix_2
)
6427 add_sysrooted_prefix (&startfile_prefixes
,
6428 standard_startfile_prefix_2
, "BINUTILS",
6429 PREFIX_PRIORITY_LAST
, 0, 1);
6432 /* Process any user specified specs in the order given on the command
6434 for (uptr
= user_specs_head
; uptr
; uptr
= uptr
->next
)
6436 char *filename
= find_a_file (&startfile_prefixes
, uptr
->filename
,
6438 read_specs (filename
? filename
: uptr
->filename
, FALSE
);
6441 /* Process any user self specs. */
6443 struct spec_list
*sl
;
6444 for (sl
= specs
; sl
; sl
= sl
->next
)
6445 if (sl
->name_len
== sizeof "self_spec" - 1
6446 && !strcmp (sl
->name
, "self_spec"))
6447 do_self_spec (*sl
->ptr_spec
);
6452 enum save_temps save
;
6454 if (!compare_debug_second
)
6456 n_switches_debug_check
[1] = n_switches
;
6457 n_switches_alloc_debug_check
[1] = n_switches_alloc
;
6458 switches_debug_check
[1] = XDUPVEC (struct switchstr
, switches
,
6461 do_self_spec ("%:compare-debug-self-opt()");
6462 n_switches_debug_check
[0] = n_switches
;
6463 n_switches_alloc_debug_check
[0] = n_switches_alloc
;
6464 switches_debug_check
[0] = switches
;
6466 n_switches
= n_switches_debug_check
[1];
6467 n_switches_alloc
= n_switches_alloc_debug_check
[1];
6468 switches
= switches_debug_check
[1];
6471 /* Avoid crash when computing %j in this early. */
6472 save
= save_temps_flag
;
6473 save_temps_flag
= SAVE_TEMPS_NONE
;
6475 compare_debug
= -compare_debug
;
6476 do_self_spec ("%:compare-debug-self-opt()");
6478 save_temps_flag
= save
;
6480 if (!compare_debug_second
)
6482 n_switches_debug_check
[1] = n_switches
;
6483 n_switches_alloc_debug_check
[1] = n_switches_alloc
;
6484 switches_debug_check
[1] = switches
;
6485 compare_debug
= -compare_debug
;
6486 n_switches
= n_switches_debug_check
[0];
6487 n_switches_alloc
= n_switches_debug_check
[0];
6488 switches
= switches_debug_check
[0];
6493 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
6494 if (gcc_exec_prefix
)
6495 gcc_exec_prefix
= concat (gcc_exec_prefix
, spec_machine
, dir_separator_str
,
6496 spec_version
, dir_separator_str
, NULL
);
6498 /* Now we have the specs.
6499 Set the `valid' bits for switches that match anything in any spec. */
6501 validate_all_switches ();
6503 /* Now that we have the switches and the specs, set
6504 the subdirectory based on the options. */
6505 set_multilib_dir ();
6507 /* Set up to remember the pathname of gcc and any options
6508 needed for collect. We use argv[0] instead of progname because
6509 we need the complete pathname. */
6510 obstack_init (&collect_obstack
);
6511 obstack_grow (&collect_obstack
, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
6512 obstack_grow (&collect_obstack
, argv
[0], strlen (argv
[0]) + 1);
6513 xputenv (XOBFINISH (&collect_obstack
, char *));
6515 /* Set up to remember the pathname of the lto wrapper. */
6518 lto_wrapper_file
= NULL
;
6520 lto_wrapper_file
= find_a_file (&exec_prefixes
, "lto-wrapper",
6522 if (lto_wrapper_file
)
6524 lto_wrapper_file
= convert_white_space (lto_wrapper_file
);
6525 lto_wrapper_spec
= lto_wrapper_file
;
6526 obstack_init (&collect_obstack
);
6527 obstack_grow (&collect_obstack
, "COLLECT_LTO_WRAPPER=",
6528 sizeof ("COLLECT_LTO_WRAPPER=") - 1);
6529 obstack_grow (&collect_obstack
, lto_wrapper_spec
,
6530 strlen (lto_wrapper_spec
) + 1);
6531 xputenv (XOBFINISH (&collect_obstack
, char *));
6534 /* Warn about any switches that no pass was interested in. */
6536 for (i
= 0; (int) i
< n_switches
; i
++)
6537 if (! switches
[i
].validated
)
6538 error ("unrecognized option %<-%s%>", switches
[i
].part1
);
6540 /* Obey some of the options. */
6542 if (print_search_dirs
)
6544 printf (_("install: %s\n"), STD_EXEC_PATH
);
6545 printf (_("programs: %s\n"),
6546 build_search_list (&exec_prefixes
, "", false, false));
6547 printf (_("libraries: %s\n"),
6548 build_search_list (&startfile_prefixes
, "", false, true));
6552 if (print_file_name
)
6554 printf ("%s\n", find_file (print_file_name
));
6558 if (print_prog_name
)
6560 char *newname
= find_a_file (&exec_prefixes
, print_prog_name
, X_OK
, 0);
6561 printf ("%s\n", (newname
? newname
: print_prog_name
));
6565 if (print_multi_lib
)
6567 print_multilib_info ();
6571 if (print_multi_directory
)
6573 if (multilib_dir
== NULL
)
6576 printf ("%s\n", multilib_dir
);
6580 if (print_multiarch
)
6582 if (multiarch_dir
== NULL
)
6585 printf ("%s\n", multiarch_dir
);
6591 if (target_system_root
)
6593 if (target_sysroot_suffix
)
6594 printf ("%s%s\n", target_system_root
, target_sysroot_suffix
);
6596 printf ("%s\n", target_system_root
);
6601 if (print_multi_os_directory
)
6603 if (multilib_os_dir
== NULL
)
6606 printf ("%s\n", multilib_os_dir
);
6610 if (print_sysroot_headers_suffix
)
6612 if (*sysroot_hdrs_suffix_spec
)
6614 printf("%s\n", (target_sysroot_hdrs_suffix
6615 ? target_sysroot_hdrs_suffix
6620 /* The error status indicates that only one set of fixed
6621 headers should be built. */
6622 fatal_error ("not configured with sysroot headers suffix");
6625 if (print_help_list
)
6631 printf (_("\nFor bug reporting instructions, please see:\n"));
6632 printf ("%s.\n", bug_report_url
);
6637 /* We do not exit here. Instead we have created a fake input file
6638 called 'help-dummy' which needs to be compiled, and we pass this
6639 on the various sub-processes, along with the --help switch.
6640 Ensure their output appears after ours. */
6641 fputc ('\n', stdout
);
6647 printf (_("%s %s%s\n"), progname
, pkgversion_string
,
6649 printf ("Copyright %s 2012 Free Software Foundation, Inc.\n",
6651 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
6652 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
6657 /* We do not exit here. We use the same mechanism of --help to print
6658 the version of the sub-processes. */
6659 fputc ('\n', stdout
);
6668 fnotice (stderr
, "Target: %s\n", spec_machine
);
6669 fnotice (stderr
, "Configured with: %s\n", configuration_arguments
);
6671 #ifdef THREAD_MODEL_SPEC
6672 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
6673 but there's no point in doing all this processing just to get
6674 thread_model back. */
6675 obstack_init (&obstack
);
6676 do_spec_1 (THREAD_MODEL_SPEC
, 0, thread_model
);
6677 obstack_1grow (&obstack
, '\0');
6678 thrmod
= XOBFINISH (&obstack
, const char *);
6680 thrmod
= thread_model
;
6683 fnotice (stderr
, "Thread model: %s\n", thrmod
);
6685 /* compiler_version is truncated at the first space when initialized
6686 from version string, so truncate version_string at the first space
6687 before comparing. */
6688 for (n
= 0; version_string
[n
]; n
++)
6689 if (version_string
[n
] == ' ')
6692 if (! strncmp (version_string
, compiler_version
, n
)
6693 && compiler_version
[n
] == 0)
6694 fnotice (stderr
, "gcc version %s %s\n", version_string
,
6697 fnotice (stderr
, "gcc driver version %s %sexecuting gcc version %s\n",
6698 version_string
, pkgversion_string
, compiler_version
);
6704 if (n_infiles
== added_libraries
)
6705 fatal_error ("no input files");
6710 /* Make a place to record the compiler output file names
6711 that correspond to the input files. */
6714 i
+= lang_specific_extra_outfiles
;
6715 outfiles
= XCNEWVEC (const char *, i
);
6717 /* Record which files were specified explicitly as link input. */
6719 explicit_link_files
= XCNEWVEC (char, n_infiles
);
6721 combine_inputs
= have_o
|| flag_wpa
;
6723 for (i
= 0; (int) i
< n_infiles
; i
++)
6725 const char *name
= infiles
[i
].name
;
6726 struct compiler
*compiler
= lookup_compiler (name
,
6728 infiles
[i
].language
);
6730 if (compiler
&& !(compiler
->combinable
))
6731 combine_inputs
= false;
6733 if (lang_n_infiles
> 0 && compiler
!= input_file_compiler
6734 && infiles
[i
].language
&& infiles
[i
].language
[0] != '*')
6735 infiles
[i
].incompiler
= compiler
;
6739 input_file_compiler
= compiler
;
6740 infiles
[i
].incompiler
= compiler
;
6744 /* Since there is no compiler for this input file, assume it is a
6746 explicit_link_files
[i
] = 1;
6747 infiles
[i
].incompiler
= NULL
;
6749 infiles
[i
].compiled
= false;
6750 infiles
[i
].preprocessed
= false;
6753 if (!combine_inputs
&& have_c
&& have_o
&& lang_n_infiles
> 1)
6754 fatal_error ("cannot specify -o with -c, -S or -E with multiple files");
6756 for (i
= 0; (int) i
< n_infiles
; i
++)
6758 int this_file_error
= 0;
6760 /* Tell do_spec what to substitute for %i. */
6762 input_file_number
= i
;
6763 set_input (infiles
[i
].name
);
6765 if (infiles
[i
].compiled
)
6768 /* Use the same thing in %o, unless cp->spec says otherwise. */
6770 outfiles
[i
] = gcc_input_filename
;
6772 /* Figure out which compiler from the file's suffix. */
6775 = lookup_compiler (infiles
[i
].name
, input_filename_length
,
6776 infiles
[i
].language
);
6778 if (input_file_compiler
)
6780 /* Ok, we found an applicable compiler. Run its spec. */
6782 if (input_file_compiler
->spec
[0] == '#')
6784 error ("%s: %s compiler not installed on this system",
6785 gcc_input_filename
, &input_file_compiler
->spec
[1]);
6786 this_file_error
= 1;
6792 free (debug_check_temp_file
[0]);
6793 debug_check_temp_file
[0] = NULL
;
6795 free (debug_check_temp_file
[1]);
6796 debug_check_temp_file
[1] = NULL
;
6799 value
= do_spec (input_file_compiler
->spec
);
6800 infiles
[i
].compiled
= true;
6802 this_file_error
= 1;
6803 else if (compare_debug
&& debug_check_temp_file
[0])
6806 inform (0, "recompiling with -fcompare-debug");
6808 compare_debug
= -compare_debug
;
6809 n_switches
= n_switches_debug_check
[1];
6810 n_switches_alloc
= n_switches_alloc_debug_check
[1];
6811 switches
= switches_debug_check
[1];
6813 value
= do_spec (input_file_compiler
->spec
);
6815 compare_debug
= -compare_debug
;
6816 n_switches
= n_switches_debug_check
[0];
6817 n_switches_alloc
= n_switches_alloc_debug_check
[0];
6818 switches
= switches_debug_check
[0];
6822 error ("during -fcompare-debug recompilation");
6823 this_file_error
= 1;
6826 gcc_assert (debug_check_temp_file
[1]
6827 && filename_cmp (debug_check_temp_file
[0],
6828 debug_check_temp_file
[1]));
6831 inform (0, "comparing final insns dumps");
6833 if (compare_files (debug_check_temp_file
))
6834 this_file_error
= 1;
6839 free (debug_check_temp_file
[0]);
6840 debug_check_temp_file
[0] = NULL
;
6842 free (debug_check_temp_file
[1]);
6843 debug_check_temp_file
[1] = NULL
;
6848 /* If this file's name does not contain a recognized suffix,
6849 record it as explicit linker input. */
6852 explicit_link_files
[i
] = 1;
6854 /* Clear the delete-on-failure queue, deleting the files in it
6855 if this compilation failed. */
6857 if (this_file_error
)
6859 delete_failure_queue ();
6862 /* If this compilation succeeded, don't delete those files later. */
6863 clear_failure_queue ();
6866 /* Reset the input file name to the first compile/object file name, for use
6867 with %b in LINK_SPEC. We use the first input file that we can find
6868 a compiler to compile it instead of using infiles.language since for
6869 languages other than C we use aliases that we then lookup later. */
6874 for (i
= 0; i
< n_infiles
; i
++)
6875 if (infiles
[i
].incompiler
6876 || (infiles
[i
].language
&& infiles
[i
].language
[0] != '*'))
6878 set_input (infiles
[i
].name
);
6885 /* Make sure INPUT_FILE_NUMBER points to first available open
6887 input_file_number
= n_infiles
;
6888 if (lang_specific_pre_link ())
6892 /* Determine if there are any linker input files. */
6893 num_linker_inputs
= 0;
6894 for (i
= 0; (int) i
< n_infiles
; i
++)
6895 if (explicit_link_files
[i
] || outfiles
[i
] != NULL
)
6896 num_linker_inputs
++;
6898 /* Run ld to link all the compiler output files. */
6900 if (num_linker_inputs
> 0 && !seen_error () && print_subprocess_help
< 2)
6902 int tmp
= execution_count
;
6906 #if HAVE_LTO_PLUGIN > 0
6907 #if HAVE_LTO_PLUGIN == 2
6908 const char *fno_use_linker_plugin
= "fno-use-linker-plugin";
6910 const char *fuse_linker_plugin
= "fuse-linker-plugin";
6914 /* We'll use ld if we can't find collect2. */
6915 if (! strcmp (linker_name_spec
, "collect2"))
6917 char *s
= find_a_file (&exec_prefixes
, "collect2", X_OK
, false);
6919 linker_name_spec
= "ld";
6922 #if HAVE_LTO_PLUGIN > 0
6923 #if HAVE_LTO_PLUGIN == 2
6924 if (!switch_matches (fno_use_linker_plugin
,
6925 fno_use_linker_plugin
6926 + strlen (fno_use_linker_plugin
), 0))
6928 if (switch_matches (fuse_linker_plugin
,
6930 + strlen (fuse_linker_plugin
), 0))
6933 char *temp_spec
= find_a_file (&exec_prefixes
,
6934 LTOPLUGINSONAME
, R_OK
,
6937 fatal_error ("-fuse-linker-plugin, but %s not found",
6939 linker_plugin_file_spec
= convert_white_space (temp_spec
);
6942 lto_gcc_spec
= argv
[0];
6945 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
6947 putenv_from_prefixes (&exec_prefixes
, "COMPILER_PATH", false);
6948 putenv_from_prefixes (&startfile_prefixes
, LIBRARY_PATH_ENV
, true);
6950 if (print_subprocess_help
== 1)
6952 printf (_("\nLinker options\n==============\n\n"));
6953 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
6954 " to the linker.\n\n"));
6957 value
= do_spec (link_command_spec
);
6960 linker_was_run
= (tmp
!= execution_count
);
6963 /* If options said don't run linker,
6964 complain about input files to be given to the linker. */
6966 if (! linker_was_run
&& !seen_error ())
6967 for (i
= 0; (int) i
< n_infiles
; i
++)
6968 if (explicit_link_files
[i
]
6969 && !(infiles
[i
].language
&& infiles
[i
].language
[0] == '*'))
6970 warning (0, "%s: linker input file unused because linking not done",
6973 /* Delete some or all of the temporary files we made. */
6976 delete_failure_queue ();
6977 delete_temp_files ();
6979 if (print_help_list
)
6981 printf (("\nFor bug reporting instructions, please see:\n"));
6982 printf ("%s\n", bug_report_url
);
6986 return (signal_count
!= 0 ? 2
6987 : seen_error () ? (pass_exit_codes
? greatest_status
: 1)
6991 /* Find the proper compilation spec for the file name NAME,
6992 whose length is LENGTH. LANGUAGE is the specified language,
6993 or 0 if this file is to be passed to the linker. */
6995 static struct compiler
*
6996 lookup_compiler (const char *name
, size_t length
, const char *language
)
6998 struct compiler
*cp
;
7000 /* If this was specified by the user to be a linker input, indicate that. */
7001 if (language
!= 0 && language
[0] == '*')
7004 /* Otherwise, look for the language, if one is spec'd. */
7007 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
7008 if (cp
->suffix
[0] == '@' && !strcmp (cp
->suffix
+ 1, language
))
7011 error ("language %s not recognized", language
);
7015 /* Look for a suffix. */
7016 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
7018 if (/* The suffix `-' matches only the file name `-'. */
7019 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
7020 || (strlen (cp
->suffix
) < length
7021 /* See if the suffix matches the end of NAME. */
7022 && !strcmp (cp
->suffix
,
7023 name
+ length
- strlen (cp
->suffix
))
7028 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
7029 /* Look again, but case-insensitively this time. */
7031 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
7033 if (/* The suffix `-' matches only the file name `-'. */
7034 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
7035 || (strlen (cp
->suffix
) < length
7036 /* See if the suffix matches the end of NAME. */
7037 && ((!strcmp (cp
->suffix
,
7038 name
+ length
- strlen (cp
->suffix
))
7039 || !strpbrk (cp
->suffix
, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
7040 && !strcasecmp (cp
->suffix
,
7041 name
+ length
- strlen (cp
->suffix
)))
7047 if (cp
>= compilers
)
7049 if (cp
->spec
[0] != '@')
7050 /* A non-alias entry: return it. */
7053 /* An alias entry maps a suffix to a language.
7054 Search for the language; pass 0 for NAME and LENGTH
7055 to avoid infinite recursion if language not found. */
7056 return lookup_compiler (NULL
, 0, cp
->spec
+ 1);
7062 save_string (const char *s
, int len
)
7064 char *result
= XNEWVEC (char, len
+ 1);
7066 memcpy (result
, s
, len
);
7072 pfatal_with_name (const char *name
)
7074 perror_with_name (name
);
7075 delete_temp_files ();
7080 perror_with_name (const char *name
)
7082 error ("%s: %m", name
);
7086 validate_switches_from_spec (const char *spec
)
7088 const char *p
= spec
;
7091 if (c
== '%' && (*p
== '{' || *p
== '<' || (*p
== 'W' && *++p
== '{')))
7092 /* We have a switch spec. */
7093 p
= validate_switches (p
+ 1);
7097 validate_all_switches (void)
7099 struct compiler
*comp
;
7100 struct spec_list
*spec
;
7102 for (comp
= compilers
; comp
->spec
; comp
++)
7103 validate_switches_from_spec (comp
->spec
);
7105 /* Look through the linked list of specs read from the specs file. */
7106 for (spec
= specs
; spec
; spec
= spec
->next
)
7107 validate_switches_from_spec (*spec
->ptr_spec
);
7109 validate_switches_from_spec (link_command_spec
);
7112 /* Look at the switch-name that comes after START
7113 and mark as valid all supplied switches that match it. */
7116 validate_switches (const char *start
)
7118 const char *p
= start
;
7122 bool suffix
= false;
7123 bool starred
= false;
7125 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7134 if (*p
== '.' || *p
== ',')
7138 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
7139 || *p
== ',' || *p
== '.' || *p
== '@')
7144 starred
= true, p
++;
7150 /* Mark all matching switches as valid. */
7151 for (i
= 0; i
< n_switches
; i
++)
7152 if (!strncmp (switches
[i
].part1
, atom
, len
)
7153 && (starred
|| switches
[i
].part1
[len
] == 0))
7154 switches
[i
].validated
= 1;
7158 if (*p
&& (p
[-1] == '|' || p
[-1] == '&'))
7161 if (*p
&& p
[-1] == ':')
7163 while (*p
&& *p
!= ';' && *p
!= '}')
7168 if (*p
== '{' || *p
== '<')
7169 p
= validate_switches (p
+1);
7170 else if (p
[0] == 'W' && p
[1] == '{')
7171 p
= validate_switches (p
+2);
7178 if (*p
&& p
[-1] == ';')
7192 static struct mdswitchstr
*mdswitches
;
7193 static int n_mdswitches
;
7195 /* Check whether a particular argument was used. The first time we
7196 canonicalize the switches to keep only the ones we care about. */
7199 used_arg (const char *p
, int len
)
7204 const char *replace
;
7209 static struct mswitchstr
*mswitches
;
7210 static int n_mswitches
;
7215 struct mswitchstr
*matches
;
7219 /* Break multilib_matches into the component strings of string
7220 and replacement string. */
7221 for (q
= multilib_matches
; *q
!= '\0'; q
++)
7226 = (struct mswitchstr
*) alloca ((sizeof (struct mswitchstr
)) * cnt
);
7228 q
= multilib_matches
;
7237 fatal_error ("multilib spec %qs is invalid",
7242 matches
[i
].len
= q
- matches
[i
].str
;
7244 matches
[i
].replace
= ++q
;
7245 while (*q
!= ';' && *q
!= '\0')
7248 goto invalid_matches
;
7251 matches
[i
].rep_len
= q
- matches
[i
].replace
;
7257 /* Now build a list of the replacement string for switches that we care
7258 about. Make sure we allocate at least one entry. This prevents
7259 xmalloc from calling fatal, and prevents us from re-executing this
7262 = XNEWVEC (struct mswitchstr
, n_mdswitches
+ (n_switches
? n_switches
: 1));
7263 for (i
= 0; i
< n_switches
; i
++)
7264 if ((switches
[i
].live_cond
& SWITCH_IGNORE
) == 0)
7266 int xlen
= strlen (switches
[i
].part1
);
7267 for (j
= 0; j
< cnt
; j
++)
7268 if (xlen
== matches
[j
].len
7269 && ! strncmp (switches
[i
].part1
, matches
[j
].str
, xlen
))
7271 mswitches
[n_mswitches
].str
= matches
[j
].replace
;
7272 mswitches
[n_mswitches
].len
= matches
[j
].rep_len
;
7273 mswitches
[n_mswitches
].replace
= (char *) 0;
7274 mswitches
[n_mswitches
].rep_len
= 0;
7280 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
7281 on the command line nor any options mutually incompatible with
7283 for (i
= 0; i
< n_mdswitches
; i
++)
7287 for (q
= multilib_options
; *q
!= '\0'; q
++)
7293 while (strncmp (q
, mdswitches
[i
].str
, mdswitches
[i
].len
) != 0
7294 || strchr (" /", q
[mdswitches
[i
].len
]) == NULL
)
7296 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
7303 if (*q
!= ' ' && *q
!= '\0')
7305 while (*r
!= ' ' && *r
!= '\0')
7308 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
7311 if (used_arg (r
, q
- r
))
7316 mswitches
[n_mswitches
].str
= mdswitches
[i
].str
;
7317 mswitches
[n_mswitches
].len
= mdswitches
[i
].len
;
7318 mswitches
[n_mswitches
].replace
= (char *) 0;
7319 mswitches
[n_mswitches
].rep_len
= 0;
7332 for (i
= 0; i
< n_mswitches
; i
++)
7333 if (len
== mswitches
[i
].len
&& ! strncmp (p
, mswitches
[i
].str
, len
))
7340 default_arg (const char *p
, int len
)
7344 for (i
= 0; i
< n_mdswitches
; i
++)
7345 if (len
== mdswitches
[i
].len
&& ! strncmp (p
, mdswitches
[i
].str
, len
))
7351 /* Work out the subdirectory to use based on the options. The format of
7352 multilib_select is a list of elements. Each element is a subdirectory
7353 name followed by a list of options followed by a semicolon. The format
7354 of multilib_exclusions is the same, but without the preceding
7355 directory. First gcc will check the exclusions, if none of the options
7356 beginning with an exclamation point are present, and all of the other
7357 options are present, then we will ignore this completely. Passing
7358 that, gcc will consider each multilib_select in turn using the same
7359 rules for matching the options. If a match is found, that subdirectory
7361 A subdirectory name is optionally followed by a colon and the corresponding
7365 set_multilib_dir (void)
7368 unsigned int this_path_len
;
7369 const char *this_path
, *this_arg
;
7370 const char *start
, *end
;
7372 int ok
, ndfltok
, first
;
7375 start
= multilib_defaults
;
7376 while (*start
== ' ' || *start
== '\t')
7378 while (*start
!= '\0')
7381 while (*start
!= ' ' && *start
!= '\t' && *start
!= '\0')
7383 while (*start
== ' ' || *start
== '\t')
7391 mdswitches
= XNEWVEC (struct mdswitchstr
, n_mdswitches
);
7392 for (start
= multilib_defaults
; *start
!= '\0'; start
= end
+ 1)
7394 while (*start
== ' ' || *start
== '\t')
7400 for (end
= start
+ 1;
7401 *end
!= ' ' && *end
!= '\t' && *end
!= '\0'; end
++)
7404 obstack_grow (&multilib_obstack
, start
, end
- start
);
7405 obstack_1grow (&multilib_obstack
, 0);
7406 mdswitches
[i
].str
= XOBFINISH (&multilib_obstack
, const char *);
7407 mdswitches
[i
++].len
= end
- start
;
7414 p
= multilib_exclusions
;
7417 /* Ignore newlines. */
7424 /* Check the arguments. */
7431 fatal_error ("multilib exclusions %qs is invalid",
7432 multilib_exclusions
);
7442 while (*p
!= ' ' && *p
!= ';')
7445 goto invalid_exclusions
;
7449 if (*this_arg
!= '!')
7457 ok
= used_arg (this_arg
, p
- this_arg
);
7472 p
= multilib_select
;
7475 /* Ignore newlines. */
7482 /* Get the initial path. */
7489 fatal_error ("multilib select %qs is invalid",
7494 this_path_len
= p
- this_path
;
7496 /* Check the arguments. */
7503 goto invalid_select
;
7512 while (*p
!= ' ' && *p
!= ';')
7515 goto invalid_select
;
7519 if (*this_arg
!= '!')
7527 /* If this is a default argument, we can just ignore it.
7528 This is true even if this_arg begins with '!'. Beginning
7529 with '!' does not mean that this argument is necessarily
7530 inappropriate for this library: it merely means that
7531 there is a more specific library which uses this
7532 argument. If this argument is a default, we need not
7533 consider that more specific library. */
7534 ok
= used_arg (this_arg
, p
- this_arg
);
7541 if (default_arg (this_arg
, p
- this_arg
))
7550 if (this_path_len
!= 1
7551 || this_path
[0] != '.')
7553 char *new_multilib_dir
= XNEWVEC (char, this_path_len
+ 1);
7556 strncpy (new_multilib_dir
, this_path
, this_path_len
);
7557 new_multilib_dir
[this_path_len
] = '\0';
7558 q
= strchr (new_multilib_dir
, ':');
7561 multilib_dir
= new_multilib_dir
;
7568 const char *q
= this_path
, *end
= this_path
+ this_path_len
;
7570 while (q
< end
&& *q
!= ':')
7574 const char *q2
= q
+ 1, *ml_end
= end
;
7575 char *new_multilib_os_dir
;
7577 while (q2
< end
&& *q2
!= ':')
7581 new_multilib_os_dir
= XNEWVEC (char, ml_end
- q
);
7582 memcpy (new_multilib_os_dir
, q
+ 1, ml_end
- q
- 1);
7583 new_multilib_os_dir
[ml_end
- q
- 1] = '\0';
7584 multilib_os_dir
= *new_multilib_os_dir
? new_multilib_os_dir
: ".";
7586 if (q2
< end
&& *q2
== ':')
7588 char *new_multiarch_dir
= XNEWVEC (char, end
- q2
);
7589 memcpy (new_multiarch_dir
, q2
+ 1, end
- q2
- 1);
7590 new_multiarch_dir
[end
- q2
- 1] = '\0';
7591 multiarch_dir
= new_multiarch_dir
;
7600 if (multilib_dir
== NULL
&& multilib_os_dir
!= NULL
7601 && strcmp (multilib_os_dir
, ".") == 0)
7603 free (CONST_CAST (char *, multilib_os_dir
));
7604 multilib_os_dir
= NULL
;
7606 else if (multilib_dir
!= NULL
&& multilib_os_dir
== NULL
)
7607 multilib_os_dir
= multilib_dir
;
7610 /* Print out the multiple library subdirectory selection
7611 information. This prints out a series of lines. Each line looks
7612 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
7613 required. Only the desired options are printed out, the negative
7614 matches. The options are print without a leading dash. There are
7615 no spaces to make it easy to use the information in the shell.
7616 Each subdirectory is printed only once. This assumes the ordering
7617 generated by the genmultilib script. Also, we leave out ones that match
7621 print_multilib_info (void)
7623 const char *p
= multilib_select
;
7624 const char *last_path
= 0, *this_path
;
7626 unsigned int last_path_len
= 0;
7631 /* Ignore newlines. */
7638 /* Get the initial path. */
7645 fatal_error ("multilib select %qs is invalid", multilib_select
);
7651 /* When --disable-multilib was used but target defines
7652 MULTILIB_OSDIRNAMES, entries starting with .: (and not starting
7653 with .:: for multiarch configurations) are there just to find
7654 multilib_os_dir, so skip them from output. */
7655 if (this_path
[0] == '.' && this_path
[1] == ':' && this_path
[2] != ':')
7658 /* Check for matches with the multilib_exclusions. We don't bother
7659 with the '!' in either list. If any of the exclusion rules match
7660 all of its options with the select rule, we skip it. */
7662 const char *e
= multilib_exclusions
;
7663 const char *this_arg
;
7668 /* Ignore newlines. */
7675 /* Check the arguments. */
7684 fatal_error ("multilib exclusion %qs is invalid",
7685 multilib_exclusions
);
7696 while (*e
!= ' ' && *e
!= ';')
7699 goto invalid_exclusion
;
7707 int len
= e
- this_arg
;
7710 goto invalid_select
;
7714 while (*q
!= ' ' && *q
!= ';')
7717 goto invalid_select
;
7721 if (! strncmp (arg
, this_arg
,
7722 (len
< q
- arg
) ? q
- arg
: len
)
7723 || default_arg (this_arg
, e
- this_arg
))
7753 /* If this is a duplicate, skip it. */
7754 skip
= (last_path
!= 0
7755 && (unsigned int) (p
- this_path
) == last_path_len
7756 && ! filename_ncmp (last_path
, this_path
, last_path_len
));
7758 last_path
= this_path
;
7759 last_path_len
= p
- this_path
;
7762 /* If this directory requires any default arguments, we can skip
7763 it. We will already have printed a directory identical to
7764 this one which does not require that default argument. */
7775 goto invalid_select
;
7782 while (*q
!= ' ' && *q
!= ';')
7785 goto invalid_select
;
7790 && default_arg (arg
, q
- arg
))
7805 for (p1
= last_path
; p1
< p
&& *p1
!= ':'; p1
++)
7816 goto invalid_select
;
7824 use_arg
= *p
!= '!';
7829 while (*p
!= ' ' && *p
!= ';')
7832 goto invalid_select
;
7844 /* If there are extra options, print them now. */
7845 if (multilib_extra
&& *multilib_extra
)
7847 int print_at
= TRUE
;
7850 for (q
= multilib_extra
; *q
!= '\0'; q
++)
7871 /* getenv built-in spec function.
7873 Returns the value of the environment variable given by its first
7874 argument, concatenated with the second argument. If the
7875 environment variable is not defined, a fatal error is issued. */
7878 getenv_spec_function (int argc
, const char **argv
)
7888 value
= getenv (argv
[0]);
7890 fatal_error ("environment variable %qs not defined", argv
[0]);
7892 /* We have to escape every character of the environment variable so
7893 they are not interpreted as active spec characters. A
7894 particularly painful case is when we are reading a variable
7895 holding a windows path complete with \ separators. */
7896 len
= strlen (value
) * 2 + strlen (argv
[1]) + 1;
7897 result
= XNEWVAR (char, len
);
7898 for (ptr
= result
; *value
; ptr
+= 2)
7904 strcpy (ptr
, argv
[1]);
7909 /* if-exists built-in spec function.
7911 Checks to see if the file specified by the absolute pathname in
7912 ARGS exists. Returns that pathname if found.
7914 The usual use for this function is to check for a library file
7915 (whose name has been expanded with %s). */
7918 if_exists_spec_function (int argc
, const char **argv
)
7920 /* Must have only one argument. */
7921 if (argc
== 1 && IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
7927 /* if-exists-else built-in spec function.
7929 This is like if-exists, but takes an additional argument which
7930 is returned if the first argument does not exist. */
7933 if_exists_else_spec_function (int argc
, const char **argv
)
7935 /* Must have exactly two arguments. */
7939 if (IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
7945 /* replace-outfile built-in spec function.
7947 This looks for the first argument in the outfiles array's name and
7948 replaces it with the second argument. */
7951 replace_outfile_spec_function (int argc
, const char **argv
)
7954 /* Must have exactly two arguments. */
7958 for (i
= 0; i
< n_infiles
; i
++)
7960 if (outfiles
[i
] && !filename_cmp (outfiles
[i
], argv
[0]))
7961 outfiles
[i
] = xstrdup (argv
[1]);
7966 /* remove-outfile built-in spec function.
7968 * This looks for the first argument in the outfiles array's name and
7972 remove_outfile_spec_function (int argc
, const char **argv
)
7975 /* Must have exactly one argument. */
7979 for (i
= 0; i
< n_infiles
; i
++)
7981 if (outfiles
[i
] && !filename_cmp (outfiles
[i
], argv
[0]))
7987 /* Given two version numbers, compares the two numbers.
7988 A version number must match the regular expression
7989 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
7992 compare_version_strings (const char *v1
, const char *v2
)
7997 if (regcomp (&r
, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
7998 REG_EXTENDED
| REG_NOSUB
) != 0)
8000 rresult
= regexec (&r
, v1
, 0, NULL
, 0);
8001 if (rresult
== REG_NOMATCH
)
8002 fatal_error ("invalid version number %qs", v1
);
8003 else if (rresult
!= 0)
8005 rresult
= regexec (&r
, v2
, 0, NULL
, 0);
8006 if (rresult
== REG_NOMATCH
)
8007 fatal_error ("invalid version number %qs", v2
);
8008 else if (rresult
!= 0)
8011 return strverscmp (v1
, v2
);
8015 /* version_compare built-in spec function.
8017 This takes an argument of the following form:
8019 <comparison-op> <arg1> [<arg2>] <switch> <result>
8021 and produces "result" if the comparison evaluates to true,
8022 and nothing if it doesn't.
8024 The supported <comparison-op> values are:
8026 >= true if switch is a later (or same) version than arg1
8028 < true if switch is an earlier version than arg1
8030 >< true if switch is arg1 or later, and earlier than arg2
8031 <> true if switch is earlier than arg1 or is arg2 or later
8033 If the switch is not present, the condition is false unless
8034 the first character of the <comparison-op> is '!'.
8037 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
8038 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
8041 version_compare_spec_function (int argc
, const char **argv
)
8045 const char *switch_value
= NULL
;
8050 fatal_error ("too few arguments to %%:version-compare");
8051 if (argv
[0][0] == '\0')
8053 if ((argv
[0][1] == '<' || argv
[0][1] == '>') && argv
[0][0] != '!')
8055 if (argc
!= nargs
+ 3)
8056 fatal_error ("too many arguments to %%:version-compare");
8058 switch_len
= strlen (argv
[nargs
+ 1]);
8059 for (i
= 0; i
< n_switches
; i
++)
8060 if (!strncmp (switches
[i
].part1
, argv
[nargs
+ 1], switch_len
)
8061 && check_live_switch (i
, switch_len
))
8062 switch_value
= switches
[i
].part1
+ switch_len
;
8064 if (switch_value
== NULL
)
8068 comp1
= compare_version_strings (switch_value
, argv
[1]);
8070 comp2
= compare_version_strings (switch_value
, argv
[2]);
8072 comp2
= -1; /* This value unused. */
8075 switch (argv
[0][0] << 8 | argv
[0][1])
8077 case '>' << 8 | '=':
8078 result
= comp1
>= 0;
8080 case '!' << 8 | '<':
8081 result
= comp1
>= 0 || switch_value
== NULL
;
8086 case '!' << 8 | '>':
8087 result
= comp1
< 0 || switch_value
== NULL
;
8089 case '>' << 8 | '<':
8090 result
= comp1
>= 0 && comp2
< 0;
8092 case '<' << 8 | '>':
8093 result
= comp1
< 0 || comp2
>= 0;
8097 fatal_error ("unknown operator %qs in %%:version-compare", argv
[0]);
8102 return argv
[nargs
+ 2];
8105 /* %:include builtin spec function. This differs from %include in that it
8106 can be nested inside a spec, and thus be conditionalized. It takes
8107 one argument, the filename, and looks for it in the startfile path.
8108 The result is always NULL, i.e. an empty expansion. */
8111 include_spec_function (int argc
, const char **argv
)
8118 file
= find_a_file (&startfile_prefixes
, argv
[0], R_OK
, true);
8119 read_specs (file
? file
: argv
[0], FALSE
);
8124 /* %:find-file spec function. This function replaces its argument by
8125 the file found thru find_file, that is the -print-file-name gcc
8128 find_file_spec_function (int argc
, const char **argv
)
8135 file
= find_file (argv
[0]);
8140 /* %:find-plugindir spec function. This function replaces its argument
8141 by the -iplugindir=<dir> option. `dir' is found thru find_file, that
8142 is the -print-file-name gcc program option. */
8144 find_plugindir_spec_function (int argc
, const char **argv ATTRIBUTE_UNUSED
)
8151 option
= concat ("-iplugindir=", find_file ("plugin"), NULL
);
8156 /* %:print-asm-header spec function. Print a banner to say that the
8157 following output is from the assembler. */
8160 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED
,
8161 const char **argv ATTRIBUTE_UNUSED
)
8163 printf (_("Assembler options\n=================\n\n"));
8164 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
8169 /* Get a random number for -frandom-seed */
8171 static unsigned HOST_WIDE_INT
8172 get_random_number (void)
8174 unsigned HOST_WIDE_INT ret
= 0;
8177 fd
= open ("/dev/urandom", O_RDONLY
);
8180 read (fd
, &ret
, sizeof (HOST_WIDE_INT
));
8186 /* Get some more or less random data. */
8187 #ifdef HAVE_GETTIMEOFDAY
8191 gettimeofday (&tv
, NULL
);
8192 ret
= tv
.tv_sec
* 1000 + tv
.tv_usec
/ 1000;
8196 time_t now
= time (NULL
);
8198 if (now
!= (time_t)-1)
8199 ret
= (unsigned) now
;
8203 return ret
^ getpid();
8206 /* %:compare-debug-dump-opt spec function. Save the last argument,
8207 expected to be the last -fdump-final-insns option, or generate a
8211 compare_debug_dump_opt_spec_function (int arg
,
8212 const char **argv ATTRIBUTE_UNUSED
)
8217 static char random_seed
[HOST_BITS_PER_WIDE_INT
/ 4 + 3];
8220 fatal_error ("too many arguments to %%:compare-debug-dump-opt");
8222 do_spec_2 ("%{fdump-final-insns=*:%*}");
8223 do_spec_1 (" ", 0, NULL
);
8225 if (VEC_length (const_char_p
, argbuf
) > 0
8226 && strcmp (argv
[VEC_length (const_char_p
, argbuf
) - 1], "."))
8231 name
= xstrdup (argv
[VEC_length (const_char_p
, argbuf
) - 1]);
8236 const char *ext
= NULL
;
8238 if (VEC_length (const_char_p
, argbuf
) > 0)
8240 do_spec_2 ("%{o*:%*}%{!o:%{!S:%b%O}%{S:%b.s}}");
8243 else if (!compare_debug
)
8246 do_spec_2 ("%g.gkd");
8248 do_spec_1 (" ", 0, NULL
);
8250 gcc_assert (VEC_length (const_char_p
, argbuf
) > 0);
8252 name
= concat (VEC_last (const_char_p
, argbuf
), ext
, NULL
);
8254 ret
= concat ("-fdump-final-insns=", name
, NULL
);
8257 which
= compare_debug
< 0;
8258 debug_check_temp_file
[which
] = name
;
8262 unsigned HOST_WIDE_INT value
= get_random_number ();
8264 sprintf (random_seed
, HOST_WIDE_INT_PRINT_HEX
, value
);
8268 ret
= concat ("%{!frandom-seed=*:-frandom-seed=", random_seed
, "} ",
8277 static const char *debug_auxbase_opt
;
8279 /* %:compare-debug-self-opt spec function. Expands to the options
8280 that are to be passed in the second compilation of
8284 compare_debug_self_opt_spec_function (int arg
,
8285 const char **argv ATTRIBUTE_UNUSED
)
8288 fatal_error ("too many arguments to %%:compare-debug-self-opt");
8290 if (compare_debug
>= 0)
8293 do_spec_2 ("%{c|S:%{o*:%*}}");
8294 do_spec_1 (" ", 0, NULL
);
8296 if (VEC_length (const_char_p
, argbuf
) > 0)
8297 debug_auxbase_opt
= concat ("-auxbase-strip ",
8298 VEC_last (const_char_p
, argbuf
),
8301 debug_auxbase_opt
= NULL
;
8304 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
8305 %<fdump-final-insns=* -w -S -o %j \
8306 %{!fcompare-debug-second:-fcompare-debug-second} \
8307 ", compare_debug_opt
, NULL
);
8310 /* %:compare-debug-auxbase-opt spec function. Expands to the auxbase
8311 options that are to be passed in the second compilation of
8312 compare-debug. It expects, as an argument, the basename of the
8313 current input file name, with the .gk suffix appended to it. */
8316 compare_debug_auxbase_opt_spec_function (int arg
,
8323 fatal_error ("too few arguments to %%:compare-debug-auxbase-opt");
8326 fatal_error ("too many arguments to %%:compare-debug-auxbase-opt");
8328 if (compare_debug
>= 0)
8331 len
= strlen (argv
[0]);
8332 if (len
< 3 || strcmp (argv
[0] + len
- 3, ".gk") != 0)
8333 fatal_error ("argument to %%:compare-debug-auxbase-opt "
8334 "does not end in .gk");
8336 if (debug_auxbase_opt
)
8337 return debug_auxbase_opt
;
8339 #define OPT "-auxbase "
8342 name
= (char*) xmalloc (sizeof (OPT
) + len
);
8343 memcpy (name
, OPT
, sizeof (OPT
) - 1);
8344 memcpy (name
+ sizeof (OPT
) - 1, argv
[0], len
);
8345 name
[sizeof (OPT
) - 1 + len
] = '\0';
8352 /* %:pass-through-libs spec function. Finds all -l options and input
8353 file names in the lib spec passed to it, and makes a list of them
8354 prepended with the plugin option to cause them to be passed through
8355 to the final link after all the new object files have been added. */
8358 pass_through_libs_spec_func (int argc
, const char **argv
)
8360 char *prepended
= xstrdup (" ");
8362 /* Shlemiel the painter's algorithm. Innately horrible, but at least
8363 we know that there will never be more than a handful of strings to
8364 concat, and it's only once per run, so it's not worth optimising. */
8365 for (n
= 0; n
< argc
; n
++)
8367 char *old
= prepended
;
8368 /* Anything that isn't an option is a full path to an output
8369 file; pass it through if it ends in '.a'. Among options,
8371 if (argv
[n
][0] == '-' && argv
[n
][1] == 'l')
8373 const char *lopt
= argv
[n
] + 2;
8374 /* Handle both joined and non-joined -l options. If for any
8375 reason there's a trailing -l with no joined or following
8376 arg just discard it. */
8377 if (!*lopt
&& ++n
>= argc
)
8381 prepended
= concat (prepended
, "-plugin-opt=-pass-through=-l",
8384 else if (!strcmp (".a", argv
[n
] + strlen (argv
[n
]) - 2))
8386 prepended
= concat (prepended
, "-plugin-opt=-pass-through=",
8387 argv
[n
], " ", NULL
);
8389 if (prepended
!= old
)
8395 /* Insert backslash before spaces in ORIG (usually a file path), to
8396 avoid being broken by spec parser.
8398 This function is needed as do_spec_1 treats white space (' ' and '\t')
8399 as the end of an argument. But in case of -plugin /usr/gcc install/xxx.so,
8400 the file name should be treated as a single argument rather than being
8401 broken into multiple. Solution is to insert '\\' before the space in a
8404 This function converts and only converts all occurrence of ' '
8405 to '\\' + ' ' and '\t' to '\\' + '\t'. For example:
8409 "a\\ b" -> "a\\\\ b"
8411 orig: input null-terminating string that was allocated by xalloc. The
8412 memory it points to might be freed in this function. Behavior undefined
8413 if ORIG wasn't xalloced or was freed already at entry.
8415 Return: ORIG if no conversion needed. Otherwise a newly allocated string
8416 that was converted from ORIG. */
8419 convert_white_space (char *orig
)
8421 int len
, number_of_space
= 0;
8423 for (len
= 0; orig
[len
]; len
++)
8424 if (orig
[len
] == ' ' || orig
[len
] == '\t') number_of_space
++;
8426 if (number_of_space
)
8428 char *new_spec
= (char *) xmalloc (len
+ number_of_space
+ 1);
8430 for (j
= 0, k
= 0; j
<= len
; j
++, k
++)
8432 if (orig
[j
] == ' ' || orig
[j
] == '\t')
8433 new_spec
[k
++] = '\\';
8434 new_spec
[k
] = orig
[j
];