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 PVPROTO(ARGS) ARGS
66 #define VPROTO(ARGS) ARGS
67 #define VA_START(va_list,var) va_start(va_list,var)
69 #define PVPROTO(ARGS) ()
70 #define VPROTO(ARGS) (va_alist) va_dcl
71 #define VA_START(va_list,var) va_start(va_list)
75 /* Define a generic NULL if one hasn't already been defined. */
82 #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
83 #define GENERIC_PTR void *
85 #define GENERIC_PTR char *
90 #define NULL_PTR ((GENERIC_PTR)0)
97 /* On MSDOS, write temp files in current dir
98 because there's no place else we can expect to use. */
105 /* Test if something is a normal file. */
107 #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
110 /* Test if something is a directory. */
112 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
115 /* By default there is no special suffix for executables. */
116 #ifndef EXECUTABLE_SUFFIX
117 #define EXECUTABLE_SUFFIX ""
120 /* By default, colon separates directories in a path. */
121 #ifndef PATH_SEPARATOR
122 #define PATH_SEPARATOR ':'
125 #define obstack_chunk_alloc xmalloc
126 #define obstack_chunk_free free
129 extern char *getenv ();
131 extern int errno
, sys_nerr
;
133 extern const char *const sys_errlist
[];
135 extern char *sys_errlist
[];
138 extern int execv (), execvp ();
140 /* If a stage of compilation returns an exit status >= 1,
141 compilation of that file ceases. */
143 #define MIN_FATAL_STATUS 1
145 /* Flag saying to print the full filename of this file
146 as found through our usual search mechanism. */
148 static char *print_file_name
= NULL
;
150 /* As print_file_name, but search for executable file. */
152 static char *print_prog_name
= NULL
;
154 /* Flag indicating whether we should print the command and arguments */
156 static int verbose_flag
;
158 /* Nonzero means write "temp" files in source directory
159 and use the source file's name in them, and don't delete them. */
161 static int save_temps_flag
;
163 /* The compiler version. */
165 static char *compiler_version
;
167 /* The target version specified with -V */
169 static char *spec_version
= DEFAULT_TARGET_VERSION
;
171 /* The target machine specified with -b. */
173 static char *spec_machine
= DEFAULT_TARGET_MACHINE
;
175 /* Nonzero if cross-compiling.
176 When -b is used, the value comes from the `specs' file. */
179 static int cross_compile
= 1;
181 static int cross_compile
= 0;
184 /* The number of errors that have occurred; the link phase will not be
185 run if this is non-zero. */
186 static int error_count
= 0;
188 /* This is the obstack which we use to allocate many strings. */
190 static struct obstack obstack
;
192 /* This is the obstack to build an environment variable to pass to
193 collect2 that describes all of the relevant switches of what to
194 pass the compiler in building the list of pointers to constructors
197 static struct obstack collect_obstack
;
199 extern char *version_string
;
201 /* Forward declaration for prototypes. */
204 static void set_spec
PROTO((char *, char *));
205 static struct compiler
*lookup_compiler
PROTO((char *, int, char *));
206 static char *find_a_file
PROTO((struct path_prefix
*, char *, int));
207 static void add_prefix
PROTO((struct path_prefix
*, char *, int, int, int *));
208 static char *skip_whitespace
PROTO((char *));
209 static void record_temp_file
PROTO((char *, int, int));
210 static int check_live_switch
PROTO((int, int));
211 static char *handle_braces
PROTO((char *));
212 static char *save_string
PROTO((char *, int));
213 static char *concat
PROTO((char *, char *, char *));
214 static int do_spec
PROTO((char *));
215 static int do_spec_1
PROTO((char *, int, char *));
216 static char *find_file
PROTO((char *));
217 static int is_directory
PROTO((char *, char *, int));
218 static void validate_switches
PROTO((char *));
219 static void validate_all_switches
PROTO((void));
220 static void give_switch
PROTO((int, int));
221 static void pfatal_with_name
PROTO((char *));
222 static void perror_with_name
PROTO((char *));
223 static void perror_exec
PROTO((char *));
225 static void fatal
PVPROTO((char *, ...));
226 static void error
PVPROTO((char *, ...));
228 /* We must not provide any prototype here, even if ANSI C. */
229 static void fatal
PROTO(());
230 static void error
PROTO(());
237 /* Specs are strings containing lines, each of which (if not blank)
238 is made up of a program name, and arguments separated by spaces.
239 The program name must be exact and start from root, since no path
240 is searched and it is unreliable to depend on the current working directory.
241 Redirection of input or output is not supported; the subprograms must
242 accept filenames saying what files to read and write.
244 In addition, the specs can contain %-sequences to substitute variable text
245 or for conditional text. Here is a table of all defined %-sequences.
246 Note that spaces are not generated automatically around the results of
247 expanding these sequences; therefore, you can concatenate them together
248 or with constant text in a single argument.
250 %% substitute one % into the program name or argument.
251 %i substitute the name of the input file being processed.
252 %b substitute the basename of the input file being processed.
253 This is the substring up to (and not including) the last period
254 and not including the directory.
255 %g substitute the temporary-file-name-base. This is a string chosen
256 once per compilation. Different temporary file names are made by
257 concatenation of constant strings on the end, as in `%g.s'.
258 %g also has the same effect of %d.
259 %u like %g, but make the temporary file name unique.
260 %U returns the last file name generated with %u.
261 %d marks the argument containing or following the %d as a
262 temporary file name, so that that file will be deleted if CC exits
263 successfully. Unlike %g, this contributes no text to the argument.
264 %w marks the argument containing or following the %w as the
265 "output file" of this compilation. This puts the argument
266 into the sequence of arguments that %o will substitute later.
268 like %{...} but mark last argument supplied within
269 as a file to be deleted on failure.
270 %o substitutes the names of all the output files, with spaces
271 automatically placed around them. You should write spaces
272 around the %o as well or the results are undefined.
273 %o is for use in the specs for running the linker.
274 Input files whose names have no recognized suffix are not compiled
275 at all, but they are included among the output files, so they will
277 %p substitutes the standard macro predefinitions for the
278 current target machine. Use this when running cpp.
279 %P like %p, but puts `__' before and after the name of each macro.
280 (Except macros that already have __.)
282 %I Substitute a -iprefix option made from GCC_EXEC_PREFIX.
283 %s current argument is the name of a library or startup file of some sort.
284 Search for that file in a standard list of directories
285 and substitute the full name found.
286 %eSTR Print STR as an error message. STR is terminated by a newline.
287 Use this when inconsistent options are detected.
288 %x{OPTION} Accumulate an option for %X.
289 %X Output the accumulated linker options specified by compilations.
290 %Y Output the accumulated assembler options specified by compilations.
291 %v1 Substitute the major version number of GCC.
292 (For version 2.5.n, this is 2.)
293 %v2 Substitute the minor version number of GCC.
294 (For version 2.5.n, this is 5.)
295 %a process ASM_SPEC as a spec.
296 This allows config.h to specify part of the spec for running as.
297 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
298 used here. This can be used to run a post-processor after the
299 assembler has done it's job.
300 %D Dump out a -L option for each directory in startfile_prefix.
301 %l process LINK_SPEC as a spec.
302 %L process LIB_SPEC as a spec.
303 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
304 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
305 %c process SIGNED_CHAR_SPEC as a spec.
306 %C process CPP_SPEC as a spec. A capital C is actually used here.
307 %1 process CC1_SPEC as a spec.
308 %2 process CC1PLUS_SPEC as a spec.
309 %| output "-" if the input for the current command is coming from a pipe.
310 %* substitute the variable part of a matched option. (See below.)
311 Note that each comma in the substituted string is replaced by
313 %{S} substitutes the -S switch, if that switch was given to CC.
314 If that switch was not specified, this substitutes nothing.
315 Here S is a metasyntactic variable.
316 %{S*} substitutes all the switches specified to CC whose names start
317 with -S. This is used for -o, -D, -I, etc; switches that take
318 arguments. CC considers `-o foo' as being one switch whose
319 name starts with `o'. %{o*} would substitute this text,
320 including the space; thus, two arguments would be generated.
321 %{S*:X} substitutes X if one or more switches whose names start with -S are
322 specified to CC. Note that the tail part of the -S option
323 (i.e. the part matched by the `*') will be substituted for each
324 occurrence of %* within X.
325 %{S:X} substitutes X, but only if the -S switch was given to CC.
326 %{!S:X} substitutes X, but only if the -S switch was NOT given to CC.
327 %{|S:X} like %{S:X}, but if no S switch, substitute `-'.
328 %{|!S:X} like %{!S:X}, but if there is an S switch, substitute `-'.
329 %{.S:X} substitutes X, but only if processing a file with suffix S.
330 %{!.S:X} substitutes X, but only if NOT processing a file with suffix S.
331 %(Spec) processes a specification defined in a specs file as *Spec:
332 %[Spec] as above, but put __ around -D arguments
334 The conditional text X in a %{S:X} or %{!S:X} construct may contain
335 other nested % constructs or spaces, or even newlines. They are
336 processed as usual, as described above.
338 The -O, -f, -m, and -W switches are handled specifically in these
339 constructs. If another value of -O or the negated form of a -f, -m, or
340 -W switch is found later in the command line, the earlier switch
341 value is ignored, except with {S*} where S is just one letter; this
342 passes all matching options.
344 The character | is used to indicate that a command should be piped to
345 the following command, but only if -pipe is specified.
347 Note that it is built into CC which switches take arguments and which
348 do not. You might think it would be useful to generalize this to
349 allow each compiler's spec to say which switches take arguments. But
350 this cannot be done in a consistent fashion. CC cannot even decide
351 which input files have been specified without knowing which switches
352 take arguments, and it must know which input files to compile in order
353 to tell which compilers to run.
355 CC also knows implicitly that arguments starting in `-l' are to be
356 treated as compiler output files, and passed to the linker in their
357 proper position among the other output files. */
359 /* Define the macros used for specs %a, %l, %L, %S, %c, %C, %1. */
361 /* config.h can define ASM_SPEC to provide extra args to the assembler
362 or extra switch-translations. */
367 /* config.h can define ASM_FINAL_SPEC to run a post processor after
368 the assembler has run. */
369 #ifndef ASM_FINAL_SPEC
370 #define ASM_FINAL_SPEC ""
373 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
374 or extra switch-translations. */
379 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
380 or extra switch-translations. */
385 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
386 or extra switch-translations. */
388 #define CC1PLUS_SPEC ""
391 /* config.h can define LINK_SPEC to provide extra args to the linker
392 or extra switch-translations. */
397 /* config.h can define LIB_SPEC to override the default libraries. */
399 #define LIB_SPEC "%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}"
402 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
403 #ifndef STARTFILE_SPEC
404 #define STARTFILE_SPEC \
405 "%{pg:gcrt0.o%s}%{!pg:%{p:mcrt0.o%s}%{!p:crt0.o%s}}"
408 /* config.h can define SWITCHES_NEED_SPACES to control passing -o and -L.
409 Make the string nonempty to require spaces there. */
410 #ifndef SWITCHES_NEED_SPACES
411 #define SWITCHES_NEED_SPACES ""
414 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
416 #define ENDFILE_SPEC ""
419 /* This spec is used for telling cpp whether char is signed or not. */
420 #ifndef SIGNED_CHAR_SPEC
421 /* Use #if rather than ?:
422 because MIPS C compiler rejects like ?: in initializers. */
423 #if DEFAULT_SIGNED_CHAR
424 #define SIGNED_CHAR_SPEC "%{funsigned-char:-D__CHAR_UNSIGNED__}"
426 #define SIGNED_CHAR_SPEC "%{!fsigned-char:-D__CHAR_UNSIGNED__}"
430 static char *cpp_spec
= CPP_SPEC
;
431 static char *cpp_predefines
= CPP_PREDEFINES
;
432 static char *cc1_spec
= CC1_SPEC
;
433 static char *cc1plus_spec
= CC1PLUS_SPEC
;
434 static char *signed_char_spec
= SIGNED_CHAR_SPEC
;
435 static char *asm_spec
= ASM_SPEC
;
436 static char *asm_final_spec
= ASM_FINAL_SPEC
;
437 static char *link_spec
= LINK_SPEC
;
438 static char *lib_spec
= LIB_SPEC
;
439 static char *endfile_spec
= ENDFILE_SPEC
;
440 static char *startfile_spec
= STARTFILE_SPEC
;
441 static char *switches_need_spaces
= SWITCHES_NEED_SPACES
;
443 /* This defines which switch letters take arguments. */
445 #ifndef SWITCH_TAKES_ARG
446 #define SWITCH_TAKES_ARG(CHAR) \
447 ((CHAR) == 'D' || (CHAR) == 'U' || (CHAR) == 'o' \
448 || (CHAR) == 'e' || (CHAR) == 'T' || (CHAR) == 'u' \
449 || (CHAR) == 'I' || (CHAR) == 'm' \
450 || (CHAR) == 'L' || (CHAR) == 'A')
453 /* This defines which multi-letter switches take arguments. */
455 #define DEFAULT_WORD_SWITCH_TAKES_ARG(STR) \
456 (!strcmp (STR, "Tdata") || !strcmp (STR, "Ttext") \
457 || !strcmp (STR, "Tbss") || !strcmp (STR, "include") \
458 || !strcmp (STR, "imacros") || !strcmp (STR, "aux-info") \
459 || !strcmp (STR, "idirafter") || !strcmp (STR, "iprefix") \
460 || !strcmp (STR, "iwithprefix") || !strcmp (STR, "iwithprefixbefore"))
462 #ifndef WORD_SWITCH_TAKES_ARG
463 #define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR)
466 /* Record the mapping from file suffixes for compilation specs. */
470 char *suffix
; /* Use this compiler for input files
471 whose names end in this suffix. */
473 char *spec
[4]; /* To use this compiler, concatenate these
474 specs and pass to do_spec. */
477 /* Pointer to a vector of `struct compiler' that gives the spec for
478 compiling a file, based on its suffix.
479 A file that does not end in any of these suffixes will be passed
480 unchanged to the loader and nothing else will be done to it.
482 An entry containing two 0s is used to terminate the vector.
484 If multiple entries match a file, the last matching one is used. */
486 static struct compiler
*compilers
;
488 /* Number of entries in `compilers', not counting the null terminator. */
490 static int n_compilers
;
492 /* The default list of file name suffixes and their compilation specs. */
494 static struct compiler default_compilers
[] =
498 "cpp -lang-c %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
499 %{C:%{!E:%eGNU C does not support -C without using -E}}\
500 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d}\
501 -undef -D__GNUC__=%v1 -D__GNUC_MINOR__=%v2\
502 %{ansi:-trigraphs -$ -D__STRICT_ANSI__}\
503 %{!undef:%{!ansi:%p} %P} %{trigraphs} \
504 %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\
505 %{traditional-cpp:-traditional}\
506 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
507 %i %{!M:%{!MM:%{!E:%{!pipe:%g.i}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
508 "%{!M:%{!MM:%{!E:cc1 %{!pipe:%g.i} %1 \
509 %{!Q:-quiet} -dumpbase %b.c %{d*} %{m*} %{a}\
510 %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi} \
511 %{traditional} %{v:-version} %{pg:-p} %{p} %{f*}\
513 %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
514 %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
515 %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
516 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
517 %{!pipe:%g.s} %A\n }}}}"},
519 "%{E:cpp -lang-c %{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__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*}\
529 %{!E:%e-E required when input is from standard input}"},
530 {".m", "@objective-c"},
532 "cpp -lang-objc %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
533 %{C:%{!E:%eGNU C does not support -C without using -E}}\
534 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d}\
535 -undef -D__OBJC__ -D__GNUC__=%v1 -D__GNUC_MINOR__=%v2\
536 %{ansi:-trigraphs -$ -D__STRICT_ANSI__}\
537 %{!undef:%{!ansi:%p} %P} %{trigraphs}\
538 %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\
539 %{traditional-cpp:-traditional}\
540 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
541 %i %{!M:%{!MM:%{!E:%{!pipe:%g.i}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
542 "%{!M:%{!MM:%{!E:cc1obj %{!pipe:%g.i} %1 \
543 %{!Q:-quiet} -dumpbase %b.m %{d*} %{m*} %{a}\
544 %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi} \
545 %{traditional} %{v:-version} %{pg:-p} %{p} %{f*} \
546 -lang-objc %{gen-decls} \
548 %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
549 %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
550 %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
551 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
552 %{!pipe:%g.s} %A\n }}}}"},
555 "%{!E:%eCompilation of header file requested} \
556 cpp %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
557 %{C:%{!E:%eGNU C does not support -C without using -E}}\
558 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} \
559 -undef -D__GNUC__=%v1 -D__GNUC_MINOR__=%v2\
560 %{ansi:-trigraphs -$ -D__STRICT_ANSI__}\
561 %{!undef:%{!ansi:%p} %P} %{trigraphs}\
562 %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\
563 %{traditional-cpp:-traditional}\
564 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
571 "cpp -lang-c++ %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
572 %{C:%{!E:%eGNU C++ does not support -C without using -E}}\
573 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} \
574 -undef -D__GNUC__=%v1 -D__GNUG__=%v1 -D__cplusplus -D__GNUC_MINOR__=%v2\
575 %{ansi:-trigraphs -$ -D__STRICT_ANSI__} %{!undef:%{!ansi:%p} %P}\
576 %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\
577 %{traditional-cpp:-traditional} %{trigraphs}\
578 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
579 %i %{!M:%{!MM:%{!E:%{!pipe:%g.ii}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
580 "%{!M:%{!MM:%{!E:cc1plus %{!pipe:%g.ii} %1 %2\
581 %{!Q:-quiet} -dumpbase %b.cc %{d*} %{m*} %{a}\
582 %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi}\
583 %{traditional} %{v:-version} %{pg:-p} %{p}\
584 %{f*} %{+e*} %{aux-info*}\
585 %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
586 %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}}|\n\
587 %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
588 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
589 %{!pipe:%g.s} %A\n }}}}"},
590 {".i", "@cpp-output"},
592 "%{!M:%{!MM:%{!E:cc1 %i %1 %{!Q:-quiet} %{d*} %{m*} %{a}\
593 %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi}\
594 %{traditional} %{v:-version} %{pg:-p} %{p} %{f*}\
596 %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
597 %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
598 %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
599 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
600 %{!pipe:%g.s} %A\n }}}}"},
601 {".ii", "@c++-cpp-output"},
603 "%{!M:%{!MM:%{!E:cc1plus %i %1 %2 %{!Q:-quiet} %{d*} %{m*} %{a}\
604 %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi}\
605 %{traditional} %{v:-version} %{pg:-p} %{p}\
606 %{f*} %{+e*} %{aux-info*}\
607 %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
608 %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
609 %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
610 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
611 %{!pipe:%g.s} %A\n }}}}"},
612 {".s", "@assembler"},
614 "%{!M:%{!MM:%{!E:%{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
615 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
617 {".S", "@assembler-with-cpp"},
618 {"@assembler-with-cpp",
619 "cpp -lang-asm %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
620 %{C:%{!E:%eGNU C does not support -C without using -E}}\
621 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{trigraphs} \
622 -undef -$ %{!undef:%p %P} -D__ASSEMBLER__ \
623 %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\
624 %{traditional-cpp:-traditional}\
625 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
626 %i %{!M:%{!MM:%{!E:%{!pipe:%g.s}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
627 "%{!M:%{!MM:%{!E:%{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
628 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
629 %{!pipe:%g.s} %A\n }}}}"},
634 "%{!M:%{!MM:%{!E:gnat1 %{k8:-gnatk8} %{w:-gnatws} %{!Q:-quiet}\
635 -dumpbase %b.ada %{g*} %{O*} %{p} %{pg:-p} %{f*}\
637 %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
638 %i %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
639 %{!S:%{!gnatc:%{!gnats:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
640 %{c:%W{o*}%{!o*:-o %w%b.o}}\
641 %{!c:-o %d%w%u.o} %{!pipe:%g.s} %A\n}}}}}} "},
642 /* Mark end of table */
646 /* Number of elements in default_compilers, not counting the terminator. */
648 static int n_default_compilers
649 = (sizeof default_compilers
/ sizeof (struct compiler
)) - 1;
651 /* Here is the spec for running the linker, after compiling all files. */
653 /* -u* was put back because both BSD and SysV seem to support it. */
654 /* %{static:} simply prevents an error message if the target machine
655 doesn't handle -static. */
656 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
657 scripts which exist in user specified directories, or in standard
659 #ifdef LINK_LIBGCC_SPECIAL_1
660 /* Have gcc do the search for libgcc.a, but generate -L options as usual. */
661 static char *link_command_spec
= "\
663 %{!c:%{!M:%{!MM:%{!E:%{!S:ld %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} \
664 %{r} %{s} %{t} %{u*} %{x} %{z} %{Z}\
665 %{!A:%{!nostartfiles:%{!nostdlib:%S}}} %{static:}\
666 %{L*} %D %{T*} %o %{!nostdlib:libgcc.a%s %L libgcc.a%s %{!A:%E}}\n }}}}}}";
668 #ifdef LINK_LIBGCC_SPECIAL
669 /* Have gcc do the search for libgcc.a, and don't generate -L options. */
670 static char *link_command_spec
= "\
672 %{!c:%{!M:%{!MM:%{!E:%{!S:ld %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} \
673 %{r} %{s} %{t} %{u*} %{x} %{z} %{Z}\
674 %{!A:%{!nostartfiles:%{!nostdlib:%S}}} %{static:}\
675 %{L*} %{T*} %o %{!nostdlib:libgcc.a%s %L libgcc.a%s %{!A:%E}}\n }}}}}}";
677 /* Use -L and have the linker do the search for -lgcc. */
678 static char *link_command_spec
= "\
680 %{!c:%{!M:%{!MM:%{!E:%{!S:ld %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} \
681 %{r} %{s} %{t} %{u*} %{x} %{z} %{Z}\
682 %{!A:%{!nostartfiles:%{!nostdlib:%S}}} %{static:}\
683 %{L*} %D %{T*} %o %{!nostdlib:-lgcc %L -lgcc %{!A:%E}}\n }}}}}}";
687 /* A vector of options to give to the linker.
688 These options are accumulated by -Xlinker and -Wl,
689 and substituted into the linker command with %X. */
690 static int n_linker_options
;
691 static char **linker_options
;
693 /* A vector of options to give to the assembler.
694 These options are accumulated by -Wa,
695 and substituted into the assembler command with %X. */
696 static int n_assembler_options
;
697 static char **assembler_options
;
699 /* Define how to map long options into short ones. */
701 /* This structure describes one mapping. */
704 /* The long option's name. */
706 /* The equivalent short option. */
708 /* Argument info. A string of flag chars; NULL equals no options.
709 a => argument required.
710 o => argument optional.
711 j => join argument to equivalent, making one word.
712 * => allow other text after NAME as an argument. */
716 /* This is the table of mappings. Mappings are tried sequentially
717 for each option encountered; the first one that matches, wins. */
719 struct option_map option_map
[] =
721 {"--profile-blocks", "-a", 0},
722 {"--target", "-b", "a"},
723 {"--compile", "-c", 0},
724 {"--dump", "-d", "a"},
725 {"--entry", "-e", 0},
726 {"--debug", "-g", "oj"},
727 {"--include", "-include", "a"},
728 {"--imacros", "-imacros", "a"},
729 {"--include-prefix", "-iprefix", "a"},
730 {"--include-directory-after", "-idirafter", "a"},
731 {"--include-with-prefix", "-iwithprefix", "a"},
732 {"--include-with-prefix-before", "-iwithprefixbefore", "a"},
733 {"--include-with-prefix-after", "-iwithprefix", "a"},
734 {"--machine-", "-m", "*j"},
735 {"--machine", "-m", "aj"},
736 {"--no-standard-includes", "-nostdinc", 0},
737 {"--no-standard-libraries", "-nostdlib", 0},
738 {"--no-precompiled-includes", "-noprecomp", 0},
739 {"--output", "-o", "a"},
740 {"--profile", "-p", 0},
741 {"--quiet", "-q", 0},
742 {"--silent", "-q", 0},
743 {"--force-link", "-u", "a"},
744 {"--verbose", "-v", 0},
745 {"--version", "-dumpversion", 0},
746 {"--no-warnings", "-w", 0},
747 {"--language", "-x", "a"},
749 {"--assert", "-A", "a"},
750 {"--prefix", "-B", "a"},
751 {"--comments", "-C", 0},
752 {"--define-macro", "-D", "a"},
753 {"--preprocess", "-E", 0},
754 {"--trace-includes", "-H", 0},
755 {"--include-directory", "-I", "a"},
756 {"--include-barrier", "-I-", 0},
757 {"--library-directory", "-L", "a"},
758 {"--dependencies", "-M", 0},
759 {"--user-dependencies", "-MM", 0},
760 {"--write-dependencies", "-MD", 0},
761 {"--write-user-dependencies", "-MMD", 0},
762 {"--optimize", "-O", "oj"},
763 {"--no-line-commands", "-P", 0},
764 {"--assemble", "-S", 0},
765 {"--undefine-macro", "-U", "a"},
766 {"--use-version", "-V", "a"},
767 {"--for-assembler", "-Wa", "a"},
768 {"--extra-warnings", "-W", 0},
769 {"--all-warnings", "-Wall", 0},
770 {"--warn-", "-W", "*j"},
771 {"--for-linker", "-Xlinker", "a"},
773 {"--ansi", "-ansi", 0},
774 {"--traditional", "-traditional", 0},
775 {"--traditional-cpp", "-traditional-cpp", 0},
776 {"--trigraphs", "-trigraphs", 0},
777 {"--pipe", "-pipe", 0},
778 {"--dumpbase", "-dumpbase", "a"},
779 {"--pedantic", "-pedantic", 0},
780 {"--pedantic-errors", "-pedantic-errors", 0},
781 {"--save-temps", "-save-temps", 0},
782 {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
783 {"--print-file-name", "-print-file-name=", "aj"},
784 {"--print-prog-name", "-print-prog-name=", "aj"},
785 {"--static", "-static", 0},
786 {"--shared", "-shared", 0},
787 {"--symbolic", "-symbolic", 0},
791 /* Translate the options described by *ARGCP and *ARGVP.
792 Make a new vector and store it back in *ARGVP,
793 and store its length in *ARGVC. */
796 translate_options (argcp
, argvp
)
802 char **argv
= *argvp
;
803 char **newv
= (char **) xmalloc ((argc
+ 2) * 2 * sizeof (char *));
807 newv
[newindex
++] = argv
[i
++];
811 /* Translate -- options. */
812 if (argv
[i
][0] == '-' && argv
[i
][1] == '-')
814 /* Find a mapping that applies to this option. */
815 for (j
= 0; j
< sizeof (option_map
) / sizeof (option_map
[0]); j
++)
817 int optlen
= strlen (option_map
[j
].name
);
818 int complen
= strlen (argv
[i
]);
819 char *arginfo
= option_map
[j
].arg_info
;
823 if (complen
> optlen
)
825 if (!strncmp (argv
[i
], option_map
[j
].name
, complen
))
827 int extra
= strlen (argv
[i
]) > optlen
;
832 /* If the option has an argument, accept that. */
833 if (argv
[i
][optlen
] == '=')
834 arg
= argv
[i
] + optlen
+ 1;
835 /* If this mapping allows extra text at end of name,
836 accept that as "argument". */
837 else if (index (arginfo
, '*') != 0)
838 arg
= argv
[i
] + optlen
;
839 /* Otherwise, extra text at end means mismatch.
840 Try other mappings. */
844 else if (index (arginfo
, '*') != 0)
845 error ("Incomplete `%s' option", option_map
[j
].name
);
847 /* Handle arguments. */
848 if (index (arginfo
, 'o') != 0)
853 error ("Missing argument to `%s' option",
858 else if (index (arginfo
, '*') != 0)
860 else if (index (arginfo
, 'a') == 0)
863 error ("Extraneous argument to `%s' option",
868 /* Store the translation as one argv elt or as two. */
869 if (arg
!= 0 && index (arginfo
, 'j') != 0)
870 newv
[newindex
++] = concat (option_map
[j
].equivalent
,
874 newv
[newindex
++] = option_map
[j
].equivalent
;
875 newv
[newindex
++] = arg
;
878 newv
[newindex
++] = option_map
[j
].equivalent
;
885 /* Handle old-fashioned options--just copy them through,
886 with their arguments. */
887 else if (argv
[i
][0] == '-')
889 char *p
= argv
[i
] + 1;
893 if (SWITCH_TAKES_ARG (c
) > (p
[1] != 0))
894 nskip
+= SWITCH_TAKES_ARG (c
) - (p
[1] != 0);
895 else if (WORD_SWITCH_TAKES_ARG (p
))
896 nskip
+= WORD_SWITCH_TAKES_ARG (p
);
897 else if ((c
== 'B' || c
== 'b' || c
== 'V' || c
== 'x')
900 else if (! strcmp (p
, "Xlinker"))
903 /* Watch out for an option at the end of the command line that
904 is missing arguments, and avoid skipping past the end of the
906 if (nskip
+ i
> argc
)
911 newv
[newindex
++] = argv
[i
++];
916 /* Ordinary operands, or +e options. */
917 newv
[newindex
++] = argv
[i
++];
926 /* Read compilation specs from a file named FILENAME,
927 replacing the default ones.
929 A suffix which starts with `*' is a definition for
930 one of the machine-specific sub-specs. The "suffix" should be
931 *asm, *cc1, *cpp, *link, *startfile, *signed_char, etc.
932 The corresponding spec is stored in asm_spec, etc.,
933 rather than in the `compilers' vector.
935 Anything invalid in the file is a fatal error. */
938 read_specs (filename
)
947 fprintf (stderr
, "Reading specs from %s\n", filename
);
949 /* Open and stat the file. */
950 desc
= open (filename
, 0, 0);
952 pfatal_with_name (filename
);
953 if (stat (filename
, &statbuf
) < 0)
954 pfatal_with_name (filename
);
956 /* Read contents of file into BUFFER. */
957 buffer
= xmalloc ((unsigned) statbuf
.st_size
+ 1);
958 read (desc
, buffer
, (unsigned) statbuf
.st_size
);
959 buffer
[statbuf
.st_size
] = 0;
962 /* Scan BUFFER for specs, putting them in the vector. */
968 char *in
, *out
, *p1
, *p2
;
970 /* Advance P in BUFFER to the next nonblank nocomment line. */
971 p
= skip_whitespace (p
);
975 /* Find the colon that should end the suffix. */
977 while (*p1
&& *p1
!= ':' && *p1
!= '\n') p1
++;
978 /* The colon shouldn't be missing. */
980 fatal ("specs file malformed after %d characters", p1
- buffer
);
981 /* Skip back over trailing whitespace. */
983 while (p2
> buffer
&& (p2
[-1] == ' ' || p2
[-1] == '\t')) p2
--;
984 /* Copy the suffix to a string. */
985 suffix
= save_string (p
, p2
- p
);
986 /* Find the next line. */
987 p
= skip_whitespace (p1
+ 1);
989 fatal ("specs file malformed after %d characters", p
- buffer
);
991 /* Find next blank line. */
992 while (*p1
&& !(*p1
== '\n' && p1
[1] == '\n')) p1
++;
993 /* Specs end at the blank line and do not include the newline. */
994 spec
= save_string (p
, p1
- p
);
997 /* Delete backslash-newline sequences from the spec. */
1002 if (in
[0] == '\\' && in
[1] == '\n')
1004 else if (in
[0] == '#')
1006 while (*in
&& *in
!= '\n') in
++;
1013 if (suffix
[0] == '*')
1015 if (! strcmp (suffix
, "*link_command"))
1016 link_command_spec
= spec
;
1018 set_spec (suffix
+ 1, spec
);
1022 /* Add this pair to the vector. */
1024 = ((struct compiler
*)
1025 xrealloc (compilers
, (n_compilers
+ 2) * sizeof (struct compiler
)));
1026 compilers
[n_compilers
].suffix
= suffix
;
1027 bzero (compilers
[n_compilers
].spec
,
1028 sizeof compilers
[n_compilers
].spec
);
1029 compilers
[n_compilers
].spec
[0] = spec
;
1031 bzero (&compilers
[n_compilers
], sizeof compilers
[n_compilers
]);
1035 link_command_spec
= spec
;
1038 if (link_command_spec
== 0)
1039 fatal ("spec file has no spec for linking");
1048 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1049 be considered whitespace. */
1050 if (p
[0] == '\n' && p
[1] == '\n' && p
[2] == '\n')
1052 else if (*p
== '\n' || *p
== ' ' || *p
== '\t')
1056 while (*p
!= '\n') p
++;
1066 /* Structure to keep track of the specs that have been defined so far. These
1067 are accessed using %(specname) or %[specname] in a compiler or link spec. */
1071 char *name
; /* Name of the spec. */
1072 char *spec
; /* The spec itself. */
1073 struct spec_list
*next
; /* Next spec in linked list. */
1076 /* List of specs that have been defined so far. */
1078 static struct spec_list
*specs
= (struct spec_list
*) 0;
1080 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1081 removed; If the spec starts with a + then SPEC is added to the end of the
1085 set_spec (name
, spec
)
1089 struct spec_list
*sl
;
1092 /* See if the spec already exists */
1093 for (sl
= specs
; sl
; sl
= sl
->next
)
1094 if (strcmp (sl
->name
, name
) == 0)
1099 /* Not found - make it */
1100 sl
= (struct spec_list
*) xmalloc (sizeof (struct spec_list
));
1101 sl
->name
= save_string (name
, strlen (name
));
1102 sl
->spec
= save_string ("", 0);
1107 old_spec
= sl
->spec
;
1108 if (name
&& spec
[0] == '+' && isspace (spec
[1]))
1109 sl
->spec
= concat (old_spec
, spec
+ 1, "");
1111 sl
->spec
= save_string (spec
, strlen (spec
));
1113 if (! strcmp (name
, "asm"))
1114 asm_spec
= sl
->spec
;
1115 else if (! strcmp (name
, "asm_final"))
1116 asm_final_spec
= sl
->spec
;
1117 else if (! strcmp (name
, "cc1"))
1118 cc1_spec
= sl
->spec
;
1119 else if (! strcmp (name
, "cc1plus"))
1120 cc1plus_spec
= sl
->spec
;
1121 else if (! strcmp (name
, "cpp"))
1122 cpp_spec
= sl
->spec
;
1123 else if (! strcmp (name
, "endfile"))
1124 endfile_spec
= sl
->spec
;
1125 else if (! strcmp (name
, "lib"))
1126 lib_spec
= sl
->spec
;
1127 else if (! strcmp (name
, "link"))
1128 link_spec
= sl
->spec
;
1129 else if (! strcmp (name
, "predefines"))
1130 cpp_predefines
= sl
->spec
;
1131 else if (! strcmp (name
, "signed_char"))
1132 signed_char_spec
= sl
->spec
;
1133 else if (! strcmp (name
, "startfile"))
1134 startfile_spec
= sl
->spec
;
1135 else if (! strcmp (name
, "switches_need_spaces"))
1136 switches_need_spaces
= sl
->spec
;
1137 else if (! strcmp (name
, "cross_compile"))
1138 cross_compile
= atoi (sl
->spec
);
1139 /* Free the old spec */
1144 /* Accumulate a command (program name and args), and run it. */
1146 /* Vector of pointers to arguments in the current line of specifications. */
1148 static char **argbuf
;
1150 /* Number of elements allocated in argbuf. */
1152 static int argbuf_length
;
1154 /* Number of elements in argbuf currently in use (containing args). */
1156 static int argbuf_index
;
1158 /* This is the list of suffixes and codes (%g/%u/%U) and the associated
1159 temp file. Used only if MKTEMP_EACH_FILE. */
1161 static struct temp_name
{
1162 char *suffix
; /* suffix associated with the code. */
1163 int length
; /* strlen (suffix). */
1164 int unique
; /* Indicates whether %g or %u/%U was used. */
1165 char *filename
; /* associated filename. */
1166 int filename_length
; /* strlen (filename). */
1167 struct temp_name
*next
;
1170 /* Number of commands executed so far. */
1172 static int execution_count
;
1174 /* Number of commands that exited with a signal. */
1176 static int signal_count
;
1178 /* Name with which this program was invoked. */
1180 static char *programname
;
1182 /* Structures to keep track of prefixes to try when looking for files. */
1186 char *prefix
; /* String to prepend to the path. */
1187 struct prefix_list
*next
; /* Next in linked list. */
1188 int require_machine_suffix
; /* Don't use without machine_suffix. */
1189 /* 2 means try both machine_suffix and just_machine_suffix. */
1190 int *used_flag_ptr
; /* 1 if a file was found with this prefix. */
1195 struct prefix_list
*plist
; /* List of prefixes to try */
1196 int max_len
; /* Max length of a prefix in PLIST */
1197 char *name
; /* Name of this list (used in config stuff) */
1200 /* List of prefixes to try when looking for executables. */
1202 static struct path_prefix exec_prefix
= { 0, 0, "exec" };
1204 /* List of prefixes to try when looking for startup (crt0) files. */
1206 static struct path_prefix startfile_prefix
= { 0, 0, "startfile" };
1208 /* List of prefixes to try when looking for include files. */
1210 static struct path_prefix include_prefix
= { 0, 0, "include" };
1212 /* Suffix to attach to directories searched for commands.
1213 This looks like `MACHINE/VERSION/'. */
1215 static char *machine_suffix
= 0;
1217 /* Suffix to attach to directories searched for commands.
1218 This is just `MACHINE/'. */
1220 static char *just_machine_suffix
= 0;
1222 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1224 static char *gcc_exec_prefix
;
1226 /* Default prefixes to attach to command names. */
1228 #ifdef CROSS_COMPILE /* Don't use these prefixes for a cross compiler. */
1229 #undef MD_EXEC_PREFIX
1230 #undef MD_STARTFILE_PREFIX
1231 #undef MD_STARTFILE_PREFIX_1
1234 #ifndef STANDARD_EXEC_PREFIX
1235 #define STANDARD_EXEC_PREFIX "/usr/local/lib/gcc-lib/"
1236 #endif /* !defined STANDARD_EXEC_PREFIX */
1238 static char *standard_exec_prefix
= STANDARD_EXEC_PREFIX
;
1239 static char *standard_exec_prefix_1
= "/usr/lib/gcc/";
1240 #ifdef MD_EXEC_PREFIX
1241 static char *md_exec_prefix
= MD_EXEC_PREFIX
;
1244 #ifndef STANDARD_STARTFILE_PREFIX
1245 #define STANDARD_STARTFILE_PREFIX "/usr/local/lib/"
1246 #endif /* !defined STANDARD_STARTFILE_PREFIX */
1248 #ifdef MD_STARTFILE_PREFIX
1249 static char *md_startfile_prefix
= MD_STARTFILE_PREFIX
;
1251 #ifdef MD_STARTFILE_PREFIX_1
1252 static char *md_startfile_prefix_1
= MD_STARTFILE_PREFIX_1
;
1254 static char *standard_startfile_prefix
= STANDARD_STARTFILE_PREFIX
;
1255 static char *standard_startfile_prefix_1
= "/lib/";
1256 static char *standard_startfile_prefix_2
= "/usr/lib/";
1258 #ifndef TOOLDIR_BASE_PREFIX
1259 #define TOOLDIR_BASE_PREFIX "/usr/local/"
1261 static char *tooldir_base_prefix
= TOOLDIR_BASE_PREFIX
;
1262 static char *tooldir_prefix
;
1264 /* Clear out the vector of arguments (after a command is executed). */
1272 /* Add one argument to the vector at the end.
1273 This is done when a space is seen or at the end of the line.
1274 If DELETE_ALWAYS is nonzero, the arg is a filename
1275 and the file should be deleted eventually.
1276 If DELETE_FAILURE is nonzero, the arg is a filename
1277 and the file should be deleted if this compilation fails. */
1280 store_arg (arg
, delete_always
, delete_failure
)
1282 int delete_always
, delete_failure
;
1284 if (argbuf_index
+ 1 == argbuf_length
)
1286 argbuf
= (char **) xrealloc (argbuf
, (argbuf_length
*= 2) * sizeof (char *));
1289 argbuf
[argbuf_index
++] = arg
;
1290 argbuf
[argbuf_index
] = 0;
1292 if (delete_always
|| delete_failure
)
1293 record_temp_file (arg
, delete_always
, delete_failure
);
1296 /* Record the names of temporary files we tell compilers to write,
1297 and delete them at the end of the run. */
1299 /* This is the common prefix we use to make temp file names.
1300 It is chosen once for each run of this program.
1301 It is substituted into a spec by %g.
1302 Thus, all temp file names contain this prefix.
1303 In practice, all temp file names start with this prefix.
1305 This prefix comes from the envvar TMPDIR if it is defined;
1306 otherwise, from the P_tmpdir macro if that is defined;
1307 otherwise, in /usr/tmp or /tmp. */
1309 static char *temp_filename
;
1311 /* Length of the prefix. */
1313 static int temp_filename_length
;
1315 /* Define the list of temporary files to delete. */
1320 struct temp_file
*next
;
1323 /* Queue of files to delete on success or failure of compilation. */
1324 static struct temp_file
*always_delete_queue
;
1325 /* Queue of files to delete on failure of compilation. */
1326 static struct temp_file
*failure_delete_queue
;
1328 /* Record FILENAME as a file to be deleted automatically.
1329 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
1330 otherwise delete it in any case.
1331 FAIL_DELETE nonzero means delete it if a compilation step fails;
1332 otherwise delete it in any case. */
1335 record_temp_file (filename
, always_delete
, fail_delete
)
1340 register char *name
;
1341 name
= xmalloc (strlen (filename
) + 1);
1342 strcpy (name
, filename
);
1346 register struct temp_file
*temp
;
1347 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
1348 if (! strcmp (name
, temp
->name
))
1350 temp
= (struct temp_file
*) xmalloc (sizeof (struct temp_file
));
1351 temp
->next
= always_delete_queue
;
1353 always_delete_queue
= temp
;
1359 register struct temp_file
*temp
;
1360 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
1361 if (! strcmp (name
, temp
->name
))
1363 temp
= (struct temp_file
*) xmalloc (sizeof (struct temp_file
));
1364 temp
->next
= failure_delete_queue
;
1366 failure_delete_queue
= temp
;
1371 /* Delete all the temporary files whose names we previously recorded. */
1374 delete_temp_files ()
1376 register struct temp_file
*temp
;
1378 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
1382 printf ("Delete %s? (y or n) ", temp
->name
);
1386 while (getchar () != '\n') ;
1387 if (i
== 'y' || i
== 'Y')
1391 if (stat (temp
->name
, &st
) >= 0)
1393 /* Delete only ordinary files. */
1394 if (S_ISREG (st
.st_mode
))
1395 if (unlink (temp
->name
) < 0)
1397 perror_with_name (temp
->name
);
1402 always_delete_queue
= 0;
1405 /* Delete all the files to be deleted on error. */
1408 delete_failure_queue ()
1410 register struct temp_file
*temp
;
1412 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
1416 printf ("Delete %s? (y or n) ", temp
->name
);
1420 while (getchar () != '\n') ;
1421 if (i
== 'y' || i
== 'Y')
1424 if (unlink (temp
->name
) < 0)
1426 perror_with_name (temp
->name
);
1432 clear_failure_queue ()
1434 failure_delete_queue
= 0;
1437 /* Compute a string to use as the base of all temporary file names.
1438 It is substituted for %g. */
1441 choose_temp_base_try (try, base
)
1448 else if (try == (char *)0)
1450 else if (access (try, R_OK
| W_OK
) != 0)
1463 base
= choose_temp_base_try (getenv ("TMPDIR"), base
);
1464 base
= choose_temp_base_try (getenv ("TMP"), base
);
1465 base
= choose_temp_base_try (getenv ("TEMP"), base
);
1468 base
= choose_temp_base_try (P_tmpdir
, base
);
1471 base
= choose_temp_base_try ("/usr/tmp", base
);
1472 base
= choose_temp_base_try ("/tmp", base
);
1474 /* If all else fails, use the current directory! */
1475 if (base
== (char *)0)
1478 len
= strlen (base
);
1479 temp_filename
= xmalloc (len
+ sizeof("/ccXXXXXX") + 1);
1480 strcpy (temp_filename
, base
);
1481 if (len
> 0 && temp_filename
[len
-1] != '/')
1482 temp_filename
[len
++] = '/';
1483 strcpy (temp_filename
+ len
, "ccXXXXXX");
1485 mktemp (temp_filename
);
1486 temp_filename_length
= strlen (temp_filename
);
1487 if (temp_filename_length
== 0)
1492 /* Routine to add variables to the environment. We do this to pass
1493 the pathname of the gcc driver, and the directories search to the
1494 collect2 program, which is being run as ld. This way, we can be
1495 sure of executing the right compiler when collect2 wants to build
1496 constructors and destructors. Since the environment variables we
1497 use come from an obstack, we don't have to worry about allocating
1506 #ifndef VMS /* nor about VMS */
1508 extern char **environ
;
1509 char **old_environ
= environ
;
1513 int str_len
= strlen (str
);
1517 while ((ch
= *p
++) != '\0' && ch
!= '=')
1523 /* Search for replacing an existing environment variable, and
1524 count the number of total environment variables. */
1525 for (envp
= old_environ
; *envp
; envp
++)
1528 if (!strncmp (str
, *envp
, name_len
))
1535 /* Add a new environment variable */
1536 environ
= (char **) xmalloc (sizeof (char *) * (num_envs
+2));
1538 bcopy (old_environ
, environ
+1, sizeof (char *) * (num_envs
+1));
1543 #endif /* HAVE_PUTENV */
1546 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables for collect. */
1549 putenv_from_prefixes (paths
, env_var
)
1550 struct path_prefix
*paths
;
1553 int suffix_len
= (machine_suffix
) ? strlen (machine_suffix
) : 0;
1555 = (just_machine_suffix
) ? strlen (just_machine_suffix
) : 0;
1556 int first_time
= TRUE
;
1557 struct prefix_list
*pprefix
;
1559 obstack_grow (&collect_obstack
, env_var
, strlen (env_var
));
1561 for (pprefix
= paths
->plist
; pprefix
!= 0; pprefix
= pprefix
->next
)
1563 int len
= strlen (pprefix
->prefix
);
1566 && is_directory (pprefix
->prefix
, machine_suffix
, 0))
1569 obstack_1grow (&collect_obstack
, PATH_SEPARATOR
);
1572 obstack_grow (&collect_obstack
, pprefix
->prefix
, len
);
1573 obstack_grow (&collect_obstack
, machine_suffix
, suffix_len
);
1576 if (just_machine_suffix
1577 && pprefix
->require_machine_suffix
== 2
1578 && is_directory (pprefix
->prefix
, just_machine_suffix
, 0))
1581 obstack_1grow (&collect_obstack
, PATH_SEPARATOR
);
1584 obstack_grow (&collect_obstack
, pprefix
->prefix
, len
);
1585 obstack_grow (&collect_obstack
, just_machine_suffix
,
1589 if (!pprefix
->require_machine_suffix
)
1592 obstack_1grow (&collect_obstack
, PATH_SEPARATOR
);
1595 obstack_grow (&collect_obstack
, pprefix
->prefix
, len
);
1598 obstack_1grow (&collect_obstack
, '\0');
1599 putenv (obstack_finish (&collect_obstack
));
1603 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
1604 access to check permissions.
1605 Return 0 if not found, otherwise return its name, allocated with malloc. */
1608 find_a_file (pprefix
, name
, mode
)
1609 struct path_prefix
*pprefix
;
1614 char *file_suffix
= ((mode
& X_OK
) != 0 ? EXECUTABLE_SUFFIX
: "");
1615 struct prefix_list
*pl
;
1616 int len
= pprefix
->max_len
+ strlen (name
) + strlen (file_suffix
) + 1;
1619 len
+= strlen (machine_suffix
);
1621 temp
= xmalloc (len
);
1623 /* Determine the filename to execute (special case for absolute paths). */
1627 if (access (name
, mode
))
1629 strcpy (temp
, name
);
1634 for (pl
= pprefix
->plist
; pl
; pl
= pl
->next
)
1638 strcpy (temp
, pl
->prefix
);
1639 strcat (temp
, machine_suffix
);
1640 strcat (temp
, name
);
1641 if (access (temp
, mode
) == 0)
1643 if (pl
->used_flag_ptr
!= 0)
1644 *pl
->used_flag_ptr
= 1;
1647 /* Some systems have a suffix for executable files.
1648 So try appending that. */
1649 if (file_suffix
[0] != 0)
1651 strcat (temp
, file_suffix
);
1652 if (access (temp
, mode
) == 0)
1654 if (pl
->used_flag_ptr
!= 0)
1655 *pl
->used_flag_ptr
= 1;
1660 /* Certain prefixes are tried with just the machine type,
1661 not the version. This is used for finding as, ld, etc. */
1662 if (just_machine_suffix
&& pl
->require_machine_suffix
== 2)
1664 strcpy (temp
, pl
->prefix
);
1665 strcat (temp
, just_machine_suffix
);
1666 strcat (temp
, name
);
1667 if (access (temp
, mode
) == 0)
1669 if (pl
->used_flag_ptr
!= 0)
1670 *pl
->used_flag_ptr
= 1;
1673 /* Some systems have a suffix for executable files.
1674 So try appending that. */
1675 if (file_suffix
[0] != 0)
1677 strcat (temp
, file_suffix
);
1678 if (access (temp
, mode
) == 0)
1680 if (pl
->used_flag_ptr
!= 0)
1681 *pl
->used_flag_ptr
= 1;
1686 /* Certain prefixes can't be used without the machine suffix
1687 when the machine or version is explicitly specified. */
1688 if (!pl
->require_machine_suffix
)
1690 strcpy (temp
, pl
->prefix
);
1691 strcat (temp
, name
);
1692 if (access (temp
, mode
) == 0)
1694 if (pl
->used_flag_ptr
!= 0)
1695 *pl
->used_flag_ptr
= 1;
1698 /* Some systems have a suffix for executable files.
1699 So try appending that. */
1700 if (file_suffix
[0] != 0)
1702 strcat (temp
, file_suffix
);
1703 if (access (temp
, mode
) == 0)
1705 if (pl
->used_flag_ptr
!= 0)
1706 *pl
->used_flag_ptr
= 1;
1717 /* Add an entry for PREFIX in PLIST. If FIRST is set, it goes
1718 at the start of the list, otherwise it goes at the end.
1720 If WARN is nonzero, we will warn if no file is found
1721 through this prefix. WARN should point to an int
1722 which will be set to 1 if this entry is used.
1724 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
1725 the complete value of machine_suffix.
1726 2 means try both machine_suffix and just_machine_suffix. */
1729 add_prefix (pprefix
, prefix
, first
, require_machine_suffix
, warn
)
1730 struct path_prefix
*pprefix
;
1733 int require_machine_suffix
;
1736 struct prefix_list
*pl
, **prev
;
1739 if (!first
&& pprefix
->plist
)
1741 for (pl
= pprefix
->plist
; pl
->next
; pl
= pl
->next
)
1746 prev
= &pprefix
->plist
;
1748 /* Keep track of the longest prefix */
1750 len
= strlen (prefix
);
1751 if (len
> pprefix
->max_len
)
1752 pprefix
->max_len
= len
;
1754 pl
= (struct prefix_list
*) xmalloc (sizeof (struct prefix_list
));
1755 pl
->prefix
= save_string (prefix
, len
);
1756 pl
->require_machine_suffix
= require_machine_suffix
;
1757 pl
->used_flag_ptr
= warn
;
1764 pl
->next
= (struct prefix_list
*) 0;
1768 /* Print warnings for any prefixes in the list PPREFIX that were not used. */
1771 unused_prefix_warnings (pprefix
)
1772 struct path_prefix
*pprefix
;
1774 struct prefix_list
*pl
= pprefix
->plist
;
1778 if (pl
->used_flag_ptr
!= 0 && !*pl
->used_flag_ptr
)
1780 error ("file path prefix `%s' never used",
1782 /* Prevent duplicate warnings. */
1783 *pl
->used_flag_ptr
= 1;
1789 /* Get rid of all prefixes built up so far in *PLISTP. */
1792 free_path_prefix (pprefix
)
1793 struct path_prefix
*pprefix
;
1795 struct prefix_list
*pl
= pprefix
->plist
;
1796 struct prefix_list
*temp
;
1802 free (temp
->prefix
);
1803 free ((char *) temp
);
1805 pprefix
->plist
= (struct prefix_list
*) 0;
1808 /* stdin file number. */
1809 #define STDIN_FILE_NO 0
1811 /* stdout file number. */
1812 #define STDOUT_FILE_NO 1
1814 /* value of `pipe': port index for reading. */
1817 /* value of `pipe': port index for writing. */
1818 #define WRITE_PORT 1
1820 /* Pipe waiting from last process, to be used as input for the next one.
1821 Value is STDIN_FILE_NO if no pipe is waiting
1822 (i.e. the next command is the first of a group). */
1824 static int last_pipe_input
;
1826 /* Fork one piped subcommand. FUNC is the system call to use
1827 (either execv or execvp). ARGV is the arg vector to use.
1828 NOT_LAST is nonzero if this is not the last subcommand
1829 (i.e. its output should be piped to the next one.) */
1834 /* Declare these to avoid compilation error. They won't be called. */
1835 int execv(const char *a
, const char **b
){}
1836 int execvp(const char *a
, const char **b
){}
1839 pexecute (search_flag
, program
, argv
, not_last
)
1847 int i
, el
= search_flag
? 0 : 4;
1849 scmd
= (char *)malloc (strlen (program
) + strlen (temp_filename
) + 6 + el
);
1850 rf
= scmd
+ strlen(program
) + 2 + el
;
1851 sprintf (scmd
, "%s%s @%s.gp", program
,
1852 (search_flag
? "" : ".exe"), temp_filename
);
1853 argfile
= fopen (rf
, "w");
1855 pfatal_with_name (rf
);
1857 for (i
=1; argv
[i
]; i
++)
1860 for (cp
= argv
[i
]; *cp
; cp
++)
1862 if (*cp
== '"' || *cp
== '\'' || *cp
== '\\' || isspace (*cp
))
1863 fputc ('\\', argfile
);
1864 fputc (*cp
, argfile
);
1866 fputc ('\n', argfile
);
1876 perror_exec (program
);
1877 return MIN_FATAL_STATUS
<< 8;
1883 #else /* not __MSDOS__ */
1886 pexecute (search_flag
, program
, argv
, not_last
)
1892 int (*func
)() = (search_flag
? execv
: execvp
);
1895 int input_desc
= last_pipe_input
;
1896 int output_desc
= STDOUT_FILE_NO
;
1897 int retries
, sleep_interval
;
1899 /* If this isn't the last process, make a pipe for its output,
1900 and record it as waiting to be the input to the next process. */
1904 if (pipe (pdes
) < 0)
1905 pfatal_with_name ("pipe");
1906 output_desc
= pdes
[WRITE_PORT
];
1907 last_pipe_input
= pdes
[READ_PORT
];
1910 last_pipe_input
= STDIN_FILE_NO
;
1912 /* Fork a subprocess; wait and retry if it fails. */
1914 for (retries
= 0; retries
< 4; retries
++)
1919 sleep (sleep_interval
);
1920 sleep_interval
*= 2;
1927 pfatal_with_name ("fork");
1929 pfatal_with_name ("vfork");
1935 /* Move the input and output pipes into place, if nec. */
1936 if (input_desc
!= STDIN_FILE_NO
)
1938 close (STDIN_FILE_NO
);
1942 if (output_desc
!= STDOUT_FILE_NO
)
1944 close (STDOUT_FILE_NO
);
1946 close (output_desc
);
1949 /* Close the parent's descs that aren't wanted here. */
1950 if (last_pipe_input
!= STDIN_FILE_NO
)
1951 close (last_pipe_input
);
1953 /* Exec the program. */
1954 (*func
) (program
, argv
);
1955 perror_exec (program
);
1961 /* In the parent, after forking.
1962 Close the descriptors that we made for this child. */
1963 if (input_desc
!= STDIN_FILE_NO
)
1965 if (output_desc
!= STDOUT_FILE_NO
)
1966 close (output_desc
);
1968 /* Return child's process number. */
1973 #endif /* not __MSDOS__ */
1977 pexecute (search_flag
, program
, argv
, not_last
)
1983 return (search_flag
? spawnv
: spawnvp
) (1, program
, argv
);
1985 #endif /* not OS2 */
1987 /* Execute the command specified by the arguments on the current line of spec.
1988 When using pipes, this includes several piped-together commands
1989 with `|' between them.
1991 Return 0 if successful, -1 if failed. */
1997 int n_commands
; /* # of command. */
2001 char *prog
; /* program name. */
2002 char **argv
; /* vector of args. */
2003 int pid
; /* pid of process for this command. */
2006 struct command
*commands
; /* each command buffer with above info. */
2008 /* Count # of piped commands. */
2009 for (n_commands
= 1, i
= 0; i
< argbuf_index
; i
++)
2010 if (strcmp (argbuf
[i
], "|") == 0)
2013 /* Get storage for each command. */
2015 = (struct command
*) alloca (n_commands
* sizeof (struct command
));
2017 /* Split argbuf into its separate piped processes,
2018 and record info about each one.
2019 Also search for the programs that are to be run. */
2021 commands
[0].prog
= argbuf
[0]; /* first command. */
2022 commands
[0].argv
= &argbuf
[0];
2023 string
= find_a_file (&exec_prefix
, commands
[0].prog
, X_OK
);
2025 commands
[0].argv
[0] = string
;
2027 for (n_commands
= 1, i
= 0; i
< argbuf_index
; i
++)
2028 if (strcmp (argbuf
[i
], "|") == 0)
2029 { /* each command. */
2031 fatal ("-pipe not supported under MS-DOS");
2033 argbuf
[i
] = 0; /* termination of command args. */
2034 commands
[n_commands
].prog
= argbuf
[i
+ 1];
2035 commands
[n_commands
].argv
= &argbuf
[i
+ 1];
2036 string
= find_a_file (&exec_prefix
, commands
[n_commands
].prog
, X_OK
);
2038 commands
[n_commands
].argv
[0] = string
;
2042 argbuf
[argbuf_index
] = 0;
2044 /* If -v, print what we are about to do, and maybe query. */
2048 /* Print each piped command as a separate line. */
2049 for (i
= 0; i
< n_commands
; i
++)
2053 for (j
= commands
[i
].argv
; *j
; j
++)
2054 fprintf (stderr
, " %s", *j
);
2056 /* Print a pipe symbol after all but the last command. */
2057 if (i
+ 1 != n_commands
)
2058 fprintf (stderr
, " |");
2059 fprintf (stderr
, "\n");
2063 fprintf (stderr
, "\nGo ahead? (y or n) ");
2067 while (getchar () != '\n') ;
2068 if (i
!= 'y' && i
!= 'Y')
2073 /* Run each piped subprocess. */
2075 last_pipe_input
= STDIN_FILE_NO
;
2076 for (i
= 0; i
< n_commands
; i
++)
2078 char *string
= commands
[i
].argv
[0];
2080 commands
[i
].pid
= pexecute (string
!= commands
[i
].prog
,
2081 string
, commands
[i
].argv
,
2082 i
+ 1 < n_commands
);
2084 if (string
!= commands
[i
].prog
)
2090 /* Wait for all the subprocesses to finish.
2091 We don't care what order they finish in;
2092 we know that N_COMMANDS waits will get them all. */
2097 for (i
= 0; i
< n_commands
; i
++)
2101 char *prog
= "unknown";
2104 status
= pid
= commands
[i
].pid
;
2106 pid
= wait (&status
);
2114 for (j
= 0; j
< n_commands
; j
++)
2115 if (commands
[j
].pid
== pid
)
2116 prog
= commands
[j
].prog
;
2118 if ((status
& 0x7F) != 0)
2120 fatal ("Internal compiler error: program %s got fatal signal %d",
2121 prog
, (status
& 0x7F));
2124 if (((status
& 0xFF00) >> 8) >= MIN_FATAL_STATUS
)
2132 /* Find all the switches given to us
2133 and make a vector describing them.
2134 The elements of the vector are strings, one per switch given.
2135 If a switch uses following arguments, then the `part1' field
2136 is the switch itself and the `args' field
2137 is a null-terminated vector containing the following arguments.
2138 The `live_cond' field is 1 if the switch is true in a conditional spec,
2139 -1 if false (overridden by a later switch), and is initialized to zero.
2140 The `valid' field is nonzero if any spec has looked at this switch;
2141 if it remains zero at the end of the run, it must be meaningless. */
2151 static struct switchstr
*switches
;
2153 static int n_switches
;
2161 /* Also a vector of input files specified. */
2163 static struct infile
*infiles
;
2165 static int n_infiles
;
2167 /* And a vector of corresponding output files is made up later. */
2169 static char **outfiles
;
2171 /* Create the vector `switches' and its contents.
2172 Store its length in `n_switches'. */
2175 process_command (argc
, argv
)
2181 char *spec_lang
= 0;
2182 int last_language_n_infiles
;
2184 gcc_exec_prefix
= getenv ("GCC_EXEC_PREFIX");
2189 /* Figure compiler version from version string. */
2191 compiler_version
= save_string (version_string
, strlen (version_string
));
2192 for (temp
= compiler_version
; *temp
; ++temp
)
2201 /* Set up the default search paths. */
2203 if (gcc_exec_prefix
)
2205 add_prefix (&exec_prefix
, gcc_exec_prefix
, 0, 0, NULL_PTR
);
2206 add_prefix (&startfile_prefix
, gcc_exec_prefix
, 0, 0, NULL_PTR
);
2209 /* COMPILER_PATH and LIBRARY_PATH have values
2210 that are lists of directory names with colons. */
2212 temp
= getenv ("COMPILER_PATH");
2215 char *startp
, *endp
;
2216 char *nstore
= (char *) alloca (strlen (temp
) + 3);
2218 startp
= endp
= temp
;
2221 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
2223 strncpy (nstore
, startp
, endp
-startp
);
2226 strcpy (nstore
, "./");
2228 else if (endp
[-1] != '/')
2230 nstore
[endp
-startp
] = '/';
2231 nstore
[endp
-startp
+1] = 0;
2234 nstore
[endp
-startp
] = 0;
2235 add_prefix (&exec_prefix
, nstore
, 0, 0, NULL_PTR
);
2238 endp
= startp
= endp
+ 1;
2245 temp
= getenv ("LIBRARY_PATH");
2248 char *startp
, *endp
;
2249 char *nstore
= (char *) alloca (strlen (temp
) + 3);
2251 startp
= endp
= temp
;
2254 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
2256 strncpy (nstore
, startp
, endp
-startp
);
2259 strcpy (nstore
, "./");
2261 else if (endp
[-1] != '/')
2263 nstore
[endp
-startp
] = '/';
2264 nstore
[endp
-startp
+1] = 0;
2267 nstore
[endp
-startp
] = 0;
2268 add_prefix (&startfile_prefix
, nstore
, 0, 0, NULL_PTR
);
2271 endp
= startp
= endp
+ 1;
2278 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
2279 temp
= getenv ("LPATH");
2282 char *startp
, *endp
;
2283 char *nstore
= (char *) alloca (strlen (temp
) + 3);
2285 startp
= endp
= temp
;
2288 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
2290 strncpy (nstore
, startp
, endp
-startp
);
2293 strcpy (nstore
, "./");
2295 else if (endp
[-1] != '/')
2297 nstore
[endp
-startp
] = '/';
2298 nstore
[endp
-startp
+1] = 0;
2301 nstore
[endp
-startp
] = 0;
2302 add_prefix (&startfile_prefix
, nstore
, 0, 0, NULL_PTR
);
2305 endp
= startp
= endp
+ 1;
2312 /* Convert new-style -- options to old-style. */
2313 translate_options (&argc
, &argv
);
2315 /* Scan argv twice. Here, the first time, just count how many switches
2316 there will be in their vector, and how many input files in theirs.
2317 Here we also parse the switches that cc itself uses (e.g. -v). */
2319 for (i
= 1; i
< argc
; i
++)
2321 if (! strcmp (argv
[i
], "-dumpspecs"))
2323 printf ("*asm:\n%s\n\n", asm_spec
);
2324 printf ("*asm_final:\n%s\n\n", asm_final_spec
);
2325 printf ("*cpp:\n%s\n\n", cpp_spec
);
2326 printf ("*cc1:\n%s\n\n", cc1_spec
);
2327 printf ("*cc1plus:\n%s\n\n", cc1plus_spec
);
2328 printf ("*endfile:\n%s\n\n", endfile_spec
);
2329 printf ("*link:\n%s\n\n", link_spec
);
2330 printf ("*lib:\n%s\n\n", lib_spec
);
2331 printf ("*startfile:\n%s\n\n", startfile_spec
);
2332 printf ("*switches_need_spaces:\n%s\n\n", switches_need_spaces
);
2333 printf ("*signed_char:\n%s\n\n", signed_char_spec
);
2334 printf ("*predefines:\n%s\n\n", cpp_predefines
);
2335 printf ("*cross_compile:\n%d\n\n", cross_compile
);
2339 else if (! strcmp (argv
[i
], "-dumpversion"))
2341 printf ("%s\n", version_string
);
2344 else if (! strcmp (argv
[i
], "-print-libgcc-file-name"))
2345 print_file_name
= "libgcc.a";
2346 else if (! strncmp (argv
[i
], "-print-file-name=", 17))
2347 print_file_name
= argv
[i
] + 17;
2348 else if (! strncmp (argv
[i
], "-print-prog-name=", 17))
2349 print_prog_name
= argv
[i
] + 17;
2350 else if (! strcmp (argv
[i
], "-Xlinker"))
2352 /* Pass the argument of this option to the linker when we link. */
2355 fatal ("argument to `-Xlinker' is missing");
2358 if (!linker_options
)
2360 = (char **) xmalloc (n_linker_options
* sizeof (char **));
2363 = (char **) xrealloc (linker_options
,
2364 n_linker_options
* sizeof (char **));
2366 linker_options
[n_linker_options
- 1] = argv
[++i
];
2368 else if (! strncmp (argv
[i
], "-Wl,", 4))
2371 /* Pass the rest of this option to the linker when we link. */
2374 if (!linker_options
)
2376 = (char **) xmalloc (n_linker_options
* sizeof (char **));
2379 = (char **) xrealloc (linker_options
,
2380 n_linker_options
* sizeof (char **));
2382 /* Split the argument at commas. */
2384 for (j
= 4; argv
[i
][j
]; j
++)
2385 if (argv
[i
][j
] == ',')
2387 linker_options
[n_linker_options
- 1]
2388 = save_string (argv
[i
] + prev
, j
- prev
);
2391 = (char **) xrealloc (linker_options
,
2392 n_linker_options
* sizeof (char **));
2395 /* Record the part after the last comma. */
2396 linker_options
[n_linker_options
- 1] = argv
[i
] + prev
;
2398 else if (! strncmp (argv
[i
], "-Wa,", 4))
2401 /* Pass the rest of this option to the assembler. */
2403 n_assembler_options
++;
2404 if (!assembler_options
)
2406 = (char **) xmalloc (n_assembler_options
* sizeof (char **));
2409 = (char **) xrealloc (assembler_options
,
2410 n_assembler_options
* sizeof (char **));
2412 /* Split the argument at commas. */
2414 for (j
= 4; argv
[i
][j
]; j
++)
2415 if (argv
[i
][j
] == ',')
2417 assembler_options
[n_assembler_options
- 1]
2418 = save_string (argv
[i
] + prev
, j
- prev
);
2419 n_assembler_options
++;
2421 = (char **) xrealloc (assembler_options
,
2422 n_assembler_options
* sizeof (char **));
2425 /* Record the part after the last comma. */
2426 assembler_options
[n_assembler_options
- 1] = argv
[i
] + prev
;
2428 else if (argv
[i
][0] == '+' && argv
[i
][1] == 'e')
2429 /* The +e options to the C++ front-end. */
2431 else if (argv
[i
][0] == '-' && argv
[i
][1] != 0 && argv
[i
][1] != 'l')
2433 register char *p
= &argv
[i
][1];
2434 register int c
= *p
;
2439 if (p
[1] == 0 && i
+ 1 == argc
)
2440 fatal ("argument to `-b' is missing");
2442 spec_machine
= argv
[++i
];
2444 spec_machine
= p
+ 1;
2449 int *temp
= (int *) xmalloc (sizeof (int));
2451 if (p
[1] == 0 && i
+ 1 == argc
)
2452 fatal ("argument to `-B' is missing");
2457 add_prefix (&exec_prefix
, value
, 1, 0, temp
);
2458 add_prefix (&startfile_prefix
, value
, 1, 0, temp
);
2459 add_prefix (&include_prefix
, concat (value
, "include", ""),
2462 /* As a kludge, if the arg is "[foo/]stageN/", just add
2463 "include" to the include prefix. */
2465 int len
= strlen (value
);
2466 if ((len
== 7 || (len
> 7 && value
[len
- 8] == '/'))
2467 && strncmp (value
+ len
- 7, "stage", 5) == 0
2468 && isdigit (value
[len
- 2])
2469 && value
[len
- 1] == '/')
2470 add_prefix (&include_prefix
, "include", 1, 0, 0);
2475 case 'v': /* Print our subcommands and print versions. */
2477 /* If they do anything other than exactly `-v', don't set
2478 verbose_flag; rather, continue on to give the error. */
2485 if (p
[1] == 0 && i
+ 1 == argc
)
2486 fatal ("argument to `-V' is missing");
2488 spec_version
= argv
[++i
];
2490 spec_version
= p
+ 1;
2491 compiler_version
= spec_version
;
2495 if (!strcmp (p
, "save-temps"))
2497 save_temps_flag
= 1;
2504 if (SWITCH_TAKES_ARG (c
) > (p
[1] != 0))
2505 i
+= SWITCH_TAKES_ARG (c
) - (p
[1] != 0);
2506 else if (WORD_SWITCH_TAKES_ARG (p
))
2507 i
+= WORD_SWITCH_TAKES_ARG (p
);
2514 /* Set up the search paths before we go looking for config files. */
2516 /* These come before the md prefixes so that we will find gcc's subcommands
2517 (such as cpp) rather than those of the host system. */
2518 /* Use 2 as fourth arg meaning try just the machine as a suffix,
2519 as well as trying the machine and the version. */
2520 add_prefix (&exec_prefix
, standard_exec_prefix
, 0, 2, NULL_PTR
);
2521 add_prefix (&exec_prefix
, standard_exec_prefix_1
, 0, 2, NULL_PTR
);
2523 add_prefix (&startfile_prefix
, standard_exec_prefix
, 0, 1, NULL_PTR
);
2524 add_prefix (&startfile_prefix
, standard_exec_prefix_1
, 0, 1, NULL_PTR
);
2526 tooldir_prefix
= concat (tooldir_base_prefix
, spec_machine
, "/");
2528 /* If tooldir is relative, base it on exec_prefix. A relative
2529 tooldir lets us move the installed tree as a unit.
2531 If GCC_EXEC_PREFIX is defined, then we want to add two relative
2532 directories, so that we can search both the user specified directory
2533 and the standard place. */
2535 if (*tooldir_prefix
!= '/')
2537 if (gcc_exec_prefix
)
2539 char *gcc_exec_tooldir_prefix
2540 = concat (concat (gcc_exec_prefix
, spec_machine
, "/"),
2541 concat (spec_version
, "/", tooldir_prefix
),
2544 add_prefix (&exec_prefix
, concat (gcc_exec_tooldir_prefix
, "bin", "/"),
2546 add_prefix (&startfile_prefix
, concat (gcc_exec_tooldir_prefix
, "lib", "/"),
2550 tooldir_prefix
= concat (concat (standard_exec_prefix
, spec_machine
, "/"),
2551 concat (spec_version
, "/", tooldir_prefix
),
2555 add_prefix (&exec_prefix
, concat (tooldir_prefix
, "bin", "/"),
2557 add_prefix (&startfile_prefix
, concat (tooldir_prefix
, "lib", "/"),
2560 /* More prefixes are enabled in main, after we read the specs file
2561 and determine whether this is cross-compilation or not. */
2564 /* Then create the space for the vectors and scan again. */
2566 switches
= ((struct switchstr
*)
2567 xmalloc ((n_switches
+ 1) * sizeof (struct switchstr
)));
2568 infiles
= (struct infile
*) xmalloc ((n_infiles
+ 1) * sizeof (struct infile
));
2571 last_language_n_infiles
= -1;
2573 /* This, time, copy the text of each switch and store a pointer
2574 to the copy in the vector of switches.
2575 Store all the infiles in their vector. */
2577 for (i
= 1; i
< argc
; i
++)
2579 /* Just skip the switches that were handled by the preceding loop. */
2580 if (!strcmp (argv
[i
], "-Xlinker"))
2582 else if (! strncmp (argv
[i
], "-Wl,", 4))
2584 else if (! strncmp (argv
[i
], "-Wa,", 4))
2586 else if (! strcmp (argv
[i
], "-print-libgcc-file-name"))
2588 else if (! strncmp (argv
[i
], "-print-file-name=", 17))
2590 else if (! strncmp (argv
[i
], "-print-prog-name=", 17))
2592 else if (argv
[i
][0] == '+' && argv
[i
][1] == 'e')
2594 /* Compensate for the +e options to the C++ front-end;
2595 they're there simply for cfront call-compatibility. We do
2596 some magic in default_compilers to pass them down properly.
2597 Note we deliberately start at the `+' here, to avoid passing
2598 -e0 or -e1 down into the linker. */
2599 switches
[n_switches
].part1
= &argv
[i
][0];
2600 switches
[n_switches
].args
= 0;
2601 switches
[n_switches
].live_cond
= 0;
2602 switches
[n_switches
].valid
= 0;
2605 else if (argv
[i
][0] == '-' && argv
[i
][1] != 0 && argv
[i
][1] != 'l')
2607 register char *p
= &argv
[i
][1];
2608 register int c
= *p
;
2610 if (c
== 'B' || c
== 'b' || c
== 'V')
2612 /* Skip a separate arg, if any. */
2619 if (p
[1] == 0 && i
+ 1 == argc
)
2620 fatal ("argument to `-x' is missing");
2622 spec_lang
= argv
[++i
];
2625 if (! strcmp (spec_lang
, "none"))
2626 /* Suppress the warning if -xnone comes after the last input file,
2627 because alternate command interfaces like g++ might find it
2628 useful to place -xnone after each input file. */
2631 last_language_n_infiles
= n_infiles
;
2634 switches
[n_switches
].part1
= p
;
2635 /* Deal with option arguments in separate argv elements. */
2636 if ((SWITCH_TAKES_ARG (c
) > (p
[1] != 0))
2637 || WORD_SWITCH_TAKES_ARG (p
))
2640 int n_args
= WORD_SWITCH_TAKES_ARG (p
);
2644 /* Count only the option arguments in separate argv elements. */
2645 n_args
= SWITCH_TAKES_ARG (c
) - (p
[1] != 0);
2647 if (i
+ n_args
>= argc
)
2648 fatal ("argument to `-%s' is missing", p
);
2649 switches
[n_switches
].args
2650 = (char **) xmalloc ((n_args
+ 1) * sizeof (char *));
2652 switches
[n_switches
].args
[j
++] = argv
[++i
];
2653 /* Null-terminate the vector. */
2654 switches
[n_switches
].args
[j
] = 0;
2656 else if (*switches_need_spaces
!= 0 && (c
== 'o' || c
== 'L'))
2658 /* On some systems, ld cannot handle -o or -L without space.
2659 So split the -o or -L from its argument. */
2660 switches
[n_switches
].part1
= (c
== 'o' ? "o" : "L");
2661 switches
[n_switches
].args
= (char **) xmalloc (2 * sizeof (char *));
2662 switches
[n_switches
].args
[0] = xmalloc (strlen (p
));
2663 strcpy (switches
[n_switches
].args
[0], &p
[1]);
2664 switches
[n_switches
].args
[1] = 0;
2667 switches
[n_switches
].args
= 0;
2669 switches
[n_switches
].live_cond
= 0;
2670 switches
[n_switches
].valid
= 0;
2671 /* This is always valid, since gcc.c itself understands it. */
2672 if (!strcmp (p
, "save-temps"))
2673 switches
[n_switches
].valid
= 1;
2678 if ((argv
[i
][0] != '-' || argv
[i
][1] != 'l')
2679 && strcmp (argv
[i
], "-")
2680 && access (argv
[i
], R_OK
) < 0)
2682 perror_with_name (argv
[i
]);
2687 infiles
[n_infiles
].language
= spec_lang
;
2688 infiles
[n_infiles
++].name
= argv
[i
];
2693 if (n_infiles
== last_language_n_infiles
&& spec_lang
!= 0)
2694 error ("Warning: `-x %s' after last input file has no effect", spec_lang
);
2696 switches
[n_switches
].part1
= 0;
2697 infiles
[n_infiles
].name
= 0;
2699 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
2700 if (gcc_exec_prefix
)
2702 temp
= (char *) xmalloc (strlen (gcc_exec_prefix
) + strlen (spec_version
)
2703 + strlen (spec_machine
) + 3);
2704 strcpy (temp
, gcc_exec_prefix
);
2705 strcat (temp
, spec_machine
);
2707 strcat (temp
, spec_version
);
2709 gcc_exec_prefix
= temp
;
2713 /* Process a spec string, accumulating and running commands. */
2715 /* These variables describe the input file name.
2716 input_file_number is the index on outfiles of this file,
2717 so that the output file name can be stored for later use by %o.
2718 input_basename is the start of the part of the input file
2719 sans all directory names, and basename_length is the number
2720 of characters starting there excluding the suffix .c or whatever. */
2722 static char *input_filename
;
2723 static int input_file_number
;
2724 static int input_filename_length
;
2725 static int basename_length
;
2726 static char *input_basename
;
2727 static char *input_suffix
;
2729 /* These are variables used within do_spec and do_spec_1. */
2731 /* Nonzero if an arg has been started and not yet terminated
2732 (with space, tab or newline). */
2733 static int arg_going
;
2735 /* Nonzero means %d or %g has been seen; the next arg to be terminated
2736 is a temporary file name. */
2737 static int delete_this_arg
;
2739 /* Nonzero means %w has been seen; the next arg to be terminated
2740 is the output file name of this compilation. */
2741 static int this_is_output_file
;
2743 /* Nonzero means %s has been seen; the next arg to be terminated
2744 is the name of a library file and we should try the standard
2745 search dirs for it. */
2746 static int this_is_library_file
;
2748 /* Nonzero means that the input of this command is coming from a pipe. */
2749 static int input_from_pipe
;
2751 /* Process the spec SPEC and run the commands specified therein.
2752 Returns 0 if the spec is successfully processed; -1 if failed. */
2762 delete_this_arg
= 0;
2763 this_is_output_file
= 0;
2764 this_is_library_file
= 0;
2765 input_from_pipe
= 0;
2767 value
= do_spec_1 (spec
, 0, NULL_PTR
);
2769 /* Force out any unfinished command.
2770 If -pipe, this forces out the last command if it ended in `|'. */
2773 if (argbuf_index
> 0 && !strcmp (argbuf
[argbuf_index
- 1], "|"))
2776 if (argbuf_index
> 0)
2783 /* Process the sub-spec SPEC as a portion of a larger spec.
2784 This is like processing a whole spec except that we do
2785 not initialize at the beginning and we do not supply a
2786 newline by default at the end.
2787 INSWITCH nonzero means don't process %-sequences in SPEC;
2788 in this case, % is treated as an ordinary character.
2789 This is used while substituting switches.
2790 INSWITCH nonzero also causes SPC not to terminate an argument.
2792 Value is zero unless a line was finished
2793 and the command on that line reported an error. */
2796 do_spec_1 (spec
, inswitch
, soft_matched_part
)
2799 char *soft_matched_part
;
2801 register char *p
= spec
;
2808 /* If substituting a switch, treat all chars like letters.
2809 Otherwise, NL, SPC, TAB and % are special. */
2810 switch (inswitch
? 'a' : c
)
2813 /* End of line: finish any pending argument,
2814 then run the pending command if one has been started. */
2817 obstack_1grow (&obstack
, 0);
2818 string
= obstack_finish (&obstack
);
2819 if (this_is_library_file
)
2820 string
= find_file (string
);
2821 store_arg (string
, delete_this_arg
, this_is_output_file
);
2822 if (this_is_output_file
)
2823 outfiles
[input_file_number
] = string
;
2827 if (argbuf_index
> 0 && !strcmp (argbuf
[argbuf_index
- 1], "|"))
2830 for (i
= 0; i
< n_switches
; i
++)
2831 if (!strcmp (switches
[i
].part1
, "pipe"))
2834 /* A `|' before the newline means use a pipe here,
2835 but only if -pipe was specified.
2836 Otherwise, execute now and don't pass the `|' as an arg. */
2839 input_from_pipe
= 1;
2840 switches
[i
].valid
= 1;
2847 if (argbuf_index
> 0)
2853 /* Reinitialize for a new command, and for a new argument. */
2856 delete_this_arg
= 0;
2857 this_is_output_file
= 0;
2858 this_is_library_file
= 0;
2859 input_from_pipe
= 0;
2863 /* End any pending argument. */
2866 obstack_1grow (&obstack
, 0);
2867 string
= obstack_finish (&obstack
);
2868 if (this_is_library_file
)
2869 string
= find_file (string
);
2870 store_arg (string
, delete_this_arg
, this_is_output_file
);
2871 if (this_is_output_file
)
2872 outfiles
[input_file_number
] = string
;
2876 obstack_1grow (&obstack
, c
);
2882 /* Space or tab ends an argument if one is pending. */
2885 obstack_1grow (&obstack
, 0);
2886 string
= obstack_finish (&obstack
);
2887 if (this_is_library_file
)
2888 string
= find_file (string
);
2889 store_arg (string
, delete_this_arg
, this_is_output_file
);
2890 if (this_is_output_file
)
2891 outfiles
[input_file_number
] = string
;
2893 /* Reinitialize for a new argument. */
2895 delete_this_arg
= 0;
2896 this_is_output_file
= 0;
2897 this_is_library_file
= 0;
2904 fatal ("Invalid specification! Bug in cc.");
2907 obstack_grow (&obstack
, input_basename
, basename_length
);
2912 delete_this_arg
= 2;
2915 /* Dump out the directories specified with LIBRARY_PATH,
2916 followed by the absolute directories
2917 that we search for startfiles. */
2920 struct prefix_list
*pl
= startfile_prefix
.plist
;
2922 char *buffer
= (char *) xmalloc (bufsize
);
2925 for (; pl
; pl
= pl
->next
)
2927 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
2928 /* Used on systems which record the specified -L dirs
2929 and use them to search for dynamic linking. */
2930 /* Relative directories always come from -B,
2931 and it is better not to use them for searching
2932 at run time. In particular, stage1 loses */
2933 if (pl
->prefix
[0] != '/')
2938 if (is_directory (pl
->prefix
, machine_suffix
, 1))
2940 do_spec_1 ("-L", 0, NULL_PTR
);
2941 #ifdef SPACE_AFTER_L_OPTION
2942 do_spec_1 (" ", 0, NULL_PTR
);
2944 do_spec_1 (pl
->prefix
, 1, NULL_PTR
);
2945 /* Remove slash from machine_suffix. */
2946 if (strlen (machine_suffix
) >= bufsize
)
2947 bufsize
= strlen (machine_suffix
) * 2 + 1;
2948 buffer
= (char *) xrealloc (buffer
, bufsize
);
2949 strcpy (buffer
, machine_suffix
);
2950 idx
= strlen (buffer
);
2951 if (buffer
[idx
- 1] == '/')
2952 buffer
[idx
- 1] = 0;
2953 do_spec_1 (buffer
, 1, NULL_PTR
);
2954 /* Make this a separate argument. */
2955 do_spec_1 (" ", 0, NULL_PTR
);
2958 if (!pl
->require_machine_suffix
)
2960 if (is_directory (pl
->prefix
, "", 1))
2962 do_spec_1 ("-L", 0, NULL_PTR
);
2963 #ifdef SPACE_AFTER_L_OPTION
2964 do_spec_1 (" ", 0, NULL_PTR
);
2966 /* Remove slash from pl->prefix. */
2967 if (strlen (pl
->prefix
) >= bufsize
)
2968 bufsize
= strlen (pl
->prefix
) * 2 + 1;
2969 buffer
= (char *) xrealloc (buffer
, bufsize
);
2970 strcpy (buffer
, pl
->prefix
);
2971 idx
= strlen (buffer
);
2972 if (buffer
[idx
- 1] == '/')
2973 buffer
[idx
- 1] = 0;
2974 do_spec_1 (buffer
, 1, NULL_PTR
);
2975 /* Make this a separate argument. */
2976 do_spec_1 (" ", 0, NULL_PTR
);
2985 /* {...:%efoo} means report an error with `foo' as error message
2986 and don't execute any more commands for this file. */
2990 while (*p
!= 0 && *p
!= '\n') p
++;
2991 buf
= (char *) alloca (p
- q
+ 1);
2992 strncpy (buf
, q
, p
- q
);
3002 if (save_temps_flag
)
3004 obstack_grow (&obstack
, input_basename
, basename_length
);
3005 delete_this_arg
= 0;
3009 #ifdef MKTEMP_EACH_FILE
3010 /* ??? This has a problem: the total number of
3011 values mktemp can return is limited.
3012 That matters for the names of object files.
3013 In 2.4, do something about that. */
3014 struct temp_name
*t
;
3016 while (*p
== '.' || isalpha (*p
))
3019 /* See if we already have an association of %g/%u/%U and
3021 for (t
= temp_names
; t
; t
= t
->next
)
3022 if (t
->length
== p
- suffix
3023 && strncmp (t
->suffix
, suffix
, p
- suffix
) == 0
3024 && t
->unique
== (c
!= 'g'))
3027 /* Make a new association if needed. %u requires one. */
3028 if (t
== 0 || c
== 'u')
3032 t
= (struct temp_name
*) xmalloc (sizeof (struct temp_name
));
3033 t
->next
= temp_names
;
3036 t
->length
= p
- suffix
;
3037 t
->suffix
= save_string (suffix
, p
- suffix
);
3038 t
->unique
= (c
!= 'g');
3039 choose_temp_base ();
3040 t
->filename
= temp_filename
;
3041 t
->filename_length
= temp_filename_length
;
3044 obstack_grow (&obstack
, t
->filename
, t
->filename_length
);
3045 delete_this_arg
= 1;
3047 obstack_grow (&obstack
, temp_filename
, temp_filename_length
);
3048 if (c
== 'u' || c
== 'U')
3054 sprintf (buff
, "%d", unique
);
3055 obstack_grow (&obstack
, buff
, strlen (buff
));
3058 delete_this_arg
= 1;
3064 obstack_grow (&obstack
, input_filename
, input_filename_length
);
3070 struct prefix_list
*pl
= include_prefix
.plist
;
3072 if (gcc_exec_prefix
)
3074 do_spec_1 ("-iprefix", 1, NULL_PTR
);
3075 /* Make this a separate argument. */
3076 do_spec_1 (" ", 0, NULL_PTR
);
3077 do_spec_1 (gcc_exec_prefix
, 1, NULL_PTR
);
3078 do_spec_1 (" ", 0, NULL_PTR
);
3081 for (; pl
; pl
= pl
->next
)
3083 do_spec_1 ("-isystem", 1, NULL_PTR
);
3084 /* Make this a separate argument. */
3085 do_spec_1 (" ", 0, NULL_PTR
);
3086 do_spec_1 (pl
->prefix
, 1, NULL_PTR
);
3087 do_spec_1 (" ", 0, NULL_PTR
);
3095 for (f
= 0; f
< n_infiles
; f
++)
3096 store_arg (outfiles
[f
], 0, 0);
3101 this_is_library_file
= 1;
3105 this_is_output_file
= 1;
3110 int index
= argbuf_index
;
3111 /* Handle the {...} following the %W. */
3114 p
= handle_braces (p
+ 1);
3117 /* If any args were output, mark the last one for deletion
3119 if (argbuf_index
!= index
)
3120 record_temp_file (argbuf
[argbuf_index
- 1], 0, 1);
3124 /* %x{OPTION} records OPTION for %X to output. */
3130 /* Skip past the option value and make a copy. */
3135 string
= save_string (p1
+ 1, p
- p1
- 2);
3137 /* See if we already recorded this option. */
3138 for (i
= 0; i
< n_linker_options
; i
++)
3139 if (! strcmp (string
, linker_options
[i
]))
3145 /* This option is new; add it. */
3147 if (!linker_options
)
3149 = (char **) xmalloc (n_linker_options
* sizeof (char **));
3152 = (char **) xrealloc (linker_options
,
3153 n_linker_options
* sizeof (char **));
3155 linker_options
[n_linker_options
- 1] = string
;
3159 /* Dump out the options accumulated previously using %x,
3160 -Xlinker and -Wl,. */
3162 for (i
= 0; i
< n_linker_options
; i
++)
3164 do_spec_1 (linker_options
[i
], 1, NULL_PTR
);
3165 /* Make each accumulated option a separate argument. */
3166 do_spec_1 (" ", 0, NULL_PTR
);
3170 /* Dump out the options accumulated previously using -Wa,. */
3172 for (i
= 0; i
< n_assembler_options
; i
++)
3174 do_spec_1 (assembler_options
[i
], 1, NULL_PTR
);
3175 /* Make each accumulated option a separate argument. */
3176 do_spec_1 (" ", 0, NULL_PTR
);
3180 /* Here are digits and numbers that just process
3181 a certain constant string as a spec. */
3184 value
= do_spec_1 (cc1_spec
, 0, NULL_PTR
);
3190 value
= do_spec_1 (cc1plus_spec
, 0, NULL_PTR
);
3196 value
= do_spec_1 (asm_spec
, 0, NULL_PTR
);
3202 value
= do_spec_1 (asm_final_spec
, 0, NULL_PTR
);
3208 value
= do_spec_1 (signed_char_spec
, 0, NULL_PTR
);
3214 value
= do_spec_1 (cpp_spec
, 0, NULL_PTR
);
3220 value
= do_spec_1 (endfile_spec
, 0, NULL_PTR
);
3226 value
= do_spec_1 (link_spec
, 0, NULL_PTR
);
3232 value
= do_spec_1 (lib_spec
, 0, NULL_PTR
);
3239 char *x
= (char *) alloca (strlen (cpp_predefines
) + 1);
3243 /* Copy all of the -D options in CPP_PREDEFINES into BUF. */
3247 if (! strncmp (y
, "-D", 2))
3248 /* Copy the whole option. */
3249 while (*y
&& *y
!= ' ' && *y
!= '\t')
3251 else if (*y
== ' ' || *y
== '\t')
3252 /* Copy whitespace to the result. */
3254 /* Don't copy other options. */
3261 value
= do_spec_1 (buf
, 0, NULL_PTR
);
3269 char *x
= (char *) alloca (strlen (cpp_predefines
) * 4 + 1);
3273 /* Copy all of CPP_PREDEFINES into BUF,
3274 but put __ after every -D and at the end of each arg. */
3278 if (! strncmp (y
, "-D", 2))
3285 if (strncmp (y
, "__", 2))
3287 /* Stick __ at front of macro name. */
3290 /* Arrange to stick __ at the end as well. */
3294 /* Copy the macro name. */
3295 while (*y
&& *y
!= '=' && *y
!= ' ' && *y
!= '\t')
3304 /* Copy the value given, if any. */
3305 while (*y
&& *y
!= ' ' && *y
!= '\t')
3308 else if (*y
== ' ' || *y
== '\t')
3309 /* Copy whitespace to the result. */
3311 /* Don't copy -A options */
3317 /* Copy all of CPP_PREDEFINES into BUF,
3318 but put __ after every -D. */
3322 if (! strncmp (y
, "-D", 2))
3326 if (strncmp (y
, "__", 2))
3328 /* Stick -D__ at front of macro name. */
3334 /* Copy the macro name. */
3335 while (*y
&& *y
!= '=' && *y
!= ' ' && *y
!= '\t')
3338 /* Copy the value given, if any. */
3339 while (*y
&& *y
!= ' ' && *y
!= '\t')
3344 /* Do not copy this macro - we have just done it before */
3345 while (*y
&& *y
!= ' ' && *y
!= '\t')
3349 else if (*y
== ' ' || *y
== '\t')
3350 /* Copy whitespace to the result. */
3352 /* Don't copy -A options */
3358 /* Copy all of the -A options in CPP_PREDEFINES into BUF. */
3362 if (! strncmp (y
, "-A", 2))
3363 /* Copy the whole option. */
3364 while (*y
&& *y
!= ' ' && *y
!= '\t')
3366 else if (*y
== ' ' || *y
== '\t')
3367 /* Copy whitespace to the result. */
3369 /* Don't copy other options. */
3376 value
= do_spec_1 (buf
, 0, NULL_PTR
);
3383 value
= do_spec_1 (startfile_spec
, 0, NULL_PTR
);
3388 /* Here we define characters other than letters and digits. */
3391 p
= handle_braces (p
);
3397 obstack_1grow (&obstack
, '%');
3401 do_spec_1 (soft_matched_part
, 1, NULL_PTR
);
3402 do_spec_1 (" ", 0, NULL_PTR
);
3405 /* Process a string found as the value of a spec given by name.
3406 This feature allows individual machine descriptions
3407 to add and use their own specs.
3408 %[...] modifies -D options the way %P does;
3409 %(...) uses the spec unmodified. */
3414 struct spec_list
*sl
;
3417 /* The string after the S/P is the name of a spec that is to be
3419 while (*p
&& *p
!= ')' && *p
!= ']')
3422 /* See if it's in the list */
3423 for (len
= p
- name
, sl
= specs
; sl
; sl
= sl
->next
)
3424 if (strncmp (sl
->name
, name
, len
) == 0 && !sl
->name
[len
])
3434 value
= do_spec_1 (name
, 0, NULL_PTR
);
3440 char *x
= (char *) alloca (strlen (name
) * 2 + 1);
3444 /* Copy all of NAME into BUF, but put __ after
3445 every -D and at the end of each arg, */
3448 if (! strncmp (y
, "-D", 2))
3456 else if (*y
== ' ' || *y
== 0)
3470 value
= do_spec_1 (buf
, 0, NULL_PTR
);
3476 /* Discard the closing paren or bracket. */
3484 int c1
= *p
++; /* Select first or second version number. */
3485 char *v
= compiler_version
;
3487 /* If desired, advance to second version number. */
3490 /* Set P after the first period. */
3491 while (*v
!= 0 && *v
!= ' ' && *v
!= '.')
3496 /* Set Q at the next period or at the end. */
3498 while (*q
!= 0 && *q
!= ' ' && *q
!= '.')
3500 /* Empty string means zero. */
3506 /* Put that part into the command. */
3507 obstack_grow (&obstack
, v
, q
- v
);
3513 if (input_from_pipe
)
3514 do_spec_1 ("-", 0, NULL_PTR
);
3523 /* Backslash: treat next character as ordinary. */
3528 /* Ordinary character: put it into the current argument. */
3529 obstack_1grow (&obstack
, c
);
3533 return 0; /* End of string */
3536 /* Return 0 if we call do_spec_1 and that returns -1. */
3549 /* A `|' after the open-brace means,
3550 if the test fails, output a single minus sign rather than nothing.
3551 This is used in %{|!pipe:...}. */
3555 /* A `!' after the open-brace negates the condition:
3556 succeed if the specified switch is not present. */
3560 /* A `.' after the open-brace means test against the current suffix. */
3570 while (*p
!= ':' && *p
!= '}') p
++;
3573 register int count
= 1;
3591 int found
= (input_suffix
!= 0
3592 && strlen (input_suffix
) == p
- filter
3593 && strncmp (input_suffix
, filter
, p
- filter
) == 0);
3599 && do_spec_1 (save_string (p
+ 1, q
- p
- 2), 0, NULL_PTR
) < 0)
3604 else if (p
[-1] == '*' && p
[0] == '}')
3606 /* Substitute all matching switches as separate args. */
3609 for (i
= 0; i
< n_switches
; i
++)
3610 if (!strncmp (switches
[i
].part1
, filter
, p
- filter
)
3611 && check_live_switch (i
, p
- filter
))
3616 /* Test for presence of the specified switch. */
3620 /* If name specified ends in *, as in {x*:...},
3621 check for %* and handle that case. */
3622 if (p
[-1] == '*' && !negate
)
3627 /* First see whether we have %*. */
3631 if (*r
== '%' && r
[1] == '*')
3635 /* If we do, handle that case. */
3638 /* Substitute all matching switches as separate args.
3639 But do this by substituting for %*
3640 in the text that follows the colon. */
3642 unsigned hard_match_len
= p
- filter
- 1;
3643 char *string
= save_string (p
+ 1, q
- p
- 2);
3645 for (i
= 0; i
< n_switches
; i
++)
3646 if (!strncmp (switches
[i
].part1
, filter
, hard_match_len
)
3647 && check_live_switch (i
, -1))
3649 do_spec_1 (string
, 0, &switches
[i
].part1
[hard_match_len
]);
3650 /* Pass any arguments this switch has. */
3658 /* If name specified ends in *, as in {x*:...},
3659 check for presence of any switch name starting with x. */
3662 for (i
= 0; i
< n_switches
; i
++)
3664 unsigned hard_match_len
= p
- filter
- 1;
3666 if (!strncmp (switches
[i
].part1
, filter
, hard_match_len
)
3667 && check_live_switch (i
, hard_match_len
))
3673 /* Otherwise, check for presence of exact name specified. */
3676 for (i
= 0; i
< n_switches
; i
++)
3678 if (!strncmp (switches
[i
].part1
, filter
, p
- filter
)
3679 && switches
[i
].part1
[p
- filter
] == 0
3680 && check_live_switch (i
, -1))
3688 /* If it is as desired (present for %{s...}, absent for %{-s...})
3689 then substitute either the switch or the specified
3690 conditional text. */
3691 if (present
!= negate
)
3699 if (do_spec_1 (save_string (p
+ 1, q
- p
- 2), 0, NULL_PTR
) < 0)
3705 /* Here if a %{|...} conditional fails: output a minus sign,
3706 which means "standard output" or "standard input". */
3707 do_spec_1 ("-", 0, NULL_PTR
);
3714 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
3715 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
3716 spec, or -1 if either exact match or %* is used.
3718 A -O switch is obsoleted by a later -O switch. A -f, -m, or -W switch
3719 whose value does not begin with "no-" is obsoleted by the same value
3720 with the "no-", similarly for a switch with the "no-" prefix. */
3723 check_live_switch (switchnum
, prefix_length
)
3727 char *name
= switches
[switchnum
].part1
;
3730 /* In the common case of {<at-most-one-letter>*}, a negating
3731 switch would always match, so ignore that case. We will just
3732 send the conflicting switches to the compiler phase. */
3733 if (prefix_length
>= 0 && prefix_length
<= 1)
3736 /* If we already processed this switch and determined if it was
3737 live or not, return our past determination. */
3738 if (switches
[switchnum
].live_cond
!= 0)
3739 return switches
[switchnum
].live_cond
> 0;
3741 /* Now search for duplicate in a manner that depends on the name. */
3745 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
3746 if (switches
[i
].part1
[0] == 'O')
3748 switches
[switchnum
].valid
= 1;
3749 switches
[switchnum
].live_cond
= -1;
3754 case 'W': case 'f': case 'm':
3755 if (! strncmp (name
+ 1, "no-", 3))
3757 /* We have Xno-YYY, search for XYYY. */
3758 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
3759 if (switches
[i
].part1
[0] == name
[0]
3760 && ! strcmp (&switches
[i
].part1
[1], &name
[4]))
3762 switches
[switchnum
].valid
= 1;
3763 switches
[switchnum
].live_cond
= -1;
3769 /* We have XYYY, search for Xno-YYY. */
3770 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
3771 if (switches
[i
].part1
[0] == name
[0]
3772 && switches
[i
].part1
[1] == 'n'
3773 && switches
[i
].part1
[2] == 'o'
3774 && switches
[i
].part1
[3] == '-'
3775 && !strcmp (&switches
[i
].part1
[4], &name
[1]))
3777 switches
[switchnum
].valid
= 1;
3778 switches
[switchnum
].live_cond
= -1;
3785 /* Otherwise the switch is live. */
3786 switches
[switchnum
].live_cond
= 1;
3790 /* Pass a switch to the current accumulating command
3791 in the same form that we received it.
3792 SWITCHNUM identifies the switch; it is an index into
3793 the vector of switches gcc received, which is `switches'.
3794 This cannot fail since it never finishes a command line.
3796 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
3799 give_switch (switchnum
, omit_first_word
)
3801 int omit_first_word
;
3803 if (!omit_first_word
)
3805 do_spec_1 ("-", 0, NULL_PTR
);
3806 do_spec_1 (switches
[switchnum
].part1
, 1, NULL_PTR
);
3808 do_spec_1 (" ", 0, NULL_PTR
);
3809 if (switches
[switchnum
].args
!= 0)
3812 for (p
= switches
[switchnum
].args
; *p
; p
++)
3814 do_spec_1 (*p
, 1, NULL_PTR
);
3815 do_spec_1 (" ", 0, NULL_PTR
);
3818 switches
[switchnum
].valid
= 1;
3821 /* Search for a file named NAME trying various prefixes including the
3822 user's -B prefix and some standard ones.
3823 Return the absolute file name found. If nothing is found, return NAME. */
3831 newname
= find_a_file (&startfile_prefix
, name
, R_OK
);
3832 return newname
? newname
: name
;
3835 /* Determine whether a directory exists. If LINKER, return 0 for
3836 certain fixed names not needed by the linker. If not LINKER, it is
3837 only important to return 0 if the host machine has a small ARG_MAX
3841 is_directory (path1
, path2
, linker
)
3846 int len1
= strlen (path1
);
3847 int len2
= strlen (path2
);
3848 char *path
= (char *) alloca (3 + len1
+ len2
);
3852 #ifndef SMALL_ARG_MAX
3857 /* Construct the path from the two parts. Ensure the string ends with "/.".
3858 The resulting path will be a directory even if the given path is a
3860 bcopy (path1
, path
, len1
);
3861 bcopy (path2
, path
+ len1
, len2
);
3862 cp
= path
+ len1
+ len2
;
3868 /* Exclude directories that the linker is known to search. */
3870 && ((cp
- path
== 6 && strcmp (path
, "/lib/.") == 0)
3871 || (cp
- path
== 10 && strcmp (path
, "/usr/lib/.") == 0)))
3874 return (stat (path
, &st
) >= 0 && S_ISDIR (st
.st_mode
));
3877 /* On fatal signals, delete all the temporary files. */
3880 fatal_error (signum
)
3883 signal (signum
, SIG_DFL
);
3884 delete_failure_queue ();
3885 delete_temp_files ();
3886 /* Get the same signal again, this time not handled,
3887 so its normal effect occurs. */
3888 kill (getpid (), signum
);
3899 int linker_was_run
= 0;
3900 char *explicit_link_files
;
3904 p
= argv
[0] + strlen (argv
[0]);
3905 while (p
!= argv
[0] && p
[-1] != '/') --p
;
3908 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
3909 signal (SIGINT
, fatal_error
);
3911 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
3912 signal (SIGHUP
, fatal_error
);
3914 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
3915 signal (SIGTERM
, fatal_error
);
3917 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
3918 signal (SIGPIPE
, fatal_error
);
3922 argbuf
= (char **) xmalloc (argbuf_length
* sizeof (char *));
3924 obstack_init (&obstack
);
3926 /* Set up to remember the pathname of gcc and any options
3927 needed for collect. We use argv[0] instead of programname because
3928 we need the complete pathname. */
3929 obstack_init (&collect_obstack
);
3930 obstack_grow (&collect_obstack
, "COLLECT_GCC=", sizeof ("COLLECT_GCC=")-1);
3931 obstack_grow (&collect_obstack
, argv
[0], strlen (argv
[0])+1);
3932 putenv (obstack_finish (&collect_obstack
));
3934 /* Choose directory for temp files. */
3936 choose_temp_base ();
3938 /* Make a table of what switches there are (switches, n_switches).
3939 Make a table of specified input files (infiles, n_infiles).
3940 Decode switches that are handled locally. */
3942 process_command (argc
, argv
);
3944 /* Initialize the vector of specs to just the default.
3945 This means one element containing 0s, as a terminator. */
3947 compilers
= (struct compiler
*) xmalloc (sizeof default_compilers
);
3948 bcopy (default_compilers
, compilers
, sizeof default_compilers
);
3949 n_compilers
= n_default_compilers
;
3951 /* Read specs from a file if there is one. */
3953 machine_suffix
= concat (spec_machine
, "/", concat (spec_version
, "/", ""));
3954 just_machine_suffix
= concat (spec_machine
, "/", "");
3956 specs_file
= find_a_file (&startfile_prefix
, "specs", R_OK
);
3957 /* Read the specs file unless it is a default one. */
3958 if (specs_file
!= 0 && strcmp (specs_file
, "specs"))
3959 read_specs (specs_file
);
3961 /* If not cross-compiling, look for startfiles in the standard places. */
3962 /* The fact that these are done here, after reading the specs file,
3963 means that it cannot be found in these directories.
3964 But that's okay. It should never be there anyway. */
3967 #ifdef MD_EXEC_PREFIX
3968 add_prefix (&exec_prefix
, md_exec_prefix
, 0, 0, NULL_PTR
);
3969 add_prefix (&startfile_prefix
, md_exec_prefix
, 0, 0, NULL_PTR
);
3972 #ifdef MD_STARTFILE_PREFIX
3973 add_prefix (&startfile_prefix
, md_startfile_prefix
, 0, 0, NULL_PTR
);
3976 #ifdef MD_STARTFILE_PREFIX_1
3977 add_prefix (&startfile_prefix
, md_startfile_prefix_1
, 0, 0, NULL_PTR
);
3980 /* If standard_startfile_prefix is relative, base it on
3981 standard_exec_prefix. This lets us move the installed tree
3982 as a unit. If GCC_EXEC_PREFIX is defined, base
3983 standard_startfile_prefix on that as well. */
3984 if (*standard_startfile_prefix
== '/')
3985 add_prefix (&startfile_prefix
, standard_startfile_prefix
, 0, 0,
3989 if (gcc_exec_prefix
)
3990 add_prefix (&startfile_prefix
,
3991 concat (gcc_exec_prefix
,
3992 standard_startfile_prefix
,
3995 add_prefix (&startfile_prefix
,
3996 concat (standard_exec_prefix
,
3998 standard_startfile_prefix
),
4002 add_prefix (&startfile_prefix
, standard_startfile_prefix_1
, 0, 0,
4004 add_prefix (&startfile_prefix
, standard_startfile_prefix_2
, 0, 0,
4006 #if 0 /* Can cause surprises, and one can use -B./ instead. */
4007 add_prefix (&startfile_prefix
, "./", 0, 1, NULL_PTR
);
4011 /* Now we have the specs.
4012 Set the `valid' bits for switches that match anything in any spec. */
4014 validate_all_switches ();
4016 /* Warn about any switches that no pass was interested in. */
4018 for (i
= 0; i
< n_switches
; i
++)
4019 if (! switches
[i
].valid
)
4020 error ("unrecognized option `-%s'", switches
[i
].part1
);
4022 /* Obey some of the options. */
4024 if (print_file_name
)
4026 printf ("%s\n", find_file (print_file_name
));
4030 if (print_prog_name
)
4032 char *newname
= find_a_file (&exec_prefix
, print_prog_name
, X_OK
);
4033 printf ("%s\n", (newname
? newname
: print_prog_name
));
4039 fprintf (stderr
, "gcc version %s\n", version_string
);
4045 fatal ("No input files");
4047 /* Make a place to record the compiler output file names
4048 that correspond to the input files. */
4050 outfiles
= (char **) xmalloc (n_infiles
* sizeof (char *));
4051 bzero (outfiles
, n_infiles
* sizeof (char *));
4053 /* Record which files were specified explicitly as link input. */
4055 explicit_link_files
= xmalloc (n_infiles
);
4056 bzero (explicit_link_files
, n_infiles
);
4058 for (i
= 0; i
< n_infiles
; i
++)
4060 register struct compiler
*cp
= 0;
4061 int this_file_error
= 0;
4063 /* Tell do_spec what to substitute for %i. */
4065 input_filename
= infiles
[i
].name
;
4066 input_filename_length
= strlen (input_filename
);
4067 input_file_number
= i
;
4069 /* Use the same thing in %o, unless cp->spec says otherwise. */
4071 outfiles
[i
] = input_filename
;
4073 /* Figure out which compiler from the file's suffix. */
4075 cp
= lookup_compiler (infiles
[i
].name
, input_filename_length
,
4076 infiles
[i
].language
);
4080 /* Ok, we found an applicable compiler. Run its spec. */
4081 /* First say how much of input_filename to substitute for %b */
4085 input_basename
= input_filename
;
4086 for (p
= input_filename
; *p
; p
++)
4088 input_basename
= p
+ 1;
4090 /* Find a suffix starting with the last period,
4091 and set basename_length to exclude that suffix. */
4092 basename_length
= strlen (input_basename
);
4093 p
= input_basename
+ basename_length
;
4094 while (p
!= input_basename
&& *p
!= '.') --p
;
4095 if (*p
== '.' && p
!= input_basename
)
4097 basename_length
= p
- input_basename
;
4098 input_suffix
= p
+ 1;
4104 for (j
= 0; j
< sizeof cp
->spec
/ sizeof cp
->spec
[0]; j
++)
4106 len
+= strlen (cp
->spec
[j
]);
4108 p
= (char *) xmalloc (len
+ 1);
4111 for (j
= 0; j
< sizeof cp
->spec
/ sizeof cp
->spec
[0]; j
++)
4114 strcpy (p
+ len
, cp
->spec
[j
]);
4115 len
+= strlen (cp
->spec
[j
]);
4118 value
= do_spec (p
);
4121 this_file_error
= 1;
4124 /* If this file's name does not contain a recognized suffix,
4125 record it as explicit linker input. */
4128 explicit_link_files
[i
] = 1;
4130 /* Clear the delete-on-failure queue, deleting the files in it
4131 if this compilation failed. */
4133 if (this_file_error
)
4135 delete_failure_queue ();
4138 /* If this compilation succeeded, don't delete those files later. */
4139 clear_failure_queue ();
4142 /* Run ld to link all the compiler output files. */
4144 if (error_count
== 0)
4146 int tmp
= execution_count
;
4150 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
4152 putenv_from_prefixes (&exec_prefix
, "COMPILER_PATH=");
4153 putenv_from_prefixes (&startfile_prefix
, "LIBRARY_PATH=");
4155 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4157 obstack_grow (&collect_obstack
, "COLLECT_GCC_OPTIONS=",
4158 sizeof ("COLLECT_GCC_OPTIONS=")-1);
4161 for (i
= 0; i
< n_switches
; i
++)
4165 obstack_grow (&collect_obstack
, " ", 1);
4168 obstack_grow (&collect_obstack
, "-", 1);
4169 obstack_grow (&collect_obstack
, switches
[i
].part1
,
4170 strlen (switches
[i
].part1
));
4172 for (args
= switches
[i
].args
; args
&& *args
; args
++)
4174 obstack_grow (&collect_obstack
, " ", 1);
4175 obstack_grow (&collect_obstack
, *args
, strlen (*args
));
4178 obstack_grow (&collect_obstack
, "\0", 1);
4179 putenv (obstack_finish (&collect_obstack
));
4181 value
= do_spec (link_command_spec
);
4184 linker_was_run
= (tmp
!= execution_count
);
4187 /* Warn if a -B option was specified but the prefix was never used. */
4188 unused_prefix_warnings (&exec_prefix
);
4189 unused_prefix_warnings (&startfile_prefix
);
4191 /* If options said don't run linker,
4192 complain about input files to be given to the linker. */
4194 if (! linker_was_run
&& error_count
== 0)
4195 for (i
= 0; i
< n_infiles
; i
++)
4196 if (explicit_link_files
[i
])
4197 error ("%s: linker input file unused since linking not done",
4200 /* Delete some or all of the temporary files we made. */
4203 delete_failure_queue ();
4204 delete_temp_files ();
4206 exit (error_count
> 0 ? (signal_count
? 2 : 1) : 0);
4211 /* Find the proper compilation spec for the file name NAME,
4212 whose length is LENGTH. LANGUAGE is the specified language,
4213 or 0 if none specified. */
4215 static struct compiler
*
4216 lookup_compiler (name
, length
, language
)
4221 struct compiler
*cp
;
4223 /* Look for the language, if one is spec'd. */
4226 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
4230 if (cp
->suffix
[0] == '@'
4231 && !strcmp (cp
->suffix
+ 1, language
))
4235 error ("language %s not recognized", language
);
4238 /* Look for a suffix. */
4239 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
4241 if (/* The suffix `-' matches only the file name `-'. */
4242 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
4244 (strlen (cp
->suffix
) < length
4245 /* See if the suffix matches the end of NAME. */
4246 && !strcmp (cp
->suffix
,
4247 name
+ length
- strlen (cp
->suffix
))))
4249 if (cp
->spec
[0][0] == '@')
4251 struct compiler
*new;
4252 /* An alias entry maps a suffix to a language.
4253 Search for the language; pass 0 for NAME and LENGTH
4254 to avoid infinite recursion if language not found.
4255 Construct the new compiler spec. */
4256 language
= cp
->spec
[0] + 1;
4257 new = (struct compiler
*) xmalloc (sizeof (struct compiler
));
4258 new->suffix
= cp
->suffix
;
4259 bcopy (lookup_compiler (NULL_PTR
, 0, language
)->spec
,
4260 new->spec
, sizeof new->spec
);
4263 /* A non-alias entry: return it. */
4275 register char *value
= (char *) malloc (size
);
4277 fatal ("virtual memory exhausted");
4282 xrealloc (ptr
, size
)
4286 register char *value
= (char *) realloc (ptr
, size
);
4288 fatal ("virtual memory exhausted");
4292 /* Return a newly-allocated string whose contents concatenate those of s1, s2, s3. */
4298 int len1
= strlen (s1
), len2
= strlen (s2
), len3
= strlen (s3
);
4299 char *result
= xmalloc (len1
+ len2
+ len3
+ 1);
4301 strcpy (result
, s1
);
4302 strcpy (result
+ len1
, s2
);
4303 strcpy (result
+ len1
+ len2
, s3
);
4304 *(result
+ len1
+ len2
+ len3
) = 0;
4310 save_string (s
, len
)
4314 register char *result
= xmalloc (len
+ 1);
4316 bcopy (s
, result
, len
);
4322 pfatal_with_name (name
)
4327 if (errno
< sys_nerr
)
4328 s
= concat ("%s: ", sys_errlist
[errno
], "");
4330 s
= "cannot open %s";
4335 perror_with_name (name
)
4340 if (errno
< sys_nerr
)
4341 s
= concat ("%s: ", sys_errlist
[errno
], "");
4343 s
= "cannot open %s";
4353 if (errno
< sys_nerr
)
4354 s
= concat ("installation problem, cannot exec %s: ",
4355 sys_errlist
[errno
], "");
4357 s
= "installation problem, cannot exec %s";
4361 /* More 'friendly' abort that prints the line and file.
4362 config.h can #define abort fancy_abort if you like that sort of thing. */
4367 fatal ("Internal gcc abort.");
4372 /* Output an error message and exit */
4375 fatal
VPROTO((char *format
, ...))
4382 VA_START (ap
, format
);
4385 format
= va_arg (ap
, char*);
4388 fprintf (stderr
, "%s: ", programname
);
4389 vfprintf (stderr
, format
, ap
);
4391 fprintf (stderr
, "\n");
4392 delete_temp_files ();
4397 error
VPROTO((char *format
, ...))
4404 VA_START (ap
, format
);
4407 format
= va_arg (ap
, char*);
4410 fprintf (stderr
, "%s: ", programname
);
4411 vfprintf (stderr
, format
, ap
);
4414 fprintf (stderr
, "\n");
4417 #else /* not HAVE_VPRINTF */
4420 fatal (msg
, arg1
, arg2
)
4421 char *msg
, *arg1
, *arg2
;
4423 error (msg
, arg1
, arg2
);
4424 delete_temp_files ();
4429 error (msg
, arg1
, arg2
)
4430 char *msg
, *arg1
, *arg2
;
4432 fprintf (stderr
, "%s: ", programname
);
4433 fprintf (stderr
, msg
, arg1
, arg2
);
4434 fprintf (stderr
, "\n");
4437 #endif /* not HAVE_VPRINTF */
4441 validate_all_switches ()
4443 struct compiler
*comp
;
4446 struct spec_list
*spec
;
4448 for (comp
= compilers
; comp
->spec
[0]; comp
++)
4451 for (i
= 0; i
< sizeof comp
->spec
/ sizeof comp
->spec
[0] && comp
->spec
[i
]; i
++)
4455 if (c
== '%' && *p
== '{')
4456 /* We have a switch spec. */
4457 validate_switches (p
+ 1);
4461 /* look through the linked list of extra specs read from the specs file */
4462 for (spec
= specs
; spec
; spec
= spec
->next
)
4466 if (c
== '%' && *p
== '{')
4467 /* We have a switch spec. */
4468 validate_switches (p
+ 1);
4471 p
= link_command_spec
;
4473 if (c
== '%' && *p
== '{')
4474 /* We have a switch spec. */
4475 validate_switches (p
+ 1);
4477 /* Now notice switches mentioned in the machine-specific specs. */
4481 if (c
== '%' && *p
== '{')
4482 /* We have a switch spec. */
4483 validate_switches (p
+ 1);
4487 if (c
== '%' && *p
== '{')
4488 /* We have a switch spec. */
4489 validate_switches (p
+ 1);
4493 if (c
== '%' && *p
== '{')
4494 /* We have a switch spec. */
4495 validate_switches (p
+ 1);
4497 p
= signed_char_spec
;
4499 if (c
== '%' && *p
== '{')
4500 /* We have a switch spec. */
4501 validate_switches (p
+ 1);
4505 if (c
== '%' && *p
== '{')
4506 /* We have a switch spec. */
4507 validate_switches (p
+ 1);
4511 if (c
== '%' && *p
== '{')
4512 /* We have a switch spec. */
4513 validate_switches (p
+ 1);
4517 if (c
== '%' && *p
== '{')
4518 /* We have a switch spec. */
4519 validate_switches (p
+ 1);
4523 if (c
== '%' && *p
== '{')
4524 /* We have a switch spec. */
4525 validate_switches (p
+ 1);
4529 if (c
== '%' && *p
== '{')
4530 /* We have a switch spec. */
4531 validate_switches (p
+ 1);
4534 /* Look at the switch-name that comes after START
4535 and mark as valid all supplied switches that match it. */
4538 validate_switches (start
)
4541 register char *p
= start
;
4556 while (*p
!= ':' && *p
!= '}') p
++;
4560 else if (p
[-1] == '*')
4562 /* Mark all matching switches as valid. */
4564 for (i
= 0; i
< n_switches
; i
++)
4565 if (!strncmp (switches
[i
].part1
, filter
, p
- filter
))
4566 switches
[i
].valid
= 1;
4570 /* Mark an exact matching switch as valid. */
4571 for (i
= 0; i
< n_switches
; i
++)
4573 if (!strncmp (switches
[i
].part1
, filter
, p
- filter
)
4574 && switches
[i
].part1
[p
- filter
] == 0)
4575 switches
[i
].valid
= 1;