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 void delete_if_ordinary
PROTO((char *));
211 static void delete_temp_files
PROTO((void));
212 static void delete_failure_queue
PROTO((void));
213 static void clear_failure_queue
PROTO((void));
214 static char *choose_temp_base_try
PROTO((char *, char *));
215 static void choose_temp_base
PROTO((void));
216 static int check_live_switch
PROTO((int, int));
217 static char *handle_braces
PROTO((char *));
218 static char *save_string
PROTO((char *, int));
219 static char *concat
PROTO((char *, char *, char *));
220 static int do_spec
PROTO((char *));
221 static int do_spec_1
PROTO((char *, int, char *));
222 static char *find_file
PROTO((char *));
223 static int is_directory
PROTO((char *, char *, int));
224 static void validate_switches
PROTO((char *));
225 static void validate_all_switches
PROTO((void));
226 static void give_switch
PROTO((int, int));
227 static void pfatal_with_name
PROTO((char *));
228 static void perror_with_name
PROTO((char *));
229 static void perror_exec
PROTO((char *));
231 static void fatal
PVPROTO((char *, ...));
232 static void error
PVPROTO((char *, ...));
234 /* We must not provide any prototype here, even if ANSI C. */
235 static void fatal
PROTO(());
236 static void error
PROTO(());
243 /* Specs are strings containing lines, each of which (if not blank)
244 is made up of a program name, and arguments separated by spaces.
245 The program name must be exact and start from root, since no path
246 is searched and it is unreliable to depend on the current working directory.
247 Redirection of input or output is not supported; the subprograms must
248 accept filenames saying what files to read and write.
250 In addition, the specs can contain %-sequences to substitute variable text
251 or for conditional text. Here is a table of all defined %-sequences.
252 Note that spaces are not generated automatically around the results of
253 expanding these sequences; therefore, you can concatenate them together
254 or with constant text in a single argument.
256 %% substitute one % into the program name or argument.
257 %i substitute the name of the input file being processed.
258 %b substitute the basename of the input file being processed.
259 This is the substring up to (and not including) the last period
260 and not including the directory.
261 %g substitute the temporary-file-name-base. This is a string chosen
262 once per compilation. Different temporary file names are made by
263 concatenation of constant strings on the end, as in `%g.s'.
264 %g also has the same effect of %d.
265 %u like %g, but make the temporary file name unique.
266 %U returns the last file name generated with %u.
267 %d marks the argument containing or following the %d as a
268 temporary file name, so that that file will be deleted if CC exits
269 successfully. Unlike %g, this contributes no text to the argument.
270 %w marks the argument containing or following the %w as the
271 "output file" of this compilation. This puts the argument
272 into the sequence of arguments that %o will substitute later.
274 like %{...} but mark last argument supplied within
275 as a file to be deleted on failure.
276 %o substitutes the names of all the output files, with spaces
277 automatically placed around them. You should write spaces
278 around the %o as well or the results are undefined.
279 %o is for use in the specs for running the linker.
280 Input files whose names have no recognized suffix are not compiled
281 at all, but they are included among the output files, so they will
283 %p substitutes the standard macro predefinitions for the
284 current target machine. Use this when running cpp.
285 %P like %p, but puts `__' before and after the name of each macro.
286 (Except macros that already have __.)
288 %I Substitute a -iprefix option made from GCC_EXEC_PREFIX.
289 %s current argument is the name of a library or startup file of some sort.
290 Search for that file in a standard list of directories
291 and substitute the full name found.
292 %eSTR Print STR as an error message. STR is terminated by a newline.
293 Use this when inconsistent options are detected.
294 %x{OPTION} Accumulate an option for %X.
295 %X Output the accumulated linker options specified by compilations.
296 %Y Output the accumulated assembler options specified by compilations.
297 %v1 Substitute the major version number of GCC.
298 (For version 2.5.n, this is 2.)
299 %v2 Substitute the minor version number of GCC.
300 (For version 2.5.n, this is 5.)
301 %a process ASM_SPEC as a spec.
302 This allows config.h to specify part of the spec for running as.
303 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
304 used here. This can be used to run a post-processor after the
305 assembler has done it's job.
306 %D Dump out a -L option for each directory in startfile_prefix.
307 %l process LINK_SPEC as a spec.
308 %L process LIB_SPEC as a spec.
309 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
310 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
311 %c process SIGNED_CHAR_SPEC as a spec.
312 %C process CPP_SPEC as a spec. A capital C is actually used here.
313 %1 process CC1_SPEC as a spec.
314 %2 process CC1PLUS_SPEC as a spec.
315 %| output "-" if the input for the current command is coming from a pipe.
316 %* substitute the variable part of a matched option. (See below.)
317 Note that each comma in the substituted string is replaced by
319 %{S} substitutes the -S switch, if that switch was given to CC.
320 If that switch was not specified, this substitutes nothing.
321 Here S is a metasyntactic variable.
322 %{S*} substitutes all the switches specified to CC whose names start
323 with -S. This is used for -o, -D, -I, etc; switches that take
324 arguments. CC considers `-o foo' as being one switch whose
325 name starts with `o'. %{o*} would substitute this text,
326 including the space; thus, two arguments would be generated.
327 %{S*:X} substitutes X if one or more switches whose names start with -S are
328 specified to CC. Note that the tail part of the -S option
329 (i.e. the part matched by the `*') will be substituted for each
330 occurrence of %* within X.
331 %{S:X} substitutes X, but only if the -S switch was given to CC.
332 %{!S:X} substitutes X, but only if the -S switch was NOT given to CC.
333 %{|S:X} like %{S:X}, but if no S switch, substitute `-'.
334 %{|!S:X} like %{!S:X}, but if there is an S switch, substitute `-'.
335 %{.S:X} substitutes X, but only if processing a file with suffix S.
336 %{!.S:X} substitutes X, but only if NOT processing a file with suffix S.
337 %(Spec) processes a specification defined in a specs file as *Spec:
338 %[Spec] as above, but put __ around -D arguments
340 The conditional text X in a %{S:X} or %{!S:X} construct may contain
341 other nested % constructs or spaces, or even newlines. They are
342 processed as usual, as described above.
344 The -O, -f, -m, and -W switches are handled specifically in these
345 constructs. If another value of -O or the negated form of a -f, -m, or
346 -W switch is found later in the command line, the earlier switch
347 value is ignored, except with {S*} where S is just one letter; this
348 passes all matching options.
350 The character | is used to indicate that a command should be piped to
351 the following command, but only if -pipe is specified.
353 Note that it is built into CC which switches take arguments and which
354 do not. You might think it would be useful to generalize this to
355 allow each compiler's spec to say which switches take arguments. But
356 this cannot be done in a consistent fashion. CC cannot even decide
357 which input files have been specified without knowing which switches
358 take arguments, and it must know which input files to compile in order
359 to tell which compilers to run.
361 CC also knows implicitly that arguments starting in `-l' are to be
362 treated as compiler output files, and passed to the linker in their
363 proper position among the other output files. */
365 /* Define the macros used for specs %a, %l, %L, %S, %c, %C, %1. */
367 /* config.h can define ASM_SPEC to provide extra args to the assembler
368 or extra switch-translations. */
373 /* config.h can define ASM_FINAL_SPEC to run a post processor after
374 the assembler has run. */
375 #ifndef ASM_FINAL_SPEC
376 #define ASM_FINAL_SPEC ""
379 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
380 or extra switch-translations. */
385 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
386 or extra switch-translations. */
391 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
392 or extra switch-translations. */
394 #define CC1PLUS_SPEC ""
397 /* config.h can define LINK_SPEC to provide extra args to the linker
398 or extra switch-translations. */
403 /* config.h can define LIB_SPEC to override the default libraries. */
405 #define LIB_SPEC "%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}"
408 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
409 #ifndef STARTFILE_SPEC
410 #define STARTFILE_SPEC \
411 "%{pg:gcrt0.o%s}%{!pg:%{p:mcrt0.o%s}%{!p:crt0.o%s}}"
414 /* config.h can define SWITCHES_NEED_SPACES to control passing -o and -L.
415 Make the string nonempty to require spaces there. */
416 #ifndef SWITCHES_NEED_SPACES
417 #define SWITCHES_NEED_SPACES ""
420 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
422 #define ENDFILE_SPEC ""
425 /* This spec is used for telling cpp whether char is signed or not. */
426 #ifndef SIGNED_CHAR_SPEC
427 /* Use #if rather than ?:
428 because MIPS C compiler rejects like ?: in initializers. */
429 #if DEFAULT_SIGNED_CHAR
430 #define SIGNED_CHAR_SPEC "%{funsigned-char:-D__CHAR_UNSIGNED__}"
432 #define SIGNED_CHAR_SPEC "%{!fsigned-char:-D__CHAR_UNSIGNED__}"
436 static char *cpp_spec
= CPP_SPEC
;
437 static char *cpp_predefines
= CPP_PREDEFINES
;
438 static char *cc1_spec
= CC1_SPEC
;
439 static char *cc1plus_spec
= CC1PLUS_SPEC
;
440 static char *signed_char_spec
= SIGNED_CHAR_SPEC
;
441 static char *asm_spec
= ASM_SPEC
;
442 static char *asm_final_spec
= ASM_FINAL_SPEC
;
443 static char *link_spec
= LINK_SPEC
;
444 static char *lib_spec
= LIB_SPEC
;
445 static char *endfile_spec
= ENDFILE_SPEC
;
446 static char *startfile_spec
= STARTFILE_SPEC
;
447 static char *switches_need_spaces
= SWITCHES_NEED_SPACES
;
449 /* This defines which switch letters take arguments. */
451 #ifndef SWITCH_TAKES_ARG
452 #define SWITCH_TAKES_ARG(CHAR) \
453 ((CHAR) == 'D' || (CHAR) == 'U' || (CHAR) == 'o' \
454 || (CHAR) == 'e' || (CHAR) == 'T' || (CHAR) == 'u' \
455 || (CHAR) == 'I' || (CHAR) == 'm' \
456 || (CHAR) == 'L' || (CHAR) == 'A')
459 /* This defines which multi-letter switches take arguments. */
461 #define DEFAULT_WORD_SWITCH_TAKES_ARG(STR) \
462 (!strcmp (STR, "Tdata") || !strcmp (STR, "Ttext") \
463 || !strcmp (STR, "Tbss") || !strcmp (STR, "include") \
464 || !strcmp (STR, "imacros") || !strcmp (STR, "aux-info") \
465 || !strcmp (STR, "idirafter") || !strcmp (STR, "iprefix") \
466 || !strcmp (STR, "iwithprefix") || !strcmp (STR, "iwithprefixbefore"))
468 #ifndef WORD_SWITCH_TAKES_ARG
469 #define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR)
472 /* Record the mapping from file suffixes for compilation specs. */
476 char *suffix
; /* Use this compiler for input files
477 whose names end in this suffix. */
479 char *spec
[4]; /* To use this compiler, concatenate these
480 specs and pass to do_spec. */
483 /* Pointer to a vector of `struct compiler' that gives the spec for
484 compiling a file, based on its suffix.
485 A file that does not end in any of these suffixes will be passed
486 unchanged to the loader and nothing else will be done to it.
488 An entry containing two 0s is used to terminate the vector.
490 If multiple entries match a file, the last matching one is used. */
492 static struct compiler
*compilers
;
494 /* Number of entries in `compilers', not counting the null terminator. */
496 static int n_compilers
;
498 /* The default list of file name suffixes and their compilation specs. */
500 static struct compiler default_compilers
[] =
504 "cpp -lang-c %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
505 %{C:%{!E:%eGNU C does not support -C without using -E}}\
506 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
507 -undef -D__GNUC__=%v1 -D__GNUC_MINOR__=%v2\
508 %{ansi:-trigraphs -$ -D__STRICT_ANSI__}\
509 %{!undef:%{!ansi:%p} %P} %{trigraphs} \
510 %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\
511 %{traditional-cpp:-traditional}\
512 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
513 %i %{!M:%{!MM:%{!E:%{!pipe:%g.i}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
514 "%{!M:%{!MM:%{!E:cc1 %{!pipe:%g.i} %1 \
515 %{!Q:-quiet} -dumpbase %b.c %{d*} %{m*} %{a}\
516 %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi} \
517 %{traditional} %{v:-version} %{pg:-p} %{p} %{f*}\
519 %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
520 %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
521 %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
522 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
523 %{!pipe:%g.s} %A\n }}}}"},
525 "%{E:cpp -lang-c %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
526 %{C:%{!E:%eGNU C does not support -C without using -E}}\
527 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
528 -undef -D__GNUC__=%v1 -D__GNUC_MINOR__=%v2\
529 %{ansi:-trigraphs -$ -D__STRICT_ANSI__}\
530 %{!undef:%{!ansi:%p} %P} %{trigraphs}\
531 %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\
532 %{traditional-cpp:-traditional}\
533 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
535 %{!E:%e-E required when input is from standard input}"},
536 {".m", "@objective-c"},
538 "cpp -lang-objc %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
539 %{C:%{!E:%eGNU C does not support -C without using -E}}\
540 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
541 -undef -D__OBJC__ -D__GNUC__=%v1 -D__GNUC_MINOR__=%v2\
542 %{ansi:-trigraphs -$ -D__STRICT_ANSI__}\
543 %{!undef:%{!ansi:%p} %P} %{trigraphs}\
544 %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\
545 %{traditional-cpp:-traditional}\
546 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
547 %i %{!M:%{!MM:%{!E:%{!pipe:%g.i}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
548 "%{!M:%{!MM:%{!E:cc1obj %{!pipe:%g.i} %1 \
549 %{!Q:-quiet} -dumpbase %b.m %{d*} %{m*} %{a}\
550 %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi} \
551 %{traditional} %{v:-version} %{pg:-p} %{p} %{f*} \
552 -lang-objc %{gen-decls} \
554 %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
555 %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
556 %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
557 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
558 %{!pipe:%g.s} %A\n }}}}"},
561 "%{!E:%eCompilation of header file requested} \
562 cpp %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
563 %{C:%{!E:%eGNU C does not support -C without using -E}}\
564 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
565 -undef -D__GNUC__=%v1 -D__GNUC_MINOR__=%v2\
566 %{ansi:-trigraphs -$ -D__STRICT_ANSI__}\
567 %{!undef:%{!ansi:%p} %P} %{trigraphs}\
568 %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\
569 %{traditional-cpp:-traditional}\
570 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
577 "cpp -lang-c++ %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
578 %{C:%{!E:%eGNU C++ does not support -C without using -E}}\
579 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
580 -undef -D__GNUC__=%v1 -D__GNUG__=%v1 -D__cplusplus -D__GNUC_MINOR__=%v2\
581 %{ansi:-trigraphs -$ -D__STRICT_ANSI__} %{!undef:%{!ansi:%p} %P}\
582 %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\
583 %{traditional-cpp:-traditional} %{trigraphs}\
584 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
585 %i %{!M:%{!MM:%{!E:%{!pipe:%g.ii}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
586 "%{!M:%{!MM:%{!E:cc1plus %{!pipe:%g.ii} %1 %2\
587 %{!Q:-quiet} -dumpbase %b.cc %{d*} %{m*} %{a}\
588 %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi}\
589 %{traditional} %{v:-version} %{pg:-p} %{p}\
590 %{f*} %{+e*} %{aux-info*}\
591 %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
592 %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}}|\n\
593 %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
594 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
595 %{!pipe:%g.s} %A\n }}}}"},
596 {".i", "@cpp-output"},
598 "%{!M:%{!MM:%{!E:cc1 %i %1 %{!Q:-quiet} %{d*} %{m*} %{a}\
599 %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi}\
600 %{traditional} %{v:-version} %{pg:-p} %{p} %{f*}\
602 %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
603 %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
604 %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
605 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
606 %{!pipe:%g.s} %A\n }}}}"},
607 {".ii", "@c++-cpp-output"},
609 "%{!M:%{!MM:%{!E:cc1plus %i %1 %2 %{!Q:-quiet} %{d*} %{m*} %{a}\
610 %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi}\
611 %{traditional} %{v:-version} %{pg:-p} %{p}\
612 %{f*} %{+e*} %{aux-info*}\
613 %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
614 %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
615 %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
616 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
617 %{!pipe:%g.s} %A\n }}}}"},
618 {".s", "@assembler"},
620 "%{!M:%{!MM:%{!E:%{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
621 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
623 {".S", "@assembler-with-cpp"},
624 {"@assembler-with-cpp",
625 "cpp -lang-asm %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
626 %{C:%{!E:%eGNU C does not support -C without using -E}}\
627 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG} %{trigraphs}\
628 -undef -$ %{!undef:%p %P} -D__ASSEMBLER__ \
629 %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\
630 %{traditional-cpp:-traditional}\
631 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
632 %i %{!M:%{!MM:%{!E:%{!pipe:%g.s}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
633 "%{!M:%{!MM:%{!E:%{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
634 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
635 %{!pipe:%g.s} %A\n }}}}"},
640 "%{!M:%{!MM:%{!E:gnat1 %{k8:-gnatk8} %{w:-gnatws} %{!Q:-quiet}\
641 -dumpbase %b.ada %{g*} %{O*} %{p} %{pg:-p} %{f*}\
643 %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
644 %i %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
645 %{!S:%{!gnatc:%{!gnats:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
646 %{c:%W{o*}%{!o*:-o %w%b.o}}\
647 %{!c:-o %d%w%u.o} %{!pipe:%g.s} %A\n}}}}}} "},
648 /* Mark end of table */
652 /* Number of elements in default_compilers, not counting the terminator. */
654 static int n_default_compilers
655 = (sizeof default_compilers
/ sizeof (struct compiler
)) - 1;
657 /* Here is the spec for running the linker, after compiling all files. */
659 /* -u* was put back because both BSD and SysV seem to support it. */
660 /* %{static:} simply prevents an error message if the target machine
661 doesn't handle -static. */
662 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
663 scripts which exist in user specified directories, or in standard
665 #ifdef LINK_LIBGCC_SPECIAL_1
666 /* Have gcc do the search for libgcc.a, but generate -L options as usual. */
667 static char *link_command_spec
= "\
669 %{!c:%{!M:%{!MM:%{!E:%{!S:ld %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} \
670 %{r} %{s} %{t} %{u*} %{x} %{z} %{Z}\
671 %{!A:%{!nostartfiles:%{!nostdlib:%S}}} %{static:}\
672 %{L*} %D %{T*} %o %{!nostdlib:libgcc.a%s %L libgcc.a%s %{!A:%E}}\n }}}}}}";
674 #ifdef LINK_LIBGCC_SPECIAL
675 /* Have gcc do the search for libgcc.a, and don't generate -L options. */
676 static char *link_command_spec
= "\
678 %{!c:%{!M:%{!MM:%{!E:%{!S:ld %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} \
679 %{r} %{s} %{t} %{u*} %{x} %{z} %{Z}\
680 %{!A:%{!nostartfiles:%{!nostdlib:%S}}} %{static:}\
681 %{L*} %{T*} %o %{!nostdlib:libgcc.a%s %L libgcc.a%s %{!A:%E}}\n }}}}}}";
683 /* Use -L and have the linker do the search for -lgcc. */
684 static char *link_command_spec
= "\
686 %{!c:%{!M:%{!MM:%{!E:%{!S:ld %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} \
687 %{r} %{s} %{t} %{u*} %{x} %{z} %{Z}\
688 %{!A:%{!nostartfiles:%{!nostdlib:%S}}} %{static:}\
689 %{L*} %D %{T*} %o %{!nostdlib:-lgcc %L -lgcc %{!A:%E}}\n }}}}}}";
693 /* A vector of options to give to the linker.
694 These options are accumulated by -Xlinker and -Wl,
695 and substituted into the linker command with %X. */
696 static int n_linker_options
;
697 static char **linker_options
;
699 /* A vector of options to give to the assembler.
700 These options are accumulated by -Wa,
701 and substituted into the assembler command with %X. */
702 static int n_assembler_options
;
703 static char **assembler_options
;
705 /* Define how to map long options into short ones. */
707 /* This structure describes one mapping. */
710 /* The long option's name. */
712 /* The equivalent short option. */
714 /* Argument info. A string of flag chars; NULL equals no options.
715 a => argument required.
716 o => argument optional.
717 j => join argument to equivalent, making one word.
718 * => allow other text after NAME as an argument. */
722 /* This is the table of mappings. Mappings are tried sequentially
723 for each option encountered; the first one that matches, wins. */
725 struct option_map option_map
[] =
727 {"--profile-blocks", "-a", 0},
728 {"--target", "-b", "a"},
729 {"--compile", "-c", 0},
730 {"--dump", "-d", "a"},
731 {"--entry", "-e", 0},
732 {"--debug", "-g", "oj"},
733 {"--include", "-include", "a"},
734 {"--imacros", "-imacros", "a"},
735 {"--include-prefix", "-iprefix", "a"},
736 {"--include-directory-after", "-idirafter", "a"},
737 {"--include-with-prefix", "-iwithprefix", "a"},
738 {"--include-with-prefix-before", "-iwithprefixbefore", "a"},
739 {"--include-with-prefix-after", "-iwithprefix", "a"},
740 {"--machine-", "-m", "*j"},
741 {"--machine", "-m", "aj"},
742 {"--no-standard-includes", "-nostdinc", 0},
743 {"--no-standard-libraries", "-nostdlib", 0},
744 {"--no-precompiled-includes", "-noprecomp", 0},
745 {"--output", "-o", "a"},
746 {"--profile", "-p", 0},
747 {"--quiet", "-q", 0},
748 {"--silent", "-q", 0},
749 {"--force-link", "-u", "a"},
750 {"--verbose", "-v", 0},
751 {"--version", "-dumpversion", 0},
752 {"--no-warnings", "-w", 0},
753 {"--language", "-x", "a"},
755 {"--assert", "-A", "a"},
756 {"--prefix", "-B", "a"},
757 {"--comments", "-C", 0},
758 {"--define-macro", "-D", "a"},
759 {"--preprocess", "-E", 0},
760 {"--trace-includes", "-H", 0},
761 {"--include-directory", "-I", "a"},
762 {"--include-barrier", "-I-", 0},
763 {"--library-directory", "-L", "a"},
764 {"--dependencies", "-M", 0},
765 {"--user-dependencies", "-MM", 0},
766 {"--write-dependencies", "-MD", 0},
767 {"--write-user-dependencies", "-MMD", 0},
768 {"--print-missing-file-dependencies", "-MG", 0},
769 {"--optimize", "-O", "oj"},
770 {"--no-line-commands", "-P", 0},
771 {"--assemble", "-S", 0},
772 {"--undefine-macro", "-U", "a"},
773 {"--use-version", "-V", "a"},
774 {"--for-assembler", "-Wa", "a"},
775 {"--extra-warnings", "-W", 0},
776 {"--all-warnings", "-Wall", 0},
777 {"--warn-", "-W", "*j"},
778 {"--for-linker", "-Xlinker", "a"},
780 {"--ansi", "-ansi", 0},
781 {"--traditional", "-traditional", 0},
782 {"--traditional-cpp", "-traditional-cpp", 0},
783 {"--trigraphs", "-trigraphs", 0},
784 {"--pipe", "-pipe", 0},
785 {"--dumpbase", "-dumpbase", "a"},
786 {"--pedantic", "-pedantic", 0},
787 {"--pedantic-errors", "-pedantic-errors", 0},
788 {"--save-temps", "-save-temps", 0},
789 {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
790 {"--print-file-name", "-print-file-name=", "aj"},
791 {"--print-prog-name", "-print-prog-name=", "aj"},
792 {"--static", "-static", 0},
793 {"--shared", "-shared", 0},
794 {"--symbolic", "-symbolic", 0},
798 /* Translate the options described by *ARGCP and *ARGVP.
799 Make a new vector and store it back in *ARGVP,
800 and store its length in *ARGVC. */
803 translate_options (argcp
, argvp
)
809 char **argv
= *argvp
;
810 char **newv
= (char **) xmalloc ((argc
+ 2) * 2 * sizeof (char *));
814 newv
[newindex
++] = argv
[i
++];
818 /* Translate -- options. */
819 if (argv
[i
][0] == '-' && argv
[i
][1] == '-')
821 /* Find a mapping that applies to this option. */
822 for (j
= 0; j
< sizeof (option_map
) / sizeof (option_map
[0]); j
++)
824 int optlen
= strlen (option_map
[j
].name
);
825 int complen
= strlen (argv
[i
]);
826 char *arginfo
= option_map
[j
].arg_info
;
830 if (complen
> optlen
)
832 if (!strncmp (argv
[i
], option_map
[j
].name
, complen
))
834 int extra
= strlen (argv
[i
]) > optlen
;
839 /* If the option has an argument, accept that. */
840 if (argv
[i
][optlen
] == '=')
841 arg
= argv
[i
] + optlen
+ 1;
842 /* If this mapping allows extra text at end of name,
843 accept that as "argument". */
844 else if (index (arginfo
, '*') != 0)
845 arg
= argv
[i
] + optlen
;
846 /* Otherwise, extra text at end means mismatch.
847 Try other mappings. */
851 else if (index (arginfo
, '*') != 0)
852 error ("Incomplete `%s' option", option_map
[j
].name
);
854 /* Handle arguments. */
855 if (index (arginfo
, 'o') != 0)
860 error ("Missing argument to `%s' option",
865 else if (index (arginfo
, '*') != 0)
867 else if (index (arginfo
, 'a') == 0)
870 error ("Extraneous argument to `%s' option",
875 /* Store the translation as one argv elt or as two. */
876 if (arg
!= 0 && index (arginfo
, 'j') != 0)
877 newv
[newindex
++] = concat (option_map
[j
].equivalent
,
881 newv
[newindex
++] = option_map
[j
].equivalent
;
882 newv
[newindex
++] = arg
;
885 newv
[newindex
++] = option_map
[j
].equivalent
;
892 /* Handle old-fashioned options--just copy them through,
893 with their arguments. */
894 else if (argv
[i
][0] == '-')
896 char *p
= argv
[i
] + 1;
900 if (SWITCH_TAKES_ARG (c
) > (p
[1] != 0))
901 nskip
+= SWITCH_TAKES_ARG (c
) - (p
[1] != 0);
902 else if (WORD_SWITCH_TAKES_ARG (p
))
903 nskip
+= WORD_SWITCH_TAKES_ARG (p
);
904 else if ((c
== 'B' || c
== 'b' || c
== 'V' || c
== 'x')
907 else if (! strcmp (p
, "Xlinker"))
910 /* Watch out for an option at the end of the command line that
911 is missing arguments, and avoid skipping past the end of the
913 if (nskip
+ i
> argc
)
918 newv
[newindex
++] = argv
[i
++];
923 /* Ordinary operands, or +e options. */
924 newv
[newindex
++] = argv
[i
++];
933 /* Read compilation specs from a file named FILENAME,
934 replacing the default ones.
936 A suffix which starts with `*' is a definition for
937 one of the machine-specific sub-specs. The "suffix" should be
938 *asm, *cc1, *cpp, *link, *startfile, *signed_char, etc.
939 The corresponding spec is stored in asm_spec, etc.,
940 rather than in the `compilers' vector.
942 Anything invalid in the file is a fatal error. */
945 read_specs (filename
)
954 fprintf (stderr
, "Reading specs from %s\n", filename
);
956 /* Open and stat the file. */
957 desc
= open (filename
, 0, 0);
959 pfatal_with_name (filename
);
960 if (stat (filename
, &statbuf
) < 0)
961 pfatal_with_name (filename
);
963 /* Read contents of file into BUFFER. */
964 buffer
= xmalloc ((unsigned) statbuf
.st_size
+ 1);
965 read (desc
, buffer
, (unsigned) statbuf
.st_size
);
966 buffer
[statbuf
.st_size
] = 0;
969 /* Scan BUFFER for specs, putting them in the vector. */
975 char *in
, *out
, *p1
, *p2
;
977 /* Advance P in BUFFER to the next nonblank nocomment line. */
978 p
= skip_whitespace (p
);
982 /* Find the colon that should end the suffix. */
984 while (*p1
&& *p1
!= ':' && *p1
!= '\n') p1
++;
985 /* The colon shouldn't be missing. */
987 fatal ("specs file malformed after %d characters", p1
- buffer
);
988 /* Skip back over trailing whitespace. */
990 while (p2
> buffer
&& (p2
[-1] == ' ' || p2
[-1] == '\t')) p2
--;
991 /* Copy the suffix to a string. */
992 suffix
= save_string (p
, p2
- p
);
993 /* Find the next line. */
994 p
= skip_whitespace (p1
+ 1);
996 fatal ("specs file malformed after %d characters", p
- buffer
);
998 /* Find next blank line. */
999 while (*p1
&& !(*p1
== '\n' && p1
[1] == '\n')) p1
++;
1000 /* Specs end at the blank line and do not include the newline. */
1001 spec
= save_string (p
, p1
- p
);
1004 /* Delete backslash-newline sequences from the spec. */
1009 if (in
[0] == '\\' && in
[1] == '\n')
1011 else if (in
[0] == '#')
1013 while (*in
&& *in
!= '\n') in
++;
1020 if (suffix
[0] == '*')
1022 if (! strcmp (suffix
, "*link_command"))
1023 link_command_spec
= spec
;
1025 set_spec (suffix
+ 1, spec
);
1029 /* Add this pair to the vector. */
1031 = ((struct compiler
*)
1032 xrealloc (compilers
, (n_compilers
+ 2) * sizeof (struct compiler
)));
1033 compilers
[n_compilers
].suffix
= suffix
;
1034 bzero (compilers
[n_compilers
].spec
,
1035 sizeof compilers
[n_compilers
].spec
);
1036 compilers
[n_compilers
].spec
[0] = spec
;
1038 bzero (&compilers
[n_compilers
], sizeof compilers
[n_compilers
]);
1042 link_command_spec
= spec
;
1045 if (link_command_spec
== 0)
1046 fatal ("spec file has no spec for linking");
1055 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1056 be considered whitespace. */
1057 if (p
[0] == '\n' && p
[1] == '\n' && p
[2] == '\n')
1059 else if (*p
== '\n' || *p
== ' ' || *p
== '\t')
1063 while (*p
!= '\n') p
++;
1073 /* Structure to keep track of the specs that have been defined so far. These
1074 are accessed using %(specname) or %[specname] in a compiler or link spec. */
1078 char *name
; /* Name of the spec. */
1079 char *spec
; /* The spec itself. */
1080 struct spec_list
*next
; /* Next spec in linked list. */
1083 /* List of specs that have been defined so far. */
1085 static struct spec_list
*specs
= (struct spec_list
*) 0;
1087 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1088 removed; If the spec starts with a + then SPEC is added to the end of the
1092 set_spec (name
, spec
)
1096 struct spec_list
*sl
;
1099 /* See if the spec already exists */
1100 for (sl
= specs
; sl
; sl
= sl
->next
)
1101 if (strcmp (sl
->name
, name
) == 0)
1106 /* Not found - make it */
1107 sl
= (struct spec_list
*) xmalloc (sizeof (struct spec_list
));
1108 sl
->name
= save_string (name
, strlen (name
));
1109 sl
->spec
= save_string ("", 0);
1114 old_spec
= sl
->spec
;
1115 if (name
&& spec
[0] == '+' && isspace (spec
[1]))
1116 sl
->spec
= concat (old_spec
, spec
+ 1, "");
1118 sl
->spec
= save_string (spec
, strlen (spec
));
1120 if (! strcmp (name
, "asm"))
1121 asm_spec
= sl
->spec
;
1122 else if (! strcmp (name
, "asm_final"))
1123 asm_final_spec
= sl
->spec
;
1124 else if (! strcmp (name
, "cc1"))
1125 cc1_spec
= sl
->spec
;
1126 else if (! strcmp (name
, "cc1plus"))
1127 cc1plus_spec
= sl
->spec
;
1128 else if (! strcmp (name
, "cpp"))
1129 cpp_spec
= sl
->spec
;
1130 else if (! strcmp (name
, "endfile"))
1131 endfile_spec
= sl
->spec
;
1132 else if (! strcmp (name
, "lib"))
1133 lib_spec
= sl
->spec
;
1134 else if (! strcmp (name
, "link"))
1135 link_spec
= sl
->spec
;
1136 else if (! strcmp (name
, "predefines"))
1137 cpp_predefines
= sl
->spec
;
1138 else if (! strcmp (name
, "signed_char"))
1139 signed_char_spec
= sl
->spec
;
1140 else if (! strcmp (name
, "startfile"))
1141 startfile_spec
= sl
->spec
;
1142 else if (! strcmp (name
, "switches_need_spaces"))
1143 switches_need_spaces
= sl
->spec
;
1144 else if (! strcmp (name
, "cross_compile"))
1145 cross_compile
= atoi (sl
->spec
);
1146 /* Free the old spec */
1151 /* Accumulate a command (program name and args), and run it. */
1153 /* Vector of pointers to arguments in the current line of specifications. */
1155 static char **argbuf
;
1157 /* Number of elements allocated in argbuf. */
1159 static int argbuf_length
;
1161 /* Number of elements in argbuf currently in use (containing args). */
1163 static int argbuf_index
;
1165 /* This is the list of suffixes and codes (%g/%u/%U) and the associated
1166 temp file. Used only if MKTEMP_EACH_FILE. */
1168 static struct temp_name
{
1169 char *suffix
; /* suffix associated with the code. */
1170 int length
; /* strlen (suffix). */
1171 int unique
; /* Indicates whether %g or %u/%U was used. */
1172 char *filename
; /* associated filename. */
1173 int filename_length
; /* strlen (filename). */
1174 struct temp_name
*next
;
1177 /* Number of commands executed so far. */
1179 static int execution_count
;
1181 /* Number of commands that exited with a signal. */
1183 static int signal_count
;
1185 /* Name with which this program was invoked. */
1187 static char *programname
;
1189 /* Structures to keep track of prefixes to try when looking for files. */
1193 char *prefix
; /* String to prepend to the path. */
1194 struct prefix_list
*next
; /* Next in linked list. */
1195 int require_machine_suffix
; /* Don't use without machine_suffix. */
1196 /* 2 means try both machine_suffix and just_machine_suffix. */
1197 int *used_flag_ptr
; /* 1 if a file was found with this prefix. */
1202 struct prefix_list
*plist
; /* List of prefixes to try */
1203 int max_len
; /* Max length of a prefix in PLIST */
1204 char *name
; /* Name of this list (used in config stuff) */
1207 /* List of prefixes to try when looking for executables. */
1209 static struct path_prefix exec_prefix
= { 0, 0, "exec" };
1211 /* List of prefixes to try when looking for startup (crt0) files. */
1213 static struct path_prefix startfile_prefix
= { 0, 0, "startfile" };
1215 /* List of prefixes to try when looking for include files. */
1217 static struct path_prefix include_prefix
= { 0, 0, "include" };
1219 /* Suffix to attach to directories searched for commands.
1220 This looks like `MACHINE/VERSION/'. */
1222 static char *machine_suffix
= 0;
1224 /* Suffix to attach to directories searched for commands.
1225 This is just `MACHINE/'. */
1227 static char *just_machine_suffix
= 0;
1229 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1231 static char *gcc_exec_prefix
;
1233 /* Default prefixes to attach to command names. */
1235 #ifdef CROSS_COMPILE /* Don't use these prefixes for a cross compiler. */
1236 #undef MD_EXEC_PREFIX
1237 #undef MD_STARTFILE_PREFIX
1238 #undef MD_STARTFILE_PREFIX_1
1241 #ifndef STANDARD_EXEC_PREFIX
1242 #define STANDARD_EXEC_PREFIX "/usr/local/lib/gcc-lib/"
1243 #endif /* !defined STANDARD_EXEC_PREFIX */
1245 static char *standard_exec_prefix
= STANDARD_EXEC_PREFIX
;
1246 static char *standard_exec_prefix_1
= "/usr/lib/gcc/";
1247 #ifdef MD_EXEC_PREFIX
1248 static char *md_exec_prefix
= MD_EXEC_PREFIX
;
1251 #ifndef STANDARD_STARTFILE_PREFIX
1252 #define STANDARD_STARTFILE_PREFIX "/usr/local/lib/"
1253 #endif /* !defined STANDARD_STARTFILE_PREFIX */
1255 #ifdef MD_STARTFILE_PREFIX
1256 static char *md_startfile_prefix
= MD_STARTFILE_PREFIX
;
1258 #ifdef MD_STARTFILE_PREFIX_1
1259 static char *md_startfile_prefix_1
= MD_STARTFILE_PREFIX_1
;
1261 static char *standard_startfile_prefix
= STANDARD_STARTFILE_PREFIX
;
1262 static char *standard_startfile_prefix_1
= "/lib/";
1263 static char *standard_startfile_prefix_2
= "/usr/lib/";
1265 #ifndef TOOLDIR_BASE_PREFIX
1266 #define TOOLDIR_BASE_PREFIX "/usr/local/"
1268 static char *tooldir_base_prefix
= TOOLDIR_BASE_PREFIX
;
1269 static char *tooldir_prefix
;
1271 /* Clear out the vector of arguments (after a command is executed). */
1279 /* Add one argument to the vector at the end.
1280 This is done when a space is seen or at the end of the line.
1281 If DELETE_ALWAYS is nonzero, the arg is a filename
1282 and the file should be deleted eventually.
1283 If DELETE_FAILURE is nonzero, the arg is a filename
1284 and the file should be deleted if this compilation fails. */
1287 store_arg (arg
, delete_always
, delete_failure
)
1289 int delete_always
, delete_failure
;
1291 if (argbuf_index
+ 1 == argbuf_length
)
1293 argbuf
= (char **) xrealloc (argbuf
, (argbuf_length
*= 2) * sizeof (char *));
1296 argbuf
[argbuf_index
++] = arg
;
1297 argbuf
[argbuf_index
] = 0;
1299 if (delete_always
|| delete_failure
)
1300 record_temp_file (arg
, delete_always
, delete_failure
);
1303 /* Record the names of temporary files we tell compilers to write,
1304 and delete them at the end of the run. */
1306 /* This is the common prefix we use to make temp file names.
1307 It is chosen once for each run of this program.
1308 It is substituted into a spec by %g.
1309 Thus, all temp file names contain this prefix.
1310 In practice, all temp file names start with this prefix.
1312 This prefix comes from the envvar TMPDIR if it is defined;
1313 otherwise, from the P_tmpdir macro if that is defined;
1314 otherwise, in /usr/tmp or /tmp. */
1316 static char *temp_filename
;
1318 /* Length of the prefix. */
1320 static int temp_filename_length
;
1322 /* Define the list of temporary files to delete. */
1327 struct temp_file
*next
;
1330 /* Queue of files to delete on success or failure of compilation. */
1331 static struct temp_file
*always_delete_queue
;
1332 /* Queue of files to delete on failure of compilation. */
1333 static struct temp_file
*failure_delete_queue
;
1335 /* Record FILENAME as a file to be deleted automatically.
1336 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
1337 otherwise delete it in any case.
1338 FAIL_DELETE nonzero means delete it if a compilation step fails;
1339 otherwise delete it in any case. */
1342 record_temp_file (filename
, always_delete
, fail_delete
)
1347 register char *name
;
1348 name
= xmalloc (strlen (filename
) + 1);
1349 strcpy (name
, filename
);
1353 register struct temp_file
*temp
;
1354 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
1355 if (! strcmp (name
, temp
->name
))
1357 temp
= (struct temp_file
*) xmalloc (sizeof (struct temp_file
));
1358 temp
->next
= always_delete_queue
;
1360 always_delete_queue
= temp
;
1366 register struct temp_file
*temp
;
1367 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
1368 if (! strcmp (name
, temp
->name
))
1370 temp
= (struct temp_file
*) xmalloc (sizeof (struct temp_file
));
1371 temp
->next
= failure_delete_queue
;
1373 failure_delete_queue
= temp
;
1378 /* Delete all the temporary files whose names we previously recorded. */
1381 delete_if_ordinary (name
)
1388 printf ("Delete %s? (y or n) ", name
);
1392 while ((c
= getchar ()) != '\n' && c
!= EOF
) ;
1393 if (i
== 'y' || i
== 'Y')
1395 if (stat (name
, &st
) >= 0 && S_ISREG (st
.st_mode
))
1396 if (unlink (name
) < 0)
1398 perror_with_name (name
);
1402 delete_temp_files ()
1404 register struct temp_file
*temp
;
1406 for (temp
= always_delete_queue
; temp
; temp
= temp
->next
)
1407 delete_if_ordinary (temp
->name
);
1408 always_delete_queue
= 0;
1411 /* Delete all the files to be deleted on error. */
1414 delete_failure_queue ()
1416 register struct temp_file
*temp
;
1418 for (temp
= failure_delete_queue
; temp
; temp
= temp
->next
)
1419 delete_if_ordinary (temp
->name
);
1423 clear_failure_queue ()
1425 failure_delete_queue
= 0;
1428 /* Compute a string to use as the base of all temporary file names.
1429 It is substituted for %g. */
1432 choose_temp_base_try (try, base
)
1439 else if (try == (char *)0)
1441 else if (access (try, R_OK
| W_OK
) != 0)
1454 base
= choose_temp_base_try (getenv ("TMPDIR"), base
);
1455 base
= choose_temp_base_try (getenv ("TMP"), base
);
1456 base
= choose_temp_base_try (getenv ("TEMP"), base
);
1459 base
= choose_temp_base_try (P_tmpdir
, base
);
1462 base
= choose_temp_base_try ("/usr/tmp", base
);
1463 base
= choose_temp_base_try ("/tmp", base
);
1465 /* If all else fails, use the current directory! */
1466 if (base
== (char *)0)
1469 len
= strlen (base
);
1470 temp_filename
= xmalloc (len
+ sizeof("/ccXXXXXX") + 1);
1471 strcpy (temp_filename
, base
);
1472 if (len
> 0 && temp_filename
[len
-1] != '/')
1473 temp_filename
[len
++] = '/';
1474 strcpy (temp_filename
+ len
, "ccXXXXXX");
1476 mktemp (temp_filename
);
1477 temp_filename_length
= strlen (temp_filename
);
1478 if (temp_filename_length
== 0)
1483 /* Routine to add variables to the environment. We do this to pass
1484 the pathname of the gcc driver, and the directories search to the
1485 collect2 program, which is being run as ld. This way, we can be
1486 sure of executing the right compiler when collect2 wants to build
1487 constructors and destructors. Since the environment variables we
1488 use come from an obstack, we don't have to worry about allocating
1497 #ifndef VMS /* nor about VMS */
1499 extern char **environ
;
1500 char **old_environ
= environ
;
1504 int str_len
= strlen (str
);
1508 while ((ch
= *p
++) != '\0' && ch
!= '=')
1514 /* Search for replacing an existing environment variable, and
1515 count the number of total environment variables. */
1516 for (envp
= old_environ
; *envp
; envp
++)
1519 if (!strncmp (str
, *envp
, name_len
))
1526 /* Add a new environment variable */
1527 environ
= (char **) xmalloc (sizeof (char *) * (num_envs
+2));
1529 bcopy (old_environ
, environ
+1, sizeof (char *) * (num_envs
+1));
1534 #endif /* HAVE_PUTENV */
1537 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables for collect. */
1540 putenv_from_prefixes (paths
, env_var
)
1541 struct path_prefix
*paths
;
1544 int suffix_len
= (machine_suffix
) ? strlen (machine_suffix
) : 0;
1546 = (just_machine_suffix
) ? strlen (just_machine_suffix
) : 0;
1547 int first_time
= TRUE
;
1548 struct prefix_list
*pprefix
;
1550 obstack_grow (&collect_obstack
, env_var
, strlen (env_var
));
1552 for (pprefix
= paths
->plist
; pprefix
!= 0; pprefix
= pprefix
->next
)
1554 int len
= strlen (pprefix
->prefix
);
1557 && is_directory (pprefix
->prefix
, machine_suffix
, 0))
1560 obstack_1grow (&collect_obstack
, PATH_SEPARATOR
);
1563 obstack_grow (&collect_obstack
, pprefix
->prefix
, len
);
1564 obstack_grow (&collect_obstack
, machine_suffix
, suffix_len
);
1567 if (just_machine_suffix
1568 && pprefix
->require_machine_suffix
== 2
1569 && is_directory (pprefix
->prefix
, just_machine_suffix
, 0))
1572 obstack_1grow (&collect_obstack
, PATH_SEPARATOR
);
1575 obstack_grow (&collect_obstack
, pprefix
->prefix
, len
);
1576 obstack_grow (&collect_obstack
, just_machine_suffix
,
1580 if (!pprefix
->require_machine_suffix
)
1583 obstack_1grow (&collect_obstack
, PATH_SEPARATOR
);
1586 obstack_grow (&collect_obstack
, pprefix
->prefix
, len
);
1589 obstack_1grow (&collect_obstack
, '\0');
1590 putenv (obstack_finish (&collect_obstack
));
1594 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
1595 access to check permissions.
1596 Return 0 if not found, otherwise return its name, allocated with malloc. */
1599 find_a_file (pprefix
, name
, mode
)
1600 struct path_prefix
*pprefix
;
1605 char *file_suffix
= ((mode
& X_OK
) != 0 ? EXECUTABLE_SUFFIX
: "");
1606 struct prefix_list
*pl
;
1607 int len
= pprefix
->max_len
+ strlen (name
) + strlen (file_suffix
) + 1;
1610 len
+= strlen (machine_suffix
);
1612 temp
= xmalloc (len
);
1614 /* Determine the filename to execute (special case for absolute paths). */
1618 if (access (name
, mode
))
1620 strcpy (temp
, name
);
1625 for (pl
= pprefix
->plist
; pl
; pl
= pl
->next
)
1629 strcpy (temp
, pl
->prefix
);
1630 strcat (temp
, machine_suffix
);
1631 strcat (temp
, name
);
1632 if (access (temp
, mode
) == 0)
1634 if (pl
->used_flag_ptr
!= 0)
1635 *pl
->used_flag_ptr
= 1;
1638 /* Some systems have a suffix for executable files.
1639 So try appending that. */
1640 if (file_suffix
[0] != 0)
1642 strcat (temp
, file_suffix
);
1643 if (access (temp
, mode
) == 0)
1645 if (pl
->used_flag_ptr
!= 0)
1646 *pl
->used_flag_ptr
= 1;
1651 /* Certain prefixes are tried with just the machine type,
1652 not the version. This is used for finding as, ld, etc. */
1653 if (just_machine_suffix
&& pl
->require_machine_suffix
== 2)
1655 strcpy (temp
, pl
->prefix
);
1656 strcat (temp
, just_machine_suffix
);
1657 strcat (temp
, name
);
1658 if (access (temp
, mode
) == 0)
1660 if (pl
->used_flag_ptr
!= 0)
1661 *pl
->used_flag_ptr
= 1;
1664 /* Some systems have a suffix for executable files.
1665 So try appending that. */
1666 if (file_suffix
[0] != 0)
1668 strcat (temp
, file_suffix
);
1669 if (access (temp
, mode
) == 0)
1671 if (pl
->used_flag_ptr
!= 0)
1672 *pl
->used_flag_ptr
= 1;
1677 /* Certain prefixes can't be used without the machine suffix
1678 when the machine or version is explicitly specified. */
1679 if (!pl
->require_machine_suffix
)
1681 strcpy (temp
, pl
->prefix
);
1682 strcat (temp
, name
);
1683 if (access (temp
, mode
) == 0)
1685 if (pl
->used_flag_ptr
!= 0)
1686 *pl
->used_flag_ptr
= 1;
1689 /* Some systems have a suffix for executable files.
1690 So try appending that. */
1691 if (file_suffix
[0] != 0)
1693 strcat (temp
, file_suffix
);
1694 if (access (temp
, mode
) == 0)
1696 if (pl
->used_flag_ptr
!= 0)
1697 *pl
->used_flag_ptr
= 1;
1708 /* Add an entry for PREFIX in PLIST. If FIRST is set, it goes
1709 at the start of the list, otherwise it goes at the end.
1711 If WARN is nonzero, we will warn if no file is found
1712 through this prefix. WARN should point to an int
1713 which will be set to 1 if this entry is used.
1715 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
1716 the complete value of machine_suffix.
1717 2 means try both machine_suffix and just_machine_suffix. */
1720 add_prefix (pprefix
, prefix
, first
, require_machine_suffix
, warn
)
1721 struct path_prefix
*pprefix
;
1724 int require_machine_suffix
;
1727 struct prefix_list
*pl
, **prev
;
1730 if (!first
&& pprefix
->plist
)
1732 for (pl
= pprefix
->plist
; pl
->next
; pl
= pl
->next
)
1737 prev
= &pprefix
->plist
;
1739 /* Keep track of the longest prefix */
1741 len
= strlen (prefix
);
1742 if (len
> pprefix
->max_len
)
1743 pprefix
->max_len
= len
;
1745 pl
= (struct prefix_list
*) xmalloc (sizeof (struct prefix_list
));
1746 pl
->prefix
= save_string (prefix
, len
);
1747 pl
->require_machine_suffix
= require_machine_suffix
;
1748 pl
->used_flag_ptr
= warn
;
1755 pl
->next
= (struct prefix_list
*) 0;
1759 /* Print warnings for any prefixes in the list PPREFIX that were not used. */
1762 unused_prefix_warnings (pprefix
)
1763 struct path_prefix
*pprefix
;
1765 struct prefix_list
*pl
= pprefix
->plist
;
1769 if (pl
->used_flag_ptr
!= 0 && !*pl
->used_flag_ptr
)
1771 error ("file path prefix `%s' never used",
1773 /* Prevent duplicate warnings. */
1774 *pl
->used_flag_ptr
= 1;
1780 /* Get rid of all prefixes built up so far in *PLISTP. */
1783 free_path_prefix (pprefix
)
1784 struct path_prefix
*pprefix
;
1786 struct prefix_list
*pl
= pprefix
->plist
;
1787 struct prefix_list
*temp
;
1793 free (temp
->prefix
);
1794 free ((char *) temp
);
1796 pprefix
->plist
= (struct prefix_list
*) 0;
1799 /* stdin file number. */
1800 #define STDIN_FILE_NO 0
1802 /* stdout file number. */
1803 #define STDOUT_FILE_NO 1
1805 /* value of `pipe': port index for reading. */
1808 /* value of `pipe': port index for writing. */
1809 #define WRITE_PORT 1
1811 /* Pipe waiting from last process, to be used as input for the next one.
1812 Value is STDIN_FILE_NO if no pipe is waiting
1813 (i.e. the next command is the first of a group). */
1815 static int last_pipe_input
;
1817 /* Fork one piped subcommand. FUNC is the system call to use
1818 (either execv or execvp). ARGV is the arg vector to use.
1819 NOT_LAST is nonzero if this is not the last subcommand
1820 (i.e. its output should be piped to the next one.) */
1825 /* Declare these to avoid compilation error. They won't be called. */
1826 int execv(const char *a
, const char **b
){}
1827 int execvp(const char *a
, const char **b
){}
1830 pexecute (search_flag
, program
, argv
, not_last
)
1838 int i
, el
= search_flag
? 0 : 4;
1840 scmd
= (char *)malloc (strlen (program
) + strlen (temp_filename
) + 6 + el
);
1841 rf
= scmd
+ strlen(program
) + 2 + el
;
1842 sprintf (scmd
, "%s%s @%s.gp", program
,
1843 (search_flag
? "" : ".exe"), temp_filename
);
1844 argfile
= fopen (rf
, "w");
1846 pfatal_with_name (rf
);
1848 for (i
=1; argv
[i
]; i
++)
1851 for (cp
= argv
[i
]; *cp
; cp
++)
1853 if (*cp
== '"' || *cp
== '\'' || *cp
== '\\' || isspace (*cp
))
1854 fputc ('\\', argfile
);
1855 fputc (*cp
, argfile
);
1857 fputc ('\n', argfile
);
1867 perror_exec (program
);
1868 return MIN_FATAL_STATUS
<< 8;
1874 #else /* not __MSDOS__ */
1877 pexecute (search_flag
, program
, argv
, not_last
)
1883 int (*func
)() = (search_flag
? execv
: execvp
);
1886 int input_desc
= last_pipe_input
;
1887 int output_desc
= STDOUT_FILE_NO
;
1888 int retries
, sleep_interval
;
1890 /* If this isn't the last process, make a pipe for its output,
1891 and record it as waiting to be the input to the next process. */
1895 if (pipe (pdes
) < 0)
1896 pfatal_with_name ("pipe");
1897 output_desc
= pdes
[WRITE_PORT
];
1898 last_pipe_input
= pdes
[READ_PORT
];
1901 last_pipe_input
= STDIN_FILE_NO
;
1903 /* Fork a subprocess; wait and retry if it fails. */
1905 for (retries
= 0; retries
< 4; retries
++)
1910 sleep (sleep_interval
);
1911 sleep_interval
*= 2;
1918 pfatal_with_name ("fork");
1920 pfatal_with_name ("vfork");
1926 /* Move the input and output pipes into place, if nec. */
1927 if (input_desc
!= STDIN_FILE_NO
)
1929 close (STDIN_FILE_NO
);
1933 if (output_desc
!= STDOUT_FILE_NO
)
1935 close (STDOUT_FILE_NO
);
1937 close (output_desc
);
1940 /* Close the parent's descs that aren't wanted here. */
1941 if (last_pipe_input
!= STDIN_FILE_NO
)
1942 close (last_pipe_input
);
1944 /* Exec the program. */
1945 (*func
) (program
, argv
);
1946 perror_exec (program
);
1952 /* In the parent, after forking.
1953 Close the descriptors that we made for this child. */
1954 if (input_desc
!= STDIN_FILE_NO
)
1956 if (output_desc
!= STDOUT_FILE_NO
)
1957 close (output_desc
);
1959 /* Return child's process number. */
1964 #endif /* not __MSDOS__ */
1968 pexecute (search_flag
, program
, argv
, not_last
)
1974 return (search_flag
? spawnv
: spawnvp
) (1, program
, argv
);
1976 #endif /* not OS2 */
1978 /* Execute the command specified by the arguments on the current line of spec.
1979 When using pipes, this includes several piped-together commands
1980 with `|' between them.
1982 Return 0 if successful, -1 if failed. */
1988 int n_commands
; /* # of command. */
1992 char *prog
; /* program name. */
1993 char **argv
; /* vector of args. */
1994 int pid
; /* pid of process for this command. */
1997 struct command
*commands
; /* each command buffer with above info. */
1999 /* Count # of piped commands. */
2000 for (n_commands
= 1, i
= 0; i
< argbuf_index
; i
++)
2001 if (strcmp (argbuf
[i
], "|") == 0)
2004 /* Get storage for each command. */
2006 = (struct command
*) alloca (n_commands
* sizeof (struct command
));
2008 /* Split argbuf into its separate piped processes,
2009 and record info about each one.
2010 Also search for the programs that are to be run. */
2012 commands
[0].prog
= argbuf
[0]; /* first command. */
2013 commands
[0].argv
= &argbuf
[0];
2014 string
= find_a_file (&exec_prefix
, commands
[0].prog
, X_OK
);
2016 commands
[0].argv
[0] = string
;
2018 for (n_commands
= 1, i
= 0; i
< argbuf_index
; i
++)
2019 if (strcmp (argbuf
[i
], "|") == 0)
2020 { /* each command. */
2022 fatal ("-pipe not supported under MS-DOS");
2024 argbuf
[i
] = 0; /* termination of command args. */
2025 commands
[n_commands
].prog
= argbuf
[i
+ 1];
2026 commands
[n_commands
].argv
= &argbuf
[i
+ 1];
2027 string
= find_a_file (&exec_prefix
, commands
[n_commands
].prog
, X_OK
);
2029 commands
[n_commands
].argv
[0] = string
;
2033 argbuf
[argbuf_index
] = 0;
2035 /* If -v, print what we are about to do, and maybe query. */
2039 /* Print each piped command as a separate line. */
2040 for (i
= 0; i
< n_commands
; i
++)
2044 for (j
= commands
[i
].argv
; *j
; j
++)
2045 fprintf (stderr
, " %s", *j
);
2047 /* Print a pipe symbol after all but the last command. */
2048 if (i
+ 1 != n_commands
)
2049 fprintf (stderr
, " |");
2050 fprintf (stderr
, "\n");
2054 fprintf (stderr
, "\nGo ahead? (y or n) ");
2058 while (getchar () != '\n') ;
2059 if (i
!= 'y' && i
!= 'Y')
2064 /* Run each piped subprocess. */
2066 last_pipe_input
= STDIN_FILE_NO
;
2067 for (i
= 0; i
< n_commands
; i
++)
2069 char *string
= commands
[i
].argv
[0];
2071 commands
[i
].pid
= pexecute (string
!= commands
[i
].prog
,
2072 string
, commands
[i
].argv
,
2073 i
+ 1 < n_commands
);
2075 if (string
!= commands
[i
].prog
)
2081 /* Wait for all the subprocesses to finish.
2082 We don't care what order they finish in;
2083 we know that N_COMMANDS waits will get them all. */
2088 for (i
= 0; i
< n_commands
; i
++)
2092 char *prog
= "unknown";
2095 status
= pid
= commands
[i
].pid
;
2097 pid
= wait (&status
);
2105 for (j
= 0; j
< n_commands
; j
++)
2106 if (commands
[j
].pid
== pid
)
2107 prog
= commands
[j
].prog
;
2109 if ((status
& 0x7F) != 0)
2111 fatal ("Internal compiler error: program %s got fatal signal %d",
2112 prog
, (status
& 0x7F));
2115 if (((status
& 0xFF00) >> 8) >= MIN_FATAL_STATUS
)
2123 /* Find all the switches given to us
2124 and make a vector describing them.
2125 The elements of the vector are strings, one per switch given.
2126 If a switch uses following arguments, then the `part1' field
2127 is the switch itself and the `args' field
2128 is a null-terminated vector containing the following arguments.
2129 The `live_cond' field is 1 if the switch is true in a conditional spec,
2130 -1 if false (overridden by a later switch), and is initialized to zero.
2131 The `valid' field is nonzero if any spec has looked at this switch;
2132 if it remains zero at the end of the run, it must be meaningless. */
2142 static struct switchstr
*switches
;
2144 static int n_switches
;
2152 /* Also a vector of input files specified. */
2154 static struct infile
*infiles
;
2156 static int n_infiles
;
2158 /* And a vector of corresponding output files is made up later. */
2160 static char **outfiles
;
2162 /* Create the vector `switches' and its contents.
2163 Store its length in `n_switches'. */
2166 process_command (argc
, argv
)
2172 char *spec_lang
= 0;
2173 int last_language_n_infiles
;
2175 gcc_exec_prefix
= getenv ("GCC_EXEC_PREFIX");
2180 /* Figure compiler version from version string. */
2182 compiler_version
= save_string (version_string
, strlen (version_string
));
2183 for (temp
= compiler_version
; *temp
; ++temp
)
2192 /* Set up the default search paths. */
2194 if (gcc_exec_prefix
)
2196 add_prefix (&exec_prefix
, gcc_exec_prefix
, 0, 0, NULL_PTR
);
2197 add_prefix (&startfile_prefix
, gcc_exec_prefix
, 0, 0, NULL_PTR
);
2200 /* COMPILER_PATH and LIBRARY_PATH have values
2201 that are lists of directory names with colons. */
2203 temp
= getenv ("COMPILER_PATH");
2206 char *startp
, *endp
;
2207 char *nstore
= (char *) alloca (strlen (temp
) + 3);
2209 startp
= endp
= temp
;
2212 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
2214 strncpy (nstore
, startp
, endp
-startp
);
2217 strcpy (nstore
, "./");
2219 else if (endp
[-1] != '/')
2221 nstore
[endp
-startp
] = '/';
2222 nstore
[endp
-startp
+1] = 0;
2225 nstore
[endp
-startp
] = 0;
2226 add_prefix (&exec_prefix
, nstore
, 0, 0, NULL_PTR
);
2229 endp
= startp
= endp
+ 1;
2236 temp
= getenv ("LIBRARY_PATH");
2239 char *startp
, *endp
;
2240 char *nstore
= (char *) alloca (strlen (temp
) + 3);
2242 startp
= endp
= temp
;
2245 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
2247 strncpy (nstore
, startp
, endp
-startp
);
2250 strcpy (nstore
, "./");
2252 else if (endp
[-1] != '/')
2254 nstore
[endp
-startp
] = '/';
2255 nstore
[endp
-startp
+1] = 0;
2258 nstore
[endp
-startp
] = 0;
2259 add_prefix (&startfile_prefix
, nstore
, 0, 0, NULL_PTR
);
2262 endp
= startp
= endp
+ 1;
2269 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
2270 temp
= getenv ("LPATH");
2273 char *startp
, *endp
;
2274 char *nstore
= (char *) alloca (strlen (temp
) + 3);
2276 startp
= endp
= temp
;
2279 if (*endp
== PATH_SEPARATOR
|| *endp
== 0)
2281 strncpy (nstore
, startp
, endp
-startp
);
2284 strcpy (nstore
, "./");
2286 else if (endp
[-1] != '/')
2288 nstore
[endp
-startp
] = '/';
2289 nstore
[endp
-startp
+1] = 0;
2292 nstore
[endp
-startp
] = 0;
2293 add_prefix (&startfile_prefix
, nstore
, 0, 0, NULL_PTR
);
2296 endp
= startp
= endp
+ 1;
2303 /* Convert new-style -- options to old-style. */
2304 translate_options (&argc
, &argv
);
2306 /* Scan argv twice. Here, the first time, just count how many switches
2307 there will be in their vector, and how many input files in theirs.
2308 Here we also parse the switches that cc itself uses (e.g. -v). */
2310 for (i
= 1; i
< argc
; i
++)
2312 if (! strcmp (argv
[i
], "-dumpspecs"))
2314 printf ("*asm:\n%s\n\n", asm_spec
);
2315 printf ("*asm_final:\n%s\n\n", asm_final_spec
);
2316 printf ("*cpp:\n%s\n\n", cpp_spec
);
2317 printf ("*cc1:\n%s\n\n", cc1_spec
);
2318 printf ("*cc1plus:\n%s\n\n", cc1plus_spec
);
2319 printf ("*endfile:\n%s\n\n", endfile_spec
);
2320 printf ("*link:\n%s\n\n", link_spec
);
2321 printf ("*lib:\n%s\n\n", lib_spec
);
2322 printf ("*startfile:\n%s\n\n", startfile_spec
);
2323 printf ("*switches_need_spaces:\n%s\n\n", switches_need_spaces
);
2324 printf ("*signed_char:\n%s\n\n", signed_char_spec
);
2325 printf ("*predefines:\n%s\n\n", cpp_predefines
);
2326 printf ("*cross_compile:\n%d\n\n", cross_compile
);
2330 else if (! strcmp (argv
[i
], "-dumpversion"))
2332 printf ("%s\n", version_string
);
2335 else if (! strcmp (argv
[i
], "-print-libgcc-file-name"))
2336 print_file_name
= "libgcc.a";
2337 else if (! strncmp (argv
[i
], "-print-file-name=", 17))
2338 print_file_name
= argv
[i
] + 17;
2339 else if (! strncmp (argv
[i
], "-print-prog-name=", 17))
2340 print_prog_name
= argv
[i
] + 17;
2341 else if (! strcmp (argv
[i
], "-Xlinker"))
2343 /* Pass the argument of this option to the linker when we link. */
2346 fatal ("argument to `-Xlinker' is missing");
2349 if (!linker_options
)
2351 = (char **) xmalloc (n_linker_options
* sizeof (char **));
2354 = (char **) xrealloc (linker_options
,
2355 n_linker_options
* sizeof (char **));
2357 linker_options
[n_linker_options
- 1] = argv
[++i
];
2359 else if (! strncmp (argv
[i
], "-Wl,", 4))
2362 /* Pass the rest of this option to the linker when we link. */
2365 if (!linker_options
)
2367 = (char **) xmalloc (n_linker_options
* sizeof (char **));
2370 = (char **) xrealloc (linker_options
,
2371 n_linker_options
* sizeof (char **));
2373 /* Split the argument at commas. */
2375 for (j
= 4; argv
[i
][j
]; j
++)
2376 if (argv
[i
][j
] == ',')
2378 linker_options
[n_linker_options
- 1]
2379 = save_string (argv
[i
] + prev
, j
- prev
);
2382 = (char **) xrealloc (linker_options
,
2383 n_linker_options
* sizeof (char **));
2386 /* Record the part after the last comma. */
2387 linker_options
[n_linker_options
- 1] = argv
[i
] + prev
;
2389 else if (! strncmp (argv
[i
], "-Wa,", 4))
2392 /* Pass the rest of this option to the assembler. */
2394 n_assembler_options
++;
2395 if (!assembler_options
)
2397 = (char **) xmalloc (n_assembler_options
* sizeof (char **));
2400 = (char **) xrealloc (assembler_options
,
2401 n_assembler_options
* sizeof (char **));
2403 /* Split the argument at commas. */
2405 for (j
= 4; argv
[i
][j
]; j
++)
2406 if (argv
[i
][j
] == ',')
2408 assembler_options
[n_assembler_options
- 1]
2409 = save_string (argv
[i
] + prev
, j
- prev
);
2410 n_assembler_options
++;
2412 = (char **) xrealloc (assembler_options
,
2413 n_assembler_options
* sizeof (char **));
2416 /* Record the part after the last comma. */
2417 assembler_options
[n_assembler_options
- 1] = argv
[i
] + prev
;
2419 else if (argv
[i
][0] == '+' && argv
[i
][1] == 'e')
2420 /* The +e options to the C++ front-end. */
2422 else if (argv
[i
][0] == '-' && argv
[i
][1] != 0 && argv
[i
][1] != 'l')
2424 register char *p
= &argv
[i
][1];
2425 register int c
= *p
;
2430 if (p
[1] == 0 && i
+ 1 == argc
)
2431 fatal ("argument to `-b' is missing");
2433 spec_machine
= argv
[++i
];
2435 spec_machine
= p
+ 1;
2440 int *temp
= (int *) xmalloc (sizeof (int));
2442 if (p
[1] == 0 && i
+ 1 == argc
)
2443 fatal ("argument to `-B' is missing");
2448 add_prefix (&exec_prefix
, value
, 1, 0, temp
);
2449 add_prefix (&startfile_prefix
, value
, 1, 0, temp
);
2450 add_prefix (&include_prefix
, concat (value
, "include", ""),
2453 /* As a kludge, if the arg is "[foo/]stageN/", just add
2454 "[foo/]stageN/../include" to the include prefix. */
2456 int len
= strlen (value
);
2457 if ((len
== 7 || (len
> 7 && value
[len
- 8] == '/'))
2458 && strncmp (value
+ len
- 7, "stage", 5) == 0
2459 && isdigit (value
[len
- 2])
2460 && value
[len
- 1] == '/')
2461 add_prefix (&include_prefix
,
2462 concat (value
, "../include", ""), 1, 0, 0);
2467 case 'v': /* Print our subcommands and print versions. */
2469 /* If they do anything other than exactly `-v', don't set
2470 verbose_flag; rather, continue on to give the error. */
2477 if (p
[1] == 0 && i
+ 1 == argc
)
2478 fatal ("argument to `-V' is missing");
2480 spec_version
= argv
[++i
];
2482 spec_version
= p
+ 1;
2483 compiler_version
= spec_version
;
2487 if (!strcmp (p
, "save-temps"))
2489 save_temps_flag
= 1;
2496 if (SWITCH_TAKES_ARG (c
) > (p
[1] != 0))
2497 i
+= SWITCH_TAKES_ARG (c
) - (p
[1] != 0);
2498 else if (WORD_SWITCH_TAKES_ARG (p
))
2499 i
+= WORD_SWITCH_TAKES_ARG (p
);
2506 /* Set up the search paths before we go looking for config files. */
2508 /* These come before the md prefixes so that we will find gcc's subcommands
2509 (such as cpp) rather than those of the host system. */
2510 /* Use 2 as fourth arg meaning try just the machine as a suffix,
2511 as well as trying the machine and the version. */
2512 add_prefix (&exec_prefix
, standard_exec_prefix
, 0, 2, NULL_PTR
);
2513 add_prefix (&exec_prefix
, standard_exec_prefix_1
, 0, 2, NULL_PTR
);
2515 add_prefix (&startfile_prefix
, standard_exec_prefix
, 0, 1, NULL_PTR
);
2516 add_prefix (&startfile_prefix
, standard_exec_prefix_1
, 0, 1, NULL_PTR
);
2518 tooldir_prefix
= concat (tooldir_base_prefix
, spec_machine
, "/");
2520 /* If tooldir is relative, base it on exec_prefix. A relative
2521 tooldir lets us move the installed tree as a unit.
2523 If GCC_EXEC_PREFIX is defined, then we want to add two relative
2524 directories, so that we can search both the user specified directory
2525 and the standard place. */
2527 if (*tooldir_prefix
!= '/')
2529 if (gcc_exec_prefix
)
2531 char *gcc_exec_tooldir_prefix
2532 = concat (concat (gcc_exec_prefix
, spec_machine
, "/"),
2533 concat (spec_version
, "/", tooldir_prefix
),
2536 add_prefix (&exec_prefix
, concat (gcc_exec_tooldir_prefix
, "bin", "/"),
2538 add_prefix (&startfile_prefix
, concat (gcc_exec_tooldir_prefix
, "lib", "/"),
2542 tooldir_prefix
= concat (concat (standard_exec_prefix
, spec_machine
, "/"),
2543 concat (spec_version
, "/", tooldir_prefix
),
2547 add_prefix (&exec_prefix
, concat (tooldir_prefix
, "bin", "/"),
2549 add_prefix (&startfile_prefix
, concat (tooldir_prefix
, "lib", "/"),
2552 /* More prefixes are enabled in main, after we read the specs file
2553 and determine whether this is cross-compilation or not. */
2556 /* Then create the space for the vectors and scan again. */
2558 switches
= ((struct switchstr
*)
2559 xmalloc ((n_switches
+ 1) * sizeof (struct switchstr
)));
2560 infiles
= (struct infile
*) xmalloc ((n_infiles
+ 1) * sizeof (struct infile
));
2563 last_language_n_infiles
= -1;
2565 /* This, time, copy the text of each switch and store a pointer
2566 to the copy in the vector of switches.
2567 Store all the infiles in their vector. */
2569 for (i
= 1; i
< argc
; i
++)
2571 /* Just skip the switches that were handled by the preceding loop. */
2572 if (!strcmp (argv
[i
], "-Xlinker"))
2574 else if (! strncmp (argv
[i
], "-Wl,", 4))
2576 else if (! strncmp (argv
[i
], "-Wa,", 4))
2578 else if (! strcmp (argv
[i
], "-print-libgcc-file-name"))
2580 else if (! strncmp (argv
[i
], "-print-file-name=", 17))
2582 else if (! strncmp (argv
[i
], "-print-prog-name=", 17))
2584 else if (argv
[i
][0] == '+' && argv
[i
][1] == 'e')
2586 /* Compensate for the +e options to the C++ front-end;
2587 they're there simply for cfront call-compatibility. We do
2588 some magic in default_compilers to pass them down properly.
2589 Note we deliberately start at the `+' here, to avoid passing
2590 -e0 or -e1 down into the linker. */
2591 switches
[n_switches
].part1
= &argv
[i
][0];
2592 switches
[n_switches
].args
= 0;
2593 switches
[n_switches
].live_cond
= 0;
2594 switches
[n_switches
].valid
= 0;
2597 else if (argv
[i
][0] == '-' && argv
[i
][1] != 0 && argv
[i
][1] != 'l')
2599 register char *p
= &argv
[i
][1];
2600 register int c
= *p
;
2602 if (c
== 'B' || c
== 'b' || c
== 'V')
2604 /* Skip a separate arg, if any. */
2611 if (p
[1] == 0 && i
+ 1 == argc
)
2612 fatal ("argument to `-x' is missing");
2614 spec_lang
= argv
[++i
];
2617 if (! strcmp (spec_lang
, "none"))
2618 /* Suppress the warning if -xnone comes after the last input file,
2619 because alternate command interfaces like g++ might find it
2620 useful to place -xnone after each input file. */
2623 last_language_n_infiles
= n_infiles
;
2626 switches
[n_switches
].part1
= p
;
2627 /* Deal with option arguments in separate argv elements. */
2628 if ((SWITCH_TAKES_ARG (c
) > (p
[1] != 0))
2629 || WORD_SWITCH_TAKES_ARG (p
))
2632 int n_args
= WORD_SWITCH_TAKES_ARG (p
);
2636 /* Count only the option arguments in separate argv elements. */
2637 n_args
= SWITCH_TAKES_ARG (c
) - (p
[1] != 0);
2639 if (i
+ n_args
>= argc
)
2640 fatal ("argument to `-%s' is missing", p
);
2641 switches
[n_switches
].args
2642 = (char **) xmalloc ((n_args
+ 1) * sizeof (char *));
2644 switches
[n_switches
].args
[j
++] = argv
[++i
];
2645 /* Null-terminate the vector. */
2646 switches
[n_switches
].args
[j
] = 0;
2648 else if (*switches_need_spaces
!= 0 && (c
== 'o' || c
== 'L'))
2650 /* On some systems, ld cannot handle -o or -L without space.
2651 So split the -o or -L from its argument. */
2652 switches
[n_switches
].part1
= (c
== 'o' ? "o" : "L");
2653 switches
[n_switches
].args
= (char **) xmalloc (2 * sizeof (char *));
2654 switches
[n_switches
].args
[0] = xmalloc (strlen (p
));
2655 strcpy (switches
[n_switches
].args
[0], &p
[1]);
2656 switches
[n_switches
].args
[1] = 0;
2659 switches
[n_switches
].args
= 0;
2661 switches
[n_switches
].live_cond
= 0;
2662 switches
[n_switches
].valid
= 0;
2663 /* This is always valid, since gcc.c itself understands it. */
2664 if (!strcmp (p
, "save-temps"))
2665 switches
[n_switches
].valid
= 1;
2670 if ((argv
[i
][0] != '-' || argv
[i
][1] != 'l')
2671 && strcmp (argv
[i
], "-")
2672 && access (argv
[i
], R_OK
) < 0)
2674 perror_with_name (argv
[i
]);
2679 infiles
[n_infiles
].language
= spec_lang
;
2680 infiles
[n_infiles
++].name
= argv
[i
];
2685 if (n_infiles
== last_language_n_infiles
&& spec_lang
!= 0)
2686 error ("Warning: `-x %s' after last input file has no effect", spec_lang
);
2688 switches
[n_switches
].part1
= 0;
2689 infiles
[n_infiles
].name
= 0;
2691 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
2692 if (gcc_exec_prefix
)
2694 temp
= (char *) xmalloc (strlen (gcc_exec_prefix
) + strlen (spec_version
)
2695 + strlen (spec_machine
) + 3);
2696 strcpy (temp
, gcc_exec_prefix
);
2697 strcat (temp
, spec_machine
);
2699 strcat (temp
, spec_version
);
2701 gcc_exec_prefix
= temp
;
2705 /* Process a spec string, accumulating and running commands. */
2707 /* These variables describe the input file name.
2708 input_file_number is the index on outfiles of this file,
2709 so that the output file name can be stored for later use by %o.
2710 input_basename is the start of the part of the input file
2711 sans all directory names, and basename_length is the number
2712 of characters starting there excluding the suffix .c or whatever. */
2714 static char *input_filename
;
2715 static int input_file_number
;
2716 static int input_filename_length
;
2717 static int basename_length
;
2718 static char *input_basename
;
2719 static char *input_suffix
;
2721 /* These are variables used within do_spec and do_spec_1. */
2723 /* Nonzero if an arg has been started and not yet terminated
2724 (with space, tab or newline). */
2725 static int arg_going
;
2727 /* Nonzero means %d or %g has been seen; the next arg to be terminated
2728 is a temporary file name. */
2729 static int delete_this_arg
;
2731 /* Nonzero means %w has been seen; the next arg to be terminated
2732 is the output file name of this compilation. */
2733 static int this_is_output_file
;
2735 /* Nonzero means %s has been seen; the next arg to be terminated
2736 is the name of a library file and we should try the standard
2737 search dirs for it. */
2738 static int this_is_library_file
;
2740 /* Nonzero means that the input of this command is coming from a pipe. */
2741 static int input_from_pipe
;
2743 /* Process the spec SPEC and run the commands specified therein.
2744 Returns 0 if the spec is successfully processed; -1 if failed. */
2754 delete_this_arg
= 0;
2755 this_is_output_file
= 0;
2756 this_is_library_file
= 0;
2757 input_from_pipe
= 0;
2759 value
= do_spec_1 (spec
, 0, NULL_PTR
);
2761 /* Force out any unfinished command.
2762 If -pipe, this forces out the last command if it ended in `|'. */
2765 if (argbuf_index
> 0 && !strcmp (argbuf
[argbuf_index
- 1], "|"))
2768 if (argbuf_index
> 0)
2775 /* Process the sub-spec SPEC as a portion of a larger spec.
2776 This is like processing a whole spec except that we do
2777 not initialize at the beginning and we do not supply a
2778 newline by default at the end.
2779 INSWITCH nonzero means don't process %-sequences in SPEC;
2780 in this case, % is treated as an ordinary character.
2781 This is used while substituting switches.
2782 INSWITCH nonzero also causes SPC not to terminate an argument.
2784 Value is zero unless a line was finished
2785 and the command on that line reported an error. */
2788 do_spec_1 (spec
, inswitch
, soft_matched_part
)
2791 char *soft_matched_part
;
2793 register char *p
= spec
;
2800 /* If substituting a switch, treat all chars like letters.
2801 Otherwise, NL, SPC, TAB and % are special. */
2802 switch (inswitch
? 'a' : c
)
2805 /* End of line: finish any pending argument,
2806 then run the pending command if one has been started. */
2809 obstack_1grow (&obstack
, 0);
2810 string
= obstack_finish (&obstack
);
2811 if (this_is_library_file
)
2812 string
= find_file (string
);
2813 store_arg (string
, delete_this_arg
, this_is_output_file
);
2814 if (this_is_output_file
)
2815 outfiles
[input_file_number
] = string
;
2819 if (argbuf_index
> 0 && !strcmp (argbuf
[argbuf_index
- 1], "|"))
2822 for (i
= 0; i
< n_switches
; i
++)
2823 if (!strcmp (switches
[i
].part1
, "pipe"))
2826 /* A `|' before the newline means use a pipe here,
2827 but only if -pipe was specified.
2828 Otherwise, execute now and don't pass the `|' as an arg. */
2831 input_from_pipe
= 1;
2832 switches
[i
].valid
= 1;
2839 if (argbuf_index
> 0)
2845 /* Reinitialize for a new command, and for a new argument. */
2848 delete_this_arg
= 0;
2849 this_is_output_file
= 0;
2850 this_is_library_file
= 0;
2851 input_from_pipe
= 0;
2855 /* End any pending argument. */
2858 obstack_1grow (&obstack
, 0);
2859 string
= obstack_finish (&obstack
);
2860 if (this_is_library_file
)
2861 string
= find_file (string
);
2862 store_arg (string
, delete_this_arg
, this_is_output_file
);
2863 if (this_is_output_file
)
2864 outfiles
[input_file_number
] = string
;
2868 obstack_1grow (&obstack
, c
);
2874 /* Space or tab ends an argument if one is pending. */
2877 obstack_1grow (&obstack
, 0);
2878 string
= obstack_finish (&obstack
);
2879 if (this_is_library_file
)
2880 string
= find_file (string
);
2881 store_arg (string
, delete_this_arg
, this_is_output_file
);
2882 if (this_is_output_file
)
2883 outfiles
[input_file_number
] = string
;
2885 /* Reinitialize for a new argument. */
2887 delete_this_arg
= 0;
2888 this_is_output_file
= 0;
2889 this_is_library_file
= 0;
2896 fatal ("Invalid specification! Bug in cc.");
2899 obstack_grow (&obstack
, input_basename
, basename_length
);
2904 delete_this_arg
= 2;
2907 /* Dump out the directories specified with LIBRARY_PATH,
2908 followed by the absolute directories
2909 that we search for startfiles. */
2912 struct prefix_list
*pl
= startfile_prefix
.plist
;
2914 char *buffer
= (char *) xmalloc (bufsize
);
2917 for (; pl
; pl
= pl
->next
)
2919 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
2920 /* Used on systems which record the specified -L dirs
2921 and use them to search for dynamic linking. */
2922 /* Relative directories always come from -B,
2923 and it is better not to use them for searching
2924 at run time. In particular, stage1 loses */
2925 if (pl
->prefix
[0] != '/')
2930 if (is_directory (pl
->prefix
, machine_suffix
, 1))
2932 do_spec_1 ("-L", 0, NULL_PTR
);
2933 #ifdef SPACE_AFTER_L_OPTION
2934 do_spec_1 (" ", 0, NULL_PTR
);
2936 do_spec_1 (pl
->prefix
, 1, NULL_PTR
);
2937 /* Remove slash from machine_suffix. */
2938 if (strlen (machine_suffix
) >= bufsize
)
2939 bufsize
= strlen (machine_suffix
) * 2 + 1;
2940 buffer
= (char *) xrealloc (buffer
, bufsize
);
2941 strcpy (buffer
, machine_suffix
);
2942 idx
= strlen (buffer
);
2943 if (buffer
[idx
- 1] == '/')
2944 buffer
[idx
- 1] = 0;
2945 do_spec_1 (buffer
, 1, NULL_PTR
);
2946 /* Make this a separate argument. */
2947 do_spec_1 (" ", 0, NULL_PTR
);
2950 if (!pl
->require_machine_suffix
)
2952 if (is_directory (pl
->prefix
, "", 1))
2954 do_spec_1 ("-L", 0, NULL_PTR
);
2955 #ifdef SPACE_AFTER_L_OPTION
2956 do_spec_1 (" ", 0, NULL_PTR
);
2958 /* Remove slash from pl->prefix. */
2959 if (strlen (pl
->prefix
) >= bufsize
)
2960 bufsize
= strlen (pl
->prefix
) * 2 + 1;
2961 buffer
= (char *) xrealloc (buffer
, bufsize
);
2962 strcpy (buffer
, pl
->prefix
);
2963 idx
= strlen (buffer
);
2964 if (buffer
[idx
- 1] == '/')
2965 buffer
[idx
- 1] = 0;
2966 do_spec_1 (buffer
, 1, NULL_PTR
);
2967 /* Make this a separate argument. */
2968 do_spec_1 (" ", 0, NULL_PTR
);
2977 /* {...:%efoo} means report an error with `foo' as error message
2978 and don't execute any more commands for this file. */
2982 while (*p
!= 0 && *p
!= '\n') p
++;
2983 buf
= (char *) alloca (p
- q
+ 1);
2984 strncpy (buf
, q
, p
- q
);
2994 if (save_temps_flag
)
2996 obstack_grow (&obstack
, input_basename
, basename_length
);
2997 delete_this_arg
= 0;
3001 #ifdef MKTEMP_EACH_FILE
3002 /* ??? This has a problem: the total number of
3003 values mktemp can return is limited.
3004 That matters for the names of object files.
3005 In 2.4, do something about that. */
3006 struct temp_name
*t
;
3008 while (*p
== '.' || isalpha (*p
))
3011 /* See if we already have an association of %g/%u/%U and
3013 for (t
= temp_names
; t
; t
= t
->next
)
3014 if (t
->length
== p
- suffix
3015 && strncmp (t
->suffix
, suffix
, p
- suffix
) == 0
3016 && t
->unique
== (c
!= 'g'))
3019 /* Make a new association if needed. %u requires one. */
3020 if (t
== 0 || c
== 'u')
3024 t
= (struct temp_name
*) xmalloc (sizeof (struct temp_name
));
3025 t
->next
= temp_names
;
3028 t
->length
= p
- suffix
;
3029 t
->suffix
= save_string (suffix
, p
- suffix
);
3030 t
->unique
= (c
!= 'g');
3031 choose_temp_base ();
3032 t
->filename
= temp_filename
;
3033 t
->filename_length
= temp_filename_length
;
3036 obstack_grow (&obstack
, t
->filename
, t
->filename_length
);
3037 delete_this_arg
= 1;
3039 obstack_grow (&obstack
, temp_filename
, temp_filename_length
);
3040 if (c
== 'u' || c
== 'U')
3046 sprintf (buff
, "%d", unique
);
3047 obstack_grow (&obstack
, buff
, strlen (buff
));
3050 delete_this_arg
= 1;
3056 obstack_grow (&obstack
, input_filename
, input_filename_length
);
3062 struct prefix_list
*pl
= include_prefix
.plist
;
3064 if (gcc_exec_prefix
)
3066 do_spec_1 ("-iprefix", 1, NULL_PTR
);
3067 /* Make this a separate argument. */
3068 do_spec_1 (" ", 0, NULL_PTR
);
3069 do_spec_1 (gcc_exec_prefix
, 1, NULL_PTR
);
3070 do_spec_1 (" ", 0, NULL_PTR
);
3073 for (; pl
; pl
= pl
->next
)
3075 do_spec_1 ("-isystem", 1, NULL_PTR
);
3076 /* Make this a separate argument. */
3077 do_spec_1 (" ", 0, NULL_PTR
);
3078 do_spec_1 (pl
->prefix
, 1, NULL_PTR
);
3079 do_spec_1 (" ", 0, NULL_PTR
);
3087 for (f
= 0; f
< n_infiles
; f
++)
3088 store_arg (outfiles
[f
], 0, 0);
3093 this_is_library_file
= 1;
3097 this_is_output_file
= 1;
3102 int index
= argbuf_index
;
3103 /* Handle the {...} following the %W. */
3106 p
= handle_braces (p
+ 1);
3109 /* If any args were output, mark the last one for deletion
3111 if (argbuf_index
!= index
)
3112 record_temp_file (argbuf
[argbuf_index
- 1], 0, 1);
3116 /* %x{OPTION} records OPTION for %X to output. */
3122 /* Skip past the option value and make a copy. */
3127 string
= save_string (p1
+ 1, p
- p1
- 2);
3129 /* See if we already recorded this option. */
3130 for (i
= 0; i
< n_linker_options
; i
++)
3131 if (! strcmp (string
, linker_options
[i
]))
3137 /* This option is new; add it. */
3139 if (!linker_options
)
3141 = (char **) xmalloc (n_linker_options
* sizeof (char **));
3144 = (char **) xrealloc (linker_options
,
3145 n_linker_options
* sizeof (char **));
3147 linker_options
[n_linker_options
- 1] = string
;
3151 /* Dump out the options accumulated previously using %x,
3152 -Xlinker and -Wl,. */
3154 for (i
= 0; i
< n_linker_options
; i
++)
3156 do_spec_1 (linker_options
[i
], 1, NULL_PTR
);
3157 /* Make each accumulated option a separate argument. */
3158 do_spec_1 (" ", 0, NULL_PTR
);
3162 /* Dump out the options accumulated previously using -Wa,. */
3164 for (i
= 0; i
< n_assembler_options
; i
++)
3166 do_spec_1 (assembler_options
[i
], 1, NULL_PTR
);
3167 /* Make each accumulated option a separate argument. */
3168 do_spec_1 (" ", 0, NULL_PTR
);
3172 /* Here are digits and numbers that just process
3173 a certain constant string as a spec. */
3176 value
= do_spec_1 (cc1_spec
, 0, NULL_PTR
);
3182 value
= do_spec_1 (cc1plus_spec
, 0, NULL_PTR
);
3188 value
= do_spec_1 (asm_spec
, 0, NULL_PTR
);
3194 value
= do_spec_1 (asm_final_spec
, 0, NULL_PTR
);
3200 value
= do_spec_1 (signed_char_spec
, 0, NULL_PTR
);
3206 value
= do_spec_1 (cpp_spec
, 0, NULL_PTR
);
3212 value
= do_spec_1 (endfile_spec
, 0, NULL_PTR
);
3218 value
= do_spec_1 (link_spec
, 0, NULL_PTR
);
3224 value
= do_spec_1 (lib_spec
, 0, NULL_PTR
);
3231 char *x
= (char *) alloca (strlen (cpp_predefines
) + 1);
3235 /* Copy all of the -D options in CPP_PREDEFINES into BUF. */
3239 if (! strncmp (y
, "-D", 2))
3240 /* Copy the whole option. */
3241 while (*y
&& *y
!= ' ' && *y
!= '\t')
3243 else if (*y
== ' ' || *y
== '\t')
3244 /* Copy whitespace to the result. */
3246 /* Don't copy other options. */
3253 value
= do_spec_1 (buf
, 0, NULL_PTR
);
3261 char *x
= (char *) alloca (strlen (cpp_predefines
) * 4 + 1);
3265 /* Copy all of CPP_PREDEFINES into BUF,
3266 but put __ after every -D and at the end of each arg. */
3270 if (! strncmp (y
, "-D", 2))
3277 if (strncmp (y
, "__", 2))
3279 /* Stick __ at front of macro name. */
3282 /* Arrange to stick __ at the end as well. */
3286 /* Copy the macro name. */
3287 while (*y
&& *y
!= '=' && *y
!= ' ' && *y
!= '\t')
3296 /* Copy the value given, if any. */
3297 while (*y
&& *y
!= ' ' && *y
!= '\t')
3300 else if (*y
== ' ' || *y
== '\t')
3301 /* Copy whitespace to the result. */
3303 /* Don't copy -A options */
3309 /* Copy all of CPP_PREDEFINES into BUF,
3310 but put __ after every -D. */
3314 if (! strncmp (y
, "-D", 2))
3318 if (strncmp (y
, "__", 2))
3320 /* Stick -D__ at front of macro name. */
3326 /* Copy the macro name. */
3327 while (*y
&& *y
!= '=' && *y
!= ' ' && *y
!= '\t')
3330 /* Copy the value given, if any. */
3331 while (*y
&& *y
!= ' ' && *y
!= '\t')
3336 /* Do not copy this macro - we have just done it before */
3337 while (*y
&& *y
!= ' ' && *y
!= '\t')
3341 else if (*y
== ' ' || *y
== '\t')
3342 /* Copy whitespace to the result. */
3344 /* Don't copy -A options */
3350 /* Copy all of the -A options in CPP_PREDEFINES into BUF. */
3354 if (! strncmp (y
, "-A", 2))
3355 /* Copy the whole option. */
3356 while (*y
&& *y
!= ' ' && *y
!= '\t')
3358 else if (*y
== ' ' || *y
== '\t')
3359 /* Copy whitespace to the result. */
3361 /* Don't copy other options. */
3368 value
= do_spec_1 (buf
, 0, NULL_PTR
);
3375 value
= do_spec_1 (startfile_spec
, 0, NULL_PTR
);
3380 /* Here we define characters other than letters and digits. */
3383 p
= handle_braces (p
);
3389 obstack_1grow (&obstack
, '%');
3393 do_spec_1 (soft_matched_part
, 1, NULL_PTR
);
3394 do_spec_1 (" ", 0, NULL_PTR
);
3397 /* Process a string found as the value of a spec given by name.
3398 This feature allows individual machine descriptions
3399 to add and use their own specs.
3400 %[...] modifies -D options the way %P does;
3401 %(...) uses the spec unmodified. */
3406 struct spec_list
*sl
;
3409 /* The string after the S/P is the name of a spec that is to be
3411 while (*p
&& *p
!= ')' && *p
!= ']')
3414 /* See if it's in the list */
3415 for (len
= p
- name
, sl
= specs
; sl
; sl
= sl
->next
)
3416 if (strncmp (sl
->name
, name
, len
) == 0 && !sl
->name
[len
])
3426 value
= do_spec_1 (name
, 0, NULL_PTR
);
3432 char *x
= (char *) alloca (strlen (name
) * 2 + 1);
3436 /* Copy all of NAME into BUF, but put __ after
3437 every -D and at the end of each arg, */
3440 if (! strncmp (y
, "-D", 2))
3448 else if (*y
== ' ' || *y
== 0)
3462 value
= do_spec_1 (buf
, 0, NULL_PTR
);
3468 /* Discard the closing paren or bracket. */
3476 int c1
= *p
++; /* Select first or second version number. */
3477 char *v
= compiler_version
;
3479 /* If desired, advance to second version number. */
3482 /* Set P after the first period. */
3483 while (*v
!= 0 && *v
!= ' ' && *v
!= '.')
3488 /* Set Q at the next period or at the end. */
3490 while (*q
!= 0 && *q
!= ' ' && *q
!= '.')
3492 /* Empty string means zero. */
3498 /* Put that part into the command. */
3499 obstack_grow (&obstack
, v
, q
- v
);
3505 if (input_from_pipe
)
3506 do_spec_1 ("-", 0, NULL_PTR
);
3515 /* Backslash: treat next character as ordinary. */
3520 /* Ordinary character: put it into the current argument. */
3521 obstack_1grow (&obstack
, c
);
3525 return 0; /* End of string */
3528 /* Return 0 if we call do_spec_1 and that returns -1. */
3541 /* A `|' after the open-brace means,
3542 if the test fails, output a single minus sign rather than nothing.
3543 This is used in %{|!pipe:...}. */
3547 /* A `!' after the open-brace negates the condition:
3548 succeed if the specified switch is not present. */
3552 /* A `.' after the open-brace means test against the current suffix. */
3562 while (*p
!= ':' && *p
!= '}') p
++;
3565 register int count
= 1;
3583 int found
= (input_suffix
!= 0
3584 && strlen (input_suffix
) == p
- filter
3585 && strncmp (input_suffix
, filter
, p
- filter
) == 0);
3591 && do_spec_1 (save_string (p
+ 1, q
- p
- 2), 0, NULL_PTR
) < 0)
3596 else if (p
[-1] == '*' && p
[0] == '}')
3598 /* Substitute all matching switches as separate args. */
3601 for (i
= 0; i
< n_switches
; i
++)
3602 if (!strncmp (switches
[i
].part1
, filter
, p
- filter
)
3603 && check_live_switch (i
, p
- filter
))
3608 /* Test for presence of the specified switch. */
3612 /* If name specified ends in *, as in {x*:...},
3613 check for %* and handle that case. */
3614 if (p
[-1] == '*' && !negate
)
3619 /* First see whether we have %*. */
3623 if (*r
== '%' && r
[1] == '*')
3627 /* If we do, handle that case. */
3630 /* Substitute all matching switches as separate args.
3631 But do this by substituting for %*
3632 in the text that follows the colon. */
3634 unsigned hard_match_len
= p
- filter
- 1;
3635 char *string
= save_string (p
+ 1, q
- p
- 2);
3637 for (i
= 0; i
< n_switches
; i
++)
3638 if (!strncmp (switches
[i
].part1
, filter
, hard_match_len
)
3639 && check_live_switch (i
, -1))
3641 do_spec_1 (string
, 0, &switches
[i
].part1
[hard_match_len
]);
3642 /* Pass any arguments this switch has. */
3650 /* If name specified ends in *, as in {x*:...},
3651 check for presence of any switch name starting with x. */
3654 for (i
= 0; i
< n_switches
; i
++)
3656 unsigned hard_match_len
= p
- filter
- 1;
3658 if (!strncmp (switches
[i
].part1
, filter
, hard_match_len
)
3659 && check_live_switch (i
, hard_match_len
))
3665 /* Otherwise, check for presence of exact name specified. */
3668 for (i
= 0; i
< n_switches
; i
++)
3670 if (!strncmp (switches
[i
].part1
, filter
, p
- filter
)
3671 && switches
[i
].part1
[p
- filter
] == 0
3672 && check_live_switch (i
, -1))
3680 /* If it is as desired (present for %{s...}, absent for %{-s...})
3681 then substitute either the switch or the specified
3682 conditional text. */
3683 if (present
!= negate
)
3691 if (do_spec_1 (save_string (p
+ 1, q
- p
- 2), 0, NULL_PTR
) < 0)
3697 /* Here if a %{|...} conditional fails: output a minus sign,
3698 which means "standard output" or "standard input". */
3699 do_spec_1 ("-", 0, NULL_PTR
);
3706 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
3707 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
3708 spec, or -1 if either exact match or %* is used.
3710 A -O switch is obsoleted by a later -O switch. A -f, -m, or -W switch
3711 whose value does not begin with "no-" is obsoleted by the same value
3712 with the "no-", similarly for a switch with the "no-" prefix. */
3715 check_live_switch (switchnum
, prefix_length
)
3719 char *name
= switches
[switchnum
].part1
;
3722 /* In the common case of {<at-most-one-letter>*}, a negating
3723 switch would always match, so ignore that case. We will just
3724 send the conflicting switches to the compiler phase. */
3725 if (prefix_length
>= 0 && prefix_length
<= 1)
3728 /* If we already processed this switch and determined if it was
3729 live or not, return our past determination. */
3730 if (switches
[switchnum
].live_cond
!= 0)
3731 return switches
[switchnum
].live_cond
> 0;
3733 /* Now search for duplicate in a manner that depends on the name. */
3737 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
3738 if (switches
[i
].part1
[0] == 'O')
3740 switches
[switchnum
].valid
= 1;
3741 switches
[switchnum
].live_cond
= -1;
3746 case 'W': case 'f': case 'm':
3747 if (! strncmp (name
+ 1, "no-", 3))
3749 /* We have Xno-YYY, search for XYYY. */
3750 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
3751 if (switches
[i
].part1
[0] == name
[0]
3752 && ! strcmp (&switches
[i
].part1
[1], &name
[4]))
3754 switches
[switchnum
].valid
= 1;
3755 switches
[switchnum
].live_cond
= -1;
3761 /* We have XYYY, search for Xno-YYY. */
3762 for (i
= switchnum
+ 1; i
< n_switches
; i
++)
3763 if (switches
[i
].part1
[0] == name
[0]
3764 && switches
[i
].part1
[1] == 'n'
3765 && switches
[i
].part1
[2] == 'o'
3766 && switches
[i
].part1
[3] == '-'
3767 && !strcmp (&switches
[i
].part1
[4], &name
[1]))
3769 switches
[switchnum
].valid
= 1;
3770 switches
[switchnum
].live_cond
= -1;
3777 /* Otherwise the switch is live. */
3778 switches
[switchnum
].live_cond
= 1;
3782 /* Pass a switch to the current accumulating command
3783 in the same form that we received it.
3784 SWITCHNUM identifies the switch; it is an index into
3785 the vector of switches gcc received, which is `switches'.
3786 This cannot fail since it never finishes a command line.
3788 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
3791 give_switch (switchnum
, omit_first_word
)
3793 int omit_first_word
;
3795 if (!omit_first_word
)
3797 do_spec_1 ("-", 0, NULL_PTR
);
3798 do_spec_1 (switches
[switchnum
].part1
, 1, NULL_PTR
);
3800 do_spec_1 (" ", 0, NULL_PTR
);
3801 if (switches
[switchnum
].args
!= 0)
3804 for (p
= switches
[switchnum
].args
; *p
; p
++)
3806 do_spec_1 (*p
, 1, NULL_PTR
);
3807 do_spec_1 (" ", 0, NULL_PTR
);
3810 switches
[switchnum
].valid
= 1;
3813 /* Search for a file named NAME trying various prefixes including the
3814 user's -B prefix and some standard ones.
3815 Return the absolute file name found. If nothing is found, return NAME. */
3823 newname
= find_a_file (&startfile_prefix
, name
, R_OK
);
3824 return newname
? newname
: name
;
3827 /* Determine whether a directory exists. If LINKER, return 0 for
3828 certain fixed names not needed by the linker. If not LINKER, it is
3829 only important to return 0 if the host machine has a small ARG_MAX
3833 is_directory (path1
, path2
, linker
)
3838 int len1
= strlen (path1
);
3839 int len2
= strlen (path2
);
3840 char *path
= (char *) alloca (3 + len1
+ len2
);
3844 #ifndef SMALL_ARG_MAX
3849 /* Construct the path from the two parts. Ensure the string ends with "/.".
3850 The resulting path will be a directory even if the given path is a
3852 bcopy (path1
, path
, len1
);
3853 bcopy (path2
, path
+ len1
, len2
);
3854 cp
= path
+ len1
+ len2
;
3860 /* Exclude directories that the linker is known to search. */
3862 && ((cp
- path
== 6 && strcmp (path
, "/lib/.") == 0)
3863 || (cp
- path
== 10 && strcmp (path
, "/usr/lib/.") == 0)))
3866 return (stat (path
, &st
) >= 0 && S_ISDIR (st
.st_mode
));
3869 /* On fatal signals, delete all the temporary files. */
3872 fatal_error (signum
)
3875 signal (signum
, SIG_DFL
);
3876 delete_failure_queue ();
3877 delete_temp_files ();
3878 /* Get the same signal again, this time not handled,
3879 so its normal effect occurs. */
3880 kill (getpid (), signum
);
3891 int linker_was_run
= 0;
3892 char *explicit_link_files
;
3896 p
= argv
[0] + strlen (argv
[0]);
3897 while (p
!= argv
[0] && p
[-1] != '/') --p
;
3900 if (signal (SIGINT
, SIG_IGN
) != SIG_IGN
)
3901 signal (SIGINT
, fatal_error
);
3903 if (signal (SIGHUP
, SIG_IGN
) != SIG_IGN
)
3904 signal (SIGHUP
, fatal_error
);
3906 if (signal (SIGTERM
, SIG_IGN
) != SIG_IGN
)
3907 signal (SIGTERM
, fatal_error
);
3909 if (signal (SIGPIPE
, SIG_IGN
) != SIG_IGN
)
3910 signal (SIGPIPE
, fatal_error
);
3914 argbuf
= (char **) xmalloc (argbuf_length
* sizeof (char *));
3916 obstack_init (&obstack
);
3918 /* Set up to remember the pathname of gcc and any options
3919 needed for collect. We use argv[0] instead of programname because
3920 we need the complete pathname. */
3921 obstack_init (&collect_obstack
);
3922 obstack_grow (&collect_obstack
, "COLLECT_GCC=", sizeof ("COLLECT_GCC=")-1);
3923 obstack_grow (&collect_obstack
, argv
[0], strlen (argv
[0])+1);
3924 putenv (obstack_finish (&collect_obstack
));
3926 /* Choose directory for temp files. */
3928 choose_temp_base ();
3930 /* Make a table of what switches there are (switches, n_switches).
3931 Make a table of specified input files (infiles, n_infiles).
3932 Decode switches that are handled locally. */
3934 process_command (argc
, argv
);
3936 /* Initialize the vector of specs to just the default.
3937 This means one element containing 0s, as a terminator. */
3939 compilers
= (struct compiler
*) xmalloc (sizeof default_compilers
);
3940 bcopy (default_compilers
, compilers
, sizeof default_compilers
);
3941 n_compilers
= n_default_compilers
;
3943 /* Read specs from a file if there is one. */
3945 machine_suffix
= concat (spec_machine
, "/", concat (spec_version
, "/", ""));
3946 just_machine_suffix
= concat (spec_machine
, "/", "");
3948 specs_file
= find_a_file (&startfile_prefix
, "specs", R_OK
);
3949 /* Read the specs file unless it is a default one. */
3950 if (specs_file
!= 0 && strcmp (specs_file
, "specs"))
3951 read_specs (specs_file
);
3953 /* If not cross-compiling, look for startfiles in the standard places. */
3954 /* The fact that these are done here, after reading the specs file,
3955 means that it cannot be found in these directories.
3956 But that's okay. It should never be there anyway. */
3959 #ifdef MD_EXEC_PREFIX
3960 add_prefix (&exec_prefix
, md_exec_prefix
, 0, 0, NULL_PTR
);
3961 add_prefix (&startfile_prefix
, md_exec_prefix
, 0, 0, NULL_PTR
);
3964 #ifdef MD_STARTFILE_PREFIX
3965 add_prefix (&startfile_prefix
, md_startfile_prefix
, 0, 0, NULL_PTR
);
3968 #ifdef MD_STARTFILE_PREFIX_1
3969 add_prefix (&startfile_prefix
, md_startfile_prefix_1
, 0, 0, NULL_PTR
);
3972 /* If standard_startfile_prefix is relative, base it on
3973 standard_exec_prefix. This lets us move the installed tree
3974 as a unit. If GCC_EXEC_PREFIX is defined, base
3975 standard_startfile_prefix on that as well. */
3976 if (*standard_startfile_prefix
== '/')
3977 add_prefix (&startfile_prefix
, standard_startfile_prefix
, 0, 0,
3981 if (gcc_exec_prefix
)
3982 add_prefix (&startfile_prefix
,
3983 concat (gcc_exec_prefix
,
3984 standard_startfile_prefix
,
3987 add_prefix (&startfile_prefix
,
3988 concat (standard_exec_prefix
,
3990 standard_startfile_prefix
),
3994 add_prefix (&startfile_prefix
, standard_startfile_prefix_1
, 0, 0,
3996 add_prefix (&startfile_prefix
, standard_startfile_prefix_2
, 0, 0,
3998 #if 0 /* Can cause surprises, and one can use -B./ instead. */
3999 add_prefix (&startfile_prefix
, "./", 0, 1, NULL_PTR
);
4003 /* Now we have the specs.
4004 Set the `valid' bits for switches that match anything in any spec. */
4006 validate_all_switches ();
4008 /* Warn about any switches that no pass was interested in. */
4010 for (i
= 0; i
< n_switches
; i
++)
4011 if (! switches
[i
].valid
)
4012 error ("unrecognized option `-%s'", switches
[i
].part1
);
4014 /* Obey some of the options. */
4016 if (print_file_name
)
4018 printf ("%s\n", find_file (print_file_name
));
4022 if (print_prog_name
)
4024 char *newname
= find_a_file (&exec_prefix
, print_prog_name
, X_OK
);
4025 printf ("%s\n", (newname
? newname
: print_prog_name
));
4031 fprintf (stderr
, "gcc version %s\n", version_string
);
4037 fatal ("No input files");
4039 /* Make a place to record the compiler output file names
4040 that correspond to the input files. */
4042 outfiles
= (char **) xmalloc (n_infiles
* sizeof (char *));
4043 bzero (outfiles
, n_infiles
* sizeof (char *));
4045 /* Record which files were specified explicitly as link input. */
4047 explicit_link_files
= xmalloc (n_infiles
);
4048 bzero (explicit_link_files
, n_infiles
);
4050 for (i
= 0; i
< n_infiles
; i
++)
4052 register struct compiler
*cp
= 0;
4053 int this_file_error
= 0;
4055 /* Tell do_spec what to substitute for %i. */
4057 input_filename
= infiles
[i
].name
;
4058 input_filename_length
= strlen (input_filename
);
4059 input_file_number
= i
;
4061 /* Use the same thing in %o, unless cp->spec says otherwise. */
4063 outfiles
[i
] = input_filename
;
4065 /* Figure out which compiler from the file's suffix. */
4067 cp
= lookup_compiler (infiles
[i
].name
, input_filename_length
,
4068 infiles
[i
].language
);
4072 /* Ok, we found an applicable compiler. Run its spec. */
4073 /* First say how much of input_filename to substitute for %b */
4077 input_basename
= input_filename
;
4078 for (p
= input_filename
; *p
; p
++)
4080 input_basename
= p
+ 1;
4082 /* Find a suffix starting with the last period,
4083 and set basename_length to exclude that suffix. */
4084 basename_length
= strlen (input_basename
);
4085 p
= input_basename
+ basename_length
;
4086 while (p
!= input_basename
&& *p
!= '.') --p
;
4087 if (*p
== '.' && p
!= input_basename
)
4089 basename_length
= p
- input_basename
;
4090 input_suffix
= p
+ 1;
4096 for (j
= 0; j
< sizeof cp
->spec
/ sizeof cp
->spec
[0]; j
++)
4098 len
+= strlen (cp
->spec
[j
]);
4100 p
= (char *) xmalloc (len
+ 1);
4103 for (j
= 0; j
< sizeof cp
->spec
/ sizeof cp
->spec
[0]; j
++)
4106 strcpy (p
+ len
, cp
->spec
[j
]);
4107 len
+= strlen (cp
->spec
[j
]);
4110 value
= do_spec (p
);
4113 this_file_error
= 1;
4116 /* If this file's name does not contain a recognized suffix,
4117 record it as explicit linker input. */
4120 explicit_link_files
[i
] = 1;
4122 /* Clear the delete-on-failure queue, deleting the files in it
4123 if this compilation failed. */
4125 if (this_file_error
)
4127 delete_failure_queue ();
4130 /* If this compilation succeeded, don't delete those files later. */
4131 clear_failure_queue ();
4134 /* Run ld to link all the compiler output files. */
4136 if (error_count
== 0)
4138 int tmp
= execution_count
;
4142 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
4144 putenv_from_prefixes (&exec_prefix
, "COMPILER_PATH=");
4145 putenv_from_prefixes (&startfile_prefix
, "LIBRARY_PATH=");
4147 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4149 obstack_grow (&collect_obstack
, "COLLECT_GCC_OPTIONS=",
4150 sizeof ("COLLECT_GCC_OPTIONS=")-1);
4153 for (i
= 0; i
< n_switches
; i
++)
4157 obstack_grow (&collect_obstack
, " ", 1);
4160 obstack_grow (&collect_obstack
, "-", 1);
4161 obstack_grow (&collect_obstack
, switches
[i
].part1
,
4162 strlen (switches
[i
].part1
));
4164 for (args
= switches
[i
].args
; args
&& *args
; args
++)
4166 obstack_grow (&collect_obstack
, " ", 1);
4167 obstack_grow (&collect_obstack
, *args
, strlen (*args
));
4170 obstack_grow (&collect_obstack
, "\0", 1);
4171 putenv (obstack_finish (&collect_obstack
));
4173 value
= do_spec (link_command_spec
);
4176 linker_was_run
= (tmp
!= execution_count
);
4179 /* Warn if a -B option was specified but the prefix was never used. */
4180 unused_prefix_warnings (&exec_prefix
);
4181 unused_prefix_warnings (&startfile_prefix
);
4183 /* If options said don't run linker,
4184 complain about input files to be given to the linker. */
4186 if (! linker_was_run
&& error_count
== 0)
4187 for (i
= 0; i
< n_infiles
; i
++)
4188 if (explicit_link_files
[i
])
4189 error ("%s: linker input file unused since linking not done",
4192 /* Delete some or all of the temporary files we made. */
4195 delete_failure_queue ();
4196 delete_temp_files ();
4198 exit (error_count
> 0 ? (signal_count
? 2 : 1) : 0);
4203 /* Find the proper compilation spec for the file name NAME,
4204 whose length is LENGTH. LANGUAGE is the specified language,
4205 or 0 if none specified. */
4207 static struct compiler
*
4208 lookup_compiler (name
, length
, language
)
4213 struct compiler
*cp
;
4215 /* Look for the language, if one is spec'd. */
4218 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
4222 if (cp
->suffix
[0] == '@'
4223 && !strcmp (cp
->suffix
+ 1, language
))
4227 error ("language %s not recognized", language
);
4230 /* Look for a suffix. */
4231 for (cp
= compilers
+ n_compilers
- 1; cp
>= compilers
; cp
--)
4233 if (/* The suffix `-' matches only the file name `-'. */
4234 (!strcmp (cp
->suffix
, "-") && !strcmp (name
, "-"))
4236 (strlen (cp
->suffix
) < length
4237 /* See if the suffix matches the end of NAME. */
4238 && !strcmp (cp
->suffix
,
4239 name
+ length
- strlen (cp
->suffix
))))
4241 if (cp
->spec
[0][0] == '@')
4243 struct compiler
*new;
4244 /* An alias entry maps a suffix to a language.
4245 Search for the language; pass 0 for NAME and LENGTH
4246 to avoid infinite recursion if language not found.
4247 Construct the new compiler spec. */
4248 language
= cp
->spec
[0] + 1;
4249 new = (struct compiler
*) xmalloc (sizeof (struct compiler
));
4250 new->suffix
= cp
->suffix
;
4251 bcopy (lookup_compiler (NULL_PTR
, 0, language
)->spec
,
4252 new->spec
, sizeof new->spec
);
4255 /* A non-alias entry: return it. */
4267 register char *value
= (char *) malloc (size
);
4269 fatal ("virtual memory exhausted");
4274 xrealloc (ptr
, size
)
4278 register char *value
= (char *) realloc (ptr
, size
);
4280 fatal ("virtual memory exhausted");
4284 /* Return a newly-allocated string whose contents concatenate those of s1, s2, s3. */
4290 int len1
= strlen (s1
), len2
= strlen (s2
), len3
= strlen (s3
);
4291 char *result
= xmalloc (len1
+ len2
+ len3
+ 1);
4293 strcpy (result
, s1
);
4294 strcpy (result
+ len1
, s2
);
4295 strcpy (result
+ len1
+ len2
, s3
);
4296 *(result
+ len1
+ len2
+ len3
) = 0;
4302 save_string (s
, len
)
4306 register char *result
= xmalloc (len
+ 1);
4308 bcopy (s
, result
, len
);
4314 pfatal_with_name (name
)
4319 if (errno
< sys_nerr
)
4320 s
= concat ("%s: ", sys_errlist
[errno
], "");
4322 s
= "cannot open %s";
4327 perror_with_name (name
)
4332 if (errno
< sys_nerr
)
4333 s
= concat ("%s: ", sys_errlist
[errno
], "");
4335 s
= "cannot open %s";
4345 if (errno
< sys_nerr
)
4346 s
= concat ("installation problem, cannot exec %s: ",
4347 sys_errlist
[errno
], "");
4349 s
= "installation problem, cannot exec %s";
4353 /* More 'friendly' abort that prints the line and file.
4354 config.h can #define abort fancy_abort if you like that sort of thing. */
4359 fatal ("Internal gcc abort.");
4364 /* Output an error message and exit */
4367 fatal
VPROTO((char *format
, ...))
4374 VA_START (ap
, format
);
4377 format
= va_arg (ap
, char*);
4380 fprintf (stderr
, "%s: ", programname
);
4381 vfprintf (stderr
, format
, ap
);
4383 fprintf (stderr
, "\n");
4384 delete_temp_files ();
4389 error
VPROTO((char *format
, ...))
4396 VA_START (ap
, format
);
4399 format
= va_arg (ap
, char*);
4402 fprintf (stderr
, "%s: ", programname
);
4403 vfprintf (stderr
, format
, ap
);
4406 fprintf (stderr
, "\n");
4409 #else /* not HAVE_VPRINTF */
4412 fatal (msg
, arg1
, arg2
)
4413 char *msg
, *arg1
, *arg2
;
4415 error (msg
, arg1
, arg2
);
4416 delete_temp_files ();
4421 error (msg
, arg1
, arg2
)
4422 char *msg
, *arg1
, *arg2
;
4424 fprintf (stderr
, "%s: ", programname
);
4425 fprintf (stderr
, msg
, arg1
, arg2
);
4426 fprintf (stderr
, "\n");
4429 #endif /* not HAVE_VPRINTF */
4433 validate_all_switches ()
4435 struct compiler
*comp
;
4438 struct spec_list
*spec
;
4440 for (comp
= compilers
; comp
->spec
[0]; comp
++)
4443 for (i
= 0; i
< sizeof comp
->spec
/ sizeof comp
->spec
[0] && comp
->spec
[i
]; i
++)
4447 if (c
== '%' && *p
== '{')
4448 /* We have a switch spec. */
4449 validate_switches (p
+ 1);
4453 /* look through the linked list of extra specs read from the specs file */
4454 for (spec
= specs
; spec
; spec
= spec
->next
)
4458 if (c
== '%' && *p
== '{')
4459 /* We have a switch spec. */
4460 validate_switches (p
+ 1);
4463 p
= link_command_spec
;
4465 if (c
== '%' && *p
== '{')
4466 /* We have a switch spec. */
4467 validate_switches (p
+ 1);
4469 /* Now notice switches mentioned in the machine-specific specs. */
4473 if (c
== '%' && *p
== '{')
4474 /* We have a switch spec. */
4475 validate_switches (p
+ 1);
4479 if (c
== '%' && *p
== '{')
4480 /* We have a switch spec. */
4481 validate_switches (p
+ 1);
4485 if (c
== '%' && *p
== '{')
4486 /* We have a switch spec. */
4487 validate_switches (p
+ 1);
4489 p
= signed_char_spec
;
4491 if (c
== '%' && *p
== '{')
4492 /* We have a switch spec. */
4493 validate_switches (p
+ 1);
4497 if (c
== '%' && *p
== '{')
4498 /* We have a switch spec. */
4499 validate_switches (p
+ 1);
4503 if (c
== '%' && *p
== '{')
4504 /* We have a switch spec. */
4505 validate_switches (p
+ 1);
4509 if (c
== '%' && *p
== '{')
4510 /* We have a switch spec. */
4511 validate_switches (p
+ 1);
4515 if (c
== '%' && *p
== '{')
4516 /* We have a switch spec. */
4517 validate_switches (p
+ 1);
4521 if (c
== '%' && *p
== '{')
4522 /* We have a switch spec. */
4523 validate_switches (p
+ 1);
4526 /* Look at the switch-name that comes after START
4527 and mark as valid all supplied switches that match it. */
4530 validate_switches (start
)
4533 register char *p
= start
;
4548 while (*p
!= ':' && *p
!= '}') p
++;
4552 else if (p
[-1] == '*')
4554 /* Mark all matching switches as valid. */
4556 for (i
= 0; i
< n_switches
; i
++)
4557 if (!strncmp (switches
[i
].part1
, filter
, p
- filter
))
4558 switches
[i
].valid
= 1;
4562 /* Mark an exact matching switch as valid. */
4563 for (i
= 0; i
< n_switches
; i
++)
4565 if (!strncmp (switches
[i
].part1
, filter
, p
- filter
)
4566 && switches
[i
].part1
[p
- filter
] == 0)
4567 switches
[i
].valid
= 1;