1 /* Compiler driver program that can handle many languages.
2 Copyright (C) 1987, 89, 92-98, 1999 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, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA.
21 This paragraph is here to try to keep Sun CC from dying.
22 The number of chars here seems crucial!!!! */
24 /* This program is the user interface to the C compiler and possibly to
25 other compilers. It is used because compilation is a complicated procedure
26 which involves running several programs and passing temporary files between
27 them, forwarding the users switches to those programs selectively,
28 and deleting the temporary files at the end.
30 CC recognizes how to compile each input file by suffixes in the file names.
31 Once it knows which kind of compilation to perform, the procedure for
32 compilation is specified by a string called a "spec". */
43 #define exit __posix_exit
46 /* By default there is no special suffix for executables. */
47 #ifdef EXECUTABLE_SUFFIX
48 #define HAVE_EXECUTABLE_SUFFIX
50 #define EXECUTABLE_SUFFIX ""
53 /* By default, the suffix for object files is ".o". */
55 #define HAVE_OBJECT_SUFFIX
57 #define OBJECT_SUFFIX ".o"
60 /* By default, colon separates directories in a path. */
61 #ifndef PATH_SEPARATOR
62 #define PATH_SEPARATOR ':'
66 #define DIR_SEPARATOR '/'
69 static char dir_separator_str[] = {DIR_SEPARATOR, 0};
71 #define obstack_chunk_alloc xmalloc
72 #define obstack_chunk_free free
74 #ifndef GET_ENV_PATH_LIST
75 #define GET_ENV_PATH_LIST(VAR,NAME) do { (VAR) = getenv (NAME); } while (0)
79 #define kill(p,s) raise(s)
82 /* If a stage of compilation returns an exit status >= 1,
83 compilation of that file ceases. */
85 #define MIN_FATAL_STATUS 1
87 /* Flag saying to print the directories gcc will search through looking for
88 programs, libraries, etc. */
90 static int print_search_dirs;
92 /* Flag saying to print the full filename of this file
93 as found through our usual search mechanism. */
95 static const char *print_file_name = NULL;
97 /* As print_file_name, but search for executable file. */
99 static const char *print_prog_name = NULL;
101 /* Flag saying to print the relative path we'd use to
102 find libgcc.a given the current compiler flags. */
104 static int print_multi_directory;
106 /* Flag saying to print the list of subdirectories and
107 compiler flags used to select them in a standard form. */
109 static int print_multi_lib;
111 /* Flag saying to print the command line options understood by gcc and its
114 static int print_help_list;
116 /* Flag indicating whether we should print the command and arguments */
118 static int verbose_flag;
120 /* Nonzero means write "temp" files in source directory
121 and use the source file's name in them, and don't delete them. */
123 static int save_temps_flag;
125 /* The compiler version. */
127 static char *compiler_version;
129 /* The target version specified with -V */
131 static char *spec_version = DEFAULT_TARGET_VERSION;
133 /* The target machine specified with -b. */
135 static const char *spec_machine = DEFAULT_TARGET_MACHINE;
137 /* Nonzero if cross-compiling.
138 When -b is used, the value comes from the `specs' file. */
141 static char *cross_compile = "1";
143 static char *cross_compile = "0";
146 /* The number of errors that have occurred; the link phase will not be
147 run if this is non-zero. */
148 static int error_count = 0;
150 /* This is the obstack which we use to allocate many strings. */
152 static struct obstack obstack;
154 /* This is the obstack to build an environment variable to pass to
155 collect2 that describes all of the relevant switches of what to
156 pass the compiler in building the list of pointers to constructors
159 static struct obstack collect_obstack;
161 extern char *version_string;
163 /* Forward declaration for prototypes. */
166 static void init_spec PROTO((void));
167 static void read_specs PROTO((const char *, int));
168 static void set_spec PROTO((const char *, const char *));
169 static struct compiler *lookup_compiler PROTO((const char *, size_t, const char *));
170 static char *build_search_list PROTO((struct path_prefix *, const char *, int));
171 static void putenv_from_prefixes PROTO((struct path_prefix *, const char *));
172 static char *find_a_file PROTO((struct path_prefix *, const char *, int));
173 static void add_prefix PROTO((struct path_prefix *, const char *,
174 const char *, int, int, int *));
175 static char *skip_whitespace PROTO((char *));
176 static void record_temp_file PROTO((const char *, int, int));
177 static void delete_if_ordinary PROTO((const char *));
178 static void delete_temp_files PROTO((void));
179 static void delete_failure_queue PROTO((void));
180 static void clear_failure_queue PROTO((void));
181 static int check_live_switch PROTO((int, int));
182 static const char *handle_braces PROTO((const char *));
183 static char *save_string PROTO((const char *, int));
184 extern int do_spec PROTO((const char *));
185 static int do_spec_1 PROTO((const char *, int, const char *));
186 static const char *find_file PROTO((const char *));
187 static int is_directory PROTO((const char *, const char *, int));
188 static void validate_switches PROTO((const char *));
189 static void validate_all_switches PROTO((void));
190 static void give_switch PROTO((int, int, int));
191 static int used_arg PROTO((const char *, int));
192 static int default_arg PROTO((const char *, int));
193 static void set_multilib_dir PROTO((void));
194 static void print_multilib_info PROTO((void));
195 static void pfatal_with_name PROTO((const char *)) ATTRIBUTE_NORETURN;
196 static void perror_with_name PROTO((const char *));
197 static void pfatal_pexecute PROTO((const char *, const char *))
199 static void fatal PVPROTO((const char *, ...))
200 ATTRIBUTE_NORETURN ATTRIBUTE_PRINTF_1;
201 static void error PVPROTO((const char *, ...))
203 static void notice PVPROTO((const char *, ...))
205 static void display_help PROTO((void));
206 static void add_preprocessor_option PROTO ((const char *, int));
207 static void add_assembler_option PROTO ((const char *, int));
208 static void add_linker_option PROTO ((const char *, int));
209 static void process_command PROTO ((int, char **));
210 static int execute PROTO ((void));
211 static void unused_prefix_warnings PROTO ((struct path_prefix *));
212 static void clear_args PROTO ((void));
213 static void fatal_error PROTO ((int));
215 void fancy_abort PROTO((void)) ATTRIBUTE_NORETURN;
217 /* Called before processing to change/add/remove arguments. */
218 extern void lang_specific_driver PROTO ((void (*) PVPROTO((const char *, ...)),
219 int *, char ***, int *));
221 /* Called before linking. Returns 0 on success and -1 on failure. */
222 extern int lang_specific_pre_link ();
224 /* Number of extra output files that lang_specific_pre_link may generate. */
225 extern int lang_specific_extra_outfiles;
227 /* Specs are strings containing lines, each of which (if not blank)
228 is made up of a program name, and arguments separated by spaces.
229 The program name must be exact and start from root, since no path
230 is searched and it is unreliable to depend on the current working directory.
231 Redirection of input or output is not supported; the subprograms must
232 accept filenames saying what files to read and write.
234 In addition, the specs can contain %-sequences to substitute variable text
235 or for conditional text. Here is a table of all defined %-sequences.
236 Note that spaces are not generated automatically around the results of
237 expanding these sequences; therefore, you can concatenate them together
238 or with constant text in a single argument.
240 %% substitute one % into the program name or argument.
241 %i substitute the name of the input file being processed.
242 %b substitute the basename of the input file being processed.
243 This is the substring up to (and not including) the last period
244 and not including the directory.
246 substitute a file name that has suffix SUFFIX and is chosen
247 once per compilation, and mark the argument a la %d. To reduce
248 exposure to denial-of-service attacks, the file name is now
249 chosen in a way that is hard to predict even when previously
250 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
251 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
252 the regexp "[.A-Za-z]*" or the special string "%O", which is
253 treated exactly as if %O had been pre-processed. Previously, %g
254 was simply substituted with a file name chosen once per compilation,
255 without regard to any appended suffix (which was therefore treated
256 just like ordinary text), making such attacks more likely to succeed.
258 like %g, but generates a new temporary file name even if %uSUFFIX
261 substitutes the last file name generated with %uSUFFIX, generating a
262 new one if there is no such last file name. In the absence of any
263 %uSUFFIX, this is just like %gSUFFIX, except they don't share
264 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
265 would involve the generation of two distinct file names, one
266 for each `%g.s' and another for each `%U.s'. Previously, %U was
267 simply substituted with a file name chosen for the previous %u,
268 without regard to any appended suffix.
269 %d marks the argument containing or following the %d as a
270 temporary file name, so that that file will be deleted if CC exits
271 successfully. Unlike %g, this contributes no text to the argument.
272 %w marks the argument containing or following the %w as the
273 "output file" of this compilation. This puts the argument
274 into the sequence of arguments that %o will substitute later.
276 like %{...} but mark last argument supplied within
277 as a file to be deleted on failure.
278 %o substitutes the names of all the output files, with spaces
279 automatically placed around them. You should write spaces
280 around the %o as well or the results are undefined.
281 %o is for use in the specs for running the linker.
282 Input files whose names have no recognized suffix are not compiled
283 at all, but they are included among the output files, so they will
285 %O substitutes the suffix for object files. Note that this is
286 handled specially when it immediately follows %g, %u, or %U,
287 because of the need for those to form complete file names. The
288 handling is such that %O is treated exactly as if it had already
289 been substituted, except that %g, %u, and %U do not currently
290 support additional SUFFIX characters following %O as they would
291 following, for example, `.o'.
292 %p substitutes the standard macro predefinitions for the
293 current target machine. Use this when running cpp.
294 %P like %p, but puts `__' before and after the name of each macro.
295 (Except macros that already have __.)
297 %I Substitute a -iprefix option made from GCC_EXEC_PREFIX.
298 %s current argument is the name of a library or startup file of some sort.
299 Search for that file in a standard list of directories
300 and substitute the full name found.
301 %eSTR Print STR as an error message. STR is terminated by a newline.
302 Use this when inconsistent options are detected.
303 %x{OPTION} Accumulate an option for %X.
304 %X Output the accumulated linker options specified by compilations.
305 %Y Output the accumulated assembler options specified by compilations.
306 %Z Output the accumulated preprocessor options specified by compilations.
307 %v1 Substitute the major version number of GCC.
308 (For version 2.5.n, this is 2.)
309 %v2 Substitute the minor version number of GCC.
310 (For version 2.5.n, this is 5.)
311 %a process ASM_SPEC as a spec.
312 This allows config.h to specify part of the spec for running as.
313 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
314 used here. This can be used to run a post-processor after the
315 assembler has done its job.
316 %D Dump out a -L option for each directory in startfile_prefixes.
317 If multilib_dir is set, extra entries are generated with it affixed.
318 %l process LINK_SPEC as a spec.
319 %L process LIB_SPEC as a spec.
320 %G process LIBGCC_SPEC as a spec.
321 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
322 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
323 %c process SIGNED_CHAR_SPEC as a spec.
324 %C process CPP_SPEC as a spec. A capital C is actually used here.
325 %1 process CC1_SPEC as a spec.
326 %2 process CC1PLUS_SPEC as a spec.
327 %| output "-" if the input for the current command is coming from a pipe.
328 %* substitute the variable part of a matched option. (See below.)
329 Note that each comma in the substituted string is replaced by
331 %{S} substitutes the -S switch, if that switch was given to CC.
332 If that switch was not specified, this substitutes nothing.
333 Here S is a metasyntactic variable.
334 %{S*} substitutes all the switches specified to CC whose names start
335 with -S. This is used for -o, -D, -I, etc; switches that take
336 arguments. CC considers `-o foo' as being one switch whose
337 name starts with `o'. %{o*} would substitute this text,
338 including the space; thus, two arguments would be generated.
339 %{^S*} likewise, but don't put a blank between a switch and any args.
340 %{S*:X} substitutes X if one or more switches whose names start with -S are
341 specified to CC. Note that the tail part of the -S option
342 (i.e. the part matched by the `*') will be substituted for each
343 occurrence of %* within X.
344 %{S:X} substitutes X, but only if the -S switch was given to CC.
345 %{!S:X} substitutes X, but only if the -S switch was NOT given to CC.
346 %{|S:X} like %{S:X}, but if no S switch, substitute `-'.
347 %{|!S:X} like %{!S:X}, but if there is an S switch, substitute `-'.
348 %{.S:X} substitutes X, but only if processing a file with suffix S.
349 %{!.S:X} substitutes X, but only if NOT processing a file with suffix S.
350 %{S|P:X} substitutes X if either -S or -P was given to CC. This may be
351 combined with ! and . as above binding stronger than the OR.
352 %(Spec) processes a specification defined in a specs file as *Spec:
353 %[Spec] as above, but put __ around -D arguments
355 The conditional text X in a %{S:X} or %{!S:X} construct may contain
356 other nested % constructs or spaces, or even newlines. They are
357 processed as usual, as described above.
359 The -O, -f, -m, and -W switches are handled specifically in these
360 constructs. If another value of -O or the negated form of a -f, -m, or
361 -W switch is found later in the command line, the earlier switch
362 value is ignored, except with {S*} where S is just one letter; this
363 passes all matching options.
365 The character | at the beginning of the predicate text is used to indicate
366 that a command should be piped to the following command, but only if -pipe
369 Note that it is built into CC which switches take arguments and which
370 do not. You might think it would be useful to generalize this to
371 allow each compiler's spec to say which switches take arguments. But
372 this cannot be done in a consistent fashion. CC cannot even decide
373 which input files have been specified without knowing which switches
374 take arguments, and it must know which input files to compile in order
375 to tell which compilers to run.
377 CC also knows implicitly that arguments starting in `-l' are to be
378 treated as compiler output files, and passed to the linker in their
379 proper position among the other output files. */
381 /* Define the macros used for specs %a, %l, %L, %S, %c, %C, %1. */
383 /* config.h can define ASM_SPEC to provide extra args to the assembler
384 or extra switch-translations. */
389 /* config.h can define ASM_FINAL_SPEC to run a post processor after
390 the assembler has run. */
391 #ifndef ASM_FINAL_SPEC
392 #define ASM_FINAL_SPEC ""
395 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
396 or extra switch-translations. */
401 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
402 or extra switch-translations. */
407 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
408 or extra switch-translations. */
410 #define CC1PLUS_SPEC ""
413 /* config.h can define LINK_SPEC to provide extra args to the linker
414 or extra switch-translations. */
419 /* config.h can define LIB_SPEC to override the default libraries. */
421 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
424 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
427 #if defined(LINK_LIBGCC_SPECIAL) || defined(LINK_LIBGCC_SPECIAL_1)
428 /* Have gcc do the search for libgcc.a. */
429 #define LIBGCC_SPEC "libgcc.a%s"
431 #define LIBGCC_SPEC "-lgcc"
435 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
436 #ifndef STARTFILE_SPEC
437 #define STARTFILE_SPEC \
438 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
441 /* config.h can define SWITCHES_NEED_SPACES to control which options
442 require spaces between the option and the argument. */
443 #ifndef SWITCHES_NEED_SPACES
444 #define SWITCHES_NEED_SPACES ""
447 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
449 #define ENDFILE_SPEC ""
452 /* This spec is used for telling cpp whether char is signed or not. */
453 #ifndef SIGNED_CHAR_SPEC
454 /* Use #if rather than ?:
455 because MIPS C compiler rejects like ?: in initializers. */
456 #if DEFAULT_SIGNED_CHAR
457 #define SIGNED_CHAR_SPEC "%{funsigned-char:-D__CHAR_UNSIGNED__}"
459 #define SIGNED_CHAR_SPEC "%{!fsigned-char:-D__CHAR_UNSIGNED__}"
464 #define LINKER_NAME "collect2"
467 static char *cpp_spec = CPP_SPEC;
468 static char *cpp_predefines = CPP_PREDEFINES;
469 static char *cc1_spec = CC1_SPEC;
470 static char *cc1plus_spec = CC1PLUS_SPEC;
471 static char *signed_char_spec = SIGNED_CHAR_SPEC;
472 static char *asm_spec = ASM_SPEC;
473 static char *asm_final_spec = ASM_FINAL_SPEC;
474 static char *link_spec = LINK_SPEC;
475 static char *lib_spec = LIB_SPEC;
476 static char *libgcc_spec = LIBGCC_SPEC;
477 static char *endfile_spec = ENDFILE_SPEC;
478 static char *startfile_spec = STARTFILE_SPEC;
479 static char *switches_need_spaces = SWITCHES_NEED_SPACES;
480 static char *linker_name_spec = LINKER_NAME;
482 /* Some compilers have limits on line lengths, and the multilib_select
483 and/or multilib_matches strings can be very long, so we build them at
485 static struct obstack multilib_obstack;
486 static char *multilib_select;
487 static char *multilib_matches;
488 static char *multilib_defaults;
489 #include "multilib.h"
491 /* Check whether a particular argument is a default argument. */
493 #ifndef MULTILIB_DEFAULTS
494 #define MULTILIB_DEFAULTS { "" }
497 static char *multilib_defaults_raw[] = MULTILIB_DEFAULTS;
500 struct user_specs *next;
501 const char *filename;
504 static struct user_specs *user_specs_head, *user_specs_tail;
506 /* This defines which switch letters take arguments. */
508 #define DEFAULT_SWITCH_TAKES_ARG(CHAR) \
509 ((CHAR) == 'D' || (CHAR) == 'U' || (CHAR) == 'o' \
510 || (CHAR) == 'e' || (CHAR) == 'T' || (CHAR) == 'u' \
511 || (CHAR) == 'I' || (CHAR) == 'm' || (CHAR) == 'x' \
512 || (CHAR) == 'L' || (CHAR) == 'A' || (CHAR) == 'V' \
513 || (CHAR) == 'B' || (CHAR) == 'b')
515 #ifndef SWITCH_TAKES_ARG
516 #define SWITCH_TAKES_ARG(CHAR) DEFAULT_SWITCH_TAKES_ARG(CHAR)
519 /* This defines which multi-letter switches take arguments. */
521 #define DEFAULT_WORD_SWITCH_TAKES_ARG(STR) \
522 (!strcmp (STR, "Tdata") || !strcmp (STR, "Ttext") \
523 || !strcmp (STR, "Tbss") || !strcmp (STR, "include") \
524 || !strcmp (STR, "imacros") || !strcmp (STR, "aux-info") \
525 || !strcmp (STR, "idirafter") || !strcmp (STR, "iprefix") \
526 || !strcmp (STR, "iwithprefix") || !strcmp (STR, "iwithprefixbefore") \
527 || !strcmp (STR, "isystem") || !strcmp (STR, "specs"))
529 #ifndef WORD_SWITCH_TAKES_ARG
530 #define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR)
534 #ifdef HAVE_EXECUTABLE_SUFFIX
535 /* This defines which switches stop a full compilation. */
536 #define DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) \
537 ((CHAR) == 'c' || (CHAR) == 'S')
539 #ifndef SWITCH_CURTAILS_COMPILATION
540 #define SWITCH_CURTAILS_COMPILATION(CHAR) \
541 DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR)
545 /* Record the mapping from file suffixes for compilation specs. */
549 const char *suffix; /* Use this compiler for input files
550 whose names end in this suffix. */
552 const char *spec[4]; /* To use this compiler, concatenate these
553 specs and pass to do_spec. */
556 /* Pointer to a vector of `struct compiler' that gives the spec for
557 compiling a file, based on its suffix.
558 A file that does not end in any of these suffixes will be passed
559 unchanged to the loader and nothing else will be done to it.
561 An entry containing two 0s is used to terminate the vector.
563 If multiple entries match a file, the last matching one is used. */
565 static struct compiler *compilers;
567 /* Number of entries in `compilers', not counting the null terminator. */
569 static int n_compilers;
571 /* The default list of file name suffixes and their compilation specs. */
573 static struct compiler default_compilers[] =
575 /* Add lists of suffixes of known languages here. If those languages
576 were not present when we built the driver, we will hit these copies
577 and be given a more meaningful error than "file not used since
578 linking is not done". */
579 {".m", {"#Objective-C"}},
580 {".cc", {"#C++"}}, {".cxx", {"#C++"}}, {".cpp", {"#C++"}},
581 {".c++", {"#C++"}}, {".C", {"#C++"}},
582 {".ads", {"#Ada"}}, {".adb", {"#Ada"}}, {".ada", {"#Ada"}},
583 {".f", {"#Fortran"}}, {".for", {"#Fortran"}}, {".F", {"#Fortran"}},
584 {".fpp", {"#Fortran"}},
585 {".p", {"#Pascal"}}, {".pas", {"#Pascal"}},
586 /* Next come the entries for C. */
591 "%{E|M|MM:cpp -lang-c %{ansi:-std=c89} %{std*} %{nostdinc*}\
592 %{C} %{v} %{A*} %{I*} %{P} %I\
593 %{C:%{!E:%eGNU C does not support -C without using -E}}\
594 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
595 -D__GNUC__=%v1 -D__GNUC_MINOR__=%v2\
596 %{ansi|std=*:%{!std=gnu*:-trigraphs -D__STRICT_ANSI__}}\
597 %{!undef:%{!ansi:%{!std=*:%p}%{std=gnu*:%p}} %P} %{trigraphs}\
598 %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
599 %{ffast-math:-D__FAST_MATH__}\
600 %{traditional} %{ftraditional:-traditional}\
601 %{traditional-cpp:-traditional}\
602 %{fleading-underscore} %{fno-leading-underscore}\
603 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\
604 %i %{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}}\n}\
605 %{!E:%{!M:%{!MM:cc1 %i %1 \
606 %{std*} %{nostdinc*} %{A*} %{I*} %I\
607 %{!Q:-quiet} -dumpbase %b.c %{d*} %{m*} %{a*}\
608 %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
609 -D__GNUC__=%v1 -D__GNUC_MINOR__=%v2\
610 %{ansi|std=*:%{!std=gnu*:-trigraphs -D__STRICT_ANSI__}}\
611 %{!undef:%{!ansi:%{!std=*:%p}%{std=gnu*:%p}} %P} %{trigraphs}\
612 %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
613 %{ffast-math:-D__FAST_MATH__}\
614 %{H} %C %{D*} %{U*} %{i*} %Z\
615 %{ftraditional:-traditional}\
616 %{traditional-cpp:-traditional}\
617 %{traditional} %{v:-version} %{pg:-p} %{p} %{f*}\
618 %{aux-info*} %{Qn:-fno-ident}\
620 %{g*} %{O*} %{W*} %{w} %{pedantic*}\
621 %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
622 %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
624 %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}\
625 %{!pipe:%g.s} %A\n }}}}"
627 #else /* ! USE_CPPLIB */
628 "cpp -lang-c %{ansi:-std=c89} %{std*} %{nostdinc*}\
629 %{C} %{v} %{A*} %{I*} %{P} %I\
630 %{C:%{!E:%eGNU C does not support -C without using -E}}\
631 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
632 -D__GNUC__=%v1 -D__GNUC_MINOR__=%v2\
633 %{ansi|std=*:%{!std=gnu*:-trigraphs -D__STRICT_ANSI__}}\
634 %{!undef:%{!ansi:%{!std=*:%p}%{std=gnu*:%p}} %P} %{trigraphs}\
635 %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
636 %{ffast-math:-D__FAST_MATH__}\
637 %{traditional} %{ftraditional:-traditional}\
638 %{traditional-cpp:-traditional}\
639 %{fleading-underscore} %{fno-leading-underscore}\
640 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\
641 %i %{!M:%{!MM:%{!E:%{!pipe:%g.i}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
642 "%{!M:%{!MM:%{!E:cc1 %{!pipe:%g.i} %1 \
643 %{!Q:-quiet} -dumpbase %b.c %{d*} %{m*} %{a*}\
644 %{g*} %{O*} %{W*} %{w} %{pedantic*} %{std*}\
645 %{traditional} %{v:-version} %{pg:-p} %{p} %{f*}\
646 %{aux-info*} %{Qn:-fno-ident}\
648 %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
649 %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
651 %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}\
652 %{!pipe:%g.s} %A\n }}}}"
654 #endif /* ! USE_CPPLIB */
656 {"%{E:cpp -lang-c %{ansi:-std=c89} %{std*} %{nostdinc*}\
657 %{C} %{v} %{A*} %{I*} %{P} %I\
658 %{C:%{!E:%eGNU C does not support -C without using -E}}\
659 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
660 -D__GNUC__=%v1 -D__GNUC_MINOR__=%v2\
661 %{ansi|std=*:%{!std=gnu*:-trigraphs -D__STRICT_ANSI__}}\
662 %{!undef:%{!ansi:%{!std=*:%p}%{std=gnu*:%p}} %P} %{trigraphs}\
663 %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
664 %{ffast-math:-D__FAST_MATH__}\
665 %{traditional} %{ftraditional:-traditional}\
666 %{traditional-cpp:-traditional}\
667 %{fleading-underscore} %{fno-leading-underscore}\
668 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\
670 %{!E:%e-E required when input is from standard input}"}},
671 {".h", {"@c-header"}},
673 {"%{!E:%eCompilation of header file requested} \
674 cpp %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
675 %{C:%{!E:%eGNU C does not support -C without using -E}}\
676 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
677 -D__GNUC__=%v1 -D__GNUC_MINOR__=%v2\
678 %{std=*:%{!std=gnu*:-trigraphs -D__STRICT_ANSI__}}\
679 %{!undef:%{!std=*:%p}%{std=gnu*:%p} %P} %{trigraphs}\
680 %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
681 %{ffast-math:-D__FAST_MATH__}\
682 %{traditional} %{ftraditional:-traditional}\
683 %{traditional-cpp:-traditional}\
684 %{fleading-underscore} %{fno-leading-underscore}\
685 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\
687 {".i", {"@cpp-output"}},
689 {"%{!M:%{!MM:%{!E:cc1 %i %1 %{!Q:-quiet} %{d*} %{m*} %{a*}\
690 %{g*} %{O*} %{W*} %{w} %{pedantic*} %{std*}\
691 %{traditional} %{v:-version} %{pg:-p} %{p} %{f*}\
692 %{aux-info*} %{Qn:-fno-ident}\
693 %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
694 %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
696 %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}\
697 %{!pipe:%g.s} %A\n }}}}"}},
698 {".s", {"@assembler"}},
700 {"%{!M:%{!MM:%{!E:%{!S:as %a %Y\
701 %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}\
703 {".S", {"@assembler-with-cpp"}},
704 {"@assembler-with-cpp",
705 {"cpp -lang-asm %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
706 %{C:%{!E:%eGNU C does not support -C without using -E}}\
707 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG} %{trigraphs}\
708 -$ %{!undef:%p %P} -D__ASSEMBLER__ \
709 %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
710 %{ffast-math:-D__FAST_MATH__}\
711 %{traditional} %{ftraditional:-traditional}\
712 %{traditional-cpp:-traditional}\
713 %{fleading-underscore} %{fno-leading-underscore}\
714 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\
715 %i %{!M:%{!MM:%{!E:%{!pipe:%g.s}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
716 "%{!M:%{!MM:%{!E:%{!S:as %a %Y\
717 %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}\
718 %{!pipe:%g.s} %A\n }}}}"}},
720 /* Mark end of table */
724 /* Number of elements in default_compilers, not counting the terminator. */
726 static int n_default_compilers
727 = (sizeof default_compilers / sizeof (struct compiler)) - 1;
729 /* Here is the spec for running the linker, after compiling all files. */
731 /* -u* was put back because both BSD and SysV seem to support it. */
732 /* %{static:} simply prevents an error message if the target machine
733 doesn't handle -static. */
734 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
735 scripts which exist in user specified directories, or in standard
737 #ifdef LINK_COMMAND_SPEC
738 /* Provide option to override link_command_spec from machine specific
739 configuration files. */
740 static const char *link_command_spec =
743 #ifdef LINK_LIBGCC_SPECIAL
744 /* Don't generate -L options. */
745 static const char *link_command_spec = "\
747 %{!c:%{!M:%{!MM:%{!E:%{!S:%(linker) %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} \
748 %{r} %{s} %{t} %{u*} %{x} %{z} %{Z}\
749 %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
751 %{!nostdlib:%{!nodefaultlibs:%G %L %G}}\
752 %{!A:%{!nostdlib:%{!nostartfiles:%E}}}\
757 static const char *link_command_spec = "\
759 %{!c:%{!M:%{!MM:%{!E:%{!S:%(linker) %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} \
760 %{r} %{s} %{t} %{u*} %{x} %{z} %{Z}\
761 %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
762 %{static:} %{L*} %D %o\
763 %{!nostdlib:%{!nodefaultlibs:%G %L %G}}\
764 %{!A:%{!nostdlib:%{!nostartfiles:%E}}}\
770 /* A vector of options to give to the linker.
771 These options are accumulated by %x,
772 and substituted into the linker command with %X. */
773 static int n_linker_options;
774 static char **linker_options;
776 /* A vector of options to give to the assembler.
777 These options are accumulated by -Wa,
778 and substituted into the assembler command with %Y. */
779 static int n_assembler_options;
780 static char **assembler_options;
782 /* A vector of options to give to the preprocessor.
783 These options are accumulated by -Wp,
784 and substituted into the preprocessor command with %Z. */
785 static int n_preprocessor_options;
786 static char **preprocessor_options;
788 /* Define how to map long options into short ones. */
790 /* This structure describes one mapping. */
793 /* The long option's name. */
795 /* The equivalent short option. */
796 const char *equivalent;
797 /* Argument info. A string of flag chars; NULL equals no options.
798 a => argument required.
799 o => argument optional.
800 j => join argument to equivalent, making one word.
801 * => require other text after NAME as an argument. */
802 const char *arg_info;
805 /* This is the table of mappings. Mappings are tried sequentially
806 for each option encountered; the first one that matches, wins. */
808 struct option_map option_map[] =
810 {"--all-warnings", "-Wall", 0},
811 {"--ansi", "-ansi", 0},
812 {"--assemble", "-S", 0},
813 {"--assert", "-A", "a"},
814 {"--classpath", "-fclasspath=", "aj"},
815 {"--CLASSPATH", "-fCLASSPATH=", "aj"},
816 {"--comments", "-C", 0},
817 {"--compile", "-c", 0},
818 {"--debug", "-g", "oj"},
819 {"--define-macro", "-D", "aj"},
820 {"--dependencies", "-M", 0},
821 {"--dump", "-d", "a"},
822 {"--dumpbase", "-dumpbase", "a"},
823 {"--entry", "-e", 0},
824 {"--extra-warnings", "-W", 0},
825 {"--for-assembler", "-Wa", "a"},
826 {"--for-linker", "-Xlinker", "a"},
827 {"--force-link", "-u", "a"},
828 {"--imacros", "-imacros", "a"},
829 {"--include", "-include", "a"},
830 {"--include-barrier", "-I-", 0},
831 {"--include-directory", "-I", "aj"},
832 {"--include-directory-after", "-idirafter", "a"},
833 {"--include-prefix", "-iprefix", "a"},
834 {"--include-with-prefix", "-iwithprefix", "a"},
835 {"--include-with-prefix-before", "-iwithprefixbefore", "a"},
836 {"--include-with-prefix-after", "-iwithprefix", "a"},
837 {"--language", "-x", "a"},
838 {"--library-directory", "-L", "a"},
839 {"--machine", "-m", "aj"},
840 {"--machine-", "-m", "*j"},
841 {"--no-line-commands", "-P", 0},
842 {"--no-precompiled-includes", "-noprecomp", 0},
843 {"--no-standard-includes", "-nostdinc", 0},
844 {"--no-standard-libraries", "-nostdlib", 0},
845 {"--no-warnings", "-w", 0},
846 {"--optimize", "-O", "oj"},
847 {"--output", "-o", "a"},
848 {"--output-class-directory", "-foutput-class-dir=", "ja"},
849 {"--pedantic", "-pedantic", 0},
850 {"--pedantic-errors", "-pedantic-errors", 0},
851 {"--pipe", "-pipe", 0},
852 {"--prefix", "-B", "a"},
853 {"--preprocess", "-E", 0},
854 {"--print-search-dirs", "-print-search-dirs", 0},
855 {"--print-file-name", "-print-file-name=", "aj"},
856 {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
857 {"--print-missing-file-dependencies", "-MG", 0},
858 {"--print-multi-lib", "-print-multi-lib", 0},
859 {"--print-multi-directory", "-print-multi-directory", 0},
860 {"--print-prog-name", "-print-prog-name=", "aj"},
861 {"--profile", "-p", 0},
862 {"--profile-blocks", "-a", 0},
863 {"--quiet", "-q", 0},
864 {"--save-temps", "-save-temps", 0},
865 {"--shared", "-shared", 0},
866 {"--silent", "-q", 0},
867 {"--specs", "-specs=", "aj"},
868 {"--static", "-static", 0},
869 {"--std", "-std=", "aj"},
870 {"--symbolic", "-symbolic", 0},
871 {"--target", "-b", "a"},
872 {"--trace-includes", "-H", 0},
873 {"--traditional", "-traditional", 0},
874 {"--traditional-cpp", "-traditional-cpp", 0},
875 {"--trigraphs", "-trigraphs", 0},
876 {"--undefine-macro", "-U", "aj"},
877 {"--use-version", "-V", "a"},
878 {"--user-dependencies", "-MM", 0},
879 {"--verbose", "-v", 0},
880 {"--version", "-dumpversion", 0},
881 {"--warn-", "-W", "*j"},
882 {"--write-dependencies", "-MD", 0},
883 {"--write-user-dependencies", "-MMD", 0},
887 /* Translate the options described by *ARGCP and *ARGVP.
888 Make a new vector and store it back in *ARGVP,
889 and store its length in *ARGVC. */
892 translate_options (argcp, argvp)
898 const char **argv = *argvp;
900 (const char **) xmalloc ((argc + 2) * 2 * sizeof (const char *));
904 newv[newindex++] = argv[i++];
908 /* Translate -- options. */
909 if (argv[i][0] == '-' && argv[i][1] == '-')
912 /* Find a mapping that applies to this option. */
913 for (j = 0; j < sizeof (option_map) / sizeof (option_map[0]); j++)
915 size_t optlen = strlen (option_map[j].name);
916 size_t arglen = strlen (argv[i]);
917 size_t complen = arglen > optlen ? optlen : arglen;
918 const char *arginfo = option_map[j].arg_info;
923 if (!strncmp (argv[i], option_map[j].name, complen))
931 k < sizeof (option_map) / sizeof (option_map[0]);
933 if (strlen (option_map[k].name) >= arglen
934 && !strncmp (argv[i], option_map[k].name, arglen))
936 error ("Ambiguous abbreviation %s", argv[i]);
940 if (k != sizeof (option_map) / sizeof (option_map[0]))
946 /* If the option has an argument, accept that. */
947 if (argv[i][optlen] == '=')
948 arg = argv[i] + optlen + 1;
950 /* If this mapping requires extra text at end of name,
951 accept that as "argument". */
952 else if (index (arginfo, '*') != 0)
953 arg = argv[i] + optlen;
955 /* Otherwise, extra text at end means mismatch.
956 Try other mappings. */
961 else if (index (arginfo, '*') != 0)
963 error ("Incomplete `%s' option", option_map[j].name);
967 /* Handle arguments. */
968 if (index (arginfo, 'a') != 0)
974 error ("Missing argument to `%s' option",
982 else if (index (arginfo, '*') != 0)
984 else if (index (arginfo, 'o') == 0)
987 error ("Extraneous argument to `%s' option",
992 /* Store the translation as one argv elt or as two. */
993 if (arg != 0 && index (arginfo, 'j') != 0)
994 newv[newindex++] = concat (option_map[j].equivalent, arg,
998 newv[newindex++] = option_map[j].equivalent;
999 newv[newindex++] = arg;
1002 newv[newindex++] = option_map[j].equivalent;
1010 /* Handle old-fashioned options--just copy them through,
1011 with their arguments. */
1012 else if (argv[i][0] == '-')
1014 const char *p = argv[i] + 1;
1018 if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
1019 nskip += SWITCH_TAKES_ARG (c) - (p[1] != 0);
1020 else if (WORD_SWITCH_TAKES_ARG (p))
1021 nskip += WORD_SWITCH_TAKES_ARG (p);
1022 else if ((c == 'B' || c == 'b' || c == 'V' || c == 'x')
1025 else if (! strcmp (p, "Xlinker"))
1028 /* Watch out for an option at the end of the command line that
1029 is missing arguments, and avoid skipping past the end of the
1031 if (nskip + i > argc)
1036 newv[newindex++] = argv[i++];
1041 /* Ordinary operands, or +e options. */
1042 newv[newindex++] = argv[i++];
1055 #ifdef HAVE_STRERROR
1064 if (e > 0 && e < sys_nerr)
1065 return sys_errlist[e];
1077 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1078 be considered whitespace. */
1079 if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
1081 else if (*p == '\n' || *p == ' ' || *p == '\t')
1085 while (*p != '\n') p++;
1095 /* Structure to keep track of the specs that have been defined so far.
1096 These are accessed using %(specname) or %[specname] in a compiler
1101 /* The following 2 fields must be first */
1102 /* to allow EXTRA_SPECS to be initialized */
1103 char *name; /* name of the spec. */
1104 char *ptr; /* available ptr if no static pointer */
1106 /* The following fields are not initialized */
1107 /* by EXTRA_SPECS */
1108 char **ptr_spec; /* pointer to the spec itself. */
1109 struct spec_list *next; /* Next spec in linked list. */
1110 int name_len; /* length of the name */
1111 int alloc_p; /* whether string was allocated */
1114 #define INIT_STATIC_SPEC(NAME,PTR) \
1115 { NAME, NULL_PTR, PTR, (struct spec_list *)0, sizeof (NAME)-1, 0 }
1117 /* List of statically defined specs */
1118 static struct spec_list static_specs[] = {
1119 INIT_STATIC_SPEC ("asm", &asm_spec),
1120 INIT_STATIC_SPEC ("asm_final", &asm_final_spec),
1121 INIT_STATIC_SPEC ("cpp", &cpp_spec),
1122 INIT_STATIC_SPEC ("cc1", &cc1_spec),
1123 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec),
1124 INIT_STATIC_SPEC ("endfile", &endfile_spec),
1125 INIT_STATIC_SPEC ("link", &link_spec),
1126 INIT_STATIC_SPEC ("lib", &lib_spec),
1127 INIT_STATIC_SPEC ("libgcc", &libgcc_spec),
1128 INIT_STATIC_SPEC ("startfile", &startfile_spec),
1129 INIT_STATIC_SPEC ("switches_need_spaces", &switches_need_spaces),
1130 INIT_STATIC_SPEC ("signed_char", &signed_char_spec),
1131 INIT_STATIC_SPEC ("predefines", &cpp_predefines),
1132 INIT_STATIC_SPEC ("cross_compile", &cross_compile),
1133 INIT_STATIC_SPEC ("version", &compiler_version),
1134 INIT_STATIC_SPEC ("multilib", &multilib_select),
1135 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults),
1136 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra),
1137 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches),
1138 INIT_STATIC_SPEC ("linker", &linker_name_spec),
1141 #ifdef EXTRA_SPECS /* additional specs needed */
1142 /* Structure to keep track of just the first two args of a spec_list.
1143 That is all that the EXTRA_SPECS macro gives us. */
1150 static struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1151 static struct spec_list * extra_specs = (struct spec_list *)0;
1154 /* List of dynamically allocates specs that have been defined so far. */
1156 static struct spec_list *specs = (struct spec_list *)0;
1159 /* Initialize the specs lookup routines. */
1164 struct spec_list *next = (struct spec_list *)0;
1165 struct spec_list *sl = (struct spec_list *)0;
1169 return; /* already initialized */
1172 notice ("Using builtin specs.\n");
1175 extra_specs = (struct spec_list *)
1176 xmalloc (sizeof(struct spec_list) *
1177 (sizeof(extra_specs_1)/sizeof(extra_specs_1[0])));
1178 bzero ((PTR) extra_specs, sizeof(struct spec_list) *
1179 (sizeof(extra_specs_1)/sizeof(extra_specs_1[0])));
1181 for (i = (sizeof(extra_specs_1) / sizeof(extra_specs_1[0])) - 1; i >= 0; i--)
1183 sl = &extra_specs[i];
1184 sl->name = extra_specs_1[i].name;
1185 sl->ptr = extra_specs_1[i].ptr;
1187 sl->name_len = strlen (sl->name);
1188 sl->ptr_spec = &sl->ptr;
1193 for (i = (sizeof (static_specs) / sizeof (static_specs[0])) - 1; i >= 0; i--)
1195 sl = &static_specs[i];
1204 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1205 removed; If the spec starts with a + then SPEC is added to the end of the
1209 set_spec (name, spec)
1213 struct spec_list *sl;
1215 int name_len = strlen (name);
1218 /* If this is the first call, initialize the statically allocated specs */
1221 struct spec_list *next = (struct spec_list *)0;
1222 for (i = (sizeof (static_specs) / sizeof (static_specs[0])) - 1;
1225 sl = &static_specs[i];
1232 /* See if the spec already exists */
1233 for (sl = specs; sl; sl = sl->next)
1234 if (name_len == sl->name_len && !strcmp (sl->name, name))
1239 /* Not found - make it */
1240 sl = (struct spec_list *) xmalloc (sizeof (struct spec_list));
1241 sl->name = save_string (name, strlen (name));
1242 sl->name_len = name_len;
1243 sl->ptr_spec = &sl->ptr;
1245 *(sl->ptr_spec) = "";
1250 old_spec = *(sl->ptr_spec);
1251 *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
1252 ? concat (old_spec, spec + 1, NULL_PTR)
1253 : save_string (spec, strlen (spec)));
1257 notice ("Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
1260 /* Free the old spec */
1261 if (old_spec && sl->alloc_p)
1267 /* Accumulate a command (program name and args), and run it. */
1269 /* Vector of pointers to arguments in the current line of specifications. */
1271 static char **argbuf;
1273 /* Number of elements allocated in argbuf. */
1275 static int argbuf_length;
1277 /* Number of elements in argbuf currently in use (containing args). */
1279 static int argbuf_index;
1281 /* We want this on by default all the time now. */
1282 #define MKTEMP_EACH_FILE
1284 #ifdef MKTEMP_EACH_FILE
1286 extern char *make_temp_file PROTO((const char *));
1288 /* This is the list of suffixes and codes (%g/%u/%U) and the associated
1291 static struct temp_name {
1292 const char *suffix; /* suffix associated with the code. */
1293 int length; /* strlen (suffix). */
1294 int unique; /* Indicates whether %g or %u/%U was used. */
1295 const char *filename; /* associated filename. */
1296 int filename_length; /* strlen (filename). */
1297 struct temp_name *next;
1302 /* Number of commands executed so far. */
1304 static int execution_count;
1306 /* Number of commands that exited with a signal. */
1308 static int signal_count;
1310 /* Name with which this program was invoked. */
1312 static const char *programname;
1314 /* Structures to keep track of prefixes to try when looking for files. */
1318 char *prefix; /* String to prepend to the path. */
1319 struct prefix_list *next; /* Next in linked list. */
1320 int require_machine_suffix; /* Don't use without machine_suffix. */
1321 /* 2 means try both machine_suffix and just_machine_suffix. */
1322 int *used_flag_ptr; /* 1 if a file was found with this prefix. */
1327 struct prefix_list *plist; /* List of prefixes to try */
1328 int max_len; /* Max length of a prefix in PLIST */
1329 const char *name; /* Name of this list (used in config stuff) */
1332 /* List of prefixes to try when looking for executables. */
1334 static struct path_prefix exec_prefixes = { 0, 0, "exec" };
1336 /* List of prefixes to try when looking for startup (crt0) files. */
1338 static struct path_prefix startfile_prefixes = { 0, 0, "startfile" };
1340 /* List of prefixes to try when looking for include files. */
1342 static struct path_prefix include_prefixes = { 0, 0, "include" };
1344 /* Suffix to attach to directories searched for commands.
1345 This looks like `MACHINE/VERSION/'. */
1347 static const char *machine_suffix = 0;
1349 /* Suffix to attach to directories searched for commands.
1350 This is just `MACHINE/'. */
1352 static const char *just_machine_suffix = 0;
1354 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1356 static const char *gcc_exec_prefix;
1358 /* Default prefixes to attach to command names. */
1360 #ifdef CROSS_COMPILE /* Don't use these prefixes for a cross compiler. */
1361 #undef MD_EXEC_PREFIX
1362 #undef MD_STARTFILE_PREFIX
1363 #undef MD_STARTFILE_PREFIX_1
1366 #ifndef STANDARD_EXEC_PREFIX
1367 #define STANDARD_EXEC_PREFIX "/usr/local/lib/gcc-lib/"
1368 #endif /* !defined STANDARD_EXEC_PREFIX */
1370 static const char *standard_exec_prefix = STANDARD_EXEC_PREFIX;
1371 static const char *standard_exec_prefix_1 = "/usr/lib/gcc/";
1372 #ifdef MD_EXEC_PREFIX
1373 static const char *md_exec_prefix = MD_EXEC_PREFIX;
1376 #ifndef STANDARD_STARTFILE_PREFIX
1377 #define STANDARD_STARTFILE_PREFIX "/usr/local/lib/"
1378 #endif /* !defined STANDARD_STARTFILE_PREFIX */
1380 #ifdef MD_STARTFILE_PREFIX
1381 static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1383 #ifdef MD_STARTFILE_PREFIX_1
1384 static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1386 static const char *standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1387 static const char *standard_startfile_prefix_1 = "/lib/";
1388 static const char *standard_startfile_prefix_2 = "/usr/lib/";
1390 #ifndef TOOLDIR_BASE_PREFIX
1391 #define TOOLDIR_BASE_PREFIX "/usr/local/"
1393 static const char *tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1394 static const char *tooldir_prefix;
1396 /* Subdirectory to use for locating libraries. Set by
1397 set_multilib_dir based on the compilation options. */
1399 static const char *multilib_dir;
1401 /* Clear out the vector of arguments (after a command is executed). */
1409 /* Add one argument to the vector at the end.
1410 This is done when a space is seen or at the end of the line.
1411 If DELETE_ALWAYS is nonzero, the arg is a filename
1412 and the file should be deleted eventually.
1413 If DELETE_FAILURE is nonzero, the arg is a filename
1414 and the file should be deleted if this compilation fails. */
1417 store_arg (arg, delete_always, delete_failure)
1419 int delete_always, delete_failure;
1421 if (argbuf_index + 1 == argbuf_length)
1423 = (char **) xrealloc (argbuf, (argbuf_length *= 2) * sizeof (char *));
1425 argbuf[argbuf_index++] = arg;
1426 argbuf[argbuf_index] = 0;
1428 if (delete_always || delete_failure)
1429 record_temp_file (arg, delete_always, delete_failure);
1432 /* Read compilation specs from a file named FILENAME,
1433 replacing the default ones.
1435 A suffix which starts with `*' is a definition for
1436 one of the machine-specific sub-specs. The "suffix" should be
1437 *asm, *cc1, *cpp, *link, *startfile, *signed_char, etc.
1438 The corresponding spec is stored in asm_spec, etc.,
1439 rather than in the `compilers' vector.
1441 Anything invalid in the file is a fatal error. */
1444 read_specs (filename, main_p)
1445 const char *filename;
1450 struct stat statbuf;
1455 notice ("Reading specs from %s\n", filename);
1457 /* Open and stat the file. */
1458 desc = open (filename, O_RDONLY, 0);
1460 pfatal_with_name (filename);
1461 if (stat (filename, &statbuf) < 0)
1462 pfatal_with_name (filename);
1464 /* Read contents of file into BUFFER. */
1465 buffer = xmalloc ((unsigned) statbuf.st_size + 1);
1466 readlen = read (desc, buffer, (unsigned) statbuf.st_size);
1468 pfatal_with_name (filename);
1469 buffer[readlen] = 0;
1472 /* Scan BUFFER for specs, putting them in the vector. */
1478 char *in, *out, *p1, *p2, *p3;
1480 /* Advance P in BUFFER to the next nonblank nocomment line. */
1481 p = skip_whitespace (p);
1485 /* Is this a special command that starts with '%'? */
1486 /* Don't allow this for the main specs file, since it would
1487 encourage people to overwrite it. */
1488 if (*p == '%' && !main_p)
1491 while (*p && *p != '\n')
1494 p++; /* Skip '\n' */
1496 if (!strncmp (p1, "%include", sizeof ("%include")-1)
1497 && (p1[sizeof "%include" - 1] == ' '
1498 || p1[sizeof "%include" - 1] == '\t'))
1502 p1 += sizeof ("%include");
1503 while (*p1 == ' ' || *p1 == '\t')
1506 if (*p1++ != '<' || p[-2] != '>')
1507 fatal ("specs %%include syntax malformed after %ld characters",
1508 (long) (p1 - buffer + 1));
1511 new_filename = find_a_file (&startfile_prefixes, p1, R_OK);
1512 read_specs (new_filename ? new_filename : p1, FALSE);
1515 else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
1516 && (p1[sizeof "%include_noerr" - 1] == ' '
1517 || p1[sizeof "%include_noerr" - 1] == '\t'))
1521 p1 += sizeof "%include_noerr";
1522 while (*p1 == ' ' || *p1 == '\t') p1++;
1524 if (*p1++ != '<' || p[-2] != '>')
1525 fatal ("specs %%include syntax malformed after %ld characters",
1526 (long) (p1 - buffer + 1));
1529 new_filename = find_a_file (&startfile_prefixes, p1, R_OK);
1531 read_specs (new_filename, FALSE);
1532 else if (verbose_flag)
1533 notice ("Could not find specs file %s\n", p1);
1536 else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
1537 && (p1[sizeof "%rename" - 1] == ' '
1538 || p1[sizeof "%rename" - 1] == '\t'))
1541 struct spec_list *sl;
1543 /* Get original name */
1544 p1 += sizeof "%rename";
1545 while (*p1 == ' ' || *p1 == '\t')
1548 if (! ISALPHA ((unsigned char)*p1))
1549 fatal ("specs %%rename syntax malformed after %ld characters",
1550 (long) (p1 - buffer));
1553 while (*p2 && !ISSPACE ((unsigned char)*p2))
1556 if (*p2 != ' ' && *p2 != '\t')
1557 fatal ("specs %%rename syntax malformed after %ld characters",
1558 (long) (p2 - buffer));
1562 while (*p2 == ' ' || *p2 == '\t')
1565 if (! ISALPHA ((unsigned char)*p2))
1566 fatal ("specs %%rename syntax malformed after %ld characters",
1567 (long) (p2 - buffer));
1569 /* Get new spec name */
1571 while (*p3 && !ISSPACE ((unsigned char)*p3))
1575 fatal ("specs %%rename syntax malformed after %ld characters",
1576 (long) (p3 - buffer));
1579 for (sl = specs; sl; sl = sl->next)
1580 if (name_len == sl->name_len && !strcmp (sl->name, p1))
1584 fatal ("specs %s spec was not found to be renamed", p1);
1586 if (strcmp (p1, p2) == 0)
1591 notice ("rename spec %s to %s\n", p1, p2);
1593 notice ("spec is '%s'\n\n", *(sl->ptr_spec));
1597 set_spec (p2, *(sl->ptr_spec));
1599 free (*(sl->ptr_spec));
1601 *(sl->ptr_spec) = "";
1606 fatal ("specs unknown %% command after %ld characters",
1607 (long) (p1 - buffer));
1610 /* Find the colon that should end the suffix. */
1612 while (*p1 && *p1 != ':' && *p1 != '\n')
1615 /* The colon shouldn't be missing. */
1617 fatal ("specs file malformed after %ld characters",
1618 (long) (p1 - buffer));
1620 /* Skip back over trailing whitespace. */
1622 while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
1625 /* Copy the suffix to a string. */
1626 suffix = save_string (p, p2 - p);
1627 /* Find the next line. */
1628 p = skip_whitespace (p1 + 1);
1630 fatal ("specs file malformed after %ld characters",
1631 (long) (p - buffer));
1634 /* Find next blank line or end of string. */
1635 while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
1638 /* Specs end at the blank line and do not include the newline. */
1639 spec = save_string (p, p1 - p);
1642 /* Delete backslash-newline sequences from the spec. */
1647 if (in[0] == '\\' && in[1] == '\n')
1649 else if (in[0] == '#')
1650 while (*in && *in != '\n')
1658 if (suffix[0] == '*')
1660 if (! strcmp (suffix, "*link_command"))
1661 link_command_spec = spec;
1663 set_spec (suffix + 1, spec);
1667 /* Add this pair to the vector. */
1669 = ((struct compiler *)
1670 xrealloc (compilers,
1671 (n_compilers + 2) * sizeof (struct compiler)));
1673 compilers[n_compilers].suffix = suffix;
1674 bzero ((char *) compilers[n_compilers].spec,
1675 sizeof compilers[n_compilers].spec);
1676 compilers[n_compilers].spec[0] = spec;
1678 bzero ((char *) &compilers[n_compilers],
1679 sizeof compilers[n_compilers]);
1683 link_command_spec = spec;
1686 if (link_command_spec == 0)
1687 fatal ("spec file has no spec for linking");
1690 /* Record the names of temporary files we tell compilers to write,
1691 and delete them at the end of the run. */
1693 /* This is the common prefix we use to make temp file names.
1694 It is chosen once for each run of this program.
1695 It is substituted into a spec by %g.
1696 Thus, all temp file names contain this prefix.
1697 In practice, all temp file names start with this prefix.
1699 This prefix comes from the envvar TMPDIR if it is defined;
1700 otherwise, from the P_tmpdir macro if that is defined;
1701 otherwise, in /usr/tmp or /tmp;
1702 or finally the current directory if all else fails. */
1704 static const char *temp_filename;
1706 /* Length of the prefix. */
1708 static int temp_filename_length;
1710 /* Define the list of temporary files to delete. */
1715 struct temp_file *next;
1718 /* Queue of files to delete on success or failure of compilation. */
1719 static struct temp_file *always_delete_queue;
1720 /* Queue of files to delete on failure of compilation. */
1721 static struct temp_file *failure_delete_queue;
1723 /* Record FILENAME as a file to be deleted automatically.
1724 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
1725 otherwise delete it in any case.
1726 FAIL_DELETE nonzero means delete it if a compilation step fails;
1727 otherwise delete it in any case. */
1730 record_temp_file (filename, always_delete, fail_delete)
1731 const char *filename;
1735 register char *name;
1736 name = xmalloc (strlen (filename) + 1);
1737 strcpy (name, filename);
1741 register struct temp_file *temp;
1742 for (temp = always_delete_queue; temp; temp = temp->next)
1743 if (! strcmp (name, temp->name))
1746 temp = (struct temp_file *) xmalloc (sizeof (struct temp_file));
1747 temp->next = always_delete_queue;
1749 always_delete_queue = temp;
1756 register struct temp_file *temp;
1757 for (temp = failure_delete_queue; temp; temp = temp->next)
1758 if (! strcmp (name, temp->name))
1761 temp = (struct temp_file *) xmalloc (sizeof (struct temp_file));
1762 temp->next = failure_delete_queue;
1764 failure_delete_queue = temp;
1770 /* Delete all the temporary files whose names we previously recorded. */
1773 delete_if_ordinary (name)
1780 printf ("Delete %s? (y or n) ", name);
1784 while ((c = getchar ()) != '\n' && c != EOF)
1787 if (i == 'y' || i == 'Y')
1789 if (stat (name, &st) >= 0 && S_ISREG (st.st_mode))
1790 if (unlink (name) < 0)
1792 perror_with_name (name);
1796 delete_temp_files ()
1798 register struct temp_file *temp;
1800 for (temp = always_delete_queue; temp; temp = temp->next)
1801 delete_if_ordinary (temp->name);
1802 always_delete_queue = 0;
1805 /* Delete all the files to be deleted on error. */
1808 delete_failure_queue ()
1810 register struct temp_file *temp;
1812 for (temp = failure_delete_queue; temp; temp = temp->next)
1813 delete_if_ordinary (temp->name);
1817 clear_failure_queue ()
1819 failure_delete_queue = 0;
1822 /* Routine to add variables to the environment. We do this to pass
1823 the pathname of the gcc driver, and the directories search to the
1824 collect2 program, which is being run as ld. This way, we can be
1825 sure of executing the right compiler when collect2 wants to build
1826 constructors and destructors. Since the environment variables we
1827 use come from an obstack, we don't have to worry about allocating
1836 #ifndef VMS /* nor about VMS */
1838 extern char **environ;
1839 char **old_environ = environ;
1843 int str_len = strlen (str);
1847 while ((ch = *p++) != '\0' && ch != '=')
1853 /* Search for replacing an existing environment variable, and
1854 count the number of total environment variables. */
1855 for (envp = old_environ; *envp; envp++)
1858 if (!strncmp (str, *envp, name_len))
1865 /* Add a new environment variable */
1866 environ = (char **) xmalloc (sizeof (char *) * (num_envs+2));
1868 memcpy ((char *) (environ + 1), (char *) old_environ,
1869 sizeof (char *) * (num_envs+1));
1874 #endif /* HAVE_PUTENV */
1877 /* Build a list of search directories from PATHS.
1878 PREFIX is a string to prepend to the list.
1879 If CHECK_DIR_P is non-zero we ensure the directory exists.
1880 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
1881 It is also used by the --print-search-dirs flag. */
1884 build_search_list (paths, prefix, check_dir_p)
1885 struct path_prefix *paths;
1889 int suffix_len = (machine_suffix) ? strlen (machine_suffix) : 0;
1891 = (just_machine_suffix) ? strlen (just_machine_suffix) : 0;
1892 int first_time = TRUE;
1893 struct prefix_list *pprefix;
1895 obstack_grow (&collect_obstack, prefix, strlen (prefix));
1897 for (pprefix = paths->plist; pprefix != 0; pprefix = pprefix->next)
1899 int len = strlen (pprefix->prefix);
1903 || is_directory (pprefix->prefix, machine_suffix, 0)))
1906 obstack_1grow (&collect_obstack, PATH_SEPARATOR);
1909 obstack_grow (&collect_obstack, pprefix->prefix, len);
1910 obstack_grow (&collect_obstack, machine_suffix, suffix_len);
1913 if (just_machine_suffix
1914 && pprefix->require_machine_suffix == 2
1916 || is_directory (pprefix->prefix, just_machine_suffix, 0)))
1919 obstack_1grow (&collect_obstack, PATH_SEPARATOR);
1922 obstack_grow (&collect_obstack, pprefix->prefix, len);
1923 obstack_grow (&collect_obstack, just_machine_suffix,
1927 if (! pprefix->require_machine_suffix)
1930 obstack_1grow (&collect_obstack, PATH_SEPARATOR);
1933 obstack_grow (&collect_obstack, pprefix->prefix, len);
1937 obstack_1grow (&collect_obstack, '\0');
1938 return obstack_finish (&collect_obstack);
1941 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
1945 putenv_from_prefixes (paths, env_var)
1946 struct path_prefix *paths;
1947 const char *env_var;
1949 putenv (build_search_list (paths, env_var, 1));
1952 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
1953 access to check permissions.
1954 Return 0 if not found, otherwise return its name, allocated with malloc. */
1957 find_a_file (pprefix, name, mode)
1958 struct path_prefix *pprefix;
1963 const char *file_suffix = ((mode & X_OK) != 0 ? EXECUTABLE_SUFFIX : "");
1964 struct prefix_list *pl;
1965 int len = pprefix->max_len + strlen (name) + strlen (file_suffix) + 1;
1967 #ifdef DEFAULT_ASSEMBLER
1968 if (! strcmp(name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0) {
1969 name = DEFAULT_ASSEMBLER;
1970 len = strlen(name)+1;
1971 temp = xmalloc (len);
1972 strcpy (temp, name);
1977 #ifdef DEFAULT_LINKER
1978 if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0) {
1979 name = DEFAULT_LINKER;
1980 len = strlen(name)+1;
1981 temp = xmalloc (len);
1982 strcpy (temp, name);
1988 len += strlen (machine_suffix);
1990 temp = xmalloc (len);
1992 /* Determine the filename to execute (special case for absolute paths). */
1994 if (*name == '/' || *name == DIR_SEPARATOR
1995 /* Check for disk name on MS-DOS-based systems. */
1996 || (DIR_SEPARATOR == '\\' && name[1] == ':'
1997 && (name[2] == DIR_SEPARATOR || name[2] == '/')))
1999 if (access (name, mode) == 0)
2001 strcpy (temp, name);
2006 for (pl = pprefix->plist; pl; pl = pl->next)
2010 /* Some systems have a suffix for executable files.
2011 So try appending that first. */
2012 if (file_suffix[0] != 0)
2014 strcpy (temp, pl->prefix);
2015 strcat (temp, machine_suffix);
2016 strcat (temp, name);
2017 strcat (temp, file_suffix);
2018 if (access (temp, mode) == 0)
2020 if (pl->used_flag_ptr != 0)
2021 *pl->used_flag_ptr = 1;
2026 /* Now try just the name. */
2027 strcpy (temp, pl->prefix);
2028 strcat (temp, machine_suffix);
2029 strcat (temp, name);
2030 if (access (temp, mode) == 0)
2032 if (pl->used_flag_ptr != 0)
2033 *pl->used_flag_ptr = 1;
2038 /* Certain prefixes are tried with just the machine type,
2039 not the version. This is used for finding as, ld, etc. */
2040 if (just_machine_suffix && pl->require_machine_suffix == 2)
2042 /* Some systems have a suffix for executable files.
2043 So try appending that first. */
2044 if (file_suffix[0] != 0)
2046 strcpy (temp, pl->prefix);
2047 strcat (temp, just_machine_suffix);
2048 strcat (temp, name);
2049 strcat (temp, file_suffix);
2050 if (access (temp, mode) == 0)
2052 if (pl->used_flag_ptr != 0)
2053 *pl->used_flag_ptr = 1;
2058 strcpy (temp, pl->prefix);
2059 strcat (temp, just_machine_suffix);
2060 strcat (temp, name);
2061 if (access (temp, mode) == 0)
2063 if (pl->used_flag_ptr != 0)
2064 *pl->used_flag_ptr = 1;
2069 /* Certain prefixes can't be used without the machine suffix
2070 when the machine or version is explicitly specified. */
2071 if (! pl->require_machine_suffix)
2073 /* Some systems have a suffix for executable files.
2074 So try appending that first. */
2075 if (file_suffix[0] != 0)
2077 strcpy (temp, pl->prefix);
2078 strcat (temp, name);
2079 strcat (temp, file_suffix);
2080 if (access (temp, mode) == 0)
2082 if (pl->used_flag_ptr != 0)
2083 *pl->used_flag_ptr = 1;
2088 strcpy (temp, pl->prefix);
2089 strcat (temp, name);
2090 if (access (temp, mode) == 0)
2092 if (pl->used_flag_ptr != 0)
2093 *pl->used_flag_ptr = 1;
2103 /* Add an entry for PREFIX in PLIST. If FIRST is set, it goes
2104 at the start of the list, otherwise it goes at the end.
2106 If WARN is nonzero, we will warn if no file is found
2107 through this prefix. WARN should point to an int
2108 which will be set to 1 if this entry is used.
2110 COMPONENT is the value to be passed to update_path.
2112 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2113 the complete value of machine_suffix.
2114 2 means try both machine_suffix and just_machine_suffix. */
2117 add_prefix (pprefix, prefix, component, first, require_machine_suffix, warn)
2118 struct path_prefix *pprefix;
2120 const char *component;
2122 int require_machine_suffix;
2125 struct prefix_list *pl, **prev;
2128 if (! first && pprefix->plist)
2130 for (pl = pprefix->plist; pl->next; pl = pl->next)
2135 prev = &pprefix->plist;
2137 /* Keep track of the longest prefix */
2139 prefix = update_path (prefix, component);
2140 len = strlen (prefix);
2141 if (len > pprefix->max_len)
2142 pprefix->max_len = len;
2144 pl = (struct prefix_list *) xmalloc (sizeof (struct prefix_list));
2145 pl->prefix = save_string (prefix, len);
2146 pl->require_machine_suffix = require_machine_suffix;
2147 pl->used_flag_ptr = warn;
2154 pl->next = (struct prefix_list *) 0;
2158 /* Print warnings for any prefixes in the list PPREFIX that were not used. */
2161 unused_prefix_warnings (pprefix)
2162 struct path_prefix *pprefix;
2164 struct prefix_list *pl = pprefix->plist;
2168 if (pl->used_flag_ptr != 0 && !*pl->used_flag_ptr)
2170 if (pl->require_machine_suffix && machine_suffix)
2171 error ("file path prefix `%s%s' never used", pl->prefix,
2174 error ("file path prefix `%s' never used", pl->prefix);
2176 /* Prevent duplicate warnings. */
2177 *pl->used_flag_ptr = 1;
2185 /* Execute the command specified by the arguments on the current line of spec.
2186 When using pipes, this includes several piped-together commands
2187 with `|' between them.
2189 Return 0 if successful, -1 if failed. */
2195 int n_commands; /* # of command. */
2199 const char *prog; /* program name. */
2200 char **argv; /* vector of args. */
2201 int pid; /* pid of process for this command. */
2204 struct command *commands; /* each command buffer with above info. */
2206 /* Count # of piped commands. */
2207 for (n_commands = 1, i = 0; i < argbuf_index; i++)
2208 if (strcmp (argbuf[i], "|") == 0)
2211 /* Get storage for each command. */
2213 = (struct command *) alloca (n_commands * sizeof (struct command));
2215 /* Split argbuf into its separate piped processes,
2216 and record info about each one.
2217 Also search for the programs that are to be run. */
2219 commands[0].prog = argbuf[0]; /* first command. */
2220 commands[0].argv = &argbuf[0];
2221 string = find_a_file (&exec_prefixes, commands[0].prog, X_OK);
2224 commands[0].argv[0] = string;
2226 for (n_commands = 1, i = 0; i < argbuf_index; i++)
2227 if (strcmp (argbuf[i], "|") == 0)
2228 { /* each command. */
2229 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2230 fatal ("-pipe not supported");
2232 argbuf[i] = 0; /* termination of command args. */
2233 commands[n_commands].prog = argbuf[i + 1];
2234 commands[n_commands].argv = &argbuf[i + 1];
2235 string = find_a_file (&exec_prefixes, commands[n_commands].prog, X_OK);
2237 commands[n_commands].argv[0] = string;
2241 argbuf[argbuf_index] = 0;
2243 /* If -v, print what we are about to do, and maybe query. */
2247 /* For help listings, put a blank line between sub-processes. */
2248 if (print_help_list)
2249 fputc ('\n', stderr);
2251 /* Print each piped command as a separate line. */
2252 for (i = 0; i < n_commands ; i++)
2256 for (j = commands[i].argv; *j; j++)
2257 fprintf (stderr, " %s", *j);
2259 /* Print a pipe symbol after all but the last command. */
2260 if (i + 1 != n_commands)
2261 fprintf (stderr, " |");
2262 fprintf (stderr, "\n");
2266 notice ("\nGo ahead? (y or n) ");
2270 while (getchar () != '\n')
2273 if (i != 'y' && i != 'Y')
2278 /* Run each piped subprocess. */
2280 for (i = 0; i < n_commands; i++)
2282 char *errmsg_fmt, *errmsg_arg;
2283 char *string = commands[i].argv[0];
2285 commands[i].pid = pexecute (string, commands[i].argv,
2286 programname, temp_filename,
2287 &errmsg_fmt, &errmsg_arg,
2288 ((i == 0 ? PEXECUTE_FIRST : 0)
2289 | (i + 1 == n_commands ? PEXECUTE_LAST : 0)
2290 | (string == commands[i].prog
2291 ? PEXECUTE_SEARCH : 0)
2292 | (verbose_flag ? PEXECUTE_VERBOSE : 0)));
2294 if (commands[i].pid == -1)
2295 pfatal_pexecute (errmsg_fmt, errmsg_arg);
2297 if (string != commands[i].prog)
2303 /* Wait for all the subprocesses to finish.
2304 We don't care what order they finish in;
2305 we know that N_COMMANDS waits will get them all.
2306 Ignore subprocesses that we don't know about,
2307 since they can be spawned by the process that exec'ed us. */
2312 for (i = 0; i < n_commands; )
2318 pid = pwait (commands[i].pid, &status, 0);
2322 for (j = 0; j < n_commands; j++)
2323 if (commands[j].pid == pid)
2328 if (WIFSIGNALED (status))
2330 fatal ("Internal compiler error: program %s got fatal signal %d",
2331 commands[j].prog, WTERMSIG (status));
2335 else if (WIFEXITED (status)
2336 && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
2346 /* Find all the switches given to us
2347 and make a vector describing them.
2348 The elements of the vector are strings, one per switch given.
2349 If a switch uses following arguments, then the `part1' field
2350 is the switch itself and the `args' field
2351 is a null-terminated vector containing the following arguments.
2352 The `live_cond' field is 1 if the switch is true in a conditional spec,
2353 -1 if false (overridden by a later switch), and is initialized to zero.
2354 The `validated' field is nonzero if any spec has looked at this switch;
2355 if it remains zero at the end of the run, it must be meaningless. */
2365 static struct switchstr *switches;
2367 static int n_switches;
2372 const char *language;
2375 /* Also a vector of input files specified. */
2377 static struct infile *infiles;
2379 static int n_infiles;
2381 /* This counts the number of libraries added by lang_specific_driver, so that
2382 we can tell if there were any user supplied any files or libraries. */
2384 static int added_libraries;
2386 /* And a vector of corresponding output files is made up later. */
2388 static const char **outfiles;
2390 /* Used to track if none of the -B paths are used. */
2393 /* Used to track if standard path isn't used and -b or -V is specified. */
2394 static int warn_std;
2396 /* Gives value to pass as "warn" to add_prefix for standard prefixes. */
2397 static int *warn_std_ptr = 0;
2400 #if defined(HAVE_OBJECT_SUFFIX) || defined(HAVE_EXECUTABLE_SUFFIX)
2402 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
2403 is true if we should look for an executable suffix as well. */
2406 convert_filename (name, do_exe)
2416 len = strlen (name);
2418 #ifdef HAVE_OBJECT_SUFFIX
2419 /* Convert x.o to x.obj if OBJECT_SUFFIX is ".obj". */
2421 && name[len - 2] == '.'
2422 && name[len - 1] == 'o')
2424 obstack_grow (&obstack, name, len - 2);
2425 obstack_grow0 (&obstack, OBJECT_SUFFIX, strlen (OBJECT_SUFFIX));
2426 name = obstack_finish (&obstack);
2430 #ifdef HAVE_EXECUTABLE_SUFFIX
2431 /* If there is no filetype, make it the executable suffix (which includes
2432 the "."). But don't get confused if we have just "-o". */
2433 if (! do_exe || EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
2436 for (i = len - 1; i >= 0; i--)
2437 if (name[i] == '/' || name[i] == DIR_SEPARATOR)
2440 for (i++; i < len; i++)
2444 obstack_grow (&obstack, name, len);
2445 obstack_grow0 (&obstack, EXECUTABLE_SUFFIX, strlen (EXECUTABLE_SUFFIX));
2446 name = obstack_finish (&obstack);
2453 /* Display the command line switches accepted by gcc. */
2457 printf ("Usage: %s [options] file...\n", programname);
2458 printf ("Options:\n");
2460 printf (" --help Display this information\n");
2462 printf (" (Use '-v --help' to display command line options of sub-processes)\n");
2463 printf (" -dumpspecs Display all of the built in spec strings\n");
2464 printf (" -dumpversion Display the version of the compiler\n");
2465 printf (" -dumpmachine Display the compiler's target processor\n");
2466 printf (" -print-search-dirs Display the directories in the compiler's search path\n");
2467 printf (" -print-libgcc-file-name Display the name of the compiler's companion library\n");
2468 printf (" -print-file-name=<lib> Display the full path to library <lib>\n");
2469 printf (" -print-prog-name=<prog> Display the full path to compiler component <prog>\n");
2470 printf (" -print-multi-directory Display the root directory for versions of libgcc\n");
2471 printf (" -print-multi-lib Display the mapping between command line options and\n");
2472 printf (" multiple library search directories\n");
2473 printf (" -Wa,<options> Pass comma-separated <options> on to the assembler\n");
2474 printf (" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n");
2475 printf (" -Wl,<options> Pass comma-separated <options> on to the linker\n");
2476 printf (" -Xlinker <arg> Pass <arg> on to the linker\n");
2477 printf (" -save-temps Do not delete intermediate files\n");
2478 printf (" -pipe Use pipes rather than intermediate files\n");
2479 printf (" -specs=<file> Override builtin specs with the contents of <file>\n");
2480 printf (" -std=<standard> Assume that the input sources are for <standard>\n");
2481 printf (" -B <directory> Add <directory> to the compiler's search paths\n");
2482 printf (" -b <machine> Run gcc for target <machine>, if installed\n");
2483 printf (" -V <version> Run gcc version number <version>, if installed\n");
2484 printf (" -v Display the programs invoked by the compiler\n");
2485 printf (" -E Preprocess only; do not compile, assemble or link\n");
2486 printf (" -S Compile only; do not assemble or link\n");
2487 printf (" -c Compile and assemble, but do not link\n");
2488 printf (" -o <file> Place the output into <file>\n");
2489 printf (" -x <language> Specify the language of the following input files\n");
2490 printf (" Permissable languages include: c c++ assembler none\n");
2491 printf (" 'none' means revert to the default behaviour of\n");
2492 printf (" guessing the language based on the file's extension\n");
2494 printf ("\nOptions starting with -g, -f, -m, -O or -W are automatically passed on to\n");
2495 printf ("the various sub-processes invoked by %s. In order to pass other options\n",
2497 printf ("on to these processes the -W<letter> options must be used.\n");
2499 /* The rest of the options are displayed by invocations of the various
2504 add_preprocessor_option (option, len)
2505 const char * option;
2508 n_preprocessor_options++;
2510 if (! preprocessor_options)
2511 preprocessor_options
2512 = (char **) xmalloc (n_preprocessor_options * sizeof (char *));
2514 preprocessor_options
2515 = (char **) xrealloc (preprocessor_options,
2516 n_preprocessor_options * sizeof (char *));
2518 preprocessor_options [n_preprocessor_options - 1] =
2519 save_string (option, len);
2523 add_assembler_option (option, len)
2524 const char * option;
2527 n_assembler_options++;
2529 if (! assembler_options)
2531 = (char **) xmalloc (n_assembler_options * sizeof (char *));
2534 = (char **) xrealloc (assembler_options,
2535 n_assembler_options * sizeof (char *));
2537 assembler_options [n_assembler_options - 1] = save_string (option, len);
2541 add_linker_option (option, len)
2542 const char * option;
2547 if (! linker_options)
2549 = (char **) xmalloc (n_linker_options * sizeof (char *));
2552 = (char **) xrealloc (linker_options,
2553 n_linker_options * sizeof (char *));
2555 linker_options [n_linker_options - 1] = save_string (option, len);
2558 /* Create the vector `switches' and its contents.
2559 Store its length in `n_switches'. */
2562 process_command (argc, argv)
2569 char *spec_lang = 0;
2570 int last_language_n_infiles;
2573 int lang_n_infiles = 0;
2575 GET_ENV_PATH_LIST (gcc_exec_prefix, "GCC_EXEC_PREFIX");
2579 added_libraries = 0;
2581 /* Figure compiler version from version string. */
2583 compiler_version = temp1 =
2584 save_string (version_string, strlen (version_string));
2585 for (; *temp1; ++temp1)
2594 /* Set up the default search paths. */
2596 if (gcc_exec_prefix)
2598 int len = strlen (gcc_exec_prefix);
2599 if (len > (int) sizeof ("/lib/gcc-lib/")-1
2600 && (gcc_exec_prefix[len-1] == '/'
2601 || gcc_exec_prefix[len-1] == DIR_SEPARATOR))
2603 temp = gcc_exec_prefix + len - sizeof ("/lib/gcc-lib/") + 1;
2604 if ((*temp == '/' || *temp == DIR_SEPARATOR)
2605 && strncmp (temp+1, "lib", 3) == 0
2606 && (temp[4] == '/' || temp[4] == DIR_SEPARATOR)
2607 && strncmp (temp+5, "gcc-lib", 7) == 0)
2608 len -= sizeof ("/lib/gcc-lib/") - 1;
2611 set_std_prefix (gcc_exec_prefix, len);
2612 add_prefix (&exec_prefixes, gcc_exec_prefix, "GCC", 0, 0, NULL_PTR);
2613 add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC", 0, 0, NULL_PTR);
2616 /* COMPILER_PATH and LIBRARY_PATH have values
2617 that are lists of directory names with colons. */
2619 GET_ENV_PATH_LIST (temp, "COMPILER_PATH");
2622 const char *startp, *endp;
2623 char *nstore = (char *) alloca (strlen (temp) + 3);
2625 startp = endp = temp;
2628 if (*endp == PATH_SEPARATOR || *endp == 0)
2630 strncpy (nstore, startp, endp-startp);
2632 strcpy (nstore, concat (".", dir_separator_str, NULL_PTR));
2633 else if (endp[-1] != '/' && endp[-1] != DIR_SEPARATOR)
2635 nstore[endp-startp] = DIR_SEPARATOR;
2636 nstore[endp-startp+1] = 0;
2639 nstore[endp-startp] = 0;
2640 add_prefix (&exec_prefixes, nstore, 0, 0, 0, NULL_PTR);
2641 add_prefix (&include_prefixes,
2642 concat (nstore, "include", NULL_PTR),
2646 endp = startp = endp + 1;
2653 GET_ENV_PATH_LIST (temp, "LIBRARY_PATH");
2654 if (temp && *cross_compile == '0')
2656 const char *startp, *endp;
2657 char *nstore = (char *) alloca (strlen (temp) + 3);
2659 startp = endp = temp;
2662 if (*endp == PATH_SEPARATOR || *endp == 0)
2664 strncpy (nstore, startp, endp-startp);
2666 strcpy (nstore, concat (".", dir_separator_str, NULL_PTR));
2667 else if (endp[-1] != '/' && endp[-1] != DIR_SEPARATOR)
2669 nstore[endp-startp] = DIR_SEPARATOR;
2670 nstore[endp-startp+1] = 0;
2673 nstore[endp-startp] = 0;
2674 add_prefix (&startfile_prefixes, nstore, NULL_PTR,
2678 endp = startp = endp + 1;
2685 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
2686 GET_ENV_PATH_LIST (temp, "LPATH");
2687 if (temp && *cross_compile == '0')
2689 const char *startp, *endp;
2690 char *nstore = (char *) alloca (strlen (temp) + 3);
2692 startp = endp = temp;
2695 if (*endp == PATH_SEPARATOR || *endp == 0)
2697 strncpy (nstore, startp, endp-startp);
2699 strcpy (nstore, concat (".", dir_separator_str, NULL_PTR));
2700 else if (endp[-1] != '/' && endp[-1] != DIR_SEPARATOR)
2702 nstore[endp-startp] = DIR_SEPARATOR;
2703 nstore[endp-startp+1] = 0;
2706 nstore[endp-startp] = 0;
2707 add_prefix (&startfile_prefixes, nstore, NULL_PTR,
2711 endp = startp = endp + 1;
2718 /* Convert new-style -- options to old-style. */
2719 translate_options (&argc, &argv);
2721 /* Do language-specific adjustment/addition of flags. */
2722 lang_specific_driver (fatal, &argc, &argv, &added_libraries);
2724 /* Scan argv twice. Here, the first time, just count how many switches
2725 there will be in their vector, and how many input files in theirs.
2726 Here we also parse the switches that cc itself uses (e.g. -v). */
2728 for (i = 1; i < argc; i++)
2730 if (! strcmp (argv[i], "-dumpspecs"))
2732 struct spec_list *sl;
2734 for (sl = specs; sl; sl = sl->next)
2735 printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
2736 if (link_command_spec)
2737 printf ("*link_command:\n%s\n\n", link_command_spec);
2740 else if (! strcmp (argv[i], "-dumpversion"))
2742 printf ("%s\n", spec_version);
2745 else if (! strcmp (argv[i], "-dumpmachine"))
2747 printf ("%s\n", spec_machine);
2750 else if (strcmp (argv[i], "-fhelp") == 0)
2752 /* translate_options () has turned --help into -fhelp. */
2753 print_help_list = 1;
2755 /* We will be passing a dummy file on to the sub-processes. */
2759 add_preprocessor_option ("--help", 6);
2760 add_assembler_option ("--help", 6);
2761 add_linker_option ("--help", 6);
2763 else if (! strcmp (argv[i], "-print-search-dirs"))
2764 print_search_dirs = 1;
2765 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
2766 print_file_name = "libgcc.a";
2767 else if (! strncmp (argv[i], "-print-file-name=", 17))
2768 print_file_name = argv[i] + 17;
2769 else if (! strncmp (argv[i], "-print-prog-name=", 17))
2770 print_prog_name = argv[i] + 17;
2771 else if (! strcmp (argv[i], "-print-multi-lib"))
2772 print_multi_lib = 1;
2773 else if (! strcmp (argv[i], "-print-multi-directory"))
2774 print_multi_directory = 1;
2775 else if (! strncmp (argv[i], "-Wa,", 4))
2778 /* Pass the rest of this option to the assembler. */
2780 /* Split the argument at commas. */
2782 for (j = 4; argv[i][j]; j++)
2783 if (argv[i][j] == ',')
2785 add_assembler_option (argv[i] + prev, j - prev);
2789 /* Record the part after the last comma. */
2790 add_assembler_option (argv[i] + prev, j - prev);
2792 else if (! strncmp (argv[i], "-Wp,", 4))
2795 /* Pass the rest of this option to the preprocessor. */
2797 /* Split the argument at commas. */
2799 for (j = 4; argv[i][j]; j++)
2800 if (argv[i][j] == ',')
2802 add_preprocessor_option (argv[i] + prev, j - prev);
2806 /* Record the part after the last comma. */
2807 add_preprocessor_option (argv[i] + prev, j - prev);
2809 else if (argv[i][0] == '+' && argv[i][1] == 'e')
2810 /* The +e options to the C++ front-end. */
2812 else if (strncmp (argv[i], "-Wl,", 4) == 0)
2815 /* Split the argument at commas. */
2816 for (j = 3; argv[i][j]; j++)
2817 n_infiles += (argv[i][j] == ',');
2819 else if (strcmp (argv[i], "-Xlinker") == 0)
2822 fatal ("argument to `-Xlinker' is missing");
2827 else if (strncmp (argv[i], "-l", 2) == 0)
2829 else if (strcmp (argv[i], "-save-temps") == 0)
2831 save_temps_flag = 1;
2834 else if (strcmp (argv[i], "-specs") == 0)
2836 struct user_specs *user = (struct user_specs *)
2837 xmalloc (sizeof (struct user_specs));
2839 fatal ("argument to `-specs' is missing");
2841 user->next = (struct user_specs *)0;
2842 user->filename = argv[i];
2843 if (user_specs_tail)
2844 user_specs_tail->next = user;
2846 user_specs_head = user;
2847 user_specs_tail = user;
2849 else if (strncmp (argv[i], "-specs=", 7) == 0)
2851 struct user_specs *user = (struct user_specs *)
2852 xmalloc (sizeof (struct user_specs));
2853 if (strlen (argv[i]) == 7)
2854 fatal ("argument to `-specs=' is missing");
2856 user->next = (struct user_specs *)0;
2857 user->filename = argv[i]+7;
2858 if (user_specs_tail)
2859 user_specs_tail->next = user;
2861 user_specs_head = user;
2862 user_specs_tail = user;
2864 else if (argv[i][0] == '-' && argv[i][1] != 0)
2866 register char *p = &argv[i][1];
2867 register int c = *p;
2873 if (p[1] == 0 && i + 1 == argc)
2874 fatal ("argument to `-b' is missing");
2876 spec_machine = argv[++i];
2878 spec_machine = p + 1;
2880 warn_std_ptr = &warn_std;
2886 if (p[1] == 0 && i + 1 == argc)
2887 fatal ("argument to `-B' is missing");
2892 add_prefix (&exec_prefixes, value, NULL_PTR, 1, 0, &warn_B);
2893 add_prefix (&startfile_prefixes, value, NULL_PTR,
2895 add_prefix (&include_prefixes, concat (value, "include",
2897 NULL_PTR, 1, 0, NULL_PTR);
2899 /* As a kludge, if the arg is "[foo/]stageN/", just add
2900 "[foo/]include" to the include prefix. */
2902 int len = strlen (value);
2905 && (value[len - 8] == '/'
2906 || value[len - 8] == DIR_SEPARATOR)))
2907 && strncmp (value + len - 7, "stage", 5) == 0
2908 && ISDIGIT (value[len - 2])
2909 && (value[len - 1] == '/'
2910 || value[len - 1] == DIR_SEPARATOR))
2913 add_prefix (&include_prefixes, "include", NULL_PTR,
2917 char *string = xmalloc (len + 1);
2918 strncpy (string, value, len-7);
2919 strcpy (string+len-7, "include");
2920 add_prefix (&include_prefixes, string, NULL_PTR,
2929 case 'v': /* Print our subcommands and print versions. */
2931 /* If they do anything other than exactly `-v', don't set
2932 verbose_flag; rather, continue on to give the error. */
2940 if (p[1] == 0 && i + 1 == argc)
2941 fatal ("argument to `-V' is missing");
2943 spec_version = argv[++i];
2945 spec_version = p + 1;
2946 compiler_version = spec_version;
2947 warn_std_ptr = &warn_std;
2949 /* Validate the version number. Use the same checks
2950 done when inserting it into a spec.
2952 The format of the version string is
2953 ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)? */
2955 const char *v = compiler_version;
2957 /* Ignore leading non-digits. i.e. "foo-" in "foo-2.7.2". */
2958 while (! ISDIGIT (*v))
2961 if (v > compiler_version && v[-1] != '-')
2962 fatal ("invalid version number format");
2964 /* Set V after the first period. */
2965 while (ISDIGIT (*v))
2969 fatal ("invalid version number format");
2972 while (ISDIGIT (*v))
2975 if (*v != 0 && *v != ' ' && *v != '.' && *v != '-')
2976 fatal ("invalid version number format");
2992 #if defined(HAVE_EXECUTABLE_SUFFIX)
2997 /* Forward scan, just in case -S or -c is specified
3004 if (argv[j][0] == '-')
3006 if (SWITCH_CURTAILS_COMPILATION (argv[j][1])
3012 else if (skip = SWITCH_TAKES_ARG (argv[j][1]))
3013 j += skip - (argv[j][2] != 0);
3014 else if (skip = WORD_SWITCH_TAKES_ARG (argv[j] + 1))
3021 #if defined(HAVE_EXECUTABLE_SUFFIX) || defined(HAVE_OBJECT_SUFFIX)
3023 argv[i+1] = convert_filename (argv[i+1], ! have_c);
3025 argv[i] = convert_filename (argv[i], ! have_c);
3033 if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
3034 i += SWITCH_TAKES_ARG (c) - (p[1] != 0);
3035 else if (WORD_SWITCH_TAKES_ARG (p))
3036 i += WORD_SWITCH_TAKES_ARG (p);
3046 if (have_c && have_o && lang_n_infiles > 1)
3047 fatal ("cannot specify -o with -c or -S and multiple compilations");
3049 /* Set up the search paths before we go looking for config files. */
3051 /* These come before the md prefixes so that we will find gcc's subcommands
3052 (such as cpp) rather than those of the host system. */
3053 /* Use 2 as fourth arg meaning try just the machine as a suffix,
3054 as well as trying the machine and the version. */
3056 add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
3057 0, 2, warn_std_ptr);
3058 add_prefix (&exec_prefixes, standard_exec_prefix_1, "BINUTILS",
3059 0, 2, warn_std_ptr);
3062 add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
3063 0, 1, warn_std_ptr);
3064 add_prefix (&startfile_prefixes, standard_exec_prefix_1, "BINUTILS",
3065 0, 1, warn_std_ptr);
3067 tooldir_prefix = concat (tooldir_base_prefix, spec_machine,
3068 dir_separator_str, NULL_PTR);
3070 /* If tooldir is relative, base it on exec_prefixes. A relative
3071 tooldir lets us move the installed tree as a unit.
3073 If GCC_EXEC_PREFIX is defined, then we want to add two relative
3074 directories, so that we can search both the user specified directory
3075 and the standard place. */
3077 if (*tooldir_prefix != '/' && *tooldir_prefix != DIR_SEPARATOR)
3079 if (gcc_exec_prefix)
3081 char *gcc_exec_tooldir_prefix
3082 = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
3083 spec_version, dir_separator_str, tooldir_prefix, NULL_PTR);
3085 add_prefix (&exec_prefixes,
3086 concat (gcc_exec_tooldir_prefix, "bin",
3087 dir_separator_str, NULL_PTR),
3088 NULL_PTR, 0, 0, NULL_PTR);
3089 add_prefix (&startfile_prefixes,
3090 concat (gcc_exec_tooldir_prefix, "lib",
3091 dir_separator_str, NULL_PTR),
3092 NULL_PTR, 0, 0, NULL_PTR);
3095 tooldir_prefix = concat (standard_exec_prefix, spec_machine,
3096 dir_separator_str, spec_version,
3097 dir_separator_str, tooldir_prefix, NULL_PTR);
3100 add_prefix (&exec_prefixes,
3101 concat (tooldir_prefix, "bin", dir_separator_str, NULL_PTR),
3102 "BINUTILS", 0, 0, NULL_PTR);
3103 add_prefix (&startfile_prefixes,
3104 concat (tooldir_prefix, "lib", dir_separator_str, NULL_PTR),
3105 "BINUTILS", 0, 0, NULL_PTR);
3107 /* More prefixes are enabled in main, after we read the specs file
3108 and determine whether this is cross-compilation or not. */
3111 /* Then create the space for the vectors and scan again. */
3113 switches = ((struct switchstr *)
3114 xmalloc ((n_switches + 1) * sizeof (struct switchstr)));
3115 infiles = (struct infile *) xmalloc ((n_infiles + 1) * sizeof (struct infile));
3118 last_language_n_infiles = -1;
3120 /* This, time, copy the text of each switch and store a pointer
3121 to the copy in the vector of switches.
3122 Store all the infiles in their vector. */
3124 for (i = 1; i < argc; i++)
3126 /* Just skip the switches that were handled by the preceding loop. */
3127 if (! strncmp (argv[i], "-Wa,", 4))
3129 else if (! strncmp (argv[i], "-Wp,", 4))
3131 else if (! strcmp (argv[i], "-print-search-dirs"))
3133 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3135 else if (! strncmp (argv[i], "-print-file-name=", 17))
3137 else if (! strncmp (argv[i], "-print-prog-name=", 17))
3139 else if (! strcmp (argv[i], "-print-multi-lib"))
3141 else if (! strcmp (argv[i], "-print-multi-directory"))
3143 else if (strcmp (argv[i], "-fhelp") == 0)
3147 /* Create a dummy input file, so that we can pass --help on to
3148 the various sub-processes. */
3149 infiles[n_infiles].language = "c";
3150 infiles[n_infiles++].name = "help-dummy";
3152 /* Preserve the --help switch so that it can be caught by the
3154 switches[n_switches].part1 = "--help";
3155 switches[n_switches].args = 0;
3156 switches[n_switches].live_cond = 0;
3157 switches[n_switches].validated = 0;
3162 else if (argv[i][0] == '+' && argv[i][1] == 'e')
3164 /* Compensate for the +e options to the C++ front-end;
3165 they're there simply for cfront call-compatibility. We do
3166 some magic in default_compilers to pass them down properly.
3167 Note we deliberately start at the `+' here, to avoid passing
3168 -e0 or -e1 down into the linker. */
3169 switches[n_switches].part1 = &argv[i][0];
3170 switches[n_switches].args = 0;
3171 switches[n_switches].live_cond = 0;
3172 switches[n_switches].validated = 0;
3175 else if (strncmp (argv[i], "-Wl,", 4) == 0)
3178 /* Split the argument at commas. */
3180 for (j = 4; argv[i][j]; j++)
3181 if (argv[i][j] == ',')
3183 infiles[n_infiles].language = "*";
3184 infiles[n_infiles++].name
3185 = save_string (argv[i] + prev, j - prev);
3188 /* Record the part after the last comma. */
3189 infiles[n_infiles].language = "*";
3190 infiles[n_infiles++].name = argv[i] + prev;
3192 else if (strcmp (argv[i], "-Xlinker") == 0)
3194 infiles[n_infiles].language = "*";
3195 infiles[n_infiles++].name = argv[++i];
3197 else if (strncmp (argv[i], "-l", 2) == 0)
3199 infiles[n_infiles].language = "*";
3200 infiles[n_infiles++].name = argv[i];
3202 else if (strcmp (argv[i], "-specs") == 0)
3204 else if (strncmp (argv[i], "-specs=", 7) == 0)
3206 /* -save-temps overrides -pipe, so that temp files are produced */
3207 else if (save_temps_flag && strcmp (argv[i], "-pipe") == 0)
3208 error ("Warning: -pipe ignored since -save-temps specified");
3209 else if (argv[i][0] == '-' && argv[i][1] != 0)
3211 register char *p = &argv[i][1];
3212 register int c = *p;
3216 if (p[1] == 0 && i + 1 == argc)
3217 fatal ("argument to `-x' is missing");
3219 spec_lang = argv[++i];
3222 if (! strcmp (spec_lang, "none"))
3223 /* Suppress the warning if -xnone comes after the last input
3224 file, because alternate command interfaces like g++ might
3225 find it useful to place -xnone after each input file. */
3228 last_language_n_infiles = n_infiles;
3231 switches[n_switches].part1 = p;
3232 /* Deal with option arguments in separate argv elements. */
3233 if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
3234 || WORD_SWITCH_TAKES_ARG (p))
3237 int n_args = WORD_SWITCH_TAKES_ARG (p);
3241 /* Count only the option arguments in separate argv elements. */
3242 n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
3244 if (i + n_args >= argc)
3245 fatal ("argument to `-%s' is missing", p);
3246 switches[n_switches].args
3247 = (char **) xmalloc ((n_args + 1) * sizeof (char *));
3249 switches[n_switches].args[j++] = argv[++i];
3250 /* Null-terminate the vector. */
3251 switches[n_switches].args[j] = 0;
3253 else if (index (switches_need_spaces, c))
3255 /* On some systems, ld cannot handle some options without
3256 a space. So split the option from its argument. */
3257 char *part1 = (char *) xmalloc (2);
3261 switches[n_switches].part1 = part1;
3262 switches[n_switches].args = (char **) xmalloc (2 * sizeof (char *));
3263 switches[n_switches].args[0] = xmalloc (strlen (p));
3264 strcpy (switches[n_switches].args[0], &p[1]);
3265 switches[n_switches].args[1] = 0;
3268 switches[n_switches].args = 0;
3270 switches[n_switches].live_cond = 0;
3271 switches[n_switches].validated = 0;
3272 /* This is always valid, since gcc.c itself understands it. */
3273 if (!strcmp (p, "save-temps"))
3274 switches[n_switches].validated = 1;
3277 char ch = switches[n_switches].part1[0];
3278 if (ch == 'V' || ch == 'b' || ch == 'B')
3279 switches[n_switches].validated = 1;
3285 #ifdef HAVE_OBJECT_SUFFIX
3286 argv[i] = convert_filename (argv[i], 0);
3289 if (strcmp (argv[i], "-") != 0 && access (argv[i], R_OK) < 0)
3291 perror_with_name (argv[i]);
3296 infiles[n_infiles].language = spec_lang;
3297 infiles[n_infiles++].name = argv[i];
3302 if (n_infiles == last_language_n_infiles && spec_lang != 0)
3303 error ("Warning: `-x %s' after last input file has no effect", spec_lang);
3305 switches[n_switches].part1 = 0;
3306 infiles[n_infiles].name = 0;
3309 /* Process a spec string, accumulating and running commands. */
3311 /* These variables describe the input file name.
3312 input_file_number is the index on outfiles of this file,
3313 so that the output file name can be stored for later use by %o.
3314 input_basename is the start of the part of the input file
3315 sans all directory names, and basename_length is the number
3316 of characters starting there excluding the suffix .c or whatever. */
3318 const char *input_filename;
3319 static int input_file_number;
3320 size_t input_filename_length;
3321 static int basename_length;
3322 static const char *input_basename;
3323 static const char *input_suffix;
3325 /* These are variables used within do_spec and do_spec_1. */
3327 /* Nonzero if an arg has been started and not yet terminated
3328 (with space, tab or newline). */
3329 static int arg_going;
3331 /* Nonzero means %d or %g has been seen; the next arg to be terminated
3332 is a temporary file name. */
3333 static int delete_this_arg;
3335 /* Nonzero means %w has been seen; the next arg to be terminated
3336 is the output file name of this compilation. */
3337 static int this_is_output_file;
3339 /* Nonzero means %s has been seen; the next arg to be terminated
3340 is the name of a library file and we should try the standard
3341 search dirs for it. */
3342 static int this_is_library_file;
3344 /* Nonzero means that the input of this command is coming from a pipe. */
3345 static int input_from_pipe;
3347 /* Process the spec SPEC and run the commands specified therein.
3348 Returns 0 if the spec is successfully processed; -1 if failed. */
3358 delete_this_arg = 0;
3359 this_is_output_file = 0;
3360 this_is_library_file = 0;
3361 input_from_pipe = 0;
3363 value = do_spec_1 (spec, 0, NULL_PTR);
3365 /* Force out any unfinished command.
3366 If -pipe, this forces out the last command if it ended in `|'. */
3369 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
3372 if (argbuf_index > 0)
3379 /* Process the sub-spec SPEC as a portion of a larger spec.
3380 This is like processing a whole spec except that we do
3381 not initialize at the beginning and we do not supply a
3382 newline by default at the end.
3383 INSWITCH nonzero means don't process %-sequences in SPEC;
3384 in this case, % is treated as an ordinary character.
3385 This is used while substituting switches.
3386 INSWITCH nonzero also causes SPC not to terminate an argument.
3388 Value is zero unless a line was finished
3389 and the command on that line reported an error. */
3392 do_spec_1 (spec, inswitch, soft_matched_part)
3395 const char *soft_matched_part;
3397 register const char *p = spec;
3404 /* If substituting a switch, treat all chars like letters.
3405 Otherwise, NL, SPC, TAB and % are special. */
3406 switch (inswitch ? 'a' : c)
3409 /* End of line: finish any pending argument,
3410 then run the pending command if one has been started. */
3413 obstack_1grow (&obstack, 0);
3414 string = obstack_finish (&obstack);
3415 if (this_is_library_file)
3416 string = find_file (string);
3417 store_arg (string, delete_this_arg, this_is_output_file);
3418 if (this_is_output_file)
3419 outfiles[input_file_number] = string;
3423 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
3425 for (i = 0; i < n_switches; i++)
3426 if (!strcmp (switches[i].part1, "pipe"))
3429 /* A `|' before the newline means use a pipe here,
3430 but only if -pipe was specified.
3431 Otherwise, execute now and don't pass the `|' as an arg. */
3434 input_from_pipe = 1;
3435 switches[i].validated = 1;
3442 if (argbuf_index > 0)
3448 /* Reinitialize for a new command, and for a new argument. */
3451 delete_this_arg = 0;
3452 this_is_output_file = 0;
3453 this_is_library_file = 0;
3454 input_from_pipe = 0;
3458 /* End any pending argument. */
3461 obstack_1grow (&obstack, 0);
3462 string = obstack_finish (&obstack);
3463 if (this_is_library_file)
3464 string = find_file (string);
3465 store_arg (string, delete_this_arg, this_is_output_file);
3466 if (this_is_output_file)
3467 outfiles[input_file_number] = string;
3471 obstack_1grow (&obstack, c);
3477 /* Space or tab ends an argument if one is pending. */
3480 obstack_1grow (&obstack, 0);
3481 string = obstack_finish (&obstack);
3482 if (this_is_library_file)
3483 string = find_file (string);
3484 store_arg (string, delete_this_arg, this_is_output_file);
3485 if (this_is_output_file)
3486 outfiles[input_file_number] = string;
3488 /* Reinitialize for a new argument. */
3490 delete_this_arg = 0;
3491 this_is_output_file = 0;
3492 this_is_library_file = 0;
3499 fatal ("Invalid specification! Bug in cc.");
3502 obstack_grow (&obstack, input_basename, basename_length);
3507 delete_this_arg = 2;
3510 /* Dump out the directories specified with LIBRARY_PATH,
3511 followed by the absolute directories
3512 that we search for startfiles. */
3515 struct prefix_list *pl = startfile_prefixes.plist;
3516 size_t bufsize = 100;
3517 char *buffer = (char *) xmalloc (bufsize);
3520 for (; pl; pl = pl->next)
3522 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
3523 /* Used on systems which record the specified -L dirs
3524 and use them to search for dynamic linking. */
3525 /* Relative directories always come from -B,
3526 and it is better not to use them for searching
3527 at run time. In particular, stage1 loses */
3528 if (pl->prefix[0] != '/' && pl->prefix[0] != DIR_SEPARATOR)
3531 /* Try subdirectory if there is one. */
3532 if (multilib_dir != NULL)
3536 if (strlen (pl->prefix) + strlen (machine_suffix)
3538 bufsize = (strlen (pl->prefix)
3539 + strlen (machine_suffix)) * 2 + 1;
3540 buffer = (char *) xrealloc (buffer, bufsize);
3541 strcpy (buffer, pl->prefix);
3542 strcat (buffer, machine_suffix);
3543 if (is_directory (buffer, multilib_dir, 1))
3545 do_spec_1 ("-L", 0, NULL_PTR);
3546 #ifdef SPACE_AFTER_L_OPTION
3547 do_spec_1 (" ", 0, NULL_PTR);
3549 do_spec_1 (buffer, 1, NULL_PTR);
3550 do_spec_1 (multilib_dir, 1, NULL_PTR);
3551 /* Make this a separate argument. */
3552 do_spec_1 (" ", 0, NULL_PTR);
3555 if (!pl->require_machine_suffix)
3557 if (is_directory (pl->prefix, multilib_dir, 1))
3559 do_spec_1 ("-L", 0, NULL_PTR);
3560 #ifdef SPACE_AFTER_L_OPTION
3561 do_spec_1 (" ", 0, NULL_PTR);
3563 do_spec_1 (pl->prefix, 1, NULL_PTR);
3564 do_spec_1 (multilib_dir, 1, NULL_PTR);
3565 /* Make this a separate argument. */
3566 do_spec_1 (" ", 0, NULL_PTR);
3572 if (is_directory (pl->prefix, machine_suffix, 1))
3574 do_spec_1 ("-L", 0, NULL_PTR);
3575 #ifdef SPACE_AFTER_L_OPTION
3576 do_spec_1 (" ", 0, NULL_PTR);
3578 do_spec_1 (pl->prefix, 1, NULL_PTR);
3579 /* Remove slash from machine_suffix. */
3580 if (strlen (machine_suffix) >= bufsize)
3581 bufsize = strlen (machine_suffix) * 2 + 1;
3582 buffer = (char *) xrealloc (buffer, bufsize);
3583 strcpy (buffer, machine_suffix);
3584 idx = strlen (buffer);
3585 if (buffer[idx - 1] == '/'
3586 || buffer[idx - 1] == DIR_SEPARATOR)
3587 buffer[idx - 1] = 0;
3588 do_spec_1 (buffer, 1, NULL_PTR);
3589 /* Make this a separate argument. */
3590 do_spec_1 (" ", 0, NULL_PTR);
3593 if (!pl->require_machine_suffix)
3595 if (is_directory (pl->prefix, "", 1))
3597 do_spec_1 ("-L", 0, NULL_PTR);
3598 #ifdef SPACE_AFTER_L_OPTION
3599 do_spec_1 (" ", 0, NULL_PTR);
3601 /* Remove slash from pl->prefix. */
3602 if (strlen (pl->prefix) >= bufsize)
3603 bufsize = strlen (pl->prefix) * 2 + 1;
3604 buffer = (char *) xrealloc (buffer, bufsize);
3605 strcpy (buffer, pl->prefix);
3606 idx = strlen (buffer);
3607 if (buffer[idx - 1] == '/'
3608 || buffer[idx - 1] == DIR_SEPARATOR)
3609 buffer[idx - 1] = 0;
3610 do_spec_1 (buffer, 1, NULL_PTR);
3611 /* Make this a separate argument. */
3612 do_spec_1 (" ", 0, NULL_PTR);
3621 /* %efoo means report an error with `foo' as error message
3622 and don't execute any more commands for this file. */
3626 while (*p != 0 && *p != '\n') p++;
3627 buf = (char *) alloca (p - q + 1);
3628 strncpy (buf, q, p - q);
3638 if (save_temps_flag)
3640 obstack_grow (&obstack, input_basename, basename_length);
3641 delete_this_arg = 0;
3645 #ifdef MKTEMP_EACH_FILE
3646 /* ??? This has a problem: the total number of
3647 values mktemp can return is limited.
3648 That matters for the names of object files.
3649 In 2.4, do something about that. */
3650 struct temp_name *t;
3652 const char *suffix = p;
3654 if (p[0] == '%' && p[1] == 'O')
3657 /* We don't support extra suffix characters after %O. */
3658 if (*p == '.' || ISALPHA ((unsigned char)*p))
3660 suffix = OBJECT_SUFFIX;
3661 suffix_length = strlen (OBJECT_SUFFIX);
3665 while (*p == '.' || ISALPHA ((unsigned char)*p))
3667 suffix_length = p - suffix;
3670 /* See if we already have an association of %g/%u/%U and
3672 for (t = temp_names; t; t = t->next)
3673 if (t->length == suffix_length
3674 && strncmp (t->suffix, suffix, suffix_length) == 0
3675 && t->unique == (c != 'g'))
3678 /* Make a new association if needed. %u requires one. */
3679 if (t == 0 || c == 'u')
3683 t = (struct temp_name *) xmalloc (sizeof (struct temp_name));
3684 t->next = temp_names;
3687 t->length = suffix_length;
3688 t->suffix = save_string (suffix, suffix_length);
3689 t->unique = (c != 'g');
3690 temp_filename = make_temp_file (t->suffix);
3691 temp_filename_length = strlen (temp_filename);
3692 t->filename = temp_filename;
3693 t->filename_length = temp_filename_length;
3696 obstack_grow (&obstack, t->filename, t->filename_length);
3697 delete_this_arg = 1;
3699 obstack_grow (&obstack, temp_filename, temp_filename_length);
3700 if (c == 'u' || c == 'U')
3706 sprintf (buff, "%d", unique);
3707 obstack_grow (&obstack, buff, strlen (buff));
3710 delete_this_arg = 1;
3716 obstack_grow (&obstack, input_filename, input_filename_length);
3722 struct prefix_list *pl = include_prefixes.plist;
3724 if (gcc_exec_prefix)
3726 do_spec_1 ("-iprefix", 1, NULL_PTR);
3727 /* Make this a separate argument. */
3728 do_spec_1 (" ", 0, NULL_PTR);
3729 do_spec_1 (gcc_exec_prefix, 1, NULL_PTR);
3730 do_spec_1 (" ", 0, NULL_PTR);
3733 for (; pl; pl = pl->next)
3735 do_spec_1 ("-isystem", 1, NULL_PTR);
3736 /* Make this a separate argument. */
3737 do_spec_1 (" ", 0, NULL_PTR);
3738 do_spec_1 (pl->prefix, 1, NULL_PTR);
3739 do_spec_1 (" ", 0, NULL_PTR);
3746 int max = n_infiles;
3747 max += lang_specific_extra_outfiles;
3749 for (i = 0; i < max; i++)
3751 store_arg (outfiles[i], 0, 0);
3756 obstack_grow (&obstack, OBJECT_SUFFIX, strlen (OBJECT_SUFFIX));
3761 this_is_library_file = 1;
3765 this_is_output_file = 1;
3770 int cur_index = argbuf_index;
3771 /* Handle the {...} following the %W. */
3774 p = handle_braces (p + 1);
3777 /* If any args were output, mark the last one for deletion
3779 if (argbuf_index != cur_index)
3780 record_temp_file (argbuf[argbuf_index - 1], 0, 1);
3784 /* %x{OPTION} records OPTION for %X to output. */
3790 /* Skip past the option value and make a copy. */
3795 string = save_string (p1 + 1, p - p1 - 2);
3797 /* See if we already recorded this option. */
3798 for (i = 0; i < n_linker_options; i++)
3799 if (! strcmp (string, linker_options[i]))
3805 /* This option is new; add it. */
3806 add_linker_option (string, strlen (string));
3810 /* Dump out the options accumulated previously using %x. */
3812 for (i = 0; i < n_linker_options; i++)
3814 do_spec_1 (linker_options[i], 1, NULL_PTR);
3815 /* Make each accumulated option a separate argument. */
3816 do_spec_1 (" ", 0, NULL_PTR);
3820 /* Dump out the options accumulated previously using -Wa,. */
3822 for (i = 0; i < n_assembler_options; i++)
3824 do_spec_1 (assembler_options[i], 1, NULL_PTR);
3825 /* Make each accumulated option a separate argument. */
3826 do_spec_1 (" ", 0, NULL_PTR);
3830 /* Dump out the options accumulated previously using -Wp,. */
3832 for (i = 0; i < n_preprocessor_options; i++)
3834 do_spec_1 (preprocessor_options[i], 1, NULL_PTR);
3835 /* Make each accumulated option a separate argument. */
3836 do_spec_1 (" ", 0, NULL_PTR);
3840 /* Here are digits and numbers that just process
3841 a certain constant string as a spec. */
3844 value = do_spec_1 (cc1_spec, 0, NULL_PTR);
3850 value = do_spec_1 (cc1plus_spec, 0, NULL_PTR);
3856 value = do_spec_1 (asm_spec, 0, NULL_PTR);
3862 value = do_spec_1 (asm_final_spec, 0, NULL_PTR);
3868 value = do_spec_1 (signed_char_spec, 0, NULL_PTR);
3874 value = do_spec_1 (cpp_spec, 0, NULL_PTR);
3880 value = do_spec_1 (endfile_spec, 0, NULL_PTR);
3886 value = do_spec_1 (link_spec, 0, NULL_PTR);
3892 value = do_spec_1 (lib_spec, 0, NULL_PTR);
3898 value = do_spec_1 (libgcc_spec, 0, NULL_PTR);
3905 char *x = (char *) alloca (strlen (cpp_predefines) + 1);
3909 /* Copy all of the -D options in CPP_PREDEFINES into BUF. */
3913 if (! strncmp (y, "-D", 2))
3914 /* Copy the whole option. */
3915 while (*y && *y != ' ' && *y != '\t')
3917 else if (*y == ' ' || *y == '\t')
3918 /* Copy whitespace to the result. */
3920 /* Don't copy other options. */
3927 value = do_spec_1 (buf, 0, NULL_PTR);
3935 char *x = (char *) alloca (strlen (cpp_predefines) * 4 + 1);
3939 /* Copy all of CPP_PREDEFINES into BUF,
3940 but put __ after every -D and at the end of each arg. */
3944 if (! strncmp (y, "-D", 2))
3953 && ! ISUPPER ((unsigned char)*(y+1))))
3955 /* Stick __ at front of macro name. */
3958 /* Arrange to stick __ at the end as well. */
3962 /* Copy the macro name. */
3963 while (*y && *y != '=' && *y != ' ' && *y != '\t')
3972 /* Copy the value given, if any. */
3973 while (*y && *y != ' ' && *y != '\t')
3976 else if (*y == ' ' || *y == '\t')
3977 /* Copy whitespace to the result. */
3979 /* Don't copy -A options */
3985 /* Copy all of CPP_PREDEFINES into BUF,
3986 but put __ after every -D. */
3990 if (! strncmp (y, "-D", 2))
3996 && ! ISUPPER ((unsigned char)*(y+1))))
3998 /* Stick -D__ at front of macro name. */
4004 /* Copy the macro name. */
4005 while (*y && *y != '=' && *y != ' ' && *y != '\t')
4008 /* Copy the value given, if any. */
4009 while (*y && *y != ' ' && *y != '\t')
4014 /* Do not copy this macro - we have just done it before */
4015 while (*y && *y != ' ' && *y != '\t')
4019 else if (*y == ' ' || *y == '\t')
4020 /* Copy whitespace to the result. */
4022 /* Don't copy -A options */
4028 /* Copy all of the -A options in CPP_PREDEFINES into BUF. */
4032 if (! strncmp (y, "-A", 2))
4033 /* Copy the whole option. */
4034 while (*y && *y != ' ' && *y != '\t')
4036 else if (*y == ' ' || *y == '\t')
4037 /* Copy whitespace to the result. */
4039 /* Don't copy other options. */
4046 value = do_spec_1 (buf, 0, NULL_PTR);
4053 value = do_spec_1 (startfile_spec, 0, NULL_PTR);
4058 /* Here we define characters other than letters and digits. */
4061 p = handle_braces (p);
4067 obstack_1grow (&obstack, '%');
4071 do_spec_1 (soft_matched_part, 1, NULL_PTR);
4072 do_spec_1 (" ", 0, NULL_PTR);
4075 /* Process a string found as the value of a spec given by name.
4076 This feature allows individual machine descriptions
4077 to add and use their own specs.
4078 %[...] modifies -D options the way %P does;
4079 %(...) uses the spec unmodified. */
4081 error ("Warning: use of obsolete %%[ operator in specs");
4084 const char *name = p;
4085 struct spec_list *sl;
4088 /* The string after the S/P is the name of a spec that is to be
4090 while (*p && *p != ')' && *p != ']')
4093 /* See if it's in the list */
4094 for (len = p - name, sl = specs; sl; sl = sl->next)
4095 if (sl->name_len == len && !strncmp (sl->name, name, len))
4097 name = *(sl->ptr_spec);
4099 notice ("Processing spec %c%s%c, which is '%s'\n",
4100 c, sl->name, (c == '(') ? ')' : ']', name);
4109 value = do_spec_1 (name, 0, NULL_PTR);
4115 char *x = (char *) alloca (strlen (name) * 2 + 1);
4117 const char *y = name;
4120 /* Copy all of NAME into BUF, but put __ after
4121 every -D and at the end of each arg, */
4124 if (! strncmp (y, "-D", 2))
4134 else if (flag && (*y == ' ' || *y == '\t' || *y == '='
4135 || *y == '}' || *y == 0))
4148 value = do_spec_1 (buf, 0, NULL_PTR);
4154 /* Discard the closing paren or bracket. */
4162 int c1 = *p++; /* Select first or second version number. */
4163 char *v = compiler_version;
4166 /* The format of the version string is
4167 ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)? */
4169 /* Ignore leading non-digits. i.e. "foo-" in "foo-2.7.2". */
4170 while (! ISDIGIT (*v))
4172 if (v > compiler_version && v[-1] != '-')
4175 /* If desired, advance to second version number. */
4178 /* Set V after the first period. */
4179 while (ISDIGIT (*v))
4186 /* Set Q at the next period or at the end. */
4188 while (ISDIGIT (*q))
4190 if (*q != 0 && *q != ' ' && *q != '.' && *q != '-')
4193 /* Put that part into the command. */
4194 obstack_grow (&obstack, v, q - v);
4200 if (input_from_pipe)
4201 do_spec_1 ("-", 0, NULL_PTR);
4210 /* Backslash: treat next character as ordinary. */
4215 /* Ordinary character: put it into the current argument. */
4216 obstack_1grow (&obstack, c);
4220 return 0; /* End of string */
4223 /* Return 0 if we call do_spec_1 and that returns -1. */
4227 register const char *p;
4229 const char *filter, *body = NULL, *endbody = NULL;
4233 int include_blanks = 1;
4236 /* A '^' after the open-brace means to not give blanks before args. */
4237 include_blanks = 0, ++p;
4240 /* A `|' after the open-brace means,
4241 if the test fails, output a single minus sign rather than nothing.
4242 This is used in %{|!pipe:...}. */
4246 negate = suffix = 0;
4249 /* A `!' after the open-brace negates the condition:
4250 succeed if the specified switch is not present. */
4254 /* A `.' after the open-brace means test against the current suffix. */
4264 while (*p != ':' && *p != '}' && *p != '|') p++;
4266 if (*p == '|' && pipe_p)
4273 register int count = 1;
4274 register const char *q = p;
4276 while (*q++ != ':') continue;
4292 body = p, endbody = p+1;
4297 int found = (input_suffix != 0
4298 && (long) strlen (input_suffix) == (long)(p - filter)
4299 && strncmp (input_suffix, filter, p - filter) == 0);
4305 && do_spec_1 (save_string (body, endbody-body-1), 0, NULL_PTR) < 0)
4308 else if (p[-1] == '*' && p[0] == '}')
4310 /* Substitute all matching switches as separate args. */
4313 for (i = 0; i < n_switches; i++)
4314 if (!strncmp (switches[i].part1, filter, p - filter)
4315 && check_live_switch (i, p - filter))
4316 give_switch (i, 0, include_blanks);
4320 /* Test for presence of the specified switch. */
4324 /* If name specified ends in *, as in {x*:...},
4325 check for %* and handle that case. */
4326 if (p[-1] == '*' && !negate)
4329 const char *r = body;
4331 /* First see whether we have %*. */
4335 if (*r == '%' && r[1] == '*')
4339 /* If we do, handle that case. */
4342 /* Substitute all matching switches as separate args.
4343 But do this by substituting for %*
4344 in the text that follows the colon. */
4346 unsigned hard_match_len = p - filter - 1;
4347 char *string = save_string (body, endbody - body - 1);
4349 for (i = 0; i < n_switches; i++)
4350 if (!strncmp (switches[i].part1, filter, hard_match_len)
4351 && check_live_switch (i, -1))
4353 do_spec_1 (string, 0, &switches[i].part1[hard_match_len]);
4354 /* Pass any arguments this switch has. */
4355 give_switch (i, 1, 1);
4358 /* We didn't match. Try again. */
4365 /* If name specified ends in *, as in {x*:...},
4366 check for presence of any switch name starting with x. */
4369 for (i = 0; i < n_switches; i++)
4371 unsigned hard_match_len = p - filter - 1;
4373 if (!strncmp (switches[i].part1, filter, hard_match_len)
4374 && check_live_switch (i, hard_match_len))
4380 /* Otherwise, check for presence of exact name specified. */
4383 for (i = 0; i < n_switches; i++)
4385 if (!strncmp (switches[i].part1, filter, p - filter)
4386 && switches[i].part1[p - filter] == 0
4387 && check_live_switch (i, -1))
4395 /* If it is as desired (present for %{s...}, absent for %{!s...})
4396 then substitute either the switch or the specified
4397 conditional text. */
4398 if (present != negate)
4402 give_switch (i, 0, include_blanks);
4406 if (do_spec_1 (save_string (body, endbody - body - 1),
4413 /* Here if a %{|...} conditional fails: output a minus sign,
4414 which means "standard output" or "standard input". */
4415 do_spec_1 ("-", 0, NULL_PTR);
4420 /* We didn't match; try again. */
4427 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
4428 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
4429 spec, or -1 if either exact match or %* is used.
4431 A -O switch is obsoleted by a later -O switch. A -f, -m, or -W switch
4432 whose value does not begin with "no-" is obsoleted by the same value
4433 with the "no-", similarly for a switch with the "no-" prefix. */
4436 check_live_switch (switchnum, prefix_length)
4440 const char *name = switches[switchnum].part1;
4443 /* In the common case of {<at-most-one-letter>*}, a negating
4444 switch would always match, so ignore that case. We will just
4445 send the conflicting switches to the compiler phase. */
4446 if (prefix_length >= 0 && prefix_length <= 1)
4449 /* If we already processed this switch and determined if it was
4450 live or not, return our past determination. */
4451 if (switches[switchnum].live_cond != 0)
4452 return switches[switchnum].live_cond > 0;
4454 /* Now search for duplicate in a manner that depends on the name. */
4458 for (i = switchnum + 1; i < n_switches; i++)
4459 if (switches[i].part1[0] == 'O')
4461 switches[switchnum].validated = 1;
4462 switches[switchnum].live_cond = -1;
4467 case 'W': case 'f': case 'm':
4468 if (! strncmp (name + 1, "no-", 3))
4470 /* We have Xno-YYY, search for XYYY. */
4471 for (i = switchnum + 1; i < n_switches; i++)
4472 if (switches[i].part1[0] == name[0]
4473 && ! strcmp (&switches[i].part1[1], &name[4]))
4475 switches[switchnum].validated = 1;
4476 switches[switchnum].live_cond = -1;
4482 /* We have XYYY, search for Xno-YYY. */
4483 for (i = switchnum + 1; i < n_switches; i++)
4484 if (switches[i].part1[0] == name[0]
4485 && switches[i].part1[1] == 'n'
4486 && switches[i].part1[2] == 'o'
4487 && switches[i].part1[3] == '-'
4488 && !strcmp (&switches[i].part1[4], &name[1]))
4490 switches[switchnum].validated = 1;
4491 switches[switchnum].live_cond = -1;
4498 /* Otherwise the switch is live. */
4499 switches[switchnum].live_cond = 1;
4503 /* Pass a switch to the current accumulating command
4504 in the same form that we received it.
4505 SWITCHNUM identifies the switch; it is an index into
4506 the vector of switches gcc received, which is `switches'.
4507 This cannot fail since it never finishes a command line.
4509 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument.
4511 If INCLUDE_BLANKS is nonzero, then we include blanks before each argument
4515 give_switch (switchnum, omit_first_word, include_blanks)
4517 int omit_first_word;
4520 if (!omit_first_word)
4522 do_spec_1 ("-", 0, NULL_PTR);
4523 do_spec_1 (switches[switchnum].part1, 1, NULL_PTR);
4526 if (switches[switchnum].args != 0)
4529 for (p = switches[switchnum].args; *p; p++)
4532 do_spec_1 (" ", 0, NULL_PTR);
4533 do_spec_1 (*p, 1, NULL_PTR);
4537 do_spec_1 (" ", 0, NULL_PTR);
4538 switches[switchnum].validated = 1;
4541 /* Search for a file named NAME trying various prefixes including the
4542 user's -B prefix and some standard ones.
4543 Return the absolute file name found. If nothing is found, return NAME. */
4551 /* Try multilib_dir if it is defined. */
4552 if (multilib_dir != NULL)
4556 try = (char *) alloca (strlen (multilib_dir) + strlen (name) + 2);
4557 strcpy (try, multilib_dir);
4558 strcat (try, dir_separator_str);
4561 newname = find_a_file (&startfile_prefixes, try, R_OK);
4563 /* If we don't find it in the multi library dir, then fall
4564 through and look for it in the normal places. */
4565 if (newname != NULL)
4569 newname = find_a_file (&startfile_prefixes, name, R_OK);
4570 return newname ? newname : name;
4573 /* Determine whether a directory exists. If LINKER, return 0 for
4574 certain fixed names not needed by the linker. If not LINKER, it is
4575 only important to return 0 if the host machine has a small ARG_MAX
4579 is_directory (path1, path2, linker)
4584 int len1 = strlen (path1);
4585 int len2 = strlen (path2);
4586 char *path = (char *) alloca (3 + len1 + len2);
4590 #ifndef SMALL_ARG_MAX
4595 /* Construct the path from the two parts. Ensure the string ends with "/.".
4596 The resulting path will be a directory even if the given path is a
4598 memcpy (path, path1, len1);
4599 memcpy (path + len1, path2, len2);
4600 cp = path + len1 + len2;
4601 if (cp[-1] != '/' && cp[-1] != DIR_SEPARATOR)
4602 *cp++ = DIR_SEPARATOR;
4606 /* Exclude directories that the linker is known to search. */
4609 && strcmp (path, concat (dir_separator_str, "lib",
4610 dir_separator_str, ".", NULL_PTR)) == 0)
4612 && strcmp (path, concat (dir_separator_str, "usr",
4613 dir_separator_str, "lib",
4614 dir_separator_str, ".", NULL_PTR)) == 0)))
4617 return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
4620 /* On fatal signals, delete all the temporary files. */
4623 fatal_error (signum)
4626 signal (signum, SIG_DFL);
4627 delete_failure_queue ();
4628 delete_temp_files ();
4629 /* Get the same signal again, this time not handled,
4630 so its normal effect occurs. */
4631 kill (getpid (), signum);
4642 int linker_was_run = 0;
4643 char *explicit_link_files;
4646 struct user_specs *uptr;
4648 p = argv[0] + strlen (argv[0]);
4649 while (p != argv[0] && p[-1] != '/' && p[-1] != DIR_SEPARATOR) --p;
4652 #ifdef HAVE_LC_MESSAGES
4653 setlocale (LC_MESSAGES, "");
4655 (void) bindtextdomain (PACKAGE, localedir);
4656 (void) textdomain (PACKAGE);
4658 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
4659 signal (SIGINT, fatal_error);
4661 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
4662 signal (SIGHUP, fatal_error);
4664 if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
4665 signal (SIGTERM, fatal_error);
4667 if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
4668 signal (SIGPIPE, fatal_error);
4672 argbuf = (char **) xmalloc (argbuf_length * sizeof (char *));
4674 obstack_init (&obstack);
4676 /* Build multilib_select, et. al from the separate lines that make up each
4677 multilib selection. */
4679 char **q = multilib_raw;
4682 obstack_init (&multilib_obstack);
4683 while ((p = *q++) != (char *) 0)
4684 obstack_grow (&multilib_obstack, p, strlen (p));
4686 obstack_1grow (&multilib_obstack, 0);
4687 multilib_select = obstack_finish (&multilib_obstack);
4689 q = multilib_matches_raw;
4690 while ((p = *q++) != (char *) 0)
4691 obstack_grow (&multilib_obstack, p, strlen (p));
4693 obstack_1grow (&multilib_obstack, 0);
4694 multilib_matches = obstack_finish (&multilib_obstack);
4698 i < sizeof (multilib_defaults_raw) / sizeof (multilib_defaults_raw[0]);
4702 obstack_1grow (&multilib_obstack, ' ');
4703 obstack_grow (&multilib_obstack,
4704 multilib_defaults_raw[i],
4705 strlen (multilib_defaults_raw[i]));
4709 obstack_1grow (&multilib_obstack, 0);
4710 multilib_defaults = obstack_finish (&multilib_obstack);
4713 /* Set up to remember the pathname of gcc and any options
4714 needed for collect. We use argv[0] instead of programname because
4715 we need the complete pathname. */
4716 obstack_init (&collect_obstack);
4717 obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=")-1);
4718 obstack_grow (&collect_obstack, argv[0], strlen (argv[0])+1);
4719 putenv (obstack_finish (&collect_obstack));
4721 #ifdef INIT_ENVIRONMENT
4722 /* Set up any other necessary machine specific environment variables. */
4723 putenv (INIT_ENVIRONMENT);
4726 /* Choose directory for temp files. */
4728 #ifndef MKTEMP_EACH_FILE
4729 temp_filename = choose_temp_base ();
4730 temp_filename_length = strlen (temp_filename);
4733 /* Make a table of what switches there are (switches, n_switches).
4734 Make a table of specified input files (infiles, n_infiles).
4735 Decode switches that are handled locally. */
4737 process_command (argc, argv);
4742 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4744 obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
4745 sizeof ("COLLECT_GCC_OPTIONS=")-1);
4748 for (i = 0; (int)i < n_switches; i++)
4753 obstack_grow (&collect_obstack, " ", 1);
4756 obstack_grow (&collect_obstack, "'-", 2);
4757 q = switches[i].part1;
4758 while ((p = index (q,'\'')))
4760 obstack_grow (&collect_obstack, q, p-q);
4761 obstack_grow (&collect_obstack, "'\\''", 4);
4764 obstack_grow (&collect_obstack, q, strlen (q));
4765 obstack_grow (&collect_obstack, "'", 1);
4767 for (args = switches[i].args; args && *args; args++)
4769 obstack_grow (&collect_obstack, " '", 2);
4771 while ((p = index (q,'\'')))
4773 obstack_grow (&collect_obstack, q, p-q);
4774 obstack_grow (&collect_obstack, "'\\''", 4);
4777 obstack_grow (&collect_obstack, q, strlen (q));
4778 obstack_grow (&collect_obstack, "'", 1);
4781 obstack_grow (&collect_obstack, "\0", 1);
4782 putenv (obstack_finish (&collect_obstack));
4785 /* Initialize the vector of specs to just the default.
4786 This means one element containing 0s, as a terminator. */
4788 compilers = (struct compiler *) xmalloc (sizeof default_compilers);
4789 bcopy ((char *) default_compilers, (char *) compilers,
4790 sizeof default_compilers);
4791 n_compilers = n_default_compilers;
4793 /* Read specs from a file if there is one. */
4795 machine_suffix = concat (spec_machine, dir_separator_str,
4796 spec_version, dir_separator_str, NULL_PTR);
4797 just_machine_suffix = concat (spec_machine, dir_separator_str, NULL_PTR);
4799 specs_file = find_a_file (&startfile_prefixes, "specs", R_OK);
4800 /* Read the specs file unless it is a default one. */
4801 if (specs_file != 0 && strcmp (specs_file, "specs"))
4802 read_specs (specs_file, TRUE);
4806 /* We need to check standard_exec_prefix/just_machine_suffix/specs
4807 for any override of as, ld and libraries. */
4808 specs_file = (char *) alloca (strlen (standard_exec_prefix)
4809 + strlen (just_machine_suffix)
4810 + sizeof ("specs"));
4812 strcpy (specs_file, standard_exec_prefix);
4813 strcat (specs_file, just_machine_suffix);
4814 strcat (specs_file, "specs");
4815 if (access (specs_file, R_OK) == 0)
4816 read_specs (specs_file, TRUE);
4818 /* Process any user specified specs in the order given on the command
4820 for (uptr = user_specs_head; uptr; uptr = uptr->next)
4822 char *filename = find_a_file (&startfile_prefixes, uptr->filename, R_OK);
4823 read_specs (filename ? filename : uptr->filename, FALSE);
4826 /* If not cross-compiling, look for startfiles in the standard places. */
4827 /* The fact that these are done here, after reading the specs file,
4828 means that it cannot be found in these directories.
4829 But that's okay. It should never be there anyway. */
4830 if (*cross_compile == '0')
4832 #ifdef MD_EXEC_PREFIX
4833 add_prefix (&exec_prefixes, md_exec_prefix, "GCC", 0, 0, NULL_PTR);
4834 add_prefix (&startfile_prefixes, md_exec_prefix, "GCC", 0, 0, NULL_PTR);
4837 #ifdef MD_STARTFILE_PREFIX
4838 add_prefix (&startfile_prefixes, md_startfile_prefix, "GCC",
4842 #ifdef MD_STARTFILE_PREFIX_1
4843 add_prefix (&startfile_prefixes, md_startfile_prefix_1, "GCC",
4847 /* If standard_startfile_prefix is relative, base it on
4848 standard_exec_prefix. This lets us move the installed tree
4849 as a unit. If GCC_EXEC_PREFIX is defined, base
4850 standard_startfile_prefix on that as well. */
4851 if (*standard_startfile_prefix == '/'
4852 || *standard_startfile_prefix == DIR_SEPARATOR
4853 || *standard_startfile_prefix == '$'
4855 /* Check for disk name on MS-DOS-based systems. */
4856 || (standard_startfile_prefix[1] == ':'
4857 && (standard_startfile_prefix[2] == DIR_SEPARATOR
4858 || standard_startfile_prefix[2] == '/'))
4861 add_prefix (&startfile_prefixes, standard_startfile_prefix, "BINUTILS",
4865 if (gcc_exec_prefix)
4866 add_prefix (&startfile_prefixes,
4867 concat (gcc_exec_prefix, machine_suffix,
4868 standard_startfile_prefix, NULL_PTR),
4869 NULL_PTR, 0, 0, NULL_PTR);
4870 add_prefix (&startfile_prefixes,
4871 concat (standard_exec_prefix,
4873 standard_startfile_prefix, NULL_PTR),
4874 NULL_PTR, 0, 0, NULL_PTR);
4877 add_prefix (&startfile_prefixes, standard_startfile_prefix_1,
4878 "BINUTILS", 0, 0, NULL_PTR);
4879 add_prefix (&startfile_prefixes, standard_startfile_prefix_2,
4880 "BINUTILS", 0, 0, NULL_PTR);
4881 #if 0 /* Can cause surprises, and one can use -B./ instead. */
4882 add_prefix (&startfile_prefixes, "./", NULL_PTR, 0, 1, NULL_PTR);
4887 if (*standard_startfile_prefix != DIR_SEPARATOR && gcc_exec_prefix)
4888 add_prefix (&startfile_prefixes,
4889 concat (gcc_exec_prefix, machine_suffix,
4890 standard_startfile_prefix, NULL_PTR),
4891 "BINUTILS", 0, 0, NULL_PTR);
4894 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
4895 if (gcc_exec_prefix)
4897 char * temp = (char *) xmalloc (strlen (gcc_exec_prefix)
4898 + strlen (spec_version)
4899 + strlen (spec_machine) + 3);
4900 strcpy (temp, gcc_exec_prefix);
4901 strcat (temp, spec_machine);
4902 strcat (temp, dir_separator_str);
4903 strcat (temp, spec_version);
4904 strcat (temp, dir_separator_str);
4905 gcc_exec_prefix = temp;
4908 /* Now we have the specs.
4909 Set the `valid' bits for switches that match anything in any spec. */
4911 validate_all_switches ();
4913 /* Now that we have the switches and the specs, set
4914 the subdirectory based on the options. */
4915 set_multilib_dir ();
4917 /* Warn about any switches that no pass was interested in. */
4919 for (i = 0; (int)i < n_switches; i++)
4920 if (! switches[i].validated)
4921 error ("unrecognized option `-%s'", switches[i].part1);
4923 /* Obey some of the options. */
4925 if (print_search_dirs)
4927 printf ("install: %s%s\n", standard_exec_prefix, machine_suffix);
4928 printf ("programs: %s\n", build_search_list (&exec_prefixes, "", 0));
4929 printf ("libraries: %s\n", build_search_list (&startfile_prefixes, "", 0));
4933 if (print_file_name)
4935 printf ("%s\n", find_file (print_file_name));
4939 if (print_prog_name)
4941 char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK);
4942 printf ("%s\n", (newname ? newname : print_prog_name));
4946 if (print_multi_lib)
4948 print_multilib_info ();
4952 if (print_multi_directory)
4954 if (multilib_dir == NULL)
4957 printf ("%s\n", multilib_dir);
4961 if (print_help_list)
4967 printf ("\nReport bugs to egcs-bugs@egcs.cygnus.com.\n");
4968 printf ("Please see the file BUGS (included with the sources) first.\n");
4973 /* We do not exit here. Instead we have created a fake input file
4974 called 'help-dummy' which needs to be compiled, and we pass this
4975 on the the various sub-processes, along with the --help switch. */
4982 /* compiler_version is truncated at the first space when initialized
4983 from version string, so truncate version_string at the first space
4984 before comparing. */
4985 for (n = 0; version_string[n]; n++)
4986 if (version_string[n] == ' ')
4989 if (! strncmp (version_string, compiler_version, n)
4990 && compiler_version[n] == 0)
4991 notice ("gcc version %s\n", version_string);
4993 notice ("gcc driver version %s executing gcc version %s\n",
4994 version_string, compiler_version);
5000 if (n_infiles == added_libraries)
5001 fatal ("No input files");
5003 /* Make a place to record the compiler output file names
5004 that correspond to the input files. */
5007 i += lang_specific_extra_outfiles;
5008 outfiles = (const char **) xmalloc (i * sizeof (char *));
5009 bzero ((char *) outfiles, i * sizeof (char *));
5011 /* Record which files were specified explicitly as link input. */
5013 explicit_link_files = xmalloc (n_infiles);
5014 bzero (explicit_link_files, n_infiles);
5016 for (i = 0; (int)i < n_infiles; i++)
5018 register struct compiler *cp = 0;
5019 int this_file_error = 0;
5021 /* Tell do_spec what to substitute for %i. */
5023 input_filename = infiles[i].name;
5024 input_filename_length = strlen (input_filename);
5025 input_file_number = i;
5027 /* Use the same thing in %o, unless cp->spec says otherwise. */
5029 outfiles[i] = input_filename;
5031 /* Figure out which compiler from the file's suffix. */
5033 cp = lookup_compiler (infiles[i].name, input_filename_length,
5034 infiles[i].language);
5038 /* Ok, we found an applicable compiler. Run its spec. */
5039 /* First say how much of input_filename to substitute for %b */
5040 register const char *p;
5043 if (cp->spec[0][0] == '#')
5044 error ("%s: %s compiler not installed on this system",
5045 input_filename, &cp->spec[0][1]);
5047 input_basename = input_filename;
5048 for (p = input_filename; *p; p++)
5049 if (*p == '/' || *p == DIR_SEPARATOR)
5050 input_basename = p + 1;
5052 /* Find a suffix starting with the last period,
5053 and set basename_length to exclude that suffix. */
5054 basename_length = strlen (input_basename);
5055 p = input_basename + basename_length;
5056 while (p != input_basename && *p != '.') --p;
5057 if (*p == '.' && p != input_basename)
5059 basename_length = p - input_basename;
5060 input_suffix = p + 1;
5066 for (j = 0; j < sizeof cp->spec / sizeof cp->spec[0]; j++)
5068 len += strlen (cp->spec[j]);
5071 char *p1 = (char *) xmalloc (len + 1);
5074 for (j = 0; j < sizeof cp->spec / sizeof cp->spec[0]; j++)
5077 strcpy (p1 + len, cp->spec[j]);
5078 len += strlen (cp->spec[j]);
5081 value = do_spec (p1);
5085 this_file_error = 1;
5088 /* If this file's name does not contain a recognized suffix,
5089 record it as explicit linker input. */
5092 explicit_link_files[i] = 1;
5094 /* Clear the delete-on-failure queue, deleting the files in it
5095 if this compilation failed. */
5097 if (this_file_error)
5099 delete_failure_queue ();
5102 /* If this compilation succeeded, don't delete those files later. */
5103 clear_failure_queue ();
5106 if (error_count == 0)
5108 /* Make sure INPUT_FILE_NUMBER points to first available open
5110 input_file_number = n_infiles;
5111 if (lang_specific_pre_link ())
5115 /* Run ld to link all the compiler output files. */
5117 if (error_count == 0)
5119 int tmp = execution_count;
5121 /* We'll use ld if we can't find collect2. */
5122 if (! strcmp (linker_name_spec, "collect2"))
5124 char *s = find_a_file (&exec_prefixes, "collect2", X_OK);
5126 linker_name_spec = "ld";
5128 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
5130 putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH=");
5131 putenv_from_prefixes (&startfile_prefixes, "LIBRARY_PATH=");
5133 value = do_spec (link_command_spec);
5136 linker_was_run = (tmp != execution_count);
5139 /* Warn if a -B option was specified but the prefix was never used. */
5140 unused_prefix_warnings (&exec_prefixes);
5141 unused_prefix_warnings (&startfile_prefixes);
5143 /* If options said don't run linker,
5144 complain about input files to be given to the linker. */
5146 if (! linker_was_run && error_count == 0)
5147 for (i = 0; (int)i < n_infiles; i++)
5148 if (explicit_link_files[i])
5149 error ("%s: linker input file unused since linking not done",
5152 /* Delete some or all of the temporary files we made. */
5155 delete_failure_queue ();
5156 delete_temp_files ();
5158 if (print_help_list)
5160 printf ("\nReport bugs to egcs-bugs@egcs.cygnus.com.\n");
5161 printf ("Please see the file BUGS (included with the sources) first.\n");
5164 exit (error_count > 0 ? (signal_count ? 2 : 1) : 0);
5169 /* Find the proper compilation spec for the file name NAME,
5170 whose length is LENGTH. LANGUAGE is the specified language,
5171 or 0 if this file is to be passed to the linker. */
5173 static struct compiler *
5174 lookup_compiler (name, length, language)
5177 const char *language;
5179 struct compiler *cp;
5181 /* If this was specified by the user to be a linker input, indicate that. */
5182 if (language != 0 && language[0] == '*')
5185 /* Otherwise, look for the language, if one is spec'd. */
5188 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
5189 if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
5192 error ("language %s not recognized", language);
5196 /* Look for a suffix. */
5197 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
5199 if (/* The suffix `-' matches only the file name `-'. */
5200 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
5201 || (strlen (cp->suffix) < length
5202 /* See if the suffix matches the end of NAME. */
5204 && ((!strcmp (cp->suffix,
5205 name + length - strlen (cp->suffix))
5206 || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
5207 && !strcasecmp (cp->suffix,
5208 name + length - strlen (cp->suffix)))
5210 && !strcmp (cp->suffix,
5211 name + length - strlen (cp->suffix))
5215 if (cp->spec[0][0] == '@')
5217 struct compiler *new;
5219 /* An alias entry maps a suffix to a language.
5220 Search for the language; pass 0 for NAME and LENGTH
5221 to avoid infinite recursion if language not found.
5222 Construct the new compiler spec. */
5223 language = cp->spec[0] + 1;
5224 new = (struct compiler *) xmalloc (sizeof (struct compiler));
5225 new->suffix = cp->suffix;
5226 bcopy ((char *) lookup_compiler (NULL_PTR, 0, language)->spec,
5227 (char *) new->spec, sizeof new->spec);
5231 /* A non-alias entry: return it. */
5243 register PTR value = (PTR) malloc (size);
5245 fatal ("virtual memory exhausted");
5250 xrealloc (old, size)
5256 ptr = (PTR) realloc (old, size);
5258 ptr = (PTR) malloc (size);
5260 fatal ("virtual memory exhausted");
5265 save_string (s, len)
5269 register char *result = xmalloc (len + 1);
5271 bcopy (s, result, len);
5277 pfatal_with_name (name)
5280 perror_with_name (name);
5281 delete_temp_files ();
5286 perror_with_name (name)
5289 error ("%s: %s", name, xstrerror (errno));
5293 pfatal_pexecute (errmsg_fmt, errmsg_arg)
5294 const char *errmsg_fmt;
5295 const char *errmsg_arg;
5299 int save_errno = errno;
5301 /* Space for trailing '\0' is in %s. */
5302 char *msg = xmalloc (strlen (errmsg_fmt) + strlen (errmsg_arg));
5303 sprintf (msg, errmsg_fmt, errmsg_arg);
5309 pfatal_with_name (errmsg_fmt);
5312 /* More 'friendly' abort that prints the line and file.
5313 config.h can #define abort fancy_abort if you like that sort of thing. */
5318 fatal ("Internal gcc abort.");
5321 /* Output an error message and exit */
5324 fatal VPROTO((const char *msgid, ...))
5326 #ifndef ANSI_PROTOTYPES
5331 VA_START (ap, msgid);
5333 #ifndef ANSI_PROTOTYPES
5334 msgid = va_arg (ap, const char *);
5337 fprintf (stderr, "%s: ", programname);
5338 vfprintf (stderr, _(msgid), ap);
5340 fprintf (stderr, "\n");
5341 delete_temp_files ();
5346 error VPROTO((const char *msgid, ...))
5348 #ifndef ANSI_PROTOTYPES
5353 VA_START (ap, msgid);
5355 #ifndef ANSI_PROTOTYPES
5356 msgid = va_arg (ap, const char *);
5359 fprintf (stderr, "%s: ", programname);
5360 vfprintf (stderr, _(msgid), ap);
5363 fprintf (stderr, "\n");
5367 notice VPROTO((const char *msgid, ...))
5369 #ifndef ANSI_PROTOTYPES
5374 VA_START (ap, msgid);
5376 #ifndef ANSI_PROTOTYPES
5377 msgid = va_arg (ap, const char *);
5380 vfprintf (stderr, _(msgid), ap);
5386 validate_all_switches ()
5388 struct compiler *comp;
5389 register const char *p;
5391 struct spec_list *spec;
5393 for (comp = compilers; comp->spec[0]; comp++)
5396 for (i = 0; i < sizeof comp->spec / sizeof comp->spec[0] && comp->spec[i]; i++)
5400 if (c == '%' && *p == '{')
5401 /* We have a switch spec. */
5402 validate_switches (p + 1);
5406 /* look through the linked list of specs read from the specs file */
5407 for (spec = specs; spec ; spec = spec->next)
5409 p = *(spec->ptr_spec);
5411 if (c == '%' && *p == '{')
5412 /* We have a switch spec. */
5413 validate_switches (p + 1);
5416 p = link_command_spec;
5418 if (c == '%' && *p == '{')
5419 /* We have a switch spec. */
5420 validate_switches (p + 1);
5423 /* Look at the switch-name that comes after START
5424 and mark as valid all supplied switches that match it. */
5427 validate_switches (start)
5430 register const char *p = start;
5445 while (*p != ':' && *p != '}') p++;
5449 else if (p[-1] == '*')
5451 /* Mark all matching switches as valid. */
5453 for (i = 0; i < n_switches; i++)
5454 if (!strncmp (switches[i].part1, filter, p - filter))
5455 switches[i].validated = 1;
5459 /* Mark an exact matching switch as valid. */
5460 for (i = 0; i < n_switches; i++)
5462 if (!strncmp (switches[i].part1, filter, p - filter)
5463 && switches[i].part1[p - filter] == 0)
5464 switches[i].validated = 1;
5469 /* Check whether a particular argument was used. The first time we
5470 canonicalize the switches to keep only the ones we care about. */
5484 static struct mswitchstr *mswitches;
5485 static int n_mswitches;
5490 struct mswitchstr *matches;
5494 /* Break multilib_matches into the component strings of string and replacement
5496 for (q = multilib_matches; *q != '\0'; q++)
5500 matches = (struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt);
5502 q = multilib_matches;
5513 matches[i].len = q - matches[i].str;
5515 matches[i].replace = ++q;
5516 while (*q != ';' && *q != '\0')
5522 matches[i].rep_len = q - matches[i].replace;
5530 /* Now build a list of the replacement string for switches that we care
5531 about. Make sure we allocate at least one entry. This prevents
5532 xmalloc from calling fatal, and prevents us from re-executing this
5535 = (struct mswitchstr *) xmalloc ((sizeof (struct mswitchstr))
5536 * (n_switches ? n_switches : 1));
5537 for (i = 0; i < n_switches; i++)
5539 int xlen = strlen (switches[i].part1);
5540 for (j = 0; j < cnt; j++)
5541 if (xlen == matches[j].len && ! strcmp (switches[i].part1, matches[j].str))
5543 mswitches[n_mswitches].str = matches[j].replace;
5544 mswitches[n_mswitches].len = matches[j].rep_len;
5545 mswitches[n_mswitches].replace = (char *)0;
5546 mswitches[n_mswitches].rep_len = 0;
5553 for (i = 0; i < n_mswitches; i++)
5554 if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
5561 default_arg (p, len)
5567 for (start = multilib_defaults; *start != '\0'; start = end+1)
5569 while (*start == ' ' || *start == '\t')
5575 for (end = start+1; *end != ' ' && *end != '\t' && *end != '\0'; end++)
5578 if ((end - start) == len && strncmp (p, start, len) == 0)
5588 /* Work out the subdirectory to use based on the
5589 options. The format of multilib_select is a list of elements.
5590 Each element is a subdirectory name followed by a list of options
5591 followed by a semicolon. gcc will consider each line in turn. If
5592 none of the options beginning with an exclamation point are
5593 present, and all of the other options are present, that
5594 subdirectory will be used. */
5599 char *p = multilib_select;
5601 char *this_path, *this_arg;
5607 /* Ignore newlines. */
5614 /* Get the initial path. */
5622 this_path_len = p - this_path;
5624 /* Check the arguments. */
5639 while (*p != ' ' && *p != ';')
5646 if (*this_arg != '!')
5654 /* If this is a default argument, we can just ignore it.
5655 This is true even if this_arg begins with '!'. Beginning
5656 with '!' does not mean that this argument is necessarily
5657 inappropriate for this library: it merely means that
5658 there is a more specific library which uses this
5659 argument. If this argument is a default, we need not
5660 consider that more specific library. */
5661 if (! default_arg (this_arg, p - this_arg))
5663 ok = used_arg (this_arg, p - this_arg);
5674 if (this_path_len != 1
5675 || this_path[0] != '.')
5677 char * new_multilib_dir = xmalloc (this_path_len + 1);
5678 strncpy (new_multilib_dir, this_path, this_path_len);
5679 new_multilib_dir[this_path_len] = '\0';
5680 multilib_dir = new_multilib_dir;
5689 /* Print out the multiple library subdirectory selection
5690 information. This prints out a series of lines. Each line looks
5691 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
5692 required. Only the desired options are printed out, the negative
5693 matches. The options are print without a leading dash. There are
5694 no spaces to make it easy to use the information in the shell.
5695 Each subdirectory is printed only once. This assumes the ordering
5696 generated by the genmultilib script. */
5699 print_multilib_info ()
5701 char *p = multilib_select;
5702 char *last_path = 0, *this_path;
5704 int last_path_len = 0;
5708 /* Ignore newlines. */
5715 /* Get the initial path. */
5724 /* If this is a duplicate, skip it. */
5725 skip = (last_path != 0 && p - this_path == last_path_len
5726 && ! strncmp (last_path, this_path, last_path_len));
5728 last_path = this_path;
5729 last_path_len = p - this_path;
5731 /* If this directory requires any default arguments, we can skip
5732 it. We will already have printed a directory identical to
5733 this one which does not require that default argument. */
5751 while (*q != ' ' && *q != ';')
5759 && default_arg (arg, q - arg))
5774 for (p1 = last_path; p1 < p; p1++)
5793 use_arg = *p != '!';
5798 while (*p != ' ' && *p != ';')
5813 /* If there are extra options, print them now */
5814 if (multilib_extra && *multilib_extra)
5816 int print_at = TRUE;
5819 for (q = multilib_extra; *q != '\0'; q++)