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 #if defined (HAVE_DECL_GETRUSAGE) && !HAVE_DECL_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 store_arg PARAMS ((const char *, int, int));
203 static char *load_specs PARAMS ((const char *));
204 static void read_specs PARAMS ((const char *, int));
205 static void set_spec PARAMS ((const char *, const char *));
206 static struct compiler *lookup_compiler PARAMS ((const char *, size_t, const char *));
207 static char *build_search_list PARAMS ((struct path_prefix *, const char *, int));
208 static void putenv_from_prefixes PARAMS ((struct path_prefix *, const char *));
209 static int access_check PARAMS ((const char *, int));
210 static char *find_a_file PARAMS ((struct path_prefix *, const char *, int));
211 static void add_prefix PARAMS ((struct path_prefix *, const char *,
212 const char *, int, int, int *));
213 static void translate_options PARAMS ((int *, const char ***));
214 static char *skip_whitespace PARAMS ((char *));
215 static void record_temp_file PARAMS ((const char *, int, int));
216 static void delete_if_ordinary PARAMS ((const char *));
217 static void delete_temp_files PARAMS ((void));
218 static void delete_failure_queue PARAMS ((void));
219 static void clear_failure_queue PARAMS ((void));
220 static int check_live_switch PARAMS ((int, int));
221 static const char *handle_braces PARAMS ((const char *));
222 static char *save_string PARAMS ((const char *, int));
223 static int do_spec_1 PARAMS ((const char *, int, const char *));
224 static const char *find_file PARAMS ((const char *));
225 static int is_directory PARAMS ((const char *, const char *, int));
226 static void validate_switches PARAMS ((const char *));
227 static void validate_all_switches PARAMS ((void));
228 static void give_switch PARAMS ((int, int, int));
229 static int used_arg PARAMS ((const char *, int));
230 static int default_arg PARAMS ((const char *, int));
231 static void set_multilib_dir PARAMS ((void));
232 static void print_multilib_info PARAMS ((void));
233 static void pfatal_with_name PARAMS ((const char *)) ATTRIBUTE_NORETURN;
234 static void perror_with_name PARAMS ((const char *));
235 static void pfatal_pexecute PARAMS ((const char *, const char *))
237 static void error PARAMS ((const char *, ...))
239 static void notice PARAMS ((const char *, ...))
241 static void display_help PARAMS ((void));
242 static void add_preprocessor_option PARAMS ((const char *, int));
243 static void add_assembler_option PARAMS ((const char *, int));
244 static void add_linker_option PARAMS ((const char *, int));
245 static void process_command PARAMS ((int, const char **));
246 static int execute PARAMS ((void));
247 static void unused_prefix_warnings PARAMS ((struct path_prefix *));
248 static void clear_args PARAMS ((void));
249 static void fatal_error PARAMS ((int));
250 static void set_input PARAMS ((const char *));
252 /* Specs are strings containing lines, each of which (if not blank)
253 is made up of a program name, and arguments separated by spaces.
254 The program name must be exact and start from root, since no path
255 is searched and it is unreliable to depend on the current working directory.
256 Redirection of input or output is not supported; the subprograms must
257 accept filenames saying what files to read and write.
259 In addition, the specs can contain %-sequences to substitute variable text
260 or for conditional text. Here is a table of all defined %-sequences.
261 Note that spaces are not generated automatically around the results of
262 expanding these sequences; therefore, you can concatenate them together
263 or with constant text in a single argument.
265 %% substitute one % into the program name or argument.
266 %i substitute the name of the input file being processed.
267 %b substitute the basename of the input file being processed.
268 This is the substring up to (and not including) the last period
269 and not including the directory.
271 substitute a file name that has suffix SUFFIX and is chosen
272 once per compilation, and mark the argument a la %d. To reduce
273 exposure to denial-of-service attacks, the file name is now
274 chosen in a way that is hard to predict even when previously
275 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
276 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
277 the regexp "[.A-Za-z]*%O"; "%O" is treated exactly as if it
278 had been pre-processed. Previously, %g was simply substituted
279 with a file name chosen once per compilation, without regard
280 to any appended suffix (which was therefore treated just like
281 ordinary text), making such attacks more likely to succeed.
283 like %g, but generates a new temporary file name even if %uSUFFIX
286 substitutes the last file name generated with %uSUFFIX, generating a
287 new one if there is no such last file name. In the absence of any
288 %uSUFFIX, this is just like %gSUFFIX, except they don't share
289 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
290 would involve the generation of two distinct file names, one
291 for each `%g.s' and another for each `%U.s'. Previously, %U was
292 simply substituted with a file name chosen for the previous %u,
293 without regard to any appended suffix.
294 %d marks the argument containing or following the %d as a
295 temporary file name, so that that file will be deleted if CC exits
296 successfully. Unlike %g, this contributes no text to the argument.
297 %w marks the argument containing or following the %w as the
298 "output file" of this compilation. This puts the argument
299 into the sequence of arguments that %o will substitute later.
301 like %{...} but mark last argument supplied within
302 as a file to be deleted on failure.
303 %o substitutes the names of all the output files, with spaces
304 automatically placed around them. You should write spaces
305 around the %o as well or the results are undefined.
306 %o is for use in the specs for running the linker.
307 Input files whose names have no recognized suffix are not compiled
308 at all, but they are included among the output files, so they will
310 %O substitutes the suffix for object files. Note that this is
311 handled specially when it immediately follows %g, %u, or %U
312 (with or without a suffix argument) because of the need for
313 those to form complete file names. The handling is such that
314 %O is treated exactly as if it had already been substituted,
315 except that %g, %u, and %U do not currently support additional
316 SUFFIX characters following %O as they would following, for
318 %p substitutes the standard macro predefinitions for the
319 current target machine. Use this when running cpp.
320 %P like %p, but puts `__' before and after the name of each macro.
321 (Except macros that already have __.)
323 %I Substitute a -iprefix option made from GCC_EXEC_PREFIX.
324 %s current argument is the name of a library or startup file of some sort.
325 Search for that file in a standard list of directories
326 and substitute the full name found.
327 %eSTR Print STR as an error message. STR is terminated by a newline.
328 Use this when inconsistent options are detected.
329 %x{OPTION} Accumulate an option for %X.
330 %X Output the accumulated linker options specified by compilations.
331 %Y Output the accumulated assembler options specified by compilations.
332 %Z Output the accumulated preprocessor options specified by compilations.
333 %v1 Substitute the major version number of GCC.
334 (For version 2.5.3, this is 2.)
335 %v2 Substitute the minor version number of GCC.
336 (For version 2.5.3, this is 5.)
337 %v3 Substitute the patch level number of GCC.
338 (For version 2.5.3, this is 3.)
339 %a process ASM_SPEC as a spec.
340 This allows config.h to specify part of the spec for running as.
341 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
342 used here. This can be used to run a post-processor after the
343 assembler has done its job.
344 %D Dump out a -L option for each directory in startfile_prefixes.
345 If multilib_dir is set, extra entries are generated with it affixed.
346 %l process LINK_SPEC as a spec.
347 %L process LIB_SPEC as a spec.
348 %G process LIBGCC_SPEC as a spec.
349 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
350 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
351 %c process SIGNED_CHAR_SPEC as a spec.
352 %C process CPP_SPEC as a spec. A capital C is actually used here.
353 %1 process CC1_SPEC as a spec.
354 %2 process CC1PLUS_SPEC as a spec.
355 %| output "-" if the input for the current command is coming from a pipe.
356 %* substitute the variable part of a matched option. (See below.)
357 Note that each comma in the substituted string is replaced by
359 %{S} substitutes the -S switch, if that switch was given to CC.
360 If that switch was not specified, this substitutes nothing.
361 Here S is a metasyntactic variable.
362 %{S*} substitutes all the switches specified to CC whose names start
363 with -S. This is used for -o, -D, -I, etc; switches that take
364 arguments. CC considers `-o foo' as being one switch whose
365 name starts with `o'. %{o*} would substitute this text,
366 including the space; thus, two arguments would be generated.
367 %{^S*} likewise, but don't put a blank between a switch and any args.
368 %{S*:X} substitutes X if one or more switches whose names start with -S are
369 specified to CC. Note that the tail part of the -S option
370 (i.e. the part matched by the `*') will be substituted for each
371 occurrence of %* within X.
372 %{<S} remove all occurences of S from the command line.
373 Note - this option is position dependent. % commands in the
374 spec string before this option will see S, % commands in the
375 spec string after this option will not.
376 %{S:X} substitutes X, but only if the -S switch was given to CC.
377 %{!S:X} substitutes X, but only if the -S switch was NOT given to CC.
378 %{|S:X} like %{S:X}, but if no S switch, substitute `-'.
379 %{|!S:X} like %{!S:X}, but if there is an S switch, substitute `-'.
380 %{.S:X} substitutes X, but only if processing a file with suffix S.
381 %{!.S:X} substitutes X, but only if NOT processing a file with suffix S.
382 %{S|P:X} substitutes X if either -S or -P was given to CC. This may be
383 combined with ! and . as above binding stronger than the OR.
384 %(Spec) processes a specification defined in a specs file as *Spec:
385 %[Spec] as above, but put __ around -D arguments
387 The conditional text X in a %{S:X} or %{!S:X} construct may contain
388 other nested % constructs or spaces, or even newlines. They are
389 processed as usual, as described above.
391 The -O, -f, -m, and -W switches are handled specifically in these
392 constructs. If another value of -O or the negated form of a -f, -m, or
393 -W switch is found later in the command line, the earlier switch
394 value is ignored, except with {S*} where S is just one letter; this
395 passes all matching options.
397 The character | at the beginning of the predicate text is used to indicate
398 that a command should be piped to the following command, but only if -pipe
401 Note that it is built into CC which switches take arguments and which
402 do not. You might think it would be useful to generalize this to
403 allow each compiler's spec to say which switches take arguments. But
404 this cannot be done in a consistent fashion. CC cannot even decide
405 which input files have been specified without knowing which switches
406 take arguments, and it must know which input files to compile in order
407 to tell which compilers to run.
409 CC also knows implicitly that arguments starting in `-l' are to be
410 treated as compiler output files, and passed to the linker in their
411 proper position among the other output files. */
413 /* Define the macros used for specs %a, %l, %L, %S, %c, %C, %1. */
415 /* config.h can define ASM_SPEC to provide extra args to the assembler
416 or extra switch-translations. */
421 /* config.h can define ASM_FINAL_SPEC to run a post processor after
422 the assembler has run. */
423 #ifndef ASM_FINAL_SPEC
424 #define ASM_FINAL_SPEC ""
427 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
428 or extra switch-translations. */
433 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
434 or extra switch-translations. */
439 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
440 or extra switch-translations. */
442 #define CC1PLUS_SPEC ""
445 /* config.h can define LINK_SPEC to provide extra args to the linker
446 or extra switch-translations. */
451 /* config.h can define LIB_SPEC to override the default libraries. */
453 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
456 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
459 #if defined(LINK_LIBGCC_SPECIAL) || defined(LINK_LIBGCC_SPECIAL_1)
460 /* Have gcc do the search for libgcc.a. */
461 #define LIBGCC_SPEC "libgcc.a%s"
463 #define LIBGCC_SPEC "-lgcc"
467 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
468 #ifndef STARTFILE_SPEC
469 #define STARTFILE_SPEC \
470 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
473 /* config.h can define SWITCHES_NEED_SPACES to control which options
474 require spaces between the option and the argument. */
475 #ifndef SWITCHES_NEED_SPACES
476 #define SWITCHES_NEED_SPACES ""
479 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
481 #define ENDFILE_SPEC ""
484 /* This spec is used for telling cpp whether char is signed or not. */
485 #ifndef SIGNED_CHAR_SPEC
486 /* Use #if rather than ?:
487 because MIPS C compiler rejects like ?: in initializers. */
488 #if DEFAULT_SIGNED_CHAR
489 #define SIGNED_CHAR_SPEC "%{funsigned-char:-D__CHAR_UNSIGNED__}"
491 #define SIGNED_CHAR_SPEC "%{!fsigned-char:-D__CHAR_UNSIGNED__}"
496 #define LINKER_NAME "collect2"
499 static const char *cpp_spec = CPP_SPEC;
500 static const char *cpp_predefines = CPP_PREDEFINES;
501 static const char *cc1_spec = CC1_SPEC;
502 static const char *cc1plus_spec = CC1PLUS_SPEC;
503 static const char *signed_char_spec = SIGNED_CHAR_SPEC;
504 static const char *asm_spec = ASM_SPEC;
505 static const char *asm_final_spec = ASM_FINAL_SPEC;
506 static const char *link_spec = LINK_SPEC;
507 static const char *lib_spec = LIB_SPEC;
508 static const char *libgcc_spec = LIBGCC_SPEC;
509 static const char *endfile_spec = ENDFILE_SPEC;
510 static const char *startfile_spec = STARTFILE_SPEC;
511 static const char *switches_need_spaces = SWITCHES_NEED_SPACES;
512 static const char *linker_name_spec = LINKER_NAME;
514 /* Some compilers have limits on line lengths, and the multilib_select
515 and/or multilib_matches strings can be very long, so we build them at
517 static struct obstack multilib_obstack;
518 static const char *multilib_select;
519 static const char *multilib_matches;
520 static const char *multilib_defaults;
521 static const char *multilib_exclusions;
522 #include "multilib.h"
524 /* Check whether a particular argument is a default argument. */
526 #ifndef MULTILIB_DEFAULTS
527 #define MULTILIB_DEFAULTS { "" }
530 static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
534 struct user_specs *next;
535 const char *filename;
538 static struct user_specs *user_specs_head, *user_specs_tail;
540 /* This defines which switch letters take arguments. */
542 #define DEFAULT_SWITCH_TAKES_ARG(CHAR) \
543 ((CHAR) == 'D' || (CHAR) == 'U' || (CHAR) == 'o' \
544 || (CHAR) == 'e' || (CHAR) == 'T' || (CHAR) == 'u' \
545 || (CHAR) == 'I' || (CHAR) == 'm' || (CHAR) == 'x' \
546 || (CHAR) == 'L' || (CHAR) == 'A' || (CHAR) == 'V' \
547 || (CHAR) == 'B' || (CHAR) == 'b')
549 #ifndef SWITCH_TAKES_ARG
550 #define SWITCH_TAKES_ARG(CHAR) DEFAULT_SWITCH_TAKES_ARG(CHAR)
553 /* This defines which multi-letter switches take arguments. */
555 #define DEFAULT_WORD_SWITCH_TAKES_ARG(STR) \
556 (!strcmp (STR, "Tdata") || !strcmp (STR, "Ttext") \
557 || !strcmp (STR, "Tbss") || !strcmp (STR, "include") \
558 || !strcmp (STR, "imacros") || !strcmp (STR, "aux-info") \
559 || !strcmp (STR, "idirafter") || !strcmp (STR, "iprefix") \
560 || !strcmp (STR, "iwithprefix") || !strcmp (STR, "iwithprefixbefore") \
561 || !strcmp (STR, "isystem") || !strcmp (STR, "specs"))
563 #ifndef WORD_SWITCH_TAKES_ARG
564 #define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR)
568 #ifdef HAVE_EXECUTABLE_SUFFIX
569 /* This defines which switches stop a full compilation. */
570 #define DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) \
571 ((CHAR) == 'c' || (CHAR) == 'S')
573 #ifndef SWITCH_CURTAILS_COMPILATION
574 #define SWITCH_CURTAILS_COMPILATION(CHAR) \
575 DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR)
579 /* Record the mapping from file suffixes for compilation specs. */
583 const char *suffix; /* Use this compiler for input files
584 whose names end in this suffix. */
586 const char *spec[4]; /* To use this compiler, concatenate these
587 specs and pass to do_spec. */
590 /* Pointer to a vector of `struct compiler' that gives the spec for
591 compiling a file, based on its suffix.
592 A file that does not end in any of these suffixes will be passed
593 unchanged to the loader and nothing else will be done to it.
595 An entry containing two 0s is used to terminate the vector.
597 If multiple entries match a file, the last matching one is used. */
599 static struct compiler *compilers;
601 /* Number of entries in `compilers', not counting the null terminator. */
603 static int n_compilers;
605 /* The default list of file name suffixes and their compilation specs. */
607 static struct compiler default_compilers[] =
609 /* Add lists of suffixes of known languages here. If those languages
610 were not present when we built the driver, we will hit these copies
611 and be given a more meaningful error than "file not used since
612 linking is not done". */
613 {".m", {"#Objective-C"}},
614 {".cc", {"#C++"}}, {".cxx", {"#C++"}}, {".cpp", {"#C++"}},
615 {".c++", {"#C++"}}, {".C", {"#C++"}},
616 {".ads", {"#Ada"}}, {".adb", {"#Ada"}}, {".ada", {"#Ada"}},
617 {".f", {"#Fortran"}}, {".for", {"#Fortran"}}, {".F", {"#Fortran"}},
618 {".fpp", {"#Fortran"}},
619 {".p", {"#Pascal"}}, {".pas", {"#Pascal"}},
620 /* Next come the entries for C. */
625 "%{E|M|MM:cpp -lang-c %{ansi:-std=c89} %{std*} %{nostdinc*}\
626 %{C} %{v} %{A*} %{I*} %{P} %{$} %I\
627 %{C:%{!E:%eGNU C does not support -C without using -E}}\
628 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
629 %{!no-gcc:-D__GNUC__=%v1 -D__GNUC_MINOR__=%v2 -D__GNUC_PATCHLEVEL__=%v3}\
630 %{!undef:%{!ansi:%{!std=*:%p}%{std=gnu*:%p}} %P} %{trigraphs}\
631 %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
632 %{ffast-math:-D__FAST_MATH__}\
633 %{fshort-wchar:-D__WCHAR_TYPE__=short\\ unsigned\\ int}\
634 %{traditional} %{ftraditional:-traditional}\
635 %{traditional-cpp:-traditional}\
636 %{fleading-underscore} %{fno-leading-underscore}\
637 %{fshow-column} %{fno-show-column}\
638 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\
639 %i %{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}}\n}\
640 %{!E:%{!M:%{!MM:cc1 %i %1 \
641 %{std*} %{nostdinc*} %{A*} %{I*} %I\
642 %{!Q:-quiet} -dumpbase %b.c %{d*} %{m*} %{a*}\
643 %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
644 %{!no-gcc:-D__GNUC__=%v1 -D__GNUC_MINOR__=%v2 -D__GNUC_PATCHLEVEL__=%v3}\
645 %{!undef:%{!ansi:%{!std=*:%p}%{std=gnu*:%p}} %P} %{trigraphs}\
646 %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
647 %{ffast-math:-D__FAST_MATH__}\
648 %{fshort-wchar:-D__WCHAR_TYPE__=short\\ unsigned\\ int}\
649 %{fshort-wchar:-D__WCHAR_TYPE__=short\\ unsigned\\ int}\
650 %{H} %C %{D*} %{U*} %{i*} %Z\
651 %{ftraditional:-traditional}\
652 %{traditional-cpp:-traditional}\
653 %{traditional} %{v:-version} %{pg:-p} %{p} %{f*}\
654 %{aux-info*} %{Qn:-fno-ident}\
656 %{g*} %{O*} %{W*} %{w} %{pedantic*}\
657 %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
658 %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
660 %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}\
661 %{!pipe:%g.s} %A\n }}}}"
662 #else /* ! USE_CPPLIB */
663 "%{traditional|ftraditional|traditional-cpp:trad}cpp -lang-c \
664 %{ansi:-std=c89} %{std*} %{nostdinc*}\
665 %{C} %{v} %{A*} %{I*} %{P} %{$} %I\
666 %{C:%{!E:%eGNU C does not support -C without using -E}}\
667 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
668 %{!no-gcc:-D__GNUC__=%v1 -D__GNUC_MINOR__=%v2 -D__GNUC_PATCHLEVEL__=%v3}\
669 %{!undef:%{!ansi:%{!std=*:%p}%{std=gnu*:%p}} %P} %{trigraphs}\
670 %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
671 %{ffast-math:-D__FAST_MATH__}\
672 %{fshort-wchar:-D__WCHAR_TYPE__=short\\ unsigned\\ int}\
673 %{fshow-column} %{fno-show-column}\
674 %{fleading-underscore} %{fno-leading-underscore}\
675 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\
676 %i %{!M:%{!MM:%{!E:%{!pipe:%g.i}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
677 "%{!M:%{!MM:%{!E:cc1 %{!pipe:%g.i} %1 \
678 %{!Q:-quiet} -dumpbase %b.c %{d*} %{m*} %{a*}\
679 %{g*} %{O*} %{W*} %{w} %{pedantic*} %{std*}\
680 %{traditional} %{v:-version} %{pg:-p} %{p} %{f*}\
681 %{aux-info*} %{Qn:-fno-ident}\
683 %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
684 %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
686 %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}\
687 %{!pipe:%g.s} %A\n }}}}"
688 #endif /* ! USE_CPPLIB */
691 {"%{E:%{traditional|ftraditional|traditional-cpp:trad}cpp \
692 -lang-c %{ansi:-std=c89} %{std*} %{nostdinc*}\
693 %{C} %{v} %{A*} %{I*} %{P} %{$} %I\
694 %{C:%{!E:%eGNU C does not support -C without using -E}}\
695 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
696 %{!no-gcc:-D__GNUC__=%v1 -D__GNUC_MINOR__=%v2 -D__GNUC_PATCHLEVEL__=%v3}\
697 %{!undef:%{!ansi:%{!std=*:%p}%{std=gnu*:%p}} %P} %{trigraphs}\
698 %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
699 %{ffast-math:-D__FAST_MATH__}\
700 %{fshort-wchar:-D__WCHAR_TYPE__=short\\ unsigned\\ int}\
701 %{fshow-column} %{fno-show-column}\
702 %{fleading-underscore} %{fno-leading-underscore}\
703 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\
705 %{!E:%e-E required when input is from standard input}"}},
706 {".h", {"@c-header"}},
708 {"%{!E:%eCompilation of header file requested} \
709 %{traditional|ftraditional|traditional-cpp:trad}cpp \
710 %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %{$} %I\
711 %{C:%{!E:%eGNU C does not support -C without using -E}}\
712 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
713 %{!no-gcc:-D__GNUC__=%v1 -D__GNUC_MINOR__=%v2 -D__GNUC_PATCHLEVEL__=%v3}\
714 %{!undef:%{!std=*:%p}%{std=gnu*:%p} %P} %{trigraphs}\
715 %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
716 %{ffast-math:-D__FAST_MATH__}\
717 %{fshort-wchar:-D__WCHAR_TYPE__=short\\ unsigned\\ int}\
718 %{fshort-wchar:-D__WCHAR_TYPE__=short\\ unsigned\\ int}\
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 {"%{traditional|ftraditional|traditional-cpp:trad}cpp -lang-asm \
742 %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %{$} %I\
743 %{C:%{!E:%eGNU C does not support -C without using -E}}\
744 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG} %{trigraphs}\
746 %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
747 %{ffast-math:-D__FAST_MATH__}\
748 %{fshort-wchar:-D__WCHAR_TYPE__=short\\ unsigned\\ int}\
749 %{fshow-column} %{fno-show-column}\
750 %{fleading-underscore} %{fno-leading-underscore}\
751 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\
752 %i %{!M:%{!MM:%{!E:%{!pipe:%g.s}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
753 "%{!M:%{!MM:%{!E:%{!S:as %a %Y\
754 %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}\
755 %{!pipe:%g.s} %A\n }}}}"}},
757 /* Mark end of table */
761 /* Number of elements in default_compilers, not counting the terminator. */
763 static int n_default_compilers
764 = (sizeof default_compilers / sizeof (struct compiler)) - 1;
766 /* Here is the spec for running the linker, after compiling all files. */
768 /* -u* was put back because both BSD and SysV seem to support it. */
769 /* %{static:} simply prevents an error message if the target machine
770 doesn't handle -static. */
771 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
772 scripts which exist in user specified directories, or in standard
774 #ifdef LINK_COMMAND_SPEC
775 /* Provide option to override link_command_spec from machine specific
776 configuration files. */
777 static const char *link_command_spec =
780 #ifdef LINK_LIBGCC_SPECIAL
781 /* Don't generate -L options. */
782 static const char *link_command_spec = "\
784 %{!c:%{!M:%{!MM:%{!E:%{!S:%(linker) %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} \
785 %{r} %{s} %{t} %{u*} %{x} %{z} %{Z}\
786 %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
788 %{!nostdlib:%{!nodefaultlibs:%G %L %G}}\
789 %{!A:%{!nostdlib:%{!nostartfiles:%E}}}\
794 static const char *link_command_spec = "\
796 %{!c:%{!M:%{!MM:%{!E:%{!S:%(linker) %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} \
797 %{r} %{s} %{t} %{u*} %{x} %{z} %{Z}\
798 %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
799 %{static:} %{L*} %D %o\
800 %{!nostdlib:%{!nodefaultlibs:%G %L %G}}\
801 %{!A:%{!nostdlib:%{!nostartfiles:%E}}}\
807 /* A vector of options to give to the linker.
808 These options are accumulated by %x,
809 and substituted into the linker command with %X. */
810 static int n_linker_options;
811 static char **linker_options;
813 /* A vector of options to give to the assembler.
814 These options are accumulated by -Wa,
815 and substituted into the assembler command with %Y. */
816 static int n_assembler_options;
817 static char **assembler_options;
819 /* A vector of options to give to the preprocessor.
820 These options are accumulated by -Wp,
821 and substituted into the preprocessor command with %Z. */
822 static int n_preprocessor_options;
823 static char **preprocessor_options;
825 /* Define how to map long options into short ones. */
827 /* This structure describes one mapping. */
830 /* The long option's name. */
832 /* The equivalent short option. */
833 const char *equivalent;
834 /* Argument info. A string of flag chars; NULL equals no options.
835 a => argument required.
836 o => argument optional.
837 j => join argument to equivalent, making one word.
838 * => require other text after NAME as an argument. */
839 const char *arg_info;
842 /* This is the table of mappings. Mappings are tried sequentially
843 for each option encountered; the first one that matches, wins. */
845 struct option_map option_map[] =
847 {"--all-warnings", "-Wall", 0},
848 {"--ansi", "-ansi", 0},
849 {"--assemble", "-S", 0},
850 {"--assert", "-A", "a"},
851 {"--classpath", "-fclasspath=", "aj"},
852 {"--CLASSPATH", "-fCLASSPATH=", "aj"},
853 {"--comments", "-C", 0},
854 {"--compile", "-c", 0},
855 {"--debug", "-g", "oj"},
856 {"--define-macro", "-D", "aj"},
857 {"--dependencies", "-M", 0},
858 {"--dump", "-d", "a"},
859 {"--dumpbase", "-dumpbase", "a"},
860 {"--entry", "-e", 0},
861 {"--extra-warnings", "-W", 0},
862 {"--for-assembler", "-Wa", "a"},
863 {"--for-linker", "-Xlinker", "a"},
864 {"--force-link", "-u", "a"},
865 {"--imacros", "-imacros", "a"},
866 {"--include", "-include", "a"},
867 {"--include-barrier", "-I-", 0},
868 {"--include-directory", "-I", "aj"},
869 {"--include-directory-after", "-idirafter", "a"},
870 {"--include-prefix", "-iprefix", "a"},
871 {"--include-with-prefix", "-iwithprefix", "a"},
872 {"--include-with-prefix-before", "-iwithprefixbefore", "a"},
873 {"--include-with-prefix-after", "-iwithprefix", "a"},
874 {"--language", "-x", "a"},
875 {"--library-directory", "-L", "a"},
876 {"--machine", "-m", "aj"},
877 {"--machine-", "-m", "*j"},
878 {"--no-line-commands", "-P", 0},
879 {"--no-precompiled-includes", "-noprecomp", 0},
880 {"--no-standard-includes", "-nostdinc", 0},
881 {"--no-standard-libraries", "-nostdlib", 0},
882 {"--no-warnings", "-w", 0},
883 {"--optimize", "-O", "oj"},
884 {"--output", "-o", "a"},
885 {"--output-class-directory", "-foutput-class-dir=", "ja"},
886 {"--pedantic", "-pedantic", 0},
887 {"--pedantic-errors", "-pedantic-errors", 0},
888 {"--pipe", "-pipe", 0},
889 {"--prefix", "-B", "a"},
890 {"--preprocess", "-E", 0},
891 {"--print-search-dirs", "-print-search-dirs", 0},
892 {"--print-file-name", "-print-file-name=", "aj"},
893 {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
894 {"--print-missing-file-dependencies", "-MG", 0},
895 {"--print-multi-lib", "-print-multi-lib", 0},
896 {"--print-multi-directory", "-print-multi-directory", 0},
897 {"--print-prog-name", "-print-prog-name=", "aj"},
898 {"--profile", "-p", 0},
899 {"--profile-blocks", "-a", 0},
900 {"--quiet", "-q", 0},
901 {"--save-temps", "-save-temps", 0},
902 {"--shared", "-shared", 0},
903 {"--silent", "-q", 0},
904 {"--specs", "-specs=", "aj"},
905 {"--static", "-static", 0},
906 {"--std", "-std=", "aj"},
907 {"--symbolic", "-symbolic", 0},
908 {"--target", "-b", "a"},
909 {"--time", "-time", 0},
910 {"--trace-includes", "-H", 0},
911 {"--traditional", "-traditional", 0},
912 {"--traditional-cpp", "-traditional-cpp", 0},
913 {"--trigraphs", "-trigraphs", 0},
914 {"--undefine-macro", "-U", "aj"},
915 {"--use-version", "-V", "a"},
916 {"--user-dependencies", "-MM", 0},
917 {"--verbose", "-v", 0},
918 {"--version", "-dumpversion", 0},
919 {"--warn-", "-W", "*j"},
920 {"--write-dependencies", "-MD", 0},
921 {"--write-user-dependencies", "-MMD", 0},
925 /* Translate the options described by *ARGCP and *ARGVP.
926 Make a new vector and store it back in *ARGVP,
927 and store its length in *ARGVC. */
930 translate_options (argcp, argvp)
936 const char **argv = *argvp;
938 (const char **) xmalloc ((argc + 2) * 2 * sizeof (const char *));
942 newv[newindex++] = argv[i++];
946 /* Translate -- options. */
947 if (argv[i][0] == '-' && argv[i][1] == '-')
950 /* Find a mapping that applies to this option. */
951 for (j = 0; j < sizeof (option_map) / sizeof (option_map[0]); j++)
953 size_t optlen = strlen (option_map[j].name);
954 size_t arglen = strlen (argv[i]);
955 size_t complen = arglen > optlen ? optlen : arglen;
956 const char *arginfo = option_map[j].arg_info;
961 if (!strncmp (argv[i], option_map[j].name, complen))
969 k < sizeof (option_map) / sizeof (option_map[0]);
971 if (strlen (option_map[k].name) >= arglen
972 && !strncmp (argv[i], option_map[k].name, arglen))
974 error ("Ambiguous abbreviation %s", argv[i]);
978 if (k != sizeof (option_map) / sizeof (option_map[0]))
984 /* If the option has an argument, accept that. */
985 if (argv[i][optlen] == '=')
986 arg = argv[i] + optlen + 1;
988 /* If this mapping requires extra text at end of name,
989 accept that as "argument". */
990 else if (index (arginfo, '*') != 0)
991 arg = argv[i] + optlen;
993 /* Otherwise, extra text at end means mismatch.
994 Try other mappings. */
999 else if (index (arginfo, '*') != 0)
1001 error ("Incomplete `%s' option", option_map[j].name);
1005 /* Handle arguments. */
1006 if (index (arginfo, 'a') != 0)
1012 error ("Missing argument to `%s' option",
1013 option_map[j].name);
1020 else if (index (arginfo, '*') != 0)
1022 else if (index (arginfo, 'o') == 0)
1025 error ("Extraneous argument to `%s' option",
1026 option_map[j].name);
1030 /* Store the translation as one argv elt or as two. */
1031 if (arg != 0 && index (arginfo, 'j') != 0)
1032 newv[newindex++] = concat (option_map[j].equivalent, arg,
1036 newv[newindex++] = option_map[j].equivalent;
1037 newv[newindex++] = arg;
1040 newv[newindex++] = option_map[j].equivalent;
1048 /* Handle old-fashioned options--just copy them through,
1049 with their arguments. */
1050 else if (argv[i][0] == '-')
1052 const char *p = argv[i] + 1;
1056 if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
1057 nskip += SWITCH_TAKES_ARG (c) - (p[1] != 0);
1058 else if (WORD_SWITCH_TAKES_ARG (p))
1059 nskip += WORD_SWITCH_TAKES_ARG (p);
1060 else if ((c == 'B' || c == 'b' || c == 'V' || c == 'x')
1063 else if (! strcmp (p, "Xlinker"))
1066 /* Watch out for an option at the end of the command line that
1067 is missing arguments, and avoid skipping past the end of the
1069 if (nskip + i > argc)
1074 newv[newindex++] = argv[i++];
1079 /* Ordinary operands, or +e options. */
1080 newv[newindex++] = argv[i++];
1095 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1096 be considered whitespace. */
1097 if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
1099 else if (*p == '\n' || *p == ' ' || *p == '\t')
1103 while (*p != '\n') p++;
1113 /* Structure to keep track of the specs that have been defined so far.
1114 These are accessed using %(specname) or %[specname] in a compiler
1119 /* The following 2 fields must be first */
1120 /* to allow EXTRA_SPECS to be initialized */
1121 const char *name; /* name of the spec. */
1122 const char *ptr; /* available ptr if no static pointer */
1124 /* The following fields are not initialized */
1125 /* by EXTRA_SPECS */
1126 const char **ptr_spec; /* pointer to the spec itself. */
1127 struct spec_list *next; /* Next spec in linked list. */
1128 int name_len; /* length of the name */
1129 int alloc_p; /* whether string was allocated */
1132 #define INIT_STATIC_SPEC(NAME,PTR) \
1133 { NAME, NULL_PTR, PTR, (struct spec_list *)0, sizeof (NAME)-1, 0 }
1135 /* List of statically defined specs. */
1136 static struct spec_list static_specs[] =
1138 INIT_STATIC_SPEC ("asm", &asm_spec),
1139 INIT_STATIC_SPEC ("asm_final", &asm_final_spec),
1140 INIT_STATIC_SPEC ("cpp", &cpp_spec),
1141 INIT_STATIC_SPEC ("cc1", &cc1_spec),
1142 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec),
1143 INIT_STATIC_SPEC ("endfile", &endfile_spec),
1144 INIT_STATIC_SPEC ("link", &link_spec),
1145 INIT_STATIC_SPEC ("lib", &lib_spec),
1146 INIT_STATIC_SPEC ("libgcc", &libgcc_spec),
1147 INIT_STATIC_SPEC ("startfile", &startfile_spec),
1148 INIT_STATIC_SPEC ("switches_need_spaces", &switches_need_spaces),
1149 INIT_STATIC_SPEC ("signed_char", &signed_char_spec),
1150 INIT_STATIC_SPEC ("predefines", &cpp_predefines),
1151 INIT_STATIC_SPEC ("cross_compile", &cross_compile),
1152 INIT_STATIC_SPEC ("version", &compiler_version),
1153 INIT_STATIC_SPEC ("multilib", &multilib_select),
1154 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults),
1155 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra),
1156 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches),
1157 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions),
1158 INIT_STATIC_SPEC ("linker", &linker_name_spec),
1161 #ifdef EXTRA_SPECS /* additional specs needed */
1162 /* Structure to keep track of just the first two args of a spec_list.
1163 That is all that the EXTRA_SPECS macro gives us. */
1170 static struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1171 static struct spec_list * extra_specs = (struct spec_list *)0;
1174 /* List of dynamically allocates specs that have been defined so far. */
1176 static struct spec_list *specs = (struct spec_list *)0;
1179 /* Initialize the specs lookup routines. */
1184 struct spec_list *next = (struct spec_list *)0;
1185 struct spec_list *sl = (struct spec_list *)0;
1189 return; /* Already initialized. */
1192 notice ("Using builtin specs.\n");
1195 extra_specs = (struct spec_list *)
1196 xcalloc (sizeof(struct spec_list),
1197 (sizeof(extra_specs_1)/sizeof(extra_specs_1[0])));
1199 for (i = (sizeof(extra_specs_1) / sizeof(extra_specs_1[0])) - 1; i >= 0; i--)
1201 sl = &extra_specs[i];
1202 sl->name = extra_specs_1[i].name;
1203 sl->ptr = extra_specs_1[i].ptr;
1205 sl->name_len = strlen (sl->name);
1206 sl->ptr_spec = &sl->ptr;
1211 for (i = (sizeof (static_specs) / sizeof (static_specs[0])) - 1; i >= 0; i--)
1213 sl = &static_specs[i];
1222 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1223 removed; If the spec starts with a + then SPEC is added to the end of the
1227 set_spec (name, spec)
1231 struct spec_list *sl;
1232 const char *old_spec;
1233 int name_len = strlen (name);
1236 /* If this is the first call, initialize the statically allocated specs. */
1239 struct spec_list *next = (struct spec_list *)0;
1240 for (i = (sizeof (static_specs) / sizeof (static_specs[0])) - 1;
1243 sl = &static_specs[i];
1250 /* See if the spec already exists. */
1251 for (sl = specs; sl; sl = sl->next)
1252 if (name_len == sl->name_len && !strcmp (sl->name, name))
1257 /* Not found - make it. */
1258 sl = (struct spec_list *) xmalloc (sizeof (struct spec_list));
1259 sl->name = xstrdup (name);
1260 sl->name_len = name_len;
1261 sl->ptr_spec = &sl->ptr;
1263 *(sl->ptr_spec) = "";
1268 old_spec = *(sl->ptr_spec);
1269 *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
1270 ? concat (old_spec, spec + 1, NULL_PTR)
1275 notice ("Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
1278 /* Free the old spec. */
1279 if (old_spec && sl->alloc_p)
1280 free ((PTR) old_spec);
1285 /* Accumulate a command (program name and args), and run it. */
1287 /* Vector of pointers to arguments in the current line of specifications. */
1289 static const char **argbuf;
1291 /* Number of elements allocated in argbuf. */
1293 static int argbuf_length;
1295 /* Number of elements in argbuf currently in use (containing args). */
1297 static int argbuf_index;
1299 /* We want this on by default all the time now. */
1300 #define MKTEMP_EACH_FILE
1302 #ifdef MKTEMP_EACH_FILE
1304 /* This is the list of suffixes and codes (%g/%u/%U) and the associated
1307 static struct temp_name {
1308 const char *suffix; /* suffix associated with the code. */
1309 int length; /* strlen (suffix). */
1310 int unique; /* Indicates whether %g or %u/%U was used. */
1311 const char *filename; /* associated filename. */
1312 int filename_length; /* strlen (filename). */
1313 struct temp_name *next;
1318 /* Number of commands executed so far. */
1320 static int execution_count;
1322 /* Number of commands that exited with a signal. */
1324 static int signal_count;
1326 /* Name with which this program was invoked. */
1328 static const char *programname;
1330 /* Structures to keep track of prefixes to try when looking for files. */
1334 char *prefix; /* String to prepend to the path. */
1335 struct prefix_list *next; /* Next in linked list. */
1336 int require_machine_suffix; /* Don't use without machine_suffix. */
1337 /* 2 means try both machine_suffix and just_machine_suffix. */
1338 int *used_flag_ptr; /* 1 if a file was found with this prefix. */
1343 struct prefix_list *plist; /* List of prefixes to try */
1344 int max_len; /* Max length of a prefix in PLIST */
1345 const char *name; /* Name of this list (used in config stuff) */
1348 /* List of prefixes to try when looking for executables. */
1350 static struct path_prefix exec_prefixes = { 0, 0, "exec" };
1352 /* List of prefixes to try when looking for startup (crt0) files. */
1354 static struct path_prefix startfile_prefixes = { 0, 0, "startfile" };
1356 /* List of prefixes to try when looking for include files. */
1358 static struct path_prefix include_prefixes = { 0, 0, "include" };
1360 /* Suffix to attach to directories searched for commands.
1361 This looks like `MACHINE/VERSION/'. */
1363 static const char *machine_suffix = 0;
1365 /* Suffix to attach to directories searched for commands.
1366 This is just `MACHINE/'. */
1368 static const char *just_machine_suffix = 0;
1370 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1372 static const char *gcc_exec_prefix;
1374 /* Default prefixes to attach to command names. */
1376 #ifdef CROSS_COMPILE /* Don't use these prefixes for a cross compiler. */
1377 #undef MD_EXEC_PREFIX
1378 #undef MD_STARTFILE_PREFIX
1379 #undef MD_STARTFILE_PREFIX_1
1382 #ifndef STANDARD_EXEC_PREFIX
1383 #define STANDARD_EXEC_PREFIX "/usr/local/lib/gcc-lib/"
1384 #endif /* !defined STANDARD_EXEC_PREFIX */
1386 static const char *standard_exec_prefix = STANDARD_EXEC_PREFIX;
1387 static const char *standard_exec_prefix_1 = "/usr/lib/gcc/";
1388 #ifdef MD_EXEC_PREFIX
1389 static const char *md_exec_prefix = MD_EXEC_PREFIX;
1392 #ifndef STANDARD_STARTFILE_PREFIX
1393 #define STANDARD_STARTFILE_PREFIX "/usr/local/lib/"
1394 #endif /* !defined STANDARD_STARTFILE_PREFIX */
1396 #ifdef MD_STARTFILE_PREFIX
1397 static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1399 #ifdef MD_STARTFILE_PREFIX_1
1400 static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1402 static const char *standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1403 static const char *standard_startfile_prefix_1 = "/lib/";
1404 static const char *standard_startfile_prefix_2 = "/usr/lib/";
1406 #ifndef TOOLDIR_BASE_PREFIX
1407 #define TOOLDIR_BASE_PREFIX "/usr/local/"
1409 static const char *tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1410 static const char *tooldir_prefix;
1412 #ifndef STANDARD_BINDIR_PREFIX
1413 #define STANDARD_BINDIR_PREFIX "/usr/local/bin"
1415 static const char *standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
1417 /* Subdirectory to use for locating libraries. Set by
1418 set_multilib_dir based on the compilation options. */
1420 static const char *multilib_dir;
1422 /* Clear out the vector of arguments (after a command is executed). */
1430 /* Add one argument to the vector at the end.
1431 This is done when a space is seen or at the end of the line.
1432 If DELETE_ALWAYS is nonzero, the arg is a filename
1433 and the file should be deleted eventually.
1434 If DELETE_FAILURE is nonzero, the arg is a filename
1435 and the file should be deleted if this compilation fails. */
1438 store_arg (arg, delete_always, delete_failure)
1440 int delete_always, delete_failure;
1442 if (argbuf_index + 1 == argbuf_length)
1444 = (const char **) xrealloc (argbuf,
1445 (argbuf_length *= 2) * sizeof (const 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 const 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 const 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)
2605 free ((PTR) string);
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)
2656 if (WIFSIGNALED (status))
2659 /* SIGPIPE is a special case. It happens in -pipe mode
2660 when the compiler dies before the preprocessor is
2661 done, or the assembler dies before the compiler is
2662 done. There's generally been an error already, and
2663 this is just fallout. So don't generate another error
2664 unless we would otherwise have succeeded. */
2665 if (WTERMSIG (status) == SIGPIPE
2666 && (signal_count || greatest_status >= MIN_FATAL_STATUS))
2671 Internal error: %s (program %s)\n\
2672 Please submit a full bug report.\n\
2673 See %s for instructions.",
2674 strsignal (WTERMSIG (status)), commands[j].prog,
2679 else if (WIFEXITED (status)
2680 && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
2682 if (WEXITSTATUS (status) > greatest_status)
2683 greatest_status = WEXITSTATUS (status);
2686 #ifdef HAVE_GETRUSAGE
2687 if (report_times && ut + st != 0)
2688 notice ("# %s %.2f %.2f\n", commands[j].prog, ut, st);
2697 /* Find all the switches given to us
2698 and make a vector describing them.
2699 The elements of the vector are strings, one per switch given.
2700 If a switch uses following arguments, then the `part1' field
2701 is the switch itself and the `args' field
2702 is a null-terminated vector containing the following arguments.
2703 The `live_cond' field is:
2705 1 if the switch is true in a conditional spec,
2706 -1 if false (overridden by a later switch)
2707 -2 if this switch should be ignored (used in %{<S})
2708 The `validated' field is nonzero if any spec has looked at this switch;
2709 if it remains zero at the end of the run, it must be meaningless. */
2712 #define SWITCH_FALSE -1
2713 #define SWITCH_IGNORE -2
2714 #define SWITCH_LIVE 1
2724 static struct switchstr *switches;
2726 static int n_switches;
2731 const char *language;
2734 /* Also a vector of input files specified. */
2736 static struct infile *infiles;
2738 static int n_infiles;
2740 /* This counts the number of libraries added by lang_specific_driver, so that
2741 we can tell if there were any user supplied any files or libraries. */
2743 static int added_libraries;
2745 /* And a vector of corresponding output files is made up later. */
2747 static const char **outfiles;
2749 /* Used to track if none of the -B paths are used. */
2752 /* Used to track if standard path isn't used and -b or -V is specified. */
2753 static int warn_std;
2755 /* Gives value to pass as "warn" to add_prefix for standard prefixes. */
2756 static int *warn_std_ptr = 0;
2759 #if defined(HAVE_OBJECT_SUFFIX) || defined(HAVE_EXECUTABLE_SUFFIX)
2761 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
2762 is true if we should look for an executable suffix as well. */
2765 convert_filename (name, do_exe)
2775 len = strlen (name);
2777 #ifdef HAVE_OBJECT_SUFFIX
2778 /* Convert x.o to x.obj if OBJECT_SUFFIX is ".obj". */
2780 && name[len - 2] == '.'
2781 && name[len - 1] == 'o')
2783 obstack_grow (&obstack, name, len - 2);
2784 obstack_grow0 (&obstack, OBJECT_SUFFIX, strlen (OBJECT_SUFFIX));
2785 name = obstack_finish (&obstack);
2789 #ifdef HAVE_EXECUTABLE_SUFFIX
2790 /* If there is no filetype, make it the executable suffix (which includes
2791 the "."). But don't get confused if we have just "-o". */
2792 if (! do_exe || EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
2795 for (i = len - 1; i >= 0; i--)
2796 if (IS_DIR_SEPARATOR (name[i]))
2799 for (i++; i < len; i++)
2803 obstack_grow (&obstack, name, len);
2804 obstack_grow0 (&obstack, EXECUTABLE_SUFFIX, strlen (EXECUTABLE_SUFFIX));
2805 name = obstack_finish (&obstack);
2812 /* Display the command line switches accepted by gcc. */
2816 printf (_("Usage: %s [options] file...\n"), programname);
2817 fputs (_("Options:\n"), stdout);
2819 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout);
2820 fputs (_(" --help Display this information\n"), stdout);
2822 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
2823 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout);
2824 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout);
2825 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout);
2826 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout);
2827 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout);
2828 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout);
2829 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout);
2830 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout);
2832 -print-multi-lib Display the mapping between command line options and\n\
2833 multiple library search directories\n"), stdout);
2834 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout);
2835 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout);
2836 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout);
2837 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout);
2838 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout);
2839 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout);
2840 fputs (_(" -time Time the execution of each subprocess\n"), stdout);
2841 fputs (_(" -specs=<file> Override builtin specs with the contents of <file>\n"), stdout);
2842 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout);
2843 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout);
2844 fputs (_(" -b <machine> Run gcc for target <machine>, if installed\n"), stdout);
2845 fputs (_(" -V <version> Run gcc version number <version>, if installed\n"), stdout);
2846 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout);
2847 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout);
2848 fputs (_(" -S Compile only; do not assemble or link\n"), stdout);
2849 fputs (_(" -c Compile and assemble, but do not link\n"), stdout);
2850 fputs (_(" -o <file> Place the output into <file>\n"), stdout);
2852 -x <language> Specify the language of the following input files\n\
2853 Permissable languages include: c c++ assembler none\n\
2854 'none' means revert to the default behaviour of\n\
2855 guessing the language based on the file's extension\n\
2859 \nOptions starting with -g, -f, -m, -O or -W are automatically passed on to\n\
2860 the various sub-processes invoked by %s. In order to pass other options\n\
2861 on to these processes the -W<letter> options must be used.\n\
2864 /* The rest of the options are displayed by invocations of the various
2869 add_preprocessor_option (option, len)
2870 const char * option;
2873 n_preprocessor_options++;
2875 if (! preprocessor_options)
2876 preprocessor_options
2877 = (char **) xmalloc (n_preprocessor_options * sizeof (char *));
2879 preprocessor_options
2880 = (char **) xrealloc (preprocessor_options,
2881 n_preprocessor_options * sizeof (char *));
2883 preprocessor_options [n_preprocessor_options - 1] =
2884 save_string (option, len);
2888 add_assembler_option (option, len)
2889 const char * option;
2892 n_assembler_options++;
2894 if (! assembler_options)
2896 = (char **) xmalloc (n_assembler_options * sizeof (char *));
2899 = (char **) xrealloc (assembler_options,
2900 n_assembler_options * sizeof (char *));
2902 assembler_options [n_assembler_options - 1] = save_string (option, len);
2906 add_linker_option (option, len)
2907 const char * option;
2912 if (! linker_options)
2914 = (char **) xmalloc (n_linker_options * sizeof (char *));
2917 = (char **) xrealloc (linker_options,
2918 n_linker_options * sizeof (char *));
2920 linker_options [n_linker_options - 1] = save_string (option, len);
2923 /* Create the vector `switches' and its contents.
2924 Store its length in `n_switches'. */
2927 process_command (argc, argv)
2934 const char *spec_lang = 0;
2935 int last_language_n_infiles;
2938 int lang_n_infiles = 0;
2940 GET_ENV_PATH_LIST (gcc_exec_prefix, "GCC_EXEC_PREFIX");
2944 added_libraries = 0;
2946 /* Figure compiler version from version string. */
2948 compiler_version = temp1 = xstrdup (version_string);
2950 for (; *temp1; ++temp1)
2959 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
2960 see if we can create it from the pathname specified in argv[0]. */
2963 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
2964 if (!gcc_exec_prefix)
2966 gcc_exec_prefix = make_relative_prefix (argv[0], standard_bindir_prefix,
2967 standard_exec_prefix);
2968 if (gcc_exec_prefix)
2969 putenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL_PTR));
2973 if (gcc_exec_prefix)
2975 int len = strlen (gcc_exec_prefix);
2976 if (len > (int) sizeof ("/lib/gcc-lib/")-1
2977 && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
2979 temp = gcc_exec_prefix + len - sizeof ("/lib/gcc-lib/") + 1;
2980 if (IS_DIR_SEPARATOR (*temp)
2981 && strncmp (temp+1, "lib", 3) == 0
2982 && IS_DIR_SEPARATOR (temp[4])
2983 && strncmp (temp+5, "gcc-lib", 7) == 0)
2984 len -= sizeof ("/lib/gcc-lib/") - 1;
2987 set_std_prefix (gcc_exec_prefix, len);
2988 add_prefix (&exec_prefixes, gcc_exec_prefix, "GCC", 0, 0, NULL_PTR);
2989 add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC", 0, 0, NULL_PTR);
2992 /* COMPILER_PATH and LIBRARY_PATH have values
2993 that are lists of directory names with colons. */
2995 GET_ENV_PATH_LIST (temp, "COMPILER_PATH");
2998 const char *startp, *endp;
2999 char *nstore = (char *) alloca (strlen (temp) + 3);
3001 startp = endp = temp;
3004 if (*endp == PATH_SEPARATOR || *endp == 0)
3006 strncpy (nstore, startp, endp-startp);
3008 strcpy (nstore, concat (".", dir_separator_str, NULL_PTR));
3009 else if (!IS_DIR_SEPARATOR (endp[-1]))
3011 nstore[endp-startp] = DIR_SEPARATOR;
3012 nstore[endp-startp+1] = 0;
3015 nstore[endp-startp] = 0;
3016 add_prefix (&exec_prefixes, nstore, 0, 0, 0, NULL_PTR);
3017 add_prefix (&include_prefixes,
3018 concat (nstore, "include", NULL_PTR),
3022 endp = startp = endp + 1;
3029 GET_ENV_PATH_LIST (temp, LIBRARY_PATH_ENV);
3030 if (temp && *cross_compile == '0')
3032 const char *startp, *endp;
3033 char *nstore = (char *) alloca (strlen (temp) + 3);
3035 startp = endp = temp;
3038 if (*endp == PATH_SEPARATOR || *endp == 0)
3040 strncpy (nstore, startp, endp-startp);
3042 strcpy (nstore, concat (".", dir_separator_str, NULL_PTR));
3043 else if (!IS_DIR_SEPARATOR (endp[-1]))
3045 nstore[endp-startp] = DIR_SEPARATOR;
3046 nstore[endp-startp+1] = 0;
3049 nstore[endp-startp] = 0;
3050 add_prefix (&startfile_prefixes, nstore, NULL_PTR,
3054 endp = startp = endp + 1;
3061 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
3062 GET_ENV_PATH_LIST (temp, "LPATH");
3063 if (temp && *cross_compile == '0')
3065 const char *startp, *endp;
3066 char *nstore = (char *) alloca (strlen (temp) + 3);
3068 startp = endp = temp;
3071 if (*endp == PATH_SEPARATOR || *endp == 0)
3073 strncpy (nstore, startp, endp-startp);
3075 strcpy (nstore, concat (".", dir_separator_str, NULL_PTR));
3076 else if (!IS_DIR_SEPARATOR (endp[-1]))
3078 nstore[endp-startp] = DIR_SEPARATOR;
3079 nstore[endp-startp+1] = 0;
3082 nstore[endp-startp] = 0;
3083 add_prefix (&startfile_prefixes, nstore, NULL_PTR,
3087 endp = startp = endp + 1;
3094 /* Convert new-style -- options to old-style. */
3095 translate_options (&argc, &argv);
3097 /* Do language-specific adjustment/addition of flags. */
3098 lang_specific_driver (&argc, &argv, &added_libraries);
3100 /* Scan argv twice. Here, the first time, just count how many switches
3101 there will be in their vector, and how many input files in theirs.
3102 Here we also parse the switches that cc itself uses (e.g. -v). */
3104 for (i = 1; i < argc; i++)
3106 if (! strcmp (argv[i], "-dumpspecs"))
3108 struct spec_list *sl;
3110 for (sl = specs; sl; sl = sl->next)
3111 printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3112 if (link_command_spec)
3113 printf ("*link_command:\n%s\n\n", link_command_spec);
3116 else if (! strcmp (argv[i], "-dumpversion"))
3118 printf ("%s\n", spec_version);
3121 else if (! strcmp (argv[i], "-dumpmachine"))
3123 printf ("%s\n", spec_machine);
3126 else if (strcmp (argv[i], "-fhelp") == 0)
3128 /* translate_options () has turned --help into -fhelp. */
3129 print_help_list = 1;
3131 /* We will be passing a dummy file on to the sub-processes. */
3135 add_preprocessor_option ("--help", 6);
3136 add_assembler_option ("--help", 6);
3137 add_linker_option ("--help", 6);
3139 else if (! strcmp (argv[i], "-pass-exit-codes"))
3141 pass_exit_codes = 1;
3144 else if (! strcmp (argv[i], "-print-search-dirs"))
3145 print_search_dirs = 1;
3146 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3147 print_file_name = "libgcc.a";
3148 else if (! strncmp (argv[i], "-print-file-name=", 17))
3149 print_file_name = argv[i] + 17;
3150 else if (! strncmp (argv[i], "-print-prog-name=", 17))
3151 print_prog_name = argv[i] + 17;
3152 else if (! strcmp (argv[i], "-print-multi-lib"))
3153 print_multi_lib = 1;
3154 else if (! strcmp (argv[i], "-print-multi-directory"))
3155 print_multi_directory = 1;
3156 else if (! strncmp (argv[i], "-Wa,", 4))
3159 /* Pass the rest of this option to the assembler. */
3161 /* Split the argument at commas. */
3163 for (j = 4; argv[i][j]; j++)
3164 if (argv[i][j] == ',')
3166 add_assembler_option (argv[i] + prev, j - prev);
3170 /* Record the part after the last comma. */
3171 add_assembler_option (argv[i] + prev, j - prev);
3173 else if (! strncmp (argv[i], "-Wp,", 4))
3176 /* Pass the rest of this option to the preprocessor. */
3178 /* Split the argument at commas. */
3180 for (j = 4; argv[i][j]; j++)
3181 if (argv[i][j] == ',')
3183 add_preprocessor_option (argv[i] + prev, j - prev);
3187 /* Record the part after the last comma. */
3188 add_preprocessor_option (argv[i] + prev, j - prev);
3190 else if (argv[i][0] == '+' && argv[i][1] == 'e')
3191 /* The +e options to the C++ front-end. */
3193 else if (strncmp (argv[i], "-Wl,", 4) == 0)
3196 /* Split the argument at commas. */
3197 for (j = 3; argv[i][j]; j++)
3198 n_infiles += (argv[i][j] == ',');
3200 else if (strcmp (argv[i], "-Xlinker") == 0)
3203 fatal ("argument to `-Xlinker' is missing");
3208 else if (strncmp (argv[i], "-l", 2) == 0)
3210 else if (strcmp (argv[i], "-save-temps") == 0)
3212 save_temps_flag = 1;
3215 else if (strcmp (argv[i], "-specs") == 0)
3217 struct user_specs *user = (struct user_specs *)
3218 xmalloc (sizeof (struct user_specs));
3220 fatal ("argument to `-specs' is missing");
3222 user->next = (struct user_specs *)0;
3223 user->filename = argv[i];
3224 if (user_specs_tail)
3225 user_specs_tail->next = user;
3227 user_specs_head = user;
3228 user_specs_tail = user;
3230 else if (strncmp (argv[i], "-specs=", 7) == 0)
3232 struct user_specs *user = (struct user_specs *)
3233 xmalloc (sizeof (struct user_specs));
3234 if (strlen (argv[i]) == 7)
3235 fatal ("argument to `-specs=' is missing");
3237 user->next = (struct user_specs *)0;
3238 user->filename = argv[i]+7;
3239 if (user_specs_tail)
3240 user_specs_tail->next = user;
3242 user_specs_head = user;
3243 user_specs_tail = user;
3245 else if (strcmp (argv[i], "-time") == 0)
3247 else if (argv[i][0] == '-' && argv[i][1] != 0)
3249 register const char *p = &argv[i][1];
3250 register int c = *p;
3256 if (p[1] == 0 && i + 1 == argc)
3257 fatal ("argument to `-b' is missing");
3259 spec_machine = argv[++i];
3261 spec_machine = p + 1;
3263 warn_std_ptr = &warn_std;
3269 if (p[1] == 0 && i + 1 == argc)
3270 fatal ("argument to `-B' is missing");
3275 add_prefix (&exec_prefixes, value, NULL_PTR, 1, 0, &warn_B);
3276 add_prefix (&startfile_prefixes, value, NULL_PTR,
3278 add_prefix (&include_prefixes, concat (value, "include",
3280 NULL_PTR, 1, 0, NULL_PTR);
3282 /* As a kludge, if the arg is "[foo/]stageN/", just add
3283 "[foo/]include" to the include prefix. */
3285 int len = strlen (value);
3288 && (IS_DIR_SEPARATOR (value[len - 8]))))
3289 && strncmp (value + len - 7, "stage", 5) == 0
3290 && ISDIGIT (value[len - 2])
3291 && (IS_DIR_SEPARATOR (value[len - 1])))
3294 add_prefix (&include_prefixes, "include", NULL_PTR,
3298 char *string = xmalloc (len + 1);
3299 strncpy (string, value, len-7);
3300 strcpy (string+len-7, "include");
3301 add_prefix (&include_prefixes, string, NULL_PTR,
3310 case 'v': /* Print our subcommands and print versions. */
3312 /* If they do anything other than exactly `-v', don't set
3313 verbose_flag; rather, continue on to give the error. */
3321 if (p[1] == 0 && i + 1 == argc)
3322 fatal ("argument to `-V' is missing");
3324 spec_version = argv[++i];
3326 spec_version = p + 1;
3327 compiler_version = spec_version;
3328 warn_std_ptr = &warn_std;
3330 /* Validate the version number. Use the same checks
3331 done when inserting it into a spec.
3333 The format of the version string is
3334 ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)? */
3336 const char *v = compiler_version;
3338 /* Ignore leading non-digits. i.e. "foo-" in "foo-2.7.2". */
3339 while (! ISDIGIT (*v))
3342 if (v > compiler_version && v[-1] != '-')
3343 fatal ("invalid version number format");
3345 /* Set V after the first period. */
3346 while (ISDIGIT (*v))
3350 fatal ("invalid version number format");
3353 while (ISDIGIT (*v))
3356 if (*v != 0 && *v != ' ' && *v != '.' && *v != '-')
3357 fatal ("invalid version number format");
3373 #if defined(HAVE_EXECUTABLE_SUFFIX)
3378 /* Forward scan, just in case -S or -c is specified
3385 if (argv[j][0] == '-')
3387 if (SWITCH_CURTAILS_COMPILATION (argv[j][1])
3393 else if (skip = SWITCH_TAKES_ARG (argv[j][1]))
3394 j += skip - (argv[j][2] != 0);
3395 else if (skip = WORD_SWITCH_TAKES_ARG (argv[j] + 1))
3402 #if defined(HAVE_EXECUTABLE_SUFFIX) || defined(HAVE_OBJECT_SUFFIX)
3404 argv[i+1] = convert_filename (argv[i+1], ! have_c);
3406 argv[i] = convert_filename (argv[i], ! have_c);
3414 if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
3415 i += SWITCH_TAKES_ARG (c) - (p[1] != 0);
3416 else if (WORD_SWITCH_TAKES_ARG (p))
3417 i += WORD_SWITCH_TAKES_ARG (p);
3427 if (have_c && have_o && lang_n_infiles > 1)
3428 fatal ("cannot specify -o with -c or -S and multiple compilations");
3430 /* Set up the search paths before we go looking for config files. */
3432 /* These come before the md prefixes so that we will find gcc's subcommands
3433 (such as cpp) rather than those of the host system. */
3434 /* Use 2 as fourth arg meaning try just the machine as a suffix,
3435 as well as trying the machine and the version. */
3437 add_prefix (&exec_prefixes, standard_exec_prefix, "GCC",
3438 0, 1, warn_std_ptr);
3439 add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
3440 0, 2, warn_std_ptr);
3441 add_prefix (&exec_prefixes, standard_exec_prefix_1, "BINUTILS",
3442 0, 2, warn_std_ptr);
3445 add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
3446 0, 1, warn_std_ptr);
3447 add_prefix (&startfile_prefixes, standard_exec_prefix_1, "BINUTILS",
3448 0, 1, warn_std_ptr);
3450 tooldir_prefix = concat (tooldir_base_prefix, spec_machine,
3451 dir_separator_str, NULL_PTR);
3453 /* If tooldir is relative, base it on exec_prefixes. A relative
3454 tooldir lets us move the installed tree as a unit.
3456 If GCC_EXEC_PREFIX is defined, then we want to add two relative
3457 directories, so that we can search both the user specified directory
3458 and the standard place. */
3460 if (!IS_DIR_SEPARATOR (*tooldir_prefix))
3462 if (gcc_exec_prefix)
3464 char *gcc_exec_tooldir_prefix
3465 = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
3466 spec_version, dir_separator_str, tooldir_prefix, NULL_PTR);
3468 add_prefix (&exec_prefixes,
3469 concat (gcc_exec_tooldir_prefix, "bin",
3470 dir_separator_str, NULL_PTR),
3471 NULL_PTR, 0, 0, NULL_PTR);
3472 add_prefix (&startfile_prefixes,
3473 concat (gcc_exec_tooldir_prefix, "lib",
3474 dir_separator_str, NULL_PTR),
3475 NULL_PTR, 0, 0, NULL_PTR);
3478 tooldir_prefix = concat (standard_exec_prefix, spec_machine,
3479 dir_separator_str, spec_version,
3480 dir_separator_str, tooldir_prefix, NULL_PTR);
3483 add_prefix (&exec_prefixes,
3484 concat (tooldir_prefix, "bin", dir_separator_str, NULL_PTR),
3485 "BINUTILS", 0, 0, NULL_PTR);
3486 add_prefix (&startfile_prefixes,
3487 concat (tooldir_prefix, "lib", dir_separator_str, NULL_PTR),
3488 "BINUTILS", 0, 0, NULL_PTR);
3490 /* More prefixes are enabled in main, after we read the specs file
3491 and determine whether this is cross-compilation or not. */
3494 /* Then create the space for the vectors and scan again. */
3496 switches = ((struct switchstr *)
3497 xmalloc ((n_switches + 1) * sizeof (struct switchstr)));
3498 infiles = (struct infile *) xmalloc ((n_infiles + 1) * sizeof (struct infile));
3501 last_language_n_infiles = -1;
3503 /* This, time, copy the text of each switch and store a pointer
3504 to the copy in the vector of switches.
3505 Store all the infiles in their vector. */
3507 for (i = 1; i < argc; i++)
3509 /* Just skip the switches that were handled by the preceding loop. */
3510 if (! strncmp (argv[i], "-Wa,", 4))
3512 else if (! strncmp (argv[i], "-Wp,", 4))
3514 else if (! strcmp (argv[i], "-pass-exit-codes"))
3516 else if (! strcmp (argv[i], "-print-search-dirs"))
3518 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3520 else if (! strncmp (argv[i], "-print-file-name=", 17))
3522 else if (! strncmp (argv[i], "-print-prog-name=", 17))
3524 else if (! strcmp (argv[i], "-print-multi-lib"))
3526 else if (! strcmp (argv[i], "-print-multi-directory"))
3528 else if (strcmp (argv[i], "-fhelp") == 0)
3532 /* Create a dummy input file, so that we can pass --help on to
3533 the various sub-processes. */
3534 infiles[n_infiles].language = "c";
3535 infiles[n_infiles++].name = "help-dummy";
3537 /* Preserve the --help switch so that it can be caught by the
3539 switches[n_switches].part1 = "--help";
3540 switches[n_switches].args = 0;
3541 switches[n_switches].live_cond = SWITCH_OK;
3542 switches[n_switches].validated = 0;
3547 else if (argv[i][0] == '+' && argv[i][1] == 'e')
3549 /* Compensate for the +e options to the C++ front-end;
3550 they're there simply for cfront call-compatibility. We do
3551 some magic in default_compilers to pass them down properly.
3552 Note we deliberately start at the `+' here, to avoid passing
3553 -e0 or -e1 down into the linker. */
3554 switches[n_switches].part1 = &argv[i][0];
3555 switches[n_switches].args = 0;
3556 switches[n_switches].live_cond = SWITCH_OK;
3557 switches[n_switches].validated = 0;
3560 else if (strncmp (argv[i], "-Wl,", 4) == 0)
3563 /* Split the argument at commas. */
3565 for (j = 4; argv[i][j]; j++)
3566 if (argv[i][j] == ',')
3568 infiles[n_infiles].language = "*";
3569 infiles[n_infiles++].name
3570 = save_string (argv[i] + prev, j - prev);
3573 /* Record the part after the last comma. */
3574 infiles[n_infiles].language = "*";
3575 infiles[n_infiles++].name = argv[i] + prev;
3577 else if (strcmp (argv[i], "-Xlinker") == 0)
3579 infiles[n_infiles].language = "*";
3580 infiles[n_infiles++].name = argv[++i];
3582 else if (strncmp (argv[i], "-l", 2) == 0)
3584 infiles[n_infiles].language = "*";
3585 infiles[n_infiles++].name = argv[i];
3587 else if (strcmp (argv[i], "-specs") == 0)
3589 else if (strncmp (argv[i], "-specs=", 7) == 0)
3591 else if (strcmp (argv[i], "-time") == 0)
3593 else if ((save_temps_flag || report_times)
3594 && strcmp (argv[i], "-pipe") == 0)
3596 /* -save-temps overrides -pipe, so that temp files are produced */
3597 if (save_temps_flag)
3598 error ("Warning: -pipe ignored since -save-temps specified");
3599 /* -time overrides -pipe because we can't get correct stats when
3600 multiple children are running at once. */
3601 else if (report_times)
3602 error ("Warning: -pipe ignored since -time specified");
3604 else if (argv[i][0] == '-' && argv[i][1] != 0)
3606 const char *p = &argv[i][1];
3611 if (p[1] == 0 && i + 1 == argc)
3612 fatal ("argument to `-x' is missing");
3614 spec_lang = argv[++i];
3617 if (! strcmp (spec_lang, "none"))
3618 /* Suppress the warning if -xnone comes after the last input
3619 file, because alternate command interfaces like g++ might
3620 find it useful to place -xnone after each input file. */
3623 last_language_n_infiles = n_infiles;
3626 switches[n_switches].part1 = p;
3627 /* Deal with option arguments in separate argv elements. */
3628 if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
3629 || WORD_SWITCH_TAKES_ARG (p))
3632 int n_args = WORD_SWITCH_TAKES_ARG (p);
3636 /* Count only the option arguments in separate argv elements. */
3637 n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
3639 if (i + n_args >= argc)
3640 fatal ("argument to `-%s' is missing", p);
3641 switches[n_switches].args
3642 = (const char **) xmalloc ((n_args + 1) * sizeof(const char *));
3644 switches[n_switches].args[j++] = argv[++i];
3645 /* Null-terminate the vector. */
3646 switches[n_switches].args[j] = 0;
3648 else if (index (switches_need_spaces, c))
3650 /* On some systems, ld cannot handle some options without
3651 a space. So split the option from its argument. */
3652 char *part1 = (char *) xmalloc (2);
3657 switches[n_switches].part1 = part1;
3658 switches[n_switches].args
3659 = (const char **) xmalloc (2 * sizeof (const char *));
3660 switches[n_switches].args[0] = tmp = xmalloc (strlen (p));
3661 strcpy (tmp, &p[1]);
3662 switches[n_switches].args[1] = 0;
3665 switches[n_switches].args = 0;
3667 switches[n_switches].live_cond = SWITCH_OK;
3668 switches[n_switches].validated = 0;
3669 /* This is always valid, since gcc.c itself understands it. */
3670 if (!strcmp (p, "save-temps"))
3671 switches[n_switches].validated = 1;
3674 char ch = switches[n_switches].part1[0];
3675 if (ch == 'V' || ch == 'b' || ch == 'B')
3676 switches[n_switches].validated = 1;
3682 #ifdef HAVE_OBJECT_SUFFIX
3683 argv[i] = convert_filename (argv[i], 0);
3686 if (strcmp (argv[i], "-") != 0 && access (argv[i], R_OK) < 0)
3688 perror_with_name (argv[i]);
3693 infiles[n_infiles].language = spec_lang;
3694 infiles[n_infiles++].name = argv[i];
3699 if (n_infiles == last_language_n_infiles && spec_lang != 0)
3700 error ("Warning: `-x %s' after last input file has no effect", spec_lang);
3702 switches[n_switches].part1 = 0;
3703 infiles[n_infiles].name = 0;
3706 /* Process a spec string, accumulating and running commands. */
3708 /* These variables describe the input file name.
3709 input_file_number is the index on outfiles of this file,
3710 so that the output file name can be stored for later use by %o.
3711 input_basename is the start of the part of the input file
3712 sans all directory names, and basename_length is the number
3713 of characters starting there excluding the suffix .c or whatever. */
3715 const char *input_filename;
3716 static int input_file_number;
3717 size_t input_filename_length;
3718 static int basename_length;
3719 static const char *input_basename;
3720 static const char *input_suffix;
3722 /* These are variables used within do_spec and do_spec_1. */
3724 /* Nonzero if an arg has been started and not yet terminated
3725 (with space, tab or newline). */
3726 static int arg_going;
3728 /* Nonzero means %d or %g has been seen; the next arg to be terminated
3729 is a temporary file name. */
3730 static int delete_this_arg;
3732 /* Nonzero means %w has been seen; the next arg to be terminated
3733 is the output file name of this compilation. */
3734 static int this_is_output_file;
3736 /* Nonzero means %s has been seen; the next arg to be terminated
3737 is the name of a library file and we should try the standard
3738 search dirs for it. */
3739 static int this_is_library_file;
3741 /* Nonzero means that the input of this command is coming from a pipe. */
3742 static int input_from_pipe;
3744 /* Process the spec SPEC and run the commands specified therein.
3745 Returns 0 if the spec is successfully processed; -1 if failed. */
3755 delete_this_arg = 0;
3756 this_is_output_file = 0;
3757 this_is_library_file = 0;
3758 input_from_pipe = 0;
3760 value = do_spec_1 (spec, 0, NULL_PTR);
3762 /* Force out any unfinished command.
3763 If -pipe, this forces out the last command if it ended in `|'. */
3766 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
3769 if (argbuf_index > 0)
3776 /* Process the sub-spec SPEC as a portion of a larger spec.
3777 This is like processing a whole spec except that we do
3778 not initialize at the beginning and we do not supply a
3779 newline by default at the end.
3780 INSWITCH nonzero means don't process %-sequences in SPEC;
3781 in this case, % is treated as an ordinary character.
3782 This is used while substituting switches.
3783 INSWITCH nonzero also causes SPC not to terminate an argument.
3785 Value is zero unless a line was finished
3786 and the command on that line reported an error. */
3789 do_spec_1 (spec, inswitch, soft_matched_part)
3792 const char *soft_matched_part;
3794 register const char *p = spec;
3801 /* If substituting a switch, treat all chars like letters.
3802 Otherwise, NL, SPC, TAB and % are special. */
3803 switch (inswitch ? 'a' : c)
3806 /* End of line: finish any pending argument,
3807 then run the pending command if one has been started. */
3810 obstack_1grow (&obstack, 0);
3811 string = obstack_finish (&obstack);
3812 if (this_is_library_file)
3813 string = find_file (string);
3814 store_arg (string, delete_this_arg, this_is_output_file);
3815 if (this_is_output_file)
3816 outfiles[input_file_number] = string;
3820 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
3822 for (i = 0; i < n_switches; i++)
3823 if (!strcmp (switches[i].part1, "pipe"))
3826 /* A `|' before the newline means use a pipe here,
3827 but only if -pipe was specified.
3828 Otherwise, execute now and don't pass the `|' as an arg. */
3831 input_from_pipe = 1;
3832 switches[i].validated = 1;
3839 if (argbuf_index > 0)
3845 /* Reinitialize for a new command, and for a new argument. */
3848 delete_this_arg = 0;
3849 this_is_output_file = 0;
3850 this_is_library_file = 0;
3851 input_from_pipe = 0;
3855 /* End any pending argument. */
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;
3868 obstack_1grow (&obstack, c);
3874 /* Space or tab ends an argument if one is pending. */
3877 obstack_1grow (&obstack, 0);
3878 string = obstack_finish (&obstack);
3879 if (this_is_library_file)
3880 string = find_file (string);
3881 store_arg (string, delete_this_arg, this_is_output_file);
3882 if (this_is_output_file)
3883 outfiles[input_file_number] = string;
3885 /* Reinitialize for a new argument. */
3887 delete_this_arg = 0;
3888 this_is_output_file = 0;
3889 this_is_library_file = 0;
3896 fatal ("Invalid specification! Bug in cc.");
3899 obstack_grow (&obstack, input_basename, basename_length);
3904 delete_this_arg = 2;
3907 /* Dump out the directories specified with LIBRARY_PATH,
3908 followed by the absolute directories
3909 that we search for startfiles. */
3912 struct prefix_list *pl = startfile_prefixes.plist;
3913 size_t bufsize = 100;
3914 char *buffer = (char *) xmalloc (bufsize);
3917 for (; pl; pl = pl->next)
3919 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
3920 /* Used on systems which record the specified -L dirs
3921 and use them to search for dynamic linking. */
3922 /* Relative directories always come from -B,
3923 and it is better not to use them for searching
3924 at run time. In particular, stage1 loses. */
3925 if (!IS_DIR_SEPARATOR (pl->prefix[0]))
3928 /* Try subdirectory if there is one. */
3929 if (multilib_dir != NULL)
3933 if (strlen (pl->prefix) + strlen (machine_suffix)
3935 bufsize = (strlen (pl->prefix)
3936 + strlen (machine_suffix)) * 2 + 1;
3937 buffer = (char *) xrealloc (buffer, bufsize);
3938 strcpy (buffer, pl->prefix);
3939 strcat (buffer, machine_suffix);
3940 if (is_directory (buffer, multilib_dir, 1))
3942 do_spec_1 ("-L", 0, NULL_PTR);
3943 #ifdef SPACE_AFTER_L_OPTION
3944 do_spec_1 (" ", 0, NULL_PTR);
3946 do_spec_1 (buffer, 1, NULL_PTR);
3947 do_spec_1 (multilib_dir, 1, NULL_PTR);
3948 /* Make this a separate argument. */
3949 do_spec_1 (" ", 0, NULL_PTR);
3952 if (!pl->require_machine_suffix)
3954 if (is_directory (pl->prefix, multilib_dir, 1))
3956 do_spec_1 ("-L", 0, NULL_PTR);
3957 #ifdef SPACE_AFTER_L_OPTION
3958 do_spec_1 (" ", 0, NULL_PTR);
3960 do_spec_1 (pl->prefix, 1, NULL_PTR);
3961 do_spec_1 (multilib_dir, 1, NULL_PTR);
3962 /* Make this a separate argument. */
3963 do_spec_1 (" ", 0, NULL_PTR);
3969 if (is_directory (pl->prefix, machine_suffix, 1))
3971 do_spec_1 ("-L", 0, NULL_PTR);
3972 #ifdef SPACE_AFTER_L_OPTION
3973 do_spec_1 (" ", 0, NULL_PTR);
3975 do_spec_1 (pl->prefix, 1, NULL_PTR);
3976 /* Remove slash from machine_suffix. */
3977 if (strlen (machine_suffix) >= bufsize)
3978 bufsize = strlen (machine_suffix) * 2 + 1;
3979 buffer = (char *) xrealloc (buffer, bufsize);
3980 strcpy (buffer, machine_suffix);
3981 idx = strlen (buffer);
3982 if (IS_DIR_SEPARATOR (buffer[idx - 1]))
3983 buffer[idx - 1] = 0;
3984 do_spec_1 (buffer, 1, NULL_PTR);
3985 /* Make this a separate argument. */
3986 do_spec_1 (" ", 0, NULL_PTR);
3989 if (!pl->require_machine_suffix)
3991 if (is_directory (pl->prefix, "", 1))
3993 do_spec_1 ("-L", 0, NULL_PTR);
3994 #ifdef SPACE_AFTER_L_OPTION
3995 do_spec_1 (" ", 0, NULL_PTR);
3997 /* Remove slash from pl->prefix. */
3998 if (strlen (pl->prefix) >= bufsize)
3999 bufsize = strlen (pl->prefix) * 2 + 1;
4000 buffer = (char *) xrealloc (buffer, bufsize);
4001 strcpy (buffer, pl->prefix);
4002 idx = strlen (buffer);
4003 if (IS_DIR_SEPARATOR (buffer[idx - 1]))
4004 buffer[idx - 1] = 0;
4005 do_spec_1 (buffer, 1, NULL_PTR);
4006 /* Make this a separate argument. */
4007 do_spec_1 (" ", 0, NULL_PTR);
4016 /* %efoo means report an error with `foo' as error message
4017 and don't execute any more commands for this file. */
4021 while (*p != 0 && *p != '\n') p++;
4022 buf = (char *) alloca (p - q + 1);
4023 strncpy (buf, q, p - q);
4033 if (save_temps_flag)
4035 obstack_grow (&obstack, input_basename, basename_length);
4036 delete_this_arg = 0;
4040 #ifdef MKTEMP_EACH_FILE
4041 /* ??? This has a problem: the total number of
4042 values mktemp can return is limited.
4043 That matters for the names of object files.
4044 In 2.4, do something about that. */
4045 struct temp_name *t;
4047 const char *suffix = p;
4048 char *saved_suffix = NULL;
4050 while (*p == '.' || ISALPHA ((unsigned char)*p))
4052 suffix_length = p - suffix;
4053 if (p[0] == '%' && p[1] == 'O')
4056 /* We don't support extra suffix characters after %O. */
4057 if (*p == '.' || ISALPHA ((unsigned char)*p))
4059 if (suffix_length == 0)
4060 suffix = OBJECT_SUFFIX;
4064 = (char *) xmalloc (suffix_length
4065 + strlen (OBJECT_SUFFIX));
4066 strncpy (saved_suffix, suffix, suffix_length);
4067 strcpy (saved_suffix + suffix_length,
4070 suffix_length += strlen (OBJECT_SUFFIX);
4073 /* See if we already have an association of %g/%u/%U and
4075 for (t = temp_names; t; t = t->next)
4076 if (t->length == suffix_length
4077 && strncmp (t->suffix, suffix, suffix_length) == 0
4078 && t->unique == (c != 'g'))
4081 /* Make a new association if needed. %u requires one. */
4082 if (t == 0 || c == 'u')
4086 t = (struct temp_name *) xmalloc (sizeof (struct temp_name));
4087 t->next = temp_names;
4090 t->length = suffix_length;
4091 t->suffix = save_string (suffix, suffix_length);
4092 t->unique = (c != 'g');
4093 temp_filename = make_temp_file (t->suffix);
4094 temp_filename_length = strlen (temp_filename);
4095 t->filename = temp_filename;
4096 t->filename_length = temp_filename_length;
4100 free (saved_suffix);
4102 obstack_grow (&obstack, t->filename, t->filename_length);
4103 delete_this_arg = 1;
4105 obstack_grow (&obstack, temp_filename, temp_filename_length);
4106 if (c == 'u' || c == 'U')
4112 sprintf (buff, "%d", unique);
4113 obstack_grow (&obstack, buff, strlen (buff));
4116 delete_this_arg = 1;
4122 obstack_grow (&obstack, input_filename, input_filename_length);
4128 struct prefix_list *pl = include_prefixes.plist;
4130 if (gcc_exec_prefix)
4132 do_spec_1 ("-iprefix", 1, NULL_PTR);
4133 /* Make this a separate argument. */
4134 do_spec_1 (" ", 0, NULL_PTR);
4135 do_spec_1 (gcc_exec_prefix, 1, NULL_PTR);
4136 do_spec_1 (" ", 0, NULL_PTR);
4139 for (; pl; pl = pl->next)
4141 do_spec_1 ("-isystem", 1, NULL_PTR);
4142 /* Make this a separate argument. */
4143 do_spec_1 (" ", 0, NULL_PTR);
4144 do_spec_1 (pl->prefix, 1, NULL_PTR);
4145 do_spec_1 (" ", 0, NULL_PTR);
4152 int max = n_infiles;
4153 max += lang_specific_extra_outfiles;
4155 for (i = 0; i < max; i++)
4157 store_arg (outfiles[i], 0, 0);
4162 obstack_grow (&obstack, OBJECT_SUFFIX, strlen (OBJECT_SUFFIX));
4167 this_is_library_file = 1;
4171 this_is_output_file = 1;
4176 int cur_index = argbuf_index;
4177 /* Handle the {...} following the %W. */
4180 p = handle_braces (p + 1);
4183 /* If any args were output, mark the last one for deletion
4185 if (argbuf_index != cur_index)
4186 record_temp_file (argbuf[argbuf_index - 1], 0, 1);
4190 /* %x{OPTION} records OPTION for %X to output. */
4196 /* Skip past the option value and make a copy. */
4201 string = save_string (p1 + 1, p - p1 - 2);
4203 /* See if we already recorded this option. */
4204 for (i = 0; i < n_linker_options; i++)
4205 if (! strcmp (string, linker_options[i]))
4211 /* This option is new; add it. */
4212 add_linker_option (string, strlen (string));
4216 /* Dump out the options accumulated previously using %x. */
4218 for (i = 0; i < n_linker_options; i++)
4220 do_spec_1 (linker_options[i], 1, NULL_PTR);
4221 /* Make each accumulated option a separate argument. */
4222 do_spec_1 (" ", 0, NULL_PTR);
4226 /* Dump out the options accumulated previously using -Wa,. */
4228 for (i = 0; i < n_assembler_options; i++)
4230 do_spec_1 (assembler_options[i], 1, NULL_PTR);
4231 /* Make each accumulated option a separate argument. */
4232 do_spec_1 (" ", 0, NULL_PTR);
4236 /* Dump out the options accumulated previously using -Wp,. */
4238 for (i = 0; i < n_preprocessor_options; i++)
4240 do_spec_1 (preprocessor_options[i], 1, NULL_PTR);
4241 /* Make each accumulated option a separate argument. */
4242 do_spec_1 (" ", 0, NULL_PTR);
4246 /* Here are digits and numbers that just process
4247 a certain constant string as a spec. */
4250 value = do_spec_1 (cc1_spec, 0, NULL_PTR);
4256 value = do_spec_1 (cc1plus_spec, 0, NULL_PTR);
4262 value = do_spec_1 (asm_spec, 0, NULL_PTR);
4268 value = do_spec_1 (asm_final_spec, 0, NULL_PTR);
4274 value = do_spec_1 (signed_char_spec, 0, NULL_PTR);
4280 value = do_spec_1 (cpp_spec, 0, NULL_PTR);
4286 value = do_spec_1 (endfile_spec, 0, NULL_PTR);
4292 value = do_spec_1 (link_spec, 0, NULL_PTR);
4298 value = do_spec_1 (lib_spec, 0, NULL_PTR);
4304 value = do_spec_1 (libgcc_spec, 0, NULL_PTR);
4311 char *x = (char *) alloca (strlen (cpp_predefines) + 1);
4315 /* Copy all of the -D options in CPP_PREDEFINES into BUF. */
4319 if (! strncmp (y, "-D", 2))
4320 /* Copy the whole option. */
4321 while (*y && *y != ' ' && *y != '\t')
4323 else if (*y == ' ' || *y == '\t')
4324 /* Copy whitespace to the result. */
4326 /* Don't copy other options. */
4333 value = do_spec_1 (buf, 0, NULL_PTR);
4341 char *x = (char *) alloca (strlen (cpp_predefines) * 4 + 1);
4345 /* Copy all of CPP_PREDEFINES into BUF,
4346 but force them all into the reserved name space if they
4347 aren't already there. The reserved name space is all
4348 identifiers beginning with two underscores or with one
4349 underscore and a capital letter. We do the forcing by
4350 adding up to two underscores to the beginning and end
4351 of each symbol. e.g. mips, _mips, mips_, and _mips_ all
4356 if (! strncmp (y, "-D", 2))
4365 && ! ISUPPER ((unsigned char)*(y+1))))
4367 /* Stick __ at front of macro name. */
4371 /* Arrange to stick __ at the end as well. */
4375 /* Copy the macro name. */
4376 while (*y && *y != '=' && *y != ' ' && *y != '\t')
4389 /* Copy the value given, if any. */
4390 while (*y && *y != ' ' && *y != '\t')
4393 else if (*y == ' ' || *y == '\t')
4394 /* Copy whitespace to the result. */
4396 /* Don't copy -A options */
4402 /* Copy all of CPP_PREDEFINES into BUF,
4403 but put __ after every -D. */
4407 if (! strncmp (y, "-D", 2))
4413 && ! ISUPPER ((unsigned char)*(y+1))))
4415 /* Stick -D__ at front of macro name. */
4422 /* Copy the macro name. */
4423 while (*y && *y != '=' && *y != ' ' && *y != '\t')
4426 /* Copy the value given, if any. */
4427 while (*y && *y != ' ' && *y != '\t')
4432 /* Do not copy this macro - we have just done it before */
4433 while (*y && *y != ' ' && *y != '\t')
4437 else if (*y == ' ' || *y == '\t')
4438 /* Copy whitespace to the result. */
4440 /* Don't copy -A options. */
4446 /* Copy all of the -A options in CPP_PREDEFINES into BUF. */
4450 if (! strncmp (y, "-A", 2))
4451 /* Copy the whole option. */
4452 while (*y && *y != ' ' && *y != '\t')
4454 else if (*y == ' ' || *y == '\t')
4455 /* Copy whitespace to the result. */
4457 /* Don't copy other options. */
4464 value = do_spec_1 (buf, 0, NULL_PTR);
4471 value = do_spec_1 (startfile_spec, 0, NULL_PTR);
4476 /* Here we define characters other than letters and digits. */
4479 p = handle_braces (p);
4485 obstack_1grow (&obstack, '%');
4489 if (soft_matched_part)
4491 do_spec_1 (soft_matched_part, 1, NULL_PTR);
4492 do_spec_1 (" ", 0, NULL_PTR);
4495 /* Catch the case where a spec string contains something like
4496 '%{foo:%*}'. ie there is no * in the pattern on the left
4497 hand side of the :. */
4498 error ("Spec failure: '%%*' has not been initialised by pattern match");
4501 /* Process a string found as the value of a spec given by name.
4502 This feature allows individual machine descriptions
4503 to add and use their own specs.
4504 %[...] modifies -D options the way %P does;
4505 %(...) uses the spec unmodified. */
4507 error ("Warning: use of obsolete %%[ operator in specs");
4510 const char *name = p;
4511 struct spec_list *sl;
4514 /* The string after the S/P is the name of a spec that is to be
4516 while (*p && *p != ')' && *p != ']')
4519 /* See if it's in the list. */
4520 for (len = p - name, sl = specs; sl; sl = sl->next)
4521 if (sl->name_len == len && !strncmp (sl->name, name, len))
4523 name = *(sl->ptr_spec);
4525 notice ("Processing spec %c%s%c, which is '%s'\n",
4526 c, sl->name, (c == '(') ? ')' : ']', name);
4535 value = do_spec_1 (name, 0, NULL_PTR);
4541 char *x = (char *) alloca (strlen (name) * 2 + 1);
4543 const char *y = name;
4546 /* Copy all of NAME into BUF, but put __ after
4547 every -D and at the end of each arg. */
4550 if (! strncmp (y, "-D", 2))
4560 else if (flag && (*y == ' ' || *y == '\t' || *y == '='
4561 || *y == '}' || *y == 0))
4574 value = do_spec_1 (buf, 0, NULL_PTR);
4580 /* Discard the closing paren or bracket. */
4588 int c1 = *p++; /* Select first or second version number. */
4589 const char *v = compiler_version;
4591 static const char zeroc = '0';
4593 /* The format of the version string is
4594 ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)? */
4596 /* Ignore leading non-digits. i.e. "foo-" in "foo-2.7.2". */
4597 while (! ISDIGIT (*v))
4599 if (v > compiler_version && v[-1] != '-')
4602 /* If desired, advance to second version number. */
4605 /* Set V after the first period. */
4606 while (ISDIGIT (*v))
4613 /* If desired, advance to third version number.
4614 But don't complain if it's not present */
4617 /* Set V after the second period. */
4618 while (ISDIGIT (*v))
4620 if ((*v != 0) && (*v != ' ') && (*v != '.') && (*v != '-'))
4626 /* Set Q at the next period or at the end. */
4628 while (ISDIGIT (*q))
4630 if (*q != 0 && q > v && *q != ' ' && *q != '.' && *q != '-')
4634 /* Put that part into the command. */
4635 obstack_grow (&obstack, v, q - v);
4637 /* Default to "0" */
4638 obstack_grow (&obstack, &zeroc, 1);
4644 if (input_from_pipe)
4645 do_spec_1 ("-", 0, NULL_PTR);
4649 error ("Spec failure: Unrecognised spec option '%c'", c);
4655 /* Backslash: treat next character as ordinary. */
4660 /* Ordinary character: put it into the current argument. */
4661 obstack_1grow (&obstack, c);
4665 return 0; /* End of string */
4668 /* Return 0 if we call do_spec_1 and that returns -1. */
4672 register const char *p;
4674 const char *filter, *body = NULL, *endbody = NULL;
4678 int include_blanks = 1;
4679 int elide_switch = 0;
4683 /* A '^' after the open-brace means to not give blanks before args. */
4690 /* A `|' after the open-brace means,
4691 if the test fails, output a single minus sign rather than nothing.
4692 This is used in %{|!pipe:...}. */
4699 /* A `<' after the open-brace means that the switch should be
4700 removed from the command-line. */
4706 negate = suffix = 0;
4709 /* A `!' after the open-brace negates the condition:
4710 succeed if the specified switch is not present. */
4714 /* A `.' after the open-brace means test against the current suffix. */
4723 if (elide_switch && (negate || pipe_p || suffix))
4725 /* It doesn't make sense to mix elision with other flags. We
4726 could fatal() here, but the standard seems to be to abort. */
4731 while (*p != ':' && *p != '}' && *p != '|') p++;
4733 if (*p == '|' && pipe_p)
4740 register int count = 1;
4741 register const char *q = p;
4743 while (*q++ != ':') continue;
4759 body = p, endbody = p+1;
4764 int found = (input_suffix != 0
4765 && (long) strlen (input_suffix) == (long)(p - filter)
4766 && strncmp (input_suffix, filter, p - filter) == 0);
4772 && do_spec_1 (save_string (body, endbody-body-1), 0, NULL_PTR) < 0)
4775 else if (p[-1] == '*' && p[0] == '}')
4777 /* Substitute all matching switches as separate args. */
4780 for (i = 0; i < n_switches; i++)
4781 if (!strncmp (switches[i].part1, filter, p - filter)
4782 && check_live_switch (i, p - filter))
4783 give_switch (i, 0, include_blanks);
4787 /* Test for presence of the specified switch. */
4791 /* If name specified ends in *, as in {x*:...},
4792 check for %* and handle that case. */
4793 if (p[-1] == '*' && !negate)
4796 const char *r = body;
4798 /* First see whether we have %*. */
4802 if (*r == '%' && r[1] == '*')
4806 /* If we do, handle that case. */
4809 /* Substitute all matching switches as separate args.
4810 But do this by substituting for %*
4811 in the text that follows the colon. */
4813 unsigned hard_match_len = p - filter - 1;
4814 char *string = save_string (body, endbody - body - 1);
4816 for (i = 0; i < n_switches; i++)
4817 if (!strncmp (switches[i].part1, filter, hard_match_len)
4818 && check_live_switch (i, -1))
4820 do_spec_1 (string, 0, &switches[i].part1[hard_match_len]);
4821 /* Pass any arguments this switch has. */
4822 give_switch (i, 1, 1);
4825 /* We didn't match. Try again. */
4832 /* If name specified ends in *, as in {x*:...},
4833 check for presence of any switch name starting with x. */
4836 for (i = 0; i < n_switches; i++)
4838 unsigned hard_match_len = p - filter - 1;
4840 if (!strncmp (switches[i].part1, filter, hard_match_len)
4841 && check_live_switch (i, hard_match_len))
4848 /* Otherwise, check for presence of exact name specified. */
4851 for (i = 0; i < n_switches; i++)
4853 if (!strncmp (switches[i].part1, filter, p - filter)
4854 && switches[i].part1[p - filter] == 0
4855 && check_live_switch (i, -1))
4863 /* If it is as desired (present for %{s...}, absent for %{!s...})
4864 then substitute either the switch or the specified
4865 conditional text. */
4866 if (present != negate)
4870 switches[i].live_cond = SWITCH_IGNORE;
4871 switches[i].validated = 1;
4875 give_switch (i, 0, include_blanks);
4879 if (do_spec_1 (save_string (body, endbody - body - 1),
4886 /* Here if a %{|...} conditional fails: output a minus sign,
4887 which means "standard output" or "standard input". */
4888 do_spec_1 ("-", 0, NULL_PTR);
4893 /* We didn't match; try again. */
4900 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
4901 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
4902 spec, or -1 if either exact match or %* is used.
4904 A -O switch is obsoleted by a later -O switch. A -f, -m, or -W switch
4905 whose value does not begin with "no-" is obsoleted by the same value
4906 with the "no-", similarly for a switch with the "no-" prefix. */
4909 check_live_switch (switchnum, prefix_length)
4913 const char *name = switches[switchnum].part1;
4916 /* In the common case of {<at-most-one-letter>*}, a negating
4917 switch would always match, so ignore that case. We will just
4918 send the conflicting switches to the compiler phase. */
4919 if (prefix_length >= 0 && prefix_length <= 1)
4922 /* If we already processed this switch and determined if it was
4923 live or not, return our past determination. */
4924 if (switches[switchnum].live_cond != 0)
4925 return switches[switchnum].live_cond > 0;
4927 /* Now search for duplicate in a manner that depends on the name. */
4931 for (i = switchnum + 1; i < n_switches; i++)
4932 if (switches[i].part1[0] == 'O')
4934 switches[switchnum].validated = 1;
4935 switches[switchnum].live_cond = SWITCH_FALSE;
4940 case 'W': case 'f': case 'm':
4941 if (! strncmp (name + 1, "no-", 3))
4943 /* We have Xno-YYY, search for XYYY. */
4944 for (i = switchnum + 1; i < n_switches; i++)
4945 if (switches[i].part1[0] == name[0]
4946 && ! strcmp (&switches[i].part1[1], &name[4]))
4948 switches[switchnum].validated = 1;
4949 switches[switchnum].live_cond = SWITCH_FALSE;
4955 /* We have XYYY, search for Xno-YYY. */
4956 for (i = switchnum + 1; i < n_switches; i++)
4957 if (switches[i].part1[0] == name[0]
4958 && switches[i].part1[1] == 'n'
4959 && switches[i].part1[2] == 'o'
4960 && switches[i].part1[3] == '-'
4961 && !strcmp (&switches[i].part1[4], &name[1]))
4963 switches[switchnum].validated = 1;
4964 switches[switchnum].live_cond = SWITCH_FALSE;
4971 /* Otherwise the switch is live. */
4972 switches[switchnum].live_cond = SWITCH_LIVE;
4976 /* Pass a switch to the current accumulating command
4977 in the same form that we received it.
4978 SWITCHNUM identifies the switch; it is an index into
4979 the vector of switches gcc received, which is `switches'.
4980 This cannot fail since it never finishes a command line.
4982 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument.
4984 If INCLUDE_BLANKS is nonzero, then we include blanks before each argument
4988 give_switch (switchnum, omit_first_word, include_blanks)
4990 int omit_first_word;
4993 if (switches[switchnum].live_cond == SWITCH_IGNORE)
4996 if (!omit_first_word)
4998 do_spec_1 ("-", 0, NULL_PTR);
4999 do_spec_1 (switches[switchnum].part1, 1, NULL_PTR);
5002 if (switches[switchnum].args != 0)
5005 for (p = switches[switchnum].args; *p; p++)
5008 do_spec_1 (" ", 0, NULL_PTR);
5009 do_spec_1 (*p, 1, NULL_PTR);
5013 do_spec_1 (" ", 0, NULL_PTR);
5014 switches[switchnum].validated = 1;
5017 /* Search for a file named NAME trying various prefixes including the
5018 user's -B prefix and some standard ones.
5019 Return the absolute file name found. If nothing is found, return NAME. */
5027 /* Try multilib_dir if it is defined. */
5028 if (multilib_dir != NULL)
5032 try = (char *) alloca (strlen (multilib_dir) + strlen (name) + 2);
5033 strcpy (try, multilib_dir);
5034 strcat (try, dir_separator_str);
5037 newname = find_a_file (&startfile_prefixes, try, R_OK);
5039 /* If we don't find it in the multi library dir, then fall
5040 through and look for it in the normal places. */
5041 if (newname != NULL)
5045 newname = find_a_file (&startfile_prefixes, name, R_OK);
5046 return newname ? newname : name;
5049 /* Determine whether a directory exists. If LINKER, return 0 for
5050 certain fixed names not needed by the linker. If not LINKER, it is
5051 only important to return 0 if the host machine has a small ARG_MAX
5055 is_directory (path1, path2, linker)
5060 int len1 = strlen (path1);
5061 int len2 = strlen (path2);
5062 char *path = (char *) alloca (3 + len1 + len2);
5066 #ifndef SMALL_ARG_MAX
5071 /* Construct the path from the two parts. Ensure the string ends with "/.".
5072 The resulting path will be a directory even if the given path is a
5074 memcpy (path, path1, len1);
5075 memcpy (path + len1, path2, len2);
5076 cp = path + len1 + len2;
5077 if (!IS_DIR_SEPARATOR (cp[-1]))
5078 *cp++ = DIR_SEPARATOR;
5082 /* Exclude directories that the linker is known to search. */
5085 && strcmp (path, concat (dir_separator_str, "lib",
5086 dir_separator_str, ".", NULL_PTR)) == 0)
5088 && strcmp (path, concat (dir_separator_str, "usr",
5089 dir_separator_str, "lib",
5090 dir_separator_str, ".", NULL_PTR)) == 0)))
5093 return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
5096 /* Set up the various global variables to indicate that we're processing
5097 the input file named FILENAME. */
5100 set_input (filename)
5101 const char *filename;
5103 register const char *p;
5105 input_filename = filename;
5106 input_filename_length = strlen (input_filename);
5108 input_basename = input_filename;
5109 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
5110 /* Skip drive name so 'x:foo' is handled properly. */
5111 if (input_basename[1] == ':')
5112 input_basename += 2;
5114 for (p = input_basename; *p; p++)
5115 if (IS_DIR_SEPARATOR (*p))
5116 input_basename = p + 1;
5118 /* Find a suffix starting with the last period,
5119 and set basename_length to exclude that suffix. */
5120 basename_length = strlen (input_basename);
5121 p = input_basename + basename_length;
5122 while (p != input_basename && *p != '.') --p;
5123 if (*p == '.' && p != input_basename)
5125 basename_length = p - input_basename;
5126 input_suffix = p + 1;
5132 /* On fatal signals, delete all the temporary files. */
5135 fatal_error (signum)
5138 signal (signum, SIG_DFL);
5139 delete_failure_queue ();
5140 delete_temp_files ();
5141 /* Get the same signal again, this time not handled,
5142 so its normal effect occurs. */
5143 kill (getpid (), signum);
5146 extern int main PARAMS ((int, char **));
5156 int linker_was_run = 0;
5157 char *explicit_link_files;
5160 struct user_specs *uptr;
5162 p = argv[0] + strlen (argv[0]);
5163 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
5167 #ifdef HAVE_LC_MESSAGES
5168 setlocale (LC_MESSAGES, "");
5170 (void) bindtextdomain (PACKAGE, localedir);
5171 (void) textdomain (PACKAGE);
5173 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
5174 signal (SIGINT, fatal_error);
5176 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
5177 signal (SIGHUP, fatal_error);
5179 if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
5180 signal (SIGTERM, fatal_error);
5182 if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
5183 signal (SIGPIPE, fatal_error);
5187 argbuf = (const char **) xmalloc (argbuf_length * sizeof (const char *));
5189 obstack_init (&obstack);
5191 /* Build multilib_select, et. al from the separate lines that make up each
5192 multilib selection. */
5194 const char *const *q = multilib_raw;
5197 obstack_init (&multilib_obstack);
5198 while ((p = *q++) != (char *) 0)
5199 obstack_grow (&multilib_obstack, p, strlen (p));
5201 obstack_1grow (&multilib_obstack, 0);
5202 multilib_select = obstack_finish (&multilib_obstack);
5204 q = multilib_matches_raw;
5205 while ((p = *q++) != (char *) 0)
5206 obstack_grow (&multilib_obstack, p, strlen (p));
5208 obstack_1grow (&multilib_obstack, 0);
5209 multilib_matches = obstack_finish (&multilib_obstack);
5211 q = multilib_exclusions_raw;
5212 while ((p = *q++) != (char *) 0)
5213 obstack_grow (&multilib_obstack, p, strlen (p));
5215 obstack_1grow (&multilib_obstack, 0);
5216 multilib_exclusions = obstack_finish (&multilib_obstack);
5220 i < sizeof (multilib_defaults_raw) / sizeof (multilib_defaults_raw[0]);
5224 obstack_1grow (&multilib_obstack, ' ');
5225 obstack_grow (&multilib_obstack,
5226 multilib_defaults_raw[i],
5227 strlen (multilib_defaults_raw[i]));
5231 obstack_1grow (&multilib_obstack, 0);
5232 multilib_defaults = obstack_finish (&multilib_obstack);
5235 /* Set up to remember the pathname of gcc and any options
5236 needed for collect. We use argv[0] instead of programname because
5237 we need the complete pathname. */
5238 obstack_init (&collect_obstack);
5239 obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=")-1);
5240 obstack_grow (&collect_obstack, argv[0], strlen (argv[0])+1);
5241 putenv (obstack_finish (&collect_obstack));
5243 #ifdef INIT_ENVIRONMENT
5244 /* Set up any other necessary machine specific environment variables. */
5245 putenv (INIT_ENVIRONMENT);
5248 /* Choose directory for temp files. */
5250 #ifndef MKTEMP_EACH_FILE
5251 temp_filename = choose_temp_base ();
5252 temp_filename_length = strlen (temp_filename);
5255 /* Make a table of what switches there are (switches, n_switches).
5256 Make a table of specified input files (infiles, n_infiles).
5257 Decode switches that are handled locally. */
5259 process_command (argc, argv);
5264 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
5266 obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
5267 sizeof ("COLLECT_GCC_OPTIONS=")-1);
5270 for (i = 0; (int)i < n_switches; i++)
5275 obstack_grow (&collect_obstack, " ", 1);
5278 obstack_grow (&collect_obstack, "'-", 2);
5279 q = switches[i].part1;
5280 while ((p = index (q,'\'')))
5282 obstack_grow (&collect_obstack, q, p-q);
5283 obstack_grow (&collect_obstack, "'\\''", 4);
5286 obstack_grow (&collect_obstack, q, strlen (q));
5287 obstack_grow (&collect_obstack, "'", 1);
5289 for (args = switches[i].args; args && *args; args++)
5291 obstack_grow (&collect_obstack, " '", 2);
5293 while ((p = index (q,'\'')))
5295 obstack_grow (&collect_obstack, q, p-q);
5296 obstack_grow (&collect_obstack, "'\\''", 4);
5299 obstack_grow (&collect_obstack, q, strlen (q));
5300 obstack_grow (&collect_obstack, "'", 1);
5303 obstack_grow (&collect_obstack, "\0", 1);
5304 putenv (obstack_finish (&collect_obstack));
5307 /* Initialize the vector of specs to just the default.
5308 This means one element containing 0s, as a terminator. */
5310 compilers = (struct compiler *) xmalloc (sizeof default_compilers);
5311 bcopy ((char *) default_compilers, (char *) compilers,
5312 sizeof default_compilers);
5313 n_compilers = n_default_compilers;
5315 /* Read specs from a file if there is one. */
5317 machine_suffix = concat (spec_machine, dir_separator_str,
5318 spec_version, dir_separator_str, NULL_PTR);
5319 just_machine_suffix = concat (spec_machine, dir_separator_str, NULL_PTR);
5321 specs_file = find_a_file (&startfile_prefixes, "specs", R_OK);
5322 /* Read the specs file unless it is a default one. */
5323 if (specs_file != 0 && strcmp (specs_file, "specs"))
5324 read_specs (specs_file, TRUE);
5328 /* We need to check standard_exec_prefix/just_machine_suffix/specs
5329 for any override of as, ld and libraries. */
5330 specs_file = (char *) alloca (strlen (standard_exec_prefix)
5331 + strlen (just_machine_suffix)
5332 + sizeof ("specs"));
5334 strcpy (specs_file, standard_exec_prefix);
5335 strcat (specs_file, just_machine_suffix);
5336 strcat (specs_file, "specs");
5337 if (access (specs_file, R_OK) == 0)
5338 read_specs (specs_file, TRUE);
5340 /* If not cross-compiling, look for startfiles in the standard places. */
5341 if (*cross_compile == '0')
5343 #ifdef MD_EXEC_PREFIX
5344 add_prefix (&exec_prefixes, md_exec_prefix, "GCC", 0, 0, NULL_PTR);
5345 add_prefix (&startfile_prefixes, md_exec_prefix, "GCC", 0, 0, NULL_PTR);
5348 #ifdef MD_STARTFILE_PREFIX
5349 add_prefix (&startfile_prefixes, md_startfile_prefix, "GCC",
5353 #ifdef MD_STARTFILE_PREFIX_1
5354 add_prefix (&startfile_prefixes, md_startfile_prefix_1, "GCC",
5358 /* If standard_startfile_prefix is relative, base it on
5359 standard_exec_prefix. This lets us move the installed tree
5360 as a unit. If GCC_EXEC_PREFIX is defined, base
5361 standard_startfile_prefix on that as well. */
5362 if (IS_DIR_SEPARATOR (*standard_startfile_prefix)
5363 || *standard_startfile_prefix == '$'
5364 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
5365 /* Check for disk name on MS-DOS-based systems. */
5366 || (standard_startfile_prefix[1] == ':'
5367 && (IS_DIR_SEPARATOR (standard_startfile_prefix[2])))
5370 add_prefix (&startfile_prefixes, standard_startfile_prefix, "BINUTILS",
5374 if (gcc_exec_prefix)
5375 add_prefix (&startfile_prefixes,
5376 concat (gcc_exec_prefix, machine_suffix,
5377 standard_startfile_prefix, NULL_PTR),
5378 NULL_PTR, 0, 0, NULL_PTR);
5379 add_prefix (&startfile_prefixes,
5380 concat (standard_exec_prefix,
5382 standard_startfile_prefix, NULL_PTR),
5383 NULL_PTR, 0, 0, NULL_PTR);
5386 add_prefix (&startfile_prefixes, standard_startfile_prefix_1,
5387 "BINUTILS", 0, 0, NULL_PTR);
5388 add_prefix (&startfile_prefixes, standard_startfile_prefix_2,
5389 "BINUTILS", 0, 0, NULL_PTR);
5390 #if 0 /* Can cause surprises, and one can use -B./ instead. */
5391 add_prefix (&startfile_prefixes, "./", NULL_PTR, 0, 1, NULL_PTR);
5396 if (!IS_DIR_SEPARATOR (*standard_startfile_prefix) && gcc_exec_prefix)
5397 add_prefix (&startfile_prefixes,
5398 concat (gcc_exec_prefix, machine_suffix,
5399 standard_startfile_prefix, NULL_PTR),
5400 "BINUTILS", 0, 0, NULL_PTR);
5403 /* Process any user specified specs in the order given on the command
5405 for (uptr = user_specs_head; uptr; uptr = uptr->next)
5407 char *filename = find_a_file (&startfile_prefixes, uptr->filename, R_OK);
5408 read_specs (filename ? filename : uptr->filename, FALSE);
5411 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
5412 if (gcc_exec_prefix)
5414 char * temp = (char *) xmalloc (strlen (gcc_exec_prefix)
5415 + strlen (spec_version)
5416 + strlen (spec_machine) + 3);
5417 strcpy (temp, gcc_exec_prefix);
5418 strcat (temp, spec_machine);
5419 strcat (temp, dir_separator_str);
5420 strcat (temp, spec_version);
5421 strcat (temp, dir_separator_str);
5422 gcc_exec_prefix = temp;
5425 /* Now we have the specs.
5426 Set the `valid' bits for switches that match anything in any spec. */
5428 validate_all_switches ();
5430 /* Now that we have the switches and the specs, set
5431 the subdirectory based on the options. */
5432 set_multilib_dir ();
5434 /* Warn about any switches that no pass was interested in. */
5436 for (i = 0; (int)i < n_switches; i++)
5437 if (! switches[i].validated)
5438 error ("unrecognized option `-%s'", switches[i].part1);
5440 /* Obey some of the options. */
5442 if (print_search_dirs)
5444 printf (_("install: %s%s\n"), standard_exec_prefix, machine_suffix);
5445 printf (_("programs: %s\n"), build_search_list (&exec_prefixes, "", 0));
5446 printf (_("libraries: %s\n"), build_search_list (&startfile_prefixes, "", 0));
5450 if (print_file_name)
5452 printf ("%s\n", find_file (print_file_name));
5456 if (print_prog_name)
5458 char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK);
5459 printf ("%s\n", (newname ? newname : print_prog_name));
5463 if (print_multi_lib)
5465 print_multilib_info ();
5469 if (print_multi_directory)
5471 if (multilib_dir == NULL)
5474 printf ("%s\n", multilib_dir);
5478 if (print_help_list)
5484 printf (_("\nFor bug reporting instructions, please see:\n"));
5485 printf ("%s.\n", GCCBUGURL);
5490 /* We do not exit here. Instead we have created a fake input file
5491 called 'help-dummy' which needs to be compiled, and we pass this
5492 on the the various sub-processes, along with the --help switch. */
5499 /* compiler_version is truncated at the first space when initialized
5500 from version string, so truncate version_string at the first space
5501 before comparing. */
5502 for (n = 0; version_string[n]; n++)
5503 if (version_string[n] == ' ')
5506 if (! strncmp (version_string, compiler_version, n)
5507 && compiler_version[n] == 0)
5508 notice ("gcc version %s\n", version_string);
5510 notice ("gcc driver version %s executing gcc version %s\n",
5511 version_string, compiler_version);
5517 if (n_infiles == added_libraries)
5518 fatal ("No input files");
5520 /* Make a place to record the compiler output file names
5521 that correspond to the input files. */
5524 i += lang_specific_extra_outfiles;
5525 outfiles = (const char **) xcalloc (i, sizeof (char *));
5527 /* Record which files were specified explicitly as link input. */
5529 explicit_link_files = xcalloc (1, n_infiles);
5531 for (i = 0; (int)i < n_infiles; i++)
5533 register struct compiler *cp = 0;
5534 int this_file_error = 0;
5536 /* Tell do_spec what to substitute for %i. */
5538 input_file_number = i;
5539 set_input (infiles[i].name);
5541 /* Use the same thing in %o, unless cp->spec says otherwise. */
5543 outfiles[i] = input_filename;
5545 /* Figure out which compiler from the file's suffix. */
5547 cp = lookup_compiler (infiles[i].name, input_filename_length,
5548 infiles[i].language);
5552 /* Ok, we found an applicable compiler. Run its spec. */
5553 /* First say how much of input_filename to substitute for %b */
5556 if (cp->spec[0][0] == '#')
5557 error ("%s: %s compiler not installed on this system",
5558 input_filename, &cp->spec[0][1]);
5561 for (j = 0; j < sizeof cp->spec / sizeof cp->spec[0]; j++)
5563 len += strlen (cp->spec[j]);
5566 char *p1 = (char *) xmalloc (len + 1);
5569 for (j = 0; j < sizeof cp->spec / sizeof cp->spec[0]; j++)
5572 strcpy (p1 + len, cp->spec[j]);
5573 len += strlen (cp->spec[j]);
5576 value = do_spec (p1);
5580 this_file_error = 1;
5583 /* If this file's name does not contain a recognized suffix,
5584 record it as explicit linker input. */
5587 explicit_link_files[i] = 1;
5589 /* Clear the delete-on-failure queue, deleting the files in it
5590 if this compilation failed. */
5592 if (this_file_error)
5594 delete_failure_queue ();
5597 /* If this compilation succeeded, don't delete those files later. */
5598 clear_failure_queue ();
5601 /* Reset the output file name to the first input file name, for use
5602 with %b in LINK_SPEC on a target that prefers not to emit a.out
5605 set_input (infiles[0].name);
5607 if (error_count == 0)
5609 /* Make sure INPUT_FILE_NUMBER points to first available open
5611 input_file_number = n_infiles;
5612 if (lang_specific_pre_link ())
5616 /* Run ld to link all the compiler output files. */
5618 if (error_count == 0)
5620 int tmp = execution_count;
5622 /* We'll use ld if we can't find collect2. */
5623 if (! strcmp (linker_name_spec, "collect2"))
5625 char *s = find_a_file (&exec_prefixes, "collect2", X_OK);
5627 linker_name_spec = "ld";
5629 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
5631 putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH");
5632 putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV);
5634 value = do_spec (link_command_spec);
5637 linker_was_run = (tmp != execution_count);
5640 /* Warn if a -B option was specified but the prefix was never used. */
5641 unused_prefix_warnings (&exec_prefixes);
5642 unused_prefix_warnings (&startfile_prefixes);
5644 /* If options said don't run linker,
5645 complain about input files to be given to the linker. */
5647 if (! linker_was_run && error_count == 0)
5648 for (i = 0; (int)i < n_infiles; i++)
5649 if (explicit_link_files[i])
5650 error ("%s: linker input file unused since linking not done",
5653 /* Delete some or all of the temporary files we made. */
5656 delete_failure_queue ();
5657 delete_temp_files ();
5659 if (print_help_list)
5661 printf (("\nFor bug reporting instructions, please see:\n"));
5662 printf ("%s\n", GCCBUGURL);
5665 return (signal_count != 0 ? 2
5666 : error_count > 0 ? (pass_exit_codes ? greatest_status : 1)
5670 /* Find the proper compilation spec for the file name NAME,
5671 whose length is LENGTH. LANGUAGE is the specified language,
5672 or 0 if this file is to be passed to the linker. */
5674 static struct compiler *
5675 lookup_compiler (name, length, language)
5678 const char *language;
5680 struct compiler *cp;
5682 /* If this was specified by the user to be a linker input, indicate that. */
5683 if (language != 0 && language[0] == '*')
5686 /* Otherwise, look for the language, if one is spec'd. */
5689 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
5690 if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
5693 error ("language %s not recognized", language);
5697 /* Look for a suffix. */
5698 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
5700 if (/* The suffix `-' matches only the file name `-'. */
5701 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
5702 || (strlen (cp->suffix) < length
5703 /* See if the suffix matches the end of NAME. */
5704 && !strcmp (cp->suffix,
5705 name + length - strlen (cp->suffix))
5710 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
5711 /* look again, but case-insensitively this time. */
5713 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
5715 if (/* The suffix `-' matches only the file name `-'. */
5716 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
5717 || (strlen (cp->suffix) < length
5718 /* See if the suffix matches the end of NAME. */
5719 && ((!strcmp (cp->suffix,
5720 name + length - strlen (cp->suffix))
5721 || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
5722 && !strcasecmp (cp->suffix,
5723 name + length - strlen (cp->suffix)))
5730 if (cp >= compilers)
5732 if (cp->spec[0][0] == '@')
5734 struct compiler *new;
5736 /* An alias entry maps a suffix to a language.
5737 Search for the language; pass 0 for NAME and LENGTH
5738 to avoid infinite recursion if language not found.
5739 Construct the new compiler spec. */
5740 language = cp->spec[0] + 1;
5741 new = (struct compiler *) xmalloc (sizeof (struct compiler));
5742 new->suffix = cp->suffix;
5744 lookup_compiler (NULL_PTR, 0, language)->spec,
5749 /* A non-alias entry: return it. */
5757 save_string (s, len)
5761 register char *result = xmalloc (len + 1);
5763 bcopy (s, result, len);
5769 pfatal_with_name (name)
5772 perror_with_name (name);
5773 delete_temp_files ();
5778 perror_with_name (name)
5781 error ("%s: %s", name, xstrerror (errno));
5785 pfatal_pexecute (errmsg_fmt, errmsg_arg)
5786 const char *errmsg_fmt;
5787 const char *errmsg_arg;
5791 int save_errno = errno;
5793 /* Space for trailing '\0' is in %s. */
5794 char *msg = xmalloc (strlen (errmsg_fmt) + strlen (errmsg_arg));
5795 sprintf (msg, errmsg_fmt, errmsg_arg);
5801 pfatal_with_name (errmsg_fmt);
5804 /* Output an error message and exit */
5809 fatal ("Internal gcc abort.");
5812 /* Output an error message and exit */
5815 fatal VPARAMS ((const char *msgid, ...))
5817 #ifndef ANSI_PROTOTYPES
5822 VA_START (ap, msgid);
5824 #ifndef ANSI_PROTOTYPES
5825 msgid = va_arg (ap, const char *);
5828 fprintf (stderr, "%s: ", programname);
5829 vfprintf (stderr, _(msgid), ap);
5831 fprintf (stderr, "\n");
5832 delete_temp_files ();
5837 error VPARAMS ((const char *msgid, ...))
5839 #ifndef ANSI_PROTOTYPES
5844 VA_START (ap, msgid);
5846 #ifndef ANSI_PROTOTYPES
5847 msgid = va_arg (ap, const char *);
5850 fprintf (stderr, "%s: ", programname);
5851 vfprintf (stderr, _(msgid), ap);
5854 fprintf (stderr, "\n");
5858 notice VPARAMS ((const char *msgid, ...))
5860 #ifndef ANSI_PROTOTYPES
5865 VA_START (ap, msgid);
5867 #ifndef ANSI_PROTOTYPES
5868 msgid = va_arg (ap, const char *);
5871 vfprintf (stderr, _(msgid), ap);
5877 validate_all_switches ()
5879 struct compiler *comp;
5880 register const char *p;
5882 struct spec_list *spec;
5884 for (comp = compilers; comp->spec[0]; comp++)
5887 for (i = 0; i < sizeof comp->spec / sizeof comp->spec[0] && comp->spec[i]; i++)
5891 if (c == '%' && *p == '{')
5892 /* We have a switch spec. */
5893 validate_switches (p + 1);
5897 /* Look through the linked list of specs read from the specs file. */
5898 for (spec = specs; spec ; spec = spec->next)
5900 p = *(spec->ptr_spec);
5902 if (c == '%' && *p == '{')
5903 /* We have a switch spec. */
5904 validate_switches (p + 1);
5907 p = link_command_spec;
5909 if (c == '%' && *p == '{')
5910 /* We have a switch spec. */
5911 validate_switches (p + 1);
5914 /* Look at the switch-name that comes after START
5915 and mark as valid all supplied switches that match it. */
5918 validate_switches (start)
5921 register const char *p = start;
5936 while (*p != ':' && *p != '}') p++;
5940 else if (p[-1] == '*')
5942 /* Mark all matching switches as valid. */
5944 for (i = 0; i < n_switches; i++)
5945 if (!strncmp (switches[i].part1, filter, p - filter))
5946 switches[i].validated = 1;
5950 /* Mark an exact matching switch as valid. */
5951 for (i = 0; i < n_switches; i++)
5953 if (!strncmp (switches[i].part1, filter, p - filter)
5954 && switches[i].part1[p - filter] == 0)
5955 switches[i].validated = 1;
5960 /* Check whether a particular argument was used. The first time we
5961 canonicalize the switches to keep only the ones we care about. */
5971 const char *replace;
5976 static struct mswitchstr *mswitches;
5977 static int n_mswitches;
5982 struct mswitchstr *matches;
5986 /* Break multilib_matches into the component strings of string and replacement
5988 for (q = multilib_matches; *q != '\0'; q++)
5992 matches = (struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt);
5994 q = multilib_matches;
6004 matches[i].len = q - matches[i].str;
6006 matches[i].replace = ++q;
6007 while (*q != ';' && *q != '\0')
6013 matches[i].rep_len = q - matches[i].replace;
6019 /* Now build a list of the replacement string for switches that we care
6020 about. Make sure we allocate at least one entry. This prevents
6021 xmalloc from calling fatal, and prevents us from re-executing this
6024 = (struct mswitchstr *) xmalloc ((sizeof (struct mswitchstr))
6025 * (n_switches ? n_switches : 1));
6026 for (i = 0; i < n_switches; i++)
6028 int xlen = strlen (switches[i].part1);
6029 for (j = 0; j < cnt; j++)
6030 if (xlen == matches[j].len
6031 && ! strncmp (switches[i].part1, matches[j].str, xlen))
6033 mswitches[n_mswitches].str = matches[j].replace;
6034 mswitches[n_mswitches].len = matches[j].rep_len;
6035 mswitches[n_mswitches].replace = (char *)0;
6036 mswitches[n_mswitches].rep_len = 0;
6043 for (i = 0; i < n_mswitches; i++)
6044 if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
6051 default_arg (p, len)
6055 const char *start, *end;
6057 for (start = multilib_defaults; *start != '\0'; start = end+1)
6059 while (*start == ' ' || *start == '\t')
6065 for (end = start+1; *end != ' ' && *end != '\t' && *end != '\0'; end++)
6068 if ((end - start) == len && strncmp (p, start, len) == 0)
6078 /* Work out the subdirectory to use based on the options. The format of
6079 multilib_select is a list of elements. Each element is a subdirectory
6080 name followed by a list of options followed by a semicolon. The format
6081 of multilib_exclusions is the same, but without the preceding
6082 directory. First gcc will check the exclusions, if none of the options
6083 beginning with an exclamation point are present, and all of the other
6084 options are present, then we will ignore this completely. Passing
6085 that, gcc will consider each multilib_select in turn using the same
6086 rules for matching the options. If a match is found, that subdirectory
6093 unsigned int this_path_len;
6094 const char *this_path, *this_arg;
6098 p = multilib_exclusions;
6101 /* Ignore newlines. */
6108 /* Check the arguments. */
6122 while (*p != ' ' && *p != ';')
6129 if (*this_arg != '!')
6137 ok = used_arg (this_arg, p - this_arg);
6151 p = multilib_select;
6154 /* Ignore newlines. */
6161 /* Get the initial path. */
6169 this_path_len = p - this_path;
6171 /* Check the arguments. */
6186 while (*p != ' ' && *p != ';')
6193 if (*this_arg != '!')
6201 /* If this is a default argument, we can just ignore it.
6202 This is true even if this_arg begins with '!'. Beginning
6203 with '!' does not mean that this argument is necessarily
6204 inappropriate for this library: it merely means that
6205 there is a more specific library which uses this
6206 argument. If this argument is a default, we need not
6207 consider that more specific library. */
6208 if (! default_arg (this_arg, p - this_arg))
6210 ok = used_arg (this_arg, p - this_arg);
6221 if (this_path_len != 1
6222 || this_path[0] != '.')
6224 char * new_multilib_dir = xmalloc (this_path_len + 1);
6225 strncpy (new_multilib_dir, this_path, this_path_len);
6226 new_multilib_dir[this_path_len] = '\0';
6227 multilib_dir = new_multilib_dir;
6236 /* Print out the multiple library subdirectory selection
6237 information. This prints out a series of lines. Each line looks
6238 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
6239 required. Only the desired options are printed out, the negative
6240 matches. The options are print without a leading dash. There are
6241 no spaces to make it easy to use the information in the shell.
6242 Each subdirectory is printed only once. This assumes the ordering
6243 generated by the genmultilib script. Also, we leave out ones that match
6247 print_multilib_info ()
6249 const char *p = multilib_select;
6250 const char *last_path = 0, *this_path;
6252 unsigned int last_path_len = 0;
6257 /* Ignore newlines. */
6264 /* Get the initial path. */
6273 /* Check for matches with the multilib_exclusions. We don't bother
6274 with the '!' in either list. If any of the exclusion rules match
6275 all of its options with the select rule, we skip it. */
6277 const char *e = multilib_exclusions;
6278 const char *this_arg;
6283 /* Ignore newlines. */
6290 /* Check the arguments. */
6307 while (*e != ' ' && *e != ';')
6318 int len = e - this_arg;
6325 while (*q != ' ' && *q != ';')
6332 if (! strncmp (arg, this_arg, (len < q - arg) ? q - arg : len) ||
6333 default_arg (this_arg, e - this_arg))
6363 /* If this is a duplicate, skip it. */
6364 skip = (last_path != 0 && (unsigned int)(p - this_path) == last_path_len
6365 && ! strncmp (last_path, this_path, last_path_len));
6367 last_path = this_path;
6368 last_path_len = p - this_path;
6371 /* If this directory requires any default arguments, we can skip
6372 it. We will already have printed a directory identical to
6373 this one which does not require that default argument. */
6391 while (*q != ' ' && *q != ';')
6399 && default_arg (arg, q - arg))
6414 for (p1 = last_path; p1 < p; p1++)
6433 use_arg = *p != '!';
6438 while (*p != ' ' && *p != ';')
6453 /* If there are extra options, print them now. */
6454 if (multilib_extra && *multilib_extra)
6456 int print_at = TRUE;
6459 for (q = multilib_extra; *q != '\0'; q++)