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 Free Software Foundation,
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 2, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
23 This paragraph is here to try to keep Sun CC from dying.
24 The number of chars here seems crucial!!!! */
26 /* This program is the user interface to the C compiler and possibly to
27 other compilers. It is used because compilation is a complicated procedure
28 which involves running several programs and passing temporary files between
29 them, forwarding the users switches to those programs selectively,
30 and deleting the temporary files at the end.
32 CC recognizes how to compile each input file by suffixes in the file names.
33 Once it knows which kind of compilation to perform, the procedure for
34 compilation is specified by a string called a "spec". */
36 /* A Short Introduction to Adding a Command-Line Option.
38 Before adding a command-line option, consider if it is really
39 necessary. Each additional command-line option adds complexity and
40 is difficult to remove in subsequent versions.
42 In the following, consider adding the command-line argument
45 1. Each command-line option is specified in the specs file. The
46 notation is described below in the comment entitled "The Specs
49 2. In this file, add an entry to "option_map" equating the long
50 `--' argument version and any shorter, single letter version. Read
51 the comments in the declaration of "struct option_map" for an
52 explanation. Do not omit the first `-'.
54 3. Look in the "specs" file to determine which program or option
55 list should be given the argument, e.g., "cc1_options". Add the
56 appropriate syntax for the shorter option version to the
57 corresponding "const char *" entry in this file. Omit the first
58 `-' from the option. For example, use `-bar', rather than `--bar'.
60 4. If the argument takes an argument, e.g., `--baz argument1',
61 modify either DEFAULT_SWITCH_TAKES_ARG or
62 DEFAULT_WORD_SWITCH_TAKES_ARG in gcc.h. Omit the first `-'
65 5. Document the option in this file's display_help(). If the
66 option is passed to a subprogram, modify its corresponding
67 function, e.g., cppinit.c:print_help() or toplev.c:display_help(),
70 6. Compile and test. Make sure that your new specs file is being
71 read. For example, use a debugger to investigate the value of
72 "specs_file" in main(). */
76 #include "coretypes.h"
77 #include "multilib.h" /* before tm.h */
80 #if ! defined( SIGCHLD ) && defined( SIGCLD )
81 # define SIGCHLD SIGCLD
90 /* By default there is no special suffix for target executables. */
91 /* FIXME: when autoconf is fixed, remove the host check - dj */
92 #if defined(TARGET_EXECUTABLE_SUFFIX) && defined(HOST_EXECUTABLE_SUFFIX)
93 #define HAVE_TARGET_EXECUTABLE_SUFFIX
96 /* By default there is no special suffix for host executables. */
97 #ifdef HOST_EXECUTABLE_SUFFIX
98 #define HAVE_HOST_EXECUTABLE_SUFFIX
100 #define HOST_EXECUTABLE_SUFFIX ""
103 /* By default, the suffix for target object files is ".o". */
104 #ifdef TARGET_OBJECT_SUFFIX
105 #define HAVE_TARGET_OBJECT_SUFFIX
107 #define TARGET_OBJECT_SUFFIX ".o"
110 static const char dir_separator_str
[] = { DIR_SEPARATOR
, 0 };
112 /* Most every one is fine with LIBRARY_PATH. For some, it conflicts. */
113 #ifndef LIBRARY_PATH_ENV
114 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
118 #define kill(p,s) raise(s)
121 /* If a stage of compilation returns an exit status >= 1,
122 compilation of that file ceases. */
124 #define MIN_FATAL_STATUS 1
126 /* Flag set by cppspec.c to 1. */
129 /* Flag saying to pass the greatest exit code returned by a sub-process
130 to the calling program. */
131 static int pass_exit_codes
;
133 /* Definition of string containing the arguments given to configure. */
134 #include "configargs.h"
136 /* Flag saying to print the directories gcc will search through looking for
137 programs, libraries, etc. */
139 static int print_search_dirs
;
141 /* Flag saying to print the full filename of this file
142 as found through our usual search mechanism. */
144 static const char *print_file_name
= NULL
;
146 /* As print_file_name, but search for executable file. */
148 static const char *print_prog_name
= NULL
;
150 /* Flag saying to print the relative path we'd use to
151 find libgcc.a given the current compiler flags. */
153 static int print_multi_directory
;
155 /* Flag saying to print the relative path we'd use to
156 find OS libraries given the current compiler flags. */
158 static int print_multi_os_directory
;
160 /* Flag saying to print the list of subdirectories and
161 compiler flags used to select them in a standard form. */
163 static int print_multi_lib
;
165 /* Flag saying to print the command line options understood by gcc and its
168 static int print_help_list
;
170 /* Flag indicating whether we should print the command and arguments */
172 static int verbose_flag
;
174 /* Flag indicating whether we should ONLY print the command and
175 arguments (like verbose_flag) without executing the command.
176 Displayed arguments are quoted so that the generated command
177 line is suitable for execution. This is intended for use in
178 shell scripts to capture the driver-generated command line. */
179 static int verbose_only_flag
;
181 /* Flag indicating to print target specific command line options. */
183 static int target_help_flag
;
185 /* Flag indicating whether we should report subprocess execution times
186 (if this is supported by the system - see pexecute.c). */
188 static int report_times
;
190 /* Nonzero means place this string before uses of /, so that include
191 and library files can be found in an alternate location. */
193 #ifdef TARGET_SYSTEM_ROOT
194 static const char *target_system_root
= TARGET_SYSTEM_ROOT
;
196 static const char *target_system_root
= 0;
199 /* Nonzero means pass the updated target_system_root to the compiler. */
201 static int target_system_root_changed
;
203 /* Nonzero means append this string to target_system_root. */
205 static const char *target_sysroot_suffix
= 0;
207 /* Nonzero means append this string to target_system_root for headers. */
209 static const char *target_sysroot_hdrs_suffix
= 0;
211 /* Nonzero means write "temp" files in source directory
212 and use the source file's name in them, and don't delete them. */
214 static int save_temps_flag
;
216 /* Nonzero means pass multiple source files to the compiler at one time. */
218 static int combine_flag
= 0;
220 /* Nonzero means use pipes to communicate between subprocesses.
221 Overridden by either of the above two flags. */
223 static int use_pipes
;
225 /* The compiler version. */
227 static const char *compiler_version
;
229 /* The target version specified with -V */
231 static const char *const spec_version
= DEFAULT_TARGET_VERSION
;
233 /* The target machine specified with -b. */
235 static const char *spec_machine
= DEFAULT_TARGET_MACHINE
;
237 /* Nonzero if cross-compiling.
238 When -b is used, the value comes from the `specs' file. */
241 static const char *cross_compile
= "1";
243 static const char *cross_compile
= "0";
246 #ifdef MODIFY_TARGET_NAME
248 /* Information on how to alter the target name based on a command-line
249 switch. The only case we support now is simply appending or deleting a
250 string to or from the end of the first part of the configuration name. */
252 static const struct modify_target
254 const char *const sw
;
255 const enum add_del
{ADD
, DELETE
} add_del
;
256 const char *const str
;
258 modify_target
[] = MODIFY_TARGET_NAME
;
261 /* The number of errors that have occurred; the link phase will not be
262 run if this is nonzero. */
263 static int error_count
= 0;
265 /* Greatest exit code of sub-processes that has been encountered up to
267 static int greatest_status
= 1;
269 /* This is the obstack which we use to allocate many strings. */
271 static struct obstack obstack
;
273 /* This is the obstack to build an environment variable to pass to
274 collect2 that describes all of the relevant switches of what to
275 pass the compiler in building the list of pointers to constructors
278 static struct obstack collect_obstack
;
280 /* Forward declaration for prototypes. */
284 static void init_spec (void);
285 static void store_arg (const char *, int, int);
286 static char *load_specs (const char *);
287 static void read_specs (const char *, int);
288 static void set_spec (const char *, const char *);
289 static struct compiler
*lookup_compiler (const char *, size_t, const char *);
290 static char *build_search_list (struct path_prefix
*, const char *, int);
291 static void putenv_from_prefixes (struct path_prefix
*, const char *);
292 static int access_check (const char *, int);
293 static char *find_a_file (struct path_prefix
*, const char *, int, int);
294 static void add_prefix (struct path_prefix
*, const char *, const char *,
296 static void add_sysrooted_prefix (struct path_prefix
*, const char *,
297 const char *, int, int, int);
298 static void translate_options (int *, const char *const **);
299 static char *skip_whitespace (char *);
300 static void delete_if_ordinary (const char *);
301 static void delete_temp_files (void);
302 static void delete_failure_queue (void);
303 static void clear_failure_queue (void);
304 static int check_live_switch (int, int);
305 static const char *handle_braces (const char *);
306 static inline bool input_suffix_matches (const char *, const char *);
307 static inline bool switch_matches (const char *, const char *, int);
308 static inline void mark_matching_switches (const char *, const char *, int);
309 static inline void process_marked_switches (void);
310 static const char *process_brace_body (const char *, const char *, const char *, int, int);
311 static const struct spec_function
*lookup_spec_function (const char *);
312 static const char *eval_spec_function (const char *, const char *);
313 static const char *handle_spec_function (const char *);
314 static char *save_string (const char *, int);
315 static void set_collect_gcc_options (void);
316 static void do_spec_path (struct prefix_list
*, const char *, int, int, int, const char *, const char *);
317 static int do_spec_1 (const char *, int, const char *);
318 static int do_spec_2 (const char *);
319 static void do_option_spec (const char *, const char *);
320 static void do_self_spec (const char *);
321 static const char *find_file (const char *);
322 static int is_directory (const char *, const char *, int);
323 static const char *validate_switches (const char *);
324 static void validate_all_switches (void);
325 static inline void validate_switches_from_spec (const char *);
326 static void give_switch (int, int);
327 static int used_arg (const char *, int);
328 static int default_arg (const char *, int);
329 static void set_multilib_dir (void);
330 static void print_multilib_info (void);
331 static void perror_with_name (const char *);
332 static void notice (const char *, ...) ATTRIBUTE_PRINTF_1
;
333 static void display_help (void);
334 static void add_preprocessor_option (const char *, int);
335 static void add_assembler_option (const char *, int);
336 static void add_linker_option (const char *, int);
337 static void process_command (int, const char **);
338 static int execute (void);
339 static void alloc_args (void);
340 static void clear_args (void);
341 static void fatal_error (int);
342 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
343 static void init_gcc_specs (struct obstack
*, const char *, const char *,
346 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
347 static const char *convert_filename (const char *, int, int);
350 static const char *if_exists_spec_function (int, const char **);
351 static const char *if_exists_else_spec_function (int, const char **);
352 static const char *replace_outfile_spec_function (int, const char **);
353 static const char *version_compare_spec_function (int, const char **);
355 /* The Specs Language
357 Specs are strings containing lines, each of which (if not blank)
358 is made up of a program name, and arguments separated by spaces.
359 The program name must be exact and start from root, since no path
360 is searched and it is unreliable to depend on the current working directory.
361 Redirection of input or output is not supported; the subprograms must
362 accept filenames saying what files to read and write.
364 In addition, the specs can contain %-sequences to substitute variable text
365 or for conditional text. Here is a table of all defined %-sequences.
366 Note that spaces are not generated automatically around the results of
367 expanding these sequences; therefore, you can concatenate them together
368 or with constant text in a single argument.
370 %% substitute one % into the program name or argument.
371 %i substitute the name of the input file being processed.
372 %b substitute the basename of the input file being processed.
373 This is the substring up to (and not including) the last period
374 and not including the directory.
375 %B same as %b, but include the file suffix (text after the last period).
377 substitute a file name that has suffix SUFFIX and is chosen
378 once per compilation, and mark the argument a la %d. To reduce
379 exposure to denial-of-service attacks, the file name is now
380 chosen in a way that is hard to predict even when previously
381 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
382 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
383 the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
384 had been pre-processed. Previously, %g was simply substituted
385 with a file name chosen once per compilation, without regard
386 to any appended suffix (which was therefore treated just like
387 ordinary text), making such attacks more likely to succeed.
389 like %g, but if -pipe is in effect, expands simply to "-".
391 like %g, but if -pipe is in effect, expands to nothing. (We have both
392 %| and %m to accommodate differences between system assemblers; see
393 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
395 like %g, but generates a new temporary file name even if %uSUFFIX
398 substitutes the last file name generated with %uSUFFIX, generating a
399 new one if there is no such last file name. In the absence of any
400 %uSUFFIX, this is just like %gSUFFIX, except they don't share
401 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
402 would involve the generation of two distinct file names, one
403 for each `%g.s' and another for each `%U.s'. Previously, %U was
404 simply substituted with a file name chosen for the previous %u,
405 without regard to any appended suffix.
407 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
408 writable, and if save-temps is off; otherwise, substitute the name
409 of a temporary file, just like %u. This temporary file is not
410 meant for communication between processes, but rather as a junk
413 substitutes .SUFFIX for the suffixes of a matched switch's args when
414 it is subsequently output with %*. SUFFIX is terminated by the next
416 %d marks the argument containing or following the %d as a
417 temporary file name, so that that file will be deleted if CC exits
418 successfully. Unlike %g, this contributes no text to the argument.
419 %w marks the argument containing or following the %w as the
420 "output file" of this compilation. This puts the argument
421 into the sequence of arguments that %o will substitute later.
422 %V indicates that this compilation produces no "output file".
424 like %{...} but mark last argument supplied within
425 as a file to be deleted on failure.
426 %o substitutes the names of all the output files, with spaces
427 automatically placed around them. You should write spaces
428 around the %o as well or the results are undefined.
429 %o is for use in the specs for running the linker.
430 Input files whose names have no recognized suffix are not compiled
431 at all, but they are included among the output files, so they will
433 %O substitutes the suffix for object files. Note that this is
434 handled specially when it immediately follows %g, %u, or %U
435 (with or without a suffix argument) because of the need for
436 those to form complete file names. The handling is such that
437 %O is treated exactly as if it had already been substituted,
438 except that %g, %u, and %U do not currently support additional
439 SUFFIX characters following %O as they would following, for
441 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
442 (made from TARGET_SYSTEM_ROOT), and -isystem (made from COMPILER_PATH
443 and -B options) as necessary.
444 %s current argument is the name of a library or startup file of some sort.
445 Search for that file in a standard list of directories
446 and substitute the full name found.
447 %eSTR Print STR as an error message. STR is terminated by a newline.
448 Use this when inconsistent options are detected.
449 %nSTR Print STR as a notice. STR is terminated by a newline.
450 %x{OPTION} Accumulate an option for %X.
451 %X Output the accumulated linker options specified by compilations.
452 %Y Output the accumulated assembler options specified by compilations.
453 %Z Output the accumulated preprocessor options specified by compilations.
454 %a process ASM_SPEC as a spec.
455 This allows config.h to specify part of the spec for running as.
456 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
457 used here. This can be used to run a post-processor after the
458 assembler has done its job.
459 %D Dump out a -L option for each directory in startfile_prefixes.
460 If multilib_dir is set, extra entries are generated with it affixed.
461 %l process LINK_SPEC as a spec.
462 %L process LIB_SPEC as a spec.
463 %G process LIBGCC_SPEC as a spec.
464 %R Output the concatenation of target_system_root and
465 target_sysroot_suffix.
466 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
467 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
468 %C process CPP_SPEC as a spec.
469 %1 process CC1_SPEC as a spec.
470 %2 process CC1PLUS_SPEC as a spec.
471 %* substitute the variable part of a matched option. (See below.)
472 Note that each comma in the substituted string is replaced by
474 %<S remove all occurrences of -S from the command line.
475 Note - this command is position dependent. % commands in the
476 spec string before this one will see -S, % commands in the
477 spec string after this one will not.
478 %<S* remove all occurrences of all switches beginning with -S from the
481 Call the named function FUNCTION, passing it ARGS. ARGS is
482 first processed as a nested spec string, then split into an
483 argument vector in the usual fashion. The function returns
484 a string which is processed as if it had appeared literally
485 as part of the current spec.
486 %{S} substitutes the -S switch, if that switch was given to CC.
487 If that switch was not specified, this substitutes nothing.
488 Here S is a metasyntactic variable.
489 %{S*} substitutes all the switches specified to CC whose names start
490 with -S. This is used for -o, -I, etc; switches that take
491 arguments. CC considers `-o foo' as being one switch whose
492 name starts with `o'. %{o*} would substitute this text,
493 including the space; thus, two arguments would be generated.
494 %{S*&T*} likewise, but preserve order of S and T options (the order
495 of S and T in the spec is not significant). Can be any number
496 of ampersand-separated variables; for each the wild card is
497 optional. Useful for CPP as %{D*&U*&A*}.
499 %{S:X} substitutes X, if the -S switch was given to CC.
500 %{!S:X} substitutes X, if the -S switch was NOT given to CC.
501 %{S*:X} substitutes X if one or more switches whose names start
502 with -S was given to CC. Normally X is substituted only
503 once, no matter how many such switches appeared. However,
504 if %* appears somewhere in X, then X will be substituted
505 once for each matching switch, with the %* replaced by the
506 part of that switch that matched the '*'.
507 %{.S:X} substitutes X, if processing a file with suffix S.
508 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
510 %{S|T:X} substitutes X if either -S or -T was given to CC. This may be
511 combined with !, ., and * as above binding stronger than the OR.
512 If %* appears in X, all of the alternatives must be starred, and
513 only the first matching alternative is substituted.
514 %{S:X; if S was given to CC, substitutes X;
515 T:Y; else if T was given to CC, substitutes Y;
516 :D} else substitutes D. There can be as many clauses as you need.
517 This may be combined with ., !, |, and * as above.
519 %(Spec) processes a specification defined in a specs file as *Spec:
520 %[Spec] as above, but put __ around -D arguments
522 The conditional text X in a %{S:X} or similar construct may contain
523 other nested % constructs or spaces, or even newlines. They are
524 processed as usual, as described above. Trailing white space in X is
525 ignored. White space may also appear anywhere on the left side of the
526 colon in these constructs, except between . or * and the corresponding
529 The -O, -f, -m, and -W switches are handled specifically in these
530 constructs. If another value of -O or the negated form of a -f, -m, or
531 -W switch is found later in the command line, the earlier switch
532 value is ignored, except with {S*} where S is just one letter; this
533 passes all matching options.
535 The character | at the beginning of the predicate text is used to indicate
536 that a command should be piped to the following command, but only if -pipe
539 Note that it is built into CC which switches take arguments and which
540 do not. You might think it would be useful to generalize this to
541 allow each compiler's spec to say which switches take arguments. But
542 this cannot be done in a consistent fashion. CC cannot even decide
543 which input files have been specified without knowing which switches
544 take arguments, and it must know which input files to compile in order
545 to tell which compilers to run.
547 CC also knows implicitly that arguments starting in `-l' are to be
548 treated as compiler output files, and passed to the linker in their
549 proper position among the other output files. */
551 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
553 /* config.h can define ASM_SPEC to provide extra args to the assembler
554 or extra switch-translations. */
559 /* config.h can define ASM_FINAL_SPEC to run a post processor after
560 the assembler has run. */
561 #ifndef ASM_FINAL_SPEC
562 #define ASM_FINAL_SPEC ""
565 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
566 or extra switch-translations. */
571 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
572 or extra switch-translations. */
577 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
578 or extra switch-translations. */
580 #define CC1PLUS_SPEC ""
583 /* config.h can define LINK_SPEC to provide extra args to the linker
584 or extra switch-translations. */
589 /* config.h can define LIB_SPEC to override the default libraries. */
591 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
596 /* XXX: valid only for GNU ld */
597 /* XXX: should exactly match hooks provided by libmudflap.a */
598 #define MFWRAP_SPEC " %{static: %{fmudflap|fmudflapth: \
599 --wrap=malloc --wrap=free --wrap=calloc --wrap=realloc\
600 --wrap=mmap --wrap=munmap --wrap=alloca\
601 } %{fmudflapth: --wrap=pthread_create\
602 }} %{fmudflap|fmudflapth: --wrap=main}"
605 #define MFLIB_SPEC "%{fmudflap|fmudflapth: -export-dynamic}"
608 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
611 #if defined(REAL_LIBGCC_SPEC)
612 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
613 #elif defined(LINK_LIBGCC_SPECIAL_1)
614 /* Have gcc do the search for libgcc.a. */
615 #define LIBGCC_SPEC "libgcc.a%s"
617 #define LIBGCC_SPEC "-lgcc"
621 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
622 #ifndef STARTFILE_SPEC
623 #define STARTFILE_SPEC \
624 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
627 /* config.h can define SWITCHES_NEED_SPACES to control which options
628 require spaces between the option and the argument. */
629 #ifndef SWITCHES_NEED_SPACES
630 #define SWITCHES_NEED_SPACES ""
633 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
635 #define ENDFILE_SPEC ""
639 #define LINKER_NAME "collect2"
642 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
644 #ifndef ASM_DEBUG_SPEC
645 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
646 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
647 # define ASM_DEBUG_SPEC \
648 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
649 ? "%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}" \
650 : "%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}")
652 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
653 # define ASM_DEBUG_SPEC "%{g*:--gstabs}"
655 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
656 # define ASM_DEBUG_SPEC "%{g*:--gdwarf2}"
660 #ifndef ASM_DEBUG_SPEC
661 # define ASM_DEBUG_SPEC ""
664 /* Here is the spec for running the linker, after compiling all files. */
666 /* This is overridable by the target in case they need to specify the
667 -lgcc and -lc order specially, yet not require them to override all
668 of LINK_COMMAND_SPEC. */
669 #ifndef LINK_GCC_C_SEQUENCE_SPEC
670 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
673 #ifndef LINK_SSP_SPEC
674 #ifdef TARGET_LIBC_PROVIDES_SSP
675 #define LINK_SSP_SPEC "%{fstack-protector:}"
677 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all:-lssp_nonshared -lssp}"
681 #ifndef LINK_PIE_SPEC
683 #define LINK_PIE_SPEC "%{pie:-pie} "
685 #define LINK_PIE_SPEC "%{pie:} "
689 /* -u* was put back because both BSD and SysV seem to support it. */
690 /* %{static:} simply prevents an error message if the target machine
691 doesn't handle -static. */
692 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
693 scripts which exist in user specified directories, or in standard
695 #ifndef LINK_COMMAND_SPEC
696 #define LINK_COMMAND_SPEC "\
697 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
698 %(linker) %l " LINK_PIE_SPEC "%X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} %{r}\
699 %{s} %{t} %{u*} %{x} %{z} %{Z} %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
700 %{static:} %{L*} %(mfwrap) %(link_libgcc) %o %(mflib)\
701 %{fprofile-arcs|fprofile-generate|coverage:-lgcov}\
702 %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\
703 %{!A:%{!nostdlib:%{!nostartfiles:%E}}} %{T*} }}}}}}"
706 #ifndef LINK_LIBGCC_SPEC
707 /* Generate -L options for startfile prefix list. */
708 # define LINK_LIBGCC_SPEC "%D"
711 #ifndef STARTFILE_PREFIX_SPEC
712 # define STARTFILE_PREFIX_SPEC ""
716 # define SYSROOT_SPEC "--sysroot=%R"
719 #ifndef SYSROOT_SUFFIX_SPEC
720 # define SYSROOT_SUFFIX_SPEC ""
723 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
724 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
727 static const char *asm_debug
;
728 static const char *cpp_spec
= CPP_SPEC
;
729 static const char *cc1_spec
= CC1_SPEC
;
730 static const char *cc1plus_spec
= CC1PLUS_SPEC
;
731 static const char *link_gcc_c_sequence_spec
= LINK_GCC_C_SEQUENCE_SPEC
;
732 static const char *link_ssp_spec
= LINK_SSP_SPEC
;
733 static const char *asm_spec
= ASM_SPEC
;
734 static const char *asm_final_spec
= ASM_FINAL_SPEC
;
735 static const char *link_spec
= LINK_SPEC
;
736 static const char *lib_spec
= LIB_SPEC
;
737 static const char *mfwrap_spec
= MFWRAP_SPEC
;
738 static const char *mflib_spec
= MFLIB_SPEC
;
739 static const char *libgcc_spec
= LIBGCC_SPEC
;
740 static const char *endfile_spec
= ENDFILE_SPEC
;
741 static const char *startfile_spec
= STARTFILE_SPEC
;
742 static const char *switches_need_spaces
= SWITCHES_NEED_SPACES
;
743 static const char *linker_name_spec
= LINKER_NAME
;
744 static const char *link_command_spec
= LINK_COMMAND_SPEC
;
745 static const char *link_libgcc_spec
= LINK_LIBGCC_SPEC
;
746 static const char *startfile_prefix_spec
= STARTFILE_PREFIX_SPEC
;
747 static const char *sysroot_spec
= SYSROOT_SPEC
;
748 static const char *sysroot_suffix_spec
= SYSROOT_SUFFIX_SPEC
;
749 static const char *sysroot_hdrs_suffix_spec
= SYSROOT_HEADERS_SUFFIX_SPEC
;
751 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
752 There should be no need to override these in target dependent files,
753 but we need to copy them to the specs file so that newer versions
754 of the GCC driver can correctly drive older tool chains with the
755 appropriate -B options. */
757 /* When cpplib handles traditional preprocessing, get rid of this, and
758 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
759 that we default the front end language better. */
760 static const char *trad_capable_cpp
=
761 "cc1 -E %{traditional|ftraditional|traditional-cpp:-traditional-cpp}";
763 /* We don't wrap .d files in %W{} since a missing .d file, and
764 therefore no dependency entry, confuses make into thinking a .o
765 file that happens to exist is up-to-date. */
766 static const char *cpp_unique_options
=
767 "%{C|CC:%{!E:%eGCC does not support -C or -CC without -E}}\
768 %{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\
769 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
770 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
771 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
772 %{!E:%{!M:%{!MM:%{MD|MMD:%{o*:-MQ %*}}}}}\
773 %{remap} %{g3:-dD} %{H} %C %{D*&U*&A*} %{i*} %Z %i\
774 %{fmudflap:-D_MUDFLAP -include mf-runtime.h}\
775 %{fmudflapth:-D_MUDFLAP -D_MUDFLAPTH -include mf-runtime.h}\
778 /* This contains cpp options which are common with cc1_options and are passed
779 only when preprocessing only to avoid duplication. We pass the cc1 spec
780 options to the preprocessor so that it the cc1 spec may manipulate
781 options used to set target flags. Those special target flags settings may
782 in turn cause preprocessor symbols to be defined specially. */
783 static const char *cpp_options
=
784 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
785 %{f*} %{g*:%{!g0:%{!fno-working-directory:-fworking-directory}}} %{O*}\
786 %{undef} %{save-temps:-fpch-preprocess}";
788 /* This contains cpp options which are not passed when the preprocessor
789 output will be used by another program. */
790 static const char *cpp_debug_options
= "%{d*}";
792 /* NB: This is shared amongst all front-ends. */
793 static const char *cc1_options
=
794 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
795 %1 %{!Q:-quiet} -dumpbase %B %{d*} %{m*} %{a*}\
796 %{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}%{!c:%{!S:-auxbase %b}}\
797 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
798 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
799 %{Qn:-fno-ident} %{--help:--help}\
800 %{--target-help:--target-help}\
801 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
802 %{fsyntax-only:-o %j} %{-param*}\
803 %{fmudflap|fmudflapth:-fno-builtin -fno-merge-constants}\
804 %{coverage:-fprofile-arcs -ftest-coverage}";
806 static const char *asm_options
=
807 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
809 static const char *invoke_as
=
810 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
811 "%{!S:-o %|.s |\n as %(asm_options) %|.s %A }";
813 "%{!S:-o %|.s |\n as %(asm_options) %m.s %A }";
816 /* Some compilers have limits on line lengths, and the multilib_select
817 and/or multilib_matches strings can be very long, so we build them at
819 static struct obstack multilib_obstack
;
820 static const char *multilib_select
;
821 static const char *multilib_matches
;
822 static const char *multilib_defaults
;
823 static const char *multilib_exclusions
;
825 /* Check whether a particular argument is a default argument. */
827 #ifndef MULTILIB_DEFAULTS
828 #define MULTILIB_DEFAULTS { "" }
831 static const char *const multilib_defaults_raw
[] = MULTILIB_DEFAULTS
;
833 #ifndef DRIVER_SELF_SPECS
834 #define DRIVER_SELF_SPECS ""
837 static const char *const driver_self_specs
[] = { DRIVER_SELF_SPECS
};
839 #ifndef OPTION_DEFAULT_SPECS
840 #define OPTION_DEFAULT_SPECS { "", "" }
849 static const struct default_spec
850 option_default_specs
[] = { OPTION_DEFAULT_SPECS
};
854 struct user_specs
*next
;
855 const char *filename
;
858 static struct user_specs
*user_specs_head
, *user_specs_tail
;
860 #ifndef SWITCH_TAKES_ARG
861 #define SWITCH_TAKES_ARG(CHAR) DEFAULT_SWITCH_TAKES_ARG(CHAR)
864 #ifndef WORD_SWITCH_TAKES_ARG
865 #define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR)
868 #ifdef HAVE_TARGET_EXECUTABLE_SUFFIX
869 /* This defines which switches stop a full compilation. */
870 #define DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) \
871 ((CHAR) == 'c' || (CHAR) == 'S')
873 #ifndef SWITCH_CURTAILS_COMPILATION
874 #define SWITCH_CURTAILS_COMPILATION(CHAR) \
875 DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR)
879 /* Record the mapping from file suffixes for compilation specs. */
883 const char *suffix
; /* Use this compiler for input files
884 whose names end in this suffix. */
886 const char *spec
; /* To use this compiler, run this spec. */
888 const char *cpp_spec
; /* If non-NULL, substitute this spec
889 for `%C', rather than the usual
891 const int combinable
; /* If nonzero, compiler can deal with
892 multiple source files at once (IMA). */
893 const int needs_preprocessing
; /* If nonzero, source files need to
894 be run through a preprocessor. */
897 /* Pointer to a vector of `struct compiler' that gives the spec for
898 compiling a file, based on its suffix.
899 A file that does not end in any of these suffixes will be passed
900 unchanged to the loader and nothing else will be done to it.
902 An entry containing two 0s is used to terminate the vector.
904 If multiple entries match a file, the last matching one is used. */
906 static struct compiler
*compilers
;
908 /* Number of entries in `compilers', not counting the null terminator. */
910 static int n_compilers
;
912 /* The default list of file name suffixes and their compilation specs. */
914 static const struct compiler default_compilers
[] =
916 /* Add lists of suffixes of known languages here. If those languages
917 were not present when we built the driver, we will hit these copies
918 and be given a more meaningful error than "file not used since
919 linking is not done". */
920 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0},
921 {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
922 {".mii", "#Objective-C++", 0, 0, 0},
923 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
924 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
925 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
926 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
927 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
928 {".f", "#Fortran", 0, 0, 0}, {".for", "#Fortran", 0, 0, 0},
929 {".fpp", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
930 {".FOR", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
931 {".f90", "#Fortran", 0, 0, 0}, {".f95", "#Fortran", 0, 0, 0},
932 {".F90", "#Fortran", 0, 0, 0}, {".F95", "#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 /* Next come the entries for C. */
938 {".c", "@c", 0, 1, 1},
940 /* cc1 has an integrated ISO C preprocessor. We should invoke the
941 external preprocessor if -save-temps is given. */
942 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
944 %{traditional|ftraditional:\
945 %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)}} \
955 %{save-temps|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
956 %(cpp_options) -o %{save-temps:%b.i} %{!save-temps:%g.i}}\
957 %{!save-temps:%{!traditional-cpp:%{!no-integrated-cpp:\
958 cc1 %(cpp_unique_options) %(cc1_options)}}\
959 %{!fsyntax-only:%(invoke_as)}}}}}}", 0, 1, 1},
961 "%{!E:%e-E or -x required when input is from standard input}\
962 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
963 {".h", "@c-header", 0, 0, 0},
965 /* cc1 has an integrated ISO C preprocessor. We should invoke the
966 external preprocessor if -save-temps is given. */
967 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
969 %{save-temps|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
970 %(cpp_options) -o %{save-temps:%b.i} %{!save-temps:%g.i} \n\
971 cc1 -fpreprocessed %{save-temps:%b.i} %{!save-temps:%g.i} \
973 -o %g.s %{!o*:--output-pch=%i.gch}\
974 %W{o*:--output-pch=%*}%V}\
975 %{!save-temps:%{!traditional-cpp:%{!no-integrated-cpp:\
976 cc1 %(cpp_unique_options) %(cc1_options)\
977 -o %g.s %{!o*:--output-pch=%i.gch}\
978 %W{o*:--output-pch=%*}%V}}}}}}", 0, 0, 0},
979 {".i", "@cpp-output", 0, 1, 0},
981 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 1, 0},
982 {".s", "@assembler", 0, 1, 0},
984 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 1, 0},
985 {".S", "@assembler-with-cpp", 0, 1, 0},
986 {"@assembler-with-cpp",
987 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
988 "%(trad_capable_cpp) -lang-asm %(cpp_options)\
989 %{E|M|MM:%(cpp_debug_options)}\
990 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
991 as %(asm_debug) %(asm_options) %|.s %A }}}}"
993 "%(trad_capable_cpp) -lang-asm %(cpp_options)\
994 %{E|M|MM:%(cpp_debug_options)}\
995 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
996 as %(asm_debug) %(asm_options) %m.s %A }}}}"
1001 /* Mark end of table. */
1005 /* Number of elements in default_compilers, not counting the terminator. */
1007 static const int n_default_compilers
= ARRAY_SIZE (default_compilers
) - 1;
1009 /* A vector of options to give to the linker.
1010 These options are accumulated by %x,
1011 and substituted into the linker command with %X. */
1012 static int n_linker_options
;
1013 static char **linker_options
;
1015 /* A vector of options to give to the assembler.
1016 These options are accumulated by -Wa,
1017 and substituted into the assembler command with %Y. */
1018 static int n_assembler_options
;
1019 static char **assembler_options
;
1021 /* A vector of options to give to the preprocessor.
1022 These options are accumulated by -Wp,
1023 and substituted into the preprocessor command with %Z. */
1024 static int n_preprocessor_options
;
1025 static char **preprocessor_options
;
1027 /* Define how to map long options into short ones. */
1029 /* This structure describes one mapping. */
1032 /* The long option's name. */
1033 const char *const name
;
1034 /* The equivalent short option. */
1035 const char *const equivalent
;
1036 /* Argument info. A string of flag chars; NULL equals no options.
1037 a => argument required.
1038 o => argument optional.
1039 j => join argument to equivalent, making one word.
1040 * => require other text after NAME as an argument. */
1041 const char *const arg_info
;
1044 /* This is the table of mappings. Mappings are tried sequentially
1045 for each option encountered; the first one that matches, wins. */
1047 static const struct option_map option_map
[] =
1049 {"--all-warnings", "-Wall", 0},
1050 {"--ansi", "-ansi", 0},
1051 {"--assemble", "-S", 0},
1052 {"--assert", "-A", "a"},
1053 {"--classpath", "-fclasspath=", "aj"},
1054 {"--bootclasspath", "-fbootclasspath=", "aj"},
1055 {"--CLASSPATH", "-fclasspath=", "aj"},
1056 {"--combine", "-combine", 0},
1057 {"--comments", "-C", 0},
1058 {"--comments-in-macros", "-CC", 0},
1059 {"--compile", "-c", 0},
1060 {"--debug", "-g", "oj"},
1061 {"--define-macro", "-D", "aj"},
1062 {"--dependencies", "-M", 0},
1063 {"--dump", "-d", "a"},
1064 {"--dumpbase", "-dumpbase", "a"},
1065 {"--encoding", "-fencoding=", "aj"},
1066 {"--entry", "-e", 0},
1067 {"--extra-warnings", "-W", 0},
1068 {"--extdirs", "-fextdirs=", "aj"},
1069 {"--for-assembler", "-Wa", "a"},
1070 {"--for-linker", "-Xlinker", "a"},
1071 {"--force-link", "-u", "a"},
1072 {"--coverage", "-coverage", 0},
1073 {"--imacros", "-imacros", "a"},
1074 {"--include", "-include", "a"},
1075 {"--include-barrier", "-I-", 0},
1076 {"--include-directory", "-I", "aj"},
1077 {"--include-directory-after", "-idirafter", "a"},
1078 {"--include-prefix", "-iprefix", "a"},
1079 {"--include-with-prefix", "-iwithprefix", "a"},
1080 {"--include-with-prefix-before", "-iwithprefixbefore", "a"},
1081 {"--include-with-prefix-after", "-iwithprefix", "a"},
1082 {"--language", "-x", "a"},
1083 {"--library-directory", "-L", "a"},
1084 {"--machine", "-m", "aj"},
1085 {"--machine-", "-m", "*j"},
1086 {"--no-integrated-cpp", "-no-integrated-cpp", 0},
1087 {"--no-line-commands", "-P", 0},
1088 {"--no-precompiled-includes", "-noprecomp", 0},
1089 {"--no-standard-includes", "-nostdinc", 0},
1090 {"--no-standard-libraries", "-nostdlib", 0},
1091 {"--no-warnings", "-w", 0},
1092 {"--optimize", "-O", "oj"},
1093 {"--output", "-o", "a"},
1094 {"--output-class-directory", "-foutput-class-dir=", "ja"},
1095 {"--param", "--param", "a"},
1096 {"--pass-exit-codes", "-pass-exit-codes", 0},
1097 {"--pedantic", "-pedantic", 0},
1098 {"--pedantic-errors", "-pedantic-errors", 0},
1099 {"--pie", "-pie", 0},
1100 {"--pipe", "-pipe", 0},
1101 {"--prefix", "-B", "a"},
1102 {"--preprocess", "-E", 0},
1103 {"--print-search-dirs", "-print-search-dirs", 0},
1104 {"--print-file-name", "-print-file-name=", "aj"},
1105 {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
1106 {"--print-missing-file-dependencies", "-MG", 0},
1107 {"--print-multi-lib", "-print-multi-lib", 0},
1108 {"--print-multi-directory", "-print-multi-directory", 0},
1109 {"--print-multi-os-directory", "-print-multi-os-directory", 0},
1110 {"--print-prog-name", "-print-prog-name=", "aj"},
1111 {"--profile", "-p", 0},
1112 {"--profile-blocks", "-a", 0},
1113 {"--quiet", "-q", 0},
1114 {"--resource", "-fcompile-resource=", "aj"},
1115 {"--save-temps", "-save-temps", 0},
1116 {"--shared", "-shared", 0},
1117 {"--silent", "-q", 0},
1118 {"--specs", "-specs=", "aj"},
1119 {"--static", "-static", 0},
1120 {"--std", "-std=", "aj"},
1121 {"--symbolic", "-symbolic", 0},
1122 {"--sysroot", "--sysroot=", "aj"},
1123 {"--time", "-time", 0},
1124 {"--trace-includes", "-H", 0},
1125 {"--traditional", "-traditional", 0},
1126 {"--traditional-cpp", "-traditional-cpp", 0},
1127 {"--trigraphs", "-trigraphs", 0},
1128 {"--undefine-macro", "-U", "aj"},
1129 {"--user-dependencies", "-MM", 0},
1130 {"--verbose", "-v", 0},
1131 {"--warn-", "-W", "*j"},
1132 {"--write-dependencies", "-MD", 0},
1133 {"--write-user-dependencies", "-MMD", 0},
1138 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1139 static const struct {
1140 const char *const option_found
;
1141 const char *const replacements
;
1142 } target_option_translations
[] =
1144 TARGET_OPTION_TRANSLATE_TABLE
,
1149 /* Translate the options described by *ARGCP and *ARGVP.
1150 Make a new vector and store it back in *ARGVP,
1151 and store its length in *ARGVC. */
1154 translate_options (int *argcp
, const char *const **argvp
)
1158 const char *const *argv
= *argvp
;
1159 int newvsize
= (argc
+ 2) * 2 * sizeof (const char *);
1160 const char **newv
= xmalloc (newvsize
);
1164 newv
[newindex
++] = argv
[i
++];
1168 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1172 target_option_translations
[tott_idx
].option_found
;
1175 if (strcmp (target_option_translations
[tott_idx
].option_found
,
1182 for (sp
= target_option_translations
[tott_idx
].replacements
;
1189 newvsize
+= spaces
* sizeof (const char *);
1190 newv
= xrealloc (newv
, newvsize
);
1192 sp
= target_option_translations
[tott_idx
].replacements
;
1201 newv
[newindex
++] = np
;
1202 while (*np
!= ' ' && *np
)
1213 if (target_option_translations
[tott_idx
].option_found
)
1217 /* Translate -- options. */
1218 if (argv
[i
][0] == '-' && argv
[i
][1] == '-')
1221 /* Find a mapping that applies to this option. */
1222 for (j
= 0; j
< ARRAY_SIZE (option_map
); j
++)
1224 size_t optlen
= strlen (option_map
[j
].name
);
1225 size_t arglen
= strlen (argv
[i
]);
1226 size_t complen
= arglen
> optlen
? optlen
: arglen
;
1227 const char *arginfo
= option_map
[j
].arg_info
;
1232 if (!strncmp (argv
[i
], option_map
[j
].name
, complen
))
1234 const char *arg
= 0;
1236 if (arglen
< optlen
)
1239 for (k
= j
+ 1; k
< ARRAY_SIZE (option_map
); k
++)
1240 if (strlen (option_map
[k
].name
) >= arglen
1241 && !strncmp (argv
[i
], option_map
[k
].name
, arglen
))
1243 error ("ambiguous abbreviation %s", argv
[i
]);
1247 if (k
!= ARRAY_SIZE (option_map
))
1251 if (arglen
> optlen
)
1253 /* If the option has an argument, accept that. */
1254 if (argv
[i
][optlen
] == '=')
1255 arg
= argv
[i
] + optlen
+ 1;
1257 /* If this mapping requires extra text at end of name,
1258 accept that as "argument". */
1259 else if (strchr (arginfo
, '*') != 0)
1260 arg
= argv
[i
] + optlen
;
1262 /* Otherwise, extra text at end means mismatch.
1263 Try other mappings. */
1268 else if (strchr (arginfo
, '*') != 0)
1270 error ("incomplete '%s' option", option_map
[j
].name
);
1274 /* Handle arguments. */
1275 if (strchr (arginfo
, 'a') != 0)
1281 error ("missing argument to '%s' option",
1282 option_map
[j
].name
);
1289 else if (strchr (arginfo
, '*') != 0)
1291 else if (strchr (arginfo
, 'o') == 0)
1294 error ("extraneous argument to '%s' option",
1295 option_map
[j
].name
);
1299 /* Store the translation as one argv elt or as two. */
1300 if (arg
!= 0 && strchr (arginfo
, 'j') != 0)
1301 newv
[newindex
++] = concat (option_map
[j
].equivalent
, arg
,
1305 newv
[newindex
++] = option_map
[j
].equivalent
;
1306 newv
[newindex
++] = arg
;
1309 newv
[newindex
++] = option_map
[j
].equivalent
;
1317 /* Handle old-fashioned options--just copy them through,
1318 with their arguments. */
1319 else if (argv
[i
][0] == '-')
1321 const char *p
= argv
[i
] + 1;
1325 if (SWITCH_TAKES_ARG (c
) > (p
[1] != 0))
1326 nskip
+= SWITCH_TAKES_ARG (c
) - (p
[1] != 0);
1327 else if (WORD_SWITCH_TAKES_ARG (p
))
1328 nskip
+= WORD_SWITCH_TAKES_ARG (p
);
1329 else if ((c
== 'B' || c
== 'b' || c
== 'x')
1332 else if (! strcmp (p
, "Xlinker"))
1334 else if (! strcmp (p
, "Xpreprocessor"))
1336 else if (! strcmp (p
, "Xassembler"))
1339 /* Watch out for an option at the end of the command line that
1340 is missing arguments, and avoid skipping past the end of the
1342 if (nskip
+ i
> argc
)
1347 newv
[newindex
++] = argv
[i
++];
1352 /* Ordinary operands, or +e options. */
1353 newv
[newindex
++] = argv
[i
++];
1363 skip_whitespace (char *p
)
1367 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1368 be considered whitespace. */
1369 if (p
[0] == '\n' && p
[1] == '\n' && p
[2] == '\n')
1371 else if (*p
== '\n' || *p
== ' ' || *p
== '\t')
1385 /* Structures to keep track of prefixes to try when looking for files. */
1389 const char *prefix
; /* String to prepend to the path. */
1390 struct prefix_list
*next
; /* Next in linked list. */
1391 int require_machine_suffix
; /* Don't use without machine_suffix. */
1392 /* 2 means try both machine_suffix and just_machine_suffix. */
1393 int priority
; /* Sort key - priority within list. */
1394 int os_multilib
; /* 1 if OS multilib scheme should be used,
1395 0 for GCC multilib scheme. */
1400 struct prefix_list
*plist
; /* List of prefixes to try */
1401 int max_len
; /* Max length of a prefix in PLIST */
1402 const char *name
; /* Name of this list (used in config stuff) */
1405 /* List of prefixes to try when looking for executables. */
1407 static struct path_prefix exec_prefixes
= { 0, 0, "exec" };
1409 /* List of prefixes to try when looking for startup (crt0) files. */
1411 static struct path_prefix startfile_prefixes
= { 0, 0, "startfile" };
1413 /* List of prefixes to try when looking for include files. */
1415 static struct path_prefix include_prefixes
= { 0, 0, "include" };
1417 /* Suffix to attach to directories searched for commands.
1418 This looks like `MACHINE/VERSION/'. */
1420 static const char *machine_suffix
= 0;
1422 /* Suffix to attach to directories searched for commands.
1423 This is just `MACHINE/'. */
1425 static const char *just_machine_suffix
= 0;
1427 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1429 static const char *gcc_exec_prefix
;
1431 /* Adjusted value of standard_libexec_prefix. */
1433 static const char *gcc_libexec_prefix
;
1435 /* Default prefixes to attach to command names. */
1437 #ifndef STANDARD_STARTFILE_PREFIX_1
1438 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1440 #ifndef STANDARD_STARTFILE_PREFIX_2
1441 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1444 #ifdef CROSS_COMPILE /* Don't use these prefixes for a cross compiler. */
1445 #undef MD_EXEC_PREFIX
1446 #undef MD_STARTFILE_PREFIX
1447 #undef MD_STARTFILE_PREFIX_1
1450 /* If no prefixes defined, use the null string, which will disable them. */
1451 #ifndef MD_EXEC_PREFIX
1452 #define MD_EXEC_PREFIX ""
1454 #ifndef MD_STARTFILE_PREFIX
1455 #define MD_STARTFILE_PREFIX ""
1457 #ifndef MD_STARTFILE_PREFIX_1
1458 #define MD_STARTFILE_PREFIX_1 ""
1461 static const char *const standard_exec_prefix
= STANDARD_EXEC_PREFIX
;
1462 static const char *const standard_exec_prefix_1
= "/usr/libexec/gcc/";
1463 static const char *const standard_exec_prefix_2
= "/usr/lib/gcc/";
1464 static const char *md_exec_prefix
= MD_EXEC_PREFIX
;
1466 static const char *md_startfile_prefix
= MD_STARTFILE_PREFIX
;
1467 static const char *md_startfile_prefix_1
= MD_STARTFILE_PREFIX_1
;
1468 static const char *const standard_startfile_prefix
= STANDARD_STARTFILE_PREFIX
;
1469 static const char *const standard_startfile_prefix_1
1470 = STANDARD_STARTFILE_PREFIX_1
;
1471 static const char *const standard_startfile_prefix_2
1472 = STANDARD_STARTFILE_PREFIX_2
;
1474 static const char *const tooldir_base_prefix
= TOOLDIR_BASE_PREFIX
;
1475 static const char *tooldir_prefix
;
1477 static const char *const standard_bindir_prefix
= STANDARD_BINDIR_PREFIX
;
1479 static const char *standard_libexec_prefix
= STANDARD_LIBEXEC_PREFIX
;
1481 /* Subdirectory to use for locating libraries. Set by
1482 set_multilib_dir based on the compilation options. */
1484 static const char *multilib_dir
;
1486 /* Subdirectory to use for locating libraries in OS conventions. Set by
1487 set_multilib_dir based on the compilation options. */
1489 static const char *multilib_os_dir
;
1491 /* Structure to keep track of the specs that have been defined so far.
1492 These are accessed using %(specname) or %[specname] in a compiler
1497 /* The following 2 fields must be first */
1498 /* to allow EXTRA_SPECS to be initialized */
1499 const char *name
; /* name of the spec. */
1500 const char *ptr
; /* available ptr if no static pointer */
1502 /* The following fields are not initialized */
1503 /* by EXTRA_SPECS */
1504 const char **ptr_spec
; /* pointer to the spec itself. */
1505 struct spec_list
*next
; /* Next spec in linked list. */
1506 int name_len
; /* length of the name */
1507 int alloc_p
; /* whether string was allocated */
1510 #define INIT_STATIC_SPEC(NAME,PTR) \
1511 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 }
1513 /* List of statically defined specs. */
1514 static struct spec_list static_specs
[] =
1516 INIT_STATIC_SPEC ("asm", &asm_spec
),
1517 INIT_STATIC_SPEC ("asm_debug", &asm_debug
),
1518 INIT_STATIC_SPEC ("asm_final", &asm_final_spec
),
1519 INIT_STATIC_SPEC ("asm_options", &asm_options
),
1520 INIT_STATIC_SPEC ("invoke_as", &invoke_as
),
1521 INIT_STATIC_SPEC ("cpp", &cpp_spec
),
1522 INIT_STATIC_SPEC ("cpp_options", &cpp_options
),
1523 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options
),
1524 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options
),
1525 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp
),
1526 INIT_STATIC_SPEC ("cc1", &cc1_spec
),
1527 INIT_STATIC_SPEC ("cc1_options", &cc1_options
),
1528 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec
),
1529 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec
),
1530 INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec
),
1531 INIT_STATIC_SPEC ("endfile", &endfile_spec
),
1532 INIT_STATIC_SPEC ("link", &link_spec
),
1533 INIT_STATIC_SPEC ("lib", &lib_spec
),
1534 INIT_STATIC_SPEC ("mfwrap", &mfwrap_spec
),
1535 INIT_STATIC_SPEC ("mflib", &mflib_spec
),
1536 INIT_STATIC_SPEC ("libgcc", &libgcc_spec
),
1537 INIT_STATIC_SPEC ("startfile", &startfile_spec
),
1538 INIT_STATIC_SPEC ("switches_need_spaces", &switches_need_spaces
),
1539 INIT_STATIC_SPEC ("cross_compile", &cross_compile
),
1540 INIT_STATIC_SPEC ("version", &compiler_version
),
1541 INIT_STATIC_SPEC ("multilib", &multilib_select
),
1542 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults
),
1543 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra
),
1544 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches
),
1545 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions
),
1546 INIT_STATIC_SPEC ("multilib_options", &multilib_options
),
1547 INIT_STATIC_SPEC ("linker", &linker_name_spec
),
1548 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec
),
1549 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix
),
1550 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix
),
1551 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1
),
1552 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec
),
1553 INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec
),
1554 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec
),
1555 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec
),
1558 #ifdef EXTRA_SPECS /* additional specs needed */
1559 /* Structure to keep track of just the first two args of a spec_list.
1560 That is all that the EXTRA_SPECS macro gives us. */
1563 const char *const name
;
1564 const char *const ptr
;
1567 static const struct spec_list_1 extra_specs_1
[] = { EXTRA_SPECS
};
1568 static struct spec_list
*extra_specs
= (struct spec_list
*) 0;
1571 /* List of dynamically allocates specs that have been defined so far. */
1573 static struct spec_list
*specs
= (struct spec_list
*) 0;
1575 /* List of static spec functions. */
1577 static const struct spec_function static_spec_functions
[] =
1579 { "if-exists", if_exists_spec_function
},
1580 { "if-exists-else", if_exists_else_spec_function
},
1581 { "replace-outfile", replace_outfile_spec_function
},
1582 { "version-compare", version_compare_spec_function
},
1586 static int processing_spec_function
;
1588 /* Add appropriate libgcc specs to OBSTACK, taking into account
1589 various permutations of -shared-libgcc, -shared, and such. */
1591 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1593 #ifndef USE_LD_AS_NEEDED
1594 #define USE_LD_AS_NEEDED 0
1598 init_gcc_specs (struct obstack
*obstack
, const char *shared_name
,
1599 const char *static_name
, const char *eh_name
)
1603 buf
= concat ("%{static|static-libgcc:", static_name
, " ", eh_name
, "}"
1604 "%{!static:%{!static-libgcc:"
1605 #if USE_LD_AS_NEEDED
1606 "%{!shared-libgcc:",
1607 static_name
, " --as-needed ", shared_name
, " --no-as-needed"
1610 shared_name
, "%{!shared: ", static_name
, "}"
1614 "%{!shared-libgcc:", static_name
, " ", eh_name
, "}"
1615 "%{shared-libgcc:", shared_name
, " ", static_name
, "}"
1619 "%{shared-libgcc:", shared_name
, "}"
1620 "%{!shared-libgcc:", static_name
, "}"
1623 "%{shared:", shared_name
, "}"
1628 obstack_grow (obstack
, buf
, strlen (buf
));
1631 #endif /* ENABLE_SHARED_LIBGCC */
1633 /* Initialize the specs lookup routines. */
1638 struct spec_list
*next
= (struct spec_list
*) 0;
1639 struct spec_list
*sl
= (struct spec_list
*) 0;
1643 return; /* Already initialized. */
1646 notice ("Using built-in specs.\n");
1649 extra_specs
= xcalloc (sizeof (struct spec_list
),
1650 ARRAY_SIZE (extra_specs_1
));
1652 for (i
= ARRAY_SIZE (extra_specs_1
) - 1; i
>= 0; i
--)
1654 sl
= &extra_specs
[i
];
1655 sl
->name
= extra_specs_1
[i
].name
;
1656 sl
->ptr
= extra_specs_1
[i
].ptr
;
1658 sl
->name_len
= strlen (sl
->name
);
1659 sl
->ptr_spec
= &sl
->ptr
;
1664 /* Initialize here, not in definition. The IRIX 6 O32 cc sometimes chokes
1665 on ?: in file-scope variable initializations. */
1666 asm_debug
= ASM_DEBUG_SPEC
;
1668 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1670 sl
= &static_specs
[i
];
1675 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1676 /* ??? If neither -shared-libgcc nor --static-libgcc was
1677 seen, then we should be making an educated guess. Some proposed
1678 heuristics for ELF include:
1680 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1681 program will be doing dynamic loading, which will likely
1682 need the shared libgcc.
1684 (2) If "-ldl", then it's also a fair bet that we're doing
1687 (3) For each ET_DYN we're linking against (either through -lfoo
1688 or /some/path/foo.so), check to see whether it or one of
1689 its dependencies depends on a shared libgcc.
1693 If the runtime is fixed to look for program headers instead
1694 of calling __register_frame_info at all, for each object,
1695 use the shared libgcc if any EH symbol referenced.
1697 If crtstuff is fixed to not invoke __register_frame_info
1698 automatically, for each object, use the shared libgcc if
1699 any non-empty unwind section found.
1701 Doing any of this probably requires invoking an external program to
1702 do the actual object file scanning. */
1704 const char *p
= libgcc_spec
;
1707 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1708 when given the proper command line arguments. */
1711 if (in_sep
&& *p
== '-' && strncmp (p
, "-lgcc", 5) == 0)
1713 init_gcc_specs (&obstack
,
1715 #ifdef USE_LIBUNWIND_EXCEPTIONS
1721 #ifdef USE_LIBUNWIND_EXCEPTIONS
1722 # ifdef HAVE_LD_STATIC_DYNAMIC
1723 " %{!static:-Bstatic} -lunwind %{!static:-Bdynamic}"
1733 else if (in_sep
&& *p
== 'l' && strncmp (p
, "libgcc.a%s", 10) == 0)
1735 /* Ug. We don't know shared library extensions. Hope that
1736 systems that use this form don't do shared libraries. */
1737 init_gcc_specs (&obstack
,
1741 #ifdef USE_LIBUNWIND_EXCEPTIONS
1750 obstack_1grow (&obstack
, *p
);
1751 in_sep
= (*p
== ' ');
1756 obstack_1grow (&obstack
, '\0');
1757 libgcc_spec
= XOBFINISH (&obstack
, const char *);
1760 #ifdef USE_AS_TRADITIONAL_FORMAT
1761 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1763 static const char tf
[] = "--traditional-format ";
1764 obstack_grow (&obstack
, tf
, sizeof(tf
) - 1);
1765 obstack_grow0 (&obstack
, asm_spec
, strlen (asm_spec
));
1766 asm_spec
= XOBFINISH (&obstack
, const char *);
1770 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1771 obstack_grow (&obstack
, LINK_EH_SPEC
, sizeof(LINK_EH_SPEC
) - 1);
1772 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
1773 link_spec
= XOBFINISH (&obstack
, const char *);
1779 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1780 removed; If the spec starts with a + then SPEC is added to the end of the
1784 set_spec (const char *name
, const char *spec
)
1786 struct spec_list
*sl
;
1787 const char *old_spec
;
1788 int name_len
= strlen (name
);
1791 /* If this is the first call, initialize the statically allocated specs. */
1794 struct spec_list
*next
= (struct spec_list
*) 0;
1795 for (i
= ARRAY_SIZE (static_specs
) - 1; i
>= 0; i
--)
1797 sl
= &static_specs
[i
];
1804 /* See if the spec already exists. */
1805 for (sl
= specs
; sl
; sl
= sl
->next
)
1806 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, name
))
1811 /* Not found - make it. */
1812 sl
= xmalloc (sizeof (struct spec_list
));
1813 sl
->name
= xstrdup (name
);
1814 sl
->name_len
= name_len
;
1815 sl
->ptr_spec
= &sl
->ptr
;
1817 *(sl
->ptr_spec
) = "";
1822 old_spec
= *(sl
->ptr_spec
);
1823 *(sl
->ptr_spec
) = ((spec
[0] == '+' && ISSPACE ((unsigned char)spec
[1]))
1824 ? concat (old_spec
, spec
+ 1, NULL
)
1829 notice ("Setting spec %s to '%s'\n\n", name
, *(sl
->ptr_spec
));
1832 /* Free the old spec. */
1833 if (old_spec
&& sl
->alloc_p
)
1834 free ((void *) old_spec
);
1839 /* Accumulate a command (program name and args), and run it. */
1841 /* Vector of pointers to arguments in the current line of specifications. */
1843 static const char **argbuf
;
1845 /* Number of elements allocated in argbuf. */
1847 static int argbuf_length
;
1849 /* Number of elements in argbuf currently in use (containing args). */
1851 static int argbuf_index
;
1853 /* Position in the argbuf array containing the name of the output file
1854 (the value associated with the "-o" flag). */
1856 static int have_o_argbuf_index
= 0;
1858 /* Were the options -c or -S passed. */
1859 static int have_c
= 0;
1861 /* Was the option -o passed. */
1862 static int have_o
= 0;
1864 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1865 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
1868 static struct temp_name
{
1869 const char *suffix
; /* suffix associated with the code. */
1870 int length
; /* strlen (suffix). */
1871 int unique
; /* Indicates whether %g or %u/%U was used. */
1872 const char *filename
; /* associated filename. */
1873 int filename_length
; /* strlen (filename). */
1874 struct temp_name
*next
;
1877 /* Number of commands executed so far. */
1879 static int execution_count
;
1881 /* Number of commands that exited with a signal. */
1883 static int signal_count
;
1885 /* Name with which this program was invoked. */
1887 static const char *programname
;
1889 /* Allocate the argument vector. */
1895 argbuf
= xmalloc (argbuf_length
* sizeof (const char *));
1898 /* Clear out the vector of arguments (after a command is executed). */
1906 /* Add one argument to the vector at the end.
1907 This is done when a space is seen or at the end of the line.
1908 If DELETE_ALWAYS is nonzero, the arg is a filename
1909 and the file should be deleted eventually.
1910 If DELETE_FAILURE is nonzero, the arg is a filename
1911 and the file should be deleted if this compilation fails. */
1914 store_arg (const char *arg
, int delete_always
, int delete_failure
)
1916 if (argbuf_index
+ 1 == argbuf_length
)
1917 argbuf
= xrealloc (argbuf
, (argbuf_length
*= 2) * sizeof (const char *));
1919 argbuf
[argbuf_index
++] = arg
;
1920 argbuf
[argbuf_index
] = 0;
1922 if (strcmp (arg
, "-o") == 0)
1923 have_o_argbuf_index
= argbuf_index
;
1924 if (delete_always
|| delete_failure
)
1925 record_temp_file (arg
, delete_always
, delete_failure
);
1928 /* Load specs from a file name named FILENAME, replacing occurrences of
1929 various different types of line-endings, \r\n, \n\r and just \r, with
1933 load_specs (const char *filename
)
1937 struct stat statbuf
;
1944 notice ("Reading specs from %s\n", filename
);
1946 /* Open and stat the file. */
1947 desc
= open (filename
, O_RDONLY
, 0);
1949 pfatal_with_name (filename
);
1950 if (stat (filename
, &statbuf
) < 0)
1951 pfatal_with_name (filename
);
1953 /* Read contents of file into BUFFER. */
1954 buffer
= xmalloc ((unsigned) statbuf
.st_size
+ 1);
1955 readlen
= read (desc
, buffer
, (unsigned) statbuf
.st_size
);
1957 pfatal_with_name (filename
);
1958 buffer
[readlen
] = 0;
1961 specs
= xmalloc (readlen
+ 1);
1963 for (buffer_p
= buffer
; buffer_p
&& *buffer_p
; buffer_p
++)
1969 if (buffer_p
> buffer
&& *(buffer_p
- 1) == '\n') /* \n\r */
1971 else if (*(buffer_p
+ 1) == '\n') /* \r\n */
1985 /* Read compilation specs from a file named FILENAME,
1986 replacing the default ones.
1988 A suffix which starts with `*' is a definition for
1989 one of the machine-specific sub-specs. The "suffix" should be
1990 *asm, *cc1, *cpp, *link, *startfile, etc.
1991 The corresponding spec is stored in asm_spec, etc.,
1992 rather than in the `compilers' vector.
1994 Anything invalid in the file is a fatal error. */
1997 read_specs (const char *filename
, int main_p
)
2002 buffer
= load_specs (filename
);
2004 /* Scan BUFFER for specs, putting them in the vector. */
2010 char *in
, *out
, *p1
, *p2
, *p3
;
2012 /* Advance P in BUFFER to the next nonblank nocomment line. */
2013 p
= skip_whitespace (p
);
2017 /* Is this a special command that starts with '%'? */
2018 /* Don't allow this for the main specs file, since it would
2019 encourage people to overwrite it. */
2020 if (*p
== '%' && !main_p
)
2023 while (*p
&& *p
!= '\n')
2029 if (!strncmp (p1
, "%include", sizeof ("%include") - 1)
2030 && (p1
[sizeof "%include" - 1] == ' '
2031 || p1
[sizeof "%include" - 1] == '\t'))
2035 p1
+= sizeof ("%include");
2036 while (*p1
== ' ' || *p1
== '\t')
2039 if (*p1
++ != '<' || p
[-2] != '>')
2040 fatal ("specs %%include syntax malformed after %ld characters",
2041 (long) (p1
- buffer
+ 1));
2044 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, 0);
2045 read_specs (new_filename
? new_filename
: p1
, FALSE
);
2048 else if (!strncmp (p1
, "%include_noerr", sizeof "%include_noerr" - 1)
2049 && (p1
[sizeof "%include_noerr" - 1] == ' '
2050 || p1
[sizeof "%include_noerr" - 1] == '\t'))
2054 p1
+= sizeof "%include_noerr";
2055 while (*p1
== ' ' || *p1
== '\t')
2058 if (*p1
++ != '<' || p
[-2] != '>')
2059 fatal ("specs %%include syntax malformed after %ld characters",
2060 (long) (p1
- buffer
+ 1));
2063 new_filename
= find_a_file (&startfile_prefixes
, p1
, R_OK
, 0);
2065 read_specs (new_filename
, FALSE
);
2066 else if (verbose_flag
)
2067 notice ("could not find specs file %s\n", p1
);
2070 else if (!strncmp (p1
, "%rename", sizeof "%rename" - 1)
2071 && (p1
[sizeof "%rename" - 1] == ' '
2072 || p1
[sizeof "%rename" - 1] == '\t'))
2075 struct spec_list
*sl
;
2076 struct spec_list
*newsl
;
2078 /* Get original name. */
2079 p1
+= sizeof "%rename";
2080 while (*p1
== ' ' || *p1
== '\t')
2083 if (! ISALPHA ((unsigned char) *p1
))
2084 fatal ("specs %%rename syntax malformed after %ld characters",
2085 (long) (p1
- buffer
));
2088 while (*p2
&& !ISSPACE ((unsigned char) *p2
))
2091 if (*p2
!= ' ' && *p2
!= '\t')
2092 fatal ("specs %%rename syntax malformed after %ld characters",
2093 (long) (p2
- buffer
));
2097 while (*p2
== ' ' || *p2
== '\t')
2100 if (! ISALPHA ((unsigned char) *p2
))
2101 fatal ("specs %%rename syntax malformed after %ld characters",
2102 (long) (p2
- buffer
));
2104 /* Get new spec name. */
2106 while (*p3
&& !ISSPACE ((unsigned char) *p3
))
2110 fatal ("specs %%rename syntax malformed after %ld characters",
2111 (long) (p3
- buffer
));
2114 for (sl
= specs
; sl
; sl
= sl
->next
)
2115 if (name_len
== sl
->name_len
&& !strcmp (sl
->name
, p1
))
2119 fatal ("specs %s spec was not found to be renamed", p1
);
2121 if (strcmp (p1
, p2
) == 0)
2124 for (newsl
= specs
; newsl
; newsl
= newsl
->next
)
2125 if (strcmp (newsl
->name
, p2
) == 0)
2126 fatal ("%s: attempt to rename spec '%s' to already defined spec '%s'",
2131 notice ("rename spec %s to %s\n", p1
, p2
);
2133 notice ("spec is '%s'\n\n", *(sl
->ptr_spec
));
2137 set_spec (p2
, *(sl
->ptr_spec
));
2139 free ((void *) *(sl
->ptr_spec
));
2141 *(sl
->ptr_spec
) = "";
2146 fatal ("specs unknown %% command after %ld characters",
2147 (long) (p1
- buffer
));
2150 /* Find the colon that should end the suffix. */
2152 while (*p1
&& *p1
!= ':' && *p1
!= '\n')
2155 /* The colon shouldn't be missing. */
2157 fatal ("specs file malformed after %ld characters",
2158 (long) (p1
- buffer
));
2160 /* Skip back over trailing whitespace. */
2162 while (p2
> buffer
&& (p2
[-1] == ' ' || p2
[-1] == '\t'))
2165 /* Copy the suffix to a string. */
2166 suffix
= save_string (p
, p2
- p
);
2167 /* Find the next line. */
2168 p
= skip_whitespace (p1
+ 1);
2170 fatal ("specs file malformed after %ld characters",
2171 (long) (p
- buffer
));
2174 /* Find next blank line or end of string. */
2175 while (*p1
&& !(*p1
== '\n' && (p1
[1] == '\n' || p1
[1] == '\0')))
2178 /* Specs end at the blank line and do not include the newline. */
2179 spec
= save_string (p
, p1
- p
);
2182 /* Delete backslash-newline sequences from the spec. */
2187 if (in
[0] == '\\' && in
[1] == '\n')
2189 else if (in
[0] == '#')
2190 while (*in
&& *in
!= '\n')
2198 if (suffix
[0] == '*')
2200 if (! strcmp (suffix
, "*link_command"))
2201 link_command_spec
= spec
;
2203 set_spec (suffix
+ 1, spec
);
2207 /* Add this pair to the vector. */
2209 = xrealloc (compilers
,
2210 (n_compilers
+ 2) * sizeof (struct compiler
));
2212 compilers
[n_compilers
].suffix
= suffix
;
2213 compilers
[n_compilers
].spec
= spec
;
2215 memset (&compilers
[n_compilers
], 0, sizeof compilers
[n_compilers
]);
2219 link_command_spec
= spec
;
2222 if (link_command_spec
== 0)
2223 fatal ("spec file has no spec for linking");
2226 /* Record the names of temporary files we tell compilers to write,
2227 and delete them at the end of the run. */
2229 /* This is the common prefix we use to make temp file names.
2230 It is chosen once for each run of this program.
2231 It is substituted into a spec by %g or %j.
2232 Thus, all temp file names contain this prefix.
2233 In practice, all temp file names start with this prefix.
2235 This prefix comes from the envvar TMPDIR if it is defined;
2236 otherwise, from the P_tmpdir macro if that is defined;
2237 otherwise, in /usr/tmp or /tmp;
2238 or finally the current directory if all else fails. */
2240 static const char *temp_filename
;
2242 /* Length of the prefix. */
2244 static int temp_filename_length
;
2246 /* Define the list of temporary files to delete. */
2251 struct temp_file
*next
;
2254 /* Queue of files to delete on success or failure of compilation. */
2255 static struct temp_file
*always_delete_queue
;
2256 /* Queue of files to delete on failure of compilation. */
2257 static struct temp_file
*failure_delete_queue
;
2259 /* Record FILENAME as a file to be deleted automatically.
2260 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2261 otherwise delete it in any case.
2262 FAIL_DELETE nonzero means delete it if a compilation step fails;
2263 otherwise delete it in any case. */
2266 record_temp_file (const char *filename
, int always_delete
, int fail_delete
)
2268 char *const name
= xstrdup (filename
);
2272 struct temp_file
*temp
;
2273 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2274 if (! strcmp (name
, temp
->name
))
2277 temp
= xmalloc (sizeof (struct temp_file
));
2278 temp
->next
= always_delete_queue
;
2280 always_delete_queue
= temp
;
2287 struct temp_file
*temp
;
2288 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2289 if (! strcmp (name
, temp
->name
))
2292 temp
= xmalloc (sizeof (struct temp_file
));
2293 temp
->next
= failure_delete_queue
;
2295 failure_delete_queue
= temp
;
2301 /* Delete all the temporary files whose names we previously recorded. */
2303 #ifndef DELETE_IF_ORDINARY
2304 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2307 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2308 if (unlink (NAME) < 0) \
2310 perror_with_name (NAME); \
2315 delete_if_ordinary (const char *name
)
2321 printf ("Delete %s? (y or n) ", name
);
2325 while ((c
= getchar ()) != '\n' && c
!= EOF
)
2328 if (i
== 'y' || i
== 'Y')
2330 DELETE_IF_ORDINARY (name
, st
, verbose_flag
);
2334 delete_temp_files (void)
2336 struct temp_file
*temp
;
2338 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
2339 delete_if_ordinary (temp
->name
);
2340 always_delete_queue
= 0;
2343 /* Delete all the files to be deleted on error. */
2346 delete_failure_queue (void)
2348 struct temp_file
*temp
;
2350 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
2351 delete_if_ordinary (temp
->name
);
2355 clear_failure_queue (void)
2357 failure_delete_queue
= 0;
2360 /* Build a list of search directories from PATHS.
2361 PREFIX is a string to prepend to the list.
2362 If CHECK_DIR_P is nonzero we ensure the directory exists.
2363 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2364 It is also used by the --print-search-dirs flag. */
2367 build_search_list (struct path_prefix
*paths
, const char *prefix
,
2370 int suffix_len
= (machine_suffix
) ? strlen (machine_suffix
) : 0;
2372 = (just_machine_suffix
) ? strlen (just_machine_suffix
) : 0;
2373 int first_time
= TRUE
;
2374 struct prefix_list
*pprefix
;
2376 obstack_grow (&collect_obstack
, prefix
, strlen (prefix
));
2377 obstack_1grow (&collect_obstack
, '=');
2379 for (pprefix
= paths
->plist
; pprefix
!= 0; pprefix
= pprefix
->next
)
2381 int len
= strlen (pprefix
->prefix
);
2385 || is_directory (pprefix
->prefix
, machine_suffix
, 0)))
2388 obstack_1grow (&collect_obstack
, PATH_SEPARATOR
);
2391 obstack_grow (&collect_obstack
, pprefix
->prefix
, len
);
2392 obstack_grow (&collect_obstack
, machine_suffix
, suffix_len
);
2395 if (just_machine_suffix
2396 && pprefix
->require_machine_suffix
== 2
2398 || is_directory (pprefix
->prefix
, just_machine_suffix
, 0)))
2401 obstack_1grow (&collect_obstack
, PATH_SEPARATOR
);
2404 obstack_grow (&collect_obstack
, pprefix
->prefix
, len
);
2405 obstack_grow (&collect_obstack
, just_machine_suffix
,
2409 if (! pprefix
->require_machine_suffix
)
2412 obstack_1grow (&collect_obstack
, PATH_SEPARATOR
);
2415 obstack_grow (&collect_obstack
, pprefix
->prefix
, len
);
2419 obstack_1grow (&collect_obstack
, '\0');
2420 return XOBFINISH (&collect_obstack
, char *);
2423 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2427 putenv_from_prefixes (struct path_prefix
*paths
, const char *env_var
)
2429 putenv (build_search_list (paths
, env_var
, 1));
2432 /* Check whether NAME can be accessed in MODE. This is like access,
2433 except that it never considers directories to be executable. */
2436 access_check (const char *name
, int mode
)
2442 if (stat (name
, &st
) < 0
2443 || S_ISDIR (st
.st_mode
))
2447 return access (name
, mode
);
2450 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2451 access to check permissions.
2452 Return 0 if not found, otherwise return its name, allocated with malloc. */
2455 find_a_file (struct path_prefix
*pprefix
, const char *name
, int mode
,
2459 const char *const file_suffix
=
2460 ((mode
& X_OK
) != 0 ? HOST_EXECUTABLE_SUFFIX
: "");
2461 struct prefix_list
*pl
;
2462 int len
= pprefix
->max_len
+ strlen (name
) + strlen (file_suffix
) + 1;
2463 const char *multilib_name
, *multilib_os_name
;
2465 #ifdef DEFAULT_ASSEMBLER
2466 if (! strcmp (name
, "as") && access (DEFAULT_ASSEMBLER
, mode
) == 0)
2467 return xstrdup (DEFAULT_ASSEMBLER
);
2470 #ifdef DEFAULT_LINKER
2471 if (! strcmp(name
, "ld") && access (DEFAULT_LINKER
, mode
) == 0)
2472 return xstrdup (DEFAULT_LINKER
);
2476 len
+= strlen (machine_suffix
);
2478 multilib_name
= name
;
2479 multilib_os_name
= name
;
2480 if (multilib
&& multilib_os_dir
)
2482 int len1
= multilib_dir
? strlen (multilib_dir
) + 1 : 0;
2483 int len2
= strlen (multilib_os_dir
) + 1;
2485 len
+= len1
> len2
? len1
: len2
;
2487 multilib_name
= ACONCAT ((multilib_dir
, dir_separator_str
, name
,
2489 if (strcmp (multilib_os_dir
, ".") != 0)
2490 multilib_os_name
= ACONCAT ((multilib_os_dir
, dir_separator_str
, name
,
2494 temp
= xmalloc (len
);
2496 /* Determine the filename to execute (special case for absolute paths). */
2498 if (IS_ABSOLUTE_PATH (name
))
2500 if (access (name
, mode
) == 0)
2502 strcpy (temp
, name
);
2507 for (pl
= pprefix
->plist
; pl
; pl
= pl
->next
)
2509 const char *this_name
2510 = pl
->os_multilib
? multilib_os_name
: multilib_name
;
2514 /* Some systems have a suffix for executable files.
2515 So try appending that first. */
2516 if (file_suffix
[0] != 0)
2518 strcpy (temp
, pl
->prefix
);
2519 strcat (temp
, machine_suffix
);
2520 strcat (temp
, multilib_name
);
2521 strcat (temp
, file_suffix
);
2522 if (access_check (temp
, mode
) == 0)
2526 /* Now try just the multilib_name. */
2527 strcpy (temp
, pl
->prefix
);
2528 strcat (temp
, machine_suffix
);
2529 strcat (temp
, multilib_name
);
2530 if (access_check (temp
, mode
) == 0)
2534 /* Certain prefixes are tried with just the machine type,
2535 not the version. This is used for finding as, ld, etc. */
2536 if (just_machine_suffix
&& pl
->require_machine_suffix
== 2)
2538 /* Some systems have a suffix for executable files.
2539 So try appending that first. */
2540 if (file_suffix
[0] != 0)
2542 strcpy (temp
, pl
->prefix
);
2543 strcat (temp
, just_machine_suffix
);
2544 strcat (temp
, multilib_name
);
2545 strcat (temp
, file_suffix
);
2546 if (access_check (temp
, mode
) == 0)
2550 strcpy (temp
, pl
->prefix
);
2551 strcat (temp
, just_machine_suffix
);
2552 strcat (temp
, multilib_name
);
2553 if (access_check (temp
, mode
) == 0)
2557 /* Certain prefixes can't be used without the machine suffix
2558 when the machine or version is explicitly specified. */
2559 if (! pl
->require_machine_suffix
)
2561 /* Some systems have a suffix for executable files.
2562 So try appending that first. */
2563 if (file_suffix
[0] != 0)
2565 strcpy (temp
, pl
->prefix
);
2566 strcat (temp
, this_name
);
2567 strcat (temp
, file_suffix
);
2568 if (access_check (temp
, mode
) == 0)
2572 strcpy (temp
, pl
->prefix
);
2573 strcat (temp
, this_name
);
2574 if (access_check (temp
, mode
) == 0)
2583 /* Ranking of prefixes in the sort list. -B prefixes are put before
2586 enum path_prefix_priority
2588 PREFIX_PRIORITY_B_OPT
,
2589 PREFIX_PRIORITY_LAST
2592 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
2593 order according to PRIORITY. Within each PRIORITY, new entries are
2596 If WARN is nonzero, we will warn if no file is found
2597 through this prefix. WARN should point to an int
2598 which will be set to 1 if this entry is used.
2600 COMPONENT is the value to be passed to update_path.
2602 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2603 the complete value of machine_suffix.
2604 2 means try both machine_suffix and just_machine_suffix. */
2607 add_prefix (struct path_prefix
*pprefix
, const char *prefix
,
2608 const char *component
, /* enum prefix_priority */ int priority
,
2609 int require_machine_suffix
, int os_multilib
)
2611 struct prefix_list
*pl
, **prev
;
2614 for (prev
= &pprefix
->plist
;
2615 (*prev
) != NULL
&& (*prev
)->priority
<= priority
;
2616 prev
= &(*prev
)->next
)
2619 /* Keep track of the longest prefix. */
2621 prefix
= update_path (prefix
, component
);
2622 len
= strlen (prefix
);
2623 if (len
> pprefix
->max_len
)
2624 pprefix
->max_len
= len
;
2626 pl
= xmalloc (sizeof (struct prefix_list
));
2627 pl
->prefix
= prefix
;
2628 pl
->require_machine_suffix
= require_machine_suffix
;
2629 pl
->priority
= priority
;
2630 pl
->os_multilib
= os_multilib
;
2632 /* Insert after PREV. */
2637 /* Same as add_prefix, but prepending target_system_root to prefix. */
2639 add_sysrooted_prefix (struct path_prefix
*pprefix
, const char *prefix
,
2640 const char *component
,
2641 /* enum prefix_priority */ int priority
,
2642 int require_machine_suffix
, int os_multilib
)
2644 if (!IS_ABSOLUTE_PATH (prefix
))
2645 fatal ("system path '%s' is not absolute", prefix
);
2647 if (target_system_root
)
2649 if (target_sysroot_suffix
)
2650 prefix
= concat (target_sysroot_suffix
, prefix
, NULL
);
2651 prefix
= concat (target_system_root
, prefix
, NULL
);
2653 /* We have to override this because GCC's notion of sysroot
2654 moves along with GCC. */
2658 add_prefix (pprefix
, prefix
, component
, priority
,
2659 require_machine_suffix
, os_multilib
);
2662 /* Execute the command specified by the arguments on the current line of spec.
2663 When using pipes, this includes several piped-together commands
2664 with `|' between them.
2666 Return 0 if successful, -1 if failed. */
2672 int n_commands
; /* # of command. */
2674 struct pex_obj
*pex
;
2677 const char *prog
; /* program name. */
2678 const char **argv
; /* vector of args. */
2681 struct command
*commands
; /* each command buffer with above info. */
2683 gcc_assert (!processing_spec_function
);
2685 /* Count # of piped commands. */
2686 for (n_commands
= 1, i
= 0; i
< argbuf_index
; i
++)
2687 if (strcmp (argbuf
[i
], "|") == 0)
2690 /* Get storage for each command. */
2691 commands
= alloca (n_commands
* sizeof (struct command
));
2693 /* Split argbuf into its separate piped processes,
2694 and record info about each one.
2695 Also search for the programs that are to be run. */
2697 commands
[0].prog
= argbuf
[0]; /* first command. */
2698 commands
[0].argv
= &argbuf
[0];
2699 string
= find_a_file (&exec_prefixes
, commands
[0].prog
, X_OK
, 0);
2702 commands
[0].argv
[0] = string
;
2704 for (n_commands
= 1, i
= 0; i
< argbuf_index
; i
++)
2705 if (strcmp (argbuf
[i
], "|") == 0)
2706 { /* each command. */
2707 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2708 fatal ("-pipe not supported");
2710 argbuf
[i
] = 0; /* termination of command args. */
2711 commands
[n_commands
].prog
= argbuf
[i
+ 1];
2712 commands
[n_commands
].argv
= &argbuf
[i
+ 1];
2713 string
= find_a_file (&exec_prefixes
, commands
[n_commands
].prog
,
2716 commands
[n_commands
].argv
[0] = string
;
2720 argbuf
[argbuf_index
] = 0;
2722 /* If -v, print what we are about to do, and maybe query. */
2726 /* For help listings, put a blank line between sub-processes. */
2727 if (print_help_list
)
2728 fputc ('\n', stderr
);
2730 /* Print each piped command as a separate line. */
2731 for (i
= 0; i
< n_commands
; i
++)
2733 const char *const *j
;
2735 if (verbose_only_flag
)
2737 for (j
= commands
[i
].argv
; *j
; j
++)
2740 fprintf (stderr
, " \"");
2741 for (p
= *j
; *p
; ++p
)
2743 if (*p
== '"' || *p
== '\\' || *p
== '$')
2744 fputc ('\\', stderr
);
2747 fputc ('"', stderr
);
2751 for (j
= commands
[i
].argv
; *j
; j
++)
2752 fprintf (stderr
, " %s", *j
);
2754 /* Print a pipe symbol after all but the last command. */
2755 if (i
+ 1 != n_commands
)
2756 fprintf (stderr
, " |");
2757 fprintf (stderr
, "\n");
2760 if (verbose_only_flag
!= 0)
2762 /* verbose_only_flag should act as if the spec was
2763 executed, so increment execution_count before
2764 returning. This prevents spurious warnings about
2765 unused linker input files, etc. */
2770 notice ("\nGo ahead? (y or n) ");
2774 while (getchar () != '\n')
2777 if (i
!= 'y' && i
!= 'Y')
2782 #ifdef ENABLE_VALGRIND_CHECKING
2783 /* Run the each command through valgrind. To simplify prepending the
2784 path to valgrind and the option "-q" (for quiet operation unless
2785 something triggers), we allocate a separate argv array. */
2787 for (i
= 0; i
< n_commands
; i
++)
2793 for (argc
= 0; commands
[i
].argv
[argc
] != NULL
; argc
++)
2796 argv
= alloca ((argc
+ 3) * sizeof (char *));
2798 argv
[0] = VALGRIND_PATH
;
2800 for (j
= 2; j
< argc
+ 2; j
++)
2801 argv
[j
] = commands
[i
].argv
[j
- 2];
2804 commands
[i
].argv
= argv
;
2805 commands
[i
].prog
= argv
[0];
2809 /* Run each piped subprocess. */
2811 pex
= pex_init (PEX_USE_PIPES
| (report_times
? PEX_RECORD_TIMES
: 0),
2812 programname
, temp_filename
);
2814 pfatal_with_name (_("pex_init failed"));
2816 for (i
= 0; i
< n_commands
; i
++)
2820 const char *string
= commands
[i
].argv
[0];
2822 errmsg
= pex_run (pex
,
2823 ((i
+ 1 == n_commands
? PEX_LAST
: 0)
2824 | (string
== commands
[i
].prog
? PEX_SEARCH
: 0)),
2825 string
, (char * const *) commands
[i
].argv
,
2834 pfatal_with_name (errmsg
);
2838 if (string
!= commands
[i
].prog
)
2839 free ((void *) string
);
2844 /* Wait for all the subprocesses to finish. */
2848 struct pex_time
*times
= NULL
;
2851 statuses
= alloca (n_commands
* sizeof (int));
2852 if (!pex_get_status (pex
, n_commands
, statuses
))
2853 pfatal_with_name (_("failed to get exit status"));
2857 times
= alloca (n_commands
* sizeof (struct pex_time
));
2858 if (!pex_get_times (pex
, n_commands
, times
))
2859 pfatal_with_name (_("failed to get process times"));
2864 for (i
= 0; i
< n_commands
; ++i
)
2866 int status
= statuses
[i
];
2868 if (WIFSIGNALED (status
))
2871 /* SIGPIPE is a special case. It happens in -pipe mode
2872 when the compiler dies before the preprocessor is done,
2873 or the assembler dies before the compiler is done.
2874 There's generally been an error already, and this is
2875 just fallout. So don't generate another error unless
2876 we would otherwise have succeeded. */
2877 if (WTERMSIG (status
) == SIGPIPE
2878 && (signal_count
|| greatest_status
>= MIN_FATAL_STATUS
))
2886 Internal error: %s (program %s)\n\
2887 Please submit a full bug report.\n\
2888 See %s for instructions.",
2889 strsignal (WTERMSIG (status
)), commands
[i
].prog
,
2892 else if (WIFEXITED (status
)
2893 && WEXITSTATUS (status
) >= MIN_FATAL_STATUS
)
2895 if (WEXITSTATUS (status
) > greatest_status
)
2896 greatest_status
= WEXITSTATUS (status
);
2902 struct pex_time
*pt
= ×
[i
];
2905 ut
= ((double) pt
->user_seconds
2906 + (double) pt
->user_microseconds
/ 1.0e6
);
2907 st
= ((double) pt
->system_seconds
2908 + (double) pt
->system_microseconds
/ 1.0e6
);
2911 notice ("# %s %.2f %.2f\n", commands
[i
].prog
, ut
, st
);
2919 /* Find all the switches given to us
2920 and make a vector describing them.
2921 The elements of the vector are strings, one per switch given.
2922 If a switch uses following arguments, then the `part1' field
2923 is the switch itself and the `args' field
2924 is a null-terminated vector containing the following arguments.
2925 The `live_cond' field is:
2927 1 if the switch is true in a conditional spec,
2928 -1 if false (overridden by a later switch)
2929 -2 if this switch should be ignored (used in %<S)
2930 The `validated' field is nonzero if any spec has looked at this switch;
2931 if it remains zero at the end of the run, it must be meaningless. */
2934 #define SWITCH_FALSE -1
2935 #define SWITCH_IGNORE -2
2936 #define SWITCH_LIVE 1
2943 unsigned char validated
;
2944 unsigned char ordering
;
2947 static struct switchstr
*switches
;
2949 static int n_switches
;
2951 /* Language is one of three things:
2953 1) The name of a real programming language.
2954 2) NULL, indicating that no one has figured out
2956 3) '*', indicating that the file should be passed
2961 const char *language
;
2962 struct compiler
*incompiler
;
2967 /* Also a vector of input files specified. */
2969 static struct infile
*infiles
;
2973 /* True if multiple input files are being compiled to a single
2976 static bool combine_inputs
;
2978 /* This counts the number of libraries added by lang_specific_driver, so that
2979 we can tell if there were any user supplied any files or libraries. */
2981 static int added_libraries
;
2983 /* And a vector of corresponding output files is made up later. */
2985 const char **outfiles
;
2987 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2989 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
2990 is true if we should look for an executable suffix. DO_OBJ
2991 is true if we should look for an object suffix. */
2994 convert_filename (const char *name
, int do_exe ATTRIBUTE_UNUSED
,
2995 int do_obj ATTRIBUTE_UNUSED
)
2997 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3005 len
= strlen (name
);
3007 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3008 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
3009 if (do_obj
&& len
> 2
3010 && name
[len
- 2] == '.'
3011 && name
[len
- 1] == 'o')
3013 obstack_grow (&obstack
, name
, len
- 2);
3014 obstack_grow0 (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
3015 name
= XOBFINISH (&obstack
, const char *);
3019 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3020 /* If there is no filetype, make it the executable suffix (which includes
3021 the "."). But don't get confused if we have just "-o". */
3022 if (! do_exe
|| TARGET_EXECUTABLE_SUFFIX
[0] == 0 || (len
== 2 && name
[0] == '-'))
3025 for (i
= len
- 1; i
>= 0; i
--)
3026 if (IS_DIR_SEPARATOR (name
[i
]))
3029 for (i
++; i
< len
; i
++)
3033 obstack_grow (&obstack
, name
, len
);
3034 obstack_grow0 (&obstack
, TARGET_EXECUTABLE_SUFFIX
,
3035 strlen (TARGET_EXECUTABLE_SUFFIX
));
3036 name
= XOBFINISH (&obstack
, const char *);
3043 /* Display the command line switches accepted by gcc. */
3047 printf (_("Usage: %s [options] file...\n"), programname
);
3048 fputs (_("Options:\n"), stdout
);
3050 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout
);
3051 fputs (_(" --help Display this information\n"), stdout
);
3052 fputs (_(" --target-help Display target specific command line options\n"), stdout
);
3054 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout
);
3055 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout
);
3056 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout
);
3057 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout
);
3058 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout
);
3059 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout
);
3060 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout
);
3061 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout
);
3062 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout
);
3064 -print-multi-lib Display the mapping between command line options and\n\
3065 multiple library search directories\n"), stdout
);
3066 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries\n"), stdout
);
3067 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout
);
3068 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout
);
3069 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout
);
3070 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler\n"), stdout
);
3071 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n"), stdout
);
3072 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout
);
3073 fputs (_(" -combine Pass multiple source files to compiler at once\n"), stdout
);
3074 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout
);
3075 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout
);
3076 fputs (_(" -time Time the execution of each subprocess\n"), stdout
);
3077 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout
);
3078 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout
);
3080 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3081 for headers and libraries\n"), stdout
);
3082 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout
);
3083 fputs (_(" -b <machine> Run gcc for target <machine>, if installed\n"), stdout
);
3084 fputs (_(" -V <version> Run gcc version number <version>, if installed\n"), stdout
);
3085 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout
);
3086 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout
);
3087 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout
);
3088 fputs (_(" -S Compile only; do not assemble or link\n"), stdout
);
3089 fputs (_(" -c Compile and assemble, but do not link\n"), stdout
);
3090 fputs (_(" -o <file> Place the output into <file>\n"), stdout
);
3092 -x <language> Specify the language of the following input files\n\
3093 Permissible languages include: c c++ assembler none\n\
3094 'none' means revert to the default behavior of\n\
3095 guessing the language based on the file's extension\n\
3099 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3100 passed on to the various sub-processes invoked by %s. In order to pass\n\
3101 other options on to these processes the -W<letter> options must be used.\n\
3104 /* The rest of the options are displayed by invocations of the various
3109 add_preprocessor_option (const char *option
, int len
)
3111 n_preprocessor_options
++;
3113 if (! preprocessor_options
)
3114 preprocessor_options
= xmalloc (n_preprocessor_options
* sizeof (char *));
3116 preprocessor_options
= xrealloc (preprocessor_options
,
3117 n_preprocessor_options
* sizeof (char *));
3119 preprocessor_options
[n_preprocessor_options
- 1] =
3120 save_string (option
, len
);
3124 add_assembler_option (const char *option
, int len
)
3126 n_assembler_options
++;
3128 if (! assembler_options
)
3129 assembler_options
= xmalloc (n_assembler_options
* sizeof (char *));
3131 assembler_options
= xrealloc (assembler_options
,
3132 n_assembler_options
* sizeof (char *));
3134 assembler_options
[n_assembler_options
- 1] = save_string (option
, len
);
3138 add_linker_option (const char *option
, int len
)
3142 if (! linker_options
)
3143 linker_options
= xmalloc (n_linker_options
* sizeof (char *));
3145 linker_options
= xrealloc (linker_options
,
3146 n_linker_options
* sizeof (char *));
3148 linker_options
[n_linker_options
- 1] = save_string (option
, len
);
3151 /* Create the vector `switches' and its contents.
3152 Store its length in `n_switches'. */
3155 process_command (int argc
, const char **argv
)
3160 const char *spec_lang
= 0;
3161 int last_language_n_infiles
;
3162 int lang_n_infiles
= 0;
3163 #ifdef MODIFY_TARGET_NAME
3164 int is_modify_target_name
;
3168 GET_ENVIRONMENT (gcc_exec_prefix
, "GCC_EXEC_PREFIX");
3172 added_libraries
= 0;
3174 /* Figure compiler version from version string. */
3176 compiler_version
= temp1
= xstrdup (version_string
);
3178 for (; *temp1
; ++temp1
)
3187 /* If there is a -V or -b option (or both), process it now, before
3188 trying to interpret the rest of the command line.
3189 Use heuristic that all configuration names must have at least
3190 one dash '-'. This allows us to pass options starting with -b. */
3191 if (argc
> 1 && argv
[1][0] == '-'
3192 && (argv
[1][1] == 'V' ||
3193 ((argv
[1][1] == 'b') && (NULL
!= strchr(argv
[1] + 2,'-')))))
3195 const char *new_version
= DEFAULT_TARGET_VERSION
;
3196 const char *new_machine
= DEFAULT_TARGET_MACHINE
;
3197 const char *progname
= argv
[0];
3202 while (argc
> 1 && argv
[1][0] == '-'
3203 && (argv
[1][1] == 'V' ||
3204 ((argv
[1][1] == 'b') && ( NULL
!= strchr(argv
[1] + 2,'-')))))
3206 char opt
= argv
[1][1];
3208 if (argv
[1][2] != '\0')
3221 fatal ("'-%c' option must have argument", opt
);
3228 for (baselen
= strlen (progname
); baselen
> 0; baselen
--)
3229 if (IS_DIR_SEPARATOR (progname
[baselen
-1]))
3231 new_argv0
= xmemdup (progname
, baselen
,
3232 baselen
+ concat_length (new_version
, new_machine
,
3233 "-gcc-", NULL
) + 1);
3234 strcpy (new_argv0
+ baselen
, new_machine
);
3235 strcat (new_argv0
, "-gcc-");
3236 strcat (new_argv0
, new_version
);
3238 new_argv
= xmemdup (argv
, (argc
+ 1) * sizeof (argv
[0]),
3239 (argc
+ 1) * sizeof (argv
[0]));
3240 new_argv
[0] = new_argv0
;
3242 execvp (new_argv0
, new_argv
);
3243 fatal ("couldn't run '%s': %s", new_argv0
, xstrerror (errno
));
3246 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
3247 see if we can create it from the pathname specified in argv[0]. */
3249 gcc_libexec_prefix
= standard_libexec_prefix
;
3251 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
3252 if (!gcc_exec_prefix
)
3254 gcc_exec_prefix
= make_relative_prefix (argv
[0], standard_bindir_prefix
,
3255 standard_exec_prefix
);
3256 gcc_libexec_prefix
= make_relative_prefix (argv
[0],
3257 standard_bindir_prefix
,
3258 standard_libexec_prefix
);
3259 if (gcc_exec_prefix
)
3260 putenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix
, NULL
));
3263 gcc_libexec_prefix
= make_relative_prefix (gcc_exec_prefix
,
3264 standard_exec_prefix
,
3265 standard_libexec_prefix
);
3269 if (gcc_exec_prefix
)
3271 int len
= strlen (gcc_exec_prefix
);
3273 if (len
> (int) sizeof ("/lib/gcc/") - 1
3274 && (IS_DIR_SEPARATOR (gcc_exec_prefix
[len
-1])))
3276 temp
= gcc_exec_prefix
+ len
- sizeof ("/lib/gcc/") + 1;
3277 if (IS_DIR_SEPARATOR (*temp
)
3278 && strncmp (temp
+ 1, "lib", 3) == 0
3279 && IS_DIR_SEPARATOR (temp
[4])
3280 && strncmp (temp
+ 5, "gcc", 3) == 0)
3281 len
-= sizeof ("/lib/gcc/") - 1;
3284 set_std_prefix (gcc_exec_prefix
, len
);
3285 add_prefix (&exec_prefixes
, gcc_libexec_prefix
, "GCC",
3286 PREFIX_PRIORITY_LAST
, 0, 0);
3287 add_prefix (&startfile_prefixes
, gcc_exec_prefix
, "GCC",
3288 PREFIX_PRIORITY_LAST
, 0, 0);
3291 /* COMPILER_PATH and LIBRARY_PATH have values
3292 that are lists of directory names with colons. */
3294 GET_ENVIRONMENT (temp
, "COMPILER_PATH");
3297 const char *startp
, *endp
;
3298 char *nstore
= alloca (strlen (temp
) + 3);
3300 startp
= endp
= temp
;
3303 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
3305 strncpy (nstore
, startp
, endp
- startp
);
3307 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
3308 else if (!IS_DIR_SEPARATOR (endp
[-1]))
3310 nstore
[endp
- startp
] = DIR_SEPARATOR
;
3311 nstore
[endp
- startp
+ 1] = 0;
3314 nstore
[endp
- startp
] = 0;
3315 add_prefix (&exec_prefixes
, nstore
, 0,
3316 PREFIX_PRIORITY_LAST
, 0, 0);
3317 add_prefix (&include_prefixes
, nstore
, 0,
3318 PREFIX_PRIORITY_LAST
, 0, 0);
3321 endp
= startp
= endp
+ 1;
3328 GET_ENVIRONMENT (temp
, LIBRARY_PATH_ENV
);
3329 if (temp
&& *cross_compile
== '0')
3331 const char *startp
, *endp
;
3332 char *nstore
= alloca (strlen (temp
) + 3);
3334 startp
= endp
= temp
;
3337 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
3339 strncpy (nstore
, startp
, endp
- startp
);
3341 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
3342 else if (!IS_DIR_SEPARATOR (endp
[-1]))
3344 nstore
[endp
- startp
] = DIR_SEPARATOR
;
3345 nstore
[endp
- startp
+ 1] = 0;
3348 nstore
[endp
- startp
] = 0;
3349 add_prefix (&startfile_prefixes
, nstore
, NULL
,
3350 PREFIX_PRIORITY_LAST
, 0, 1);
3353 endp
= startp
= endp
+ 1;
3360 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
3361 GET_ENVIRONMENT (temp
, "LPATH");
3362 if (temp
&& *cross_compile
== '0')
3364 const char *startp
, *endp
;
3365 char *nstore
= alloca (strlen (temp
) + 3);
3367 startp
= endp
= temp
;
3370 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
3372 strncpy (nstore
, startp
, endp
- startp
);
3374 strcpy (nstore
, concat (".", dir_separator_str
, NULL
));
3375 else if (!IS_DIR_SEPARATOR (endp
[-1]))
3377 nstore
[endp
- startp
] = DIR_SEPARATOR
;
3378 nstore
[endp
- startp
+ 1] = 0;
3381 nstore
[endp
- startp
] = 0;
3382 add_prefix (&startfile_prefixes
, nstore
, NULL
,
3383 PREFIX_PRIORITY_LAST
, 0, 1);
3386 endp
= startp
= endp
+ 1;
3393 /* Convert new-style -- options to old-style. */
3394 translate_options (&argc
, (const char *const **) &argv
);
3396 /* Do language-specific adjustment/addition of flags. */
3397 lang_specific_driver (&argc
, (const char *const **) &argv
, &added_libraries
);
3399 /* Scan argv twice. Here, the first time, just count how many switches
3400 there will be in their vector, and how many input files in theirs.
3401 Here we also parse the switches that cc itself uses (e.g. -v). */
3403 for (i
= 1; i
< argc
; i
++)
3405 if (! strcmp (argv
[i
], "-dumpspecs"))
3407 struct spec_list
*sl
;
3409 for (sl
= specs
; sl
; sl
= sl
->next
)
3410 printf ("*%s:\n%s\n\n", sl
->name
, *(sl
->ptr_spec
));
3411 if (link_command_spec
)
3412 printf ("*link_command:\n%s\n\n", link_command_spec
);
3415 else if (! strcmp (argv
[i
], "-dumpversion"))
3417 printf ("%s\n", spec_version
);
3420 else if (! strcmp (argv
[i
], "-dumpmachine"))
3422 printf ("%s\n", spec_machine
);
3425 else if (strcmp (argv
[i
], "-fversion") == 0)
3427 /* translate_options () has turned --version into -fversion. */
3428 printf (_("%s (GCC) %s\n"), programname
, version_string
);
3429 printf ("Copyright %s 2005 Free Software Foundation, Inc.\n",
3431 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
3432 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
3436 else if (strcmp (argv
[i
], "-fhelp") == 0)
3438 /* translate_options () has turned --help into -fhelp. */
3439 print_help_list
= 1;
3441 /* We will be passing a dummy file on to the sub-processes. */
3445 /* CPP driver cannot obtain switch from cc1_options. */
3447 add_preprocessor_option ("--help", 6);
3448 add_assembler_option ("--help", 6);
3449 add_linker_option ("--help", 6);
3451 else if (strcmp (argv
[i
], "-ftarget-help") == 0)
3453 /* translate_options() has turned --target-help into -ftarget-help. */
3454 target_help_flag
= 1;
3456 /* We will be passing a dummy file on to the sub-processes. */
3460 /* CPP driver cannot obtain switch from cc1_options. */
3462 add_preprocessor_option ("--target-help", 13);
3463 add_assembler_option ("--target-help", 13);
3464 add_linker_option ("--target-help", 13);
3466 else if (! strcmp (argv
[i
], "-pass-exit-codes"))
3468 pass_exit_codes
= 1;
3471 else if (! strcmp (argv
[i
], "-print-search-dirs"))
3472 print_search_dirs
= 1;
3473 else if (! strcmp (argv
[i
], "-print-libgcc-file-name"))
3474 print_file_name
= "libgcc.a";
3475 else if (! strncmp (argv
[i
], "-print-file-name=", 17))
3476 print_file_name
= argv
[i
] + 17;
3477 else if (! strncmp (argv
[i
], "-print-prog-name=", 17))
3478 print_prog_name
= argv
[i
] + 17;
3479 else if (! strcmp (argv
[i
], "-print-multi-lib"))
3480 print_multi_lib
= 1;
3481 else if (! strcmp (argv
[i
], "-print-multi-directory"))
3482 print_multi_directory
= 1;
3483 else if (! strcmp (argv
[i
], "-print-multi-os-directory"))
3484 print_multi_os_directory
= 1;
3485 else if (! strncmp (argv
[i
], "-Wa,", 4))
3488 /* Pass the rest of this option to the assembler. */
3490 /* Split the argument at commas. */
3492 for (j
= 4; argv
[i
][j
]; j
++)
3493 if (argv
[i
][j
] == ',')
3495 add_assembler_option (argv
[i
] + prev
, j
- prev
);
3499 /* Record the part after the last comma. */
3500 add_assembler_option (argv
[i
] + prev
, j
- prev
);
3502 else if (! strncmp (argv
[i
], "-Wp,", 4))
3505 /* Pass the rest of this option to the preprocessor. */
3507 /* Split the argument at commas. */
3509 for (j
= 4; argv
[i
][j
]; j
++)
3510 if (argv
[i
][j
] == ',')
3512 add_preprocessor_option (argv
[i
] + prev
, j
- prev
);
3516 /* Record the part after the last comma. */
3517 add_preprocessor_option (argv
[i
] + prev
, j
- prev
);
3519 else if (argv
[i
][0] == '+' && argv
[i
][1] == 'e')
3520 /* The +e options to the C++ front-end. */
3522 else if (strncmp (argv
[i
], "-Wl,", 4) == 0)
3525 /* Split the argument at commas. */
3526 for (j
= 3; argv
[i
][j
]; j
++)
3527 n_infiles
+= (argv
[i
][j
] == ',');
3529 else if (strcmp (argv
[i
], "-Xlinker") == 0)
3532 fatal ("argument to '-Xlinker' is missing");
3537 else if (strcmp (argv
[i
], "-Xpreprocessor") == 0)
3540 fatal ("argument to '-Xpreprocessor' is missing");
3542 add_preprocessor_option (argv
[i
+1], strlen (argv
[i
+1]));
3544 else if (strcmp (argv
[i
], "-Xassembler") == 0)
3547 fatal ("argument to '-Xassembler' is missing");
3549 add_assembler_option (argv
[i
+1], strlen (argv
[i
+1]));
3551 else if (strcmp (argv
[i
], "-l") == 0)
3554 fatal ("argument to '-l' is missing");
3559 else if (strncmp (argv
[i
], "-l", 2) == 0)
3561 else if (strcmp (argv
[i
], "-save-temps") == 0)
3563 save_temps_flag
= 1;
3566 else if (strcmp (argv
[i
], "-combine") == 0)
3571 else if (strcmp (argv
[i
], "-specs") == 0)
3573 struct user_specs
*user
= xmalloc (sizeof (struct user_specs
));
3575 fatal ("argument to '-specs' is missing");
3577 user
->next
= (struct user_specs
*) 0;
3578 user
->filename
= argv
[i
];
3579 if (user_specs_tail
)
3580 user_specs_tail
->next
= user
;
3582 user_specs_head
= user
;
3583 user_specs_tail
= user
;
3585 else if (strncmp (argv
[i
], "-specs=", 7) == 0)
3587 struct user_specs
*user
= xmalloc (sizeof (struct user_specs
));
3588 if (strlen (argv
[i
]) == 7)
3589 fatal ("argument to '-specs=' is missing");
3591 user
->next
= (struct user_specs
*) 0;
3592 user
->filename
= argv
[i
] + 7;
3593 if (user_specs_tail
)
3594 user_specs_tail
->next
= user
;
3596 user_specs_head
= user
;
3597 user_specs_tail
= user
;
3599 else if (strcmp (argv
[i
], "-time") == 0)
3601 else if (strcmp (argv
[i
], "-pipe") == 0)
3603 /* -pipe has to go into the switches array as well as
3608 else if (strcmp (argv
[i
], "-###") == 0)
3610 /* This is similar to -v except that there is no execution
3611 of the commands and the echoed arguments are quoted. It
3612 is intended for use in shell scripts to capture the
3613 driver-generated command line. */
3614 verbose_only_flag
++;
3617 else if (argv
[i
][0] == '-' && argv
[i
][1] != 0)
3619 const char *p
= &argv
[i
][1];
3625 if (NULL
== strchr(argv
[i
] + 2, '-')) break;
3627 fatal ("'-%c' must come at the start of the command line", c
);
3635 if (p
[1] == 0 && i
+ 1 == argc
)
3636 fatal ("argument to '-B' is missing");
3642 len
= strlen (value
);
3644 /* Catch the case where the user has forgotten to append a
3645 directory separator to the path. Note, they may be using
3646 -B to add an executable name prefix, eg "i386-elf-", in
3647 order to distinguish between multiple installations of
3648 GCC in the same directory. Hence we must check to see
3649 if appending a directory separator actually makes a
3650 valid directory name. */
3651 if (! IS_DIR_SEPARATOR (value
[len
- 1])
3652 && is_directory (value
, "", 0))
3654 char *tmp
= xmalloc (len
+ 2);
3655 strcpy (tmp
, value
);
3656 tmp
[len
] = DIR_SEPARATOR
;
3661 /* As a kludge, if the arg is "[foo/]stageN/", just
3662 add "[foo/]include" to the include prefix. */
3665 && (IS_DIR_SEPARATOR (value
[len
- 8]))))
3666 && strncmp (value
+ len
- 7, "stage", 5) == 0
3667 && ISDIGIT (value
[len
- 2])
3668 && (IS_DIR_SEPARATOR (value
[len
- 1])))
3671 add_prefix (&include_prefixes
, "./", NULL
,
3672 PREFIX_PRIORITY_B_OPT
, 0, 0);
3675 char *string
= xmalloc (len
- 6);
3676 memcpy (string
, value
, len
- 7);
3677 string
[len
- 7] = 0;
3678 add_prefix (&include_prefixes
, string
, NULL
,
3679 PREFIX_PRIORITY_B_OPT
, 0, 0);
3683 add_prefix (&exec_prefixes
, value
, NULL
,
3684 PREFIX_PRIORITY_B_OPT
, 0, 0);
3685 add_prefix (&startfile_prefixes
, value
, NULL
,
3686 PREFIX_PRIORITY_B_OPT
, 0, 0);
3687 add_prefix (&include_prefixes
, value
, NULL
,
3688 PREFIX_PRIORITY_B_OPT
, 0, 0);
3693 case 'v': /* Print our subcommands and print versions. */
3695 /* If they do anything other than exactly `-v', don't set
3696 verbose_flag; rather, continue on to give the error. */
3714 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3719 /* Forward scan, just in case -S or -c is specified
3726 if (argv
[j
][0] == '-')
3728 if (SWITCH_CURTAILS_COMPILATION (argv
[j
][1])
3734 else if ((skip
= SWITCH_TAKES_ARG (argv
[j
][1])))
3735 j
+= skip
- (argv
[j
][2] != 0);
3736 else if ((skip
= WORD_SWITCH_TAKES_ARG (argv
[j
] + 1)))
3743 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3745 argv
[i
+ 1] = convert_filename (argv
[i
+ 1], ! have_c
, 0);
3747 argv
[i
] = convert_filename (argv
[i
], ! have_c
, 0);
3754 #ifdef MODIFY_TARGET_NAME
3755 is_modify_target_name
= 0;
3757 for (j
= 0; j
< ARRAY_SIZE (modify_target
); j
++)
3758 if (! strcmp (argv
[i
], modify_target
[j
].sw
))
3760 char *new_name
= xmalloc (strlen (modify_target
[j
].str
)
3761 + strlen (spec_machine
));
3764 int made_addition
= 0;
3766 is_modify_target_name
= 1;
3767 for (p
= spec_machine
, q
= new_name
; *p
!= 0; )
3769 if (modify_target
[j
].add_del
== DELETE
3770 && (! strncmp (q
, modify_target
[j
].str
,
3771 strlen (modify_target
[j
].str
))))
3772 p
+= strlen (modify_target
[j
].str
);
3773 else if (modify_target
[j
].add_del
== ADD
3774 && ! made_addition
&& *p
== '-')
3776 for (r
= modify_target
[j
].str
; *r
!= 0; )
3784 spec_machine
= new_name
;
3787 if (is_modify_target_name
)
3793 if (SWITCH_TAKES_ARG (c
) > (p
[1] != 0))
3794 i
+= SWITCH_TAKES_ARG (c
) - (p
[1] != 0);
3795 else if (WORD_SWITCH_TAKES_ARG (p
))
3796 i
+= WORD_SWITCH_TAKES_ARG (p
);
3806 if (save_temps_flag
&& use_pipes
)
3808 /* -save-temps overrides -pipe, so that temp files are produced */
3809 if (save_temps_flag
)
3810 error ("warning: -pipe ignored because -save-temps specified");
3814 /* Set up the search paths before we go looking for config files. */
3816 /* These come before the md prefixes so that we will find gcc's subcommands
3817 (such as cpp) rather than those of the host system. */
3818 /* Use 2 as fourth arg meaning try just the machine as a suffix,
3819 as well as trying the machine and the version. */
3821 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "GCC",
3822 PREFIX_PRIORITY_LAST
, 1, 0);
3823 add_prefix (&exec_prefixes
, standard_libexec_prefix
, "BINUTILS",
3824 PREFIX_PRIORITY_LAST
, 2, 0);
3825 add_prefix (&exec_prefixes
, standard_exec_prefix
, "BINUTILS",
3826 PREFIX_PRIORITY_LAST
, 2, 0);
3827 add_prefix (&exec_prefixes
, standard_exec_prefix_1
, "BINUTILS",
3828 PREFIX_PRIORITY_LAST
, 2, 0);
3829 add_prefix (&exec_prefixes
, standard_exec_prefix_2
, "BINUTILS",
3830 PREFIX_PRIORITY_LAST
, 2, 0);
3833 add_prefix (&startfile_prefixes
, standard_exec_prefix
, "BINUTILS",
3834 PREFIX_PRIORITY_LAST
, 1, 0);
3835 add_prefix (&startfile_prefixes
, standard_exec_prefix_2
, "BINUTILS",
3836 PREFIX_PRIORITY_LAST
, 1, 0);
3838 tooldir_prefix
= concat (tooldir_base_prefix
, spec_machine
,
3839 dir_separator_str
, NULL
);
3841 /* If tooldir is relative, base it on exec_prefixes. A relative
3842 tooldir lets us move the installed tree as a unit.
3844 If GCC_EXEC_PREFIX is defined, then we want to add two relative
3845 directories, so that we can search both the user specified directory
3846 and the standard place. */
3848 if (!IS_ABSOLUTE_PATH (tooldir_prefix
))
3850 if (gcc_exec_prefix
)
3852 char *gcc_exec_tooldir_prefix
3853 = concat (gcc_exec_prefix
, spec_machine
, dir_separator_str
,
3854 spec_version
, dir_separator_str
, tooldir_prefix
, NULL
);
3856 add_prefix (&exec_prefixes
,
3857 concat (gcc_exec_tooldir_prefix
, "bin",
3858 dir_separator_str
, NULL
),
3859 NULL
, PREFIX_PRIORITY_LAST
, 0, 0);
3860 add_prefix (&startfile_prefixes
,
3861 concat (gcc_exec_tooldir_prefix
, "lib",
3862 dir_separator_str
, NULL
),
3863 NULL
, PREFIX_PRIORITY_LAST
, 0, 1);
3866 tooldir_prefix
= concat (standard_exec_prefix
, spec_machine
,
3867 dir_separator_str
, spec_version
,
3868 dir_separator_str
, tooldir_prefix
, NULL
);
3871 add_prefix (&exec_prefixes
,
3872 concat (tooldir_prefix
, "bin", dir_separator_str
, NULL
),
3873 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 0);
3874 add_prefix (&startfile_prefixes
,
3875 concat (tooldir_prefix
, "lib", dir_separator_str
, NULL
),
3876 "BINUTILS", PREFIX_PRIORITY_LAST
, 0, 1);
3878 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
3879 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
3880 then consider it to relocate with the rest of the GCC installation
3881 if GCC_EXEC_PREFIX is set.
3882 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
3883 if (target_system_root
&& gcc_exec_prefix
)
3885 char *tmp_prefix
= make_relative_prefix (argv
[0],
3886 standard_bindir_prefix
,
3887 target_system_root
);
3888 if (tmp_prefix
&& access_check (tmp_prefix
, F_OK
) == 0)
3890 target_system_root
= tmp_prefix
;
3891 target_system_root_changed
= 1;
3896 /* More prefixes are enabled in main, after we read the specs file
3897 and determine whether this is cross-compilation or not. */
3899 /* Then create the space for the vectors and scan again. */
3901 switches
= xmalloc ((n_switches
+ 1) * sizeof (struct switchstr
));
3902 infiles
= xmalloc ((n_infiles
+ 1) * sizeof (struct infile
));
3905 last_language_n_infiles
= -1;
3907 /* This, time, copy the text of each switch and store a pointer
3908 to the copy in the vector of switches.
3909 Store all the infiles in their vector. */
3911 for (i
= 1; i
< argc
; i
++)
3913 /* Just skip the switches that were handled by the preceding loop. */
3914 #ifdef MODIFY_TARGET_NAME
3915 is_modify_target_name
= 0;
3917 for (j
= 0; j
< ARRAY_SIZE (modify_target
); j
++)
3918 if (! strcmp (argv
[i
], modify_target
[j
].sw
))
3919 is_modify_target_name
= 1;
3921 if (is_modify_target_name
)
3925 if (! strncmp (argv
[i
], "-Wa,", 4))
3927 else if (! strncmp (argv
[i
], "-Wp,", 4))
3929 else if (! strcmp (argv
[i
], "-pass-exit-codes"))
3931 else if (! strcmp (argv
[i
], "-print-search-dirs"))
3933 else if (! strcmp (argv
[i
], "-print-libgcc-file-name"))
3935 else if (! strncmp (argv
[i
], "-print-file-name=", 17))
3937 else if (! strncmp (argv
[i
], "-print-prog-name=", 17))
3939 else if (! strcmp (argv
[i
], "-print-multi-lib"))
3941 else if (! strcmp (argv
[i
], "-print-multi-directory"))
3943 else if (! strcmp (argv
[i
], "-print-multi-os-directory"))
3945 else if (! strcmp (argv
[i
], "-ftarget-help"))
3947 else if (! strcmp (argv
[i
], "-fhelp"))
3949 else if (! strncmp (argv
[i
], "--sysroot=", strlen ("--sysroot=")))
3951 target_system_root
= argv
[i
] + strlen ("--sysroot=");
3952 target_system_root_changed
= 1;
3954 else if (argv
[i
][0] == '+' && argv
[i
][1] == 'e')
3956 /* Compensate for the +e options to the C++ front-end;
3957 they're there simply for cfront call-compatibility. We do
3958 some magic in default_compilers to pass them down properly.
3959 Note we deliberately start at the `+' here, to avoid passing
3960 -e0 or -e1 down into the linker. */
3961 switches
[n_switches
].part1
= &argv
[i
][0];
3962 switches
[n_switches
].args
= 0;
3963 switches
[n_switches
].live_cond
= SWITCH_OK
;
3964 switches
[n_switches
].validated
= 0;
3967 else if (strncmp (argv
[i
], "-Wl,", 4) == 0)
3970 /* Split the argument at commas. */
3972 for (j
= 4; argv
[i
][j
]; j
++)
3973 if (argv
[i
][j
] == ',')
3975 infiles
[n_infiles
].language
= "*";
3976 infiles
[n_infiles
++].name
3977 = save_string (argv
[i
] + prev
, j
- prev
);
3980 /* Record the part after the last comma. */
3981 infiles
[n_infiles
].language
= "*";
3982 infiles
[n_infiles
++].name
= argv
[i
] + prev
;
3984 else if (strcmp (argv
[i
], "-Xlinker") == 0)
3986 infiles
[n_infiles
].language
= "*";
3987 infiles
[n_infiles
++].name
= argv
[++i
];
3989 /* Xassembler and Xpreprocessor were already handled in the first argv
3990 scan, so all we need to do here is ignore them and their argument. */
3991 else if (strcmp (argv
[i
], "-Xassembler") == 0)
3993 else if (strcmp (argv
[i
], "-Xpreprocessor") == 0)
3995 else if (strcmp (argv
[i
], "-l") == 0)
3996 { /* POSIX allows separation of -l and the lib arg;
3997 canonicalize by concatenating -l with its arg */
3998 infiles
[n_infiles
].language
= "*";
3999 infiles
[n_infiles
++].name
= concat ("-l", argv
[++i
], NULL
);
4001 else if (strncmp (argv
[i
], "-l", 2) == 0)
4003 infiles
[n_infiles
].language
= "*";
4004 infiles
[n_infiles
++].name
= argv
[i
];
4006 else if (strcmp (argv
[i
], "-specs") == 0)
4008 else if (strncmp (argv
[i
], "-specs=", 7) == 0)
4010 else if (strcmp (argv
[i
], "-time") == 0)
4012 else if (strcmp (argv
[i
], "-###") == 0)
4014 else if (argv
[i
][0] == '-' && argv
[i
][1] != 0)
4016 const char *p
= &argv
[i
][1];
4021 if (p
[1] == 0 && i
+ 1 == argc
)
4022 fatal ("argument to '-x' is missing");
4024 spec_lang
= argv
[++i
];
4027 if (! strcmp (spec_lang
, "none"))
4028 /* Suppress the warning if -xnone comes after the last input
4029 file, because alternate command interfaces like g++ might
4030 find it useful to place -xnone after each input file. */
4033 last_language_n_infiles
= n_infiles
;
4036 switches
[n_switches
].part1
= p
;
4037 /* Deal with option arguments in separate argv elements. */
4038 if ((SWITCH_TAKES_ARG (c
) > (p
[1] != 0))
4039 || WORD_SWITCH_TAKES_ARG (p
))
4042 int n_args
= WORD_SWITCH_TAKES_ARG (p
);
4046 /* Count only the option arguments in separate argv elements. */
4047 n_args
= SWITCH_TAKES_ARG (c
) - (p
[1] != 0);
4049 if (i
+ n_args
>= argc
)
4050 fatal ("argument to '-%s' is missing", p
);
4051 switches
[n_switches
].args
4052 = xmalloc ((n_args
+ 1) * sizeof(const char *));
4054 switches
[n_switches
].args
[j
++] = argv
[++i
];
4055 /* Null-terminate the vector. */
4056 switches
[n_switches
].args
[j
] = 0;
4058 else if (strchr (switches_need_spaces
, c
))
4060 /* On some systems, ld cannot handle some options without
4061 a space. So split the option from its argument. */
4062 char *part1
= xmalloc (2);
4066 switches
[n_switches
].part1
= part1
;
4067 switches
[n_switches
].args
= xmalloc (2 * sizeof (const char *));
4068 switches
[n_switches
].args
[0] = xstrdup (p
+1);
4069 switches
[n_switches
].args
[1] = 0;
4072 switches
[n_switches
].args
= 0;
4074 switches
[n_switches
].live_cond
= SWITCH_OK
;
4075 switches
[n_switches
].validated
= 0;
4076 switches
[n_switches
].ordering
= 0;
4077 /* These are always valid, since gcc.c itself understands them. */
4078 if (!strcmp (p
, "save-temps")
4079 || !strcmp (p
, "static-libgcc")
4080 || !strcmp (p
, "shared-libgcc")
4081 || !strcmp (p
, "pipe"))
4082 switches
[n_switches
].validated
= 1;
4085 char ch
= switches
[n_switches
].part1
[0];
4087 switches
[n_switches
].validated
= 1;
4093 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4094 argv
[i
] = convert_filename (argv
[i
], 0, access (argv
[i
], F_OK
));
4097 if (strcmp (argv
[i
], "-") != 0 && access (argv
[i
], F_OK
) < 0)
4099 perror_with_name (argv
[i
]);
4104 infiles
[n_infiles
].language
= spec_lang
;
4105 infiles
[n_infiles
++].name
= argv
[i
];
4110 if (n_infiles
== last_language_n_infiles
&& spec_lang
!= 0)
4111 error ("warning: '-x %s' after last input file has no effect", spec_lang
);
4113 /* Ensure we only invoke each subprocess once. */
4114 if (target_help_flag
|| print_help_list
)
4118 /* Create a dummy input file, so that we can pass --target-help on to
4119 the various sub-processes. */
4120 infiles
[0].language
= "c";
4121 infiles
[0].name
= "help-dummy";
4123 if (target_help_flag
)
4125 switches
[n_switches
].part1
= "--target-help";
4126 switches
[n_switches
].args
= 0;
4127 switches
[n_switches
].live_cond
= SWITCH_OK
;
4128 switches
[n_switches
].validated
= 0;
4133 if (print_help_list
)
4135 switches
[n_switches
].part1
= "--help";
4136 switches
[n_switches
].args
= 0;
4137 switches
[n_switches
].live_cond
= SWITCH_OK
;
4138 switches
[n_switches
].validated
= 0;
4144 switches
[n_switches
].part1
= 0;
4145 infiles
[n_infiles
].name
= 0;
4148 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4149 and place that in the environment. */
4152 set_collect_gcc_options (void)
4157 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4159 obstack_grow (&collect_obstack
, "COLLECT_GCC_OPTIONS=",
4160 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4163 for (i
= 0; (int) i
< n_switches
; i
++)
4165 const char *const *args
;
4168 obstack_grow (&collect_obstack
, " ", 1);
4172 /* Ignore elided switches. */
4173 if (switches
[i
].live_cond
== SWITCH_IGNORE
)
4176 obstack_grow (&collect_obstack
, "'-", 2);
4177 q
= switches
[i
].part1
;
4178 while ((p
= strchr (q
, '\'')))
4180 obstack_grow (&collect_obstack
, q
, p
- q
);
4181 obstack_grow (&collect_obstack
, "'\\''", 4);
4184 obstack_grow (&collect_obstack
, q
, strlen (q
));
4185 obstack_grow (&collect_obstack
, "'", 1);
4187 for (args
= switches
[i
].args
; args
&& *args
; args
++)
4189 obstack_grow (&collect_obstack
, " '", 2);
4191 while ((p
= strchr (q
, '\'')))
4193 obstack_grow (&collect_obstack
, q
, p
- q
);
4194 obstack_grow (&collect_obstack
, "'\\''", 4);
4197 obstack_grow (&collect_obstack
, q
, strlen (q
));
4198 obstack_grow (&collect_obstack
, "'", 1);
4201 obstack_grow (&collect_obstack
, "\0", 1);
4202 putenv (XOBFINISH (&collect_obstack
, char *));
4205 /* Process a spec string, accumulating and running commands. */
4207 /* These variables describe the input file name.
4208 input_file_number is the index on outfiles of this file,
4209 so that the output file name can be stored for later use by %o.
4210 input_basename is the start of the part of the input file
4211 sans all directory names, and basename_length is the number
4212 of characters starting there excluding the suffix .c or whatever. */
4214 static const char *input_filename
;
4215 static int input_file_number
;
4216 size_t input_filename_length
;
4217 static int basename_length
;
4218 static int suffixed_basename_length
;
4219 static const char *input_basename
;
4220 static const char *input_suffix
;
4221 #ifndef HOST_LACKS_INODE_NUMBERS
4222 static struct stat input_stat
;
4224 static int input_stat_set
;
4226 /* The compiler used to process the current input file. */
4227 static struct compiler
*input_file_compiler
;
4229 /* These are variables used within do_spec and do_spec_1. */
4231 /* Nonzero if an arg has been started and not yet terminated
4232 (with space, tab or newline). */
4233 static int arg_going
;
4235 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4236 is a temporary file name. */
4237 static int delete_this_arg
;
4239 /* Nonzero means %w has been seen; the next arg to be terminated
4240 is the output file name of this compilation. */
4241 static int this_is_output_file
;
4243 /* Nonzero means %s has been seen; the next arg to be terminated
4244 is the name of a library file and we should try the standard
4245 search dirs for it. */
4246 static int this_is_library_file
;
4248 /* Nonzero means that the input of this command is coming from a pipe. */
4249 static int input_from_pipe
;
4251 /* Nonnull means substitute this for any suffix when outputting a switches
4253 static const char *suffix_subst
;
4255 /* Process the spec SPEC and run the commands specified therein.
4256 Returns 0 if the spec is successfully processed; -1 if failed. */
4259 do_spec (const char *spec
)
4263 value
= do_spec_2 (spec
);
4265 /* Force out any unfinished command.
4266 If -pipe, this forces out the last command if it ended in `|'. */
4269 if (argbuf_index
> 0 && !strcmp (argbuf
[argbuf_index
- 1], "|"))
4272 set_collect_gcc_options ();
4274 if (argbuf_index
> 0)
4282 do_spec_2 (const char *spec
)
4289 delete_this_arg
= 0;
4290 this_is_output_file
= 0;
4291 this_is_library_file
= 0;
4292 input_from_pipe
= 0;
4293 suffix_subst
= NULL
;
4295 result
= do_spec_1 (spec
, 0, NULL
);
4297 /* End any pending argument. */
4300 obstack_1grow (&obstack
, 0);
4301 string
= XOBFINISH (&obstack
, const char *);
4302 if (this_is_library_file
)
4303 string
= find_file (string
);
4304 store_arg (string
, delete_this_arg
, this_is_output_file
);
4305 if (this_is_output_file
)
4306 outfiles
[input_file_number
] = string
;
4314 /* Process the given spec string and add any new options to the end
4315 of the switches/n_switches array. */
4318 do_option_spec (const char *name
, const char *spec
)
4320 unsigned int i
, value_count
, value_len
;
4321 const char *p
, *q
, *value
;
4322 char *tmp_spec
, *tmp_spec_p
;
4324 if (configure_default_options
[0].name
== NULL
)
4327 for (i
= 0; i
< ARRAY_SIZE (configure_default_options
); i
++)
4328 if (strcmp (configure_default_options
[i
].name
, name
) == 0)
4330 if (i
== ARRAY_SIZE (configure_default_options
))
4333 value
= configure_default_options
[i
].value
;
4334 value_len
= strlen (value
);
4336 /* Compute the size of the final spec. */
4339 while ((p
= strstr (p
, "%(VALUE)")) != NULL
)
4345 /* Replace each %(VALUE) by the specified value. */
4346 tmp_spec
= alloca (strlen (spec
) + 1
4347 + value_count
* (value_len
- strlen ("%(VALUE)")));
4348 tmp_spec_p
= tmp_spec
;
4350 while ((p
= strstr (q
, "%(VALUE)")) != NULL
)
4352 memcpy (tmp_spec_p
, q
, p
- q
);
4353 tmp_spec_p
= tmp_spec_p
+ (p
- q
);
4354 memcpy (tmp_spec_p
, value
, value_len
);
4355 tmp_spec_p
+= value_len
;
4356 q
= p
+ strlen ("%(VALUE)");
4358 strcpy (tmp_spec_p
, q
);
4360 do_self_spec (tmp_spec
);
4363 /* Process the given spec string and add any new options to the end
4364 of the switches/n_switches array. */
4367 do_self_spec (const char *spec
)
4370 do_spec_1 (" ", 0, NULL
);
4372 if (argbuf_index
> 0)
4377 n_switches
+= argbuf_index
;
4378 switches
= xrealloc (switches
,
4379 sizeof (struct switchstr
) * (n_switches
+ 1));
4381 switches
[n_switches
] = switches
[first
];
4382 for (i
= 0; i
< argbuf_index
; i
++)
4384 struct switchstr
*sw
;
4386 /* Each switch should start with '-'. */
4387 if (argbuf
[i
][0] != '-')
4388 fatal ("switch '%s' does not start with '-'", argbuf
[i
]);
4390 sw
= &switches
[i
+ first
];
4391 sw
->part1
= &argbuf
[i
][1];
4393 sw
->live_cond
= SWITCH_OK
;
4401 do_spec_path (struct prefix_list
*pl
, const char *option
,
4402 int omit_if_relative
, int separate_options
,
4404 const char *dir_for_machine_suffix
,
4405 const char *dir_for_no_suffix
)
4407 static size_t bufsize
= 0;
4408 static char *buffer
;
4410 bool multilib_p
= false;
4412 /* Used on systems which record the specified -L dirs
4413 and use them to search for dynamic linking. */
4414 /* Relative directories always come from -B,
4415 and it is better not to use them for searching
4416 at run time. In particular, stage1 loses. */
4417 if (omit_if_relative
4418 && !IS_ABSOLUTE_PATH (pl
->prefix
))
4421 /* Try subdirectory if there is one. */
4422 if (machine_suffix
&& dir_for_machine_suffix
)
4424 if (strlen (pl
->prefix
) + strlen (machine_suffix
)
4426 bufsize
= (strlen (pl
->prefix
)
4427 + strlen (machine_suffix
)) * 2 + 1;
4428 buffer
= xrealloc (buffer
, bufsize
);
4429 strcpy (buffer
, pl
->prefix
);
4430 strcat (buffer
, machine_suffix
);
4431 if (is_directory (buffer
, dir_for_machine_suffix
, 1))
4434 do_spec_1 (option
, separate_options
, NULL
);
4435 if (separate_options
)
4436 do_spec_1 (" ", 0, NULL
);
4437 do_spec_1 (buffer
, 1, NULL
);
4438 do_spec_1 (dir_for_machine_suffix
, 1, NULL
);
4439 /* Make this a separate argument. */
4440 do_spec_1 (" ", 0, NULL
);
4443 if (!pl
->require_machine_suffix
&& dir_for_no_suffix
)
4445 if (is_directory (pl
->prefix
, dir_for_no_suffix
, 1))
4448 do_spec_1 (option
, separate_options
, NULL
);
4449 if (separate_options
)
4450 do_spec_1 (" ", 0, NULL
);
4451 do_spec_1 (pl
->prefix
, 1, NULL
);
4452 do_spec_1 (dir_for_no_suffix
, 1, NULL
);
4453 /* Make this a separate argument. */
4454 do_spec_1 (" ", 0, NULL
);
4458 if (only_subdir
|| multilib_p
)
4463 if (is_directory (pl
->prefix
, machine_suffix
, 1))
4465 do_spec_1 (option
, separate_options
, NULL
);
4466 if (separate_options
)
4467 do_spec_1 (" ", 0, NULL
);
4468 do_spec_1 (pl
->prefix
, 1, NULL
);
4469 /* Remove slash from machine_suffix. */
4470 if (strlen (machine_suffix
) >= bufsize
)
4471 bufsize
= strlen (machine_suffix
) * 2 + 1;
4472 buffer
= xrealloc (buffer
, bufsize
);
4473 strcpy (buffer
, machine_suffix
);
4474 idx
= strlen (buffer
);
4475 if (IS_DIR_SEPARATOR (buffer
[idx
- 1]))
4476 buffer
[idx
- 1] = 0;
4477 do_spec_1 (buffer
, 1, NULL
);
4478 /* Make this a separate argument. */
4479 do_spec_1 (" ", 0, NULL
);
4482 if (!pl
->require_machine_suffix
)
4484 if (is_directory (pl
->prefix
, "", 1))
4486 do_spec_1 (option
, separate_options
, NULL
);
4487 if (separate_options
)
4488 do_spec_1 (" ", 0, NULL
);
4489 /* Remove slash from pl->prefix. */
4490 if (strlen (pl
->prefix
) >= bufsize
)
4491 bufsize
= strlen (pl
->prefix
) * 2 + 1;
4492 buffer
= xrealloc (buffer
, bufsize
);
4493 strcpy (buffer
, pl
->prefix
);
4494 idx
= strlen (buffer
);
4495 if (IS_DIR_SEPARATOR (buffer
[idx
- 1]))
4496 buffer
[idx
- 1] = 0;
4497 do_spec_1 (buffer
, 1, NULL
);
4498 /* Make this a separate argument. */
4499 do_spec_1 (" ", 0, NULL
);
4504 /* Process the sub-spec SPEC as a portion of a larger spec.
4505 This is like processing a whole spec except that we do
4506 not initialize at the beginning and we do not supply a
4507 newline by default at the end.
4508 INSWITCH nonzero means don't process %-sequences in SPEC;
4509 in this case, % is treated as an ordinary character.
4510 This is used while substituting switches.
4511 INSWITCH nonzero also causes SPC not to terminate an argument.
4513 Value is zero unless a line was finished
4514 and the command on that line reported an error. */
4517 do_spec_1 (const char *spec
, int inswitch
, const char *soft_matched_part
)
4519 const char *p
= spec
;
4526 /* If substituting a switch, treat all chars like letters.
4527 Otherwise, NL, SPC, TAB and % are special. */
4528 switch (inswitch
? 'a' : c
)
4531 /* End of line: finish any pending argument,
4532 then run the pending command if one has been started. */
4535 obstack_1grow (&obstack
, 0);
4536 string
= XOBFINISH (&obstack
, const char *);
4537 if (this_is_library_file
)
4538 string
= find_file (string
);
4539 store_arg (string
, delete_this_arg
, this_is_output_file
);
4540 if (this_is_output_file
)
4541 outfiles
[input_file_number
] = string
;
4545 if (argbuf_index
> 0 && !strcmp (argbuf
[argbuf_index
- 1], "|"))
4547 /* A `|' before the newline means use a pipe here,
4548 but only if -pipe was specified.
4549 Otherwise, execute now and don't pass the `|' as an arg. */
4552 input_from_pipe
= 1;
4559 set_collect_gcc_options ();
4561 if (argbuf_index
> 0)
4567 /* Reinitialize for a new command, and for a new argument. */
4570 delete_this_arg
= 0;
4571 this_is_output_file
= 0;
4572 this_is_library_file
= 0;
4573 input_from_pipe
= 0;
4577 /* End any pending argument. */
4580 obstack_1grow (&obstack
, 0);
4581 string
= XOBFINISH (&obstack
, const char *);
4582 if (this_is_library_file
)
4583 string
= find_file (string
);
4584 store_arg (string
, delete_this_arg
, this_is_output_file
);
4585 if (this_is_output_file
)
4586 outfiles
[input_file_number
] = string
;
4590 obstack_1grow (&obstack
, c
);
4596 /* Space or tab ends an argument if one is pending. */
4599 obstack_1grow (&obstack
, 0);
4600 string
= XOBFINISH (&obstack
, const char *);
4601 if (this_is_library_file
)
4602 string
= find_file (string
);
4603 store_arg (string
, delete_this_arg
, this_is_output_file
);
4604 if (this_is_output_file
)
4605 outfiles
[input_file_number
] = string
;
4607 /* Reinitialize for a new argument. */
4609 delete_this_arg
= 0;
4610 this_is_output_file
= 0;
4611 this_is_library_file
= 0;
4618 fatal ("spec '%s' invalid", spec
);
4621 obstack_grow (&obstack
, input_basename
, basename_length
);
4626 obstack_grow (&obstack
, input_basename
, suffixed_basename_length
);
4631 delete_this_arg
= 2;
4634 /* Dump out the directories specified with LIBRARY_PATH,
4635 followed by the absolute directories
4636 that we search for startfiles. */
4639 struct prefix_list
*pl
= startfile_prefixes
.plist
;
4641 for (; pl
; pl
= pl
->next
)
4643 const char *no_suffix_multilib_dir
;
4645 no_suffix_multilib_dir
= pl
->os_multilib
? multilib_os_dir
4647 /* Do not separate options, include non-multilibbed variant. */
4648 do_spec_path (pl
, "-L",
4649 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
4654 0, 0, multilib_dir
, no_suffix_multilib_dir
);
4660 /* %efoo means report an error with `foo' as error message
4661 and don't execute any more commands for this file. */
4665 while (*p
!= 0 && *p
!= '\n')
4667 buf
= alloca (p
- q
+ 1);
4668 strncpy (buf
, q
, p
- q
);
4675 /* %nfoo means report a notice with `foo' on stderr. */
4679 while (*p
!= 0 && *p
!= '\n')
4681 buf
= alloca (p
- q
+ 1);
4682 strncpy (buf
, q
, p
- q
);
4684 notice ("%s\n", buf
);
4694 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
4695 defined, and it is not a directory, and it is
4696 writable, use it. Otherwise, treat this like any
4697 other temporary file. */
4699 if ((!save_temps_flag
)
4700 && (stat (HOST_BIT_BUCKET
, &st
) == 0) && (!S_ISDIR (st
.st_mode
))
4701 && (access (HOST_BIT_BUCKET
, W_OK
) == 0))
4703 obstack_grow (&obstack
, HOST_BIT_BUCKET
,
4704 strlen (HOST_BIT_BUCKET
));
4705 delete_this_arg
= 0;
4710 goto create_temp_file
;
4714 obstack_1grow (&obstack
, '-');
4715 delete_this_arg
= 0;
4718 /* consume suffix */
4719 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
4721 if (p
[0] == '%' && p
[1] == 'O')
4726 goto create_temp_file
;
4730 /* consume suffix */
4731 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
4733 if (p
[0] == '%' && p
[1] == 'O')
4738 goto create_temp_file
;
4744 struct temp_name
*t
;
4746 const char *suffix
= p
;
4747 char *saved_suffix
= NULL
;
4749 while (*p
== '.' || ISALNUM ((unsigned char) *p
))
4751 suffix_length
= p
- suffix
;
4752 if (p
[0] == '%' && p
[1] == 'O')
4755 /* We don't support extra suffix characters after %O. */
4756 if (*p
== '.' || ISALNUM ((unsigned char) *p
))
4757 fatal ("spec '%s' has invalid '%%0%c'", spec
, *p
);
4758 if (suffix_length
== 0)
4759 suffix
= TARGET_OBJECT_SUFFIX
;
4763 = xmalloc (suffix_length
4764 + strlen (TARGET_OBJECT_SUFFIX
));
4765 strncpy (saved_suffix
, suffix
, suffix_length
);
4766 strcpy (saved_suffix
+ suffix_length
,
4767 TARGET_OBJECT_SUFFIX
);
4769 suffix_length
+= strlen (TARGET_OBJECT_SUFFIX
);
4772 /* If the input_filename has the same suffix specified
4773 for the %g, %u, or %U, and -save-temps is specified,
4774 we could end up using that file as an intermediate
4775 thus clobbering the user's source file (.e.g.,
4776 gcc -save-temps foo.s would clobber foo.s with the
4777 output of cpp0). So check for this condition and
4778 generate a temp file as the intermediate. */
4780 if (save_temps_flag
)
4782 temp_filename_length
= basename_length
+ suffix_length
;
4783 temp_filename
= alloca (temp_filename_length
+ 1);
4784 strncpy ((char *) temp_filename
, input_basename
, basename_length
);
4785 strncpy ((char *) temp_filename
+ basename_length
, suffix
,
4787 *((char *) temp_filename
+ temp_filename_length
) = '\0';
4788 if (strcmp (temp_filename
, input_filename
) != 0)
4790 #ifndef HOST_LACKS_INODE_NUMBERS
4791 struct stat st_temp
;
4793 /* Note, set_input() resets input_stat_set to 0. */
4794 if (input_stat_set
== 0)
4796 input_stat_set
= stat (input_filename
, &input_stat
);
4797 if (input_stat_set
>= 0)
4801 /* If we have the stat for the input_filename
4802 and we can do the stat for the temp_filename
4803 then the they could still refer to the same
4804 file if st_dev/st_ino's are the same. */
4805 if (input_stat_set
!= 1
4806 || stat (temp_filename
, &st_temp
) < 0
4807 || input_stat
.st_dev
!= st_temp
.st_dev
4808 || input_stat
.st_ino
!= st_temp
.st_ino
)
4810 /* Just compare canonical pathnames. */
4811 char* input_realname
= lrealpath (input_filename
);
4812 char* temp_realname
= lrealpath (temp_filename
);
4813 bool files_differ
= strcmp (input_realname
, temp_realname
);
4814 free (input_realname
);
4815 free (temp_realname
);
4819 temp_filename
= save_string (temp_filename
,
4820 temp_filename_length
+ 1);
4821 obstack_grow (&obstack
, temp_filename
,
4822 temp_filename_length
);
4824 delete_this_arg
= 0;
4830 /* See if we already have an association of %g/%u/%U and
4832 for (t
= temp_names
; t
; t
= t
->next
)
4833 if (t
->length
== suffix_length
4834 && strncmp (t
->suffix
, suffix
, suffix_length
) == 0
4835 && t
->unique
== (c
== 'u' || c
== 'U' || c
== 'j'))
4838 /* Make a new association if needed. %u and %j
4840 if (t
== 0 || c
== 'u' || c
== 'j')
4844 t
= xmalloc (sizeof (struct temp_name
));
4845 t
->next
= temp_names
;
4848 t
->length
= suffix_length
;
4851 t
->suffix
= saved_suffix
;
4852 saved_suffix
= NULL
;
4855 t
->suffix
= save_string (suffix
, suffix_length
);
4856 t
->unique
= (c
== 'u' || c
== 'U' || c
== 'j');
4857 temp_filename
= make_temp_file (t
->suffix
);
4858 temp_filename_length
= strlen (temp_filename
);
4859 t
->filename
= temp_filename
;
4860 t
->filename_length
= temp_filename_length
;
4864 free (saved_suffix
);
4866 obstack_grow (&obstack
, t
->filename
, t
->filename_length
);
4867 delete_this_arg
= 1;
4875 for (i
= 0; (int) i
< n_infiles
; i
++)
4876 if ((!infiles
[i
].language
) || (infiles
[i
].language
[0] != '*'))
4877 if (infiles
[i
].incompiler
== input_file_compiler
)
4879 store_arg (infiles
[i
].name
, 0, 0);
4880 infiles
[i
].compiled
= true;
4885 obstack_grow (&obstack
, input_filename
, input_filename_length
);
4892 struct prefix_list
*pl
= include_prefixes
.plist
;
4894 if (gcc_exec_prefix
)
4896 do_spec_1 ("-iprefix", 1, NULL
);
4897 /* Make this a separate argument. */
4898 do_spec_1 (" ", 0, NULL
);
4899 do_spec_1 (gcc_exec_prefix
, 1, NULL
);
4900 do_spec_1 (" ", 0, NULL
);
4903 if (target_system_root_changed
||
4904 (target_system_root
&& target_sysroot_hdrs_suffix
))
4906 do_spec_1 ("-isysroot", 1, NULL
);
4907 /* Make this a separate argument. */
4908 do_spec_1 (" ", 0, NULL
);
4909 do_spec_1 (target_system_root
, 1, NULL
);
4910 if (target_sysroot_hdrs_suffix
)
4911 do_spec_1 (target_sysroot_hdrs_suffix
, 1, NULL
);
4912 do_spec_1 (" ", 0, NULL
);
4915 for (; pl
; pl
= pl
->next
)
4916 /* Separate options, don't include non-suffixed variant. */
4917 do_spec_path (pl
, "-isystem", 0, 1, 1, "include", "include");
4923 int max
= n_infiles
;
4924 max
+= lang_specific_extra_outfiles
;
4926 for (i
= 0; i
< max
; i
++)
4928 store_arg (outfiles
[i
], 0, 0);
4933 obstack_grow (&obstack
, TARGET_OBJECT_SUFFIX
, strlen (TARGET_OBJECT_SUFFIX
));
4938 this_is_library_file
= 1;
4942 outfiles
[input_file_number
] = NULL
;
4946 this_is_output_file
= 1;
4951 int cur_index
= argbuf_index
;
4952 /* Handle the {...} following the %W. */
4954 fatal ("spec '%s' has invalid '%%W%c", spec
, *p
);
4955 p
= handle_braces (p
+ 1);
4958 /* End any pending argument. */
4961 obstack_1grow (&obstack
, 0);
4962 string
= XOBFINISH (&obstack
, const char *);
4963 if (this_is_library_file
)
4964 string
= find_file (string
);
4965 store_arg (string
, delete_this_arg
, this_is_output_file
);
4966 if (this_is_output_file
)
4967 outfiles
[input_file_number
] = string
;
4970 /* If any args were output, mark the last one for deletion
4972 if (argbuf_index
!= cur_index
)
4973 record_temp_file (argbuf
[argbuf_index
- 1], 0, 1);
4977 /* %x{OPTION} records OPTION for %X to output. */
4983 /* Skip past the option value and make a copy. */
4985 fatal ("spec '%s' has invalid '%%x%c'", spec
, *p
);
4988 string
= save_string (p1
+ 1, p
- p1
- 2);
4990 /* See if we already recorded this option. */
4991 for (i
= 0; i
< n_linker_options
; i
++)
4992 if (! strcmp (string
, linker_options
[i
]))
4998 /* This option is new; add it. */
4999 add_linker_option (string
, strlen (string
));
5003 /* Dump out the options accumulated previously using %x. */
5005 for (i
= 0; i
< n_linker_options
; i
++)
5007 do_spec_1 (linker_options
[i
], 1, NULL
);
5008 /* Make each accumulated option a separate argument. */
5009 do_spec_1 (" ", 0, NULL
);
5013 /* Dump out the options accumulated previously using -Wa,. */
5015 for (i
= 0; i
< n_assembler_options
; i
++)
5017 do_spec_1 (assembler_options
[i
], 1, NULL
);
5018 /* Make each accumulated option a separate argument. */
5019 do_spec_1 (" ", 0, NULL
);
5023 /* Dump out the options accumulated previously using -Wp,. */
5025 for (i
= 0; i
< n_preprocessor_options
; i
++)
5027 do_spec_1 (preprocessor_options
[i
], 1, NULL
);
5028 /* Make each accumulated option a separate argument. */
5029 do_spec_1 (" ", 0, NULL
);
5033 /* Here are digits and numbers that just process
5034 a certain constant string as a spec. */
5037 value
= do_spec_1 (cc1_spec
, 0, NULL
);
5043 value
= do_spec_1 (cc1plus_spec
, 0, NULL
);
5049 value
= do_spec_1 (asm_spec
, 0, NULL
);
5055 value
= do_spec_1 (asm_final_spec
, 0, NULL
);
5062 const char *const spec
5063 = (input_file_compiler
->cpp_spec
5064 ? input_file_compiler
->cpp_spec
5066 value
= do_spec_1 (spec
, 0, NULL
);
5073 value
= do_spec_1 (endfile_spec
, 0, NULL
);
5079 value
= do_spec_1 (link_spec
, 0, NULL
);
5085 value
= do_spec_1 (lib_spec
, 0, NULL
);
5091 value
= do_spec_1 (libgcc_spec
, 0, NULL
);
5097 /* We assume there is a directory
5098 separator at the end of this string. */
5099 if (target_system_root
)
5101 obstack_grow (&obstack
, target_system_root
,
5102 strlen (target_system_root
));
5103 if (target_sysroot_suffix
)
5104 obstack_grow (&obstack
, target_sysroot_suffix
,
5105 strlen (target_sysroot_suffix
));
5110 value
= do_spec_1 (startfile_spec
, 0, NULL
);
5115 /* Here we define characters other than letters and digits. */
5118 p
= handle_braces (p
);
5124 p
= handle_spec_function (p
);
5130 obstack_1grow (&obstack
, '%');
5137 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '%')
5139 suffix_subst
= save_string (p
- 1, len
+ 1);
5144 /* Henceforth ignore the option(s) matching the pattern
5149 int have_wildcard
= 0;
5152 while (p
[len
] && p
[len
] != ' ' && p
[len
] != '\t')
5155 if (p
[len
-1] == '*')
5158 for (i
= 0; i
< n_switches
; i
++)
5159 if (!strncmp (switches
[i
].part1
, p
, len
- have_wildcard
)
5160 && (have_wildcard
|| switches
[i
].part1
[len
] == '\0'))
5162 switches
[i
].live_cond
= SWITCH_IGNORE
;
5163 switches
[i
].validated
= 1;
5171 if (soft_matched_part
)
5173 do_spec_1 (soft_matched_part
, 1, NULL
);
5174 do_spec_1 (" ", 0, NULL
);
5177 /* Catch the case where a spec string contains something like
5178 '%{foo:%*}'. i.e. there is no * in the pattern on the left
5179 hand side of the :. */
5180 error ("spec failure: '%%*' has not been initialized by pattern match");
5183 /* Process a string found as the value of a spec given by name.
5184 This feature allows individual machine descriptions
5185 to add and use their own specs.
5186 %[...] modifies -D options the way %P does;
5187 %(...) uses the spec unmodified. */
5189 error ("warning: use of obsolete %%[ operator in specs");
5192 const char *name
= p
;
5193 struct spec_list
*sl
;
5196 /* The string after the S/P is the name of a spec that is to be
5198 while (*p
&& *p
!= ')' && *p
!= ']')
5201 /* See if it's in the list. */
5202 for (len
= p
- name
, sl
= specs
; sl
; sl
= sl
->next
)
5203 if (sl
->name_len
== len
&& !strncmp (sl
->name
, name
, len
))
5205 name
= *(sl
->ptr_spec
);
5207 notice ("Processing spec %c%s%c, which is '%s'\n",
5208 c
, sl
->name
, (c
== '(') ? ')' : ']', name
);
5217 value
= do_spec_1 (name
, 0, NULL
);
5223 char *x
= alloca (strlen (name
) * 2 + 1);
5225 const char *y
= name
;
5228 /* Copy all of NAME into BUF, but put __ after
5229 every -D and at the end of each arg. */
5232 if (! strncmp (y
, "-D", 2))
5243 && (*y
== ' ' || *y
== '\t' || *y
== '='
5244 || *y
== '}' || *y
== 0))
5257 value
= do_spec_1 (buf
, 0, NULL
);
5263 /* Discard the closing paren or bracket. */
5270 error ("spec failure: unrecognized spec option '%c'", c
);
5276 /* Backslash: treat next character as ordinary. */
5281 /* Ordinary character: put it into the current argument. */
5282 obstack_1grow (&obstack
, c
);
5286 /* End of string. If we are processing a spec function, we need to
5287 end any pending argument. */
5288 if (processing_spec_function
&& arg_going
)
5290 obstack_1grow (&obstack
, 0);
5291 string
= XOBFINISH (&obstack
, const char *);
5292 if (this_is_library_file
)
5293 string
= find_file (string
);
5294 store_arg (string
, delete_this_arg
, this_is_output_file
);
5295 if (this_is_output_file
)
5296 outfiles
[input_file_number
] = string
;
5303 /* Look up a spec function. */
5305 static const struct spec_function
*
5306 lookup_spec_function (const char *name
)
5308 static const struct spec_function
* const spec_function_tables
[] =
5310 static_spec_functions
,
5311 lang_specific_spec_functions
,
5313 const struct spec_function
*sf
;
5316 for (i
= 0; i
< ARRAY_SIZE (spec_function_tables
); i
++)
5318 for (sf
= spec_function_tables
[i
]; sf
->name
!= NULL
; sf
++)
5319 if (strcmp (sf
->name
, name
) == 0)
5326 /* Evaluate a spec function. */
5329 eval_spec_function (const char *func
, const char *args
)
5331 const struct spec_function
*sf
;
5332 const char *funcval
;
5334 /* Saved spec processing context. */
5335 int save_argbuf_index
;
5336 int save_argbuf_length
;
5337 const char **save_argbuf
;
5340 int save_delete_this_arg
;
5341 int save_this_is_output_file
;
5342 int save_this_is_library_file
;
5343 int save_input_from_pipe
;
5344 const char *save_suffix_subst
;
5347 sf
= lookup_spec_function (func
);
5349 fatal ("unknown spec function '%s'", func
);
5351 /* Push the spec processing context. */
5352 save_argbuf_index
= argbuf_index
;
5353 save_argbuf_length
= argbuf_length
;
5354 save_argbuf
= argbuf
;
5356 save_arg_going
= arg_going
;
5357 save_delete_this_arg
= delete_this_arg
;
5358 save_this_is_output_file
= this_is_output_file
;
5359 save_this_is_library_file
= this_is_library_file
;
5360 save_input_from_pipe
= input_from_pipe
;
5361 save_suffix_subst
= suffix_subst
;
5363 /* Create a new spec processing context, and build the function
5367 if (do_spec_2 (args
) < 0)
5368 fatal ("error in args to spec function '%s'", func
);
5370 /* argbuf_index is an index for the next argument to be inserted, and
5371 so contains the count of the args already inserted. */
5373 funcval
= (*sf
->func
) (argbuf_index
, argbuf
);
5375 /* Pop the spec processing context. */
5376 argbuf_index
= save_argbuf_index
;
5377 argbuf_length
= save_argbuf_length
;
5379 argbuf
= save_argbuf
;
5381 arg_going
= save_arg_going
;
5382 delete_this_arg
= save_delete_this_arg
;
5383 this_is_output_file
= save_this_is_output_file
;
5384 this_is_library_file
= save_this_is_library_file
;
5385 input_from_pipe
= save_input_from_pipe
;
5386 suffix_subst
= save_suffix_subst
;
5391 /* Handle a spec function call of the form:
5395 ARGS is processed as a spec in a separate context and split into an
5396 argument vector in the normal fashion. The function returns a string
5397 containing a spec which we then process in the caller's context, or
5398 NULL if no processing is required. */
5401 handle_spec_function (const char *p
)
5404 const char *endp
, *funcval
;
5407 processing_spec_function
++;
5409 /* Get the function name. */
5410 for (endp
= p
; *endp
!= '\0'; endp
++)
5412 if (*endp
== '(') /* ) */
5414 /* Only allow [A-Za-z0-9], -, and _ in function names. */
5415 if (!ISALNUM (*endp
) && !(*endp
== '-' || *endp
== '_'))
5416 fatal ("malformed spec function name");
5418 if (*endp
!= '(') /* ) */
5419 fatal ("no arguments for spec function");
5420 func
= save_string (p
, endp
- p
);
5423 /* Get the arguments. */
5424 for (count
= 0; *endp
!= '\0'; endp
++)
5433 else if (*endp
== '(') /* ) */
5438 fatal ("malformed spec function arguments");
5439 args
= save_string (p
, endp
- p
);
5442 /* p now points to just past the end of the spec function expression. */
5444 funcval
= eval_spec_function (func
, args
);
5445 if (funcval
!= NULL
&& do_spec_1 (funcval
, 0, NULL
) < 0)
5451 processing_spec_function
--;
5456 /* Inline subroutine of handle_braces. Returns true if the current
5457 input suffix matches the atom bracketed by ATOM and END_ATOM. */
5459 input_suffix_matches (const char *atom
, const char *end_atom
)
5461 /* We special case the semantics of {.s:...} and {.S:...} and their
5462 negative variants. Instead of testing the input filename suffix,
5463 we test whether the input source file is an assembler file or an
5464 assembler-with-cpp file respectively. This allows us to correctly
5465 handle the -x command line option. */
5467 if (atom
+ 1 == end_atom
5468 && input_file_compiler
5469 && input_file_compiler
->suffix
)
5472 return !strcmp (input_file_compiler
->suffix
, "@assembler");
5474 return !strcmp (input_file_compiler
->suffix
, "@assembler-with-cpp");
5477 return (input_suffix
5478 && !strncmp (input_suffix
, atom
, end_atom
- atom
)
5479 && input_suffix
[end_atom
- atom
] == '\0');
5482 /* Inline subroutine of handle_braces. Returns true if a switch
5483 matching the atom bracketed by ATOM and END_ATOM appeared on the
5486 switch_matches (const char *atom
, const char *end_atom
, int starred
)
5489 int len
= end_atom
- atom
;
5490 int plen
= starred
? len
: -1;
5492 for (i
= 0; i
< n_switches
; i
++)
5493 if (!strncmp (switches
[i
].part1
, atom
, len
)
5494 && (starred
|| switches
[i
].part1
[len
] == '\0')
5495 && check_live_switch (i
, plen
))
5501 /* Inline subroutine of handle_braces. Mark all of the switches which
5502 match ATOM (extends to END_ATOM; STARRED indicates whether there
5503 was a star after the atom) for later processing. */
5505 mark_matching_switches (const char *atom
, const char *end_atom
, int starred
)
5508 int len
= end_atom
- atom
;
5509 int plen
= starred
? len
: -1;
5511 for (i
= 0; i
< n_switches
; i
++)
5512 if (!strncmp (switches
[i
].part1
, atom
, len
)
5513 && (starred
|| switches
[i
].part1
[len
] == '\0')
5514 && check_live_switch (i
, plen
))
5515 switches
[i
].ordering
= 1;
5518 /* Inline subroutine of handle_braces. Process all the currently
5519 marked switches through give_switch, and clear the marks. */
5521 process_marked_switches (void)
5525 for (i
= 0; i
< n_switches
; i
++)
5526 if (switches
[i
].ordering
== 1)
5528 switches
[i
].ordering
= 0;
5533 /* Handle a %{ ... } construct. P points just inside the leading {.
5534 Returns a pointer one past the end of the brace block, or 0
5535 if we call do_spec_1 and that returns -1. */
5538 handle_braces (const char *p
)
5540 const char *atom
, *end_atom
;
5541 const char *d_atom
= NULL
, *d_end_atom
= NULL
;
5542 const char *orig
= p
;
5549 bool a_must_be_last
= false;
5550 bool ordered_set
= false;
5551 bool disjunct_set
= false;
5552 bool disj_matched
= false;
5553 bool disj_starred
= true;
5554 bool n_way_choice
= false;
5555 bool n_way_matched
= false;
5557 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
5564 /* Scan one "atom" (S in the description above of %{}, possibly
5565 with !, ., or * modifiers). */
5566 a_matched
= a_is_suffix
= a_is_starred
= a_is_negated
= false;
5570 p
++, a_is_negated
= true;
5574 p
++, a_is_suffix
= true;
5577 while (ISIDNUM(*p
) || *p
== '-' || *p
== '+' || *p
== '='
5578 || *p
== ',' || *p
== '.' || *p
== '@')
5583 p
++, a_is_starred
= 1;
5589 /* Substitute the switch(es) indicated by the current atom. */
5591 if (disjunct_set
|| n_way_choice
|| a_is_negated
|| a_is_suffix
5592 || atom
== end_atom
)
5595 mark_matching_switches (atom
, end_atom
, a_is_starred
);
5598 process_marked_switches ();
5602 /* Substitute some text if the current atom appears as a switch
5604 disjunct_set
= true;
5608 if (atom
== end_atom
)
5610 if (!n_way_choice
|| disj_matched
|| *p
== '|'
5611 || a_is_negated
|| a_is_suffix
|| a_is_starred
)
5614 /* An empty term may appear as the last choice of an
5615 N-way choice set; it means "otherwise". */
5616 a_must_be_last
= true;
5617 disj_matched
= !n_way_matched
;
5618 disj_starred
= false;
5622 if (a_is_suffix
&& a_is_starred
)
5626 disj_starred
= false;
5628 /* Don't bother testing this atom if we already have a
5630 if (!disj_matched
&& !n_way_matched
)
5633 a_matched
= input_suffix_matches (atom
, end_atom
);
5635 a_matched
= switch_matches (atom
, end_atom
, a_is_starred
);
5637 if (a_matched
!= a_is_negated
)
5639 disj_matched
= true;
5641 d_end_atom
= end_atom
;
5648 /* Found the body, that is, the text to substitute if the
5649 current disjunction matches. */
5650 p
= process_brace_body (p
+ 1, d_atom
, d_end_atom
, disj_starred
,
5651 disj_matched
&& !n_way_matched
);
5655 /* If we have an N-way choice, reset state for the next
5659 n_way_choice
= true;
5660 n_way_matched
|= disj_matched
;
5661 disj_matched
= false;
5662 disj_starred
= true;
5663 d_atom
= d_end_atom
= NULL
;
5672 while (*p
++ != '}');
5677 fatal ("braced spec '%s' is invalid at '%c'", orig
, *p
);
5682 /* Subroutine of handle_braces. Scan and process a brace substitution body
5683 (X in the description of %{} syntax). P points one past the colon;
5684 ATOM and END_ATOM bracket the first atom which was found to be true
5685 (present) in the current disjunction; STARRED indicates whether all
5686 the atoms in the current disjunction were starred (for syntax validation);
5687 MATCHED indicates whether the disjunction matched or not, and therefore
5688 whether or not the body is to be processed through do_spec_1 or just
5689 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
5693 process_brace_body (const char *p
, const char *atom
, const char *end_atom
,
5694 int starred
, int matched
)
5696 const char *body
, *end_body
;
5697 unsigned int nesting_level
;
5698 bool have_subst
= false;
5700 /* Locate the closing } or ;, honoring nested braces.
5701 Trim trailing whitespace. */
5710 if (!--nesting_level
)
5713 else if (*p
== ';' && nesting_level
== 1)
5715 else if (*p
== '%' && p
[1] == '*' && nesting_level
== 1)
5717 else if (*p
== '\0')
5723 while (end_body
[-1] == ' ' || end_body
[-1] == '\t')
5726 if (have_subst
&& !starred
)
5731 /* Copy the substitution body to permanent storage and execute it.
5732 If have_subst is false, this is a simple matter of running the
5733 body through do_spec_1... */
5734 char *string
= save_string (body
, end_body
- body
);
5737 if (do_spec_1 (string
, 0, NULL
) < 0)
5742 /* ... but if have_subst is true, we have to process the
5743 body once for each matching switch, with %* set to the
5744 variant part of the switch. */
5745 unsigned int hard_match_len
= end_atom
- atom
;
5748 for (i
= 0; i
< n_switches
; i
++)
5749 if (!strncmp (switches
[i
].part1
, atom
, hard_match_len
)
5750 && check_live_switch (i
, hard_match_len
))
5752 if (do_spec_1 (string
, 0,
5753 &switches
[i
].part1
[hard_match_len
]) < 0)
5755 /* Pass any arguments this switch has. */
5757 suffix_subst
= NULL
;
5765 fatal ("braced spec body '%s' is invalid", body
);
5768 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
5769 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
5770 spec, or -1 if either exact match or %* is used.
5772 A -O switch is obsoleted by a later -O switch. A -f, -m, or -W switch
5773 whose value does not begin with "no-" is obsoleted by the same value
5774 with the "no-", similarly for a switch with the "no-" prefix. */
5777 check_live_switch (int switchnum
, int prefix_length
)
5779 const char *name
= switches
[switchnum
].part1
;
5782 /* In the common case of {<at-most-one-letter>*}, a negating
5783 switch would always match, so ignore that case. We will just
5784 send the conflicting switches to the compiler phase. */
5785 if (prefix_length
>= 0 && prefix_length
<= 1)
5788 /* If we already processed this switch and determined if it was
5789 live or not, return our past determination. */
5790 if (switches
[switchnum
].live_cond
!= 0)
5791 return switches
[switchnum
].live_cond
> 0;
5793 /* Now search for duplicate in a manner that depends on the name. */
5797 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
5798 if (switches
[i
].part1
[0] == 'O')
5800 switches
[switchnum
].validated
= 1;
5801 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
5806 case 'W': case 'f': case 'm':
5807 if (! strncmp (name
+ 1, "no-", 3))
5809 /* We have Xno-YYY, search for XYYY. */
5810 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
5811 if (switches
[i
].part1
[0] == name
[0]
5812 && ! strcmp (&switches
[i
].part1
[1], &name
[4]))
5814 switches
[switchnum
].validated
= 1;
5815 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
5821 /* We have XYYY, search for Xno-YYY. */
5822 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
5823 if (switches
[i
].part1
[0] == name
[0]
5824 && switches
[i
].part1
[1] == 'n'
5825 && switches
[i
].part1
[2] == 'o'
5826 && switches
[i
].part1
[3] == '-'
5827 && !strcmp (&switches
[i
].part1
[4], &name
[1]))
5829 switches
[switchnum
].validated
= 1;
5830 switches
[switchnum
].live_cond
= SWITCH_FALSE
;
5837 /* Otherwise the switch is live. */
5838 switches
[switchnum
].live_cond
= SWITCH_LIVE
;
5842 /* Pass a switch to the current accumulating command
5843 in the same form that we received it.
5844 SWITCHNUM identifies the switch; it is an index into
5845 the vector of switches gcc received, which is `switches'.
5846 This cannot fail since it never finishes a command line.
5848 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
5851 give_switch (int switchnum
, int omit_first_word
)
5853 if (switches
[switchnum
].live_cond
== SWITCH_IGNORE
)
5856 if (!omit_first_word
)
5858 do_spec_1 ("-", 0, NULL
);
5859 do_spec_1 (switches
[switchnum
].part1
, 1, NULL
);
5862 if (switches
[switchnum
].args
!= 0)
5865 for (p
= switches
[switchnum
].args
; *p
; p
++)
5867 const char *arg
= *p
;
5869 do_spec_1 (" ", 0, NULL
);
5872 unsigned length
= strlen (arg
);
5875 while (length
-- && !IS_DIR_SEPARATOR (arg
[length
]))
5876 if (arg
[length
] == '.')
5878 ((char *)arg
)[length
] = 0;
5882 do_spec_1 (arg
, 1, NULL
);
5884 ((char *)arg
)[length
] = '.';
5885 do_spec_1 (suffix_subst
, 1, NULL
);
5888 do_spec_1 (arg
, 1, NULL
);
5892 do_spec_1 (" ", 0, NULL
);
5893 switches
[switchnum
].validated
= 1;
5896 /* Search for a file named NAME trying various prefixes including the
5897 user's -B prefix and some standard ones.
5898 Return the absolute file name found. If nothing is found, return NAME. */
5901 find_file (const char *name
)
5905 /* Try multilib_dir if it is defined. */
5906 if (multilib_os_dir
!= NULL
)
5908 newname
= find_a_file (&startfile_prefixes
, name
, R_OK
, 1);
5910 /* If we don't find it in the multi library dir, then fall
5911 through and look for it in the normal places. */
5912 if (newname
!= NULL
)
5916 newname
= find_a_file (&startfile_prefixes
, name
, R_OK
, 0);
5917 return newname
? newname
: name
;
5920 /* Determine whether a directory exists. If LINKER, return 0 for
5921 certain fixed names not needed by the linker. If not LINKER, it is
5922 only important to return 0 if the host machine has a small ARG_MAX
5926 is_directory (const char *path1
, const char *path2
, int linker
)
5928 int len1
= strlen (path1
);
5929 int len2
= strlen (path2
);
5930 char *path
= alloca (3 + len1
+ len2
);
5934 #ifndef SMALL_ARG_MAX
5939 /* Construct the path from the two parts. Ensure the string ends with "/.".
5940 The resulting path will be a directory even if the given path is a
5942 memcpy (path
, path1
, len1
);
5943 memcpy (path
+ len1
, path2
, len2
);
5944 cp
= path
+ len1
+ len2
;
5945 if (!IS_DIR_SEPARATOR (cp
[-1]))
5946 *cp
++ = DIR_SEPARATOR
;
5950 /* Exclude directories that the linker is known to search. */
5953 && strcmp (path
, concat (dir_separator_str
, "lib",
5954 dir_separator_str
, ".", NULL
)) == 0)
5956 && strcmp (path
, concat (dir_separator_str
, "usr",
5957 dir_separator_str
, "lib",
5958 dir_separator_str
, ".", NULL
)) == 0)))
5961 return (stat (path
, &st
) >= 0 && S_ISDIR (st
.st_mode
));
5964 /* Set up the various global variables to indicate that we're processing
5965 the input file named FILENAME. */
5968 set_input (const char *filename
)
5972 input_filename
= filename
;
5973 input_filename_length
= strlen (input_filename
);
5975 input_basename
= input_filename
;
5976 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
5977 /* Skip drive name so 'x:foo' is handled properly. */
5978 if (input_basename
[1] == ':')
5979 input_basename
+= 2;
5981 for (p
= input_basename
; *p
; p
++)
5982 if (IS_DIR_SEPARATOR (*p
))
5983 input_basename
= p
+ 1;
5985 /* Find a suffix starting with the last period,
5986 and set basename_length to exclude that suffix. */
5987 basename_length
= strlen (input_basename
);
5988 suffixed_basename_length
= basename_length
;
5989 p
= input_basename
+ basename_length
;
5990 while (p
!= input_basename
&& *p
!= '.')
5992 if (*p
== '.' && p
!= input_basename
)
5994 basename_length
= p
- input_basename
;
5995 input_suffix
= p
+ 1;
6000 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
6001 we will need to do a stat on the input_filename. The
6002 INPUT_STAT_SET signals that the stat is needed. */
6006 /* On fatal signals, delete all the temporary files. */
6009 fatal_error (int signum
)
6011 signal (signum
, SIG_DFL
);
6012 delete_failure_queue ();
6013 delete_temp_files ();
6014 /* Get the same signal again, this time not handled,
6015 so its normal effect occurs. */
6016 kill (getpid (), signum
);
6019 extern int main (int, char **);
6022 main (int argc
, char **argv
)
6026 int linker_was_run
= 0;
6027 int lang_n_infiles
= 0;
6028 int num_linker_inputs
= 0;
6029 char *explicit_link_files
;
6032 struct user_specs
*uptr
;
6034 p
= argv
[0] + strlen (argv
[0]);
6035 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
6039 xmalloc_set_program_name (programname
);
6041 expandargv (&argc
, &argv
);
6043 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6044 /* Perform host dependent initialization when needed. */
6045 GCC_DRIVER_HOST_INITIALIZATION
;
6048 /* Unlock the stdio streams. */
6049 unlock_std_streams ();
6051 gcc_init_libintl ();
6053 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
6054 signal (SIGINT
, fatal_error
);
6056 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
6057 signal (SIGHUP
, fatal_error
);
6059 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
6060 signal (SIGTERM
, fatal_error
);
6062 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
6063 signal (SIGPIPE
, fatal_error
);
6066 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6067 receive the signal. A different setting is inheritable */
6068 signal (SIGCHLD
, SIG_DFL
);
6071 /* Allocate the argument vector. */
6074 obstack_init (&obstack
);
6076 /* Build multilib_select, et. al from the separate lines that make up each
6077 multilib selection. */
6079 const char *const *q
= multilib_raw
;
6082 obstack_init (&multilib_obstack
);
6083 while ((p
= *q
++) != (char *) 0)
6084 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6086 obstack_1grow (&multilib_obstack
, 0);
6087 multilib_select
= XOBFINISH (&multilib_obstack
, const char *);
6089 q
= multilib_matches_raw
;
6090 while ((p
= *q
++) != (char *) 0)
6091 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6093 obstack_1grow (&multilib_obstack
, 0);
6094 multilib_matches
= XOBFINISH (&multilib_obstack
, const char *);
6096 q
= multilib_exclusions_raw
;
6097 while ((p
= *q
++) != (char *) 0)
6098 obstack_grow (&multilib_obstack
, p
, strlen (p
));
6100 obstack_1grow (&multilib_obstack
, 0);
6101 multilib_exclusions
= XOBFINISH (&multilib_obstack
, const char *);
6104 for (i
= 0; i
< ARRAY_SIZE (multilib_defaults_raw
); i
++)
6107 obstack_1grow (&multilib_obstack
, ' ');
6108 obstack_grow (&multilib_obstack
,
6109 multilib_defaults_raw
[i
],
6110 strlen (multilib_defaults_raw
[i
]));
6114 obstack_1grow (&multilib_obstack
, 0);
6115 multilib_defaults
= XOBFINISH (&multilib_obstack
, const char *);
6118 /* Set up to remember the pathname of gcc and any options
6119 needed for collect. We use argv[0] instead of programname because
6120 we need the complete pathname. */
6121 obstack_init (&collect_obstack
);
6122 obstack_grow (&collect_obstack
, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
6123 obstack_grow (&collect_obstack
, argv
[0], strlen (argv
[0]) + 1);
6124 putenv (XOBFINISH (&collect_obstack
, char *));
6126 #ifdef INIT_ENVIRONMENT
6127 /* Set up any other necessary machine specific environment variables. */
6128 putenv (INIT_ENVIRONMENT
);
6131 /* Make a table of what switches there are (switches, n_switches).
6132 Make a table of specified input files (infiles, n_infiles).
6133 Decode switches that are handled locally. */
6135 process_command (argc
, (const char **) argv
);
6137 /* Initialize the vector of specs to just the default.
6138 This means one element containing 0s, as a terminator. */
6140 compilers
= xmalloc (sizeof default_compilers
);
6141 memcpy (compilers
, default_compilers
, sizeof default_compilers
);
6142 n_compilers
= n_default_compilers
;
6144 /* Read specs from a file if there is one. */
6146 machine_suffix
= concat (spec_machine
, dir_separator_str
,
6147 spec_version
, dir_separator_str
, NULL
);
6148 just_machine_suffix
= concat (spec_machine
, dir_separator_str
, NULL
);
6150 specs_file
= find_a_file (&startfile_prefixes
, "specs", R_OK
, 0);
6151 /* Read the specs file unless it is a default one. */
6152 if (specs_file
!= 0 && strcmp (specs_file
, "specs"))
6153 read_specs (specs_file
, TRUE
);
6157 /* We need to check standard_exec_prefix/just_machine_suffix/specs
6158 for any override of as, ld and libraries. */
6159 specs_file
= alloca (strlen (standard_exec_prefix
)
6160 + strlen (just_machine_suffix
) + sizeof ("specs"));
6162 strcpy (specs_file
, standard_exec_prefix
);
6163 strcat (specs_file
, just_machine_suffix
);
6164 strcat (specs_file
, "specs");
6165 if (access (specs_file
, R_OK
) == 0)
6166 read_specs (specs_file
, TRUE
);
6168 /* Process any configure-time defaults specified for the command line
6169 options, via OPTION_DEFAULT_SPECS. */
6170 for (i
= 0; i
< ARRAY_SIZE (option_default_specs
); i
++)
6171 do_option_spec (option_default_specs
[i
].name
,
6172 option_default_specs
[i
].spec
);
6174 /* Process DRIVER_SELF_SPECS, adding any new options to the end
6175 of the command line. */
6177 for (i
= 0; i
< ARRAY_SIZE (driver_self_specs
); i
++)
6178 do_self_spec (driver_self_specs
[i
]);
6180 /* If not cross-compiling, look for executables in the standard
6182 if (*cross_compile
== '0')
6184 if (*md_exec_prefix
)
6186 add_prefix (&exec_prefixes
, md_exec_prefix
, "GCC",
6187 PREFIX_PRIORITY_LAST
, 0, 0);
6191 /* Process sysroot_suffix_spec. */
6192 if (*sysroot_suffix_spec
!= 0
6193 && do_spec_2 (sysroot_suffix_spec
) == 0)
6195 if (argbuf_index
> 1)
6196 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
6197 else if (argbuf_index
== 1)
6198 target_sysroot_suffix
= xstrdup (argbuf
[argbuf_index
-1]);
6201 #ifdef HAVE_LD_SYSROOT
6202 /* Pass the --sysroot option to the linker, if it supports that. If
6203 there is a sysroot_suffix_spec, it has already been processed by
6204 this point, so target_system_root really is the system root we
6206 if (target_system_root
)
6208 obstack_grow (&obstack
, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
6209 obstack_grow0 (&obstack
, link_spec
, strlen (link_spec
));
6210 set_spec ("link", XOBFINISH (&obstack
, const char *));
6214 /* Process sysroot_hdrs_suffix_spec. */
6215 if (*sysroot_hdrs_suffix_spec
!= 0
6216 && do_spec_2 (sysroot_hdrs_suffix_spec
) == 0)
6218 if (argbuf_index
> 1)
6219 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
6220 else if (argbuf_index
== 1)
6221 target_sysroot_hdrs_suffix
= xstrdup (argbuf
[argbuf_index
-1]);
6224 /* Look for startfiles in the standard places. */
6225 if (*startfile_prefix_spec
!= 0
6226 && do_spec_2 (startfile_prefix_spec
) == 0
6227 && do_spec_1 (" ", 0, NULL
) == 0)
6230 for (ndx
= 0; ndx
< argbuf_index
; ndx
++)
6231 add_sysrooted_prefix (&startfile_prefixes
, argbuf
[ndx
], "BINUTILS",
6232 PREFIX_PRIORITY_LAST
, 0, 1);
6234 /* We should eventually get rid of all these and stick to
6235 startfile_prefix_spec exclusively. */
6236 else if (*cross_compile
== '0' || target_system_root
)
6238 if (*md_startfile_prefix
)
6239 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix
,
6240 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
6242 if (*md_startfile_prefix_1
)
6243 add_sysrooted_prefix (&startfile_prefixes
, md_startfile_prefix_1
,
6244 "GCC", PREFIX_PRIORITY_LAST
, 0, 1);
6246 /* If standard_startfile_prefix is relative, base it on
6247 standard_exec_prefix. This lets us move the installed tree
6248 as a unit. If GCC_EXEC_PREFIX is defined, base
6249 standard_startfile_prefix on that as well.
6251 If the prefix is relative, only search it for native compilers;
6252 otherwise we will search a directory containing host libraries. */
6253 if (IS_ABSOLUTE_PATH (standard_startfile_prefix
))
6254 add_sysrooted_prefix (&startfile_prefixes
,
6255 standard_startfile_prefix
, "BINUTILS",
6256 PREFIX_PRIORITY_LAST
, 0, 1);
6257 else if (*cross_compile
== '0')
6259 if (gcc_exec_prefix
)
6260 add_prefix (&startfile_prefixes
,
6261 concat (gcc_exec_prefix
, machine_suffix
,
6262 standard_startfile_prefix
, NULL
),
6263 NULL
, PREFIX_PRIORITY_LAST
, 0, 1);
6264 add_prefix (&startfile_prefixes
,
6265 concat (standard_exec_prefix
,
6267 standard_startfile_prefix
, NULL
),
6268 NULL
, PREFIX_PRIORITY_LAST
, 0, 1);
6271 if (*standard_startfile_prefix_1
)
6272 add_sysrooted_prefix (&startfile_prefixes
,
6273 standard_startfile_prefix_1
, "BINUTILS",
6274 PREFIX_PRIORITY_LAST
, 0, 1);
6275 if (*standard_startfile_prefix_2
)
6276 add_sysrooted_prefix (&startfile_prefixes
,
6277 standard_startfile_prefix_2
, "BINUTILS",
6278 PREFIX_PRIORITY_LAST
, 0, 1);
6281 /* Process any user specified specs in the order given on the command
6283 for (uptr
= user_specs_head
; uptr
; uptr
= uptr
->next
)
6285 char *filename
= find_a_file (&startfile_prefixes
, uptr
->filename
,
6287 read_specs (filename
? filename
: uptr
->filename
, FALSE
);
6290 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
6291 if (gcc_exec_prefix
)
6292 gcc_exec_prefix
= concat (gcc_exec_prefix
, spec_machine
, dir_separator_str
,
6293 spec_version
, dir_separator_str
, NULL
);
6295 /* Now we have the specs.
6296 Set the `valid' bits for switches that match anything in any spec. */
6298 validate_all_switches ();
6300 /* Now that we have the switches and the specs, set
6301 the subdirectory based on the options. */
6302 set_multilib_dir ();
6304 /* Warn about any switches that no pass was interested in. */
6306 for (i
= 0; (int) i
< n_switches
; i
++)
6307 if (! switches
[i
].validated
)
6308 error ("unrecognized option '-%s'", switches
[i
].part1
);
6310 /* Obey some of the options. */
6312 if (print_search_dirs
)
6314 printf (_("install: %s%s\n"), standard_exec_prefix
, machine_suffix
);
6315 printf (_("programs: %s\n"), build_search_list (&exec_prefixes
, "", 0));
6316 printf (_("libraries: %s\n"), build_search_list (&startfile_prefixes
, "", 0));
6320 if (print_file_name
)
6322 printf ("%s\n", find_file (print_file_name
));
6326 if (print_prog_name
)
6328 char *newname
= find_a_file (&exec_prefixes
, print_prog_name
, X_OK
, 0);
6329 printf ("%s\n", (newname
? newname
: print_prog_name
));
6333 if (print_multi_lib
)
6335 print_multilib_info ();
6339 if (print_multi_directory
)
6341 if (multilib_dir
== NULL
)
6344 printf ("%s\n", multilib_dir
);
6348 if (print_multi_os_directory
)
6350 if (multilib_os_dir
== NULL
)
6353 printf ("%s\n", multilib_os_dir
);
6357 if (target_help_flag
)
6359 /* Print if any target specific options. */
6361 /* We do not exit here. Instead we have created a fake input file
6362 called 'target-dummy' which needs to be compiled, and we pass this
6363 on to the various sub-processes, along with the --target-help
6367 if (print_help_list
)
6373 printf (_("\nFor bug reporting instructions, please see:\n"));
6374 printf ("%s.\n", bug_report_url
);
6379 /* We do not exit here. Instead we have created a fake input file
6380 called 'help-dummy' which needs to be compiled, and we pass this
6381 on the various sub-processes, along with the --help switch. */
6389 notice ("Target: %s\n", spec_machine
);
6390 notice ("Configured with: %s\n", configuration_arguments
);
6392 #ifdef THREAD_MODEL_SPEC
6393 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
6394 but there's no point in doing all this processing just to get
6395 thread_model back. */
6396 obstack_init (&obstack
);
6397 do_spec_1 (THREAD_MODEL_SPEC
, 0, thread_model
);
6398 obstack_1grow (&obstack
, '\0');
6399 thrmod
= XOBFINISH (&obstack
, const char *);
6401 thrmod
= thread_model
;
6404 notice ("Thread model: %s\n", thrmod
);
6406 /* compiler_version is truncated at the first space when initialized
6407 from version string, so truncate version_string at the first space
6408 before comparing. */
6409 for (n
= 0; version_string
[n
]; n
++)
6410 if (version_string
[n
] == ' ')
6413 if (! strncmp (version_string
, compiler_version
, n
)
6414 && compiler_version
[n
] == 0)
6415 notice ("gcc version %s\n", version_string
);
6417 notice ("gcc driver version %s executing gcc version %s\n",
6418 version_string
, compiler_version
);
6424 if (n_infiles
== added_libraries
)
6425 fatal ("no input files");
6427 /* Make a place to record the compiler output file names
6428 that correspond to the input files. */
6431 i
+= lang_specific_extra_outfiles
;
6432 outfiles
= xcalloc (i
, sizeof (char *));
6434 /* Record which files were specified explicitly as link input. */
6436 explicit_link_files
= xcalloc (1, n_infiles
);
6439 combine_inputs
= true;
6441 combine_inputs
= false;
6443 for (i
= 0; (int) i
< n_infiles
; i
++)
6445 const char *name
= infiles
[i
].name
;
6446 struct compiler
*compiler
= lookup_compiler (name
,
6448 infiles
[i
].language
);
6450 if (compiler
&& !(compiler
->combinable
))
6451 combine_inputs
= false;
6453 if (lang_n_infiles
> 0 && compiler
!= input_file_compiler
6454 && infiles
[i
].language
&& infiles
[i
].language
[0] != '*')
6455 infiles
[i
].incompiler
= compiler
;
6459 input_file_compiler
= compiler
;
6460 infiles
[i
].incompiler
= compiler
;
6464 /* Since there is no compiler for this input file, assume it is a
6466 explicit_link_files
[i
] = 1;
6467 infiles
[i
].incompiler
= NULL
;
6469 infiles
[i
].compiled
= false;
6470 infiles
[i
].preprocessed
= false;
6473 if (!combine_inputs
&& have_c
&& have_o
&& lang_n_infiles
> 1)
6474 fatal ("cannot specify -o with -c or -S with multiple files");
6476 if (combine_flag
&& save_temps_flag
)
6478 bool save_combine_inputs
= combine_inputs
;
6479 /* Must do a separate pre-processing pass for C & Objective-C files, to
6480 obtain individual .i files. */
6482 combine_inputs
= false;
6483 for (i
= 0; (int) i
< n_infiles
; i
++)
6485 int this_file_error
= 0;
6487 input_file_number
= i
;
6488 set_input (infiles
[i
].name
);
6489 if (infiles
[i
].incompiler
6490 && (infiles
[i
].incompiler
)->needs_preprocessing
)
6491 input_file_compiler
= infiles
[i
].incompiler
;
6495 if (input_file_compiler
)
6497 if (input_file_compiler
->spec
[0] == '#')
6499 error ("%s: %s compiler not installed on this system",
6500 input_filename
, &input_file_compiler
->spec
[1]);
6501 this_file_error
= 1;
6505 value
= do_spec (input_file_compiler
->spec
);
6506 infiles
[i
].preprocessed
= true;
6507 if (!have_o_argbuf_index
)
6508 fatal ("spec '%s' is invalid", input_file_compiler
->spec
);
6509 infiles
[i
].name
= argbuf
[have_o_argbuf_index
];
6510 infiles
[i
].incompiler
6511 = lookup_compiler (infiles
[i
].name
,
6512 strlen (infiles
[i
].name
),
6513 infiles
[i
].language
);
6516 this_file_error
= 1;
6520 if (this_file_error
)
6522 delete_failure_queue ();
6526 clear_failure_queue ();
6528 combine_inputs
= save_combine_inputs
;
6531 for (i
= 0; (int) i
< n_infiles
; i
++)
6533 int this_file_error
= 0;
6535 /* Tell do_spec what to substitute for %i. */
6537 input_file_number
= i
;
6538 set_input (infiles
[i
].name
);
6540 if (infiles
[i
].compiled
)
6543 /* Use the same thing in %o, unless cp->spec says otherwise. */
6545 outfiles
[i
] = input_filename
;
6547 /* Figure out which compiler from the file's suffix. */
6549 if (! combine_inputs
)
6551 = lookup_compiler (infiles
[i
].name
, input_filename_length
,
6552 infiles
[i
].language
);
6554 input_file_compiler
= infiles
[i
].incompiler
;
6556 if (input_file_compiler
)
6558 /* Ok, we found an applicable compiler. Run its spec. */
6560 if (input_file_compiler
->spec
[0] == '#')
6562 error ("%s: %s compiler not installed on this system",
6563 input_filename
, &input_file_compiler
->spec
[1]);
6564 this_file_error
= 1;
6568 value
= do_spec (input_file_compiler
->spec
);
6569 infiles
[i
].compiled
= true;
6571 this_file_error
= 1;
6575 /* If this file's name does not contain a recognized suffix,
6576 record it as explicit linker input. */
6579 explicit_link_files
[i
] = 1;
6581 /* Clear the delete-on-failure queue, deleting the files in it
6582 if this compilation failed. */
6584 if (this_file_error
)
6586 delete_failure_queue ();
6589 /* If this compilation succeeded, don't delete those files later. */
6590 clear_failure_queue ();
6593 /* Reset the input file name to the first compile/object file name, for use
6594 with %b in LINK_SPEC. We use the first input file that we can find
6595 a compiler to compile it instead of using infiles.language since for
6596 languages other than C we use aliases that we then lookup later. */
6601 for (i
= 0; i
< n_infiles
; i
++)
6602 if (infiles
[i
].language
&& infiles
[i
].language
[0] != '*')
6604 set_input (infiles
[i
].name
);
6609 if (error_count
== 0)
6611 /* Make sure INPUT_FILE_NUMBER points to first available open
6613 input_file_number
= n_infiles
;
6614 if (lang_specific_pre_link ())
6618 /* Determine if there are any linker input files. */
6619 num_linker_inputs
= 0;
6620 for (i
= 0; (int) i
< n_infiles
; i
++)
6621 if (explicit_link_files
[i
] || outfiles
[i
] != NULL
)
6622 num_linker_inputs
++;
6624 /* Run ld to link all the compiler output files. */
6626 if (num_linker_inputs
> 0 && error_count
== 0)
6628 int tmp
= execution_count
;
6630 /* We'll use ld if we can't find collect2. */
6631 if (! strcmp (linker_name_spec
, "collect2"))
6633 char *s
= find_a_file (&exec_prefixes
, "collect2", X_OK
, 0);
6635 linker_name_spec
= "ld";
6637 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
6639 putenv_from_prefixes (&exec_prefixes
, "COMPILER_PATH");
6640 putenv_from_prefixes (&startfile_prefixes
, LIBRARY_PATH_ENV
);
6642 value
= do_spec (link_command_spec
);
6645 linker_was_run
= (tmp
!= execution_count
);
6648 /* If options said don't run linker,
6649 complain about input files to be given to the linker. */
6651 if (! linker_was_run
&& error_count
== 0)
6652 for (i
= 0; (int) i
< n_infiles
; i
++)
6653 if (explicit_link_files
[i
])
6654 error ("%s: linker input file unused because linking not done",
6657 /* Delete some or all of the temporary files we made. */
6660 delete_failure_queue ();
6661 delete_temp_files ();
6663 if (print_help_list
)
6665 printf (("\nFor bug reporting instructions, please see:\n"));
6666 printf ("%s\n", bug_report_url
);
6669 return (signal_count
!= 0 ? 2
6670 : error_count
> 0 ? (pass_exit_codes
? greatest_status
: 1)
6674 /* Find the proper compilation spec for the file name NAME,
6675 whose length is LENGTH. LANGUAGE is the specified language,
6676 or 0 if this file is to be passed to the linker. */
6678 static struct compiler
*
6679 lookup_compiler (const char *name
, size_t length
, const char *language
)
6681 struct compiler
*cp
;
6683 /* If this was specified by the user to be a linker input, indicate that. */
6684 if (language
!= 0 && language
[0] == '*')
6687 /* Otherwise, look for the language, if one is spec'd. */
6690 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
6691 if (cp
->suffix
[0] == '@' && !strcmp (cp
->suffix
+ 1, language
))
6694 error ("language %s not recognized", language
);
6698 /* Look for a suffix. */
6699 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
6701 if (/* The suffix `-' matches only the file name `-'. */
6702 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
6703 || (strlen (cp
->suffix
) < length
6704 /* See if the suffix matches the end of NAME. */
6705 && !strcmp (cp
->suffix
,
6706 name
+ length
- strlen (cp
->suffix
))
6711 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
6712 /* Look again, but case-insensitively this time. */
6714 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
6716 if (/* The suffix `-' matches only the file name `-'. */
6717 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
6718 || (strlen (cp
->suffix
) < length
6719 /* See if the suffix matches the end of NAME. */
6720 && ((!strcmp (cp
->suffix
,
6721 name
+ length
- strlen (cp
->suffix
))
6722 || !strpbrk (cp
->suffix
, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
6723 && !strcasecmp (cp
->suffix
,
6724 name
+ length
- strlen (cp
->suffix
)))
6730 if (cp
>= compilers
)
6732 if (cp
->spec
[0] != '@')
6733 /* A non-alias entry: return it. */
6736 /* An alias entry maps a suffix to a language.
6737 Search for the language; pass 0 for NAME and LENGTH
6738 to avoid infinite recursion if language not found. */
6739 return lookup_compiler (NULL
, 0, cp
->spec
+ 1);
6745 save_string (const char *s
, int len
)
6747 char *result
= xmalloc (len
+ 1);
6749 memcpy (result
, s
, len
);
6755 pfatal_with_name (const char *name
)
6757 perror_with_name (name
);
6758 delete_temp_files ();
6763 perror_with_name (const char *name
)
6765 error ("%s: %s", name
, xstrerror (errno
));
6768 /* Output an error message and exit. */
6771 fancy_abort (const char *file
, int line
, const char *func
)
6773 fatal ("internal gcc abort in %s, at %s:%d", func
, file
, line
);
6776 /* Output an error message and exit. */
6779 fatal (const char *cmsgid
, ...)
6783 va_start (ap
, cmsgid
);
6785 fprintf (stderr
, "%s: ", programname
);
6786 vfprintf (stderr
, _(cmsgid
), ap
);
6788 fprintf (stderr
, "\n");
6789 delete_temp_files ();
6793 /* The argument is actually c-format, not gcc-internal-format,
6794 but because functions with identical names are used through
6795 the rest of the compiler with gcc-internal-format, we just
6796 need to hope all users of these functions use the common
6797 subset between c-format and gcc-internal-format. */
6800 error (const char *gmsgid
, ...)
6804 va_start (ap
, gmsgid
);
6805 fprintf (stderr
, "%s: ", programname
);
6806 vfprintf (stderr
, _(gmsgid
), ap
);
6809 fprintf (stderr
, "\n");
6813 notice (const char *cmsgid
, ...)
6817 va_start (ap
, cmsgid
);
6818 vfprintf (stderr
, _(cmsgid
), ap
);
6823 validate_switches_from_spec (const char *spec
)
6825 const char *p
= spec
;
6828 if (c
== '%' && (*p
== '{' || *p
== '<' || (*p
== 'W' && *++p
== '{')))
6829 /* We have a switch spec. */
6830 p
= validate_switches (p
+ 1);
6834 validate_all_switches (void)
6836 struct compiler
*comp
;
6837 struct spec_list
*spec
;
6839 for (comp
= compilers
; comp
->spec
; comp
++)
6840 validate_switches_from_spec (comp
->spec
);
6842 /* Look through the linked list of specs read from the specs file. */
6843 for (spec
= specs
; spec
; spec
= spec
->next
)
6844 validate_switches_from_spec (*spec
->ptr_spec
);
6846 validate_switches_from_spec (link_command_spec
);
6849 /* Look at the switch-name that comes after START
6850 and mark as valid all supplied switches that match it. */
6853 validate_switches (const char *start
)
6855 const char *p
= start
;
6859 bool suffix
= false;
6860 bool starred
= false;
6862 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
6875 while (ISIDNUM (*p
) || *p
== '-' || *p
== '+' || *p
== '='
6876 || *p
== ',' || *p
== '.' || *p
== '@')
6881 starred
= true, p
++;
6887 /* Mark all matching switches as valid. */
6888 for (i
= 0; i
< n_switches
; i
++)
6889 if (!strncmp (switches
[i
].part1
, atom
, len
)
6890 && (starred
|| switches
[i
].part1
[len
] == 0))
6891 switches
[i
].validated
= 1;
6895 if (*p
&& (p
[-1] == '|' || p
[-1] == '&'))
6898 if (*p
&& p
[-1] == ':')
6900 while (*p
&& *p
!= ';' && *p
!= '}')
6905 if (*p
== '{' || *p
== '<')
6906 p
= validate_switches (p
+1);
6907 else if (p
[0] == 'W' && p
[1] == '{')
6908 p
= validate_switches (p
+2);
6915 if (*p
&& p
[-1] == ';')
6929 static struct mdswitchstr
*mdswitches
;
6930 static int n_mdswitches
;
6932 /* Check whether a particular argument was used. The first time we
6933 canonicalize the switches to keep only the ones we care about. */
6936 used_arg (const char *p
, int len
)
6941 const char *replace
;
6946 static struct mswitchstr
*mswitches
;
6947 static int n_mswitches
;
6952 struct mswitchstr
*matches
;
6956 /* Break multilib_matches into the component strings of string
6957 and replacement string. */
6958 for (q
= multilib_matches
; *q
!= '\0'; q
++)
6962 matches
= alloca ((sizeof (struct mswitchstr
)) * cnt
);
6964 q
= multilib_matches
;
6973 fatal ("multilib spec '%s' is invalid", multilib_matches
);
6977 matches
[i
].len
= q
- matches
[i
].str
;
6979 matches
[i
].replace
= ++q
;
6980 while (*q
!= ';' && *q
!= '\0')
6983 goto invalid_matches
;
6986 matches
[i
].rep_len
= q
- matches
[i
].replace
;
6992 /* Now build a list of the replacement string for switches that we care
6993 about. Make sure we allocate at least one entry. This prevents
6994 xmalloc from calling fatal, and prevents us from re-executing this
6997 = xmalloc (sizeof (struct mswitchstr
)
6998 * (n_mdswitches
+ (n_switches
? n_switches
: 1)));
6999 for (i
= 0; i
< n_switches
; i
++)
7000 if (switches
[i
].live_cond
!= SWITCH_IGNORE
)
7002 int xlen
= strlen (switches
[i
].part1
);
7003 for (j
= 0; j
< cnt
; j
++)
7004 if (xlen
== matches
[j
].len
7005 && ! strncmp (switches
[i
].part1
, matches
[j
].str
, xlen
))
7007 mswitches
[n_mswitches
].str
= matches
[j
].replace
;
7008 mswitches
[n_mswitches
].len
= matches
[j
].rep_len
;
7009 mswitches
[n_mswitches
].replace
= (char *) 0;
7010 mswitches
[n_mswitches
].rep_len
= 0;
7016 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
7017 on the command line nor any options mutually incompatible with
7019 for (i
= 0; i
< n_mdswitches
; i
++)
7023 for (q
= multilib_options
; *q
!= '\0'; q
++)
7029 while (strncmp (q
, mdswitches
[i
].str
, mdswitches
[i
].len
) != 0
7030 || strchr (" /", q
[mdswitches
[i
].len
]) == NULL
)
7032 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
7039 if (*q
!= ' ' && *q
!= '\0')
7041 while (*r
!= ' ' && *r
!= '\0')
7044 while (*q
!= ' ' && *q
!= '/' && *q
!= '\0')
7047 if (used_arg (r
, q
- r
))
7052 mswitches
[n_mswitches
].str
= mdswitches
[i
].str
;
7053 mswitches
[n_mswitches
].len
= mdswitches
[i
].len
;
7054 mswitches
[n_mswitches
].replace
= (char *) 0;
7055 mswitches
[n_mswitches
].rep_len
= 0;
7068 for (i
= 0; i
< n_mswitches
; i
++)
7069 if (len
== mswitches
[i
].len
&& ! strncmp (p
, mswitches
[i
].str
, len
))
7076 default_arg (const char *p
, int len
)
7080 for (i
= 0; i
< n_mdswitches
; i
++)
7081 if (len
== mdswitches
[i
].len
&& ! strncmp (p
, mdswitches
[i
].str
, len
))
7087 /* Work out the subdirectory to use based on the options. The format of
7088 multilib_select is a list of elements. Each element is a subdirectory
7089 name followed by a list of options followed by a semicolon. The format
7090 of multilib_exclusions is the same, but without the preceding
7091 directory. First gcc will check the exclusions, if none of the options
7092 beginning with an exclamation point are present, and all of the other
7093 options are present, then we will ignore this completely. Passing
7094 that, gcc will consider each multilib_select in turn using the same
7095 rules for matching the options. If a match is found, that subdirectory
7099 set_multilib_dir (void)
7102 unsigned int this_path_len
;
7103 const char *this_path
, *this_arg
;
7104 const char *start
, *end
;
7106 int ok
, ndfltok
, first
;
7109 start
= multilib_defaults
;
7110 while (*start
== ' ' || *start
== '\t')
7112 while (*start
!= '\0')
7115 while (*start
!= ' ' && *start
!= '\t' && *start
!= '\0')
7117 while (*start
== ' ' || *start
== '\t')
7125 mdswitches
= xmalloc (sizeof (struct mdswitchstr
) * n_mdswitches
);
7126 for (start
= multilib_defaults
; *start
!= '\0'; start
= end
+ 1)
7128 while (*start
== ' ' || *start
== '\t')
7134 for (end
= start
+ 1;
7135 *end
!= ' ' && *end
!= '\t' && *end
!= '\0'; end
++)
7138 obstack_grow (&multilib_obstack
, start
, end
- start
);
7139 obstack_1grow (&multilib_obstack
, 0);
7140 mdswitches
[i
].str
= XOBFINISH (&multilib_obstack
, const char *);
7141 mdswitches
[i
++].len
= end
- start
;
7148 p
= multilib_exclusions
;
7151 /* Ignore newlines. */
7158 /* Check the arguments. */
7165 fatal ("multilib exclusions '%s' is invalid",
7166 multilib_exclusions
);
7176 while (*p
!= ' ' && *p
!= ';')
7179 goto invalid_exclusions
;
7183 if (*this_arg
!= '!')
7191 ok
= used_arg (this_arg
, p
- this_arg
);
7206 p
= multilib_select
;
7209 /* Ignore newlines. */
7216 /* Get the initial path. */
7223 fatal ("multilib select '%s' is invalid",
7228 this_path_len
= p
- this_path
;
7230 /* Check the arguments. */
7237 goto invalid_select
;
7246 while (*p
!= ' ' && *p
!= ';')
7249 goto invalid_select
;
7253 if (*this_arg
!= '!')
7261 /* If this is a default argument, we can just ignore it.
7262 This is true even if this_arg begins with '!'. Beginning
7263 with '!' does not mean that this argument is necessarily
7264 inappropriate for this library: it merely means that
7265 there is a more specific library which uses this
7266 argument. If this argument is a default, we need not
7267 consider that more specific library. */
7268 ok
= used_arg (this_arg
, p
- this_arg
);
7275 if (default_arg (this_arg
, p
- this_arg
))
7284 if (this_path_len
!= 1
7285 || this_path
[0] != '.')
7287 char *new_multilib_dir
= xmalloc (this_path_len
+ 1);
7290 strncpy (new_multilib_dir
, this_path
, this_path_len
);
7291 new_multilib_dir
[this_path_len
] = '\0';
7292 q
= strchr (new_multilib_dir
, ':');
7295 multilib_dir
= new_multilib_dir
;
7302 const char *q
= this_path
, *end
= this_path
+ this_path_len
;
7304 while (q
< end
&& *q
!= ':')
7308 char *new_multilib_os_dir
= xmalloc (end
- q
);
7309 memcpy (new_multilib_os_dir
, q
+ 1, end
- q
- 1);
7310 new_multilib_os_dir
[end
- q
- 1] = '\0';
7311 multilib_os_dir
= new_multilib_os_dir
;
7319 if (multilib_dir
== NULL
&& multilib_os_dir
!= NULL
7320 && strcmp (multilib_os_dir
, ".") == 0)
7322 free ((char *) multilib_os_dir
);
7323 multilib_os_dir
= NULL
;
7325 else if (multilib_dir
!= NULL
&& multilib_os_dir
== NULL
)
7326 multilib_os_dir
= multilib_dir
;
7329 /* Print out the multiple library subdirectory selection
7330 information. This prints out a series of lines. Each line looks
7331 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
7332 required. Only the desired options are printed out, the negative
7333 matches. The options are print without a leading dash. There are
7334 no spaces to make it easy to use the information in the shell.
7335 Each subdirectory is printed only once. This assumes the ordering
7336 generated by the genmultilib script. Also, we leave out ones that match
7340 print_multilib_info (void)
7342 const char *p
= multilib_select
;
7343 const char *last_path
= 0, *this_path
;
7345 unsigned int last_path_len
= 0;
7350 /* Ignore newlines. */
7357 /* Get the initial path. */
7364 fatal ("multilib select '%s' is invalid", multilib_select
);
7370 /* When --disable-multilib was used but target defines
7371 MULTILIB_OSDIRNAMES, entries starting with .: are there just
7372 to find multilib_os_dir, so skip them from output. */
7373 if (this_path
[0] == '.' && this_path
[1] == ':')
7376 /* Check for matches with the multilib_exclusions. We don't bother
7377 with the '!' in either list. If any of the exclusion rules match
7378 all of its options with the select rule, we skip it. */
7380 const char *e
= multilib_exclusions
;
7381 const char *this_arg
;
7386 /* Ignore newlines. */
7393 /* Check the arguments. */
7402 fatal ("multilib exclusion '%s' is invalid",
7403 multilib_exclusions
);
7414 while (*e
!= ' ' && *e
!= ';')
7417 goto invalid_exclusion
;
7425 int len
= e
- this_arg
;
7428 goto invalid_select
;
7432 while (*q
!= ' ' && *q
!= ';')
7435 goto invalid_select
;
7439 if (! strncmp (arg
, this_arg
,
7440 (len
< q
- arg
) ? q
- arg
: len
)
7441 || default_arg (this_arg
, e
- this_arg
))
7471 /* If this is a duplicate, skip it. */
7472 skip
= (last_path
!= 0
7473 && (unsigned int) (p
- this_path
) == last_path_len
7474 && ! strncmp (last_path
, this_path
, last_path_len
));
7476 last_path
= this_path
;
7477 last_path_len
= p
- this_path
;
7480 /* If this directory requires any default arguments, we can skip
7481 it. We will already have printed a directory identical to
7482 this one which does not require that default argument. */
7493 goto invalid_select
;
7500 while (*q
!= ' ' && *q
!= ';')
7503 goto invalid_select
;
7508 && default_arg (arg
, q
- arg
))
7523 for (p1
= last_path
; p1
< p
&& *p1
!= ':'; p1
++)
7534 goto invalid_select
;
7542 use_arg
= *p
!= '!';
7547 while (*p
!= ' ' && *p
!= ';')
7550 goto invalid_select
;
7562 /* If there are extra options, print them now. */
7563 if (multilib_extra
&& *multilib_extra
)
7565 int print_at
= TRUE
;
7568 for (q
= multilib_extra
; *q
!= '\0'; q
++)
7589 /* if-exists built-in spec function.
7591 Checks to see if the file specified by the absolute pathname in
7592 ARGS exists. Returns that pathname if found.
7594 The usual use for this function is to check for a library file
7595 (whose name has been expanded with %s). */
7598 if_exists_spec_function (int argc
, const char **argv
)
7600 /* Must have only one argument. */
7601 if (argc
== 1 && IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
7607 /* if-exists-else built-in spec function.
7609 This is like if-exists, but takes an additional argument which
7610 is returned if the first argument does not exist. */
7613 if_exists_else_spec_function (int argc
, const char **argv
)
7615 /* Must have exactly two arguments. */
7619 if (IS_ABSOLUTE_PATH (argv
[0]) && ! access (argv
[0], R_OK
))
7625 /* replace-outfile built-in spec function.
7627 This looks for the first argument in the outfiles array's name and
7628 replaces it with the second argument. */
7631 replace_outfile_spec_function (int argc
, const char **argv
)
7634 /* Must have exactly two arguments. */
7638 for (i
= 0; i
< n_infiles
; i
++)
7640 if (outfiles
[i
] && !strcmp (outfiles
[i
], argv
[0]))
7641 outfiles
[i
] = xstrdup (argv
[1]);
7646 /* Given two version numbers, compares the two numbers.
7647 A version number must match the regular expression
7648 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
7651 compare_version_strings (const char *v1
, const char *v2
)
7656 if (regcomp (&r
, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
7657 REG_EXTENDED
| REG_NOSUB
) != 0)
7659 rresult
= regexec (&r
, v1
, 0, NULL
, 0);
7660 if (rresult
== REG_NOMATCH
)
7661 fatal ("invalid version number `%s'", v1
);
7662 else if (rresult
!= 0)
7664 rresult
= regexec (&r
, v2
, 0, NULL
, 0);
7665 if (rresult
== REG_NOMATCH
)
7666 fatal ("invalid version number `%s'", v2
);
7667 else if (rresult
!= 0)
7670 return strverscmp (v1
, v2
);
7674 /* version_compare built-in spec function.
7676 This takes an argument of the following form:
7678 <comparison-op> <arg1> [<arg2>] <switch> <result>
7680 and produces "result" if the comparison evaluates to true,
7681 and nothing if it doesn't.
7683 The supported <comparison-op> values are:
7685 >= true if switch is a later (or same) version than arg1
7687 < true if switch is an earlier version than arg1
7689 >< true if switch is arg1 or later, and earlier than arg2
7690 <> true if switch is earlier than arg1 or is arg2 or later
7692 If the switch is not present, the condition is false unless
7693 the first character of the <comparison-op> is '!'.
7696 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
7697 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
7700 version_compare_spec_function (int argc
, const char **argv
)
7704 const char *switch_value
= NULL
;
7709 fatal ("too few arguments to %%:version-compare");
7710 if (argv
[0][0] == '\0')
7712 if ((argv
[0][1] == '<' || argv
[0][1] == '>') && argv
[0][0] != '!')
7714 if (argc
!= nargs
+ 3)
7715 fatal ("too many arguments to %%:version-compare");
7717 switch_len
= strlen (argv
[nargs
+ 1]);
7718 for (i
= 0; i
< n_switches
; i
++)
7719 if (!strncmp (switches
[i
].part1
, argv
[nargs
+ 1], switch_len
)
7720 && check_live_switch (i
, switch_len
))
7721 switch_value
= switches
[i
].part1
+ switch_len
;
7723 if (switch_value
== NULL
)
7727 comp1
= compare_version_strings (switch_value
, argv
[1]);
7729 comp2
= compare_version_strings (switch_value
, argv
[2]);
7731 comp2
= -1; /* This value unused. */
7734 switch (argv
[0][0] << 8 | argv
[0][1])
7736 case '>' << 8 | '=':
7737 result
= comp1
>= 0;
7739 case '!' << 8 | '<':
7740 result
= comp1
>= 0 || switch_value
== NULL
;
7745 case '!' << 8 | '>':
7746 result
= comp1
< 0 || switch_value
== NULL
;
7748 case '>' << 8 | '<':
7749 result
= comp1
>= 0 && comp2
< 0;
7751 case '<' << 8 | '>':
7752 result
= comp1
< 0 || comp2
>= 0;
7756 fatal ("unknown operator '%s' in %%:version-compare", argv
[0]);
7761 return argv
[nargs
+ 2];