1 /* Compiler driver program that can handle many languages.
2 Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA.
22 This paragraph is here to try to keep Sun CC from dying.
23 The number of chars here seems crucial!!!! */
25 /* This program is the user interface to the C compiler and possibly to
26 other compilers. It is used because compilation is a complicated procedure
27 which involves running several programs and passing temporary files between
28 them, forwarding the users switches to those programs selectively,
29 and deleting the temporary files at the end.
31 CC recognizes how to compile each input file by suffixes in the file names.
32 Once it knows which kind of compilation to perform, the procedure for
33 compilation is specified by a string called a "spec". */
45 #define exit __posix_exit
48 #ifdef HAVE_SYS_RESOURCE_H
49 #include <sys/resource.h>
51 #ifdef NEED_DECLARATION_GETRUSAGE
52 extern int getrusage PARAMS ((int, struct rusage *));
55 /* By default there is no special suffix for executables. */
56 #ifdef EXECUTABLE_SUFFIX
57 #define HAVE_EXECUTABLE_SUFFIX
59 #define EXECUTABLE_SUFFIX ""
62 /* By default, the suffix for object files is ".o". */
64 #define HAVE_OBJECT_SUFFIX
66 #define OBJECT_SUFFIX ".o"
70 /* FIXME: the location independence code for VMS is hairier than this,
71 and hasn't been written. */
77 static char dir_separator_str[] = {DIR_SEPARATOR, 0};
79 #define obstack_chunk_alloc xmalloc
80 #define obstack_chunk_free free
82 #ifndef GET_ENV_PATH_LIST
83 #define GET_ENV_PATH_LIST(VAR,NAME) do { (VAR) = getenv (NAME); } while (0)
86 /* Most every one is fine with LIBRARY_PATH. For some, it conflicts. */
87 #ifndef LIBRARY_PATH_ENV
88 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
92 #define kill(p,s) raise(s)
95 /* If a stage of compilation returns an exit status >= 1,
96 compilation of that file ceases. */
98 #define MIN_FATAL_STATUS 1
100 /* Flag saying to pass the greatest exit code returned by a sub-process
101 to the calling program. */
102 static int pass_exit_codes;
104 /* Flag saying to print the directories gcc will search through looking for
105 programs, libraries, etc. */
107 static int print_search_dirs;
109 /* Flag saying to print the full filename of this file
110 as found through our usual search mechanism. */
112 static const char *print_file_name = NULL;
114 /* As print_file_name, but search for executable file. */
116 static const char *print_prog_name = NULL;
118 /* Flag saying to print the relative path we'd use to
119 find libgcc.a given the current compiler flags. */
121 static int print_multi_directory;
123 /* Flag saying to print the list of subdirectories and
124 compiler flags used to select them in a standard form. */
126 static int print_multi_lib;
128 /* Flag saying to print the command line options understood by gcc and its
131 static int print_help_list;
133 /* Flag indicating whether we should print the command and arguments */
135 static int verbose_flag;
137 /* Flag indicating whether we should report subprocess execution times
138 (if this is supported by the system - see pexecute.c). */
140 static int report_times;
142 /* Nonzero means write "temp" files in source directory
143 and use the source file's name in them, and don't delete them. */
145 static int save_temps_flag;
147 /* The compiler version. */
149 static const char *compiler_version;
151 /* The target version specified with -V */
153 static const char *spec_version = DEFAULT_TARGET_VERSION;
155 /* The target machine specified with -b. */
157 static const char *spec_machine = DEFAULT_TARGET_MACHINE;
159 /* Nonzero if cross-compiling.
160 When -b is used, the value comes from the `specs' file. */
163 static const char *cross_compile = "1";
165 static const char *cross_compile = "0";
168 /* The number of errors that have occurred; the link phase will not be
169 run if this is non-zero. */
170 static int error_count = 0;
172 /* Greatest exit code of sub-processes that has been encountered up to
174 static int greatest_status = 1;
176 /* This is the obstack which we use to allocate many strings. */
178 static struct obstack obstack;
180 /* This is the obstack to build an environment variable to pass to
181 collect2 that describes all of the relevant switches of what to
182 pass the compiler in building the list of pointers to constructors
185 static struct obstack collect_obstack;
187 /* These structs are used to collect resource usage information for
189 #ifdef HAVE_GETRUSAGE
190 static struct rusage rus, prus;
193 /* Forward declaration for prototypes. */
196 static void init_spec PARAMS ((void));
198 static char **split_directories PARAMS ((const char *, int *));
199 static void free_split_directories PARAMS ((char **));
200 static char *make_relative_prefix PARAMS ((const char *, const char *, const char *));
202 static void read_specs PARAMS ((const char *, int));
203 static void set_spec PARAMS ((const char *, const char *));
204 static struct compiler *lookup_compiler PARAMS ((const char *, size_t, const char *));
205 static char *build_search_list PARAMS ((struct path_prefix *, const char *, int));
206 static void putenv_from_prefixes PARAMS ((struct path_prefix *, const char *));
207 static int access_check PARAMS ((const char *, int));
208 static char *find_a_file PARAMS ((struct path_prefix *, const char *, int));
209 static void add_prefix PARAMS ((struct path_prefix *, const char *,
210 const char *, int, int, int *));
211 static char *skip_whitespace PARAMS ((char *));
212 static void record_temp_file PARAMS ((const char *, int, int));
213 static void delete_if_ordinary PARAMS ((const char *));
214 static void delete_temp_files PARAMS ((void));
215 static void delete_failure_queue PARAMS ((void));
216 static void clear_failure_queue PARAMS ((void));
217 static int check_live_switch PARAMS ((int, int));
218 static const char *handle_braces PARAMS ((const char *));
219 static char *save_string PARAMS ((const char *, int));
220 static int do_spec_1 PARAMS ((const char *, int, const char *));
221 static const char *find_file PARAMS ((const char *));
222 static int is_directory PARAMS ((const char *, const char *, int));
223 static void validate_switches PARAMS ((const char *));
224 static void validate_all_switches PARAMS ((void));
225 static void give_switch PARAMS ((int, int, int));
226 static int used_arg PARAMS ((const char *, int));
227 static int default_arg PARAMS ((const char *, int));
228 static void set_multilib_dir PARAMS ((void));
229 static void print_multilib_info PARAMS ((void));
230 static void pfatal_with_name PARAMS ((const char *)) ATTRIBUTE_NORETURN;
231 static void perror_with_name PARAMS ((const char *));
232 static void pfatal_pexecute PARAMS ((const char *, const char *))
234 static void error PARAMS ((const char *, ...))
236 static void notice PARAMS ((const char *, ...))
238 static void display_help PARAMS ((void));
239 static void add_preprocessor_option PARAMS ((const char *, int));
240 static void add_assembler_option PARAMS ((const char *, int));
241 static void add_linker_option PARAMS ((const char *, int));
242 static void process_command PARAMS ((int, char **));
243 static int execute PARAMS ((void));
244 static void unused_prefix_warnings PARAMS ((struct path_prefix *));
245 static void clear_args PARAMS ((void));
246 static void fatal_error PARAMS ((int));
247 static void set_input PARAMS ((const char *));
249 /* Specs are strings containing lines, each of which (if not blank)
250 is made up of a program name, and arguments separated by spaces.
251 The program name must be exact and start from root, since no path
252 is searched and it is unreliable to depend on the current working directory.
253 Redirection of input or output is not supported; the subprograms must
254 accept filenames saying what files to read and write.
256 In addition, the specs can contain %-sequences to substitute variable text
257 or for conditional text. Here is a table of all defined %-sequences.
258 Note that spaces are not generated automatically around the results of
259 expanding these sequences; therefore, you can concatenate them together
260 or with constant text in a single argument.
262 %% substitute one % into the program name or argument.
263 %i substitute the name of the input file being processed.
264 %b substitute the basename of the input file being processed.
265 This is the substring up to (and not including) the last period
266 and not including the directory.
268 substitute a file name that has suffix SUFFIX and is chosen
269 once per compilation, and mark the argument a la %d. To reduce
270 exposure to denial-of-service attacks, the file name is now
271 chosen in a way that is hard to predict even when previously
272 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
273 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
274 the regexp "[.A-Za-z]*%O"; "%O" is treated exactly as if it
275 had been pre-processed. Previously, %g was simply substituted
276 with a file name chosen once per compilation, without regard
277 to any appended suffix (which was therefore treated just like
278 ordinary text), making such attacks more likely to succeed.
280 like %g, but generates a new temporary file name even if %uSUFFIX
283 substitutes the last file name generated with %uSUFFIX, generating a
284 new one if there is no such last file name. In the absence of any
285 %uSUFFIX, this is just like %gSUFFIX, except they don't share
286 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
287 would involve the generation of two distinct file names, one
288 for each `%g.s' and another for each `%U.s'. Previously, %U was
289 simply substituted with a file name chosen for the previous %u,
290 without regard to any appended suffix.
291 %d marks the argument containing or following the %d as a
292 temporary file name, so that that file will be deleted if CC exits
293 successfully. Unlike %g, this contributes no text to the argument.
294 %w marks the argument containing or following the %w as the
295 "output file" of this compilation. This puts the argument
296 into the sequence of arguments that %o will substitute later.
298 like %{...} but mark last argument supplied within
299 as a file to be deleted on failure.
300 %o substitutes the names of all the output files, with spaces
301 automatically placed around them. You should write spaces
302 around the %o as well or the results are undefined.
303 %o is for use in the specs for running the linker.
304 Input files whose names have no recognized suffix are not compiled
305 at all, but they are included among the output files, so they will
307 %O substitutes the suffix for object files. Note that this is
308 handled specially when it immediately follows %g, %u, or %U
309 (with or without a suffix argument) because of the need for
310 those to form complete file names. The handling is such that
311 %O is treated exactly as if it had already been substituted,
312 except that %g, %u, and %U do not currently support additional
313 SUFFIX characters following %O as they would following, for
315 %p substitutes the standard macro predefinitions for the
316 current target machine. Use this when running cpp.
317 %P like %p, but puts `__' before and after the name of each macro.
318 (Except macros that already have __.)
320 %I Substitute a -iprefix option made from GCC_EXEC_PREFIX.
321 %s current argument is the name of a library or startup file of some sort.
322 Search for that file in a standard list of directories
323 and substitute the full name found.
324 %eSTR Print STR as an error message. STR is terminated by a newline.
325 Use this when inconsistent options are detected.
326 %x{OPTION} Accumulate an option for %X.
327 %X Output the accumulated linker options specified by compilations.
328 %Y Output the accumulated assembler options specified by compilations.
329 %Z Output the accumulated preprocessor options specified by compilations.
330 %v1 Substitute the major version number of GCC.
331 (For version 2.5.3, this is 2.)
332 %v2 Substitute the minor version number of GCC.
333 (For version 2.5.3, this is 5.)
334 %v3 Substitute the patch level number of GCC.
335 (For version 2.5.3, this is 3.)
336 %a process ASM_SPEC as a spec.
337 This allows config.h to specify part of the spec for running as.
338 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
339 used here. This can be used to run a post-processor after the
340 assembler has done its job.
341 %D Dump out a -L option for each directory in startfile_prefixes.
342 If multilib_dir is set, extra entries are generated with it affixed.
343 %l process LINK_SPEC as a spec.
344 %L process LIB_SPEC as a spec.
345 %G process LIBGCC_SPEC as a spec.
346 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
347 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
348 %c process SIGNED_CHAR_SPEC as a spec.
349 %C process CPP_SPEC as a spec. A capital C is actually used here.
350 %1 process CC1_SPEC as a spec.
351 %2 process CC1PLUS_SPEC as a spec.
352 %| output "-" if the input for the current command is coming from a pipe.
353 %* substitute the variable part of a matched option. (See below.)
354 Note that each comma in the substituted string is replaced by
356 %{S} substitutes the -S switch, if that switch was given to CC.
357 If that switch was not specified, this substitutes nothing.
358 Here S is a metasyntactic variable.
359 %{S*} substitutes all the switches specified to CC whose names start
360 with -S. This is used for -o, -D, -I, etc; switches that take
361 arguments. CC considers `-o foo' as being one switch whose
362 name starts with `o'. %{o*} would substitute this text,
363 including the space; thus, two arguments would be generated.
364 %{^S*} likewise, but don't put a blank between a switch and any args.
365 %{S*:X} substitutes X if one or more switches whose names start with -S are
366 specified to CC. Note that the tail part of the -S option
367 (i.e. the part matched by the `*') will be substituted for each
368 occurrence of %* within X.
369 %{<S} remove all occurences of S from the command line.
370 Note - this option is position dependent. % commands in the
371 spec string before this option will see S, % commands in the
372 spec string after this option will not.
373 %{S:X} substitutes X, but only if the -S switch was given to CC.
374 %{!S:X} substitutes X, but only if the -S switch was NOT given to CC.
375 %{|S:X} like %{S:X}, but if no S switch, substitute `-'.
376 %{|!S:X} like %{!S:X}, but if there is an S switch, substitute `-'.
377 %{.S:X} substitutes X, but only if processing a file with suffix S.
378 %{!.S:X} substitutes X, but only if NOT processing a file with suffix S.
379 %{S|P:X} substitutes X if either -S or -P was given to CC. This may be
380 combined with ! and . as above binding stronger than the OR.
381 %(Spec) processes a specification defined in a specs file as *Spec:
382 %[Spec] as above, but put __ around -D arguments
384 The conditional text X in a %{S:X} or %{!S:X} construct may contain
385 other nested % constructs or spaces, or even newlines. They are
386 processed as usual, as described above.
388 The -O, -f, -m, and -W switches are handled specifically in these
389 constructs. If another value of -O or the negated form of a -f, -m, or
390 -W switch is found later in the command line, the earlier switch
391 value is ignored, except with {S*} where S is just one letter; this
392 passes all matching options.
394 The character | at the beginning of the predicate text is used to indicate
395 that a command should be piped to the following command, but only if -pipe
398 Note that it is built into CC which switches take arguments and which
399 do not. You might think it would be useful to generalize this to
400 allow each compiler's spec to say which switches take arguments. But
401 this cannot be done in a consistent fashion. CC cannot even decide
402 which input files have been specified without knowing which switches
403 take arguments, and it must know which input files to compile in order
404 to tell which compilers to run.
406 CC also knows implicitly that arguments starting in `-l' are to be
407 treated as compiler output files, and passed to the linker in their
408 proper position among the other output files. */
410 /* Define the macros used for specs %a, %l, %L, %S, %c, %C, %1. */
412 /* config.h can define ASM_SPEC to provide extra args to the assembler
413 or extra switch-translations. */
418 /* config.h can define ASM_FINAL_SPEC to run a post processor after
419 the assembler has run. */
420 #ifndef ASM_FINAL_SPEC
421 #define ASM_FINAL_SPEC ""
424 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
425 or extra switch-translations. */
430 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
431 or extra switch-translations. */
436 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
437 or extra switch-translations. */
439 #define CC1PLUS_SPEC ""
442 /* config.h can define LINK_SPEC to provide extra args to the linker
443 or extra switch-translations. */
448 /* config.h can define LIB_SPEC to override the default libraries. */
450 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
453 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
456 #if defined(LINK_LIBGCC_SPECIAL) || defined(LINK_LIBGCC_SPECIAL_1)
457 /* Have gcc do the search for libgcc.a. */
458 #define LIBGCC_SPEC "libgcc.a%s"
460 #define LIBGCC_SPEC "-lgcc"
464 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
465 #ifndef STARTFILE_SPEC
466 #define STARTFILE_SPEC \
467 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
470 /* config.h can define SWITCHES_NEED_SPACES to control which options
471 require spaces between the option and the argument. */
472 #ifndef SWITCHES_NEED_SPACES
473 #define SWITCHES_NEED_SPACES ""
476 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
478 #define ENDFILE_SPEC ""
481 /* This spec is used for telling cpp whether char is signed or not. */
482 #ifndef SIGNED_CHAR_SPEC
483 /* Use #if rather than ?:
484 because MIPS C compiler rejects like ?: in initializers. */
485 #if DEFAULT_SIGNED_CHAR
486 #define SIGNED_CHAR_SPEC "%{funsigned-char:-D__CHAR_UNSIGNED__}"
488 #define SIGNED_CHAR_SPEC "%{!fsigned-char:-D__CHAR_UNSIGNED__}"
493 #define LINKER_NAME "collect2"
496 static const char *cpp_spec = CPP_SPEC;
497 static const char *cpp_predefines = CPP_PREDEFINES;
498 static const char *cc1_spec = CC1_SPEC;
499 static const char *cc1plus_spec = CC1PLUS_SPEC;
500 static const char *signed_char_spec = SIGNED_CHAR_SPEC;
501 static const char *asm_spec = ASM_SPEC;
502 static const char *asm_final_spec = ASM_FINAL_SPEC;
503 static const char *link_spec = LINK_SPEC;
504 static const char *lib_spec = LIB_SPEC;
505 static const char *libgcc_spec = LIBGCC_SPEC;
506 static const char *endfile_spec = ENDFILE_SPEC;
507 static const char *startfile_spec = STARTFILE_SPEC;
508 static const char *switches_need_spaces = SWITCHES_NEED_SPACES;
509 static const char *linker_name_spec = LINKER_NAME;
511 /* Some compilers have limits on line lengths, and the multilib_select
512 and/or multilib_matches strings can be very long, so we build them at
514 static struct obstack multilib_obstack;
515 static const char *multilib_select;
516 static const char *multilib_matches;
517 static const char *multilib_defaults;
518 static const char *multilib_exclusions;
519 #include "multilib.h"
521 /* Check whether a particular argument is a default argument. */
523 #ifndef MULTILIB_DEFAULTS
524 #define MULTILIB_DEFAULTS { "" }
527 static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
531 struct user_specs *next;
532 const char *filename;
535 static struct user_specs *user_specs_head, *user_specs_tail;
537 /* This defines which switch letters take arguments. */
539 #define DEFAULT_SWITCH_TAKES_ARG(CHAR) \
540 ((CHAR) == 'D' || (CHAR) == 'U' || (CHAR) == 'o' \
541 || (CHAR) == 'e' || (CHAR) == 'T' || (CHAR) == 'u' \
542 || (CHAR) == 'I' || (CHAR) == 'm' || (CHAR) == 'x' \
543 || (CHAR) == 'L' || (CHAR) == 'A' || (CHAR) == 'V' \
544 || (CHAR) == 'B' || (CHAR) == 'b')
546 #ifndef SWITCH_TAKES_ARG
547 #define SWITCH_TAKES_ARG(CHAR) DEFAULT_SWITCH_TAKES_ARG(CHAR)
550 /* This defines which multi-letter switches take arguments. */
552 #define DEFAULT_WORD_SWITCH_TAKES_ARG(STR) \
553 (!strcmp (STR, "Tdata") || !strcmp (STR, "Ttext") \
554 || !strcmp (STR, "Tbss") || !strcmp (STR, "include") \
555 || !strcmp (STR, "imacros") || !strcmp (STR, "aux-info") \
556 || !strcmp (STR, "idirafter") || !strcmp (STR, "iprefix") \
557 || !strcmp (STR, "iwithprefix") || !strcmp (STR, "iwithprefixbefore") \
558 || !strcmp (STR, "isystem") || !strcmp (STR, "specs"))
560 #ifndef WORD_SWITCH_TAKES_ARG
561 #define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR)
565 #ifdef HAVE_EXECUTABLE_SUFFIX
566 /* This defines which switches stop a full compilation. */
567 #define DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) \
568 ((CHAR) == 'c' || (CHAR) == 'S')
570 #ifndef SWITCH_CURTAILS_COMPILATION
571 #define SWITCH_CURTAILS_COMPILATION(CHAR) \
572 DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR)
576 /* Record the mapping from file suffixes for compilation specs. */
580 const char *suffix; /* Use this compiler for input files
581 whose names end in this suffix. */
583 const char *spec[4]; /* To use this compiler, concatenate these
584 specs and pass to do_spec. */
587 /* Pointer to a vector of `struct compiler' that gives the spec for
588 compiling a file, based on its suffix.
589 A file that does not end in any of these suffixes will be passed
590 unchanged to the loader and nothing else will be done to it.
592 An entry containing two 0s is used to terminate the vector.
594 If multiple entries match a file, the last matching one is used. */
596 static struct compiler *compilers;
598 /* Number of entries in `compilers', not counting the null terminator. */
600 static int n_compilers;
602 /* The default list of file name suffixes and their compilation specs. */
604 static struct compiler default_compilers[] =
606 /* Add lists of suffixes of known languages here. If those languages
607 were not present when we built the driver, we will hit these copies
608 and be given a more meaningful error than "file not used since
609 linking is not done". */
610 {".m", {"#Objective-C"}},
611 {".cc", {"#C++"}}, {".cxx", {"#C++"}}, {".cpp", {"#C++"}},
612 {".c++", {"#C++"}}, {".C", {"#C++"}},
613 {".ads", {"#Ada"}}, {".adb", {"#Ada"}}, {".ada", {"#Ada"}},
614 {".f", {"#Fortran"}}, {".for", {"#Fortran"}}, {".F", {"#Fortran"}},
615 {".fpp", {"#Fortran"}},
616 {".p", {"#Pascal"}}, {".pas", {"#Pascal"}},
617 /* Next come the entries for C. */
622 "%{E|M|MM:cpp -lang-c %{ansi:-std=c89} %{std*} %{nostdinc*}\
623 %{C} %{v} %{A*} %{I*} %{P} %{$} %I\
624 %{C:%{!E:%eGNU C does not support -C without using -E}}\
625 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
626 %{!no-gcc:-D__GNUC__=%v1 -D__GNUC_MINOR__=%v2 -D__GNUC_PATCHLEVEL__=%v3}\
627 %{!undef:%{!ansi:%{!std=*:%p}%{std=gnu*:%p}} %P} %{trigraphs}\
628 %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
629 %{ffast-math:-D__FAST_MATH__}\
630 %{fshort-wchar:-D__WCHAR_TYPE__=short\\ unsigned\\ int}\
631 %{traditional} %{ftraditional:-traditional}\
632 %{traditional-cpp:-traditional}\
633 %{fleading-underscore} %{fno-leading-underscore}\
634 %{fshow-column} %{fno-show-column}\
635 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\
636 %i %{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}}\n}\
637 %{!E:%{!M:%{!MM:cc1 %i %1 \
638 %{std*} %{nostdinc*} %{A*} %{I*} %I\
639 %{!Q:-quiet} -dumpbase %b.c %{d*} %{m*} %{a*}\
640 %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
641 %{!no-gcc:-D__GNUC__=%v1 -D__GNUC_MINOR__=%v2 -D__GNUC_PATCHLEVEL__=%v3}\
642 %{!undef:%{!ansi:%{!std=*:%p}%{std=gnu*:%p}} %P} %{trigraphs}\
643 %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
644 %{ffast-math:-D__FAST_MATH__}\
645 %{fshort-wchar:-D__WCHAR_TYPE__=short\\ unsigned\\ int}\
646 %{fshort-wchar:-D__WCHAR_TYPE__=short\\ unsigned\\ int}\
647 %{H} %C %{D*} %{U*} %{i*} %Z\
648 %{ftraditional:-traditional}\
649 %{traditional-cpp:-traditional}\
650 %{traditional} %{v:-version} %{pg:-p} %{p} %{f*}\
651 %{aux-info*} %{Qn:-fno-ident}\
653 %{g*} %{O*} %{W*} %{w} %{pedantic*}\
654 %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
655 %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
657 %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}\
658 %{!pipe:%g.s} %A\n }}}}"
659 #else /* ! USE_CPPLIB */
660 "cpp -lang-c %{ansi:-std=c89} %{std*} %{nostdinc*}\
661 %{C} %{v} %{A*} %{I*} %{P} %{$} %I\
662 %{C:%{!E:%eGNU C does not support -C without using -E}}\
663 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
664 %{!no-gcc:-D__GNUC__=%v1 -D__GNUC_MINOR__=%v2 -D__GNUC_PATCHLEVEL__=%v3}\
665 %{!undef:%{!ansi:%{!std=*:%p}%{std=gnu*:%p}} %P} %{trigraphs}\
666 %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
667 %{ffast-math:-D__FAST_MATH__}\
668 %{fshort-wchar:-D__WCHAR_TYPE__=short\\ unsigned\\ int}\
669 %{traditional} %{ftraditional:-traditional}\
670 %{traditional-cpp:-traditional}\
671 %{fshow-column} %{fno-show-column}\
672 %{fleading-underscore} %{fno-leading-underscore}\
673 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\
674 %i %{!M:%{!MM:%{!E:%{!pipe:%g.i}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
675 "%{!M:%{!MM:%{!E:cc1 %{!pipe:%g.i} %1 \
676 %{!Q:-quiet} -dumpbase %b.c %{d*} %{m*} %{a*}\
677 %{g*} %{O*} %{W*} %{w} %{pedantic*} %{std*}\
678 %{traditional} %{v:-version} %{pg:-p} %{p} %{f*}\
679 %{aux-info*} %{Qn:-fno-ident}\
681 %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
682 %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
684 %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}\
685 %{!pipe:%g.s} %A\n }}}}"
686 #endif /* ! USE_CPPLIB */
689 {"%{E:cpp -lang-c %{ansi:-std=c89} %{std*} %{nostdinc*}\
690 %{C} %{v} %{A*} %{I*} %{P} %{$} %I\
691 %{C:%{!E:%eGNU C does not support -C without using -E}}\
692 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
693 %{!no-gcc:-D__GNUC__=%v1 -D__GNUC_MINOR__=%v2 -D__GNUC_PATCHLEVEL__=%v3}\
694 %{!undef:%{!ansi:%{!std=*:%p}%{std=gnu*:%p}} %P} %{trigraphs}\
695 %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
696 %{ffast-math:-D__FAST_MATH__}\
697 %{fshort-wchar:-D__WCHAR_TYPE__=short\\ unsigned\\ int}\
698 %{traditional} %{ftraditional:-traditional}\
699 %{traditional-cpp:-traditional}\
700 %{fshow-column} %{fno-show-column}\
701 %{fleading-underscore} %{fno-leading-underscore}\
702 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\
704 %{!E:%e-E required when input is from standard input}"}},
705 {".h", {"@c-header"}},
707 {"%{!E:%eCompilation of header file requested} \
708 cpp %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %{$} %I\
709 %{C:%{!E:%eGNU C does not support -C without using -E}}\
710 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
711 %{!no-gcc:-D__GNUC__=%v1 -D__GNUC_MINOR__=%v2 -D__GNUC_PATCHLEVEL__=%v3}\
712 %{!undef:%{!std=*:%p}%{std=gnu*:%p} %P} %{trigraphs}\
713 %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
714 %{ffast-math:-D__FAST_MATH__}\
715 %{fshort-wchar:-D__WCHAR_TYPE__=short\\ unsigned\\ int}\
716 %{fshort-wchar:-D__WCHAR_TYPE__=short\\ unsigned\\ int}\
717 %{traditional} %{ftraditional:-traditional}\
718 %{traditional-cpp:-traditional}\
719 %{fshow-column} %{fno-show-column}\
720 %{fleading-underscore} %{fno-leading-underscore}\
721 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\
723 {".i", {"@cpp-output"}},
725 {"%{!M:%{!MM:%{!E:cc1 %i %1 %{!Q:-quiet} %{d*} %{m*} %{a*}\
726 %{g*} %{O*} %{W*} %{w} %{pedantic*} %{std*}\
727 %{traditional} %{v:-version} %{pg:-p} %{p} %{f*}\
728 %{aux-info*} %{Qn:-fno-ident} -fpreprocessed\
729 %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
730 %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
732 %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}\
733 %{!pipe:%g.s} %A\n }}}}"}},
734 {".s", {"@assembler"}},
736 {"%{!M:%{!MM:%{!E:%{!S:as %a %Y\
737 %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}\
739 {".S", {"@assembler-with-cpp"}},
740 {"@assembler-with-cpp",
741 {"cpp -lang-asm %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %{$} %I\
742 %{C:%{!E:%eGNU C does not support -C without using -E}}\
743 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG} %{trigraphs}\
744 -$ %{!undef:%p %P} -D__ASSEMBLER__ \
745 %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
746 %{ffast-math:-D__FAST_MATH__}\
747 %{fshort-wchar:-D__WCHAR_TYPE__=short\\ unsigned\\ int}\
748 %{traditional} %{ftraditional:-traditional}\
749 %{traditional-cpp:-traditional}\
750 %{fshow-column} %{fno-show-column}\
751 %{fleading-underscore} %{fno-leading-underscore}\
752 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\
753 %i %{!M:%{!MM:%{!E:%{!pipe:%g.s}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
754 "%{!M:%{!MM:%{!E:%{!S:as %a %Y\
755 %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}\
756 %{!pipe:%g.s} %A\n }}}}"}},
758 /* Mark end of table */
762 /* Number of elements in default_compilers, not counting the terminator. */
764 static int n_default_compilers
765 = (sizeof default_compilers / sizeof (struct compiler)) - 1;
767 /* Here is the spec for running the linker, after compiling all files. */
769 /* -u* was put back because both BSD and SysV seem to support it. */
770 /* %{static:} simply prevents an error message if the target machine
771 doesn't handle -static. */
772 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
773 scripts which exist in user specified directories, or in standard
775 #ifdef LINK_COMMAND_SPEC
776 /* Provide option to override link_command_spec from machine specific
777 configuration files. */
778 static const char *link_command_spec =
781 #ifdef LINK_LIBGCC_SPECIAL
782 /* Don't generate -L options. */
783 static const char *link_command_spec = "\
785 %{!c:%{!M:%{!MM:%{!E:%{!S:%(linker) %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} \
786 %{r} %{s} %{t} %{u*} %{x} %{z} %{Z}\
787 %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
789 %{!nostdlib:%{!nodefaultlibs:%G %L %G}}\
790 %{!A:%{!nostdlib:%{!nostartfiles:%E}}}\
795 static const char *link_command_spec = "\
797 %{!c:%{!M:%{!MM:%{!E:%{!S:%(linker) %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} \
798 %{r} %{s} %{t} %{u*} %{x} %{z} %{Z}\
799 %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
800 %{static:} %{L*} %D %o\
801 %{!nostdlib:%{!nodefaultlibs:%G %L %G}}\
802 %{!A:%{!nostdlib:%{!nostartfiles:%E}}}\
808 /* A vector of options to give to the linker.
809 These options are accumulated by %x,
810 and substituted into the linker command with %X. */
811 static int n_linker_options;
812 static char **linker_options;
814 /* A vector of options to give to the assembler.
815 These options are accumulated by -Wa,
816 and substituted into the assembler command with %Y. */
817 static int n_assembler_options;
818 static char **assembler_options;
820 /* A vector of options to give to the preprocessor.
821 These options are accumulated by -Wp,
822 and substituted into the preprocessor command with %Z. */
823 static int n_preprocessor_options;
824 static char **preprocessor_options;
826 /* Define how to map long options into short ones. */
828 /* This structure describes one mapping. */
831 /* The long option's name. */
833 /* The equivalent short option. */
834 const char *equivalent;
835 /* Argument info. A string of flag chars; NULL equals no options.
836 a => argument required.
837 o => argument optional.
838 j => join argument to equivalent, making one word.
839 * => require other text after NAME as an argument. */
840 const char *arg_info;
843 /* This is the table of mappings. Mappings are tried sequentially
844 for each option encountered; the first one that matches, wins. */
846 struct option_map option_map[] =
848 {"--all-warnings", "-Wall", 0},
849 {"--ansi", "-ansi", 0},
850 {"--assemble", "-S", 0},
851 {"--assert", "-A", "a"},
852 {"--classpath", "-fclasspath=", "aj"},
853 {"--CLASSPATH", "-fCLASSPATH=", "aj"},
854 {"--comments", "-C", 0},
855 {"--compile", "-c", 0},
856 {"--debug", "-g", "oj"},
857 {"--define-macro", "-D", "aj"},
858 {"--dependencies", "-M", 0},
859 {"--dump", "-d", "a"},
860 {"--dumpbase", "-dumpbase", "a"},
861 {"--entry", "-e", 0},
862 {"--extra-warnings", "-W", 0},
863 {"--for-assembler", "-Wa", "a"},
864 {"--for-linker", "-Xlinker", "a"},
865 {"--force-link", "-u", "a"},
866 {"--imacros", "-imacros", "a"},
867 {"--include", "-include", "a"},
868 {"--include-barrier", "-I-", 0},
869 {"--include-directory", "-I", "aj"},
870 {"--include-directory-after", "-idirafter", "a"},
871 {"--include-prefix", "-iprefix", "a"},
872 {"--include-with-prefix", "-iwithprefix", "a"},
873 {"--include-with-prefix-before", "-iwithprefixbefore", "a"},
874 {"--include-with-prefix-after", "-iwithprefix", "a"},
875 {"--language", "-x", "a"},
876 {"--library-directory", "-L", "a"},
877 {"--machine", "-m", "aj"},
878 {"--machine-", "-m", "*j"},
879 {"--no-line-commands", "-P", 0},
880 {"--no-precompiled-includes", "-noprecomp", 0},
881 {"--no-standard-includes", "-nostdinc", 0},
882 {"--no-standard-libraries", "-nostdlib", 0},
883 {"--no-warnings", "-w", 0},
884 {"--optimize", "-O", "oj"},
885 {"--output", "-o", "a"},
886 {"--output-class-directory", "-foutput-class-dir=", "ja"},
887 {"--pedantic", "-pedantic", 0},
888 {"--pedantic-errors", "-pedantic-errors", 0},
889 {"--pipe", "-pipe", 0},
890 {"--prefix", "-B", "a"},
891 {"--preprocess", "-E", 0},
892 {"--print-search-dirs", "-print-search-dirs", 0},
893 {"--print-file-name", "-print-file-name=", "aj"},
894 {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
895 {"--print-missing-file-dependencies", "-MG", 0},
896 {"--print-multi-lib", "-print-multi-lib", 0},
897 {"--print-multi-directory", "-print-multi-directory", 0},
898 {"--print-prog-name", "-print-prog-name=", "aj"},
899 {"--profile", "-p", 0},
900 {"--profile-blocks", "-a", 0},
901 {"--quiet", "-q", 0},
902 {"--save-temps", "-save-temps", 0},
903 {"--shared", "-shared", 0},
904 {"--silent", "-q", 0},
905 {"--specs", "-specs=", "aj"},
906 {"--static", "-static", 0},
907 {"--std", "-std=", "aj"},
908 {"--symbolic", "-symbolic", 0},
909 {"--target", "-b", "a"},
910 {"--time", "-time", 0},
911 {"--trace-includes", "-H", 0},
912 {"--traditional", "-traditional", 0},
913 {"--traditional-cpp", "-traditional-cpp", 0},
914 {"--trigraphs", "-trigraphs", 0},
915 {"--undefine-macro", "-U", "aj"},
916 {"--use-version", "-V", "a"},
917 {"--user-dependencies", "-MM", 0},
918 {"--verbose", "-v", 0},
919 {"--version", "-dumpversion", 0},
920 {"--warn-", "-W", "*j"},
921 {"--write-dependencies", "-MD", 0},
922 {"--write-user-dependencies", "-MMD", 0},
926 /* Translate the options described by *ARGCP and *ARGVP.
927 Make a new vector and store it back in *ARGVP,
928 and store its length in *ARGVC. */
931 translate_options (argcp, argvp)
937 const char **argv = *argvp;
939 (const char **) xmalloc ((argc + 2) * 2 * sizeof (const char *));
943 newv[newindex++] = argv[i++];
947 /* Translate -- options. */
948 if (argv[i][0] == '-' && argv[i][1] == '-')
951 /* Find a mapping that applies to this option. */
952 for (j = 0; j < sizeof (option_map) / sizeof (option_map[0]); j++)
954 size_t optlen = strlen (option_map[j].name);
955 size_t arglen = strlen (argv[i]);
956 size_t complen = arglen > optlen ? optlen : arglen;
957 const char *arginfo = option_map[j].arg_info;
962 if (!strncmp (argv[i], option_map[j].name, complen))
970 k < sizeof (option_map) / sizeof (option_map[0]);
972 if (strlen (option_map[k].name) >= arglen
973 && !strncmp (argv[i], option_map[k].name, arglen))
975 error ("Ambiguous abbreviation %s", argv[i]);
979 if (k != sizeof (option_map) / sizeof (option_map[0]))
985 /* If the option has an argument, accept that. */
986 if (argv[i][optlen] == '=')
987 arg = argv[i] + optlen + 1;
989 /* If this mapping requires extra text at end of name,
990 accept that as "argument". */
991 else if (index (arginfo, '*') != 0)
992 arg = argv[i] + optlen;
994 /* Otherwise, extra text at end means mismatch.
995 Try other mappings. */
1000 else if (index (arginfo, '*') != 0)
1002 error ("Incomplete `%s' option", option_map[j].name);
1006 /* Handle arguments. */
1007 if (index (arginfo, 'a') != 0)
1013 error ("Missing argument to `%s' option",
1014 option_map[j].name);
1021 else if (index (arginfo, '*') != 0)
1023 else if (index (arginfo, 'o') == 0)
1026 error ("Extraneous argument to `%s' option",
1027 option_map[j].name);
1031 /* Store the translation as one argv elt or as two. */
1032 if (arg != 0 && index (arginfo, 'j') != 0)
1033 newv[newindex++] = concat (option_map[j].equivalent, arg,
1037 newv[newindex++] = option_map[j].equivalent;
1038 newv[newindex++] = arg;
1041 newv[newindex++] = option_map[j].equivalent;
1049 /* Handle old-fashioned options--just copy them through,
1050 with their arguments. */
1051 else if (argv[i][0] == '-')
1053 const char *p = argv[i] + 1;
1057 if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
1058 nskip += SWITCH_TAKES_ARG (c) - (p[1] != 0);
1059 else if (WORD_SWITCH_TAKES_ARG (p))
1060 nskip += WORD_SWITCH_TAKES_ARG (p);
1061 else if ((c == 'B' || c == 'b' || c == 'V' || c == 'x')
1064 else if (! strcmp (p, "Xlinker"))
1067 /* Watch out for an option at the end of the command line that
1068 is missing arguments, and avoid skipping past the end of the
1070 if (nskip + i > argc)
1075 newv[newindex++] = argv[i++];
1080 /* Ordinary operands, or +e options. */
1081 newv[newindex++] = argv[i++];
1096 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1097 be considered whitespace. */
1098 if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
1100 else if (*p == '\n' || *p == ' ' || *p == '\t')
1104 while (*p != '\n') p++;
1114 /* Structure to keep track of the specs that have been defined so far.
1115 These are accessed using %(specname) or %[specname] in a compiler
1120 /* The following 2 fields must be first */
1121 /* to allow EXTRA_SPECS to be initialized */
1122 const char *name; /* name of the spec. */
1123 const char *ptr; /* available ptr if no static pointer */
1125 /* The following fields are not initialized */
1126 /* by EXTRA_SPECS */
1127 const char **ptr_spec; /* pointer to the spec itself. */
1128 struct spec_list *next; /* Next spec in linked list. */
1129 int name_len; /* length of the name */
1130 int alloc_p; /* whether string was allocated */
1133 #define INIT_STATIC_SPEC(NAME,PTR) \
1134 { NAME, NULL_PTR, PTR, (struct spec_list *)0, sizeof (NAME)-1, 0 }
1136 /* List of statically defined specs. */
1137 static struct spec_list static_specs[] =
1139 INIT_STATIC_SPEC ("asm", &asm_spec),
1140 INIT_STATIC_SPEC ("asm_final", &asm_final_spec),
1141 INIT_STATIC_SPEC ("cpp", &cpp_spec),
1142 INIT_STATIC_SPEC ("cc1", &cc1_spec),
1143 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec),
1144 INIT_STATIC_SPEC ("endfile", &endfile_spec),
1145 INIT_STATIC_SPEC ("link", &link_spec),
1146 INIT_STATIC_SPEC ("lib", &lib_spec),
1147 INIT_STATIC_SPEC ("libgcc", &libgcc_spec),
1148 INIT_STATIC_SPEC ("startfile", &startfile_spec),
1149 INIT_STATIC_SPEC ("switches_need_spaces", &switches_need_spaces),
1150 INIT_STATIC_SPEC ("signed_char", &signed_char_spec),
1151 INIT_STATIC_SPEC ("predefines", &cpp_predefines),
1152 INIT_STATIC_SPEC ("cross_compile", &cross_compile),
1153 INIT_STATIC_SPEC ("version", &compiler_version),
1154 INIT_STATIC_SPEC ("multilib", &multilib_select),
1155 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults),
1156 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra),
1157 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches),
1158 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions),
1159 INIT_STATIC_SPEC ("linker", &linker_name_spec),
1162 #ifdef EXTRA_SPECS /* additional specs needed */
1163 /* Structure to keep track of just the first two args of a spec_list.
1164 That is all that the EXTRA_SPECS macro gives us. */
1171 static struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1172 static struct spec_list * extra_specs = (struct spec_list *)0;
1175 /* List of dynamically allocates specs that have been defined so far. */
1177 static struct spec_list *specs = (struct spec_list *)0;
1180 /* Initialize the specs lookup routines. */
1185 struct spec_list *next = (struct spec_list *)0;
1186 struct spec_list *sl = (struct spec_list *)0;
1190 return; /* Already initialized. */
1193 notice ("Using builtin specs.\n");
1196 extra_specs = (struct spec_list *)
1197 xcalloc (sizeof(struct spec_list),
1198 (sizeof(extra_specs_1)/sizeof(extra_specs_1[0])));
1200 for (i = (sizeof(extra_specs_1) / sizeof(extra_specs_1[0])) - 1; i >= 0; i--)
1202 sl = &extra_specs[i];
1203 sl->name = extra_specs_1[i].name;
1204 sl->ptr = extra_specs_1[i].ptr;
1206 sl->name_len = strlen (sl->name);
1207 sl->ptr_spec = &sl->ptr;
1212 for (i = (sizeof (static_specs) / sizeof (static_specs[0])) - 1; i >= 0; i--)
1214 sl = &static_specs[i];
1223 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1224 removed; If the spec starts with a + then SPEC is added to the end of the
1228 set_spec (name, spec)
1232 struct spec_list *sl;
1233 const char *old_spec;
1234 int name_len = strlen (name);
1237 /* If this is the first call, initialize the statically allocated specs. */
1240 struct spec_list *next = (struct spec_list *)0;
1241 for (i = (sizeof (static_specs) / sizeof (static_specs[0])) - 1;
1244 sl = &static_specs[i];
1251 /* See if the spec already exists. */
1252 for (sl = specs; sl; sl = sl->next)
1253 if (name_len == sl->name_len && !strcmp (sl->name, name))
1258 /* Not found - make it. */
1259 sl = (struct spec_list *) xmalloc (sizeof (struct spec_list));
1260 sl->name = xstrdup (name);
1261 sl->name_len = name_len;
1262 sl->ptr_spec = &sl->ptr;
1264 *(sl->ptr_spec) = "";
1269 old_spec = *(sl->ptr_spec);
1270 *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
1271 ? concat (old_spec, spec + 1, NULL_PTR)
1276 notice ("Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
1279 /* Free the old spec. */
1280 if (old_spec && sl->alloc_p)
1281 free ((PTR) old_spec);
1286 /* Accumulate a command (program name and args), and run it. */
1288 /* Vector of pointers to arguments in the current line of specifications. */
1290 static char **argbuf;
1292 /* Number of elements allocated in argbuf. */
1294 static int argbuf_length;
1296 /* Number of elements in argbuf currently in use (containing args). */
1298 static int argbuf_index;
1300 /* We want this on by default all the time now. */
1301 #define MKTEMP_EACH_FILE
1303 #ifdef MKTEMP_EACH_FILE
1305 /* This is the list of suffixes and codes (%g/%u/%U) and the associated
1308 static struct temp_name {
1309 const char *suffix; /* suffix associated with the code. */
1310 int length; /* strlen (suffix). */
1311 int unique; /* Indicates whether %g or %u/%U was used. */
1312 const char *filename; /* associated filename. */
1313 int filename_length; /* strlen (filename). */
1314 struct temp_name *next;
1319 /* Number of commands executed so far. */
1321 static int execution_count;
1323 /* Number of commands that exited with a signal. */
1325 static int signal_count;
1327 /* Name with which this program was invoked. */
1329 static const char *programname;
1331 /* Structures to keep track of prefixes to try when looking for files. */
1335 char *prefix; /* String to prepend to the path. */
1336 struct prefix_list *next; /* Next in linked list. */
1337 int require_machine_suffix; /* Don't use without machine_suffix. */
1338 /* 2 means try both machine_suffix and just_machine_suffix. */
1339 int *used_flag_ptr; /* 1 if a file was found with this prefix. */
1344 struct prefix_list *plist; /* List of prefixes to try */
1345 int max_len; /* Max length of a prefix in PLIST */
1346 const char *name; /* Name of this list (used in config stuff) */
1349 /* List of prefixes to try when looking for executables. */
1351 static struct path_prefix exec_prefixes = { 0, 0, "exec" };
1353 /* List of prefixes to try when looking for startup (crt0) files. */
1355 static struct path_prefix startfile_prefixes = { 0, 0, "startfile" };
1357 /* List of prefixes to try when looking for include files. */
1359 static struct path_prefix include_prefixes = { 0, 0, "include" };
1361 /* Suffix to attach to directories searched for commands.
1362 This looks like `MACHINE/VERSION/'. */
1364 static const char *machine_suffix = 0;
1366 /* Suffix to attach to directories searched for commands.
1367 This is just `MACHINE/'. */
1369 static const char *just_machine_suffix = 0;
1371 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1373 static const char *gcc_exec_prefix;
1375 /* Default prefixes to attach to command names. */
1377 #ifdef CROSS_COMPILE /* Don't use these prefixes for a cross compiler. */
1378 #undef MD_EXEC_PREFIX
1379 #undef MD_STARTFILE_PREFIX
1380 #undef MD_STARTFILE_PREFIX_1
1383 #ifndef STANDARD_EXEC_PREFIX
1384 #define STANDARD_EXEC_PREFIX "/usr/local/lib/gcc-lib/"
1385 #endif /* !defined STANDARD_EXEC_PREFIX */
1387 static const char *standard_exec_prefix = STANDARD_EXEC_PREFIX;
1388 static const char *standard_exec_prefix_1 = "/usr/lib/gcc/";
1389 #ifdef MD_EXEC_PREFIX
1390 static const char *md_exec_prefix = MD_EXEC_PREFIX;
1393 #ifndef STANDARD_STARTFILE_PREFIX
1394 #define STANDARD_STARTFILE_PREFIX "/usr/local/lib/"
1395 #endif /* !defined STANDARD_STARTFILE_PREFIX */
1397 #ifdef MD_STARTFILE_PREFIX
1398 static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1400 #ifdef MD_STARTFILE_PREFIX_1
1401 static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1403 static const char *standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1404 static const char *standard_startfile_prefix_1 = "/lib/";
1405 static const char *standard_startfile_prefix_2 = "/usr/lib/";
1407 #ifndef TOOLDIR_BASE_PREFIX
1408 #define TOOLDIR_BASE_PREFIX "/usr/local/"
1410 static const char *tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1411 static const char *tooldir_prefix;
1413 #ifndef STANDARD_BINDIR_PREFIX
1414 #define STANDARD_BINDIR_PREFIX "/usr/local/bin"
1416 static const char *standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
1418 /* Subdirectory to use for locating libraries. Set by
1419 set_multilib_dir based on the compilation options. */
1421 static const char *multilib_dir;
1423 /* Clear out the vector of arguments (after a command is executed). */
1431 /* Add one argument to the vector at the end.
1432 This is done when a space is seen or at the end of the line.
1433 If DELETE_ALWAYS is nonzero, the arg is a filename
1434 and the file should be deleted eventually.
1435 If DELETE_FAILURE is nonzero, the arg is a filename
1436 and the file should be deleted if this compilation fails. */
1439 store_arg (arg, delete_always, delete_failure)
1441 int delete_always, delete_failure;
1443 if (argbuf_index + 1 == argbuf_length)
1445 = (char **) xrealloc (argbuf, (argbuf_length *= 2) * sizeof (char *));
1447 argbuf[argbuf_index++] = arg;
1448 argbuf[argbuf_index] = 0;
1450 if (delete_always || delete_failure)
1451 record_temp_file (arg, delete_always, delete_failure);
1454 /* Load specs from a file name named FILENAME, replacing occurances of
1455 various different types of line-endings, \r\n, \n\r and just \r, with
1459 load_specs (filename)
1460 const char *filename;
1464 struct stat statbuf;
1471 notice ("Reading specs from %s\n", filename);
1473 /* Open and stat the file. */
1474 desc = open (filename, O_RDONLY, 0);
1476 pfatal_with_name (filename);
1477 if (stat (filename, &statbuf) < 0)
1478 pfatal_with_name (filename);
1480 /* Read contents of file into BUFFER. */
1481 buffer = xmalloc ((unsigned) statbuf.st_size + 1);
1482 readlen = read (desc, buffer, (unsigned) statbuf.st_size);
1484 pfatal_with_name (filename);
1485 buffer[readlen] = 0;
1488 specs = xmalloc (readlen + 1);
1490 for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
1496 if (buffer_p > buffer && *(buffer_p-1) == '\n') /* \n\r */
1498 else if (*(buffer_p+1) == '\n') /* \r\n */
1512 /* Read compilation specs from a file named FILENAME,
1513 replacing the default ones.
1515 A suffix which starts with `*' is a definition for
1516 one of the machine-specific sub-specs. The "suffix" should be
1517 *asm, *cc1, *cpp, *link, *startfile, *signed_char, etc.
1518 The corresponding spec is stored in asm_spec, etc.,
1519 rather than in the `compilers' vector.
1521 Anything invalid in the file is a fatal error. */
1524 read_specs (filename, main_p)
1525 const char *filename;
1531 buffer = load_specs (filename);
1533 /* Scan BUFFER for specs, putting them in the vector. */
1539 char *in, *out, *p1, *p2, *p3;
1541 /* Advance P in BUFFER to the next nonblank nocomment line. */
1542 p = skip_whitespace (p);
1546 /* Is this a special command that starts with '%'? */
1547 /* Don't allow this for the main specs file, since it would
1548 encourage people to overwrite it. */
1549 if (*p == '%' && !main_p)
1552 while (*p && *p != '\n')
1555 p++; /* Skip '\n' */
1557 if (!strncmp (p1, "%include", sizeof ("%include")-1)
1558 && (p1[sizeof "%include" - 1] == ' '
1559 || p1[sizeof "%include" - 1] == '\t'))
1563 p1 += sizeof ("%include");
1564 while (*p1 == ' ' || *p1 == '\t')
1567 if (*p1++ != '<' || p[-2] != '>')
1568 fatal ("specs %%include syntax malformed after %ld characters",
1569 (long) (p1 - buffer + 1));
1572 new_filename = find_a_file (&startfile_prefixes, p1, R_OK);
1573 read_specs (new_filename ? new_filename : p1, FALSE);
1576 else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
1577 && (p1[sizeof "%include_noerr" - 1] == ' '
1578 || p1[sizeof "%include_noerr" - 1] == '\t'))
1582 p1 += sizeof "%include_noerr";
1583 while (*p1 == ' ' || *p1 == '\t') p1++;
1585 if (*p1++ != '<' || p[-2] != '>')
1586 fatal ("specs %%include syntax malformed after %ld characters",
1587 (long) (p1 - buffer + 1));
1590 new_filename = find_a_file (&startfile_prefixes, p1, R_OK);
1592 read_specs (new_filename, FALSE);
1593 else if (verbose_flag)
1594 notice ("Could not find specs file %s\n", p1);
1597 else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
1598 && (p1[sizeof "%rename" - 1] == ' '
1599 || p1[sizeof "%rename" - 1] == '\t'))
1602 struct spec_list *sl;
1604 /* Get original name */
1605 p1 += sizeof "%rename";
1606 while (*p1 == ' ' || *p1 == '\t')
1609 if (! ISALPHA ((unsigned char)*p1))
1610 fatal ("specs %%rename syntax malformed after %ld characters",
1611 (long) (p1 - buffer));
1614 while (*p2 && !ISSPACE ((unsigned char)*p2))
1617 if (*p2 != ' ' && *p2 != '\t')
1618 fatal ("specs %%rename syntax malformed after %ld characters",
1619 (long) (p2 - buffer));
1623 while (*p2 == ' ' || *p2 == '\t')
1626 if (! ISALPHA ((unsigned char)*p2))
1627 fatal ("specs %%rename syntax malformed after %ld characters",
1628 (long) (p2 - buffer));
1630 /* Get new spec name */
1632 while (*p3 && !ISSPACE ((unsigned char)*p3))
1636 fatal ("specs %%rename syntax malformed after %ld characters",
1637 (long) (p3 - buffer));
1640 for (sl = specs; sl; sl = sl->next)
1641 if (name_len == sl->name_len && !strcmp (sl->name, p1))
1645 fatal ("specs %s spec was not found to be renamed", p1);
1647 if (strcmp (p1, p2) == 0)
1652 notice ("rename spec %s to %s\n", p1, p2);
1654 notice ("spec is '%s'\n\n", *(sl->ptr_spec));
1658 set_spec (p2, *(sl->ptr_spec));
1660 free ((PTR) *(sl->ptr_spec));
1662 *(sl->ptr_spec) = "";
1667 fatal ("specs unknown %% command after %ld characters",
1668 (long) (p1 - buffer));
1671 /* Find the colon that should end the suffix. */
1673 while (*p1 && *p1 != ':' && *p1 != '\n')
1676 /* The colon shouldn't be missing. */
1678 fatal ("specs file malformed after %ld characters",
1679 (long) (p1 - buffer));
1681 /* Skip back over trailing whitespace. */
1683 while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
1686 /* Copy the suffix to a string. */
1687 suffix = save_string (p, p2 - p);
1688 /* Find the next line. */
1689 p = skip_whitespace (p1 + 1);
1691 fatal ("specs file malformed after %ld characters",
1692 (long) (p - buffer));
1695 /* Find next blank line or end of string. */
1696 while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
1699 /* Specs end at the blank line and do not include the newline. */
1700 spec = save_string (p, p1 - p);
1703 /* Delete backslash-newline sequences from the spec. */
1708 if (in[0] == '\\' && in[1] == '\n')
1710 else if (in[0] == '#')
1711 while (*in && *in != '\n')
1719 if (suffix[0] == '*')
1721 if (! strcmp (suffix, "*link_command"))
1722 link_command_spec = spec;
1724 set_spec (suffix + 1, spec);
1728 /* Add this pair to the vector. */
1730 = ((struct compiler *)
1731 xrealloc (compilers,
1732 (n_compilers + 2) * sizeof (struct compiler)));
1734 compilers[n_compilers].suffix = suffix;
1735 memset (compilers[n_compilers].spec, 0,
1736 sizeof compilers[n_compilers].spec);
1737 compilers[n_compilers].spec[0] = spec;
1739 memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
1743 link_command_spec = spec;
1746 if (link_command_spec == 0)
1747 fatal ("spec file has no spec for linking");
1750 /* Record the names of temporary files we tell compilers to write,
1751 and delete them at the end of the run. */
1753 /* This is the common prefix we use to make temp file names.
1754 It is chosen once for each run of this program.
1755 It is substituted into a spec by %g.
1756 Thus, all temp file names contain this prefix.
1757 In practice, all temp file names start with this prefix.
1759 This prefix comes from the envvar TMPDIR if it is defined;
1760 otherwise, from the P_tmpdir macro if that is defined;
1761 otherwise, in /usr/tmp or /tmp;
1762 or finally the current directory if all else fails. */
1764 static const char *temp_filename;
1766 /* Length of the prefix. */
1768 static int temp_filename_length;
1770 /* Define the list of temporary files to delete. */
1775 struct temp_file *next;
1778 /* Queue of files to delete on success or failure of compilation. */
1779 static struct temp_file *always_delete_queue;
1780 /* Queue of files to delete on failure of compilation. */
1781 static struct temp_file *failure_delete_queue;
1783 /* Record FILENAME as a file to be deleted automatically.
1784 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
1785 otherwise delete it in any case.
1786 FAIL_DELETE nonzero means delete it if a compilation step fails;
1787 otherwise delete it in any case. */
1790 record_temp_file (filename, always_delete, fail_delete)
1791 const char *filename;
1795 register char * const name = xstrdup (filename);
1799 register struct temp_file *temp;
1800 for (temp = always_delete_queue; temp; temp = temp->next)
1801 if (! strcmp (name, temp->name))
1804 temp = (struct temp_file *) xmalloc (sizeof (struct temp_file));
1805 temp->next = always_delete_queue;
1807 always_delete_queue = temp;
1814 register struct temp_file *temp;
1815 for (temp = failure_delete_queue; temp; temp = temp->next)
1816 if (! strcmp (name, temp->name))
1819 temp = (struct temp_file *) xmalloc (sizeof (struct temp_file));
1820 temp->next = failure_delete_queue;
1822 failure_delete_queue = temp;
1828 /* Delete all the temporary files whose names we previously recorded. */
1831 delete_if_ordinary (name)
1838 printf ("Delete %s? (y or n) ", name);
1842 while ((c = getchar ()) != '\n' && c != EOF)
1845 if (i == 'y' || i == 'Y')
1847 if (stat (name, &st) >= 0 && S_ISREG (st.st_mode))
1848 if (unlink (name) < 0)
1850 perror_with_name (name);
1854 delete_temp_files ()
1856 register struct temp_file *temp;
1858 for (temp = always_delete_queue; temp; temp = temp->next)
1859 delete_if_ordinary (temp->name);
1860 always_delete_queue = 0;
1863 /* Delete all the files to be deleted on error. */
1866 delete_failure_queue ()
1868 register struct temp_file *temp;
1870 for (temp = failure_delete_queue; temp; temp = temp->next)
1871 delete_if_ordinary (temp->name);
1875 clear_failure_queue ()
1877 failure_delete_queue = 0;
1880 /* Routine to add variables to the environment. We do this to pass
1881 the pathname of the gcc driver, and the directories search to the
1882 collect2 program, which is being run as ld. This way, we can be
1883 sure of executing the right compiler when collect2 wants to build
1884 constructors and destructors. Since the environment variables we
1885 use come from an obstack, we don't have to worry about allocating
1894 #ifndef VMS /* nor about VMS */
1896 extern char **environ;
1897 char **old_environ = environ;
1901 int str_len = strlen (str);
1905 while ((ch = *p++) != '\0' && ch != '=')
1911 /* Search for replacing an existing environment variable, and
1912 count the number of total environment variables. */
1913 for (envp = old_environ; *envp; envp++)
1916 if (!strncmp (str, *envp, name_len))
1923 /* Add a new environment variable */
1924 environ = (char **) xmalloc (sizeof (char *) * (num_envs+2));
1926 memcpy ((char *) (environ + 1), (char *) old_environ,
1927 sizeof (char *) * (num_envs+1));
1932 #endif /* HAVE_PUTENV */
1935 /* Build a list of search directories from PATHS.
1936 PREFIX is a string to prepend to the list.
1937 If CHECK_DIR_P is non-zero we ensure the directory exists.
1938 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
1939 It is also used by the --print-search-dirs flag. */
1942 build_search_list (paths, prefix, check_dir_p)
1943 struct path_prefix *paths;
1947 int suffix_len = (machine_suffix) ? strlen (machine_suffix) : 0;
1949 = (just_machine_suffix) ? strlen (just_machine_suffix) : 0;
1950 int first_time = TRUE;
1951 struct prefix_list *pprefix;
1953 obstack_grow (&collect_obstack, prefix, strlen (prefix));
1954 obstack_1grow (&collect_obstack, '=');
1956 for (pprefix = paths->plist; pprefix != 0; pprefix = pprefix->next)
1958 int len = strlen (pprefix->prefix);
1962 || is_directory (pprefix->prefix, machine_suffix, 0)))
1965 obstack_1grow (&collect_obstack, PATH_SEPARATOR);
1968 obstack_grow (&collect_obstack, pprefix->prefix, len);
1969 obstack_grow (&collect_obstack, machine_suffix, suffix_len);
1972 if (just_machine_suffix
1973 && pprefix->require_machine_suffix == 2
1975 || is_directory (pprefix->prefix, just_machine_suffix, 0)))
1978 obstack_1grow (&collect_obstack, PATH_SEPARATOR);
1981 obstack_grow (&collect_obstack, pprefix->prefix, len);
1982 obstack_grow (&collect_obstack, just_machine_suffix,
1986 if (! pprefix->require_machine_suffix)
1989 obstack_1grow (&collect_obstack, PATH_SEPARATOR);
1992 obstack_grow (&collect_obstack, pprefix->prefix, len);
1996 obstack_1grow (&collect_obstack, '\0');
1997 return obstack_finish (&collect_obstack);
2000 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2004 putenv_from_prefixes (paths, env_var)
2005 struct path_prefix *paths;
2006 const char *env_var;
2008 putenv (build_search_list (paths, env_var, 1));
2013 /* FIXME: the location independence code for VMS is hairier than this,
2014 and hasn't been written. */
2016 /* Split a filename into component directories. */
2019 split_directories (name, ptr_num_dirs)
2028 /* Count the number of directories. Special case MSDOS disk names as part
2029 of the initial directory. */
2031 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2032 if (name[1] == ':' && IS_DIR_SEPARATOR (name[2]))
2037 #endif /* HAVE_DOS_BASED_FILE_SYSTEM */
2039 while ((ch = *p++) != '\0')
2041 if (IS_DIR_SEPARATOR (ch))
2044 while (IS_DIR_SEPARATOR (*p))
2049 dirs = (char **) xmalloc (sizeof (char *) * (num_dirs + 2));
2051 /* Now copy the directory parts. */
2054 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2055 if (name[1] == ':' && IS_DIR_SEPARATOR (name[2]))
2057 dirs[num_dirs++] = save_string (p, 3);
2060 #endif /* HAVE_DOS_BASED_FILE_SYSTEM */
2063 while ((ch = *p++) != '\0')
2065 if (IS_DIR_SEPARATOR (ch))
2067 while (IS_DIR_SEPARATOR (*p))
2070 dirs[num_dirs++] = save_string (q, p - q);
2076 dirs[num_dirs++] = save_string (q, p - 1 - q);
2078 dirs[num_dirs] = NULL_PTR;
2080 *ptr_num_dirs = num_dirs;
2085 /* Release storage held by split directories. */
2088 free_split_directories (dirs)
2093 while (dirs[i] != NULL_PTR)
2096 free ((char *)dirs);
2099 /* Given three strings PROGNAME, BIN_PREFIX, PREFIX, return a string that gets
2100 to PREFIX starting with the directory portion of PROGNAME and a relative
2101 pathname of the difference between BIN_PREFIX and PREFIX.
2103 For example, if BIN_PREFIX is /alpha/beta/gamma/gcc/delta, PREFIX is
2104 /alpha/beta/gamma/omega/, and PROGNAME is /red/green/blue/gcc, then this
2105 function will return /red/green/blue/../omega.
2107 If no relative prefix can be found, return NULL. */
2110 make_relative_prefix (progname, bin_prefix, prefix)
2111 const char *progname;
2112 const char *bin_prefix;
2115 char **prog_dirs, **bin_dirs, **prefix_dirs;
2116 int prog_num, bin_num, prefix_num, std_loc_p;
2119 prog_dirs = split_directories (progname, &prog_num);
2120 bin_dirs = split_directories (bin_prefix, &bin_num);
2122 /* If there is no full pathname, try to find the program by checking in each
2123 of the directories specified in the PATH environment variable. */
2128 GET_ENV_PATH_LIST (temp, "PATH");
2131 char *startp, *endp;
2132 char *nstore = (char *) alloca (strlen (temp) + strlen (progname) + 1);
2134 startp = endp = temp;
2137 if (*endp == PATH_SEPARATOR || *endp == 0)
2142 nstore[1] = DIR_SEPARATOR;
2147 strncpy (nstore, startp, endp-startp);
2148 if (! IS_DIR_SEPARATOR (endp[-1]))
2150 nstore[endp-startp] = DIR_SEPARATOR;
2151 nstore[endp-startp+1] = 0;
2154 nstore[endp-startp] = 0;
2156 strcat (nstore, progname);
2157 if (! access (nstore, X_OK)
2158 #ifdef HAVE_EXECUTABLE_SUFFIX
2159 || ! access (strcat (nstore, EXECUTABLE_SUFFIX), X_OK)
2163 free_split_directories (prog_dirs);
2165 prog_dirs = split_directories (progname, &prog_num);
2171 endp = startp = endp + 1;
2179 /* Remove the program name from comparison of directory names. */
2182 /* Determine if the compiler is installed in the standard location, and if
2183 so, we don't need to specify relative directories. Also, if argv[0]
2184 doesn't contain any directory specifiers, there is not much we can do. */
2186 if (prog_num == bin_num)
2188 for (i = 0; i < bin_num; i++)
2190 if (strcmp (prog_dirs[i], bin_dirs[i]) != 0)
2194 if (prog_num <= 0 || i == bin_num)
2197 free_split_directories (prog_dirs);
2198 free_split_directories (bin_dirs);
2199 prog_dirs = bin_dirs = (char **)0;
2204 prefix_dirs = split_directories (prefix, &prefix_num);
2206 /* Find how many directories are in common between bin_prefix & prefix. */
2207 n = (prefix_num < bin_num) ? prefix_num : bin_num;
2208 for (common = 0; common < n; common++)
2210 if (strcmp (bin_dirs[common], prefix_dirs[common]) != 0)
2214 /* If there are no common directories, there can be no relative prefix. */
2217 free_split_directories (prog_dirs);
2218 free_split_directories (bin_dirs);
2219 free_split_directories (prefix_dirs);
2223 /* Build up the pathnames in argv[0]. */
2224 for (i = 0; i < prog_num; i++)
2225 obstack_grow (&obstack, prog_dirs[i], strlen (prog_dirs[i]));
2227 /* Now build up the ..'s. */
2228 for (i = common; i < n; i++)
2230 obstack_grow (&obstack, DIR_UP, sizeof (DIR_UP)-1);
2231 obstack_1grow (&obstack, DIR_SEPARATOR);
2234 /* Put in directories to move over to prefix. */
2235 for (i = common; i < prefix_num; i++)
2236 obstack_grow (&obstack, prefix_dirs[i], strlen (prefix_dirs[i]));
2238 free_split_directories (prog_dirs);
2239 free_split_directories (bin_dirs);
2240 free_split_directories (prefix_dirs);
2242 obstack_1grow (&obstack, '\0');
2243 return obstack_finish (&obstack);
2247 /* Check whether NAME can be accessed in MODE. This is like access,
2248 except that it never considers directories to be executable. */
2251 access_check (name, mode)
2259 if (stat (name, &st) < 0
2260 || S_ISDIR (st.st_mode))
2264 return access (name, mode);
2267 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2268 access to check permissions.
2269 Return 0 if not found, otherwise return its name, allocated with malloc. */
2272 find_a_file (pprefix, name, mode)
2273 struct path_prefix *pprefix;
2278 const char *file_suffix = ((mode & X_OK) != 0 ? EXECUTABLE_SUFFIX : "");
2279 struct prefix_list *pl;
2280 int len = pprefix->max_len + strlen (name) + strlen (file_suffix) + 1;
2282 #ifdef DEFAULT_ASSEMBLER
2283 if (! strcmp(name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
2284 return xstrdup (DEFAULT_ASSEMBLER);
2287 #ifdef DEFAULT_LINKER
2288 if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0)
2289 return xstrdup (DEFAULT_LINKER);
2293 len += strlen (machine_suffix);
2295 temp = xmalloc (len);
2297 /* Determine the filename to execute (special case for absolute paths). */
2299 if (IS_DIR_SEPARATOR (*name)
2300 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2301 /* Check for disk name on MS-DOS-based systems. */
2302 || (name[0] && name[1] == ':' && IS_DIR_SEPARATOR (name[2]))
2306 if (access (name, mode) == 0)
2308 strcpy (temp, name);
2313 for (pl = pprefix->plist; pl; pl = pl->next)
2317 /* Some systems have a suffix for executable files.
2318 So try appending that first. */
2319 if (file_suffix[0] != 0)
2321 strcpy (temp, pl->prefix);
2322 strcat (temp, machine_suffix);
2323 strcat (temp, name);
2324 strcat (temp, file_suffix);
2325 if (access_check (temp, mode) == 0)
2327 if (pl->used_flag_ptr != 0)
2328 *pl->used_flag_ptr = 1;
2333 /* Now try just the name. */
2334 strcpy (temp, pl->prefix);
2335 strcat (temp, machine_suffix);
2336 strcat (temp, name);
2337 if (access_check (temp, mode) == 0)
2339 if (pl->used_flag_ptr != 0)
2340 *pl->used_flag_ptr = 1;
2345 /* Certain prefixes are tried with just the machine type,
2346 not the version. This is used for finding as, ld, etc. */
2347 if (just_machine_suffix && pl->require_machine_suffix == 2)
2349 /* Some systems have a suffix for executable files.
2350 So try appending that first. */
2351 if (file_suffix[0] != 0)
2353 strcpy (temp, pl->prefix);
2354 strcat (temp, just_machine_suffix);
2355 strcat (temp, name);
2356 strcat (temp, file_suffix);
2357 if (access_check (temp, mode) == 0)
2359 if (pl->used_flag_ptr != 0)
2360 *pl->used_flag_ptr = 1;
2365 strcpy (temp, pl->prefix);
2366 strcat (temp, just_machine_suffix);
2367 strcat (temp, name);
2368 if (access_check (temp, mode) == 0)
2370 if (pl->used_flag_ptr != 0)
2371 *pl->used_flag_ptr = 1;
2376 /* Certain prefixes can't be used without the machine suffix
2377 when the machine or version is explicitly specified. */
2378 if (! pl->require_machine_suffix)
2380 /* Some systems have a suffix for executable files.
2381 So try appending that first. */
2382 if (file_suffix[0] != 0)
2384 strcpy (temp, pl->prefix);
2385 strcat (temp, name);
2386 strcat (temp, file_suffix);
2387 if (access_check (temp, mode) == 0)
2389 if (pl->used_flag_ptr != 0)
2390 *pl->used_flag_ptr = 1;
2395 strcpy (temp, pl->prefix);
2396 strcat (temp, name);
2397 if (access_check (temp, mode) == 0)
2399 if (pl->used_flag_ptr != 0)
2400 *pl->used_flag_ptr = 1;
2410 /* Add an entry for PREFIX in PLIST. If FIRST is set, it goes
2411 at the start of the list, otherwise it goes at the end.
2413 If WARN is nonzero, we will warn if no file is found
2414 through this prefix. WARN should point to an int
2415 which will be set to 1 if this entry is used.
2417 COMPONENT is the value to be passed to update_path.
2419 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2420 the complete value of machine_suffix.
2421 2 means try both machine_suffix and just_machine_suffix. */
2424 add_prefix (pprefix, prefix, component, first, require_machine_suffix, warn)
2425 struct path_prefix *pprefix;
2427 const char *component;
2429 int require_machine_suffix;
2432 struct prefix_list *pl, **prev;
2435 if (! first && pprefix->plist)
2437 for (pl = pprefix->plist; pl->next; pl = pl->next)
2442 prev = &pprefix->plist;
2444 /* Keep track of the longest prefix */
2446 prefix = update_path (prefix, component);
2447 len = strlen (prefix);
2448 if (len > pprefix->max_len)
2449 pprefix->max_len = len;
2451 pl = (struct prefix_list *) xmalloc (sizeof (struct prefix_list));
2452 pl->prefix = save_string (prefix, len);
2453 pl->require_machine_suffix = require_machine_suffix;
2454 pl->used_flag_ptr = warn;
2461 pl->next = (struct prefix_list *) 0;
2465 /* Print warnings for any prefixes in the list PPREFIX that were not used. */
2468 unused_prefix_warnings (pprefix)
2469 struct path_prefix *pprefix;
2471 struct prefix_list *pl = pprefix->plist;
2475 if (pl->used_flag_ptr != 0 && !*pl->used_flag_ptr)
2477 if (pl->require_machine_suffix && machine_suffix)
2478 error ("file path prefix `%s%s' never used", pl->prefix,
2481 error ("file path prefix `%s' never used", pl->prefix);
2483 /* Prevent duplicate warnings. */
2484 *pl->used_flag_ptr = 1;
2492 /* Execute the command specified by the arguments on the current line of spec.
2493 When using pipes, this includes several piped-together commands
2494 with `|' between them.
2496 Return 0 if successful, -1 if failed. */
2502 int n_commands; /* # of command. */
2506 const char *prog; /* program name. */
2507 char **argv; /* vector of args. */
2508 int pid; /* pid of process for this command. */
2511 struct command *commands; /* each command buffer with above info. */
2513 /* Count # of piped commands. */
2514 for (n_commands = 1, i = 0; i < argbuf_index; i++)
2515 if (strcmp (argbuf[i], "|") == 0)
2518 /* Get storage for each command. */
2520 = (struct command *) alloca (n_commands * sizeof (struct command));
2522 /* Split argbuf into its separate piped processes,
2523 and record info about each one.
2524 Also search for the programs that are to be run. */
2526 commands[0].prog = argbuf[0]; /* first command. */
2527 commands[0].argv = &argbuf[0];
2528 string = find_a_file (&exec_prefixes, commands[0].prog, X_OK);
2531 commands[0].argv[0] = string;
2533 for (n_commands = 1, i = 0; i < argbuf_index; i++)
2534 if (strcmp (argbuf[i], "|") == 0)
2535 { /* each command. */
2536 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2537 fatal ("-pipe not supported");
2539 argbuf[i] = 0; /* termination of command args. */
2540 commands[n_commands].prog = argbuf[i + 1];
2541 commands[n_commands].argv = &argbuf[i + 1];
2542 string = find_a_file (&exec_prefixes, commands[n_commands].prog, X_OK);
2544 commands[n_commands].argv[0] = string;
2548 argbuf[argbuf_index] = 0;
2550 /* If -v, print what we are about to do, and maybe query. */
2554 /* For help listings, put a blank line between sub-processes. */
2555 if (print_help_list)
2556 fputc ('\n', stderr);
2558 /* Print each piped command as a separate line. */
2559 for (i = 0; i < n_commands ; i++)
2563 for (j = commands[i].argv; *j; j++)
2564 fprintf (stderr, " %s", *j);
2566 /* Print a pipe symbol after all but the last command. */
2567 if (i + 1 != n_commands)
2568 fprintf (stderr, " |");
2569 fprintf (stderr, "\n");
2573 notice ("\nGo ahead? (y or n) ");
2577 while (getchar () != '\n')
2580 if (i != 'y' && i != 'Y')
2585 /* Run each piped subprocess. */
2587 for (i = 0; i < n_commands; i++)
2589 char *errmsg_fmt, *errmsg_arg;
2590 char *string = commands[i].argv[0];
2592 commands[i].pid = pexecute (string, commands[i].argv,
2593 programname, temp_filename,
2594 &errmsg_fmt, &errmsg_arg,
2595 ((i == 0 ? PEXECUTE_FIRST : 0)
2596 | (i + 1 == n_commands ? PEXECUTE_LAST : 0)
2597 | (string == commands[i].prog
2598 ? PEXECUTE_SEARCH : 0)
2599 | (verbose_flag ? PEXECUTE_VERBOSE : 0)));
2601 if (commands[i].pid == -1)
2602 pfatal_pexecute (errmsg_fmt, errmsg_arg);
2604 if (string != commands[i].prog)
2610 /* Wait for all the subprocesses to finish.
2611 We don't care what order they finish in;
2612 we know that N_COMMANDS waits will get them all.
2613 Ignore subprocesses that we don't know about,
2614 since they can be spawned by the process that exec'ed us. */
2618 #ifdef HAVE_GETRUSAGE
2620 double ut = 0.0, st = 0.0;
2623 for (i = 0; i < n_commands; )
2629 pid = pwait (commands[i].pid, &status, 0);
2633 #ifdef HAVE_GETRUSAGE
2636 /* getrusage returns the total resource usage of all children
2637 up to now. Copy the previous values into prus, get the
2638 current statistics, then take the difference. */
2641 getrusage (RUSAGE_CHILDREN, &rus);
2642 d.tv_sec = rus.ru_utime.tv_sec - prus.ru_utime.tv_sec;
2643 d.tv_usec = rus.ru_utime.tv_usec - prus.ru_utime.tv_usec;
2644 ut = (double)d.tv_sec + (double)d.tv_usec / 1.0e6;
2646 d.tv_sec = rus.ru_stime.tv_sec - prus.ru_stime.tv_sec;
2647 d.tv_usec = rus.ru_stime.tv_usec - prus.ru_stime.tv_usec;
2648 st = (double)d.tv_sec + (double)d.tv_usec / 1.0e6;
2652 for (j = 0; j < n_commands; j++)
2653 if (commands[j].pid == pid)
2658 if (WIFSIGNALED (status))
2660 fatal ("Internal compiler error: program %s got fatal signal %d",
2661 commands[j].prog, WTERMSIG (status));
2665 else if (WIFEXITED (status)
2666 && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
2668 if (WEXITSTATUS (status) > greatest_status)
2669 greatest_status = WEXITSTATUS (status);
2673 #ifdef HAVE_GETRUSAGE
2674 if (report_times && ut + st != 0)
2675 notice ("# %s %.2f %.2f\n", commands[j].prog, ut, st);
2684 /* Find all the switches given to us
2685 and make a vector describing them.
2686 The elements of the vector are strings, one per switch given.
2687 If a switch uses following arguments, then the `part1' field
2688 is the switch itself and the `args' field
2689 is a null-terminated vector containing the following arguments.
2690 The `live_cond' field is:
2692 1 if the switch is true in a conditional spec,
2693 -1 if false (overridden by a later switch)
2694 -2 if this switch should be ignored (used in %{<S})
2695 The `validated' field is nonzero if any spec has looked at this switch;
2696 if it remains zero at the end of the run, it must be meaningless. */
2699 #define SWITCH_FALSE -1
2700 #define SWITCH_IGNORE -2
2701 #define SWITCH_LIVE 1
2711 static struct switchstr *switches;
2713 static int n_switches;
2718 const char *language;
2721 /* Also a vector of input files specified. */
2723 static struct infile *infiles;
2725 static int n_infiles;
2727 /* This counts the number of libraries added by lang_specific_driver, so that
2728 we can tell if there were any user supplied any files or libraries. */
2730 static int added_libraries;
2732 /* And a vector of corresponding output files is made up later. */
2734 static const char **outfiles;
2736 /* Used to track if none of the -B paths are used. */
2739 /* Used to track if standard path isn't used and -b or -V is specified. */
2740 static int warn_std;
2742 /* Gives value to pass as "warn" to add_prefix for standard prefixes. */
2743 static int *warn_std_ptr = 0;
2746 #if defined(HAVE_OBJECT_SUFFIX) || defined(HAVE_EXECUTABLE_SUFFIX)
2748 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
2749 is true if we should look for an executable suffix as well. */
2752 convert_filename (name, do_exe)
2762 len = strlen (name);
2764 #ifdef HAVE_OBJECT_SUFFIX
2765 /* Convert x.o to x.obj if OBJECT_SUFFIX is ".obj". */
2767 && name[len - 2] == '.'
2768 && name[len - 1] == 'o')
2770 obstack_grow (&obstack, name, len - 2);
2771 obstack_grow0 (&obstack, OBJECT_SUFFIX, strlen (OBJECT_SUFFIX));
2772 name = obstack_finish (&obstack);
2776 #ifdef HAVE_EXECUTABLE_SUFFIX
2777 /* If there is no filetype, make it the executable suffix (which includes
2778 the "."). But don't get confused if we have just "-o". */
2779 if (! do_exe || EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
2782 for (i = len - 1; i >= 0; i--)
2783 if (IS_DIR_SEPARATOR (name[i]))
2786 for (i++; i < len; i++)
2790 obstack_grow (&obstack, name, len);
2791 obstack_grow0 (&obstack, EXECUTABLE_SUFFIX, strlen (EXECUTABLE_SUFFIX));
2792 name = obstack_finish (&obstack);
2799 /* Display the command line switches accepted by gcc. */
2803 printf ("Usage: %s [options] file...\n", programname);
2804 printf ("Options:\n");
2806 printf (" -pass-exit-codes Exit with highest error code from a phase\n");
2807 printf (" --help Display this information\n");
2809 printf (" (Use '-v --help' to display command line options of sub-processes)\n");
2810 printf (" -dumpspecs Display all of the built in spec strings\n");
2811 printf (" -dumpversion Display the version of the compiler\n");
2812 printf (" -dumpmachine Display the compiler's target processor\n");
2813 printf (" -print-search-dirs Display the directories in the compiler's search path\n");
2814 printf (" -print-libgcc-file-name Display the name of the compiler's companion library\n");
2815 printf (" -print-file-name=<lib> Display the full path to library <lib>\n");
2816 printf (" -print-prog-name=<prog> Display the full path to compiler component <prog>\n");
2817 printf (" -print-multi-directory Display the root directory for versions of libgcc\n");
2818 printf (" -print-multi-lib Display the mapping between command line options and\n");
2819 printf (" multiple library search directories\n");
2820 printf (" -Wa,<options> Pass comma-separated <options> on to the assembler\n");
2821 printf (" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n");
2822 printf (" -Wl,<options> Pass comma-separated <options> on to the linker\n");
2823 printf (" -Xlinker <arg> Pass <arg> on to the linker\n");
2824 printf (" -save-temps Do not delete intermediate files\n");
2825 printf (" -pipe Use pipes rather than intermediate files\n");
2826 printf (" -time Time the execution of each subprocess\n");
2827 printf (" -specs=<file> Override builtin specs with the contents of <file>\n");
2828 printf (" -std=<standard> Assume that the input sources are for <standard>\n");
2829 printf (" -B <directory> Add <directory> to the compiler's search paths\n");
2830 printf (" -b <machine> Run gcc for target <machine>, if installed\n");
2831 printf (" -V <version> Run gcc version number <version>, if installed\n");
2832 printf (" -v Display the programs invoked by the compiler\n");
2833 printf (" -E Preprocess only; do not compile, assemble or link\n");
2834 printf (" -S Compile only; do not assemble or link\n");
2835 printf (" -c Compile and assemble, but do not link\n");
2836 printf (" -o <file> Place the output into <file>\n");
2837 printf (" -x <language> Specify the language of the following input files\n");
2838 printf (" Permissable languages include: c c++ assembler none\n");
2839 printf (" 'none' means revert to the default behaviour of\n");
2840 printf (" guessing the language based on the file's extension\n");
2842 printf ("\nOptions starting with -g, -f, -m, -O or -W are automatically passed on to\n");
2843 printf ("the various sub-processes invoked by %s. In order to pass other options\n",
2845 printf ("on to these processes the -W<letter> options must be used.\n");
2847 /* The rest of the options are displayed by invocations of the various
2852 add_preprocessor_option (option, len)
2853 const char * option;
2856 n_preprocessor_options++;
2858 if (! preprocessor_options)
2859 preprocessor_options
2860 = (char **) xmalloc (n_preprocessor_options * sizeof (char *));
2862 preprocessor_options
2863 = (char **) xrealloc (preprocessor_options,
2864 n_preprocessor_options * sizeof (char *));
2866 preprocessor_options [n_preprocessor_options - 1] =
2867 save_string (option, len);
2871 add_assembler_option (option, len)
2872 const char * option;
2875 n_assembler_options++;
2877 if (! assembler_options)
2879 = (char **) xmalloc (n_assembler_options * sizeof (char *));
2882 = (char **) xrealloc (assembler_options,
2883 n_assembler_options * sizeof (char *));
2885 assembler_options [n_assembler_options - 1] = save_string (option, len);
2889 add_linker_option (option, len)
2890 const char * option;
2895 if (! linker_options)
2897 = (char **) xmalloc (n_linker_options * sizeof (char *));
2900 = (char **) xrealloc (linker_options,
2901 n_linker_options * sizeof (char *));
2903 linker_options [n_linker_options - 1] = save_string (option, len);
2906 /* Create the vector `switches' and its contents.
2907 Store its length in `n_switches'. */
2910 process_command (argc, argv)
2917 char *spec_lang = 0;
2918 int last_language_n_infiles;
2921 int lang_n_infiles = 0;
2923 GET_ENV_PATH_LIST (gcc_exec_prefix, "GCC_EXEC_PREFIX");
2927 added_libraries = 0;
2929 /* Figure compiler version from version string. */
2931 compiler_version = temp1 = xstrdup (version_string);
2933 for (; *temp1; ++temp1)
2942 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
2943 see if we can create it from the pathname specified in argv[0]. */
2946 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
2947 if (!gcc_exec_prefix)
2949 gcc_exec_prefix = make_relative_prefix (argv[0], standard_bindir_prefix,
2950 standard_exec_prefix);
2951 if (gcc_exec_prefix)
2952 putenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL_PTR));
2956 if (gcc_exec_prefix)
2958 int len = strlen (gcc_exec_prefix);
2959 if (len > (int) sizeof ("/lib/gcc-lib/")-1
2960 && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
2962 temp = gcc_exec_prefix + len - sizeof ("/lib/gcc-lib/") + 1;
2963 if (IS_DIR_SEPARATOR (*temp)
2964 && strncmp (temp+1, "lib", 3) == 0
2965 && IS_DIR_SEPARATOR (temp[4])
2966 && strncmp (temp+5, "gcc-lib", 7) == 0)
2967 len -= sizeof ("/lib/gcc-lib/") - 1;
2970 set_std_prefix (gcc_exec_prefix, len);
2971 add_prefix (&exec_prefixes, gcc_exec_prefix, "GCC", 0, 0, NULL_PTR);
2972 add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC", 0, 0, NULL_PTR);
2975 /* COMPILER_PATH and LIBRARY_PATH have values
2976 that are lists of directory names with colons. */
2978 GET_ENV_PATH_LIST (temp, "COMPILER_PATH");
2981 const char *startp, *endp;
2982 char *nstore = (char *) alloca (strlen (temp) + 3);
2984 startp = endp = temp;
2987 if (*endp == PATH_SEPARATOR || *endp == 0)
2989 strncpy (nstore, startp, endp-startp);
2991 strcpy (nstore, concat (".", dir_separator_str, NULL_PTR));
2992 else if (!IS_DIR_SEPARATOR (endp[-1]))
2994 nstore[endp-startp] = DIR_SEPARATOR;
2995 nstore[endp-startp+1] = 0;
2998 nstore[endp-startp] = 0;
2999 add_prefix (&exec_prefixes, nstore, 0, 0, 0, NULL_PTR);
3000 add_prefix (&include_prefixes,
3001 concat (nstore, "include", NULL_PTR),
3005 endp = startp = endp + 1;
3012 GET_ENV_PATH_LIST (temp, LIBRARY_PATH_ENV);
3013 if (temp && *cross_compile == '0')
3015 const char *startp, *endp;
3016 char *nstore = (char *) alloca (strlen (temp) + 3);
3018 startp = endp = temp;
3021 if (*endp == PATH_SEPARATOR || *endp == 0)
3023 strncpy (nstore, startp, endp-startp);
3025 strcpy (nstore, concat (".", dir_separator_str, NULL_PTR));
3026 else if (!IS_DIR_SEPARATOR (endp[-1]))
3028 nstore[endp-startp] = DIR_SEPARATOR;
3029 nstore[endp-startp+1] = 0;
3032 nstore[endp-startp] = 0;
3033 add_prefix (&startfile_prefixes, nstore, NULL_PTR,
3037 endp = startp = endp + 1;
3044 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
3045 GET_ENV_PATH_LIST (temp, "LPATH");
3046 if (temp && *cross_compile == '0')
3048 const char *startp, *endp;
3049 char *nstore = (char *) alloca (strlen (temp) + 3);
3051 startp = endp = temp;
3054 if (*endp == PATH_SEPARATOR || *endp == 0)
3056 strncpy (nstore, startp, endp-startp);
3058 strcpy (nstore, concat (".", dir_separator_str, NULL_PTR));
3059 else if (!IS_DIR_SEPARATOR (endp[-1]))
3061 nstore[endp-startp] = DIR_SEPARATOR;
3062 nstore[endp-startp+1] = 0;
3065 nstore[endp-startp] = 0;
3066 add_prefix (&startfile_prefixes, nstore, NULL_PTR,
3070 endp = startp = endp + 1;
3077 /* Convert new-style -- options to old-style. */
3078 translate_options (&argc, &argv);
3080 /* Do language-specific adjustment/addition of flags. */
3081 lang_specific_driver (&argc, &argv, &added_libraries);
3083 /* Scan argv twice. Here, the first time, just count how many switches
3084 there will be in their vector, and how many input files in theirs.
3085 Here we also parse the switches that cc itself uses (e.g. -v). */
3087 for (i = 1; i < argc; i++)
3089 if (! strcmp (argv[i], "-dumpspecs"))
3091 struct spec_list *sl;
3093 for (sl = specs; sl; sl = sl->next)
3094 printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3095 if (link_command_spec)
3096 printf ("*link_command:\n%s\n\n", link_command_spec);
3099 else if (! strcmp (argv[i], "-dumpversion"))
3101 printf ("%s\n", spec_version);
3104 else if (! strcmp (argv[i], "-dumpmachine"))
3106 printf ("%s\n", spec_machine);
3109 else if (strcmp (argv[i], "-fhelp") == 0)
3111 /* translate_options () has turned --help into -fhelp. */
3112 print_help_list = 1;
3114 /* We will be passing a dummy file on to the sub-processes. */
3118 add_preprocessor_option ("--help", 6);
3119 add_assembler_option ("--help", 6);
3120 add_linker_option ("--help", 6);
3122 else if (! strcmp (argv[i], "-pass-exit-codes"))
3124 pass_exit_codes = 1;
3127 else if (! strcmp (argv[i], "-print-search-dirs"))
3128 print_search_dirs = 1;
3129 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3130 print_file_name = "libgcc.a";
3131 else if (! strncmp (argv[i], "-print-file-name=", 17))
3132 print_file_name = argv[i] + 17;
3133 else if (! strncmp (argv[i], "-print-prog-name=", 17))
3134 print_prog_name = argv[i] + 17;
3135 else if (! strcmp (argv[i], "-print-multi-lib"))
3136 print_multi_lib = 1;
3137 else if (! strcmp (argv[i], "-print-multi-directory"))
3138 print_multi_directory = 1;
3139 else if (! strncmp (argv[i], "-Wa,", 4))
3142 /* Pass the rest of this option to the assembler. */
3144 /* Split the argument at commas. */
3146 for (j = 4; argv[i][j]; j++)
3147 if (argv[i][j] == ',')
3149 add_assembler_option (argv[i] + prev, j - prev);
3153 /* Record the part after the last comma. */
3154 add_assembler_option (argv[i] + prev, j - prev);
3156 else if (! strncmp (argv[i], "-Wp,", 4))
3159 /* Pass the rest of this option to the preprocessor. */
3161 /* Split the argument at commas. */
3163 for (j = 4; argv[i][j]; j++)
3164 if (argv[i][j] == ',')
3166 add_preprocessor_option (argv[i] + prev, j - prev);
3170 /* Record the part after the last comma. */
3171 add_preprocessor_option (argv[i] + prev, j - prev);
3173 else if (argv[i][0] == '+' && argv[i][1] == 'e')
3174 /* The +e options to the C++ front-end. */
3176 else if (strncmp (argv[i], "-Wl,", 4) == 0)
3179 /* Split the argument at commas. */
3180 for (j = 3; argv[i][j]; j++)
3181 n_infiles += (argv[i][j] == ',');
3183 else if (strcmp (argv[i], "-Xlinker") == 0)
3186 fatal ("argument to `-Xlinker' is missing");
3191 else if (strncmp (argv[i], "-l", 2) == 0)
3193 else if (strcmp (argv[i], "-save-temps") == 0)
3195 save_temps_flag = 1;
3198 else if (strcmp (argv[i], "-specs") == 0)
3200 struct user_specs *user = (struct user_specs *)
3201 xmalloc (sizeof (struct user_specs));
3203 fatal ("argument to `-specs' is missing");
3205 user->next = (struct user_specs *)0;
3206 user->filename = argv[i];
3207 if (user_specs_tail)
3208 user_specs_tail->next = user;
3210 user_specs_head = user;
3211 user_specs_tail = user;
3213 else if (strncmp (argv[i], "-specs=", 7) == 0)
3215 struct user_specs *user = (struct user_specs *)
3216 xmalloc (sizeof (struct user_specs));
3217 if (strlen (argv[i]) == 7)
3218 fatal ("argument to `-specs=' is missing");
3220 user->next = (struct user_specs *)0;
3221 user->filename = argv[i]+7;
3222 if (user_specs_tail)
3223 user_specs_tail->next = user;
3225 user_specs_head = user;
3226 user_specs_tail = user;
3228 else if (strcmp (argv[i], "-time") == 0)
3230 else if (argv[i][0] == '-' && argv[i][1] != 0)
3232 register char *p = &argv[i][1];
3233 register int c = *p;
3239 if (p[1] == 0 && i + 1 == argc)
3240 fatal ("argument to `-b' is missing");
3242 spec_machine = argv[++i];
3244 spec_machine = p + 1;
3246 warn_std_ptr = &warn_std;
3252 if (p[1] == 0 && i + 1 == argc)
3253 fatal ("argument to `-B' is missing");
3258 add_prefix (&exec_prefixes, value, NULL_PTR, 1, 0, &warn_B);
3259 add_prefix (&startfile_prefixes, value, NULL_PTR,
3261 add_prefix (&include_prefixes, concat (value, "include",
3263 NULL_PTR, 1, 0, NULL_PTR);
3265 /* As a kludge, if the arg is "[foo/]stageN/", just add
3266 "[foo/]include" to the include prefix. */
3268 int len = strlen (value);
3271 && (IS_DIR_SEPARATOR (value[len - 8]))))
3272 && strncmp (value + len - 7, "stage", 5) == 0
3273 && ISDIGIT (value[len - 2])
3274 && (IS_DIR_SEPARATOR (value[len - 1])))
3277 add_prefix (&include_prefixes, "include", NULL_PTR,
3281 char *string = xmalloc (len + 1);
3282 strncpy (string, value, len-7);
3283 strcpy (string+len-7, "include");
3284 add_prefix (&include_prefixes, string, NULL_PTR,
3293 case 'v': /* Print our subcommands and print versions. */
3295 /* If they do anything other than exactly `-v', don't set
3296 verbose_flag; rather, continue on to give the error. */
3304 if (p[1] == 0 && i + 1 == argc)
3305 fatal ("argument to `-V' is missing");
3307 spec_version = argv[++i];
3309 spec_version = p + 1;
3310 compiler_version = spec_version;
3311 warn_std_ptr = &warn_std;
3313 /* Validate the version number. Use the same checks
3314 done when inserting it into a spec.
3316 The format of the version string is
3317 ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)? */
3319 const char *v = compiler_version;
3321 /* Ignore leading non-digits. i.e. "foo-" in "foo-2.7.2". */
3322 while (! ISDIGIT (*v))
3325 if (v > compiler_version && v[-1] != '-')
3326 fatal ("invalid version number format");
3328 /* Set V after the first period. */
3329 while (ISDIGIT (*v))
3333 fatal ("invalid version number format");
3336 while (ISDIGIT (*v))
3339 if (*v != 0 && *v != ' ' && *v != '.' && *v != '-')
3340 fatal ("invalid version number format");
3356 #if defined(HAVE_EXECUTABLE_SUFFIX)
3361 /* Forward scan, just in case -S or -c is specified
3368 if (argv[j][0] == '-')
3370 if (SWITCH_CURTAILS_COMPILATION (argv[j][1])
3376 else if (skip = SWITCH_TAKES_ARG (argv[j][1]))
3377 j += skip - (argv[j][2] != 0);
3378 else if (skip = WORD_SWITCH_TAKES_ARG (argv[j] + 1))
3385 #if defined(HAVE_EXECUTABLE_SUFFIX) || defined(HAVE_OBJECT_SUFFIX)
3387 argv[i+1] = convert_filename (argv[i+1], ! have_c);
3389 argv[i] = convert_filename (argv[i], ! have_c);
3397 if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
3398 i += SWITCH_TAKES_ARG (c) - (p[1] != 0);
3399 else if (WORD_SWITCH_TAKES_ARG (p))
3400 i += WORD_SWITCH_TAKES_ARG (p);
3410 if (have_c && have_o && lang_n_infiles > 1)
3411 fatal ("cannot specify -o with -c or -S and multiple compilations");
3413 /* Set up the search paths before we go looking for config files. */
3415 /* These come before the md prefixes so that we will find gcc's subcommands
3416 (such as cpp) rather than those of the host system. */
3417 /* Use 2 as fourth arg meaning try just the machine as a suffix,
3418 as well as trying the machine and the version. */
3420 add_prefix (&exec_prefixes, standard_exec_prefix, "GCC",
3421 0, 1, warn_std_ptr);
3422 add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
3423 0, 2, warn_std_ptr);
3424 add_prefix (&exec_prefixes, standard_exec_prefix_1, "BINUTILS",
3425 0, 2, warn_std_ptr);
3428 add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
3429 0, 1, warn_std_ptr);
3430 add_prefix (&startfile_prefixes, standard_exec_prefix_1, "BINUTILS",
3431 0, 1, warn_std_ptr);
3433 tooldir_prefix = concat (tooldir_base_prefix, spec_machine,
3434 dir_separator_str, NULL_PTR);
3436 /* If tooldir is relative, base it on exec_prefixes. A relative
3437 tooldir lets us move the installed tree as a unit.
3439 If GCC_EXEC_PREFIX is defined, then we want to add two relative
3440 directories, so that we can search both the user specified directory
3441 and the standard place. */
3443 if (!IS_DIR_SEPARATOR (*tooldir_prefix))
3445 if (gcc_exec_prefix)
3447 char *gcc_exec_tooldir_prefix
3448 = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
3449 spec_version, dir_separator_str, tooldir_prefix, NULL_PTR);
3451 add_prefix (&exec_prefixes,
3452 concat (gcc_exec_tooldir_prefix, "bin",
3453 dir_separator_str, NULL_PTR),
3454 NULL_PTR, 0, 0, NULL_PTR);
3455 add_prefix (&startfile_prefixes,
3456 concat (gcc_exec_tooldir_prefix, "lib",
3457 dir_separator_str, NULL_PTR),
3458 NULL_PTR, 0, 0, NULL_PTR);
3461 tooldir_prefix = concat (standard_exec_prefix, spec_machine,
3462 dir_separator_str, spec_version,
3463 dir_separator_str, tooldir_prefix, NULL_PTR);
3466 add_prefix (&exec_prefixes,
3467 concat (tooldir_prefix, "bin", dir_separator_str, NULL_PTR),
3468 "BINUTILS", 0, 0, NULL_PTR);
3469 add_prefix (&startfile_prefixes,
3470 concat (tooldir_prefix, "lib", dir_separator_str, NULL_PTR),
3471 "BINUTILS", 0, 0, NULL_PTR);
3473 /* More prefixes are enabled in main, after we read the specs file
3474 and determine whether this is cross-compilation or not. */
3477 /* Then create the space for the vectors and scan again. */
3479 switches = ((struct switchstr *)
3480 xmalloc ((n_switches + 1) * sizeof (struct switchstr)));
3481 infiles = (struct infile *) xmalloc ((n_infiles + 1) * sizeof (struct infile));
3484 last_language_n_infiles = -1;
3486 /* This, time, copy the text of each switch and store a pointer
3487 to the copy in the vector of switches.
3488 Store all the infiles in their vector. */
3490 for (i = 1; i < argc; i++)
3492 /* Just skip the switches that were handled by the preceding loop. */
3493 if (! strncmp (argv[i], "-Wa,", 4))
3495 else if (! strncmp (argv[i], "-Wp,", 4))
3497 else if (! strcmp (argv[i], "-pass-exit-codes"))
3499 else if (! strcmp (argv[i], "-print-search-dirs"))
3501 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3503 else if (! strncmp (argv[i], "-print-file-name=", 17))
3505 else if (! strncmp (argv[i], "-print-prog-name=", 17))
3507 else if (! strcmp (argv[i], "-print-multi-lib"))
3509 else if (! strcmp (argv[i], "-print-multi-directory"))
3511 else if (strcmp (argv[i], "-fhelp") == 0)
3515 /* Create a dummy input file, so that we can pass --help on to
3516 the various sub-processes. */
3517 infiles[n_infiles].language = "c";
3518 infiles[n_infiles++].name = "help-dummy";
3520 /* Preserve the --help switch so that it can be caught by the
3522 switches[n_switches].part1 = "--help";
3523 switches[n_switches].args = 0;
3524 switches[n_switches].live_cond = SWITCH_OK;
3525 switches[n_switches].validated = 0;
3530 else if (argv[i][0] == '+' && argv[i][1] == 'e')
3532 /* Compensate for the +e options to the C++ front-end;
3533 they're there simply for cfront call-compatibility. We do
3534 some magic in default_compilers to pass them down properly.
3535 Note we deliberately start at the `+' here, to avoid passing
3536 -e0 or -e1 down into the linker. */
3537 switches[n_switches].part1 = &argv[i][0];
3538 switches[n_switches].args = 0;
3539 switches[n_switches].live_cond = SWITCH_OK;
3540 switches[n_switches].validated = 0;
3543 else if (strncmp (argv[i], "-Wl,", 4) == 0)
3546 /* Split the argument at commas. */
3548 for (j = 4; argv[i][j]; j++)
3549 if (argv[i][j] == ',')
3551 infiles[n_infiles].language = "*";
3552 infiles[n_infiles++].name
3553 = save_string (argv[i] + prev, j - prev);
3556 /* Record the part after the last comma. */
3557 infiles[n_infiles].language = "*";
3558 infiles[n_infiles++].name = argv[i] + prev;
3560 else if (strcmp (argv[i], "-Xlinker") == 0)
3562 infiles[n_infiles].language = "*";
3563 infiles[n_infiles++].name = argv[++i];
3565 else if (strncmp (argv[i], "-l", 2) == 0)
3567 infiles[n_infiles].language = "*";
3568 infiles[n_infiles++].name = argv[i];
3570 else if (strcmp (argv[i], "-specs") == 0)
3572 else if (strncmp (argv[i], "-specs=", 7) == 0)
3574 else if (strcmp (argv[i], "-time") == 0)
3576 else if ((save_temps_flag || report_times)
3577 && strcmp (argv[i], "-pipe") == 0)
3579 /* -save-temps overrides -pipe, so that temp files are produced */
3580 if (save_temps_flag)
3581 error ("Warning: -pipe ignored since -save-temps specified");
3582 /* -time overrides -pipe because we can't get correct stats when
3583 multiple children are running at once. */
3584 else if (report_times)
3585 error ("Warning: -pipe ignored since -time specified");
3587 else if (argv[i][0] == '-' && argv[i][1] != 0)
3589 register char *p = &argv[i][1];
3590 register int c = *p;
3594 if (p[1] == 0 && i + 1 == argc)
3595 fatal ("argument to `-x' is missing");
3597 spec_lang = argv[++i];
3600 if (! strcmp (spec_lang, "none"))
3601 /* Suppress the warning if -xnone comes after the last input
3602 file, because alternate command interfaces like g++ might
3603 find it useful to place -xnone after each input file. */
3606 last_language_n_infiles = n_infiles;
3609 switches[n_switches].part1 = p;
3610 /* Deal with option arguments in separate argv elements. */
3611 if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
3612 || WORD_SWITCH_TAKES_ARG (p))
3615 int n_args = WORD_SWITCH_TAKES_ARG (p);
3619 /* Count only the option arguments in separate argv elements. */
3620 n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
3622 if (i + n_args >= argc)
3623 fatal ("argument to `-%s' is missing", p);
3624 switches[n_switches].args
3625 = (char **) xmalloc ((n_args + 1) * sizeof (char *));
3627 switches[n_switches].args[j++] = argv[++i];
3628 /* Null-terminate the vector. */
3629 switches[n_switches].args[j] = 0;
3631 else if (index (switches_need_spaces, c))
3633 /* On some systems, ld cannot handle some options without
3634 a space. So split the option from its argument. */
3635 char *part1 = (char *) xmalloc (2);
3639 switches[n_switches].part1 = part1;
3640 switches[n_switches].args = (char **) xmalloc (2 * sizeof (char *));
3641 switches[n_switches].args[0] = xmalloc (strlen (p));
3642 strcpy (switches[n_switches].args[0], &p[1]);
3643 switches[n_switches].args[1] = 0;
3646 switches[n_switches].args = 0;
3648 switches[n_switches].live_cond = SWITCH_OK;
3649 switches[n_switches].validated = 0;
3650 /* This is always valid, since gcc.c itself understands it. */
3651 if (!strcmp (p, "save-temps"))
3652 switches[n_switches].validated = 1;
3655 char ch = switches[n_switches].part1[0];
3656 if (ch == 'V' || ch == 'b' || ch == 'B')
3657 switches[n_switches].validated = 1;
3663 #ifdef HAVE_OBJECT_SUFFIX
3664 argv[i] = convert_filename (argv[i], 0);
3667 if (strcmp (argv[i], "-") != 0 && access (argv[i], R_OK) < 0)
3669 perror_with_name (argv[i]);
3674 infiles[n_infiles].language = spec_lang;
3675 infiles[n_infiles++].name = argv[i];
3680 if (n_infiles == last_language_n_infiles && spec_lang != 0)
3681 error ("Warning: `-x %s' after last input file has no effect", spec_lang);
3683 switches[n_switches].part1 = 0;
3684 infiles[n_infiles].name = 0;
3687 /* Process a spec string, accumulating and running commands. */
3689 /* These variables describe the input file name.
3690 input_file_number is the index on outfiles of this file,
3691 so that the output file name can be stored for later use by %o.
3692 input_basename is the start of the part of the input file
3693 sans all directory names, and basename_length is the number
3694 of characters starting there excluding the suffix .c or whatever. */
3696 const char *input_filename;
3697 static int input_file_number;
3698 size_t input_filename_length;
3699 static int basename_length;
3700 static const char *input_basename;
3701 static const char *input_suffix;
3703 /* These are variables used within do_spec and do_spec_1. */
3705 /* Nonzero if an arg has been started and not yet terminated
3706 (with space, tab or newline). */
3707 static int arg_going;
3709 /* Nonzero means %d or %g has been seen; the next arg to be terminated
3710 is a temporary file name. */
3711 static int delete_this_arg;
3713 /* Nonzero means %w has been seen; the next arg to be terminated
3714 is the output file name of this compilation. */
3715 static int this_is_output_file;
3717 /* Nonzero means %s has been seen; the next arg to be terminated
3718 is the name of a library file and we should try the standard
3719 search dirs for it. */
3720 static int this_is_library_file;
3722 /* Nonzero means that the input of this command is coming from a pipe. */
3723 static int input_from_pipe;
3725 /* Process the spec SPEC and run the commands specified therein.
3726 Returns 0 if the spec is successfully processed; -1 if failed. */
3736 delete_this_arg = 0;
3737 this_is_output_file = 0;
3738 this_is_library_file = 0;
3739 input_from_pipe = 0;
3741 value = do_spec_1 (spec, 0, NULL_PTR);
3743 /* Force out any unfinished command.
3744 If -pipe, this forces out the last command if it ended in `|'. */
3747 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
3750 if (argbuf_index > 0)
3757 /* Process the sub-spec SPEC as a portion of a larger spec.
3758 This is like processing a whole spec except that we do
3759 not initialize at the beginning and we do not supply a
3760 newline by default at the end.
3761 INSWITCH nonzero means don't process %-sequences in SPEC;
3762 in this case, % is treated as an ordinary character.
3763 This is used while substituting switches.
3764 INSWITCH nonzero also causes SPC not to terminate an argument.
3766 Value is zero unless a line was finished
3767 and the command on that line reported an error. */
3770 do_spec_1 (spec, inswitch, soft_matched_part)
3773 const char *soft_matched_part;
3775 register const char *p = spec;
3782 /* If substituting a switch, treat all chars like letters.
3783 Otherwise, NL, SPC, TAB and % are special. */
3784 switch (inswitch ? 'a' : c)
3787 /* End of line: finish any pending argument,
3788 then run the pending command if one has been started. */
3791 obstack_1grow (&obstack, 0);
3792 string = obstack_finish (&obstack);
3793 if (this_is_library_file)
3794 string = find_file (string);
3795 store_arg (string, delete_this_arg, this_is_output_file);
3796 if (this_is_output_file)
3797 outfiles[input_file_number] = string;
3801 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
3803 for (i = 0; i < n_switches; i++)
3804 if (!strcmp (switches[i].part1, "pipe"))
3807 /* A `|' before the newline means use a pipe here,
3808 but only if -pipe was specified.
3809 Otherwise, execute now and don't pass the `|' as an arg. */
3812 input_from_pipe = 1;
3813 switches[i].validated = 1;
3820 if (argbuf_index > 0)
3826 /* Reinitialize for a new command, and for a new argument. */
3829 delete_this_arg = 0;
3830 this_is_output_file = 0;
3831 this_is_library_file = 0;
3832 input_from_pipe = 0;
3836 /* End any pending argument. */
3839 obstack_1grow (&obstack, 0);
3840 string = obstack_finish (&obstack);
3841 if (this_is_library_file)
3842 string = find_file (string);
3843 store_arg (string, delete_this_arg, this_is_output_file);
3844 if (this_is_output_file)
3845 outfiles[input_file_number] = string;
3849 obstack_1grow (&obstack, c);
3855 /* Space or tab ends an argument if one is pending. */
3858 obstack_1grow (&obstack, 0);
3859 string = obstack_finish (&obstack);
3860 if (this_is_library_file)
3861 string = find_file (string);
3862 store_arg (string, delete_this_arg, this_is_output_file);
3863 if (this_is_output_file)
3864 outfiles[input_file_number] = string;
3866 /* Reinitialize for a new argument. */
3868 delete_this_arg = 0;
3869 this_is_output_file = 0;
3870 this_is_library_file = 0;
3877 fatal ("Invalid specification! Bug in cc.");
3880 obstack_grow (&obstack, input_basename, basename_length);
3885 delete_this_arg = 2;
3888 /* Dump out the directories specified with LIBRARY_PATH,
3889 followed by the absolute directories
3890 that we search for startfiles. */
3893 struct prefix_list *pl = startfile_prefixes.plist;
3894 size_t bufsize = 100;
3895 char *buffer = (char *) xmalloc (bufsize);
3898 for (; pl; pl = pl->next)
3900 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
3901 /* Used on systems which record the specified -L dirs
3902 and use them to search for dynamic linking. */
3903 /* Relative directories always come from -B,
3904 and it is better not to use them for searching
3905 at run time. In particular, stage1 loses. */
3906 if (!IS_DIR_SEPARATOR (pl->prefix[0]))
3909 /* Try subdirectory if there is one. */
3910 if (multilib_dir != NULL)
3914 if (strlen (pl->prefix) + strlen (machine_suffix)
3916 bufsize = (strlen (pl->prefix)
3917 + strlen (machine_suffix)) * 2 + 1;
3918 buffer = (char *) xrealloc (buffer, bufsize);
3919 strcpy (buffer, pl->prefix);
3920 strcat (buffer, machine_suffix);
3921 if (is_directory (buffer, multilib_dir, 1))
3923 do_spec_1 ("-L", 0, NULL_PTR);
3924 #ifdef SPACE_AFTER_L_OPTION
3925 do_spec_1 (" ", 0, NULL_PTR);
3927 do_spec_1 (buffer, 1, NULL_PTR);
3928 do_spec_1 (multilib_dir, 1, NULL_PTR);
3929 /* Make this a separate argument. */
3930 do_spec_1 (" ", 0, NULL_PTR);
3933 if (!pl->require_machine_suffix)
3935 if (is_directory (pl->prefix, multilib_dir, 1))
3937 do_spec_1 ("-L", 0, NULL_PTR);
3938 #ifdef SPACE_AFTER_L_OPTION
3939 do_spec_1 (" ", 0, NULL_PTR);
3941 do_spec_1 (pl->prefix, 1, NULL_PTR);
3942 do_spec_1 (multilib_dir, 1, NULL_PTR);
3943 /* Make this a separate argument. */
3944 do_spec_1 (" ", 0, NULL_PTR);
3950 if (is_directory (pl->prefix, machine_suffix, 1))
3952 do_spec_1 ("-L", 0, NULL_PTR);
3953 #ifdef SPACE_AFTER_L_OPTION
3954 do_spec_1 (" ", 0, NULL_PTR);
3956 do_spec_1 (pl->prefix, 1, NULL_PTR);
3957 /* Remove slash from machine_suffix. */
3958 if (strlen (machine_suffix) >= bufsize)
3959 bufsize = strlen (machine_suffix) * 2 + 1;
3960 buffer = (char *) xrealloc (buffer, bufsize);
3961 strcpy (buffer, machine_suffix);
3962 idx = strlen (buffer);
3963 if (IS_DIR_SEPARATOR (buffer[idx - 1]))
3964 buffer[idx - 1] = 0;
3965 do_spec_1 (buffer, 1, NULL_PTR);
3966 /* Make this a separate argument. */
3967 do_spec_1 (" ", 0, NULL_PTR);
3970 if (!pl->require_machine_suffix)
3972 if (is_directory (pl->prefix, "", 1))
3974 do_spec_1 ("-L", 0, NULL_PTR);
3975 #ifdef SPACE_AFTER_L_OPTION
3976 do_spec_1 (" ", 0, NULL_PTR);
3978 /* Remove slash from pl->prefix. */
3979 if (strlen (pl->prefix) >= bufsize)
3980 bufsize = strlen (pl->prefix) * 2 + 1;
3981 buffer = (char *) xrealloc (buffer, bufsize);
3982 strcpy (buffer, pl->prefix);
3983 idx = strlen (buffer);
3984 if (IS_DIR_SEPARATOR (buffer[idx - 1]))
3985 buffer[idx - 1] = 0;
3986 do_spec_1 (buffer, 1, NULL_PTR);
3987 /* Make this a separate argument. */
3988 do_spec_1 (" ", 0, NULL_PTR);
3997 /* %efoo means report an error with `foo' as error message
3998 and don't execute any more commands for this file. */
4002 while (*p != 0 && *p != '\n') p++;
4003 buf = (char *) alloca (p - q + 1);
4004 strncpy (buf, q, p - q);
4014 if (save_temps_flag)
4016 obstack_grow (&obstack, input_basename, basename_length);
4017 delete_this_arg = 0;
4021 #ifdef MKTEMP_EACH_FILE
4022 /* ??? This has a problem: the total number of
4023 values mktemp can return is limited.
4024 That matters for the names of object files.
4025 In 2.4, do something about that. */
4026 struct temp_name *t;
4028 const char *suffix = p;
4029 char *saved_suffix = NULL;
4031 while (*p == '.' || ISALPHA ((unsigned char)*p))
4033 suffix_length = p - suffix;
4034 if (p[0] == '%' && p[1] == 'O')
4037 /* We don't support extra suffix characters after %O. */
4038 if (*p == '.' || ISALPHA ((unsigned char)*p))
4040 if (suffix_length == 0)
4041 suffix = OBJECT_SUFFIX;
4045 = (char *) xmalloc (suffix_length
4046 + strlen (OBJECT_SUFFIX));
4047 strncpy (saved_suffix, suffix, suffix_length);
4048 strcpy (saved_suffix + suffix_length,
4051 suffix_length += strlen (OBJECT_SUFFIX);
4054 /* See if we already have an association of %g/%u/%U and
4056 for (t = temp_names; t; t = t->next)
4057 if (t->length == suffix_length
4058 && strncmp (t->suffix, suffix, suffix_length) == 0
4059 && t->unique == (c != 'g'))
4062 /* Make a new association if needed. %u requires one. */
4063 if (t == 0 || c == 'u')
4067 t = (struct temp_name *) xmalloc (sizeof (struct temp_name));
4068 t->next = temp_names;
4071 t->length = suffix_length;
4072 t->suffix = save_string (suffix, suffix_length);
4073 t->unique = (c != 'g');
4074 temp_filename = make_temp_file (t->suffix);
4075 temp_filename_length = strlen (temp_filename);
4076 t->filename = temp_filename;
4077 t->filename_length = temp_filename_length;
4081 free (saved_suffix);
4083 obstack_grow (&obstack, t->filename, t->filename_length);
4084 delete_this_arg = 1;
4086 obstack_grow (&obstack, temp_filename, temp_filename_length);
4087 if (c == 'u' || c == 'U')
4093 sprintf (buff, "%d", unique);
4094 obstack_grow (&obstack, buff, strlen (buff));
4097 delete_this_arg = 1;
4103 obstack_grow (&obstack, input_filename, input_filename_length);
4109 struct prefix_list *pl = include_prefixes.plist;
4111 if (gcc_exec_prefix)
4113 do_spec_1 ("-iprefix", 1, NULL_PTR);
4114 /* Make this a separate argument. */
4115 do_spec_1 (" ", 0, NULL_PTR);
4116 do_spec_1 (gcc_exec_prefix, 1, NULL_PTR);
4117 do_spec_1 (" ", 0, NULL_PTR);
4120 for (; pl; pl = pl->next)
4122 do_spec_1 ("-isystem", 1, NULL_PTR);
4123 /* Make this a separate argument. */
4124 do_spec_1 (" ", 0, NULL_PTR);
4125 do_spec_1 (pl->prefix, 1, NULL_PTR);
4126 do_spec_1 (" ", 0, NULL_PTR);
4133 int max = n_infiles;
4134 max += lang_specific_extra_outfiles;
4136 for (i = 0; i < max; i++)
4138 store_arg (outfiles[i], 0, 0);
4143 obstack_grow (&obstack, OBJECT_SUFFIX, strlen (OBJECT_SUFFIX));
4148 this_is_library_file = 1;
4152 this_is_output_file = 1;
4157 int cur_index = argbuf_index;
4158 /* Handle the {...} following the %W. */
4161 p = handle_braces (p + 1);
4164 /* If any args were output, mark the last one for deletion
4166 if (argbuf_index != cur_index)
4167 record_temp_file (argbuf[argbuf_index - 1], 0, 1);
4171 /* %x{OPTION} records OPTION for %X to output. */
4177 /* Skip past the option value and make a copy. */
4182 string = save_string (p1 + 1, p - p1 - 2);
4184 /* See if we already recorded this option. */
4185 for (i = 0; i < n_linker_options; i++)
4186 if (! strcmp (string, linker_options[i]))
4192 /* This option is new; add it. */
4193 add_linker_option (string, strlen (string));
4197 /* Dump out the options accumulated previously using %x. */
4199 for (i = 0; i < n_linker_options; i++)
4201 do_spec_1 (linker_options[i], 1, NULL_PTR);
4202 /* Make each accumulated option a separate argument. */
4203 do_spec_1 (" ", 0, NULL_PTR);
4207 /* Dump out the options accumulated previously using -Wa,. */
4209 for (i = 0; i < n_assembler_options; i++)
4211 do_spec_1 (assembler_options[i], 1, NULL_PTR);
4212 /* Make each accumulated option a separate argument. */
4213 do_spec_1 (" ", 0, NULL_PTR);
4217 /* Dump out the options accumulated previously using -Wp,. */
4219 for (i = 0; i < n_preprocessor_options; i++)
4221 do_spec_1 (preprocessor_options[i], 1, NULL_PTR);
4222 /* Make each accumulated option a separate argument. */
4223 do_spec_1 (" ", 0, NULL_PTR);
4227 /* Here are digits and numbers that just process
4228 a certain constant string as a spec. */
4231 value = do_spec_1 (cc1_spec, 0, NULL_PTR);
4237 value = do_spec_1 (cc1plus_spec, 0, NULL_PTR);
4243 value = do_spec_1 (asm_spec, 0, NULL_PTR);
4249 value = do_spec_1 (asm_final_spec, 0, NULL_PTR);
4255 value = do_spec_1 (signed_char_spec, 0, NULL_PTR);
4261 value = do_spec_1 (cpp_spec, 0, NULL_PTR);
4267 value = do_spec_1 (endfile_spec, 0, NULL_PTR);
4273 value = do_spec_1 (link_spec, 0, NULL_PTR);
4279 value = do_spec_1 (lib_spec, 0, NULL_PTR);
4285 value = do_spec_1 (libgcc_spec, 0, NULL_PTR);
4292 char *x = (char *) alloca (strlen (cpp_predefines) + 1);
4296 /* Copy all of the -D options in CPP_PREDEFINES into BUF. */
4300 if (! strncmp (y, "-D", 2))
4301 /* Copy the whole option. */
4302 while (*y && *y != ' ' && *y != '\t')
4304 else if (*y == ' ' || *y == '\t')
4305 /* Copy whitespace to the result. */
4307 /* Don't copy other options. */
4314 value = do_spec_1 (buf, 0, NULL_PTR);
4322 char *x = (char *) alloca (strlen (cpp_predefines) * 4 + 1);
4326 /* Copy all of CPP_PREDEFINES into BUF,
4327 but force them all into the reserved name space if they
4328 aren't already there. The reserved name space is all
4329 identifiers beginning with two underscores or with one
4330 underscore and a capital letter. We do the forcing by
4331 adding up to two underscores to the beginning and end
4332 of each symbol. e.g. mips, _mips, mips_, and _mips_ all
4337 if (! strncmp (y, "-D", 2))
4346 && ! ISUPPER ((unsigned char)*(y+1))))
4348 /* Stick __ at front of macro name. */
4352 /* Arrange to stick __ at the end as well. */
4356 /* Copy the macro name. */
4357 while (*y && *y != '=' && *y != ' ' && *y != '\t')
4370 /* Copy the value given, if any. */
4371 while (*y && *y != ' ' && *y != '\t')
4374 else if (*y == ' ' || *y == '\t')
4375 /* Copy whitespace to the result. */
4377 /* Don't copy -A options */
4383 /* Copy all of CPP_PREDEFINES into BUF,
4384 but put __ after every -D. */
4388 if (! strncmp (y, "-D", 2))
4394 && ! ISUPPER ((unsigned char)*(y+1))))
4396 /* Stick -D__ at front of macro name. */
4403 /* Copy the macro name. */
4404 while (*y && *y != '=' && *y != ' ' && *y != '\t')
4407 /* Copy the value given, if any. */
4408 while (*y && *y != ' ' && *y != '\t')
4413 /* Do not copy this macro - we have just done it before */
4414 while (*y && *y != ' ' && *y != '\t')
4418 else if (*y == ' ' || *y == '\t')
4419 /* Copy whitespace to the result. */
4421 /* Don't copy -A options. */
4427 /* Copy all of the -A options in CPP_PREDEFINES into BUF. */
4431 if (! strncmp (y, "-A", 2))
4432 /* Copy the whole option. */
4433 while (*y && *y != ' ' && *y != '\t')
4435 else if (*y == ' ' || *y == '\t')
4436 /* Copy whitespace to the result. */
4438 /* Don't copy other options. */
4445 value = do_spec_1 (buf, 0, NULL_PTR);
4452 value = do_spec_1 (startfile_spec, 0, NULL_PTR);
4457 /* Here we define characters other than letters and digits. */
4460 p = handle_braces (p);
4466 obstack_1grow (&obstack, '%');
4470 if (soft_matched_part)
4472 do_spec_1 (soft_matched_part, 1, NULL_PTR);
4473 do_spec_1 (" ", 0, NULL_PTR);
4476 /* Catch the case where a spec string contains something like
4477 '%{foo:%*}'. ie there is no * in the pattern on the left
4478 hand side of the :. */
4479 error ("Spec failure: '%%*' has not been initialised by pattern match");
4482 /* Process a string found as the value of a spec given by name.
4483 This feature allows individual machine descriptions
4484 to add and use their own specs.
4485 %[...] modifies -D options the way %P does;
4486 %(...) uses the spec unmodified. */
4488 error ("Warning: use of obsolete %%[ operator in specs");
4491 const char *name = p;
4492 struct spec_list *sl;
4495 /* The string after the S/P is the name of a spec that is to be
4497 while (*p && *p != ')' && *p != ']')
4500 /* See if it's in the list. */
4501 for (len = p - name, sl = specs; sl; sl = sl->next)
4502 if (sl->name_len == len && !strncmp (sl->name, name, len))
4504 name = *(sl->ptr_spec);
4506 notice ("Processing spec %c%s%c, which is '%s'\n",
4507 c, sl->name, (c == '(') ? ')' : ']', name);
4516 value = do_spec_1 (name, 0, NULL_PTR);
4522 char *x = (char *) alloca (strlen (name) * 2 + 1);
4524 const char *y = name;
4527 /* Copy all of NAME into BUF, but put __ after
4528 every -D and at the end of each arg. */
4531 if (! strncmp (y, "-D", 2))
4541 else if (flag && (*y == ' ' || *y == '\t' || *y == '='
4542 || *y == '}' || *y == 0))
4555 value = do_spec_1 (buf, 0, NULL_PTR);
4561 /* Discard the closing paren or bracket. */
4569 int c1 = *p++; /* Select first or second version number. */
4570 const char *v = compiler_version;
4572 static const char zeroc = '0';
4574 /* The format of the version string is
4575 ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)? */
4577 /* Ignore leading non-digits. i.e. "foo-" in "foo-2.7.2". */
4578 while (! ISDIGIT (*v))
4580 if (v > compiler_version && v[-1] != '-')
4583 /* If desired, advance to second version number. */
4586 /* Set V after the first period. */
4587 while (ISDIGIT (*v))
4594 /* If desired, advance to third version number.
4595 But don't complain if it's not present */
4598 /* Set V after the second period. */
4599 while (ISDIGIT (*v))
4601 if ((*v != 0) && (*v != ' ') && (*v != '.') && (*v != '-'))
4607 /* Set Q at the next period or at the end. */
4609 while (ISDIGIT (*q))
4611 if (*q != 0 && *q != ' ' && *q != '.' && *q != '-')
4615 /* Put that part into the command. */
4616 obstack_grow (&obstack, v, q - v);
4618 /* Default to "0" */
4619 obstack_grow (&obstack, &zeroc, 1);
4625 if (input_from_pipe)
4626 do_spec_1 ("-", 0, NULL_PTR);
4630 error ("Spec failure: Unrecognised spec option '%c'", c);
4636 /* Backslash: treat next character as ordinary. */
4641 /* Ordinary character: put it into the current argument. */
4642 obstack_1grow (&obstack, c);
4646 return 0; /* End of string */
4649 /* Return 0 if we call do_spec_1 and that returns -1. */
4653 register const char *p;
4655 const char *filter, *body = NULL, *endbody = NULL;
4659 int include_blanks = 1;
4660 int elide_switch = 0;
4664 /* A '^' after the open-brace means to not give blanks before args. */
4671 /* A `|' after the open-brace means,
4672 if the test fails, output a single minus sign rather than nothing.
4673 This is used in %{|!pipe:...}. */
4680 /* A `<' after the open-brace means that the switch should be
4681 removed from the command-line. */
4687 negate = suffix = 0;
4690 /* A `!' after the open-brace negates the condition:
4691 succeed if the specified switch is not present. */
4695 /* A `.' after the open-brace means test against the current suffix. */
4704 if (elide_switch && (negate || pipe_p || suffix))
4706 /* It doesn't make sense to mix elision with other flags. We
4707 could fatal() here, but the standard seems to be to abort. */
4712 while (*p != ':' && *p != '}' && *p != '|') p++;
4714 if (*p == '|' && pipe_p)
4721 register int count = 1;
4722 register const char *q = p;
4724 while (*q++ != ':') continue;
4740 body = p, endbody = p+1;
4745 int found = (input_suffix != 0
4746 && (long) strlen (input_suffix) == (long)(p - filter)
4747 && strncmp (input_suffix, filter, p - filter) == 0);
4753 && do_spec_1 (save_string (body, endbody-body-1), 0, NULL_PTR) < 0)
4756 else if (p[-1] == '*' && p[0] == '}')
4758 /* Substitute all matching switches as separate args. */
4761 for (i = 0; i < n_switches; i++)
4762 if (!strncmp (switches[i].part1, filter, p - filter)
4763 && check_live_switch (i, p - filter))
4764 give_switch (i, 0, include_blanks);
4768 /* Test for presence of the specified switch. */
4772 /* If name specified ends in *, as in {x*:...},
4773 check for %* and handle that case. */
4774 if (p[-1] == '*' && !negate)
4777 const char *r = body;
4779 /* First see whether we have %*. */
4783 if (*r == '%' && r[1] == '*')
4787 /* If we do, handle that case. */
4790 /* Substitute all matching switches as separate args.
4791 But do this by substituting for %*
4792 in the text that follows the colon. */
4794 unsigned hard_match_len = p - filter - 1;
4795 char *string = save_string (body, endbody - body - 1);
4797 for (i = 0; i < n_switches; i++)
4798 if (!strncmp (switches[i].part1, filter, hard_match_len)
4799 && check_live_switch (i, -1))
4801 do_spec_1 (string, 0, &switches[i].part1[hard_match_len]);
4802 /* Pass any arguments this switch has. */
4803 give_switch (i, 1, 1);
4806 /* We didn't match. Try again. */
4813 /* If name specified ends in *, as in {x*:...},
4814 check for presence of any switch name starting with x. */
4817 for (i = 0; i < n_switches; i++)
4819 unsigned hard_match_len = p - filter - 1;
4821 if (!strncmp (switches[i].part1, filter, hard_match_len)
4822 && check_live_switch (i, hard_match_len))
4829 /* Otherwise, check for presence of exact name specified. */
4832 for (i = 0; i < n_switches; i++)
4834 if (!strncmp (switches[i].part1, filter, p - filter)
4835 && switches[i].part1[p - filter] == 0
4836 && check_live_switch (i, -1))
4844 /* If it is as desired (present for %{s...}, absent for %{!s...})
4845 then substitute either the switch or the specified
4846 conditional text. */
4847 if (present != negate)
4851 switches[i].live_cond = SWITCH_IGNORE;
4852 switches[i].validated = 1;
4856 give_switch (i, 0, include_blanks);
4860 if (do_spec_1 (save_string (body, endbody - body - 1),
4867 /* Here if a %{|...} conditional fails: output a minus sign,
4868 which means "standard output" or "standard input". */
4869 do_spec_1 ("-", 0, NULL_PTR);
4874 /* We didn't match; try again. */
4881 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
4882 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
4883 spec, or -1 if either exact match or %* is used.
4885 A -O switch is obsoleted by a later -O switch. A -f, -m, or -W switch
4886 whose value does not begin with "no-" is obsoleted by the same value
4887 with the "no-", similarly for a switch with the "no-" prefix. */
4890 check_live_switch (switchnum, prefix_length)
4894 const char *name = switches[switchnum].part1;
4897 /* In the common case of {<at-most-one-letter>*}, a negating
4898 switch would always match, so ignore that case. We will just
4899 send the conflicting switches to the compiler phase. */
4900 if (prefix_length >= 0 && prefix_length <= 1)
4903 /* If we already processed this switch and determined if it was
4904 live or not, return our past determination. */
4905 if (switches[switchnum].live_cond != 0)
4906 return switches[switchnum].live_cond > 0;
4908 /* Now search for duplicate in a manner that depends on the name. */
4912 for (i = switchnum + 1; i < n_switches; i++)
4913 if (switches[i].part1[0] == 'O')
4915 switches[switchnum].validated = 1;
4916 switches[switchnum].live_cond = SWITCH_FALSE;
4921 case 'W': case 'f': case 'm':
4922 if (! strncmp (name + 1, "no-", 3))
4924 /* We have Xno-YYY, search for XYYY. */
4925 for (i = switchnum + 1; i < n_switches; i++)
4926 if (switches[i].part1[0] == name[0]
4927 && ! strcmp (&switches[i].part1[1], &name[4]))
4929 switches[switchnum].validated = 1;
4930 switches[switchnum].live_cond = SWITCH_FALSE;
4936 /* We have XYYY, search for Xno-YYY. */
4937 for (i = switchnum + 1; i < n_switches; i++)
4938 if (switches[i].part1[0] == name[0]
4939 && switches[i].part1[1] == 'n'
4940 && switches[i].part1[2] == 'o'
4941 && switches[i].part1[3] == '-'
4942 && !strcmp (&switches[i].part1[4], &name[1]))
4944 switches[switchnum].validated = 1;
4945 switches[switchnum].live_cond = SWITCH_FALSE;
4952 /* Otherwise the switch is live. */
4953 switches[switchnum].live_cond = SWITCH_LIVE;
4957 /* Pass a switch to the current accumulating command
4958 in the same form that we received it.
4959 SWITCHNUM identifies the switch; it is an index into
4960 the vector of switches gcc received, which is `switches'.
4961 This cannot fail since it never finishes a command line.
4963 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument.
4965 If INCLUDE_BLANKS is nonzero, then we include blanks before each argument
4969 give_switch (switchnum, omit_first_word, include_blanks)
4971 int omit_first_word;
4974 if (switches[switchnum].live_cond == SWITCH_IGNORE)
4977 if (!omit_first_word)
4979 do_spec_1 ("-", 0, NULL_PTR);
4980 do_spec_1 (switches[switchnum].part1, 1, NULL_PTR);
4983 if (switches[switchnum].args != 0)
4986 for (p = switches[switchnum].args; *p; p++)
4989 do_spec_1 (" ", 0, NULL_PTR);
4990 do_spec_1 (*p, 1, NULL_PTR);
4994 do_spec_1 (" ", 0, NULL_PTR);
4995 switches[switchnum].validated = 1;
4998 /* Search for a file named NAME trying various prefixes including the
4999 user's -B prefix and some standard ones.
5000 Return the absolute file name found. If nothing is found, return NAME. */
5008 /* Try multilib_dir if it is defined. */
5009 if (multilib_dir != NULL)
5013 try = (char *) alloca (strlen (multilib_dir) + strlen (name) + 2);
5014 strcpy (try, multilib_dir);
5015 strcat (try, dir_separator_str);
5018 newname = find_a_file (&startfile_prefixes, try, R_OK);
5020 /* If we don't find it in the multi library dir, then fall
5021 through and look for it in the normal places. */
5022 if (newname != NULL)
5026 newname = find_a_file (&startfile_prefixes, name, R_OK);
5027 return newname ? newname : name;
5030 /* Determine whether a directory exists. If LINKER, return 0 for
5031 certain fixed names not needed by the linker. If not LINKER, it is
5032 only important to return 0 if the host machine has a small ARG_MAX
5036 is_directory (path1, path2, linker)
5041 int len1 = strlen (path1);
5042 int len2 = strlen (path2);
5043 char *path = (char *) alloca (3 + len1 + len2);
5047 #ifndef SMALL_ARG_MAX
5052 /* Construct the path from the two parts. Ensure the string ends with "/.".
5053 The resulting path will be a directory even if the given path is a
5055 memcpy (path, path1, len1);
5056 memcpy (path + len1, path2, len2);
5057 cp = path + len1 + len2;
5058 if (!IS_DIR_SEPARATOR (cp[-1]))
5059 *cp++ = DIR_SEPARATOR;
5063 /* Exclude directories that the linker is known to search. */
5066 && strcmp (path, concat (dir_separator_str, "lib",
5067 dir_separator_str, ".", NULL_PTR)) == 0)
5069 && strcmp (path, concat (dir_separator_str, "usr",
5070 dir_separator_str, "lib",
5071 dir_separator_str, ".", NULL_PTR)) == 0)))
5074 return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
5077 /* Set up the various global variables to indicate that we're processing
5078 the input file named FILENAME. */
5081 set_input (filename)
5082 const char *filename;
5084 register const char *p;
5086 input_filename = filename;
5087 input_filename_length = strlen (input_filename);
5089 input_basename = input_filename;
5090 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
5091 /* Skip drive name so 'x:foo' is handled properly. */
5092 if (input_basename[1] == ':')
5093 input_basename += 2;
5095 for (p = input_basename; *p; p++)
5096 if (IS_DIR_SEPARATOR (*p))
5097 input_basename = p + 1;
5099 /* Find a suffix starting with the last period,
5100 and set basename_length to exclude that suffix. */
5101 basename_length = strlen (input_basename);
5102 p = input_basename + basename_length;
5103 while (p != input_basename && *p != '.') --p;
5104 if (*p == '.' && p != input_basename)
5106 basename_length = p - input_basename;
5107 input_suffix = p + 1;
5113 /* On fatal signals, delete all the temporary files. */
5116 fatal_error (signum)
5119 signal (signum, SIG_DFL);
5120 delete_failure_queue ();
5121 delete_temp_files ();
5122 /* Get the same signal again, this time not handled,
5123 so its normal effect occurs. */
5124 kill (getpid (), signum);
5127 extern int main PARAMS ((int, char **));
5137 int linker_was_run = 0;
5138 char *explicit_link_files;
5141 struct user_specs *uptr;
5143 p = argv[0] + strlen (argv[0]);
5144 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
5148 #ifdef HAVE_LC_MESSAGES
5149 setlocale (LC_MESSAGES, "");
5151 (void) bindtextdomain (PACKAGE, localedir);
5152 (void) textdomain (PACKAGE);
5154 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
5155 signal (SIGINT, fatal_error);
5157 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
5158 signal (SIGHUP, fatal_error);
5160 if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
5161 signal (SIGTERM, fatal_error);
5163 if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
5164 signal (SIGPIPE, fatal_error);
5168 argbuf = (char **) xmalloc (argbuf_length * sizeof (char *));
5170 obstack_init (&obstack);
5172 /* Build multilib_select, et. al from the separate lines that make up each
5173 multilib selection. */
5175 const char *const *q = multilib_raw;
5178 obstack_init (&multilib_obstack);
5179 while ((p = *q++) != (char *) 0)
5180 obstack_grow (&multilib_obstack, p, strlen (p));
5182 obstack_1grow (&multilib_obstack, 0);
5183 multilib_select = obstack_finish (&multilib_obstack);
5185 q = multilib_matches_raw;
5186 while ((p = *q++) != (char *) 0)
5187 obstack_grow (&multilib_obstack, p, strlen (p));
5189 obstack_1grow (&multilib_obstack, 0);
5190 multilib_matches = obstack_finish (&multilib_obstack);
5192 q = multilib_exclusions_raw;
5193 while ((p = *q++) != (char *) 0)
5194 obstack_grow (&multilib_obstack, p, strlen (p));
5196 obstack_1grow (&multilib_obstack, 0);
5197 multilib_exclusions = obstack_finish (&multilib_obstack);
5201 i < sizeof (multilib_defaults_raw) / sizeof (multilib_defaults_raw[0]);
5205 obstack_1grow (&multilib_obstack, ' ');
5206 obstack_grow (&multilib_obstack,
5207 multilib_defaults_raw[i],
5208 strlen (multilib_defaults_raw[i]));
5212 obstack_1grow (&multilib_obstack, 0);
5213 multilib_defaults = obstack_finish (&multilib_obstack);
5216 /* Set up to remember the pathname of gcc and any options
5217 needed for collect. We use argv[0] instead of programname because
5218 we need the complete pathname. */
5219 obstack_init (&collect_obstack);
5220 obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=")-1);
5221 obstack_grow (&collect_obstack, argv[0], strlen (argv[0])+1);
5222 putenv (obstack_finish (&collect_obstack));
5224 #ifdef INIT_ENVIRONMENT
5225 /* Set up any other necessary machine specific environment variables. */
5226 putenv (INIT_ENVIRONMENT);
5229 /* Choose directory for temp files. */
5231 #ifndef MKTEMP_EACH_FILE
5232 temp_filename = choose_temp_base ();
5233 temp_filename_length = strlen (temp_filename);
5236 /* Make a table of what switches there are (switches, n_switches).
5237 Make a table of specified input files (infiles, n_infiles).
5238 Decode switches that are handled locally. */
5240 process_command (argc, argv);
5245 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
5247 obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
5248 sizeof ("COLLECT_GCC_OPTIONS=")-1);
5251 for (i = 0; (int)i < n_switches; i++)
5256 obstack_grow (&collect_obstack, " ", 1);
5259 obstack_grow (&collect_obstack, "'-", 2);
5260 q = switches[i].part1;
5261 while ((p = index (q,'\'')))
5263 obstack_grow (&collect_obstack, q, p-q);
5264 obstack_grow (&collect_obstack, "'\\''", 4);
5267 obstack_grow (&collect_obstack, q, strlen (q));
5268 obstack_grow (&collect_obstack, "'", 1);
5270 for (args = switches[i].args; args && *args; args++)
5272 obstack_grow (&collect_obstack, " '", 2);
5274 while ((p = index (q,'\'')))
5276 obstack_grow (&collect_obstack, q, p-q);
5277 obstack_grow (&collect_obstack, "'\\''", 4);
5280 obstack_grow (&collect_obstack, q, strlen (q));
5281 obstack_grow (&collect_obstack, "'", 1);
5284 obstack_grow (&collect_obstack, "\0", 1);
5285 putenv (obstack_finish (&collect_obstack));
5288 /* Initialize the vector of specs to just the default.
5289 This means one element containing 0s, as a terminator. */
5291 compilers = (struct compiler *) xmalloc (sizeof default_compilers);
5292 bcopy ((char *) default_compilers, (char *) compilers,
5293 sizeof default_compilers);
5294 n_compilers = n_default_compilers;
5296 /* Read specs from a file if there is one. */
5298 machine_suffix = concat (spec_machine, dir_separator_str,
5299 spec_version, dir_separator_str, NULL_PTR);
5300 just_machine_suffix = concat (spec_machine, dir_separator_str, NULL_PTR);
5302 specs_file = find_a_file (&startfile_prefixes, "specs", R_OK);
5303 /* Read the specs file unless it is a default one. */
5304 if (specs_file != 0 && strcmp (specs_file, "specs"))
5305 read_specs (specs_file, TRUE);
5309 /* We need to check standard_exec_prefix/just_machine_suffix/specs
5310 for any override of as, ld and libraries. */
5311 specs_file = (char *) alloca (strlen (standard_exec_prefix)
5312 + strlen (just_machine_suffix)
5313 + sizeof ("specs"));
5315 strcpy (specs_file, standard_exec_prefix);
5316 strcat (specs_file, just_machine_suffix);
5317 strcat (specs_file, "specs");
5318 if (access (specs_file, R_OK) == 0)
5319 read_specs (specs_file, TRUE);
5321 /* If not cross-compiling, look for startfiles in the standard places. */
5322 if (*cross_compile == '0')
5324 #ifdef MD_EXEC_PREFIX
5325 add_prefix (&exec_prefixes, md_exec_prefix, "GCC", 0, 0, NULL_PTR);
5326 add_prefix (&startfile_prefixes, md_exec_prefix, "GCC", 0, 0, NULL_PTR);
5329 #ifdef MD_STARTFILE_PREFIX
5330 add_prefix (&startfile_prefixes, md_startfile_prefix, "GCC",
5334 #ifdef MD_STARTFILE_PREFIX_1
5335 add_prefix (&startfile_prefixes, md_startfile_prefix_1, "GCC",
5339 /* If standard_startfile_prefix is relative, base it on
5340 standard_exec_prefix. This lets us move the installed tree
5341 as a unit. If GCC_EXEC_PREFIX is defined, base
5342 standard_startfile_prefix on that as well. */
5343 if (IS_DIR_SEPARATOR (*standard_startfile_prefix)
5344 || *standard_startfile_prefix == '$'
5345 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
5346 /* Check for disk name on MS-DOS-based systems. */
5347 || (standard_startfile_prefix[1] == ':'
5348 && (IS_DIR_SEPARATOR (standard_startfile_prefix[2])))
5351 add_prefix (&startfile_prefixes, standard_startfile_prefix, "BINUTILS",
5355 if (gcc_exec_prefix)
5356 add_prefix (&startfile_prefixes,
5357 concat (gcc_exec_prefix, machine_suffix,
5358 standard_startfile_prefix, NULL_PTR),
5359 NULL_PTR, 0, 0, NULL_PTR);
5360 add_prefix (&startfile_prefixes,
5361 concat (standard_exec_prefix,
5363 standard_startfile_prefix, NULL_PTR),
5364 NULL_PTR, 0, 0, NULL_PTR);
5367 add_prefix (&startfile_prefixes, standard_startfile_prefix_1,
5368 "BINUTILS", 0, 0, NULL_PTR);
5369 add_prefix (&startfile_prefixes, standard_startfile_prefix_2,
5370 "BINUTILS", 0, 0, NULL_PTR);
5371 #if 0 /* Can cause surprises, and one can use -B./ instead. */
5372 add_prefix (&startfile_prefixes, "./", NULL_PTR, 0, 1, NULL_PTR);
5377 if (!IS_DIR_SEPARATOR (*standard_startfile_prefix) && gcc_exec_prefix)
5378 add_prefix (&startfile_prefixes,
5379 concat (gcc_exec_prefix, machine_suffix,
5380 standard_startfile_prefix, NULL_PTR),
5381 "BINUTILS", 0, 0, NULL_PTR);
5384 /* Process any user specified specs in the order given on the command
5386 for (uptr = user_specs_head; uptr; uptr = uptr->next)
5388 char *filename = find_a_file (&startfile_prefixes, uptr->filename, R_OK);
5389 read_specs (filename ? filename : uptr->filename, FALSE);
5392 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
5393 if (gcc_exec_prefix)
5395 char * temp = (char *) xmalloc (strlen (gcc_exec_prefix)
5396 + strlen (spec_version)
5397 + strlen (spec_machine) + 3);
5398 strcpy (temp, gcc_exec_prefix);
5399 strcat (temp, spec_machine);
5400 strcat (temp, dir_separator_str);
5401 strcat (temp, spec_version);
5402 strcat (temp, dir_separator_str);
5403 gcc_exec_prefix = temp;
5406 /* Now we have the specs.
5407 Set the `valid' bits for switches that match anything in any spec. */
5409 validate_all_switches ();
5411 /* Now that we have the switches and the specs, set
5412 the subdirectory based on the options. */
5413 set_multilib_dir ();
5415 /* Warn about any switches that no pass was interested in. */
5417 for (i = 0; (int)i < n_switches; i++)
5418 if (! switches[i].validated)
5419 error ("unrecognized option `-%s'", switches[i].part1);
5421 /* Obey some of the options. */
5423 if (print_search_dirs)
5425 printf ("install: %s%s\n", standard_exec_prefix, machine_suffix);
5426 printf ("programs: %s\n", build_search_list (&exec_prefixes, "", 0));
5427 printf ("libraries: %s\n", build_search_list (&startfile_prefixes, "", 0));
5431 if (print_file_name)
5433 printf ("%s\n", find_file (print_file_name));
5437 if (print_prog_name)
5439 char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK);
5440 printf ("%s\n", (newname ? newname : print_prog_name));
5444 if (print_multi_lib)
5446 print_multilib_info ();
5450 if (print_multi_directory)
5452 if (multilib_dir == NULL)
5455 printf ("%s\n", multilib_dir);
5459 if (print_help_list)
5465 printf ("\nFor bug reporting instructions, please see:\n");
5466 printf ("%s.\n", GCCBUGURL);
5471 /* We do not exit here. Instead we have created a fake input file
5472 called 'help-dummy' which needs to be compiled, and we pass this
5473 on the the various sub-processes, along with the --help switch. */
5480 /* compiler_version is truncated at the first space when initialized
5481 from version string, so truncate version_string at the first space
5482 before comparing. */
5483 for (n = 0; version_string[n]; n++)
5484 if (version_string[n] == ' ')
5487 if (! strncmp (version_string, compiler_version, n)
5488 && compiler_version[n] == 0)
5489 notice ("gcc version %s\n", version_string);
5491 notice ("gcc driver version %s executing gcc version %s\n",
5492 version_string, compiler_version);
5498 if (n_infiles == added_libraries)
5499 fatal ("No input files");
5501 /* Make a place to record the compiler output file names
5502 that correspond to the input files. */
5505 i += lang_specific_extra_outfiles;
5506 outfiles = (const char **) xcalloc (i, sizeof (char *));
5508 /* Record which files were specified explicitly as link input. */
5510 explicit_link_files = xcalloc (1, n_infiles);
5512 for (i = 0; (int)i < n_infiles; i++)
5514 register struct compiler *cp = 0;
5515 int this_file_error = 0;
5517 /* Tell do_spec what to substitute for %i. */
5519 input_file_number = i;
5520 set_input (infiles[i].name);
5522 /* Use the same thing in %o, unless cp->spec says otherwise. */
5524 outfiles[i] = input_filename;
5526 /* Figure out which compiler from the file's suffix. */
5528 cp = lookup_compiler (infiles[i].name, input_filename_length,
5529 infiles[i].language);
5533 /* Ok, we found an applicable compiler. Run its spec. */
5534 /* First say how much of input_filename to substitute for %b */
5537 if (cp->spec[0][0] == '#')
5538 error ("%s: %s compiler not installed on this system",
5539 input_filename, &cp->spec[0][1]);
5542 for (j = 0; j < sizeof cp->spec / sizeof cp->spec[0]; j++)
5544 len += strlen (cp->spec[j]);
5547 char *p1 = (char *) xmalloc (len + 1);
5550 for (j = 0; j < sizeof cp->spec / sizeof cp->spec[0]; j++)
5553 strcpy (p1 + len, cp->spec[j]);
5554 len += strlen (cp->spec[j]);
5557 value = do_spec (p1);
5561 this_file_error = 1;
5564 /* If this file's name does not contain a recognized suffix,
5565 record it as explicit linker input. */
5568 explicit_link_files[i] = 1;
5570 /* Clear the delete-on-failure queue, deleting the files in it
5571 if this compilation failed. */
5573 if (this_file_error)
5575 delete_failure_queue ();
5578 /* If this compilation succeeded, don't delete those files later. */
5579 clear_failure_queue ();
5582 /* Reset the output file name to the first input file name, for use
5583 with %b in LINK_SPEC on a target that prefers not to emit a.out
5586 set_input (infiles[0].name);
5588 if (error_count == 0)
5590 /* Make sure INPUT_FILE_NUMBER points to first available open
5592 input_file_number = n_infiles;
5593 if (lang_specific_pre_link ())
5597 /* Run ld to link all the compiler output files. */
5599 if (error_count == 0)
5601 int tmp = execution_count;
5603 /* We'll use ld if we can't find collect2. */
5604 if (! strcmp (linker_name_spec, "collect2"))
5606 char *s = find_a_file (&exec_prefixes, "collect2", X_OK);
5608 linker_name_spec = "ld";
5610 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
5612 putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH");
5613 putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV);
5615 value = do_spec (link_command_spec);
5618 linker_was_run = (tmp != execution_count);
5621 /* Warn if a -B option was specified but the prefix was never used. */
5622 unused_prefix_warnings (&exec_prefixes);
5623 unused_prefix_warnings (&startfile_prefixes);
5625 /* If options said don't run linker,
5626 complain about input files to be given to the linker. */
5628 if (! linker_was_run && error_count == 0)
5629 for (i = 0; (int)i < n_infiles; i++)
5630 if (explicit_link_files[i])
5631 error ("%s: linker input file unused since linking not done",
5634 /* Delete some or all of the temporary files we made. */
5637 delete_failure_queue ();
5638 delete_temp_files ();
5640 if (print_help_list)
5642 printf ("\nFor bug reporting instructions, please see:\n");
5643 printf ("%s\n", GCCBUGURL);
5646 return (signal_count != 0 ? 2
5647 : error_count > 0 ? (pass_exit_codes ? greatest_status : 1)
5651 /* Find the proper compilation spec for the file name NAME,
5652 whose length is LENGTH. LANGUAGE is the specified language,
5653 or 0 if this file is to be passed to the linker. */
5655 static struct compiler *
5656 lookup_compiler (name, length, language)
5659 const char *language;
5661 struct compiler *cp;
5663 /* If this was specified by the user to be a linker input, indicate that. */
5664 if (language != 0 && language[0] == '*')
5667 /* Otherwise, look for the language, if one is spec'd. */
5670 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
5671 if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
5674 error ("language %s not recognized", language);
5678 /* Look for a suffix. */
5679 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
5681 if (/* The suffix `-' matches only the file name `-'. */
5682 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
5683 || (strlen (cp->suffix) < length
5684 /* See if the suffix matches the end of NAME. */
5685 && !strcmp (cp->suffix,
5686 name + length - strlen (cp->suffix))
5691 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
5692 /* look again, but case-insensitively this time. */
5694 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
5696 if (/* The suffix `-' matches only the file name `-'. */
5697 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
5698 || (strlen (cp->suffix) < length
5699 /* See if the suffix matches the end of NAME. */
5700 && ((!strcmp (cp->suffix,
5701 name + length - strlen (cp->suffix))
5702 || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
5703 && !strcasecmp (cp->suffix,
5704 name + length - strlen (cp->suffix)))
5711 if (cp >= compilers)
5713 if (cp->spec[0][0] == '@')
5715 struct compiler *new;
5717 /* An alias entry maps a suffix to a language.
5718 Search for the language; pass 0 for NAME and LENGTH
5719 to avoid infinite recursion if language not found.
5720 Construct the new compiler spec. */
5721 language = cp->spec[0] + 1;
5722 new = (struct compiler *) xmalloc (sizeof (struct compiler));
5723 new->suffix = cp->suffix;
5725 lookup_compiler (NULL_PTR, 0, language)->spec,
5730 /* A non-alias entry: return it. */
5738 save_string (s, len)
5742 register char *result = xmalloc (len + 1);
5744 bcopy (s, result, len);
5750 pfatal_with_name (name)
5753 perror_with_name (name);
5754 delete_temp_files ();
5759 perror_with_name (name)
5762 error ("%s: %s", name, xstrerror (errno));
5766 pfatal_pexecute (errmsg_fmt, errmsg_arg)
5767 const char *errmsg_fmt;
5768 const char *errmsg_arg;
5772 int save_errno = errno;
5774 /* Space for trailing '\0' is in %s. */
5775 char *msg = xmalloc (strlen (errmsg_fmt) + strlen (errmsg_arg));
5776 sprintf (msg, errmsg_fmt, errmsg_arg);
5782 pfatal_with_name (errmsg_fmt);
5785 /* Output an error message and exit */
5790 fatal ("Internal gcc abort.");
5793 /* Output an error message and exit */
5796 fatal VPARAMS ((const char *msgid, ...))
5798 #ifndef ANSI_PROTOTYPES
5803 VA_START (ap, msgid);
5805 #ifndef ANSI_PROTOTYPES
5806 msgid = va_arg (ap, const char *);
5809 fprintf (stderr, "%s: ", programname);
5810 vfprintf (stderr, _(msgid), ap);
5812 fprintf (stderr, "\n");
5813 delete_temp_files ();
5818 error VPARAMS ((const char *msgid, ...))
5820 #ifndef ANSI_PROTOTYPES
5825 VA_START (ap, msgid);
5827 #ifndef ANSI_PROTOTYPES
5828 msgid = va_arg (ap, const char *);
5831 fprintf (stderr, "%s: ", programname);
5832 vfprintf (stderr, _(msgid), ap);
5835 fprintf (stderr, "\n");
5839 notice VPARAMS ((const char *msgid, ...))
5841 #ifndef ANSI_PROTOTYPES
5846 VA_START (ap, msgid);
5848 #ifndef ANSI_PROTOTYPES
5849 msgid = va_arg (ap, const char *);
5852 vfprintf (stderr, _(msgid), ap);
5858 validate_all_switches ()
5860 struct compiler *comp;
5861 register const char *p;
5863 struct spec_list *spec;
5865 for (comp = compilers; comp->spec[0]; comp++)
5868 for (i = 0; i < sizeof comp->spec / sizeof comp->spec[0] && comp->spec[i]; i++)
5872 if (c == '%' && *p == '{')
5873 /* We have a switch spec. */
5874 validate_switches (p + 1);
5878 /* Look through the linked list of specs read from the specs file. */
5879 for (spec = specs; spec ; spec = spec->next)
5881 p = *(spec->ptr_spec);
5883 if (c == '%' && *p == '{')
5884 /* We have a switch spec. */
5885 validate_switches (p + 1);
5888 p = link_command_spec;
5890 if (c == '%' && *p == '{')
5891 /* We have a switch spec. */
5892 validate_switches (p + 1);
5895 /* Look at the switch-name that comes after START
5896 and mark as valid all supplied switches that match it. */
5899 validate_switches (start)
5902 register const char *p = start;
5917 while (*p != ':' && *p != '}') p++;
5921 else if (p[-1] == '*')
5923 /* Mark all matching switches as valid. */
5925 for (i = 0; i < n_switches; i++)
5926 if (!strncmp (switches[i].part1, filter, p - filter))
5927 switches[i].validated = 1;
5931 /* Mark an exact matching switch as valid. */
5932 for (i = 0; i < n_switches; i++)
5934 if (!strncmp (switches[i].part1, filter, p - filter)
5935 && switches[i].part1[p - filter] == 0)
5936 switches[i].validated = 1;
5941 /* Check whether a particular argument was used. The first time we
5942 canonicalize the switches to keep only the ones we care about. */
5952 const char *replace;
5957 static struct mswitchstr *mswitches;
5958 static int n_mswitches;
5963 struct mswitchstr *matches;
5967 /* Break multilib_matches into the component strings of string and replacement
5969 for (q = multilib_matches; *q != '\0'; q++)
5973 matches = (struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt);
5975 q = multilib_matches;
5985 matches[i].len = q - matches[i].str;
5987 matches[i].replace = ++q;
5988 while (*q != ';' && *q != '\0')
5994 matches[i].rep_len = q - matches[i].replace;
6000 /* Now build a list of the replacement string for switches that we care
6001 about. Make sure we allocate at least one entry. This prevents
6002 xmalloc from calling fatal, and prevents us from re-executing this
6005 = (struct mswitchstr *) xmalloc ((sizeof (struct mswitchstr))
6006 * (n_switches ? n_switches : 1));
6007 for (i = 0; i < n_switches; i++)
6009 int xlen = strlen (switches[i].part1);
6010 for (j = 0; j < cnt; j++)
6011 if (xlen == matches[j].len
6012 && ! strncmp (switches[i].part1, matches[j].str, xlen))
6014 mswitches[n_mswitches].str = matches[j].replace;
6015 mswitches[n_mswitches].len = matches[j].rep_len;
6016 mswitches[n_mswitches].replace = (char *)0;
6017 mswitches[n_mswitches].rep_len = 0;
6024 for (i = 0; i < n_mswitches; i++)
6025 if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
6032 default_arg (p, len)
6036 const char *start, *end;
6038 for (start = multilib_defaults; *start != '\0'; start = end+1)
6040 while (*start == ' ' || *start == '\t')
6046 for (end = start+1; *end != ' ' && *end != '\t' && *end != '\0'; end++)
6049 if ((end - start) == len && strncmp (p, start, len) == 0)
6059 /* Work out the subdirectory to use based on the options. The format of
6060 multilib_select is a list of elements. Each element is a subdirectory
6061 name followed by a list of options followed by a semicolon. The format
6062 of multilib_exclusions is the same, but without the preceding
6063 directory. First gcc will check the exclusions, if none of the options
6064 beginning with an exclamation point are present, and all of the other
6065 options are present, then we will ignore this completely. Passing
6066 that, gcc will consider each multilib_select in turn using the same
6067 rules for matching the options. If a match is found, that subdirectory
6074 unsigned int this_path_len;
6075 const char *this_path, *this_arg;
6079 p = multilib_exclusions;
6082 /* Ignore newlines. */
6089 /* Check the arguments. */
6103 while (*p != ' ' && *p != ';')
6110 if (*this_arg != '!')
6118 ok = used_arg (this_arg, p - this_arg);
6132 p = multilib_select;
6135 /* Ignore newlines. */
6142 /* Get the initial path. */
6150 this_path_len = p - this_path;
6152 /* Check the arguments. */
6167 while (*p != ' ' && *p != ';')
6174 if (*this_arg != '!')
6182 /* If this is a default argument, we can just ignore it.
6183 This is true even if this_arg begins with '!'. Beginning
6184 with '!' does not mean that this argument is necessarily
6185 inappropriate for this library: it merely means that
6186 there is a more specific library which uses this
6187 argument. If this argument is a default, we need not
6188 consider that more specific library. */
6189 if (! default_arg (this_arg, p - this_arg))
6191 ok = used_arg (this_arg, p - this_arg);
6202 if (this_path_len != 1
6203 || this_path[0] != '.')
6205 char * new_multilib_dir = xmalloc (this_path_len + 1);
6206 strncpy (new_multilib_dir, this_path, this_path_len);
6207 new_multilib_dir[this_path_len] = '\0';
6208 multilib_dir = new_multilib_dir;
6217 /* Print out the multiple library subdirectory selection
6218 information. This prints out a series of lines. Each line looks
6219 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
6220 required. Only the desired options are printed out, the negative
6221 matches. The options are print without a leading dash. There are
6222 no spaces to make it easy to use the information in the shell.
6223 Each subdirectory is printed only once. This assumes the ordering
6224 generated by the genmultilib script. Also, we leave out ones that match
6228 print_multilib_info ()
6230 const char *p = multilib_select;
6231 const char *last_path = 0, *this_path;
6233 unsigned int last_path_len = 0;
6238 /* Ignore newlines. */
6245 /* Get the initial path. */
6254 /* Check for matches with the multilib_exclusions. We don't bother
6255 with the '!' in either list. If any of the exclusion rules match
6256 all of its options with the select rule, we skip it. */
6258 const char *e = multilib_exclusions;
6259 const char *this_arg;
6264 /* Ignore newlines. */
6271 /* Check the arguments. */
6288 while (*e != ' ' && *e != ';')
6299 int len = e - this_arg;
6306 while (*q != ' ' && *q != ';')
6313 if (! strncmp (arg, this_arg, (len < q - arg) ? q - arg : len) ||
6314 default_arg (this_arg, e - this_arg))
6344 /* If this is a duplicate, skip it. */
6345 skip = (last_path != 0 && (unsigned int)(p - this_path) == last_path_len
6346 && ! strncmp (last_path, this_path, last_path_len));
6348 last_path = this_path;
6349 last_path_len = p - this_path;
6352 /* If this directory requires any default arguments, we can skip
6353 it. We will already have printed a directory identical to
6354 this one which does not require that default argument. */
6372 while (*q != ' ' && *q != ';')
6380 && default_arg (arg, q - arg))
6395 for (p1 = last_path; p1 < p; p1++)
6414 use_arg = *p != '!';
6419 while (*p != ' ' && *p != ';')
6434 /* If there are extra options, print them now. */
6435 if (multilib_extra && *multilib_extra)
6437 int print_at = TRUE;
6440 for (q = multilib_extra; *q != '\0'; q++)