1 /* Compiler driver program that can handle many languages.
2 Copyright (C) 1987, 1989, 1992, 1993, 1994 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
20 This paragraph is here to try to keep Sun CC from dying.
21 The number of chars here seems crucial!!!! */
23 /* This program is the user interface to the C compiler and possibly to
24 other compilers. It is used because compilation is a complicated procedure
25 which involves running several programs and passing temporary files between
26 them, forwarding the users switches to those programs selectively,
27 and deleting the temporary files at the end.
29 CC recognizes how to compile each input file by suffixes in the file names.
30 Once it knows which kind of compilation to perform, the procedure for
31 compilation is specified by a string called a "spec". */
33 #include <sys/types.h>
37 #include <sys/file.h> /* May get R_OK, etc. on some systems. */
54 /* Add prototype support. */
56 #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
57 #define PROTO(ARGS) ARGS
59 #define PROTO(ARGS) ()
65 #define VPROTO(ARGS) ARGS
66 #define VA_START(va_list,var) va_start(va_list,var)
68 #define VPROTO(ARGS) (va_alist) va_dcl
69 #define VA_START(va_list,var) va_start(va_list)
73 /* Define a generic NULL if one hasn't already been defined. */
80 #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
81 #define GENERIC_PTR void *
83 #define GENERIC_PTR char *
88 #define NULL_PTR ((GENERIC_PTR)0)
95 /* On MSDOS, write temp files in current dir
96 because there's no place else we can expect to use. */
103 /* Test if something is a normal file. */
105 #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
108 /* Test if something is a directory. */
110 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
113 /* By default there is no special suffix for executables. */
114 #ifndef EXECUTABLE_SUFFIX
115 #define EXECUTABLE_SUFFIX ""
118 /* By default, colon separates directories in a path. */
119 #ifndef PATH_SEPARATOR
120 #define PATH_SEPARATOR ':'
123 #define obstack_chunk_alloc xmalloc
124 #define obstack_chunk_free free
127 extern char *getenv ();
129 extern int errno, sys_nerr;
131 extern const char *const sys_errlist[];
133 extern char *sys_errlist[];
136 extern int execv (), execvp ();
138 /* If a stage of compilation returns an exit status >= 1,
139 compilation of that file ceases. */
141 #define MIN_FATAL_STATUS 1
143 /* Flag saying to print the full filename of libgcc.a
144 as found through our usual search mechanism. */
146 static int print_libgcc_file_name;
148 /* Flag indicating whether we should print the command and arguments */
150 static int verbose_flag;
152 /* Nonzero means write "temp" files in source directory
153 and use the source file's name in them, and don't delete them. */
155 static int save_temps_flag;
157 /* The compiler version. */
159 static char *compiler_version;
161 /* The target version specified with -V */
163 static char *spec_version = DEFAULT_TARGET_VERSION;
165 /* The target machine specified with -b. */
167 static char *spec_machine = DEFAULT_TARGET_MACHINE;
169 /* Nonzero if cross-compiling.
170 When -b is used, the value comes from the `specs' file. */
173 static int cross_compile = 1;
175 static int cross_compile = 0;
178 /* The number of errors that have occurred; the link phase will not be
179 run if this is non-zero. */
180 static int error_count = 0;
182 /* This is the obstack which we use to allocate many strings. */
184 static struct obstack obstack;
186 /* This is the obstack to build an environment variable to pass to
187 collect2 that describes all of the relevant switches of what to
188 pass the compiler in building the list of pointers to constructors
191 static struct obstack collect_obstack;
193 extern char *version_string;
195 /* Forward declaration for prototypes. */
198 static void set_spec PROTO((char *, char *));
199 static struct compiler *lookup_compiler PROTO((char *, int, char *));
200 static char *find_a_file PROTO((struct path_prefix *, char *, int));
201 static void add_prefix PROTO((struct path_prefix *, char *, int, int, int *));
202 static char *skip_whitespace PROTO((char *));
203 static void record_temp_file PROTO((char *, int, int));
204 static char *handle_braces PROTO((char *));
205 static char *save_string PROTO((char *, int));
206 static char *concat PROTO((char *, char *, char *));
207 static int do_spec PROTO((char *));
208 static int do_spec_1 PROTO((char *, int, char *));
209 static char *find_file PROTO((char *));
210 static int is_directory PROTO((char *, char *, int));
211 static void validate_switches PROTO((char *));
212 static void validate_all_switches PROTO((void));
213 static void give_switch PROTO((int, int));
214 static void pfatal_with_name PROTO((char *));
215 static void perror_with_name PROTO((char *));
216 static void perror_exec PROTO((char *));
218 static void fatal PROTO((char *, ...));
219 static void error PROTO((char *, ...));
221 /* We must not provide any prototype here, even if ANSI C. */
222 static void fatal PROTO(());
223 static void error PROTO(());
230 /* Specs are strings containing lines, each of which (if not blank)
231 is made up of a program name, and arguments separated by spaces.
232 The program name must be exact and start from root, since no path
233 is searched and it is unreliable to depend on the current working directory.
234 Redirection of input or output is not supported; the subprograms must
235 accept filenames saying what files to read and write.
237 In addition, the specs can contain %-sequences to substitute variable text
238 or for conditional text. Here is a table of all defined %-sequences.
239 Note that spaces are not generated automatically around the results of
240 expanding these sequences; therefore, you can concatenate them together
241 or with constant text in a single argument.
243 %% substitute one % into the program name or argument.
244 %i substitute the name of the input file being processed.
245 %b substitute the basename of the input file being processed.
246 This is the substring up to (and not including) the last period
247 and not including the directory.
248 %g substitute the temporary-file-name-base. This is a string chosen
249 once per compilation. Different temporary file names are made by
250 concatenation of constant strings on the end, as in `%g.s'.
251 %g also has the same effect of %d.
252 %u like %g, but make the temporary file name unique.
253 %U returns the last file name generated with %u.
254 %d marks the argument containing or following the %d as a
255 temporary file name, so that that file will be deleted if CC exits
256 successfully. Unlike %g, this contributes no text to the argument.
257 %w marks the argument containing or following the %w as the
258 "output file" of this compilation. This puts the argument
259 into the sequence of arguments that %o will substitute later.
261 like %{...} but mark last argument supplied within
262 as a file to be deleted on failure.
263 %o substitutes the names of all the output files, with spaces
264 automatically placed around them. You should write spaces
265 around the %o as well or the results are undefined.
266 %o is for use in the specs for running the linker.
267 Input files whose names have no recognized suffix are not compiled
268 at all, but they are included among the output files, so they will
270 %p substitutes the standard macro predefinitions for the
271 current target machine. Use this when running cpp.
272 %P like %p, but puts `__' before and after the name of each macro.
273 (Except macros that already have __.)
275 %I Substitute a -iprefix option made from GCC_EXEC_PREFIX.
276 %s current argument is the name of a library or startup file of some sort.
277 Search for that file in a standard list of directories
278 and substitute the full name found.
279 %eSTR Print STR as an error message. STR is terminated by a newline.
280 Use this when inconsistent options are detected.
281 %x{OPTION} Accumulate an option for %X.
282 %X Output the accumulated linker options specified by compilations.
283 %Y Output the accumulated assembler options specified by compilations.
284 %v1 Substitute the major version number of GCC.
285 (For version 2.5.n, this is 2.)
286 %v2 Substitute the minor version number of GCC.
287 (For version 2.5.n, this is 5.)
288 %a process ASM_SPEC as a spec.
289 This allows config.h to specify part of the spec for running as.
290 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
291 used here. This can be used to run a post-processor after the
292 assembler has done it's job.
293 %D Dump out a -L option for each directory in startfile_prefix.
294 %l process LINK_SPEC as a spec.
295 %L process LIB_SPEC as a spec.
296 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
297 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
298 %c process SIGNED_CHAR_SPEC as a spec.
299 %C process CPP_SPEC as a spec. A capital C is actually used here.
300 %1 process CC1_SPEC as a spec.
301 %2 process CC1PLUS_SPEC as a spec.
302 %| output "-" if the input for the current command is coming from a pipe.
303 %* substitute the variable part of a matched option. (See below.)
304 Note that each comma in the substituted string is replaced by
306 %{S} substitutes the -S switch, if that switch was given to CC.
307 If that switch was not specified, this substitutes nothing.
308 Here S is a metasyntactic variable.
309 %{S*} substitutes all the switches specified to CC whose names start
310 with -S. This is used for -o, -D, -I, etc; switches that take
311 arguments. CC considers `-o foo' as being one switch whose
312 name starts with `o'. %{o*} would substitute this text,
313 including the space; thus, two arguments would be generated.
314 %{S*:X} substitutes X if one or more switches whose names start with -S are
315 specified to CC. Note that the tail part of the -S option
316 (i.e. the part matched by the `*') will be substituted for each
317 occurrence of %* within X.
318 %{S:X} substitutes X, but only if the -S switch was given to CC.
319 %{!S:X} substitutes X, but only if the -S switch was NOT given to CC.
320 %{|S:X} like %{S:X}, but if no S switch, substitute `-'.
321 %{|!S:X} like %{!S:X}, but if there is an S switch, substitute `-'.
322 %{.S:X} substitutes X, but only if processing a file with suffix S.
323 %{!.S:X} substitutes X, but only if NOT processing a file with suffix S.
324 %(Spec) processes a specification defined in a specs file as *Spec:
325 %[Spec] as above, but put __ around -D arguments
327 The conditional text X in a %{S:X} or %{!S:X} construct may contain
328 other nested % constructs or spaces, or even newlines. They are
329 processed as usual, as described above.
331 The character | is used to indicate that a command should be piped to
332 the following command, but only if -pipe is specified.
334 Note that it is built into CC which switches take arguments and which
335 do not. You might think it would be useful to generalize this to
336 allow each compiler's spec to say which switches take arguments. But
337 this cannot be done in a consistent fashion. CC cannot even decide
338 which input files have been specified without knowing which switches
339 take arguments, and it must know which input files to compile in order
340 to tell which compilers to run.
342 CC also knows implicitly that arguments starting in `-l' are to be
343 treated as compiler output files, and passed to the linker in their
344 proper position among the other output files. */
346 /* Define the macros used for specs %a, %l, %L, %S, %c, %C, %1. */
348 /* config.h can define ASM_SPEC to provide extra args to the assembler
349 or extra switch-translations. */
354 /* config.h can define ASM_FINAL_SPEC to run a post processor after
355 the assembler has run. */
356 #ifndef ASM_FINAL_SPEC
357 #define ASM_FINAL_SPEC ""
360 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
361 or extra switch-translations. */
366 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
367 or extra switch-translations. */
372 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
373 or extra switch-translations. */
375 #define CC1PLUS_SPEC ""
378 /* config.h can define LINK_SPEC to provide extra args to the linker
379 or extra switch-translations. */
384 /* config.h can define LIB_SPEC to override the default libraries. */
386 #define LIB_SPEC "%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}"
389 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
390 #ifndef STARTFILE_SPEC
391 #define STARTFILE_SPEC \
392 "%{pg:gcrt0.o%s}%{!pg:%{p:mcrt0.o%s}%{!p:crt0.o%s}}"
395 /* config.h can define SWITCHES_NEED_SPACES to control passing -o and -L.
396 Make the string nonempty to require spaces there. */
397 #ifndef SWITCHES_NEED_SPACES
398 #define SWITCHES_NEED_SPACES ""
401 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
403 #define ENDFILE_SPEC ""
406 /* This spec is used for telling cpp whether char is signed or not. */
407 #ifndef SIGNED_CHAR_SPEC
408 /* Use #if rather than ?:
409 because MIPS C compiler rejects like ?: in initializers. */
410 #if DEFAULT_SIGNED_CHAR
411 #define SIGNED_CHAR_SPEC "%{funsigned-char:-D__CHAR_UNSIGNED__}"
413 #define SIGNED_CHAR_SPEC "%{!fsigned-char:-D__CHAR_UNSIGNED__}"
417 static char *cpp_spec = CPP_SPEC;
418 static char *cpp_predefines = CPP_PREDEFINES;
419 static char *cc1_spec = CC1_SPEC;
420 static char *cc1plus_spec = CC1PLUS_SPEC;
421 static char *signed_char_spec = SIGNED_CHAR_SPEC;
422 static char *asm_spec = ASM_SPEC;
423 static char *asm_final_spec = ASM_FINAL_SPEC;
424 static char *link_spec = LINK_SPEC;
425 static char *lib_spec = LIB_SPEC;
426 static char *endfile_spec = ENDFILE_SPEC;
427 static char *startfile_spec = STARTFILE_SPEC;
428 static char *switches_need_spaces = SWITCHES_NEED_SPACES;
430 /* This defines which switch letters take arguments. */
432 #ifndef SWITCH_TAKES_ARG
433 #define SWITCH_TAKES_ARG(CHAR) \
434 ((CHAR) == 'D' || (CHAR) == 'U' || (CHAR) == 'o' \
435 || (CHAR) == 'e' || (CHAR) == 'T' || (CHAR) == 'u' \
436 || (CHAR) == 'I' || (CHAR) == 'm' \
437 || (CHAR) == 'L' || (CHAR) == 'A')
440 /* This defines which multi-letter switches take arguments. */
442 #define DEFAULT_WORD_SWITCH_TAKES_ARG(STR) \
443 (!strcmp (STR, "Tdata") || !strcmp (STR, "Ttext") \
444 || !strcmp (STR, "Tbss") || !strcmp (STR, "include") \
445 || !strcmp (STR, "imacros") || !strcmp (STR, "aux-info") \
446 || !strcmp (STR, "idirafter") || !strcmp (STR, "iprefix") \
447 || !strcmp (STR, "iwithprefix") || !strcmp (STR, "iwithprefixbefore"))
449 #ifndef WORD_SWITCH_TAKES_ARG
450 #define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR)
453 /* Record the mapping from file suffixes for compilation specs. */
457 char *suffix; /* Use this compiler for input files
458 whose names end in this suffix. */
460 char *spec[4]; /* To use this compiler, concatenate these
461 specs and pass to do_spec. */
464 /* Pointer to a vector of `struct compiler' that gives the spec for
465 compiling a file, based on its suffix.
466 A file that does not end in any of these suffixes will be passed
467 unchanged to the loader and nothing else will be done to it.
469 An entry containing two 0s is used to terminate the vector.
471 If multiple entries match a file, the last matching one is used. */
473 static struct compiler *compilers;
475 /* Number of entries in `compilers', not counting the null terminator. */
477 static int n_compilers;
479 /* The default list of file name suffixes and their compilation specs. */
481 static struct compiler default_compilers[] =
485 "cpp -lang-c %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
486 %{C:%{!E:%eGNU C does not support -C without using -E}}\
487 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d}\
488 -undef -D__GNUC__=%v1 -D__GNUC_MINOR__=%v2\
489 %{ansi:-trigraphs -$ -D__STRICT_ANSI__}\
490 %{!undef:%{!ansi:%p} %P} %{trigraphs} \
491 %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\
492 %{traditional-cpp:-traditional}\
493 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
494 %i %{!M:%{!MM:%{!E:%{!pipe:%g.i}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
495 "%{!M:%{!MM:%{!E:cc1 %{!pipe:%g.i} %1 \
496 %{!Q:-quiet} -dumpbase %b.c %{d*} %{m*} %{a}\
497 %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi} \
498 %{traditional} %{v:-version} %{pg:-p} %{p} %{f*}\
500 %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
501 %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
502 %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
503 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
504 %{!pipe:%g.s} %A\n }}}}"},
506 "%{E:cpp -lang-c %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
507 %{C:%{!E:%eGNU C does not support -C without using -E}}\
508 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d}\
509 -undef -D__GNUC__=%v1 -D__GNUC_MINOR__=%v2\
510 %{ansi:-trigraphs -$ -D__STRICT_ANSI__}\
511 %{!undef:%{!ansi:%p} %P} %{trigraphs}\
512 %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\
513 %{traditional-cpp:-traditional}\
514 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
516 %{!E:%e-E required when input is from standard input}"},
517 {".m", "@objective-c"},
519 "cpp -lang-objc %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
520 %{C:%{!E:%eGNU C does not support -C without using -E}}\
521 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d}\
522 -undef -D__OBJC__ -D__GNUC__=%v1 -D__GNUC_MINOR__=%v2\
523 %{ansi:-trigraphs -$ -D__STRICT_ANSI__}\
524 %{!undef:%{!ansi:%p} %P} %{trigraphs}\
525 %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\
526 %{traditional-cpp:-traditional}\
527 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
528 %i %{!M:%{!MM:%{!E:%{!pipe:%g.i}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
529 "%{!M:%{!MM:%{!E:cc1obj %{!pipe:%g.i} %1 \
530 %{!Q:-quiet} -dumpbase %b.m %{d*} %{m*} %{a}\
531 %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi} \
532 %{traditional} %{v:-version} %{pg:-p} %{p} %{f*} \
533 -lang-objc %{gen-decls} \
535 %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
536 %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
537 %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
538 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
539 %{!pipe:%g.s} %A\n }}}}"},
542 "%{!E:%eCompilation of header file requested} \
543 cpp %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
544 %{C:%{!E:%eGNU C does not support -C without using -E}}\
545 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} \
546 -undef -D__GNUC__=%v1 -D__GNUC_MINOR__=%v2\
547 %{ansi:-trigraphs -$ -D__STRICT_ANSI__}\
548 %{!undef:%{!ansi:%p} %P} %{trigraphs}\
549 %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\
550 %{traditional-cpp:-traditional}\
551 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
558 "cpp -lang-c++ %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
559 %{C:%{!E:%eGNU C++ does not support -C without using -E}}\
560 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} \
561 -undef -D__GNUC__=%v1 -D__GNUG__=%v1 -D__cplusplus -D__GNUC_MINOR__=%v2\
562 %{ansi:-trigraphs -$ -D__STRICT_ANSI__} %{!undef:%{!ansi:%p} %P}\
563 %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\
564 %{traditional-cpp:-traditional} %{trigraphs}\
565 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
566 %i %{!M:%{!MM:%{!E:%{!pipe:%g.ii}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
567 "%{!M:%{!MM:%{!E:cc1plus %{!pipe:%g.ii} %1 %2\
568 %{!Q:-quiet} -dumpbase %b.cc %{d*} %{m*} %{a}\
569 %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi} %{traditional}\
570 %{v:-version} %{pg:-p} %{p} %{f*} %{+e*}\
572 %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
573 %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
574 %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
575 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
576 %{!pipe:%g.s} %A\n }}}}"},
577 {".i", "@cpp-output"},
579 "cc1 %i %1 %{!Q:-quiet} %{d*} %{m*} %{a}\
580 %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi} %{traditional}\
581 %{v:-version} %{pg:-p} %{p} %{f*}\
583 %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
584 %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
585 %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
586 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o} %{!pipe:%g.s} %A\n }"},
587 {".ii", "@c++-cpp-output"},
589 "cc1plus %i %1 %2 %{!Q:-quiet} %{d*} %{m*} %{a}\
590 %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi} %{traditional}\
591 %{v:-version} %{pg:-p} %{p} %{f*} %{+e*}\
593 %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
594 %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
595 %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
596 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
597 %{!pipe:%g.s} %A\n }"},
598 {".s", "@assembler"},
600 "%{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
601 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o} %i %A\n }"},
602 {".S", "@assembler-with-cpp"},
603 {"@assembler-with-cpp",
604 "cpp -lang-asm %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
605 %{C:%{!E:%eGNU C does not support -C without using -E}}\
606 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{trigraphs} \
607 -undef -$ %{!undef:%p %P} -D__ASSEMBLER__ \
608 %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\
609 %{traditional-cpp:-traditional}\
610 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
611 %i %{!M:%{!MM:%{!E:%{!pipe:%g.s}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
612 "%{!M:%{!MM:%{!E:%{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
613 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
614 %{!pipe:%g.s} %A\n }}}}"},
619 "gnat1 %{k8:-gnatk8} %{w:-gnatws} %{!Q:-quiet} -dumpbase %b.ada\
620 %{g*} %{O*} %{p} %{pg:-p} %{f*} %{d*}\
621 %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
622 %i %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} | \n",
623 "%{!S:%{!gnatc:%{!gnats:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
624 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
625 %{!pipe:%g.s} %A\n}}} "},
626 /* Mark end of table */
630 /* Number of elements in default_compilers, not counting the terminator. */
632 static int n_default_compilers
633 = (sizeof default_compilers / sizeof (struct compiler)) - 1;
635 /* Here is the spec for running the linker, after compiling all files. */
637 /* -u* was put back because both BSD and SysV seem to support it. */
638 /* %{static:} simply prevents an error message if the target machine
639 doesn't handle -static. */
640 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
641 scripts which exist in user specified directories, or in standard
643 #ifdef LINK_LIBGCC_SPECIAL_1
644 /* Have gcc do the search for libgcc.a, but generate -L options as usual. */
645 static char *link_command_spec = "\
647 %{!c:%{!M:%{!MM:%{!E:%{!S:ld %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} \
648 %{r} %{s} %{t} %{u*} %{x} %{z}\
649 %{!A:%{!nostartfiles:%{!nostdlib:%S}}} %{static:}\
650 %{L*} %D %{T*} %o %{!nostdlib:libgcc.a%s %L libgcc.a%s %{!A:%E}}\n }}}}}}";
652 #ifdef LINK_LIBGCC_SPECIAL
653 /* Have gcc do the search for libgcc.a, and don't generate -L options. */
654 static char *link_command_spec = "\
656 %{!c:%{!M:%{!MM:%{!E:%{!S:ld %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} \
657 %{r} %{s} %{t} %{u*} %{x} %{z}\
658 %{!A:%{!nostartfiles:%{!nostdlib:%S}}} %{static:}\
659 %{L*} %{T*} %o %{!nostdlib:libgcc.a%s %L libgcc.a%s %{!A:%E}}\n }}}}}}";
661 /* Use -L and have the linker do the search for -lgcc. */
662 static char *link_command_spec = "\
664 %{!c:%{!M:%{!MM:%{!E:%{!S:ld %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} \
665 %{r} %{s} %{t} %{u*} %{x} %{z}\
666 %{!A:%{!nostartfiles:%{!nostdlib:%S}}} %{static:}\
667 %{L*} %D %{T*} %o %{!nostdlib:-lgcc %L -lgcc %{!A:%E}}\n }}}}}}";
671 /* A vector of options to give to the linker.
672 These options are accumulated by -Xlinker and -Wl,
673 and substituted into the linker command with %X. */
674 static int n_linker_options;
675 static char **linker_options;
677 /* A vector of options to give to the assembler.
678 These options are accumulated by -Wa,
679 and substituted into the assembler command with %X. */
680 static int n_assembler_options;
681 static char **assembler_options;
683 /* Define how to map long options into short ones. */
685 /* This structure describes one mapping. */
688 /* The long option's name. */
690 /* The equivalent short option. */
692 /* Argument info. A string of flag chars; NULL equals no options.
693 a => argument required.
694 o => argument optional.
695 j => join argument to equivalent, making one word.
696 * => allow other text after NAME as an argument. */
700 /* This is the table of mappings. Mappings are tried sequentially
701 for each option encountered; the first one that matches, wins. */
703 struct option_map option_map[] =
705 {"--profile-blocks", "-a", 0},
706 {"--target", "-b", "a"},
707 {"--compile", "-c", 0},
708 {"--dump", "-d", "a"},
709 {"--entry", "-e", 0},
710 {"--debug", "-g", "oj"},
711 {"--include", "-include", "a"},
712 {"--imacros", "-imacros", "a"},
713 {"--include-prefix", "-iprefix", "a"},
714 {"--include-directory-after", "-idirafter", "a"},
715 {"--include-with-prefix", "-iwithprefix", "a"},
716 {"--include-with-prefix-before", "-iwithprefixbefore", "a"},
717 {"--include-with-prefix-after", "-iwithprefix", "a"},
718 {"--machine-", "-m", "*j"},
719 {"--machine", "-m", "aj"},
720 {"--no-standard-includes", "-nostdinc", 0},
721 {"--no-standard-libraries", "-nostdlib", 0},
722 {"--no-precompiled-includes", "-noprecomp", 0},
723 {"--output", "-o", "a"},
724 {"--profile", "-p", 0},
725 {"--quiet", "-q", 0},
726 {"--silent", "-q", 0},
727 {"--force-link", "-u", "a"},
728 {"--verbose", "-v", 0},
729 {"--version", "-dumpversion", 0},
730 {"--no-warnings", "-w", 0},
731 {"--language", "-x", "a"},
733 {"--assert", "-A", "a"},
734 {"--prefix", "-B", "a"},
735 {"--comments", "-C", 0},
736 {"--define-macro", "-D", "a"},
737 {"--preprocess", "-E", 0},
738 {"--trace-includes", "-H", 0},
739 {"--include-directory", "-I", "a"},
740 {"--include-barrier", "-I-", 0},
741 {"--library-directory", "-L", "a"},
742 {"--dependencies", "-M", 0},
743 {"--user-dependencies", "-MM", 0},
744 {"--write-dependencies", "-MD", 0},
745 {"--write-user-dependencies", "-MMD", 0},
746 {"--optimize", "-O", "oj"},
747 {"--no-line-commands", "-P", 0},
748 {"--assemble", "-S", 0},
749 {"--undefine-macro", "-U", "a"},
750 {"--use-version", "-V", "a"},
751 {"--for-assembler", "-Wa", "a"},
752 {"--extra-warnings", "-W", 0},
753 {"--all-warnings", "-Wall", 0},
754 {"--warn-", "-W", "*j"},
755 {"--for-linker", "-Xlinker", "a"},
757 {"--ansi", "-ansi", 0},
758 {"--traditional", "-traditional", 0},
759 {"--traditional-cpp", "-traditional-cpp", 0},
760 {"--trigraphs", "-trigraphs", 0},
761 {"--pipe", "-pipe", 0},
762 {"--dumpbase", "-dumpbase", "a"},
763 {"--pedantic", "-pedantic", 0},
764 {"--pedantic-errors", "-pedantic-errors", 0},
765 {"--save-temps", "-save-temps", 0},
766 {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
767 {"--static", "-static", 0},
768 {"--shared", "-shared", 0},
769 {"--symbolic", "-symbolic", 0},
773 /* Translate the options described by *ARGCP and *ARGVP.
774 Make a new vector and store it back in *ARGVP,
775 and store its length in *ARGVC. */
778 translate_options (argcp, argvp)
784 char **argv = *argvp;
785 char **newv = (char **) xmalloc ((argc + 2) * 2 * sizeof (char *));
789 newv[newindex++] = argv[i++];
793 /* Translate -- options. */
794 if (argv[i][0] == '-' && argv[i][1] == '-')
796 /* Find a mapping that applies to this option. */
797 for (j = 0; j < sizeof (option_map) / sizeof (option_map[0]); j++)
799 int optlen = strlen (option_map[j].name);
800 int complen = strlen (argv[i]);
801 char *arginfo = option_map[j].arg_info;
805 if (complen > optlen)
807 if (!strncmp (argv[i], option_map[j].name, complen))
809 int extra = strlen (argv[i]) > optlen;
814 /* If the option has an argument, accept that. */
815 if (argv[i][optlen] == '=')
816 arg = argv[i] + optlen + 1;
817 /* If this mapping allows extra text at end of name,
818 accept that as "argument". */
819 else if (index (arginfo, '*') != 0)
820 arg = argv[i] + optlen;
821 /* Otherwise, extra text at end means mismatch.
822 Try other mappings. */
826 else if (index (arginfo, '*') != 0)
827 error ("Incomplete `%s' option", option_map[j].name);
829 /* Handle arguments. */
830 if (index (arginfo, 'o') != 0)
835 error ("Missing argument to `%s' option",
840 else if (index (arginfo, '*') != 0)
842 else if (index (arginfo, 'a') == 0)
845 error ("Extraneous argument to `%s' option",
850 /* Store the translation as one argv elt or as two. */
851 if (arg != 0 && index (arginfo, 'j') != 0)
852 newv[newindex++] = concat (option_map[j].equivalent,
856 newv[newindex++] = option_map[j].equivalent;
857 newv[newindex++] = arg;
860 newv[newindex++] = option_map[j].equivalent;
867 /* Handle old-fashioned options--just copy them through,
868 with their arguments. */
869 else if (argv[i][0] == '-')
871 char *p = argv[i] + 1;
875 if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
876 nskip += SWITCH_TAKES_ARG (c) - (p[1] != 0);
877 else if (WORD_SWITCH_TAKES_ARG (p))
878 nskip += WORD_SWITCH_TAKES_ARG (p);
879 else if ((c == 'B' || c == 'b' || c == 'V' || c == 'x')
882 else if (! strcmp (p, "Xlinker"))
887 newv[newindex++] = argv[i++];
892 /* Ordinary operands, or +e options. */
893 newv[newindex++] = argv[i++];
902 /* Read compilation specs from a file named FILENAME,
903 replacing the default ones.
905 A suffix which starts with `*' is a definition for
906 one of the machine-specific sub-specs. The "suffix" should be
907 *asm, *cc1, *cpp, *link, *startfile, *signed_char, etc.
908 The corresponding spec is stored in asm_spec, etc.,
909 rather than in the `compilers' vector.
911 Anything invalid in the file is a fatal error. */
914 read_specs (filename)
923 fprintf (stderr, "Reading specs from %s\n", filename);
925 /* Open and stat the file. */
926 desc = open (filename, 0, 0);
928 pfatal_with_name (filename);
929 if (stat (filename, &statbuf) < 0)
930 pfatal_with_name (filename);
932 /* Read contents of file into BUFFER. */
933 buffer = xmalloc ((unsigned) statbuf.st_size + 1);
934 read (desc, buffer, (unsigned) statbuf.st_size);
935 buffer[statbuf.st_size] = 0;
938 /* Scan BUFFER for specs, putting them in the vector. */
944 char *in, *out, *p1, *p2;
946 /* Advance P in BUFFER to the next nonblank nocomment line. */
947 p = skip_whitespace (p);
951 /* Find the colon that should end the suffix. */
953 while (*p1 && *p1 != ':' && *p1 != '\n') p1++;
954 /* The colon shouldn't be missing. */
956 fatal ("specs file malformed after %d characters", p1 - buffer);
957 /* Skip back over trailing whitespace. */
959 while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t')) p2--;
960 /* Copy the suffix to a string. */
961 suffix = save_string (p, p2 - p);
962 /* Find the next line. */
963 p = skip_whitespace (p1 + 1);
965 fatal ("specs file malformed after %d characters", p - buffer);
967 /* Find next blank line. */
968 while (*p1 && !(*p1 == '\n' && p1[1] == '\n')) p1++;
969 /* Specs end at the blank line and do not include the newline. */
970 spec = save_string (p, p1 - p);
973 /* Delete backslash-newline sequences from the spec. */
978 if (in[0] == '\\' && in[1] == '\n')
980 else if (in[0] == '#')
982 while (*in && *in != '\n') in++;
989 if (suffix[0] == '*')
991 if (! strcmp (suffix, "*link_command"))
992 link_command_spec = spec;
994 set_spec (suffix + 1, spec);
998 /* Add this pair to the vector. */
1000 = ((struct compiler *)
1001 xrealloc (compilers, (n_compilers + 2) * sizeof (struct compiler)));
1002 compilers[n_compilers].suffix = suffix;
1003 bzero (compilers[n_compilers].spec,
1004 sizeof compilers[n_compilers].spec);
1005 compilers[n_compilers].spec[0] = spec;
1007 bzero (&compilers[n_compilers], sizeof compilers[n_compilers]);
1011 link_command_spec = spec;
1014 if (link_command_spec == 0)
1015 fatal ("spec file has no spec for linking");
1024 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1025 be considered whitespace. */
1026 if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
1028 else if (*p == '\n' || *p == ' ' || *p == '\t')
1032 while (*p != '\n') p++;
1042 /* Structure to keep track of the specs that have been defined so far. These
1043 are accessed using %(specname) or %[specname] in a compiler or link spec. */
1047 char *name; /* Name of the spec. */
1048 char *spec; /* The spec itself. */
1049 struct spec_list *next; /* Next spec in linked list. */
1052 /* List of specs that have been defined so far. */
1054 static struct spec_list *specs = (struct spec_list *) 0;
1056 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1057 removed; If the spec starts with a + then SPEC is added to the end of the
1061 set_spec (name, spec)
1065 struct spec_list *sl;
1068 /* See if the spec already exists */
1069 for (sl = specs; sl; sl = sl->next)
1070 if (strcmp (sl->name, name) == 0)
1075 /* Not found - make it */
1076 sl = (struct spec_list *) xmalloc (sizeof (struct spec_list));
1077 sl->name = save_string (name, strlen (name));
1078 sl->spec = save_string ("", 0);
1083 old_spec = sl->spec;
1084 if (name && spec[0] == '+' && isspace (spec[1]))
1085 sl->spec = concat (old_spec, spec + 1, "");
1087 sl->spec = save_string (spec, strlen (spec));
1089 if (! strcmp (name, "asm"))
1090 asm_spec = sl->spec;
1091 else if (! strcmp (name, "asm_final"))
1092 asm_final_spec = sl->spec;
1093 else if (! strcmp (name, "cc1"))
1094 cc1_spec = sl->spec;
1095 else if (! strcmp (name, "cc1plus"))
1096 cc1plus_spec = sl->spec;
1097 else if (! strcmp (name, "cpp"))
1098 cpp_spec = sl->spec;
1099 else if (! strcmp (name, "endfile"))
1100 endfile_spec = sl->spec;
1101 else if (! strcmp (name, "lib"))
1102 lib_spec = sl->spec;
1103 else if (! strcmp (name, "link"))
1104 link_spec = sl->spec;
1105 else if (! strcmp (name, "predefines"))
1106 cpp_predefines = sl->spec;
1107 else if (! strcmp (name, "signed_char"))
1108 signed_char_spec = sl->spec;
1109 else if (! strcmp (name, "startfile"))
1110 startfile_spec = sl->spec;
1111 else if (! strcmp (name, "switches_need_spaces"))
1112 switches_need_spaces = sl->spec;
1113 else if (! strcmp (name, "cross_compile"))
1114 cross_compile = atoi (sl->spec);
1115 /* Free the old spec */
1120 /* Accumulate a command (program name and args), and run it. */
1122 /* Vector of pointers to arguments in the current line of specifications. */
1124 static char **argbuf;
1126 /* Number of elements allocated in argbuf. */
1128 static int argbuf_length;
1130 /* Number of elements in argbuf currently in use (containing args). */
1132 static int argbuf_index;
1134 /* This is the list of suffixes and codes (%g/%u/%U) and the associated
1135 temp file. Used only if MKTEMP_EACH_FILE. */
1137 static struct temp_name {
1138 char *suffix; /* suffix associated with the code. */
1139 int length; /* strlen (suffix). */
1140 int unique; /* Indicates whether %g or %u/%U was used. */
1141 char *filename; /* associated filename. */
1142 int filename_length; /* strlen (filename). */
1143 struct temp_name *next;
1146 /* Number of commands executed so far. */
1148 static int execution_count;
1150 /* Number of commands that exited with a signal. */
1152 static int signal_count;
1154 /* Name with which this program was invoked. */
1156 static char *programname;
1158 /* Structures to keep track of prefixes to try when looking for files. */
1162 char *prefix; /* String to prepend to the path. */
1163 struct prefix_list *next; /* Next in linked list. */
1164 int require_machine_suffix; /* Don't use without machine_suffix. */
1165 /* 2 means try both machine_suffix and just_machine_suffix. */
1166 int *used_flag_ptr; /* 1 if a file was found with this prefix. */
1171 struct prefix_list *plist; /* List of prefixes to try */
1172 int max_len; /* Max length of a prefix in PLIST */
1173 char *name; /* Name of this list (used in config stuff) */
1176 /* List of prefixes to try when looking for executables. */
1178 static struct path_prefix exec_prefix = { 0, 0, "exec" };
1180 /* List of prefixes to try when looking for startup (crt0) files. */
1182 static struct path_prefix startfile_prefix = { 0, 0, "startfile" };
1184 /* Suffix to attach to directories searched for commands.
1185 This looks like `MACHINE/VERSION/'. */
1187 static char *machine_suffix = 0;
1189 /* Suffix to attach to directories searched for commands.
1190 This is just `MACHINE/'. */
1192 static char *just_machine_suffix = 0;
1194 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1196 static char *gcc_exec_prefix;
1198 /* Default prefixes to attach to command names. */
1200 #ifdef CROSS_COMPILE /* Don't use these prefixes for a cross compiler. */
1201 #undef MD_EXEC_PREFIX
1202 #undef MD_STARTFILE_PREFIX
1203 #undef MD_STARTFILE_PREFIX_1
1206 #ifndef STANDARD_EXEC_PREFIX
1207 #define STANDARD_EXEC_PREFIX "/usr/local/lib/gcc-lib/"
1208 #endif /* !defined STANDARD_EXEC_PREFIX */
1210 static char *standard_exec_prefix = STANDARD_EXEC_PREFIX;
1211 static char *standard_exec_prefix_1 = "/usr/lib/gcc/";
1212 #ifdef MD_EXEC_PREFIX
1213 static char *md_exec_prefix = MD_EXEC_PREFIX;
1216 #ifndef STANDARD_STARTFILE_PREFIX
1217 #define STANDARD_STARTFILE_PREFIX "/usr/local/lib/"
1218 #endif /* !defined STANDARD_STARTFILE_PREFIX */
1220 #ifdef MD_STARTFILE_PREFIX
1221 static char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1223 #ifdef MD_STARTFILE_PREFIX_1
1224 static char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1226 static char *standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1227 static char *standard_startfile_prefix_1 = "/lib/";
1228 static char *standard_startfile_prefix_2 = "/usr/lib/";
1230 #ifndef TOOLDIR_BASE_PREFIX
1231 #define TOOLDIR_BASE_PREFIX "/usr/local/"
1233 static char *tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1234 static char *tooldir_prefix;
1236 /* Clear out the vector of arguments (after a command is executed). */
1244 /* Add one argument to the vector at the end.
1245 This is done when a space is seen or at the end of the line.
1246 If DELETE_ALWAYS is nonzero, the arg is a filename
1247 and the file should be deleted eventually.
1248 If DELETE_FAILURE is nonzero, the arg is a filename
1249 and the file should be deleted if this compilation fails. */
1252 store_arg (arg, delete_always, delete_failure)
1254 int delete_always, delete_failure;
1256 if (argbuf_index + 1 == argbuf_length)
1258 argbuf = (char **) xrealloc (argbuf, (argbuf_length *= 2) * sizeof (char *));
1261 argbuf[argbuf_index++] = arg;
1262 argbuf[argbuf_index] = 0;
1264 if (delete_always || delete_failure)
1265 record_temp_file (arg, delete_always, delete_failure);
1268 /* Record the names of temporary files we tell compilers to write,
1269 and delete them at the end of the run. */
1271 /* This is the common prefix we use to make temp file names.
1272 It is chosen once for each run of this program.
1273 It is substituted into a spec by %g.
1274 Thus, all temp file names contain this prefix.
1275 In practice, all temp file names start with this prefix.
1277 This prefix comes from the envvar TMPDIR if it is defined;
1278 otherwise, from the P_tmpdir macro if that is defined;
1279 otherwise, in /usr/tmp or /tmp. */
1281 static char *temp_filename;
1283 /* Length of the prefix. */
1285 static int temp_filename_length;
1287 /* Define the list of temporary files to delete. */
1292 struct temp_file *next;
1295 /* Queue of files to delete on success or failure of compilation. */
1296 static struct temp_file *always_delete_queue;
1297 /* Queue of files to delete on failure of compilation. */
1298 static struct temp_file *failure_delete_queue;
1300 /* Record FILENAME as a file to be deleted automatically.
1301 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
1302 otherwise delete it in any case.
1303 FAIL_DELETE nonzero means delete it if a compilation step fails;
1304 otherwise delete it in any case. */
1307 record_temp_file (filename, always_delete, fail_delete)
1312 register char *name;
1313 name = xmalloc (strlen (filename) + 1);
1314 strcpy (name, filename);
1318 register struct temp_file *temp;
1319 for (temp = always_delete_queue; temp; temp = temp->next)
1320 if (! strcmp (name, temp->name))
1322 temp = (struct temp_file *) xmalloc (sizeof (struct temp_file));
1323 temp->next = always_delete_queue;
1325 always_delete_queue = temp;
1331 register struct temp_file *temp;
1332 for (temp = failure_delete_queue; temp; temp = temp->next)
1333 if (! strcmp (name, temp->name))
1335 temp = (struct temp_file *) xmalloc (sizeof (struct temp_file));
1336 temp->next = failure_delete_queue;
1338 failure_delete_queue = temp;
1343 /* Delete all the temporary files whose names we previously recorded. */
1346 delete_temp_files ()
1348 register struct temp_file *temp;
1350 for (temp = always_delete_queue; temp; temp = temp->next)
1354 printf ("Delete %s? (y or n) ", temp->name);
1358 while (getchar () != '\n') ;
1359 if (i == 'y' || i == 'Y')
1363 if (stat (temp->name, &st) >= 0)
1365 /* Delete only ordinary files. */
1366 if (S_ISREG (st.st_mode))
1367 if (unlink (temp->name) < 0)
1369 perror_with_name (temp->name);
1374 always_delete_queue = 0;
1377 /* Delete all the files to be deleted on error. */
1380 delete_failure_queue ()
1382 register struct temp_file *temp;
1384 for (temp = failure_delete_queue; temp; temp = temp->next)
1388 printf ("Delete %s? (y or n) ", temp->name);
1392 while (getchar () != '\n') ;
1393 if (i == 'y' || i == 'Y')
1396 if (unlink (temp->name) < 0)
1398 perror_with_name (temp->name);
1404 clear_failure_queue ()
1406 failure_delete_queue = 0;
1409 /* Compute a string to use as the base of all temporary file names.
1410 It is substituted for %g. */
1413 choose_temp_base_try (try, base)
1420 else if (try == (char *)0)
1422 else if (access (try, R_OK | W_OK) != 0)
1435 base = choose_temp_base_try (getenv ("TMPDIR"), base);
1436 base = choose_temp_base_try (getenv ("TMP"), base);
1437 base = choose_temp_base_try (getenv ("TEMP"), base);
1440 base = choose_temp_base_try (P_tmpdir, base);
1443 base = choose_temp_base_try ("/usr/tmp", base);
1444 base = choose_temp_base_try ("/tmp", base);
1446 /* If all else fails, use the current directory! */
1447 if (base == (char *)0)
1450 len = strlen (base);
1451 temp_filename = xmalloc (len + sizeof("/ccXXXXXX") + 1);
1452 strcpy (temp_filename, base);
1453 if (len > 0 && temp_filename[len-1] != '/')
1454 temp_filename[len++] = '/';
1455 strcpy (temp_filename + len, "ccXXXXXX");
1457 mktemp (temp_filename);
1458 temp_filename_length = strlen (temp_filename);
1459 if (temp_filename_length == 0)
1464 /* Routine to add variables to the environment. We do this to pass
1465 the pathname of the gcc driver, and the directories search to the
1466 collect2 program, which is being run as ld. This way, we can be
1467 sure of executing the right compiler when collect2 wants to build
1468 constructors and destructors. Since the environment variables we
1469 use come from an obstack, we don't have to worry about allocating
1478 #ifndef VMS /* nor about VMS */
1480 extern char **environ;
1481 char **old_environ = environ;
1485 int str_len = strlen (str);
1489 while ((ch = *p++) != '\0' && ch != '=')
1495 /* Search for replacing an existing environment variable, and
1496 count the number of total environment variables. */
1497 for (envp = old_environ; *envp; envp++)
1500 if (!strncmp (str, *envp, name_len))
1507 /* Add a new environment variable */
1508 environ = (char **) xmalloc (sizeof (char *) * (num_envs+2));
1510 bcopy (old_environ, environ+1, sizeof (char *) * (num_envs+1));
1515 #endif /* HAVE_PUTENV */
1518 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables for collect. */
1521 putenv_from_prefixes (paths, env_var)
1522 struct path_prefix *paths;
1525 int suffix_len = (machine_suffix) ? strlen (machine_suffix) : 0;
1527 = (just_machine_suffix) ? strlen (just_machine_suffix) : 0;
1528 int first_time = TRUE;
1529 struct prefix_list *pprefix;
1531 obstack_grow (&collect_obstack, env_var, strlen (env_var));
1533 for (pprefix = paths->plist; pprefix != 0; pprefix = pprefix->next)
1535 int len = strlen (pprefix->prefix);
1538 && is_directory (pprefix->prefix, machine_suffix, 0))
1541 obstack_1grow (&collect_obstack, PATH_SEPARATOR);
1544 obstack_grow (&collect_obstack, pprefix->prefix, len);
1545 obstack_grow (&collect_obstack, machine_suffix, suffix_len);
1548 if (just_machine_suffix
1549 && pprefix->require_machine_suffix == 2
1550 && is_directory (pprefix->prefix, just_machine_suffix, 0))
1553 obstack_1grow (&collect_obstack, PATH_SEPARATOR);
1556 obstack_grow (&collect_obstack, pprefix->prefix, len);
1557 obstack_grow (&collect_obstack, just_machine_suffix,
1561 if (!pprefix->require_machine_suffix)
1564 obstack_1grow (&collect_obstack, PATH_SEPARATOR);
1567 obstack_grow (&collect_obstack, pprefix->prefix, len);
1570 obstack_1grow (&collect_obstack, '\0');
1571 putenv (obstack_finish (&collect_obstack));
1575 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
1576 access to check permissions.
1577 Return 0 if not found, otherwise return its name, allocated with malloc. */
1580 find_a_file (pprefix, name, mode)
1581 struct path_prefix *pprefix;
1586 char *file_suffix = ((mode & X_OK) != 0 ? EXECUTABLE_SUFFIX : "");
1587 struct prefix_list *pl;
1588 int len = pprefix->max_len + strlen (name) + strlen (file_suffix) + 1;
1591 len += strlen (machine_suffix);
1593 temp = xmalloc (len);
1595 /* Determine the filename to execute (special case for absolute paths). */
1599 if (access (name, mode))
1601 strcpy (temp, name);
1606 for (pl = pprefix->plist; pl; pl = pl->next)
1610 strcpy (temp, pl->prefix);
1611 strcat (temp, machine_suffix);
1612 strcat (temp, name);
1613 if (access (temp, mode) == 0)
1615 if (pl->used_flag_ptr != 0)
1616 *pl->used_flag_ptr = 1;
1619 /* Some systems have a suffix for executable files.
1620 So try appending that. */
1621 if (file_suffix[0] != 0)
1623 strcat (temp, file_suffix);
1624 if (access (temp, mode) == 0)
1626 if (pl->used_flag_ptr != 0)
1627 *pl->used_flag_ptr = 1;
1632 /* Certain prefixes are tried with just the machine type,
1633 not the version. This is used for finding as, ld, etc. */
1634 if (just_machine_suffix && pl->require_machine_suffix == 2)
1636 strcpy (temp, pl->prefix);
1637 strcat (temp, just_machine_suffix);
1638 strcat (temp, name);
1639 if (access (temp, mode) == 0)
1641 if (pl->used_flag_ptr != 0)
1642 *pl->used_flag_ptr = 1;
1645 /* Some systems have a suffix for executable files.
1646 So try appending that. */
1647 if (file_suffix[0] != 0)
1649 strcat (temp, file_suffix);
1650 if (access (temp, mode) == 0)
1652 if (pl->used_flag_ptr != 0)
1653 *pl->used_flag_ptr = 1;
1658 /* Certain prefixes can't be used without the machine suffix
1659 when the machine or version is explicitly specified. */
1660 if (!pl->require_machine_suffix)
1662 strcpy (temp, pl->prefix);
1663 strcat (temp, name);
1664 if (access (temp, mode) == 0)
1666 if (pl->used_flag_ptr != 0)
1667 *pl->used_flag_ptr = 1;
1670 /* Some systems have a suffix for executable files.
1671 So try appending that. */
1672 if (file_suffix[0] != 0)
1674 strcat (temp, file_suffix);
1675 if (access (temp, mode) == 0)
1677 if (pl->used_flag_ptr != 0)
1678 *pl->used_flag_ptr = 1;
1689 /* Add an entry for PREFIX in PLIST. If FIRST is set, it goes
1690 at the start of the list, otherwise it goes at the end.
1692 If WARN is nonzero, we will warn if no file is found
1693 through this prefix. WARN should point to an int
1694 which will be set to 1 if this entry is used.
1696 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
1697 the complete value of machine_suffix.
1698 2 means try both machine_suffix and just_machine_suffix. */
1701 add_prefix (pprefix, prefix, first, require_machine_suffix, warn)
1702 struct path_prefix *pprefix;
1705 int require_machine_suffix;
1708 struct prefix_list *pl, **prev;
1711 if (!first && pprefix->plist)
1713 for (pl = pprefix->plist; pl->next; pl = pl->next)
1718 prev = &pprefix->plist;
1720 /* Keep track of the longest prefix */
1722 len = strlen (prefix);
1723 if (len > pprefix->max_len)
1724 pprefix->max_len = len;
1726 pl = (struct prefix_list *) xmalloc (sizeof (struct prefix_list));
1727 pl->prefix = save_string (prefix, len);
1728 pl->require_machine_suffix = require_machine_suffix;
1729 pl->used_flag_ptr = warn;
1736 pl->next = (struct prefix_list *) 0;
1740 /* Print warnings for any prefixes in the list PPREFIX that were not used. */
1743 unused_prefix_warnings (pprefix)
1744 struct path_prefix *pprefix;
1746 struct prefix_list *pl = pprefix->plist;
1750 if (pl->used_flag_ptr != 0 && !*pl->used_flag_ptr)
1752 error ("file path prefix `%s' never used",
1754 /* Prevent duplicate warnings. */
1755 *pl->used_flag_ptr = 1;
1761 /* Get rid of all prefixes built up so far in *PLISTP. */
1764 free_path_prefix (pprefix)
1765 struct path_prefix *pprefix;
1767 struct prefix_list *pl = pprefix->plist;
1768 struct prefix_list *temp;
1774 free (temp->prefix);
1775 free ((char *) temp);
1777 pprefix->plist = (struct prefix_list *) 0;
1780 /* stdin file number. */
1781 #define STDIN_FILE_NO 0
1783 /* stdout file number. */
1784 #define STDOUT_FILE_NO 1
1786 /* value of `pipe': port index for reading. */
1789 /* value of `pipe': port index for writing. */
1790 #define WRITE_PORT 1
1792 /* Pipe waiting from last process, to be used as input for the next one.
1793 Value is STDIN_FILE_NO if no pipe is waiting
1794 (i.e. the next command is the first of a group). */
1796 static int last_pipe_input;
1798 /* Fork one piped subcommand. FUNC is the system call to use
1799 (either execv or execvp). ARGV is the arg vector to use.
1800 NOT_LAST is nonzero if this is not the last subcommand
1801 (i.e. its output should be piped to the next one.) */
1806 /* Declare these to avoid compilation error. They won't be called. */
1807 int execv(const char *a, const char **b){}
1808 int execvp(const char *a, const char **b){}
1811 pexecute (search_flag, program, argv, not_last)
1819 int i, el = search_flag ? 0 : 4;
1821 scmd = (char *)malloc (strlen (program) + strlen (temp_filename) + 6 + el);
1822 rf = scmd + strlen(program) + 2 + el;
1823 sprintf (scmd, "%s%s @%s.gp", program,
1824 (search_flag ? "" : ".exe"), temp_filename);
1825 argfile = fopen (rf, "w");
1827 pfatal_with_name (rf);
1829 for (i=1; argv[i]; i++)
1832 for (cp = argv[i]; *cp; cp++)
1834 if (*cp == '"' || *cp == '\'' || *cp == '\\' || isspace (*cp))
1835 fputc ('\\', argfile);
1836 fputc (*cp, argfile);
1838 fputc ('\n', argfile);
1848 perror_exec (program);
1849 return MIN_FATAL_STATUS << 8;
1855 #else /* not __MSDOS__ */
1858 pexecute (search_flag, program, argv, not_last)
1864 int (*func)() = (search_flag ? execv : execvp);
1867 int input_desc = last_pipe_input;
1868 int output_desc = STDOUT_FILE_NO;
1869 int retries, sleep_interval;
1871 /* If this isn't the last process, make a pipe for its output,
1872 and record it as waiting to be the input to the next process. */
1876 if (pipe (pdes) < 0)
1877 pfatal_with_name ("pipe");
1878 output_desc = pdes[WRITE_PORT];
1879 last_pipe_input = pdes[READ_PORT];
1882 last_pipe_input = STDIN_FILE_NO;
1884 /* Fork a subprocess; wait and retry if it fails. */
1886 for (retries = 0; retries < 4; retries++)
1891 sleep (sleep_interval);
1892 sleep_interval *= 2;
1899 pfatal_with_name ("fork");
1901 pfatal_with_name ("vfork");
1907 /* Move the input and output pipes into place, if nec. */
1908 if (input_desc != STDIN_FILE_NO)
1910 close (STDIN_FILE_NO);
1914 if (output_desc != STDOUT_FILE_NO)
1916 close (STDOUT_FILE_NO);
1918 close (output_desc);
1921 /* Close the parent's descs that aren't wanted here. */
1922 if (last_pipe_input != STDIN_FILE_NO)
1923 close (last_pipe_input);
1925 /* Exec the program. */
1926 (*func) (program, argv);
1927 perror_exec (program);
1933 /* In the parent, after forking.
1934 Close the descriptors that we made for this child. */
1935 if (input_desc != STDIN_FILE_NO)
1937 if (output_desc != STDOUT_FILE_NO)
1938 close (output_desc);
1940 /* Return child's process number. */
1945 #endif /* not __MSDOS__ */
1949 pexecute (search_flag, program, argv, not_last)
1955 return (search_flag ? spawnv : spawnvp) (1, program, argv);
1957 #endif /* not OS2 */
1959 /* Execute the command specified by the arguments on the current line of spec.
1960 When using pipes, this includes several piped-together commands
1961 with `|' between them.
1963 Return 0 if successful, -1 if failed. */
1969 int n_commands; /* # of command. */
1973 char *prog; /* program name. */
1974 char **argv; /* vector of args. */
1975 int pid; /* pid of process for this command. */
1978 struct command *commands; /* each command buffer with above info. */
1980 /* Count # of piped commands. */
1981 for (n_commands = 1, i = 0; i < argbuf_index; i++)
1982 if (strcmp (argbuf[i], "|") == 0)
1985 /* Get storage for each command. */
1987 = (struct command *) alloca (n_commands * sizeof (struct command));
1989 /* Split argbuf into its separate piped processes,
1990 and record info about each one.
1991 Also search for the programs that are to be run. */
1993 commands[0].prog = argbuf[0]; /* first command. */
1994 commands[0].argv = &argbuf[0];
1995 string = find_a_file (&exec_prefix, commands[0].prog, X_OK);
1997 commands[0].argv[0] = string;
1999 for (n_commands = 1, i = 0; i < argbuf_index; i++)
2000 if (strcmp (argbuf[i], "|") == 0)
2001 { /* each command. */
2003 fatal ("-pipe not supported under MS-DOS");
2005 argbuf[i] = 0; /* termination of command args. */
2006 commands[n_commands].prog = argbuf[i + 1];
2007 commands[n_commands].argv = &argbuf[i + 1];
2008 string = find_a_file (&exec_prefix, commands[n_commands].prog, X_OK);
2010 commands[n_commands].argv[0] = string;
2014 argbuf[argbuf_index] = 0;
2016 /* If -v, print what we are about to do, and maybe query. */
2020 /* Print each piped command as a separate line. */
2021 for (i = 0; i < n_commands ; i++)
2025 for (j = commands[i].argv; *j; j++)
2026 fprintf (stderr, " %s", *j);
2028 /* Print a pipe symbol after all but the last command. */
2029 if (i + 1 != n_commands)
2030 fprintf (stderr, " |");
2031 fprintf (stderr, "\n");
2035 fprintf (stderr, "\nGo ahead? (y or n) ");
2039 while (getchar () != '\n') ;
2040 if (i != 'y' && i != 'Y')
2045 /* Run each piped subprocess. */
2047 last_pipe_input = STDIN_FILE_NO;
2048 for (i = 0; i < n_commands; i++)
2050 char *string = commands[i].argv[0];
2052 commands[i].pid = pexecute (string != commands[i].prog,
2053 string, commands[i].argv,
2054 i + 1 < n_commands);
2056 if (string != commands[i].prog)
2062 /* Wait for all the subprocesses to finish.
2063 We don't care what order they finish in;
2064 we know that N_COMMANDS waits will get them all. */
2069 for (i = 0; i < n_commands; i++)
2076 status = pid = commands[i].pid;
2078 pid = wait (&status);
2086 for (j = 0; j < n_commands; j++)
2087 if (commands[j].pid == pid)
2088 prog = commands[j].prog;
2090 if ((status & 0x7F) != 0)
2092 fatal ("Internal compiler error: program %s got fatal signal %d",
2093 prog, (status & 0x7F));
2096 if (((status & 0xFF00) >> 8) >= MIN_FATAL_STATUS)
2104 /* Find all the switches given to us
2105 and make a vector describing them.
2106 The elements of the vector are strings, one per switch given.
2107 If a switch uses following arguments, then the `part1' field
2108 is the switch itself and the `args' field
2109 is a null-terminated vector containing the following arguments.
2110 The `valid' field is nonzero if any spec has looked at this switch;
2111 if it remains zero at the end of the run, it must be meaningless. */
2120 static struct switchstr *switches;
2122 static int n_switches;
2130 /* Also a vector of input files specified. */
2132 static struct infile *infiles;
2134 static int n_infiles;
2136 /* And a vector of corresponding output files is made up later. */
2138 static char **outfiles;
2140 /* Create the vector `switches' and its contents.
2141 Store its length in `n_switches'. */
2144 process_command (argc, argv)
2150 char *spec_lang = 0;
2151 int last_language_n_infiles;
2153 gcc_exec_prefix = getenv ("GCC_EXEC_PREFIX");
2158 /* Figure compiler version from version string. */
2160 compiler_version = save_string (version_string, strlen (version_string));
2161 for (temp = compiler_version; *temp; ++temp)
2170 /* Set up the default search paths. */
2172 if (gcc_exec_prefix)
2174 add_prefix (&exec_prefix, gcc_exec_prefix, 0, 0, NULL_PTR);
2175 add_prefix (&startfile_prefix, gcc_exec_prefix, 0, 0, NULL_PTR);
2178 /* COMPILER_PATH and LIBRARY_PATH have values
2179 that are lists of directory names with colons. */
2181 temp = getenv ("COMPILER_PATH");
2184 char *startp, *endp;
2185 char *nstore = (char *) alloca (strlen (temp) + 3);
2187 startp = endp = temp;
2190 if (*endp == PATH_SEPARATOR || *endp == 0)
2192 strncpy (nstore, startp, endp-startp);
2195 strcpy (nstore, "./");
2197 else if (endp[-1] != '/')
2199 nstore[endp-startp] = '/';
2200 nstore[endp-startp+1] = 0;
2203 nstore[endp-startp] = 0;
2204 add_prefix (&exec_prefix, nstore, 0, 0, NULL_PTR);
2207 endp = startp = endp + 1;
2214 temp = getenv ("LIBRARY_PATH");
2217 char *startp, *endp;
2218 char *nstore = (char *) alloca (strlen (temp) + 3);
2220 startp = endp = temp;
2223 if (*endp == PATH_SEPARATOR || *endp == 0)
2225 strncpy (nstore, startp, endp-startp);
2228 strcpy (nstore, "./");
2230 else if (endp[-1] != '/')
2232 nstore[endp-startp] = '/';
2233 nstore[endp-startp+1] = 0;
2236 nstore[endp-startp] = 0;
2237 add_prefix (&startfile_prefix, nstore, 0, 0, NULL_PTR);
2240 endp = startp = endp + 1;
2247 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
2248 temp = getenv ("LPATH");
2251 char *startp, *endp;
2252 char *nstore = (char *) alloca (strlen (temp) + 3);
2254 startp = endp = temp;
2257 if (*endp == PATH_SEPARATOR || *endp == 0)
2259 strncpy (nstore, startp, endp-startp);
2262 strcpy (nstore, "./");
2264 else if (endp[-1] != '/')
2266 nstore[endp-startp] = '/';
2267 nstore[endp-startp+1] = 0;
2270 nstore[endp-startp] = 0;
2271 add_prefix (&startfile_prefix, nstore, 0, 0, NULL_PTR);
2274 endp = startp = endp + 1;
2281 /* Convert new-style -- options to old-style. */
2282 translate_options (&argc, &argv);
2284 /* Scan argv twice. Here, the first time, just count how many switches
2285 there will be in their vector, and how many input files in theirs.
2286 Here we also parse the switches that cc itself uses (e.g. -v). */
2288 for (i = 1; i < argc; i++)
2290 if (! strcmp (argv[i], "-dumpspecs"))
2292 printf ("*asm:\n%s\n\n", asm_spec);
2293 printf ("*asm_final:\n%s\n\n", asm_final_spec);
2294 printf ("*cpp:\n%s\n\n", cpp_spec);
2295 printf ("*cc1:\n%s\n\n", cc1_spec);
2296 printf ("*cc1plus:\n%s\n\n", cc1plus_spec);
2297 printf ("*endfile:\n%s\n\n", endfile_spec);
2298 printf ("*link:\n%s\n\n", link_spec);
2299 printf ("*lib:\n%s\n\n", lib_spec);
2300 printf ("*startfile:\n%s\n\n", startfile_spec);
2301 printf ("*switches_need_spaces:\n%s\n\n", switches_need_spaces);
2302 printf ("*signed_char:\n%s\n\n", signed_char_spec);
2303 printf ("*predefines:\n%s\n\n", cpp_predefines);
2304 printf ("*cross_compile:\n%d\n\n", cross_compile);
2308 else if (! strcmp (argv[i], "-dumpversion"))
2310 printf ("%s\n", version_string);
2313 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
2315 print_libgcc_file_name = 1;
2317 else if (! strcmp (argv[i], "-Xlinker"))
2319 /* Pass the argument of this option to the linker when we link. */
2322 fatal ("argument to `-Xlinker' is missing");
2325 if (!linker_options)
2327 = (char **) xmalloc (n_linker_options * sizeof (char **));
2330 = (char **) xrealloc (linker_options,
2331 n_linker_options * sizeof (char **));
2333 linker_options[n_linker_options - 1] = argv[++i];
2335 else if (! strncmp (argv[i], "-Wl,", 4))
2338 /* Pass the rest of this option to the linker when we link. */
2341 if (!linker_options)
2343 = (char **) xmalloc (n_linker_options * sizeof (char **));
2346 = (char **) xrealloc (linker_options,
2347 n_linker_options * sizeof (char **));
2349 /* Split the argument at commas. */
2351 for (j = 4; argv[i][j]; j++)
2352 if (argv[i][j] == ',')
2354 linker_options[n_linker_options - 1]
2355 = save_string (argv[i] + prev, j - prev);
2358 = (char **) xrealloc (linker_options,
2359 n_linker_options * sizeof (char **));
2362 /* Record the part after the last comma. */
2363 linker_options[n_linker_options - 1] = argv[i] + prev;
2365 else if (! strncmp (argv[i], "-Wa,", 4))
2368 /* Pass the rest of this option to the assembler. */
2370 n_assembler_options++;
2371 if (!assembler_options)
2373 = (char **) xmalloc (n_assembler_options * sizeof (char **));
2376 = (char **) xrealloc (assembler_options,
2377 n_assembler_options * sizeof (char **));
2379 /* Split the argument at commas. */
2381 for (j = 4; argv[i][j]; j++)
2382 if (argv[i][j] == ',')
2384 assembler_options[n_assembler_options - 1]
2385 = save_string (argv[i] + prev, j - prev);
2386 n_assembler_options++;
2388 = (char **) xrealloc (assembler_options,
2389 n_assembler_options * sizeof (char **));
2392 /* Record the part after the last comma. */
2393 assembler_options[n_assembler_options - 1] = argv[i] + prev;
2395 else if (argv[i][0] == '+' && argv[i][1] == 'e')
2396 /* The +e options to the C++ front-end. */
2398 else if (argv[i][0] == '-' && argv[i][1] != 0 && argv[i][1] != 'l')
2400 register char *p = &argv[i][1];
2401 register int c = *p;
2406 if (p[1] == 0 && i + 1 == argc)
2407 fatal ("argument to `-b' is missing");
2409 spec_machine = argv[++i];
2411 spec_machine = p + 1;
2416 int *temp = (int *) xmalloc (sizeof (int));
2418 if (p[1] == 0 && i + 1 == argc)
2419 fatal ("argument to `-B' is missing");
2424 add_prefix (&exec_prefix, value, 1, 0, temp);
2425 add_prefix (&startfile_prefix, value, 1, 0, temp);
2429 case 'v': /* Print our subcommands and print versions. */
2431 /* If they do anything other than exactly `-v', don't set
2432 verbose_flag; rather, continue on to give the error. */
2439 if (p[1] == 0 && i + 1 == argc)
2440 fatal ("argument to `-V' is missing");
2442 spec_version = argv[++i];
2444 spec_version = p + 1;
2445 compiler_version = spec_version;
2449 if (!strcmp (p, "save-temps"))
2451 save_temps_flag = 1;
2458 if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
2459 i += SWITCH_TAKES_ARG (c) - (p[1] != 0);
2460 else if (WORD_SWITCH_TAKES_ARG (p))
2461 i += WORD_SWITCH_TAKES_ARG (p);
2468 /* Set up the search paths before we go looking for config files. */
2470 /* These come before the md prefixes so that we will find gcc's subcommands
2471 (such as cpp) rather than those of the host system. */
2472 /* Use 2 as fourth arg meaning try just the machine as a suffix,
2473 as well as trying the machine and the version. */
2474 add_prefix (&exec_prefix, standard_exec_prefix, 0, 2, NULL_PTR);
2475 add_prefix (&exec_prefix, standard_exec_prefix_1, 0, 2, NULL_PTR);
2477 add_prefix (&startfile_prefix, standard_exec_prefix, 0, 1, NULL_PTR);
2478 add_prefix (&startfile_prefix, standard_exec_prefix_1, 0, 1, NULL_PTR);
2480 tooldir_prefix = concat (tooldir_base_prefix, spec_machine, "/");
2482 /* If tooldir is relative, base it on exec_prefix. A relative
2483 tooldir lets us move the installed tree as a unit.
2485 If GCC_EXEC_PREFIX is defined, then we want to add two relative
2486 directories, so that we can search both the user specified directory
2487 and the standard place. */
2489 if (*tooldir_prefix != '/')
2491 if (gcc_exec_prefix)
2493 char *gcc_exec_tooldir_prefix
2494 = concat (concat (gcc_exec_prefix, spec_machine, "/"),
2495 concat (spec_version, "/", tooldir_prefix),
2498 add_prefix (&exec_prefix, concat (gcc_exec_tooldir_prefix, "bin", "/"),
2500 add_prefix (&startfile_prefix, concat (gcc_exec_tooldir_prefix, "lib", "/"),
2504 tooldir_prefix = concat (concat (standard_exec_prefix, spec_machine, "/"),
2505 concat (spec_version, "/", tooldir_prefix),
2509 add_prefix (&exec_prefix, concat (tooldir_prefix, "bin", "/"),
2511 add_prefix (&startfile_prefix, concat (tooldir_prefix, "lib", "/"),
2514 /* More prefixes are enabled in main, after we read the specs file
2515 and determine whether this is cross-compilation or not. */
2518 /* Then create the space for the vectors and scan again. */
2520 switches = ((struct switchstr *)
2521 xmalloc ((n_switches + 1) * sizeof (struct switchstr)));
2522 infiles = (struct infile *) xmalloc ((n_infiles + 1) * sizeof (struct infile));
2525 last_language_n_infiles = -1;
2527 /* This, time, copy the text of each switch and store a pointer
2528 to the copy in the vector of switches.
2529 Store all the infiles in their vector. */
2531 for (i = 1; i < argc; i++)
2533 /* Just skip the switches that were handled by the preceding loop. */
2534 if (!strcmp (argv[i], "-Xlinker"))
2536 else if (! strncmp (argv[i], "-Wl,", 4))
2538 else if (! strncmp (argv[i], "-Wa,", 4))
2540 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
2542 else if (argv[i][0] == '+' && argv[i][1] == 'e')
2544 /* Compensate for the +e options to the C++ front-end;
2545 they're there simply for cfront call-compatibility. We do
2546 some magic in default_compilers to pass them down properly.
2547 Note we deliberately start at the `+' here, to avoid passing
2548 -e0 or -e1 down into the linker. */
2549 switches[n_switches].part1 = &argv[i][0];
2550 switches[n_switches].args = 0;
2551 switches[n_switches].valid = 0;
2554 else if (argv[i][0] == '-' && argv[i][1] != 0 && argv[i][1] != 'l')
2556 register char *p = &argv[i][1];
2557 register int c = *p;
2559 if (c == 'B' || c == 'b' || c == 'V')
2561 /* Skip a separate arg, if any. */
2568 if (p[1] == 0 && i + 1 == argc)
2569 fatal ("argument to `-x' is missing");
2571 spec_lang = argv[++i];
2574 if (! strcmp (spec_lang, "none"))
2575 /* Suppress the warning if -xnone comes after the last input file,
2576 because alternate command interfaces like g++ might find it
2577 useful to place -xnone after each input file. */
2580 last_language_n_infiles = n_infiles;
2583 switches[n_switches].part1 = p;
2584 /* Deal with option arguments in separate argv elements. */
2585 if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
2586 || WORD_SWITCH_TAKES_ARG (p))
2589 int n_args = WORD_SWITCH_TAKES_ARG (p);
2593 /* Count only the option arguments in separate argv elements. */
2594 n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
2596 if (i + n_args >= argc)
2597 fatal ("argument to `-%s' is missing", p);
2598 switches[n_switches].args
2599 = (char **) xmalloc ((n_args + 1) * sizeof (char *));
2601 switches[n_switches].args[j++] = argv[++i];
2602 /* Null-terminate the vector. */
2603 switches[n_switches].args[j] = 0;
2605 else if (*switches_need_spaces != 0 && (c == 'o' || c == 'L'))
2607 /* On some systems, ld cannot handle -o or -L without space.
2608 So split the -o or -L from its argument. */
2609 switches[n_switches].part1 = (c == 'o' ? "o" : "L");
2610 switches[n_switches].args = (char **) xmalloc (2 * sizeof (char *));
2611 switches[n_switches].args[0] = xmalloc (strlen (p));
2612 strcpy (switches[n_switches].args[0], &p[1]);
2613 switches[n_switches].args[1] = 0;
2616 switches[n_switches].args = 0;
2617 switches[n_switches].valid = 0;
2618 /* This is always valid, since gcc.c itself understands it. */
2619 if (!strcmp (p, "save-temps"))
2620 switches[n_switches].valid = 1;
2625 if ((argv[i][0] != '-' || argv[i][1] != 'l')
2626 && strcmp (argv[i], "-")
2627 && access (argv[i], R_OK) < 0)
2629 perror_with_name (argv[i]);
2634 infiles[n_infiles].language = spec_lang;
2635 infiles[n_infiles++].name = argv[i];
2640 if (n_infiles == last_language_n_infiles && spec_lang != 0)
2641 error ("Warning: `-x %s' after last input file has no effect", spec_lang);
2643 switches[n_switches].part1 = 0;
2644 infiles[n_infiles].name = 0;
2646 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
2647 if (gcc_exec_prefix)
2649 temp = (char *) xmalloc (strlen (gcc_exec_prefix) + strlen (spec_version)
2650 + strlen (spec_machine) + 3);
2651 strcpy (temp, gcc_exec_prefix);
2652 strcat (temp, spec_machine);
2654 strcat (temp, spec_version);
2656 gcc_exec_prefix = temp;
2660 /* Process a spec string, accumulating and running commands. */
2662 /* These variables describe the input file name.
2663 input_file_number is the index on outfiles of this file,
2664 so that the output file name can be stored for later use by %o.
2665 input_basename is the start of the part of the input file
2666 sans all directory names, and basename_length is the number
2667 of characters starting there excluding the suffix .c or whatever. */
2669 static char *input_filename;
2670 static int input_file_number;
2671 static int input_filename_length;
2672 static int basename_length;
2673 static char *input_basename;
2674 static char *input_suffix;
2676 /* These are variables used within do_spec and do_spec_1. */
2678 /* Nonzero if an arg has been started and not yet terminated
2679 (with space, tab or newline). */
2680 static int arg_going;
2682 /* Nonzero means %d or %g has been seen; the next arg to be terminated
2683 is a temporary file name. */
2684 static int delete_this_arg;
2686 /* Nonzero means %w has been seen; the next arg to be terminated
2687 is the output file name of this compilation. */
2688 static int this_is_output_file;
2690 /* Nonzero means %s has been seen; the next arg to be terminated
2691 is the name of a library file and we should try the standard
2692 search dirs for it. */
2693 static int this_is_library_file;
2695 /* Nonzero means that the input of this command is coming from a pipe. */
2696 static int input_from_pipe;
2698 /* Process the spec SPEC and run the commands specified therein.
2699 Returns 0 if the spec is successfully processed; -1 if failed. */
2709 delete_this_arg = 0;
2710 this_is_output_file = 0;
2711 this_is_library_file = 0;
2712 input_from_pipe = 0;
2714 value = do_spec_1 (spec, 0, NULL_PTR);
2716 /* Force out any unfinished command.
2717 If -pipe, this forces out the last command if it ended in `|'. */
2720 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
2723 if (argbuf_index > 0)
2730 /* Process the sub-spec SPEC as a portion of a larger spec.
2731 This is like processing a whole spec except that we do
2732 not initialize at the beginning and we do not supply a
2733 newline by default at the end.
2734 INSWITCH nonzero means don't process %-sequences in SPEC;
2735 in this case, % is treated as an ordinary character.
2736 This is used while substituting switches.
2737 INSWITCH nonzero also causes SPC not to terminate an argument.
2739 Value is zero unless a line was finished
2740 and the command on that line reported an error. */
2743 do_spec_1 (spec, inswitch, soft_matched_part)
2746 char *soft_matched_part;
2748 register char *p = spec;
2755 /* If substituting a switch, treat all chars like letters.
2756 Otherwise, NL, SPC, TAB and % are special. */
2757 switch (inswitch ? 'a' : c)
2760 /* End of line: finish any pending argument,
2761 then run the pending command if one has been started. */
2764 obstack_1grow (&obstack, 0);
2765 string = obstack_finish (&obstack);
2766 if (this_is_library_file)
2767 string = find_file (string);
2768 store_arg (string, delete_this_arg, this_is_output_file);
2769 if (this_is_output_file)
2770 outfiles[input_file_number] = string;
2774 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
2777 for (i = 0; i < n_switches; i++)
2778 if (!strcmp (switches[i].part1, "pipe"))
2781 /* A `|' before the newline means use a pipe here,
2782 but only if -pipe was specified.
2783 Otherwise, execute now and don't pass the `|' as an arg. */
2786 input_from_pipe = 1;
2787 switches[i].valid = 1;
2794 if (argbuf_index > 0)
2800 /* Reinitialize for a new command, and for a new argument. */
2803 delete_this_arg = 0;
2804 this_is_output_file = 0;
2805 this_is_library_file = 0;
2806 input_from_pipe = 0;
2810 /* End any pending argument. */
2813 obstack_1grow (&obstack, 0);
2814 string = obstack_finish (&obstack);
2815 if (this_is_library_file)
2816 string = find_file (string);
2817 store_arg (string, delete_this_arg, this_is_output_file);
2818 if (this_is_output_file)
2819 outfiles[input_file_number] = string;
2823 obstack_1grow (&obstack, c);
2829 /* Space or tab ends an argument if one is pending. */
2832 obstack_1grow (&obstack, 0);
2833 string = obstack_finish (&obstack);
2834 if (this_is_library_file)
2835 string = find_file (string);
2836 store_arg (string, delete_this_arg, this_is_output_file);
2837 if (this_is_output_file)
2838 outfiles[input_file_number] = string;
2840 /* Reinitialize for a new argument. */
2842 delete_this_arg = 0;
2843 this_is_output_file = 0;
2844 this_is_library_file = 0;
2851 fatal ("Invalid specification! Bug in cc.");
2854 obstack_grow (&obstack, input_basename, basename_length);
2859 delete_this_arg = 2;
2862 /* Dump out the directories specified with LIBRARY_PATH,
2863 followed by the absolute directories
2864 that we search for startfiles. */
2867 struct prefix_list *pl = startfile_prefix.plist;
2869 char *buffer = (char *) xmalloc (bufsize);
2872 for (; pl; pl = pl->next)
2874 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
2875 /* Used on systems which record the specified -L dirs
2876 and use them to search for dynamic linking. */
2877 /* Relative directories always come from -B,
2878 and it is better not to use them for searching
2879 at run time. In particular, stage1 loses */
2880 if (pl->prefix[0] != '/')
2885 if (is_directory (pl->prefix, machine_suffix, 1))
2887 do_spec_1 ("-L", 0, NULL_PTR);
2888 #ifdef SPACE_AFTER_L_OPTION
2889 do_spec_1 (" ", 0, NULL_PTR);
2891 do_spec_1 (pl->prefix, 1, NULL_PTR);
2892 /* Remove slash from machine_suffix. */
2893 if (strlen (machine_suffix) >= bufsize)
2894 bufsize = strlen (machine_suffix) * 2 + 1;
2895 buffer = (char *) xrealloc (buffer, bufsize);
2896 strcpy (buffer, machine_suffix);
2897 idx = strlen (buffer);
2898 if (buffer[idx - 1] == '/')
2899 buffer[idx - 1] = 0;
2900 do_spec_1 (buffer, 1, NULL_PTR);
2901 /* Make this a separate argument. */
2902 do_spec_1 (" ", 0, NULL_PTR);
2905 if (!pl->require_machine_suffix)
2907 if (is_directory (pl->prefix, "", 1))
2909 do_spec_1 ("-L", 0, NULL_PTR);
2910 #ifdef SPACE_AFTER_L_OPTION
2911 do_spec_1 (" ", 0, NULL_PTR);
2913 /* Remove slash from pl->prefix. */
2914 if (strlen (pl->prefix) >= bufsize)
2915 bufsize = strlen (pl->prefix) * 2 + 1;
2916 buffer = (char *) xrealloc (buffer, bufsize);
2917 strcpy (buffer, pl->prefix);
2918 idx = strlen (buffer);
2919 if (buffer[idx - 1] == '/')
2920 buffer[idx - 1] = 0;
2921 do_spec_1 (buffer, 1, NULL_PTR);
2922 /* Make this a separate argument. */
2923 do_spec_1 (" ", 0, NULL_PTR);
2932 /* {...:%efoo} means report an error with `foo' as error message
2933 and don't execute any more commands for this file. */
2937 while (*p != 0 && *p != '\n') p++;
2938 buf = (char *) alloca (p - q + 1);
2939 strncpy (buf, q, p - q);
2949 if (save_temps_flag)
2950 obstack_grow (&obstack, input_basename, basename_length);
2953 #ifdef MKTEMP_EACH_FILE
2954 /* ??? This has a problem: the total number of
2955 values mktemp can return is limited.
2956 That matters for the names of object files.
2957 In 2.4, do something about that. */
2958 struct temp_name *t;
2960 while (*p == '.' || isalpha (*p))
2963 /* See if we already have an association of %g/%u/%U and
2965 for (t = temp_names; t; t = t->next)
2966 if (t->length == p - suffix
2967 && strncmp (t->suffix, suffix, p - suffix) == 0
2968 && t->unique == (c != 'g'))
2971 /* Make a new association if needed. %u requires one. */
2972 if (t == 0 || c == 'u')
2976 t = (struct temp_name *) xmalloc (sizeof (struct temp_name));
2977 t->next = temp_names;
2980 t->length = p - suffix;
2981 t->suffix = save_string (suffix, p - suffix);
2982 t->unique = (c != 'g');
2983 choose_temp_base ();
2984 t->filename = temp_filename;
2985 t->filename_length = temp_filename_length;
2988 obstack_grow (&obstack, t->filename, t->filename_length);
2989 delete_this_arg = 1;
2991 obstack_grow (&obstack, temp_filename, temp_filename_length);
2992 if (c == 'u' || c == 'U')
2998 sprintf (buff, "%d", unique);
2999 obstack_grow (&obstack, buff, strlen (buff));
3002 delete_this_arg = 1;
3008 obstack_grow (&obstack, input_filename, input_filename_length);
3013 if (gcc_exec_prefix)
3015 do_spec_1 ("-iprefix", 1, NULL_PTR);
3016 /* Make this a separate argument. */
3017 do_spec_1 (" ", 0, NULL_PTR);
3018 do_spec_1 (gcc_exec_prefix, 1, NULL_PTR);
3019 do_spec_1 (" ", 0, NULL_PTR);
3026 for (f = 0; f < n_infiles; f++)
3027 store_arg (outfiles[f], 0, 0);
3032 this_is_library_file = 1;
3036 this_is_output_file = 1;
3041 int index = argbuf_index;
3042 /* Handle the {...} following the %W. */
3045 p = handle_braces (p + 1);
3048 /* If any args were output, mark the last one for deletion
3050 if (argbuf_index != index)
3051 record_temp_file (argbuf[argbuf_index - 1], 0, 1);
3055 /* %x{OPTION} records OPTION for %X to output. */
3061 /* Skip past the option value and make a copy. */
3066 string = save_string (p1 + 1, p - p1 - 2);
3068 /* See if we already recorded this option. */
3069 for (i = 0; i < n_linker_options; i++)
3070 if (! strcmp (string, linker_options[i]))
3076 /* This option is new; add it. */
3078 if (!linker_options)
3080 = (char **) xmalloc (n_linker_options * sizeof (char **));
3083 = (char **) xrealloc (linker_options,
3084 n_linker_options * sizeof (char **));
3086 linker_options[n_linker_options - 1] = string;
3090 /* Dump out the options accumulated previously using %x,
3091 -Xlinker and -Wl,. */
3093 for (i = 0; i < n_linker_options; i++)
3095 do_spec_1 (linker_options[i], 1, NULL_PTR);
3096 /* Make each accumulated option a separate argument. */
3097 do_spec_1 (" ", 0, NULL_PTR);
3101 /* Dump out the options accumulated previously using -Wa,. */
3103 for (i = 0; i < n_assembler_options; i++)
3105 do_spec_1 (assembler_options[i], 1, NULL_PTR);
3106 /* Make each accumulated option a separate argument. */
3107 do_spec_1 (" ", 0, NULL_PTR);
3111 /* Here are digits and numbers that just process
3112 a certain constant string as a spec. */
3115 value = do_spec_1 (cc1_spec, 0, NULL_PTR);
3121 value = do_spec_1 (cc1plus_spec, 0, NULL_PTR);
3127 value = do_spec_1 (asm_spec, 0, NULL_PTR);
3133 value = do_spec_1 (asm_final_spec, 0, NULL_PTR);
3139 value = do_spec_1 (signed_char_spec, 0, NULL_PTR);
3145 value = do_spec_1 (cpp_spec, 0, NULL_PTR);
3151 value = do_spec_1 (endfile_spec, 0, NULL_PTR);
3157 value = do_spec_1 (link_spec, 0, NULL_PTR);
3163 value = do_spec_1 (lib_spec, 0, NULL_PTR);
3170 char *x = (char *) alloca (strlen (cpp_predefines) + 1);
3174 /* Copy all of the -D options in CPP_PREDEFINES into BUF. */
3178 if (! strncmp (y, "-D", 2))
3179 /* Copy the whole option. */
3180 while (*y && *y != ' ' && *y != '\t')
3182 else if (*y == ' ' || *y == '\t')
3183 /* Copy whitespace to the result. */
3185 /* Don't copy other options. */
3192 value = do_spec_1 (buf, 0, NULL_PTR);
3200 char *x = (char *) alloca (strlen (cpp_predefines) * 4 + 1);
3204 /* Copy all of CPP_PREDEFINES into BUF,
3205 but put __ after every -D and at the end of each arg. */
3209 if (! strncmp (y, "-D", 2))
3216 if (strncmp (y, "__", 2))
3218 /* Stick __ at front of macro name. */
3221 /* Arrange to stick __ at the end as well. */
3225 /* Copy the macro name. */
3226 while (*y && *y != '=' && *y != ' ' && *y != '\t')
3235 /* Copy the value given, if any. */
3236 while (*y && *y != ' ' && *y != '\t')
3239 else if (*y == ' ' || *y == '\t')
3240 /* Copy whitespace to the result. */
3242 /* Don't copy -A options */
3248 /* Copy all of CPP_PREDEFINES into BUF,
3249 but put __ after every -D. */
3253 if (! strncmp (y, "-D", 2))
3258 if (strncmp (y, "__", 2))
3260 /* Stick __ at front of macro name. */
3265 /* Copy the macro name. */
3266 while (*y && *y != '=' && *y != ' ' && *y != '\t')
3269 /* Copy the value given, if any. */
3270 while (*y && *y != ' ' && *y != '\t')
3273 else if (*y == ' ' || *y == '\t')
3274 /* Copy whitespace to the result. */
3276 /* Don't copy -A options */
3282 /* Copy all of the -A options in CPP_PREDEFINES into BUF. */
3286 if (! strncmp (y, "-A", 2))
3287 /* Copy the whole option. */
3288 while (*y && *y != ' ' && *y != '\t')
3290 else if (*y == ' ' || *y == '\t')
3291 /* Copy whitespace to the result. */
3293 /* Don't copy other options. */
3300 value = do_spec_1 (buf, 0, NULL_PTR);
3307 value = do_spec_1 (startfile_spec, 0, NULL_PTR);
3312 /* Here we define characters other than letters and digits. */
3315 p = handle_braces (p);
3321 obstack_1grow (&obstack, '%');
3325 do_spec_1 (soft_matched_part, 1, NULL_PTR);
3326 do_spec_1 (" ", 0, NULL_PTR);
3329 /* Process a string found as the value of a spec given by name.
3330 This feature allows individual machine descriptions
3331 to add and use their own specs.
3332 %[...] modifies -D options the way %P does;
3333 %(...) uses the spec unmodified. */
3338 struct spec_list *sl;
3341 /* The string after the S/P is the name of a spec that is to be
3343 while (*p && *p != ')' && *p != ']')
3346 /* See if it's in the list */
3347 for (len = p - name, sl = specs; sl; sl = sl->next)
3348 if (strncmp (sl->name, name, len) == 0 && !sl->name[len])
3358 value = do_spec_1 (name, 0, NULL_PTR);
3364 char *x = (char *) alloca (strlen (name) * 2 + 1);
3368 /* Copy all of NAME into BUF, but put __ after
3369 every -D and at the end of each arg, */
3372 if (! strncmp (y, "-D", 2))
3380 else if (*y == ' ' || *y == 0)
3394 value = do_spec_1 (buf, 0, NULL_PTR);
3400 /* Discard the closing paren or bracket. */
3408 int c1 = *p++; /* Select first or second version number. */
3409 char *v = compiler_version;
3411 /* If desired, advance to second version number. */
3414 /* Set P after the first period. */
3415 while (*v != 0 && *v != ' ' && *v != '.')
3420 /* Set Q at the next period or at the end. */
3422 while (*q != 0 && *q != ' ' && *q != '.')
3424 /* Empty string means zero. */
3430 /* Put that part into the command. */
3431 obstack_grow (&obstack, v, q - v);
3437 if (input_from_pipe)
3438 do_spec_1 ("-", 0, NULL_PTR);
3447 /* Backslash: treat next character as ordinary. */
3452 /* Ordinary character: put it into the current argument. */
3453 obstack_1grow (&obstack, c);
3457 return 0; /* End of string */
3460 /* Return 0 if we call do_spec_1 and that returns -1. */
3473 /* A `|' after the open-brace means,
3474 if the test fails, output a single minus sign rather than nothing.
3475 This is used in %{|!pipe:...}. */
3479 /* A `!' after the open-brace negates the condition:
3480 succeed if the specified switch is not present. */
3484 /* A `.' after the open-brace means test against the current suffix. */
3494 while (*p != ':' && *p != '}') p++;
3497 register int count = 1;
3515 int found = (input_suffix != 0
3516 && strlen (input_suffix) == p - filter
3517 && strncmp (input_suffix, filter, p - filter) == 0);
3523 && do_spec_1 (save_string (p + 1, q - p - 2), 0, NULL_PTR) < 0)
3528 else if (p[-1] == '*' && p[0] == '}')
3530 /* Substitute all matching switches as separate args. */
3533 for (i = 0; i < n_switches; i++)
3534 if (!strncmp (switches[i].part1, filter, p - filter))
3539 /* Test for presence of the specified switch. */
3543 /* If name specified ends in *, as in {x*:...},
3544 check for %* and handle that case. */
3545 if (p[-1] == '*' && !negate)
3550 /* First see whether we have %*. */
3554 if (*r == '%' && r[1] == '*')
3558 /* If we do, handle that case. */
3561 /* Substitute all matching switches as separate args.
3562 But do this by substituting for %*
3563 in the text that follows the colon. */
3565 unsigned hard_match_len = p - filter - 1;
3566 char *string = save_string (p + 1, q - p - 2);
3568 for (i = 0; i < n_switches; i++)
3569 if (!strncmp (switches[i].part1, filter, hard_match_len))
3571 do_spec_1 (string, 0, &switches[i].part1[hard_match_len]);
3572 /* Pass any arguments this switch has. */
3580 /* If name specified ends in *, as in {x*:...},
3581 check for presence of any switch name starting with x. */
3584 for (i = 0; i < n_switches; i++)
3586 unsigned hard_match_len = p - filter - 1;
3588 if (!strncmp (switches[i].part1, filter, hard_match_len))
3590 switches[i].valid = 1;
3595 /* Otherwise, check for presence of exact name specified. */
3598 for (i = 0; i < n_switches; i++)
3600 if (!strncmp (switches[i].part1, filter, p - filter)
3601 && switches[i].part1[p - filter] == 0)
3603 switches[i].valid = 1;
3610 /* If it is as desired (present for %{s...}, absent for %{-s...})
3611 then substitute either the switch or the specified
3612 conditional text. */
3613 if (present != negate)
3621 if (do_spec_1 (save_string (p + 1, q - p - 2), 0, NULL_PTR) < 0)
3627 /* Here if a %{|...} conditional fails: output a minus sign,
3628 which means "standard output" or "standard input". */
3629 do_spec_1 ("-", 0, NULL_PTR);
3636 /* Pass a switch to the current accumulating command
3637 in the same form that we received it.
3638 SWITCHNUM identifies the switch; it is an index into
3639 the vector of switches gcc received, which is `switches'.
3640 This cannot fail since it never finishes a command line.
3642 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
3645 give_switch (switchnum, omit_first_word)
3647 int omit_first_word;
3649 if (!omit_first_word)
3651 do_spec_1 ("-", 0, NULL_PTR);
3652 do_spec_1 (switches[switchnum].part1, 1, NULL_PTR);
3654 do_spec_1 (" ", 0, NULL_PTR);
3655 if (switches[switchnum].args != 0)
3658 for (p = switches[switchnum].args; *p; p++)
3660 do_spec_1 (*p, 1, NULL_PTR);
3661 do_spec_1 (" ", 0, NULL_PTR);
3664 switches[switchnum].valid = 1;
3667 /* Search for a file named NAME trying various prefixes including the
3668 user's -B prefix and some standard ones.
3669 Return the absolute file name found. If nothing is found, return NAME. */
3677 newname = find_a_file (&startfile_prefix, name, R_OK);
3678 return newname ? newname : name;
3681 /* Determine whether a directory exists. If LINKER, return 0 for
3682 certain fixed names not needed by the linker. If not LINKER, it is
3683 only important to return 0 if the host machine has a small ARG_MAX
3687 is_directory (path1, path2, linker)
3692 int len1 = strlen (path1);
3693 int len2 = strlen (path2);
3694 char *path = (char *) alloca (3 + len1 + len2);
3698 #ifndef SMALL_ARG_MAX
3703 /* Construct the path from the two parts. Ensure the string ends with "/.".
3704 The resulting path will be a directory even if the given path is a
3706 bcopy (path1, path, len1);
3707 bcopy (path2, path + len1, len2);
3708 cp = path + len1 + len2;
3714 /* Exclude directories that the linker is known to search. */
3716 && ((cp - path == 6 && strcmp (path, "/lib/.") == 0)
3717 || (cp - path == 10 && strcmp (path, "/usr/lib/.") == 0)))
3720 return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
3723 /* On fatal signals, delete all the temporary files. */
3726 fatal_error (signum)
3729 signal (signum, SIG_DFL);
3730 delete_failure_queue ();
3731 delete_temp_files ();
3732 /* Get the same signal again, this time not handled,
3733 so its normal effect occurs. */
3734 kill (getpid (), signum);
3745 int linker_was_run = 0;
3746 char *explicit_link_files;
3750 p = argv[0] + strlen (argv[0]);
3751 while (p != argv[0] && p[-1] != '/') --p;
3754 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
3755 signal (SIGINT, fatal_error);
3757 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
3758 signal (SIGHUP, fatal_error);
3760 if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
3761 signal (SIGTERM, fatal_error);
3763 if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
3764 signal (SIGPIPE, fatal_error);
3768 argbuf = (char **) xmalloc (argbuf_length * sizeof (char *));
3770 obstack_init (&obstack);
3772 /* Set up to remember the pathname of gcc and any options
3773 needed for collect. We use argv[0] instead of programname because
3774 we need the complete pathname. */
3775 obstack_init (&collect_obstack);
3776 obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=")-1);
3777 obstack_grow (&collect_obstack, argv[0], strlen (argv[0])+1);
3778 putenv (obstack_finish (&collect_obstack));
3780 /* Choose directory for temp files. */
3782 choose_temp_base ();
3784 /* Make a table of what switches there are (switches, n_switches).
3785 Make a table of specified input files (infiles, n_infiles).
3786 Decode switches that are handled locally. */
3788 process_command (argc, argv);
3790 /* Initialize the vector of specs to just the default.
3791 This means one element containing 0s, as a terminator. */
3793 compilers = (struct compiler *) xmalloc (sizeof default_compilers);
3794 bcopy (default_compilers, compilers, sizeof default_compilers);
3795 n_compilers = n_default_compilers;
3797 /* Read specs from a file if there is one. */
3799 machine_suffix = concat (spec_machine, "/", concat (spec_version, "/", ""));
3800 just_machine_suffix = concat (spec_machine, "/", "");
3802 specs_file = find_a_file (&startfile_prefix, "specs", R_OK);
3803 /* Read the specs file unless it is a default one. */
3804 if (specs_file != 0 && strcmp (specs_file, "specs"))
3805 read_specs (specs_file);
3807 /* If not cross-compiling, look for startfiles in the standard places. */
3808 /* The fact that these are done here, after reading the specs file,
3809 means that it cannot be found in these directories.
3810 But that's okay. It should never be there anyway. */
3813 #ifdef MD_EXEC_PREFIX
3814 add_prefix (&exec_prefix, md_exec_prefix, 0, 0, NULL_PTR);
3815 add_prefix (&startfile_prefix, md_exec_prefix, 0, 0, NULL_PTR);
3818 #ifdef MD_STARTFILE_PREFIX
3819 add_prefix (&startfile_prefix, md_startfile_prefix, 0, 0, NULL_PTR);
3822 #ifdef MD_STARTFILE_PREFIX_1
3823 add_prefix (&startfile_prefix, md_startfile_prefix_1, 0, 0, NULL_PTR);
3826 /* If standard_startfile_prefix is relative, base it on
3827 standard_exec_prefix. This lets us move the installed tree
3828 as a unit. If GCC_EXEC_PREFIX is defined, base
3829 standard_startfile_prefix on that as well. */
3830 if (*standard_startfile_prefix == '/')
3831 add_prefix (&startfile_prefix, standard_startfile_prefix, 0, 0,
3835 if (gcc_exec_prefix)
3836 add_prefix (&startfile_prefix,
3837 concat (gcc_exec_prefix,
3838 standard_startfile_prefix,
3841 add_prefix (&startfile_prefix,
3842 concat (standard_exec_prefix,
3844 standard_startfile_prefix),
3848 add_prefix (&startfile_prefix, standard_startfile_prefix_1, 0, 0,
3850 add_prefix (&startfile_prefix, standard_startfile_prefix_2, 0, 0,
3852 #if 0 /* Can cause surprises, and one can use -B./ instead. */
3853 add_prefix (&startfile_prefix, "./", 0, 1, NULL_PTR);
3857 /* Now we have the specs.
3858 Set the `valid' bits for switches that match anything in any spec. */
3860 validate_all_switches ();
3862 /* Warn about any switches that no pass was interested in. */
3864 for (i = 0; i < n_switches; i++)
3865 if (! switches[i].valid)
3866 error ("unrecognized option `-%s'", switches[i].part1);
3868 if (print_libgcc_file_name)
3870 printf ("%s\n", find_file ("libgcc.a"));
3874 /* Obey some of the options. */
3878 fprintf (stderr, "gcc version %s\n", version_string);
3884 fatal ("No input files");
3886 /* Make a place to record the compiler output file names
3887 that correspond to the input files. */
3889 outfiles = (char **) xmalloc (n_infiles * sizeof (char *));
3890 bzero (outfiles, n_infiles * sizeof (char *));
3892 /* Record which files were specified explicitly as link input. */
3894 explicit_link_files = xmalloc (n_infiles);
3895 bzero (explicit_link_files, n_infiles);
3897 for (i = 0; i < n_infiles; i++)
3899 register struct compiler *cp = 0;
3900 int this_file_error = 0;
3902 /* Tell do_spec what to substitute for %i. */
3904 input_filename = infiles[i].name;
3905 input_filename_length = strlen (input_filename);
3906 input_file_number = i;
3908 /* Use the same thing in %o, unless cp->spec says otherwise. */
3910 outfiles[i] = input_filename;
3912 /* Figure out which compiler from the file's suffix. */
3914 cp = lookup_compiler (infiles[i].name, input_filename_length,
3915 infiles[i].language);
3919 /* Ok, we found an applicable compiler. Run its spec. */
3920 /* First say how much of input_filename to substitute for %b */
3924 input_basename = input_filename;
3925 for (p = input_filename; *p; p++)
3927 input_basename = p + 1;
3929 /* Find a suffix starting with the last period,
3930 and set basename_length to exclude that suffix. */
3931 basename_length = strlen (input_basename);
3932 p = input_basename + basename_length;
3933 while (p != input_basename && *p != '.') --p;
3934 if (*p == '.' && p != input_basename)
3936 basename_length = p - input_basename;
3937 input_suffix = p + 1;
3943 for (j = 0; j < sizeof cp->spec / sizeof cp->spec[0]; j++)
3945 len += strlen (cp->spec[j]);
3947 p = (char *) xmalloc (len + 1);
3950 for (j = 0; j < sizeof cp->spec / sizeof cp->spec[0]; j++)
3953 strcpy (p + len, cp->spec[j]);
3954 len += strlen (cp->spec[j]);
3957 value = do_spec (p);
3960 this_file_error = 1;
3963 /* If this file's name does not contain a recognized suffix,
3964 record it as explicit linker input. */
3967 explicit_link_files[i] = 1;
3969 /* Clear the delete-on-failure queue, deleting the files in it
3970 if this compilation failed. */
3972 if (this_file_error)
3974 delete_failure_queue ();
3977 /* If this compilation succeeded, don't delete those files later. */
3978 clear_failure_queue ();
3981 /* Run ld to link all the compiler output files. */
3983 if (error_count == 0)
3985 int tmp = execution_count;
3989 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
3991 putenv_from_prefixes (&exec_prefix, "COMPILER_PATH=");
3992 putenv_from_prefixes (&startfile_prefix, "LIBRARY_PATH=");
3994 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
3996 obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
3997 sizeof ("COLLECT_GCC_OPTIONS=")-1);
4000 for (i = 0; i < n_switches; i++)
4004 obstack_grow (&collect_obstack, " ", 1);
4007 obstack_grow (&collect_obstack, "-", 1);
4008 obstack_grow (&collect_obstack, switches[i].part1,
4009 strlen (switches[i].part1));
4011 for (args = switches[i].args; args && *args; args++)
4013 obstack_grow (&collect_obstack, " ", 1);
4014 obstack_grow (&collect_obstack, *args, strlen (*args));
4017 obstack_grow (&collect_obstack, "\0", 1);
4018 putenv (obstack_finish (&collect_obstack));
4020 value = do_spec (link_command_spec);
4023 linker_was_run = (tmp != execution_count);
4026 /* Warn if a -B option was specified but the prefix was never used. */
4027 unused_prefix_warnings (&exec_prefix);
4028 unused_prefix_warnings (&startfile_prefix);
4030 /* If options said don't run linker,
4031 complain about input files to be given to the linker. */
4033 if (! linker_was_run && error_count == 0)
4034 for (i = 0; i < n_infiles; i++)
4035 if (explicit_link_files[i])
4036 error ("%s: linker input file unused since linking not done",
4039 /* Delete some or all of the temporary files we made. */
4042 delete_failure_queue ();
4043 delete_temp_files ();
4045 exit (error_count > 0 ? (signal_count ? 2 : 1) : 0);
4050 /* Find the proper compilation spec for the file name NAME,
4051 whose length is LENGTH. LANGUAGE is the specified language,
4052 or 0 if none specified. */
4054 static struct compiler *
4055 lookup_compiler (name, length, language)
4060 struct compiler *cp;
4062 /* Look for the language, if one is spec'd. */
4065 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
4069 if (cp->suffix[0] == '@'
4070 && !strcmp (cp->suffix + 1, language))
4074 error ("language %s not recognized", language);
4077 /* Look for a suffix. */
4078 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
4080 if (/* The suffix `-' matches only the file name `-'. */
4081 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
4083 (strlen (cp->suffix) < length
4084 /* See if the suffix matches the end of NAME. */
4085 && !strcmp (cp->suffix,
4086 name + length - strlen (cp->suffix))))
4088 if (cp->spec[0][0] == '@')
4090 struct compiler *new;
4091 /* An alias entry maps a suffix to a language.
4092 Search for the language; pass 0 for NAME and LENGTH
4093 to avoid infinite recursion if language not found.
4094 Construct the new compiler spec. */
4095 language = cp->spec[0] + 1;
4096 new = (struct compiler *) xmalloc (sizeof (struct compiler));
4097 new->suffix = cp->suffix;
4098 bcopy (lookup_compiler (NULL_PTR, 0, language)->spec,
4099 new->spec, sizeof new->spec);
4102 /* A non-alias entry: return it. */
4114 register char *value = (char *) malloc (size);
4116 fatal ("virtual memory exhausted");
4121 xrealloc (ptr, size)
4125 register char *value = (char *) realloc (ptr, size);
4127 fatal ("virtual memory exhausted");
4131 /* Return a newly-allocated string whose contents concatenate those of s1, s2, s3. */
4137 int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
4138 char *result = xmalloc (len1 + len2 + len3 + 1);
4140 strcpy (result, s1);
4141 strcpy (result + len1, s2);
4142 strcpy (result + len1 + len2, s3);
4143 *(result + len1 + len2 + len3) = 0;
4149 save_string (s, len)
4153 register char *result = xmalloc (len + 1);
4155 bcopy (s, result, len);
4161 pfatal_with_name (name)
4166 if (errno < sys_nerr)
4167 s = concat ("%s: ", sys_errlist[errno], "");
4169 s = "cannot open %s";
4174 perror_with_name (name)
4179 if (errno < sys_nerr)
4180 s = concat ("%s: ", sys_errlist[errno], "");
4182 s = "cannot open %s";
4192 if (errno < sys_nerr)
4193 s = concat ("installation problem, cannot exec %s: ",
4194 sys_errlist[errno], "");
4196 s = "installation problem, cannot exec %s";
4200 /* More 'friendly' abort that prints the line and file.
4201 config.h can #define abort fancy_abort if you like that sort of thing. */
4206 fatal ("Internal gcc abort.");
4211 /* Output an error message and exit */
4214 fatal VPROTO((char *format, ...))
4221 VA_START (ap, format);
4224 format = va_arg (ap, char*);
4227 fprintf (stderr, "%s: ", programname);
4228 vfprintf (stderr, format, ap);
4230 fprintf (stderr, "\n");
4231 delete_temp_files ();
4236 error VPROTO((char *format, ...))
4243 VA_START (ap, format);
4246 format = va_arg (ap, char*);
4249 fprintf (stderr, "%s: ", programname);
4250 vfprintf (stderr, format, ap);
4253 fprintf (stderr, "\n");
4256 #else /* not HAVE_VPRINTF */
4259 fatal (msg, arg1, arg2)
4260 char *msg, *arg1, *arg2;
4262 error (msg, arg1, arg2);
4263 delete_temp_files ();
4268 error (msg, arg1, arg2)
4269 char *msg, *arg1, *arg2;
4271 fprintf (stderr, "%s: ", programname);
4272 fprintf (stderr, msg, arg1, arg2);
4273 fprintf (stderr, "\n");
4276 #endif /* not HAVE_VPRINTF */
4280 validate_all_switches ()
4282 struct compiler *comp;
4285 struct spec_list *spec;
4287 for (comp = compilers; comp->spec[0]; comp++)
4290 for (i = 0; i < sizeof comp->spec / sizeof comp->spec[0] && comp->spec[i]; i++)
4294 if (c == '%' && *p == '{')
4295 /* We have a switch spec. */
4296 validate_switches (p + 1);
4300 /* look through the linked list of extra specs read from the specs file */
4301 for (spec = specs; spec ; spec = spec->next)
4305 if (c == '%' && *p == '{')
4306 /* We have a switch spec. */
4307 validate_switches (p + 1);
4310 p = link_command_spec;
4312 if (c == '%' && *p == '{')
4313 /* We have a switch spec. */
4314 validate_switches (p + 1);
4316 /* Now notice switches mentioned in the machine-specific specs. */
4320 if (c == '%' && *p == '{')
4321 /* We have a switch spec. */
4322 validate_switches (p + 1);
4326 if (c == '%' && *p == '{')
4327 /* We have a switch spec. */
4328 validate_switches (p + 1);
4332 if (c == '%' && *p == '{')
4333 /* We have a switch spec. */
4334 validate_switches (p + 1);
4336 p = signed_char_spec;
4338 if (c == '%' && *p == '{')
4339 /* We have a switch spec. */
4340 validate_switches (p + 1);
4344 if (c == '%' && *p == '{')
4345 /* We have a switch spec. */
4346 validate_switches (p + 1);
4350 if (c == '%' && *p == '{')
4351 /* We have a switch spec. */
4352 validate_switches (p + 1);
4356 if (c == '%' && *p == '{')
4357 /* We have a switch spec. */
4358 validate_switches (p + 1);
4362 if (c == '%' && *p == '{')
4363 /* We have a switch spec. */
4364 validate_switches (p + 1);
4368 if (c == '%' && *p == '{')
4369 /* We have a switch spec. */
4370 validate_switches (p + 1);
4373 /* Look at the switch-name that comes after START
4374 and mark as valid all supplied switches that match it. */
4377 validate_switches (start)
4380 register char *p = start;
4395 while (*p != ':' && *p != '}') p++;
4399 else if (p[-1] == '*')
4401 /* Mark all matching switches as valid. */
4403 for (i = 0; i < n_switches; i++)
4404 if (!strncmp (switches[i].part1, filter, p - filter))
4405 switches[i].valid = 1;
4409 /* Mark an exact matching switch as valid. */
4410 for (i = 0; i < n_switches; i++)
4412 if (!strncmp (switches[i].part1, filter, p - filter)
4413 && switches[i].part1[p - filter] == 0)
4414 switches[i].valid = 1;