1 /* Compiler driver program that can handle many languages.
2 Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA.
22 This paragraph is here to try to keep Sun CC from dying.
23 The number of chars here seems crucial!!!! */
25 /* $FreeBSD: src/contrib/gcc/gcc.c,v 1.17.2.9 2002/06/20 23:12:28 obrien Exp $ */
26 /* $DragonFly: src/contrib/gcc/Attic/gcc.c,v 1.6 2004/06/21 03:31:00 dillon Exp $ */
28 /* This program is the user interface to the C compiler and possibly to
29 other compilers. It is used because compilation is a complicated procedure
30 which involves running several programs and passing temporary files between
31 them, forwarding the users switches to those programs selectively,
32 and deleting the temporary files at the end.
34 CC recognizes how to compile each input file by suffixes in the file names.
35 Once it knows which kind of compilation to perform, the procedure for
36 compilation is specified by a string called a "spec". */
47 #define exit __posix_exit
50 /* By default there is no special suffix for executables. */
51 #ifdef EXECUTABLE_SUFFIX
52 #define HAVE_EXECUTABLE_SUFFIX
54 #define EXECUTABLE_SUFFIX ""
57 /* By default, the suffix for object files is ".o". */
59 #define HAVE_OBJECT_SUFFIX
61 #define OBJECT_SUFFIX ".o"
64 /* By default, colon separates directories in a path. */
65 #ifndef PATH_SEPARATOR
66 #define PATH_SEPARATOR ':'
70 #define DIR_SEPARATOR '/'
73 /* Define IS_DIR_SEPARATOR. */
74 #ifndef DIR_SEPARATOR_2
75 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
76 #else /* DIR_SEPARATOR_2 */
77 # define IS_DIR_SEPARATOR(ch) \
78 (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
79 #endif /* DIR_SEPARATOR_2 */
81 static char dir_separator_str[] = {DIR_SEPARATOR, 0};
83 #define obstack_chunk_alloc xmalloc
84 #define obstack_chunk_free free
86 #ifndef GET_ENV_PATH_LIST
87 #define GET_ENV_PATH_LIST(VAR,NAME) do { (VAR) = getenv (NAME); } while (0)
91 #define kill(p,s) raise(s)
94 /* If a stage of compilation returns an exit status >= 1,
95 compilation of that file ceases. */
97 #define MIN_FATAL_STATUS 1
99 /* Flag saying to print the directories gcc will search through looking for
100 programs, libraries, etc. */
102 static int print_search_dirs;
104 /* Flag saying to print the full filename of this file
105 as found through our usual search mechanism. */
107 static const char *print_file_name = NULL;
109 /* As print_file_name, but search for executable file. */
111 static const char *print_prog_name = NULL;
113 /* Flag saying to print the relative path we'd use to
114 find libgcc.a given the current compiler flags. */
116 static int print_multi_directory;
118 /* Flag saying to print the list of subdirectories and
119 compiler flags used to select them in a standard form. */
121 static int print_multi_lib;
123 /* Flag saying to print the command line options understood by gcc and its
126 static int print_help_list;
128 /* Flag indicating whether we should print the command and arguments */
130 static int verbose_flag;
132 /* Nonzero means write "temp" files in source directory
133 and use the source file's name in them, and don't delete them. */
135 static int save_temps_flag;
137 /* The compiler version. */
139 static char *compiler_version;
141 /* The target version specified with -V */
143 static char *spec_version = DEFAULT_TARGET_VERSION;
145 /* The target machine specified with -b. */
147 static const char *spec_machine = DEFAULT_TARGET_MACHINE;
149 /* Nonzero if cross-compiling.
150 When -b is used, the value comes from the `specs' file. */
153 static char *cross_compile = "1";
155 static char *cross_compile = "0";
158 /* The number of errors that have occurred; the link phase will not be
159 run if this is non-zero. */
160 static int error_count = 0;
162 /* This is the obstack which we use to allocate many strings. */
164 static struct obstack obstack;
166 /* This is the obstack to build an environment variable to pass to
167 collect2 that describes all of the relevant switches of what to
168 pass the compiler in building the list of pointers to constructors
171 static struct obstack collect_obstack;
173 extern char *version_string;
175 /* Forward declaration for prototypes. */
178 static void init_spec PROTO((void));
179 static void read_specs PROTO((const char *, int));
180 static void set_spec PROTO((const char *, const char *));
181 static struct compiler *lookup_compiler PROTO((const char *, size_t, const char *));
182 static char *build_search_list PROTO((struct path_prefix *, const char *, int));
183 static void putenv_from_prefixes PROTO((struct path_prefix *, const char *));
184 static char *find_a_file PROTO((struct path_prefix *, const char *, int));
185 static void add_prefix PROTO((struct path_prefix *, const char *,
186 const char *, int, int, int *));
187 static char *skip_whitespace PROTO((char *));
188 static void record_temp_file PROTO((const char *, int, int));
189 static void delete_if_ordinary PROTO((const char *));
190 static void delete_temp_files PROTO((void));
191 static void delete_failure_queue PROTO((void));
192 static void clear_failure_queue PROTO((void));
193 static int check_live_switch PROTO((int, int));
194 static const char *handle_braces PROTO((const char *));
195 static char *save_string PROTO((const char *, int));
196 extern int do_spec PROTO((const char *));
197 static int do_spec_1 PROTO((const char *, int, const char *));
198 static const char *find_file PROTO((const char *));
199 static int is_directory PROTO((const char *, const char *, int));
200 static void validate_switches PROTO((const char *));
201 static void validate_all_switches PROTO((void));
202 static void give_switch PROTO((int, int, int));
203 static int used_arg PROTO((const char *, int));
204 static int default_arg PROTO((const char *, int));
205 static void set_multilib_dir PROTO((void));
206 static void print_multilib_info PROTO((void));
207 static void pfatal_with_name PROTO((const char *)) ATTRIBUTE_NORETURN;
208 static void perror_with_name PROTO((const char *));
209 static void pfatal_pexecute PROTO((const char *, const char *))
211 static void error PVPROTO((const char *, ...))
213 static void notice PVPROTO((const char *, ...))
215 static void display_help PROTO((void));
216 static void add_preprocessor_option PROTO ((const char *, int));
217 static void add_assembler_option PROTO ((const char *, int));
218 static void add_linker_option PROTO ((const char *, int));
219 static void process_command PROTO ((int, char **));
220 static int execute PROTO ((void));
221 static void unused_prefix_warnings PROTO ((struct path_prefix *));
222 static void clear_args PROTO ((void));
223 static void fatal_error PROTO ((int));
225 void fancy_abort PROTO((void)) ATTRIBUTE_NORETURN;
227 /* Called before processing to change/add/remove arguments. */
228 extern void lang_specific_driver PROTO ((void (*) PVPROTO((const char *, ...)),
229 int *, char ***, int *));
231 /* Called before linking. Returns 0 on success and -1 on failure. */
232 extern int lang_specific_pre_link ();
234 /* Number of extra output files that lang_specific_pre_link may generate. */
235 extern int lang_specific_extra_outfiles;
237 /* Specs are strings containing lines, each of which (if not blank)
238 is made up of a program name, and arguments separated by spaces.
239 The program name must be exact and start from root, since no path
240 is searched and it is unreliable to depend on the current working directory.
241 Redirection of input or output is not supported; the subprograms must
242 accept filenames saying what files to read and write.
244 In addition, the specs can contain %-sequences to substitute variable text
245 or for conditional text. Here is a table of all defined %-sequences.
246 Note that spaces are not generated automatically around the results of
247 expanding these sequences; therefore, you can concatenate them together
248 or with constant text in a single argument.
250 %% substitute one % into the program name or argument.
251 %i substitute the name of the input file being processed.
252 %b substitute the basename of the input file being processed.
253 This is the substring up to (and not including) the last period
254 and not including the directory.
256 substitute a file name that has suffix SUFFIX and is chosen
257 once per compilation, and mark the argument a la %d. To reduce
258 exposure to denial-of-service attacks, the file name is now
259 chosen in a way that is hard to predict even when previously
260 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
261 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
262 the regexp "[.A-Za-z]*" or the special string "%O", which is
263 treated exactly as if %O had been pre-processed. Previously, %g
264 was simply substituted with a file name chosen once per compilation,
265 without regard to any appended suffix (which was therefore treated
266 just like ordinary text), making such attacks more likely to succeed.
268 like %g, but generates a new temporary file name even if %uSUFFIX
271 substitutes the last file name generated with %uSUFFIX, generating a
272 new one if there is no such last file name. In the absence of any
273 %uSUFFIX, this is just like %gSUFFIX, except they don't share
274 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
275 would involve the generation of two distinct file names, one
276 for each `%g.s' and another for each `%U.s'. Previously, %U was
277 simply substituted with a file name chosen for the previous %u,
278 without regard to any appended suffix.
279 %d marks the argument containing or following the %d as a
280 temporary file name, so that that file will be deleted if CC exits
281 successfully. Unlike %g, this contributes no text to the argument.
282 %w marks the argument containing or following the %w as the
283 "output file" of this compilation. This puts the argument
284 into the sequence of arguments that %o will substitute later.
286 like %{...} but mark last argument supplied within
287 as a file to be deleted on failure.
288 %o substitutes the names of all the output files, with spaces
289 automatically placed around them. You should write spaces
290 around the %o as well or the results are undefined.
291 %o is for use in the specs for running the linker.
292 Input files whose names have no recognized suffix are not compiled
293 at all, but they are included among the output files, so they will
295 %O substitutes the suffix for object files. Note that this is
296 handled specially when it immediately follows %g, %u, or %U,
297 because of the need for those to form complete file names. The
298 handling is such that %O is treated exactly as if it had already
299 been substituted, except that %g, %u, and %U do not currently
300 support additional SUFFIX characters following %O as they would
301 following, for example, `.o'.
302 %p substitutes the standard macro predefinitions for the
303 current target machine. Use this when running cpp.
304 %P like %p, but puts `__' before and after the name of each macro.
305 (Except macros that already have __.)
307 %I Substitute a -iprefix option made from GCC_EXEC_PREFIX.
308 %s current argument is the name of a library or startup file of some sort.
309 Search for that file in a standard list of directories
310 and substitute the full name found.
311 %eSTR Print STR as an error message. STR is terminated by a newline.
312 Use this when inconsistent options are detected.
313 %x{OPTION} Accumulate an option for %X.
314 %X Output the accumulated linker options specified by compilations.
315 %Y Output the accumulated assembler options specified by compilations.
316 %Z Output the accumulated preprocessor options specified by compilations.
317 %v1 Substitute the major version number of GCC.
318 (For version 2.5.n, this is 2.)
319 %v2 Substitute the minor version number of GCC.
320 (For version 2.5.n, this is 5.)
321 %a process ASM_SPEC as a spec.
322 This allows config.h to specify part of the spec for running as.
323 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
324 used here. This can be used to run a post-processor after the
325 assembler has done its job.
326 %D Dump out a -L option for each directory in startfile_prefixes.
327 If multilib_dir is set, extra entries are generated with it affixed.
328 %l process LINK_SPEC as a spec.
329 %L process LIB_SPEC as a spec.
330 %G process LIBGCC_SPEC as a spec.
331 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
332 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
333 %c process SIGNED_CHAR_SPEC as a spec.
334 %C process CPP_SPEC as a spec. A capital C is actually used here.
335 %1 process CC1_SPEC as a spec.
336 %2 process CC1PLUS_SPEC as a spec.
337 %| output "-" if the input for the current command is coming from a pipe.
338 %* substitute the variable part of a matched option. (See below.)
339 Note that each comma in the substituted string is replaced by
341 %{S} substitutes the -S switch, if that switch was given to CC.
342 If that switch was not specified, this substitutes nothing.
343 Here S is a metasyntactic variable.
344 %{S*} substitutes all the switches specified to CC whose names start
345 with -S. This is used for -o, -D, -I, etc; switches that take
346 arguments. CC considers `-o foo' as being one switch whose
347 name starts with `o'. %{o*} would substitute this text,
348 including the space; thus, two arguments would be generated.
349 %{^S*} likewise, but don't put a blank between a switch and any args.
350 %{S*:X} substitutes X if one or more switches whose names start with -S are
351 specified to CC. Note that the tail part of the -S option
352 (i.e. the part matched by the `*') will be substituted for each
353 occurrence of %* within X.
354 %{S:X} substitutes X, but only if the -S switch was given to CC.
355 %{!S:X} substitutes X, but only if the -S switch was NOT given to CC.
356 %{|S:X} like %{S:X}, but if no S switch, substitute `-'.
357 %{|!S:X} like %{!S:X}, but if there is an S switch, substitute `-'.
358 %{.S:X} substitutes X, but only if processing a file with suffix S.
359 %{!.S:X} substitutes X, but only if NOT processing a file with suffix S.
360 %{S|P:X} substitutes X if either -S or -P was given to CC. This may be
361 combined with ! and . as above binding stronger than the OR.
362 %(Spec) processes a specification defined in a specs file as *Spec:
363 %[Spec] as above, but put __ around -D arguments
365 The conditional text X in a %{S:X} or %{!S:X} construct may contain
366 other nested % constructs or spaces, or even newlines. They are
367 processed as usual, as described above.
369 The -O, -f, -m, and -W switches are handled specifically in these
370 constructs. If another value of -O or the negated form of a -f, -m, or
371 -W switch is found later in the command line, the earlier switch
372 value is ignored, except with {S*} where S is just one letter; this
373 passes all matching options.
375 The character | at the beginning of the predicate text is used to indicate
376 that a command should be piped to the following command, but only if -pipe
379 Note that it is built into CC which switches take arguments and which
380 do not. You might think it would be useful to generalize this to
381 allow each compiler's spec to say which switches take arguments. But
382 this cannot be done in a consistent fashion. CC cannot even decide
383 which input files have been specified without knowing which switches
384 take arguments, and it must know which input files to compile in order
385 to tell which compilers to run.
387 CC also knows implicitly that arguments starting in `-l' are to be
388 treated as compiler output files, and passed to the linker in their
389 proper position among the other output files. */
391 /* Define the macros used for specs %a, %l, %L, %S, %c, %C, %1. */
393 /* config.h can define ASM_SPEC to provide extra args to the assembler
394 or extra switch-translations. */
399 /* config.h can define ASM_FINAL_SPEC to run a post processor after
400 the assembler has run. */
401 #ifndef ASM_FINAL_SPEC
402 #define ASM_FINAL_SPEC ""
405 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
406 or extra switch-translations. */
411 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
412 or extra switch-translations. */
417 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
418 or extra switch-translations. */
420 #define CC1PLUS_SPEC ""
423 /* config.h can define LINK_SPEC to provide extra args to the linker
424 or extra switch-translations. */
429 /* config.h can define LIB_SPEC to override the default libraries. */
431 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
434 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
437 #if defined(LINK_LIBGCC_SPECIAL) || defined(LINK_LIBGCC_SPECIAL_1)
438 /* Have gcc do the search for libgcc.a. */
439 #define LIBGCC_SPEC "libgcc.a%s"
441 #define LIBGCC_SPEC "-lgcc"
445 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
446 #ifndef STARTFILE_SPEC
447 #define STARTFILE_SPEC \
448 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
451 /* config.h can define SWITCHES_NEED_SPACES to control which options
452 require spaces between the option and the argument. */
453 #ifndef SWITCHES_NEED_SPACES
454 #define SWITCHES_NEED_SPACES ""
457 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
459 #define ENDFILE_SPEC ""
462 /* This spec is used for telling cpp whether char is signed or not. */
463 #ifndef SIGNED_CHAR_SPEC
464 /* Use #if rather than ?:
465 because MIPS C compiler rejects like ?: in initializers. */
466 #if DEFAULT_SIGNED_CHAR
467 #define SIGNED_CHAR_SPEC "%{funsigned-char:-D__CHAR_UNSIGNED__}"
469 #define SIGNED_CHAR_SPEC "%{!fsigned-char:-D__CHAR_UNSIGNED__}"
474 #define LINKER_NAME "collect2"
477 static char *cpp_spec = CPP_SPEC;
478 static char *cpp_predefines = CPP_PREDEFINES;
479 static char *cc1_spec = CC1_SPEC;
480 static char *cc1plus_spec = CC1PLUS_SPEC;
481 static char *signed_char_spec = SIGNED_CHAR_SPEC;
482 static char *asm_spec = ASM_SPEC;
483 static char *asm_final_spec = ASM_FINAL_SPEC;
484 static char *link_spec = LINK_SPEC;
485 static char *lib_spec = LIB_SPEC;
486 static char *libgcc_spec = LIBGCC_SPEC;
487 static char *endfile_spec = ENDFILE_SPEC;
488 static char *startfile_spec = STARTFILE_SPEC;
489 static char *switches_need_spaces = SWITCHES_NEED_SPACES;
490 static char *linker_name_spec = LINKER_NAME;
492 /* Some compilers have limits on line lengths, and the multilib_select
493 and/or multilib_matches strings can be very long, so we build them at
495 static struct obstack multilib_obstack;
496 static char *multilib_select;
497 static char *multilib_matches;
498 static char *multilib_defaults;
499 #include "multilib.h"
501 /* Check whether a particular argument is a default argument. */
503 #ifndef MULTILIB_DEFAULTS
504 #define MULTILIB_DEFAULTS { "" }
507 static char *multilib_defaults_raw[] = MULTILIB_DEFAULTS;
510 struct user_specs *next;
511 const char *filename;
514 static struct user_specs *user_specs_head, *user_specs_tail;
516 /* This defines which switch letters take arguments. */
518 #define DEFAULT_SWITCH_TAKES_ARG(CHAR) \
519 ((CHAR) == 'D' || (CHAR) == 'U' || (CHAR) == 'o' \
520 || (CHAR) == 'e' || (CHAR) == 'T' || (CHAR) == 'u' \
521 || (CHAR) == 'I' || (CHAR) == 'm' || (CHAR) == 'x' \
522 || (CHAR) == 'L' || (CHAR) == 'A' || (CHAR) == 'V' \
523 || (CHAR) == 'B' || (CHAR) == 'b')
525 #ifndef SWITCH_TAKES_ARG
526 #define SWITCH_TAKES_ARG(CHAR) DEFAULT_SWITCH_TAKES_ARG(CHAR)
529 /* This defines which multi-letter switches take arguments. */
531 #define DEFAULT_WORD_SWITCH_TAKES_ARG(STR) \
532 (!strcmp (STR, "Tdata") || !strcmp (STR, "Ttext") \
533 || !strcmp (STR, "Tbss") || !strcmp (STR, "include") \
534 || !strcmp (STR, "imacros") || !strcmp (STR, "aux-info") \
535 || !strcmp (STR, "idirafter") || !strcmp (STR, "iprefix") \
536 || !strcmp (STR, "iwithprefix") || !strcmp (STR, "iwithprefixbefore") \
537 || !strcmp (STR, "isystem") || !strcmp (STR, "specs"))
539 #ifndef WORD_SWITCH_TAKES_ARG
540 #define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR)
544 #ifdef HAVE_EXECUTABLE_SUFFIX
545 /* This defines which switches stop a full compilation. */
546 #define DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) \
547 ((CHAR) == 'c' || (CHAR) == 'S')
549 #ifndef SWITCH_CURTAILS_COMPILATION
550 #define SWITCH_CURTAILS_COMPILATION(CHAR) \
551 DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR)
555 /* Record the mapping from file suffixes for compilation specs. */
559 const char *suffix; /* Use this compiler for input files
560 whose names end in this suffix. */
562 const char *spec[4]; /* To use this compiler, concatenate these
563 specs and pass to do_spec. */
566 /* Pointer to a vector of `struct compiler' that gives the spec for
567 compiling a file, based on its suffix.
568 A file that does not end in any of these suffixes will be passed
569 unchanged to the loader and nothing else will be done to it.
571 An entry containing two 0s is used to terminate the vector.
573 If multiple entries match a file, the last matching one is used. */
575 static struct compiler *compilers;
577 /* Number of entries in `compilers', not counting the null terminator. */
579 static int n_compilers;
581 /* The default list of file name suffixes and their compilation specs. */
583 static struct compiler default_compilers[] =
585 /* Add lists of suffixes of known languages here. If those languages
586 were not present when we built the driver, we will hit these copies
587 and be given a more meaningful error than "file not used since
588 linking is not done". */
589 {".m", {"#Objective-C"}},
590 {".cc", {"#C++"}}, {".cxx", {"#C++"}}, {".cpp", {"#C++"}},
591 {".c++", {"#C++"}}, {".C", {"#C++"}},
592 {".ads", {"#Ada"}}, {".adb", {"#Ada"}}, {".ada", {"#Ada"}},
593 {".f", {"#Fortran"}}, {".for", {"#Fortran"}}, {".F", {"#Fortran"}},
594 {".fpp", {"#Fortran"}},
595 {".p", {"#Pascal"}}, {".pas", {"#Pascal"}},
596 /* Next come the entries for C. */
601 "%{E|M|MM:cpp0 -lang-c %{ansi:-std=c89} %{std*} %{nostdinc*}\
602 %{C} %{v} %{A*} %{I*} %{P} %{$} %I\
603 %{C:%{!E:%eGNU C does not support -C without using -E}}\
604 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
605 %{!no-gcc:-D__GNUC__=%v1 -D__GNUC_MINOR__=%v2}\
606 %{ansi|std=*:%{!std=gnu*:-trigraphs -D__STRICT_ANSI__}}\
607 %{!undef:%{!ansi:%{!std=*:%p}%{std=gnu*:%p}} %P} %{trigraphs}\
608 %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
609 %{ffast-math:-D__FAST_MATH__}\
610 %{traditional} %{ftraditional:-traditional}\
611 %{traditional-cpp:-traditional}\
612 %{fleading-underscore} %{fno-leading-underscore}\
613 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\
614 %i %{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}}\n}\
615 %{!E:%{!M:%{!MM:cc1 %i %1 \
616 %{std*} %{nostdinc*} %{A*} %{I*} %I\
617 %{!Q:-quiet} -dumpbase %b.c %{d*} %{m*} %{a*}\
618 %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
619 %{!no-gcc:-D__GNUC__=%v1 -D__GNUC_MINOR__=%v2}\
620 %{ansi|std=*:%{!std=gnu*:-trigraphs -D__STRICT_ANSI__}}\
621 %{!undef:%{!ansi:%{!std=*:%p}%{std=gnu*:%p}} %P} %{trigraphs}\
622 %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
623 %{ffast-math:-D__FAST_MATH__}\
624 %{H} %C %{D*} %{U*} %{i*} %Z\
625 %{ftraditional:-traditional}\
626 %{traditional-cpp:-traditional}\
627 %{traditional} %{v:-version} %{pg:-p} %{p} %{f*}\
628 %{aux-info*} %{Qn:-fno-ident}\
630 %{g*} %{O*} %{W*} %{w} %{pedantic*}\
631 %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
632 %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
634 %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}\
635 %{!pipe:%g.s} %A\n }}}}"
636 #else /* ! USE_CPPLIB */
637 "cpp0 -lang-c %{ansi:-std=c89} %{std*} %{nostdinc*}\
638 %{C} %{v} %{A*} %{I*} %{P} %{$} %I\
639 %{C:%{!E:%eGNU C does not support -C without using -E}}\
640 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
641 %{!no-gcc:-D__GNUC__=%v1 -D__GNUC_MINOR__=%v2}\
642 %{ansi|std=*:%{!std=gnu*:-trigraphs -D__STRICT_ANSI__}}\
643 %{!undef:%{!ansi:%{!std=*:%p}%{std=gnu*:%p}} %P} %{trigraphs}\
644 %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
645 %{ffast-math:-D__FAST_MATH__}\
646 %{traditional} %{ftraditional:-traditional}\
647 %{traditional-cpp:-traditional}\
648 %{fleading-underscore} %{fno-leading-underscore}\
649 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\
650 %i %{!M:%{!MM:%{!E:%{!pipe:%g.i}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
651 "%{!M:%{!MM:%{!E:cc1 %{!pipe:%g.i} %1 \
652 %{!Q:-quiet} -dumpbase %b.c %{d*} %{m*} %{a*}\
653 %{g*} %{O*} %{W*} %{w} %{pedantic*} %{std*}\
654 %{traditional} %{v:-version} %{pg:-p} %{p} %{f*}\
655 %{aux-info*} %{Qn:-fno-ident}\
657 %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
658 %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
660 %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}\
661 %{!pipe:%g.s} %A\n }}}}"
662 #endif /* ! USE_CPPLIB */
665 {"%{E:cpp0 -lang-c %{ansi:-std=c89} %{std*} %{nostdinc*}\
666 %{C} %{v} %{A*} %{I*} %{P} %{$} %I\
667 %{C:%{!E:%eGNU C does not support -C without using -E}}\
668 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
669 %{!no-gcc:-D__GNUC__=%v1 -D__GNUC_MINOR__=%v2}\
670 %{ansi|std=*:%{!std=gnu*:-trigraphs -D__STRICT_ANSI__}}\
671 %{!undef:%{!ansi:%{!std=*:%p}%{std=gnu*:%p}} %P} %{trigraphs}\
672 %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
673 %{ffast-math:-D__FAST_MATH__}\
674 %{traditional} %{ftraditional:-traditional}\
675 %{traditional-cpp:-traditional}\
676 %{fleading-underscore} %{fno-leading-underscore}\
677 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\
679 %{!E:%e-E required when input is from standard input}"}},
680 {".h", {"@c-header"}},
682 {"%{!E:%eCompilation of header file requested} \
683 cpp0 %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %{$} %I\
684 %{C:%{!E:%eGNU C does not support -C without using -E}}\
685 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG}\
686 %{!no-gcc:-D__GNUC__=%v1 -D__GNUC_MINOR__=%v2}\
687 %{std=*:%{!std=gnu*:-trigraphs -D__STRICT_ANSI__}}\
688 %{!undef:%{!std=*:%p}%{std=gnu*:%p} %P} %{trigraphs}\
689 %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
690 %{ffast-math:-D__FAST_MATH__}\
691 %{traditional} %{ftraditional:-traditional}\
692 %{traditional-cpp:-traditional}\
693 %{fleading-underscore} %{fno-leading-underscore}\
694 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\
696 {".i", {"@cpp-output"}},
698 {"%{!M:%{!MM:%{!E:cc1 %i %1 %{!Q:-quiet} %{d*} %{m*} %{a*}\
699 %{g*} %{O*} %{W*} %{w} %{pedantic*} %{std*}\
700 %{traditional} %{v:-version} %{pg:-p} %{p} %{f*}\
701 %{aux-info*} %{Qn:-fno-ident}\
702 %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
703 %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
705 %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}\
706 %{!pipe:%g.s} %A\n }}}}"}},
707 {".s", {"@assembler"}},
709 {"%{!M:%{!MM:%{!E:%{!S:as %a %Y\
710 %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}\
712 {".S", {"@assembler-with-cpp"}},
713 {"@assembler-with-cpp",
714 {"cpp0 -lang-asm %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %{$} %I\
715 %{C:%{!E:%eGNU C does not support -C without using -E}}\
716 %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{MG} %{trigraphs}\
717 -$ %{!undef:%p %P} -D__ASSEMBLER__ \
718 %c %{Os:-D__OPTIMIZE_SIZE__} %{O*:%{!O0:-D__OPTIMIZE__}}\
719 %{ffast-math:-D__FAST_MATH__}\
720 %{traditional} %{ftraditional:-traditional}\
721 %{traditional-cpp:-traditional}\
722 %{fleading-underscore} %{fno-leading-underscore}\
723 %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\
724 %i %{!M:%{!MM:%{!E:%{!pipe:%g.s}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
725 "%{!M:%{!MM:%{!E:%{!S:as %a %Y\
726 %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}\
727 %{!pipe:%g.s} %A\n }}}}"}},
729 /* Mark end of table */
733 /* Number of elements in default_compilers, not counting the terminator. */
735 static int n_default_compilers
736 = (sizeof default_compilers / sizeof (struct compiler)) - 1;
738 /* Here is the spec for running the linker, after compiling all files. */
740 /* -u* was put back because both BSD and SysV seem to support it. */
741 /* %{static:} simply prevents an error message if the target machine
742 doesn't handle -static. */
743 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
744 scripts which exist in user specified directories, or in standard
746 #ifdef LINK_COMMAND_SPEC
747 /* Provide option to override link_command_spec from machine specific
748 configuration files. */
749 static const char *link_command_spec =
752 #ifdef LINK_LIBGCC_SPECIAL
753 /* Don't generate -L options. */
754 static const char *link_command_spec = "\
756 %{!c:%{!M:%{!MM:%{!E:%{!S:%(linker) %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} \
757 %{r} %{s} %{t} %{u*} %{x} %{z} %{Z}\
758 %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
760 %{!nostdlib:%{!nodefaultlibs:%G %L %G}}\
761 %{!A:%{!nostdlib:%{!nostartfiles:%E}}}\
766 static const char *link_command_spec = "\
768 %{!c:%{!M:%{!MM:%{!E:%{!S:%(linker) %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} \
769 %{r} %{s} %{t} %{u*} %{x} %{z} %{Z}\
770 %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
771 %{static:} %{L*} %D %o\
772 %{!nostdlib:%{!nodefaultlibs:%G %L %G}}\
773 %{!A:%{!nostdlib:%{!nostartfiles:%E}}}\
779 /* A vector of options to give to the linker.
780 These options are accumulated by %x,
781 and substituted into the linker command with %X. */
782 static int n_linker_options;
783 static char **linker_options;
785 /* A vector of options to give to the assembler.
786 These options are accumulated by -Wa,
787 and substituted into the assembler command with %Y. */
788 static int n_assembler_options;
789 static char **assembler_options;
791 /* A vector of options to give to the preprocessor.
792 These options are accumulated by -Wp,
793 and substituted into the preprocessor command with %Z. */
794 static int n_preprocessor_options;
795 static char **preprocessor_options;
797 /* Define how to map long options into short ones. */
799 /* This structure describes one mapping. */
802 /* The long option's name. */
804 /* The equivalent short option. */
805 const char *equivalent;
806 /* Argument info. A string of flag chars; NULL equals no options.
807 a => argument required.
808 o => argument optional.
809 j => join argument to equivalent, making one word.
810 * => require other text after NAME as an argument. */
811 const char *arg_info;
814 /* This is the table of mappings. Mappings are tried sequentially
815 for each option encountered; the first one that matches, wins. */
817 struct option_map option_map[] =
819 {"--all-warnings", "-Wall", 0},
820 {"--ansi", "-ansi", 0},
821 {"--assemble", "-S", 0},
822 {"--assert", "-A", "a"},
823 {"--classpath", "-fclasspath=", "aj"},
824 {"--CLASSPATH", "-fCLASSPATH=", "aj"},
825 {"--comments", "-C", 0},
826 {"--compile", "-c", 0},
827 {"--debug", "-g", "oj"},
828 {"--define-macro", "-D", "aj"},
829 {"--dependencies", "-M", 0},
830 {"--dump", "-d", "a"},
831 {"--dumpbase", "-dumpbase", "a"},
832 {"--entry", "-e", 0},
833 {"--extra-warnings", "-W", 0},
834 {"--for-assembler", "-Wa", "a"},
835 {"--for-linker", "-Xlinker", "a"},
836 {"--force-link", "-u", "a"},
837 {"--imacros", "-imacros", "a"},
838 {"--include", "-include", "a"},
839 {"--include-barrier", "-I-", 0},
840 {"--include-directory", "-I", "aj"},
841 {"--include-directory-after", "-idirafter", "a"},
842 {"--include-prefix", "-iprefix", "a"},
843 {"--include-with-prefix", "-iwithprefix", "a"},
844 {"--include-with-prefix-before", "-iwithprefixbefore", "a"},
845 {"--include-with-prefix-after", "-iwithprefix", "a"},
846 {"--language", "-x", "a"},
847 {"--library-directory", "-L", "a"},
848 {"--machine", "-m", "aj"},
849 {"--machine-", "-m", "*j"},
850 {"--no-line-commands", "-P", 0},
851 {"--no-precompiled-includes", "-noprecomp", 0},
852 {"--no-standard-includes", "-nostdinc", 0},
853 {"--no-standard-libraries", "-nostdlib", 0},
854 {"--no-warnings", "-w", 0},
855 {"--optimize", "-O", "oj"},
856 {"--output", "-o", "a"},
857 {"--output-class-directory", "-foutput-class-dir=", "ja"},
858 {"--pedantic", "-pedantic", 0},
859 {"--pedantic-errors", "-pedantic-errors", 0},
860 {"--pipe", "-pipe", 0},
861 {"--prefix", "-B", "a"},
862 {"--preprocess", "-E", 0},
863 {"--print-search-dirs", "-print-search-dirs", 0},
864 {"--print-file-name", "-print-file-name=", "aj"},
865 {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
866 {"--print-missing-file-dependencies", "-MG", 0},
867 {"--print-multi-lib", "-print-multi-lib", 0},
868 {"--print-multi-directory", "-print-multi-directory", 0},
869 {"--print-prog-name", "-print-prog-name=", "aj"},
870 {"--profile", "-p", 0},
871 {"--profile-blocks", "-a", 0},
872 {"--quiet", "-q", 0},
873 {"--save-temps", "-save-temps", 0},
874 {"--shared", "-shared", 0},
875 {"--silent", "-q", 0},
876 {"--specs", "-specs=", "aj"},
877 {"--static", "-static", 0},
878 {"--std", "-std=", "aj"},
879 {"--symbolic", "-symbolic", 0},
880 {"--target", "-b", "a"},
881 {"--trace-includes", "-H", 0},
882 {"--traditional", "-traditional", 0},
883 {"--traditional-cpp", "-traditional-cpp", 0},
884 {"--trigraphs", "-trigraphs", 0},
885 {"--undefine-macro", "-U", "aj"},
886 {"--use-version", "-V", "a"},
887 {"--user-dependencies", "-MM", 0},
888 {"--verbose", "-v", 0},
889 {"--version", "-dumpversion", 0},
890 {"--warn-", "-W", "*j"},
891 {"--write-dependencies", "-MD", 0},
892 {"--write-user-dependencies", "-MMD", 0},
896 /* Translate the options described by *ARGCP and *ARGVP.
897 Make a new vector and store it back in *ARGVP,
898 and store its length in *ARGVC. */
901 translate_options (argcp, argvp)
907 const char **argv = *argvp;
909 (const char **) xmalloc ((argc + 2) * 2 * sizeof (const char *));
913 newv[newindex++] = argv[i++];
917 /* Translate -- options. */
918 if (argv[i][0] == '-' && argv[i][1] == '-')
921 /* Find a mapping that applies to this option. */
922 for (j = 0; j < sizeof (option_map) / sizeof (option_map[0]); j++)
924 size_t optlen = strlen (option_map[j].name);
925 size_t arglen = strlen (argv[i]);
926 size_t complen = arglen > optlen ? optlen : arglen;
927 const char *arginfo = option_map[j].arg_info;
932 if (!strncmp (argv[i], option_map[j].name, complen))
940 k < sizeof (option_map) / sizeof (option_map[0]);
942 if (strlen (option_map[k].name) >= arglen
943 && !strncmp (argv[i], option_map[k].name, arglen))
945 error ("Ambiguous abbreviation %s", argv[i]);
949 if (k != sizeof (option_map) / sizeof (option_map[0]))
955 /* If the option has an argument, accept that. */
956 if (argv[i][optlen] == '=')
957 arg = argv[i] + optlen + 1;
959 /* If this mapping requires extra text at end of name,
960 accept that as "argument". */
961 else if (index (arginfo, '*') != 0)
962 arg = argv[i] + optlen;
964 /* Otherwise, extra text at end means mismatch.
965 Try other mappings. */
970 else if (index (arginfo, '*') != 0)
972 error ("Incomplete `%s' option", option_map[j].name);
976 /* Handle arguments. */
977 if (index (arginfo, 'a') != 0)
983 error ("Missing argument to `%s' option",
991 else if (index (arginfo, '*') != 0)
993 else if (index (arginfo, 'o') == 0)
996 error ("Extraneous argument to `%s' option",
1001 /* Store the translation as one argv elt or as two. */
1002 if (arg != 0 && index (arginfo, 'j') != 0)
1003 newv[newindex++] = concat (option_map[j].equivalent, arg,
1007 newv[newindex++] = option_map[j].equivalent;
1008 newv[newindex++] = arg;
1011 newv[newindex++] = option_map[j].equivalent;
1019 /* Handle old-fashioned options--just copy them through,
1020 with their arguments. */
1021 else if (argv[i][0] == '-')
1023 const char *p = argv[i] + 1;
1027 if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
1028 nskip += SWITCH_TAKES_ARG (c) - (p[1] != 0);
1029 else if (WORD_SWITCH_TAKES_ARG (p))
1030 nskip += WORD_SWITCH_TAKES_ARG (p);
1031 else if ((c == 'B' || c == 'b' || c == 'V' || c == 'x')
1034 else if (! strcmp (p, "Xlinker"))
1037 /* Watch out for an option at the end of the command line that
1038 is missing arguments, and avoid skipping past the end of the
1040 if (nskip + i > argc)
1045 newv[newindex++] = argv[i++];
1050 /* Ordinary operands, or +e options. */
1051 newv[newindex++] = argv[i++];
1064 #ifdef HAVE_STRERROR
1073 if (e > 0 && e < sys_nerr)
1074 return sys_errlist[e];
1086 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1087 be considered whitespace. */
1088 if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
1090 else if (*p == '\n' || *p == ' ' || *p == '\t')
1094 while (*p != '\n') p++;
1104 /* Structure to keep track of the specs that have been defined so far.
1105 These are accessed using %(specname) or %[specname] in a compiler
1110 /* The following 2 fields must be first */
1111 /* to allow EXTRA_SPECS to be initialized */
1112 char *name; /* name of the spec. */
1113 char *ptr; /* available ptr if no static pointer */
1115 /* The following fields are not initialized */
1116 /* by EXTRA_SPECS */
1117 char **ptr_spec; /* pointer to the spec itself. */
1118 struct spec_list *next; /* Next spec in linked list. */
1119 int name_len; /* length of the name */
1120 int alloc_p; /* whether string was allocated */
1123 #define INIT_STATIC_SPEC(NAME,PTR) \
1124 { NAME, NULL_PTR, PTR, (struct spec_list *)0, sizeof (NAME)-1, 0 }
1126 /* List of statically defined specs */
1127 static struct spec_list static_specs[] = {
1128 INIT_STATIC_SPEC ("asm", &asm_spec),
1129 INIT_STATIC_SPEC ("asm_final", &asm_final_spec),
1130 INIT_STATIC_SPEC ("cpp", &cpp_spec),
1131 INIT_STATIC_SPEC ("cc1", &cc1_spec),
1132 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec),
1133 INIT_STATIC_SPEC ("endfile", &endfile_spec),
1134 INIT_STATIC_SPEC ("link", &link_spec),
1135 INIT_STATIC_SPEC ("lib", &lib_spec),
1136 INIT_STATIC_SPEC ("libgcc", &libgcc_spec),
1137 INIT_STATIC_SPEC ("startfile", &startfile_spec),
1138 INIT_STATIC_SPEC ("switches_need_spaces", &switches_need_spaces),
1139 INIT_STATIC_SPEC ("signed_char", &signed_char_spec),
1140 INIT_STATIC_SPEC ("predefines", &cpp_predefines),
1141 INIT_STATIC_SPEC ("cross_compile", &cross_compile),
1142 INIT_STATIC_SPEC ("version", &compiler_version),
1143 INIT_STATIC_SPEC ("multilib", &multilib_select),
1144 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults),
1145 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra),
1146 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches),
1147 INIT_STATIC_SPEC ("linker", &linker_name_spec),
1150 #ifdef EXTRA_SPECS /* additional specs needed */
1151 /* Structure to keep track of just the first two args of a spec_list.
1152 That is all that the EXTRA_SPECS macro gives us. */
1159 static struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1160 static struct spec_list * extra_specs = (struct spec_list *)0;
1163 /* List of dynamically allocates specs that have been defined so far. */
1165 static struct spec_list *specs = (struct spec_list *)0;
1168 /* Initialize the specs lookup routines. */
1173 struct spec_list *next = (struct spec_list *)0;
1174 struct spec_list *sl = (struct spec_list *)0;
1178 return; /* already initialized */
1181 notice ("Using builtin specs.\n");
1184 extra_specs = (struct spec_list *)
1185 xmalloc (sizeof(struct spec_list) *
1186 (sizeof(extra_specs_1)/sizeof(extra_specs_1[0])));
1187 bzero ((PTR) extra_specs, sizeof(struct spec_list) *
1188 (sizeof(extra_specs_1)/sizeof(extra_specs_1[0])));
1190 for (i = (sizeof(extra_specs_1) / sizeof(extra_specs_1[0])) - 1; i >= 0; i--)
1192 sl = &extra_specs[i];
1193 sl->name = extra_specs_1[i].name;
1194 sl->ptr = extra_specs_1[i].ptr;
1196 sl->name_len = strlen (sl->name);
1197 sl->ptr_spec = &sl->ptr;
1202 for (i = (sizeof (static_specs) / sizeof (static_specs[0])) - 1; i >= 0; i--)
1204 sl = &static_specs[i];
1213 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1214 removed; If the spec starts with a + then SPEC is added to the end of the
1218 set_spec (name, spec)
1222 struct spec_list *sl;
1224 int name_len = strlen (name);
1227 /* If this is the first call, initialize the statically allocated specs */
1230 struct spec_list *next = (struct spec_list *)0;
1231 for (i = (sizeof (static_specs) / sizeof (static_specs[0])) - 1;
1234 sl = &static_specs[i];
1241 /* See if the spec already exists */
1242 for (sl = specs; sl; sl = sl->next)
1243 if (name_len == sl->name_len && !strcmp (sl->name, name))
1248 /* Not found - make it */
1249 sl = (struct spec_list *) xmalloc (sizeof (struct spec_list));
1250 sl->name = save_string (name, strlen (name));
1251 sl->name_len = name_len;
1252 sl->ptr_spec = &sl->ptr;
1254 *(sl->ptr_spec) = "";
1259 old_spec = *(sl->ptr_spec);
1260 *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
1261 ? concat (old_spec, spec + 1, NULL_PTR)
1262 : save_string (spec, strlen (spec)));
1266 notice ("Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
1269 /* Free the old spec */
1270 if (old_spec && sl->alloc_p)
1276 /* Accumulate a command (program name and args), and run it. */
1278 /* Vector of pointers to arguments in the current line of specifications. */
1280 static char **argbuf;
1282 /* Number of elements allocated in argbuf. */
1284 static int argbuf_length;
1286 /* Number of elements in argbuf currently in use (containing args). */
1288 static int argbuf_index;
1290 /* We want this on by default all the time now. */
1291 #define MKTEMP_EACH_FILE
1293 #ifdef MKTEMP_EACH_FILE
1295 extern char *make_temp_file PROTO((const char *));
1297 /* This is the list of suffixes and codes (%g/%u/%U) and the associated
1300 static struct temp_name {
1301 const char *suffix; /* suffix associated with the code. */
1302 int length; /* strlen (suffix). */
1303 int unique; /* Indicates whether %g or %u/%U was used. */
1304 const char *filename; /* associated filename. */
1305 int filename_length; /* strlen (filename). */
1306 struct temp_name *next;
1311 /* Number of commands executed so far. */
1313 static int execution_count;
1315 /* Number of commands that exited with a signal. */
1317 static int signal_count;
1319 /* Name with which this program was invoked. */
1321 static const char *programname;
1323 /* Structures to keep track of prefixes to try when looking for files. */
1327 char *prefix; /* String to prepend to the path. */
1328 struct prefix_list *next; /* Next in linked list. */
1329 int require_machine_suffix; /* Don't use without machine_suffix. */
1330 /* 2 means try both machine_suffix and just_machine_suffix. */
1331 int *used_flag_ptr; /* 1 if a file was found with this prefix. */
1336 struct prefix_list *plist; /* List of prefixes to try */
1337 int max_len; /* Max length of a prefix in PLIST */
1338 const char *name; /* Name of this list (used in config stuff) */
1341 /* List of prefixes to try when looking for executables. */
1343 static struct path_prefix exec_prefixes = { 0, 0, "exec" };
1345 /* List of prefixes to try when looking for startup (crt0) files. */
1347 static struct path_prefix startfile_prefixes = { 0, 0, "startfile" };
1349 /* List of prefixes to try when looking for include files. */
1351 static struct path_prefix include_prefixes = { 0, 0, "include" };
1353 /* Suffix to attach to directories searched for commands.
1354 This looks like `MACHINE/VERSION/'. */
1356 static const char *machine_suffix = 0;
1358 /* Suffix to attach to directories searched for commands.
1359 This is just `MACHINE/'. */
1361 static const char *just_machine_suffix = 0;
1363 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1365 static const char *gcc_exec_prefix;
1367 /* Default prefixes to attach to command names. */
1369 #ifdef CROSS_COMPILE /* Don't use these prefixes for a cross compiler. */
1370 #undef MD_EXEC_PREFIX
1371 #undef MD_STARTFILE_PREFIX
1372 #undef MD_STARTFILE_PREFIX_1
1375 #ifndef STANDARD_EXEC_PREFIX
1376 #define STANDARD_EXEC_PREFIX "/usr/local/lib/gcc-lib/"
1377 #endif /* !defined STANDARD_EXEC_PREFIX */
1379 static const char *standard_exec_prefix = STANDARD_EXEC_PREFIX;
1380 static const char *standard_exec_prefix_1 = "/usr/lib/gcc/";
1381 #ifdef MD_EXEC_PREFIX
1382 static const char *md_exec_prefix = MD_EXEC_PREFIX;
1385 #ifndef STANDARD_STARTFILE_PREFIX
1386 #define STANDARD_STARTFILE_PREFIX "/usr/local/lib/"
1387 #endif /* !defined STANDARD_STARTFILE_PREFIX */
1389 #ifdef MD_STARTFILE_PREFIX
1390 static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1392 #ifdef MD_STARTFILE_PREFIX_1
1393 static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1395 static const char *standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1396 static const char *standard_startfile_prefix_1 = "/lib/";
1397 static const char *standard_startfile_prefix_2 = "/usr/lib/";
1400 #error BINUTILS not defined
1403 #ifndef TOOLDIR_BASE_PREFIX
1404 #define TOOLDIR_BASE_PREFIX "/usr/local/"
1406 static const char *tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1407 static const char *tooldir_prefix;
1409 /* Subdirectory to use for locating libraries. Set by
1410 set_multilib_dir based on the compilation options. */
1412 static const char *multilib_dir;
1414 /* Clear out the vector of arguments (after a command is executed). */
1422 /* Add one argument to the vector at the end.
1423 This is done when a space is seen or at the end of the line.
1424 If DELETE_ALWAYS is nonzero, the arg is a filename
1425 and the file should be deleted eventually.
1426 If DELETE_FAILURE is nonzero, the arg is a filename
1427 and the file should be deleted if this compilation fails. */
1430 store_arg (arg, delete_always, delete_failure)
1432 int delete_always, delete_failure;
1434 if (argbuf_index + 1 == argbuf_length)
1436 = (char **) xrealloc (argbuf, (argbuf_length *= 2) * sizeof (char *));
1438 argbuf[argbuf_index++] = arg;
1439 argbuf[argbuf_index] = 0;
1441 if (delete_always || delete_failure)
1442 record_temp_file (arg, delete_always, delete_failure);
1445 /* Read compilation specs from a file named FILENAME,
1446 replacing the default ones.
1448 A suffix which starts with `*' is a definition for
1449 one of the machine-specific sub-specs. The "suffix" should be
1450 *asm, *cc1, *cpp, *link, *startfile, *signed_char, etc.
1451 The corresponding spec is stored in asm_spec, etc.,
1452 rather than in the `compilers' vector.
1454 Anything invalid in the file is a fatal error. */
1457 read_specs (filename, main_p)
1458 const char *filename;
1463 struct stat statbuf;
1468 notice ("Reading specs from %s\n", filename);
1470 /* Open and stat the file. */
1471 desc = open (filename, O_RDONLY, 0);
1473 pfatal_with_name (filename);
1474 if (stat (filename, &statbuf) < 0)
1475 pfatal_with_name (filename);
1477 /* Read contents of file into BUFFER. */
1478 buffer = xmalloc ((unsigned) statbuf.st_size + 1);
1479 readlen = read (desc, buffer, (unsigned) statbuf.st_size);
1481 pfatal_with_name (filename);
1482 buffer[readlen] = 0;
1485 /* Scan BUFFER for specs, putting them in the vector. */
1491 char *in, *out, *p1, *p2, *p3;
1493 /* Advance P in BUFFER to the next nonblank nocomment line. */
1494 p = skip_whitespace (p);
1498 /* Is this a special command that starts with '%'? */
1499 /* Don't allow this for the main specs file, since it would
1500 encourage people to overwrite it. */
1501 if (*p == '%' && !main_p)
1504 while (*p && *p != '\n')
1507 p++; /* Skip '\n' */
1509 if (!strncmp (p1, "%include", sizeof ("%include")-1)
1510 && (p1[sizeof "%include" - 1] == ' '
1511 || p1[sizeof "%include" - 1] == '\t'))
1515 p1 += sizeof ("%include");
1516 while (*p1 == ' ' || *p1 == '\t')
1519 if (*p1++ != '<' || p[-2] != '>')
1520 fatal ("specs %%include syntax malformed after %ld characters",
1521 (long) (p1 - buffer + 1));
1524 new_filename = find_a_file (&startfile_prefixes, p1, R_OK);
1525 read_specs (new_filename ? new_filename : p1, FALSE);
1528 else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
1529 && (p1[sizeof "%include_noerr" - 1] == ' '
1530 || p1[sizeof "%include_noerr" - 1] == '\t'))
1534 p1 += sizeof "%include_noerr";
1535 while (*p1 == ' ' || *p1 == '\t') p1++;
1537 if (*p1++ != '<' || p[-2] != '>')
1538 fatal ("specs %%include syntax malformed after %ld characters",
1539 (long) (p1 - buffer + 1));
1542 new_filename = find_a_file (&startfile_prefixes, p1, R_OK);
1544 read_specs (new_filename, FALSE);
1545 else if (verbose_flag)
1546 notice ("Could not find specs file %s\n", p1);
1549 else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
1550 && (p1[sizeof "%rename" - 1] == ' '
1551 || p1[sizeof "%rename" - 1] == '\t'))
1554 struct spec_list *sl;
1556 /* Get original name */
1557 p1 += sizeof "%rename";
1558 while (*p1 == ' ' || *p1 == '\t')
1561 if (! ISALPHA ((unsigned char)*p1))
1562 fatal ("specs %%rename syntax malformed after %ld characters",
1563 (long) (p1 - buffer));
1566 while (*p2 && !ISSPACE ((unsigned char)*p2))
1569 if (*p2 != ' ' && *p2 != '\t')
1570 fatal ("specs %%rename syntax malformed after %ld characters",
1571 (long) (p2 - buffer));
1575 while (*p2 == ' ' || *p2 == '\t')
1578 if (! ISALPHA ((unsigned char)*p2))
1579 fatal ("specs %%rename syntax malformed after %ld characters",
1580 (long) (p2 - buffer));
1582 /* Get new spec name */
1584 while (*p3 && !ISSPACE ((unsigned char)*p3))
1588 fatal ("specs %%rename syntax malformed after %ld characters",
1589 (long) (p3 - buffer));
1592 for (sl = specs; sl; sl = sl->next)
1593 if (name_len == sl->name_len && !strcmp (sl->name, p1))
1597 fatal ("specs %s spec was not found to be renamed", p1);
1599 if (strcmp (p1, p2) == 0)
1604 notice ("rename spec %s to %s\n", p1, p2);
1606 notice ("spec is '%s'\n\n", *(sl->ptr_spec));
1610 set_spec (p2, *(sl->ptr_spec));
1612 free (*(sl->ptr_spec));
1614 *(sl->ptr_spec) = "";
1619 fatal ("specs unknown %% command after %ld characters",
1620 (long) (p1 - buffer));
1623 /* Find the colon that should end the suffix. */
1625 while (*p1 && *p1 != ':' && *p1 != '\n')
1628 /* The colon shouldn't be missing. */
1630 fatal ("specs file malformed after %ld characters",
1631 (long) (p1 - buffer));
1633 /* Skip back over trailing whitespace. */
1635 while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
1638 /* Copy the suffix to a string. */
1639 suffix = save_string (p, p2 - p);
1640 /* Find the next line. */
1641 p = skip_whitespace (p1 + 1);
1643 fatal ("specs file malformed after %ld characters",
1644 (long) (p - buffer));
1647 /* Find next blank line or end of string. */
1648 while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
1651 /* Specs end at the blank line and do not include the newline. */
1652 spec = save_string (p, p1 - p);
1655 /* Delete backslash-newline sequences from the spec. */
1660 if (in[0] == '\\' && in[1] == '\n')
1662 else if (in[0] == '#')
1663 while (*in && *in != '\n')
1671 if (suffix[0] == '*')
1673 if (! strcmp (suffix, "*link_command"))
1674 link_command_spec = spec;
1676 set_spec (suffix + 1, spec);
1680 /* Add this pair to the vector. */
1682 = ((struct compiler *)
1683 xrealloc (compilers,
1684 (n_compilers + 2) * sizeof (struct compiler)));
1686 compilers[n_compilers].suffix = suffix;
1687 bzero ((char *) compilers[n_compilers].spec,
1688 sizeof compilers[n_compilers].spec);
1689 compilers[n_compilers].spec[0] = spec;
1691 bzero ((char *) &compilers[n_compilers],
1692 sizeof compilers[n_compilers]);
1696 link_command_spec = spec;
1699 if (link_command_spec == 0)
1700 fatal ("spec file has no spec for linking");
1703 /* Record the names of temporary files we tell compilers to write,
1704 and delete them at the end of the run. */
1706 /* This is the common prefix we use to make temp file names.
1707 It is chosen once for each run of this program.
1708 It is substituted into a spec by %g.
1709 Thus, all temp file names contain this prefix.
1710 In practice, all temp file names start with this prefix.
1712 This prefix comes from the envvar TMPDIR if it is defined;
1713 otherwise, from the P_tmpdir macro if that is defined;
1714 otherwise, in /usr/tmp or /tmp;
1715 or finally the current directory if all else fails. */
1717 static const char *temp_filename;
1719 /* Length of the prefix. */
1721 static int temp_filename_length;
1723 /* Define the list of temporary files to delete. */
1728 struct temp_file *next;
1731 /* Queue of files to delete on success or failure of compilation. */
1732 static struct temp_file *always_delete_queue;
1733 /* Queue of files to delete on failure of compilation. */
1734 static struct temp_file *failure_delete_queue;
1736 /* Record FILENAME as a file to be deleted automatically.
1737 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
1738 otherwise delete it in any case.
1739 FAIL_DELETE nonzero means delete it if a compilation step fails;
1740 otherwise delete it in any case. */
1743 record_temp_file (filename, always_delete, fail_delete)
1744 const char *filename;
1748 register char *name;
1749 name = xmalloc (strlen (filename) + 1);
1750 strcpy (name, filename);
1754 register struct temp_file *temp;
1755 for (temp = always_delete_queue; temp; temp = temp->next)
1756 if (! strcmp (name, temp->name))
1759 temp = (struct temp_file *) xmalloc (sizeof (struct temp_file));
1760 temp->next = always_delete_queue;
1762 always_delete_queue = temp;
1769 register struct temp_file *temp;
1770 for (temp = failure_delete_queue; temp; temp = temp->next)
1771 if (! strcmp (name, temp->name))
1774 temp = (struct temp_file *) xmalloc (sizeof (struct temp_file));
1775 temp->next = failure_delete_queue;
1777 failure_delete_queue = temp;
1783 /* Delete all the temporary files whose names we previously recorded. */
1786 delete_if_ordinary (name)
1793 printf ("Delete %s? (y or n) ", name);
1797 while ((c = getchar ()) != '\n' && c != EOF)
1800 if (i == 'y' || i == 'Y')
1802 if (stat (name, &st) >= 0 && S_ISREG (st.st_mode))
1803 if (unlink (name) < 0)
1805 perror_with_name (name);
1809 delete_temp_files ()
1811 register struct temp_file *temp;
1813 for (temp = always_delete_queue; temp; temp = temp->next)
1814 delete_if_ordinary (temp->name);
1815 always_delete_queue = 0;
1818 /* Delete all the files to be deleted on error. */
1821 delete_failure_queue ()
1823 register struct temp_file *temp;
1825 for (temp = failure_delete_queue; temp; temp = temp->next)
1826 delete_if_ordinary (temp->name);
1830 clear_failure_queue ()
1832 failure_delete_queue = 0;
1835 /* Routine to add variables to the environment. We do this to pass
1836 the pathname of the gcc driver, and the directories search to the
1837 collect2 program, which is being run as ld. This way, we can be
1838 sure of executing the right compiler when collect2 wants to build
1839 constructors and destructors. Since the environment variables we
1840 use come from an obstack, we don't have to worry about allocating
1849 #ifndef VMS /* nor about VMS */
1851 extern char **environ;
1852 char **old_environ = environ;
1856 int str_len = strlen (str);
1860 while ((ch = *p++) != '\0' && ch != '=')
1866 /* Search for replacing an existing environment variable, and
1867 count the number of total environment variables. */
1868 for (envp = old_environ; *envp; envp++)
1871 if (!strncmp (str, *envp, name_len))
1878 /* Add a new environment variable */
1879 environ = (char **) xmalloc (sizeof (char *) * (num_envs+2));
1881 memcpy ((char *) (environ + 1), (char *) old_environ,
1882 sizeof (char *) * (num_envs+1));
1887 #endif /* HAVE_PUTENV */
1890 /* Build a list of search directories from PATHS.
1891 PREFIX is a string to prepend to the list.
1892 If CHECK_DIR_P is non-zero we ensure the directory exists.
1893 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
1894 It is also used by the --print-search-dirs flag. */
1897 build_search_list (paths, prefix, check_dir_p)
1898 struct path_prefix *paths;
1902 int suffix_len = (machine_suffix) ? strlen (machine_suffix) : 0;
1904 = (just_machine_suffix) ? strlen (just_machine_suffix) : 0;
1905 int first_time = TRUE;
1906 struct prefix_list *pprefix;
1908 obstack_grow (&collect_obstack, prefix, strlen (prefix));
1910 for (pprefix = paths->plist; pprefix != 0; pprefix = pprefix->next)
1912 int len = strlen (pprefix->prefix);
1916 || is_directory (pprefix->prefix, machine_suffix, 0)))
1919 obstack_1grow (&collect_obstack, PATH_SEPARATOR);
1922 obstack_grow (&collect_obstack, pprefix->prefix, len);
1923 obstack_grow (&collect_obstack, machine_suffix, suffix_len);
1926 if (just_machine_suffix
1927 && pprefix->require_machine_suffix == 2
1929 || is_directory (pprefix->prefix, just_machine_suffix, 0)))
1932 obstack_1grow (&collect_obstack, PATH_SEPARATOR);
1935 obstack_grow (&collect_obstack, pprefix->prefix, len);
1936 obstack_grow (&collect_obstack, just_machine_suffix,
1940 if (! pprefix->require_machine_suffix)
1943 obstack_1grow (&collect_obstack, PATH_SEPARATOR);
1946 obstack_grow (&collect_obstack, pprefix->prefix, len);
1950 obstack_1grow (&collect_obstack, '\0');
1951 return obstack_finish (&collect_obstack);
1954 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
1958 putenv_from_prefixes (paths, env_var)
1959 struct path_prefix *paths;
1960 const char *env_var;
1962 putenv (build_search_list (paths, env_var, 1));
1965 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
1966 access to check permissions.
1967 Return 0 if not found, otherwise return its name, allocated with malloc. */
1970 find_a_file (pprefix, name, mode)
1971 struct path_prefix *pprefix;
1976 const char *file_suffix = ((mode & X_OK) != 0 ? EXECUTABLE_SUFFIX : "");
1977 struct prefix_list *pl;
1978 int len = pprefix->max_len + strlen (name) + strlen (file_suffix) + 1;
1980 #ifdef DEFAULT_ASSEMBLER
1981 if (! strcmp(name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0) {
1982 name = DEFAULT_ASSEMBLER;
1983 len = strlen(name)+1;
1984 temp = xmalloc (len);
1985 strcpy (temp, name);
1990 #ifdef DEFAULT_LINKER
1991 if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0) {
1992 name = DEFAULT_LINKER;
1993 len = strlen(name)+1;
1994 temp = xmalloc (len);
1995 strcpy (temp, name);
2001 len += strlen (machine_suffix);
2003 temp = xmalloc (len);
2005 /* Determine the filename to execute (special case for absolute paths). */
2007 if (IS_DIR_SEPARATOR (*name)
2008 #ifdef HAVE_DOS_BASED_FILESYSTEM
2009 /* Check for disk name on MS-DOS-based systems. */
2010 || (name[0] && name[1] == ':' && IS_DIR_SEPARATOR (name[2]))
2014 if (access (name, mode) == 0)
2016 strcpy (temp, name);
2021 for (pl = pprefix->plist; pl; pl = pl->next)
2025 /* Some systems have a suffix for executable files.
2026 So try appending that first. */
2027 if (file_suffix[0] != 0)
2029 strcpy (temp, pl->prefix);
2030 strcat (temp, machine_suffix);
2031 strcat (temp, name);
2032 strcat (temp, file_suffix);
2033 if (access (temp, mode) == 0)
2035 if (pl->used_flag_ptr != 0)
2036 *pl->used_flag_ptr = 1;
2041 /* Now try just the name. */
2042 strcpy (temp, pl->prefix);
2043 strcat (temp, machine_suffix);
2044 strcat (temp, name);
2045 if (access (temp, mode) == 0)
2047 if (pl->used_flag_ptr != 0)
2048 *pl->used_flag_ptr = 1;
2053 /* Certain prefixes are tried with just the machine type,
2054 not the version. This is used for finding as, ld, etc. */
2055 if (just_machine_suffix && pl->require_machine_suffix == 2)
2057 /* Some systems have a suffix for executable files.
2058 So try appending that first. */
2059 if (file_suffix[0] != 0)
2061 strcpy (temp, pl->prefix);
2062 strcat (temp, just_machine_suffix);
2063 strcat (temp, name);
2064 strcat (temp, file_suffix);
2065 if (access (temp, mode) == 0)
2067 if (pl->used_flag_ptr != 0)
2068 *pl->used_flag_ptr = 1;
2073 strcpy (temp, pl->prefix);
2074 strcat (temp, just_machine_suffix);
2075 strcat (temp, name);
2076 if (access (temp, mode) == 0)
2078 if (pl->used_flag_ptr != 0)
2079 *pl->used_flag_ptr = 1;
2084 /* Certain prefixes can't be used without the machine suffix
2085 when the machine or version is explicitly specified. */
2086 if (! pl->require_machine_suffix)
2088 /* Some systems have a suffix for executable files.
2089 So try appending that first. */
2090 if (file_suffix[0] != 0)
2092 strcpy (temp, pl->prefix);
2093 strcat (temp, name);
2094 strcat (temp, file_suffix);
2095 if (access (temp, mode) == 0)
2097 if (pl->used_flag_ptr != 0)
2098 *pl->used_flag_ptr = 1;
2103 strcpy (temp, pl->prefix);
2104 strcat (temp, name);
2105 if (access (temp, mode) == 0)
2107 if (pl->used_flag_ptr != 0)
2108 *pl->used_flag_ptr = 1;
2118 /* Add an entry for PREFIX in PLIST. If FIRST is set, it goes
2119 at the start of the list, otherwise it goes at the end.
2121 If WARN is nonzero, we will warn if no file is found
2122 through this prefix. WARN should point to an int
2123 which will be set to 1 if this entry is used.
2125 COMPONENT is the value to be passed to update_path.
2127 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2128 the complete value of machine_suffix.
2129 2 means try both machine_suffix and just_machine_suffix. */
2132 add_prefix (pprefix, prefix, component, first, require_machine_suffix, warn)
2133 struct path_prefix *pprefix;
2135 const char *component;
2137 int require_machine_suffix;
2140 struct prefix_list *pl, **prev;
2143 if (! first && pprefix->plist)
2145 for (pl = pprefix->plist; pl->next; pl = pl->next)
2150 prev = &pprefix->plist;
2152 /* Keep track of the longest prefix */
2154 prefix = update_path (prefix, component);
2155 len = strlen (prefix);
2156 if (len > pprefix->max_len)
2157 pprefix->max_len = len;
2159 pl = (struct prefix_list *) xmalloc (sizeof (struct prefix_list));
2160 pl->prefix = save_string (prefix, len);
2161 pl->require_machine_suffix = require_machine_suffix;
2162 pl->used_flag_ptr = warn;
2169 pl->next = (struct prefix_list *) 0;
2173 /* Print warnings for any prefixes in the list PPREFIX that were not used. */
2176 unused_prefix_warnings (pprefix)
2177 struct path_prefix *pprefix;
2179 struct prefix_list *pl = pprefix->plist;
2183 if (pl->used_flag_ptr != 0 && !*pl->used_flag_ptr)
2185 if (pl->require_machine_suffix && machine_suffix)
2186 error ("file path prefix `%s%s' never used", pl->prefix,
2189 error ("file path prefix `%s' never used", pl->prefix);
2191 /* Prevent duplicate warnings. */
2192 *pl->used_flag_ptr = 1;
2200 /* Execute the command specified by the arguments on the current line of spec.
2201 When using pipes, this includes several piped-together commands
2202 with `|' between them.
2204 Return 0 if successful, -1 if failed. */
2210 int n_commands; /* # of command. */
2214 const char *prog; /* program name. */
2215 char **argv; /* vector of args. */
2216 int pid; /* pid of process for this command. */
2219 struct command *commands; /* each command buffer with above info. */
2221 /* Count # of piped commands. */
2222 for (n_commands = 1, i = 0; i < argbuf_index; i++)
2223 if (strcmp (argbuf[i], "|") == 0)
2226 /* Get storage for each command. */
2228 = (struct command *) alloca (n_commands * sizeof (struct command));
2230 /* Split argbuf into its separate piped processes,
2231 and record info about each one.
2232 Also search for the programs that are to be run. */
2234 commands[0].prog = argbuf[0]; /* first command. */
2235 commands[0].argv = &argbuf[0];
2236 string = find_a_file (&exec_prefixes, commands[0].prog, X_OK);
2239 commands[0].argv[0] = string;
2241 for (n_commands = 1, i = 0; i < argbuf_index; i++)
2242 if (strcmp (argbuf[i], "|") == 0)
2243 { /* each command. */
2244 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2245 fatal ("-pipe not supported");
2247 argbuf[i] = 0; /* termination of command args. */
2248 commands[n_commands].prog = argbuf[i + 1];
2249 commands[n_commands].argv = &argbuf[i + 1];
2250 string = find_a_file (&exec_prefixes, commands[n_commands].prog, X_OK);
2252 commands[n_commands].argv[0] = string;
2256 argbuf[argbuf_index] = 0;
2258 /* If -v, print what we are about to do, and maybe query. */
2262 /* For help listings, put a blank line between sub-processes. */
2263 if (print_help_list)
2264 fputc ('\n', stderr);
2266 /* Print each piped command as a separate line. */
2267 for (i = 0; i < n_commands ; i++)
2271 for (j = commands[i].argv; *j; j++)
2272 fprintf (stderr, " %s", *j);
2274 /* Print a pipe symbol after all but the last command. */
2275 if (i + 1 != n_commands)
2276 fprintf (stderr, " |");
2277 fprintf (stderr, "\n");
2281 notice ("\nGo ahead? (y or n) ");
2285 while (getchar () != '\n')
2288 if (i != 'y' && i != 'Y')
2293 /* Run each piped subprocess. */
2295 for (i = 0; i < n_commands; i++)
2297 char *errmsg_fmt, *errmsg_arg;
2298 char *string = commands[i].argv[0];
2300 commands[i].pid = pexecute (string, commands[i].argv,
2301 programname, temp_filename,
2302 &errmsg_fmt, &errmsg_arg,
2303 ((i == 0 ? PEXECUTE_FIRST : 0)
2304 | (i + 1 == n_commands ? PEXECUTE_LAST : 0)
2305 | (string == commands[i].prog
2306 ? PEXECUTE_SEARCH : 0)
2307 | (verbose_flag ? PEXECUTE_VERBOSE : 0)));
2309 if (commands[i].pid == -1)
2310 pfatal_pexecute (errmsg_fmt, errmsg_arg);
2312 if (string != commands[i].prog)
2318 /* Wait for all the subprocesses to finish.
2319 We don't care what order they finish in;
2320 we know that N_COMMANDS waits will get them all.
2321 Ignore subprocesses that we don't know about,
2322 since they can be spawned by the process that exec'ed us. */
2327 for (i = 0; i < n_commands; )
2333 pid = pwait (commands[i].pid, &status, 0);
2337 for (j = 0; j < n_commands; j++)
2338 if (commands[j].pid == pid)
2343 if (WIFSIGNALED (status))
2345 fatal ("Internal compiler error: program %s got fatal signal %d",
2346 commands[j].prog, WTERMSIG (status));
2350 else if (WIFEXITED (status)
2351 && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
2361 /* Find all the switches given to us
2362 and make a vector describing them.
2363 The elements of the vector are strings, one per switch given.
2364 If a switch uses following arguments, then the `part1' field
2365 is the switch itself and the `args' field
2366 is a null-terminated vector containing the following arguments.
2367 The `live_cond' field is 1 if the switch is true in a conditional spec,
2368 -1 if false (overridden by a later switch), and is initialized to zero.
2369 The `validated' field is nonzero if any spec has looked at this switch;
2370 if it remains zero at the end of the run, it must be meaningless. */
2380 static struct switchstr *switches;
2382 static int n_switches;
2387 const char *language;
2390 /* Also a vector of input files specified. */
2392 static struct infile *infiles;
2394 static int n_infiles;
2396 /* This counts the number of libraries added by lang_specific_driver, so that
2397 we can tell if there were any user supplied any files or libraries. */
2399 static int added_libraries;
2401 /* And a vector of corresponding output files is made up later. */
2403 static const char **outfiles;
2405 /* Used to track if none of the -B paths are used. */
2408 /* Used to track if standard path isn't used and -b or -V is specified. */
2409 static int warn_std;
2411 /* Gives value to pass as "warn" to add_prefix for standard prefixes. */
2412 static int *warn_std_ptr = 0;
2414 #if defined(FREEBSD_NATIVE)
2415 #include <objformat.h>
2417 typedef enum { OBJFMT_UNKNOWN, OBJFMT_AOUT, OBJFMT_ELF } objf_t;
2419 static objf_t objformat = OBJFMT_UNKNOWN;
2420 #endif /* FREEBSD_NATIVE */
2422 #if defined(HAVE_OBJECT_SUFFIX) || defined(HAVE_EXECUTABLE_SUFFIX)
2424 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
2425 is true if we should look for an executable suffix as well. */
2428 convert_filename (name, do_exe)
2438 len = strlen (name);
2440 #ifdef HAVE_OBJECT_SUFFIX
2441 /* Convert x.o to x.obj if OBJECT_SUFFIX is ".obj". */
2443 && name[len - 2] == '.'
2444 && name[len - 1] == 'o')
2446 obstack_grow (&obstack, name, len - 2);
2447 obstack_grow0 (&obstack, OBJECT_SUFFIX, strlen (OBJECT_SUFFIX));
2448 name = obstack_finish (&obstack);
2452 #ifdef HAVE_EXECUTABLE_SUFFIX
2453 /* If there is no filetype, make it the executable suffix (which includes
2454 the "."). But don't get confused if we have just "-o". */
2455 if (! do_exe || EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
2458 for (i = len - 1; i >= 0; i--)
2459 if (IS_DIR_SEPARATOR (name[i]))
2462 for (i++; i < len; i++)
2466 obstack_grow (&obstack, name, len);
2467 obstack_grow0 (&obstack, EXECUTABLE_SUFFIX, strlen (EXECUTABLE_SUFFIX));
2468 name = obstack_finish (&obstack);
2475 /* Display the command line switches accepted by gcc. */
2479 printf ("Usage: %s [options] file...\n", programname);
2480 printf ("Options:\n");
2482 printf (" --help Display this information\n");
2484 printf (" (Use '-v --help' to display command line options of sub-processes)\n");
2485 printf (" -dumpspecs Display all of the built in spec strings\n");
2486 printf (" -dumpversion Display the version of the compiler\n");
2487 printf (" -dumpmachine Display the compiler's target processor\n");
2488 printf (" -print-search-dirs Display the directories in the compiler's search path\n");
2489 printf (" -print-libgcc-file-name Display the name of the compiler's companion library\n");
2490 printf (" -print-file-name=<lib> Display the full path to library <lib>\n");
2491 printf (" -print-prog-name=<prog> Display the full path to compiler component <prog>\n");
2492 printf (" -print-multi-directory Display the root directory for versions of libgcc\n");
2493 printf (" -print-multi-lib Display the mapping between command line options and\n");
2494 printf (" multiple library search directories\n");
2495 printf (" -Wa,<options> Pass comma-separated <options> on to the assembler\n");
2496 printf (" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n");
2497 printf (" -Wl,<options> Pass comma-separated <options> on to the linker\n");
2498 printf (" -Xlinker <arg> Pass <arg> on to the linker\n");
2499 printf (" -save-temps Do not delete intermediate files\n");
2500 printf (" -pipe Use pipes rather than intermediate files\n");
2501 printf (" -specs=<file> Override builtin specs with the contents of <file>\n");
2502 printf (" -std=<standard> Assume that the input sources are for <standard>\n");
2503 printf (" -B <directory> Add <directory> to the compiler's search paths\n");
2504 printf (" -b <machine> Run gcc for target <machine>, if installed\n");
2505 printf (" -V <version> Run gcc version number <version>, if installed\n");
2506 printf (" -v Display the programs invoked by the compiler\n");
2507 printf (" -E Preprocess only; do not compile, assemble or link\n");
2508 printf (" -S Compile only; do not assemble or link\n");
2509 printf (" -c Compile and assemble, but do not link\n");
2510 printf (" -o <file> Place the output into <file>\n");
2511 printf (" -x <language> Specify the language of the following input files\n");
2512 printf (" Permissable languages include: c c++ assembler none\n");
2513 printf (" 'none' means revert to the default behaviour of\n");
2514 printf (" guessing the language based on the file's extension\n");
2516 printf ("\nOptions starting with -g, -f, -m, -O or -W are automatically passed on to\n");
2517 printf ("the various sub-processes invoked by %s. In order to pass other options\n",
2519 printf ("on to these processes the -W<letter> options must be used.\n");
2521 /* The rest of the options are displayed by invocations of the various
2526 add_preprocessor_option (option, len)
2527 const char * option;
2530 n_preprocessor_options++;
2532 if (! preprocessor_options)
2533 preprocessor_options
2534 = (char **) xmalloc (n_preprocessor_options * sizeof (char *));
2536 preprocessor_options
2537 = (char **) xrealloc (preprocessor_options,
2538 n_preprocessor_options * sizeof (char *));
2540 preprocessor_options [n_preprocessor_options - 1] =
2541 save_string (option, len);
2545 add_assembler_option (option, len)
2546 const char * option;
2549 n_assembler_options++;
2551 if (! assembler_options)
2553 = (char **) xmalloc (n_assembler_options * sizeof (char *));
2556 = (char **) xrealloc (assembler_options,
2557 n_assembler_options * sizeof (char *));
2559 assembler_options [n_assembler_options - 1] = save_string (option, len);
2563 add_linker_option (option, len)
2564 const char * option;
2569 if (! linker_options)
2571 = (char **) xmalloc (n_linker_options * sizeof (char *));
2574 = (char **) xrealloc (linker_options,
2575 n_linker_options * sizeof (char *));
2577 linker_options [n_linker_options - 1] = save_string (option, len);
2580 /* Create the vector `switches' and its contents.
2581 Store its length in `n_switches'. */
2584 process_command (argc, argv)
2591 char *spec_lang = 0;
2592 int last_language_n_infiles;
2595 int lang_n_infiles = 0;
2597 GET_ENV_PATH_LIST (gcc_exec_prefix, "GCC_EXEC_PREFIX");
2601 added_libraries = 0;
2603 /* Figure compiler version from version string. */
2605 compiler_version = temp1 =
2606 save_string (version_string, strlen (version_string));
2607 for (; *temp1; ++temp1)
2616 /* Set up the default search paths. */
2618 if (gcc_exec_prefix)
2620 int len = strlen (gcc_exec_prefix);
2621 if (len > (int) sizeof ("/lib/gcc-lib/")-1
2622 && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
2624 temp = gcc_exec_prefix + len - sizeof ("/lib/gcc-lib/") + 1;
2625 if (IS_DIR_SEPARATOR (*temp)
2626 && strncmp (temp+1, "lib", 3) == 0
2627 && IS_DIR_SEPARATOR (temp[4])
2628 && strncmp (temp+5, "gcc-lib", 7) == 0)
2629 len -= sizeof ("/lib/gcc-lib/") - 1;
2632 set_std_prefix (gcc_exec_prefix, len);
2633 add_prefix (&exec_prefixes, gcc_exec_prefix, "GCC", 0, 0, NULL_PTR);
2634 add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC", 0, 0, NULL_PTR);
2637 /* COMPILER_PATH and LIBRARY_PATH have values
2638 that are lists of directory names with colons. */
2640 GET_ENV_PATH_LIST (temp, "COMPILER_PATH");
2643 const char *startp, *endp;
2644 char *nstore = (char *) alloca (strlen (temp) + 3);
2646 startp = endp = temp;
2649 if (*endp == PATH_SEPARATOR || *endp == 0)
2651 strncpy (nstore, startp, endp-startp);
2653 strcpy (nstore, concat (".", dir_separator_str, NULL_PTR));
2654 else if (!IS_DIR_SEPARATOR (endp[-1]))
2656 nstore[endp-startp] = DIR_SEPARATOR;
2657 nstore[endp-startp+1] = 0;
2660 nstore[endp-startp] = 0;
2661 add_prefix (&exec_prefixes, nstore, 0, 0, 0, NULL_PTR);
2662 add_prefix (&include_prefixes,
2663 concat (nstore, "include", NULL_PTR),
2667 endp = startp = endp + 1;
2674 GET_ENV_PATH_LIST (temp, "LIBRARY_PATH");
2675 if (temp && *cross_compile == '0')
2677 const char *startp, *endp;
2678 char *nstore = (char *) alloca (strlen (temp) + 3);
2680 startp = endp = temp;
2683 if (*endp == PATH_SEPARATOR || *endp == 0)
2685 strncpy (nstore, startp, endp-startp);
2687 strcpy (nstore, concat (".", dir_separator_str, NULL_PTR));
2688 else if (!IS_DIR_SEPARATOR (endp[-1]))
2690 nstore[endp-startp] = DIR_SEPARATOR;
2691 nstore[endp-startp+1] = 0;
2694 nstore[endp-startp] = 0;
2695 add_prefix (&startfile_prefixes, nstore, NULL_PTR,
2699 endp = startp = endp + 1;
2706 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
2707 GET_ENV_PATH_LIST (temp, "LPATH");
2708 if (temp && *cross_compile == '0')
2710 const char *startp, *endp;
2711 char *nstore = (char *) alloca (strlen (temp) + 3);
2713 startp = endp = temp;
2716 if (*endp == PATH_SEPARATOR || *endp == 0)
2718 strncpy (nstore, startp, endp-startp);
2720 strcpy (nstore, concat (".", dir_separator_str, NULL_PTR));
2721 else if (!IS_DIR_SEPARATOR (endp[-1]))
2723 nstore[endp-startp] = DIR_SEPARATOR;
2724 nstore[endp-startp+1] = 0;
2727 nstore[endp-startp] = 0;
2728 add_prefix (&startfile_prefixes, nstore, NULL_PTR,
2732 endp = startp = endp + 1;
2739 #if defined(FREEBSD_NATIVE)
2742 if (getobjformat (buf, sizeof buf, &argc, argv))
2743 if (strcmp (buf, "aout") == 0)
2744 objformat = OBJFMT_AOUT;
2745 else if (strcmp (buf, "elf") == 0)
2746 objformat = OBJFMT_ELF;
2748 fprintf(stderr, "Unrecognized object format: %s\n", buf);
2750 #endif /* FREEBSD_NATIVE */
2752 /* Options specified as if they appeared on the command line. */
2753 temp = getenv ("GCC_OPTIONS");
2754 if ((temp) && (strlen (temp) > 0))
2762 while (isspace (*temp))
2764 len = strlen (temp);
2765 envopts = (char *) xmalloc (len + 1);
2766 strcpy (envopts, temp);
2768 for (i = 0; i < (len - 1); i++)
2769 if ((isspace (envopts[i])) && ! (isspace (envopts[i+1])))
2772 new_argv = (char **) alloca ((optc + argc) * sizeof(char *));
2774 for (i = 0, new_argc = 1; new_argc <= optc; new_argc++)
2776 while (isspace (envopts[i]))
2778 new_argv[new_argc] = envopts + i;
2779 while (!isspace (envopts[i]) && (envopts[i] != '\0'))
2781 envopts[i++] = '\0';
2783 for (i = 1; i < argc; i++)
2784 new_argv[new_argc++] = argv[i];
2790 /* Convert new-style -- options to old-style. */
2791 translate_options (&argc, &argv);
2793 /* Do language-specific adjustment/addition of flags. */
2794 lang_specific_driver (fatal, &argc, &argv, &added_libraries);
2796 /* Scan argv twice. Here, the first time, just count how many switches
2797 there will be in their vector, and how many input files in theirs.
2798 Here we also parse the switches that cc itself uses (e.g. -v). */
2800 for (i = 1; i < argc; i++)
2802 if (! strcmp (argv[i], "-dumpspecs"))
2804 struct spec_list *sl;
2806 for (sl = specs; sl; sl = sl->next)
2807 printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
2808 if (link_command_spec)
2809 printf ("*link_command:\n%s\n\n", link_command_spec);
2812 else if (! strcmp (argv[i], "-dumpversion"))
2814 printf ("%s\n", spec_version);
2817 else if (! strcmp (argv[i], "-dumpmachine"))
2819 printf ("%s\n", spec_machine);
2822 else if (strcmp (argv[i], "-fhelp") == 0)
2824 /* translate_options () has turned --help into -fhelp. */
2825 print_help_list = 1;
2827 /* We will be passing a dummy file on to the sub-processes. */
2831 add_preprocessor_option ("--help", 6);
2832 add_assembler_option ("--help", 6);
2833 add_linker_option ("--help", 6);
2835 else if (! strcmp (argv[i], "-print-search-dirs"))
2836 print_search_dirs = 1;
2837 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
2838 print_file_name = "libgcc.a";
2839 else if (! strncmp (argv[i], "-print-file-name=", 17))
2840 print_file_name = argv[i] + 17;
2841 else if (! strncmp (argv[i], "-print-prog-name=", 17))
2842 print_prog_name = argv[i] + 17;
2843 else if (! strcmp (argv[i], "-print-multi-lib"))
2844 print_multi_lib = 1;
2845 else if (! strcmp (argv[i], "-print-multi-directory"))
2846 print_multi_directory = 1;
2847 else if (! strncmp (argv[i], "-Wa,", 4))
2850 /* Pass the rest of this option to the assembler. */
2852 /* Split the argument at commas. */
2854 for (j = 4; argv[i][j]; j++)
2855 if (argv[i][j] == ',')
2857 add_assembler_option (argv[i] + prev, j - prev);
2861 /* Record the part after the last comma. */
2862 add_assembler_option (argv[i] + prev, j - prev);
2864 else if (! strncmp (argv[i], "-Wp,", 4))
2867 /* Pass the rest of this option to the preprocessor. */
2869 /* Split the argument at commas. */
2871 for (j = 4; argv[i][j]; j++)
2872 if (argv[i][j] == ',')
2874 add_preprocessor_option (argv[i] + prev, j - prev);
2878 /* Record the part after the last comma. */
2879 add_preprocessor_option (argv[i] + prev, j - prev);
2881 else if (argv[i][0] == '+' && argv[i][1] == 'e')
2882 /* The +e options to the C++ front-end. */
2884 else if (strncmp (argv[i], "-Wl,", 4) == 0)
2887 /* Split the argument at commas. */
2888 for (j = 3; argv[i][j]; j++)
2889 n_infiles += (argv[i][j] == ',');
2891 else if (strcmp (argv[i], "-Xlinker") == 0)
2894 fatal ("argument to `-Xlinker' is missing");
2899 else if (strcmp (argv[i], "-l") == 0)
2902 fatal ("argument to `-l' is missing");
2907 else if (strncmp (argv[i], "-l", 2) == 0)
2909 else if (strcmp (argv[i], "-save-temps") == 0)
2911 save_temps_flag = 1;
2914 else if (strcmp (argv[i], "-specs") == 0)
2916 struct user_specs *user = (struct user_specs *)
2917 xmalloc (sizeof (struct user_specs));
2919 fatal ("argument to `-specs' is missing");
2921 user->next = (struct user_specs *)0;
2922 user->filename = argv[i];
2923 if (user_specs_tail)
2924 user_specs_tail->next = user;
2926 user_specs_head = user;
2927 user_specs_tail = user;
2929 else if (strncmp (argv[i], "-specs=", 7) == 0)
2931 struct user_specs *user = (struct user_specs *)
2932 xmalloc (sizeof (struct user_specs));
2933 if (strlen (argv[i]) == 7)
2934 fatal ("argument to `-specs=' is missing");
2936 user->next = (struct user_specs *)0;
2937 user->filename = argv[i]+7;
2938 if (user_specs_tail)
2939 user_specs_tail->next = user;
2941 user_specs_head = user;
2942 user_specs_tail = user;
2944 else if (argv[i][0] == '-' && argv[i][1] != 0)
2946 register char *p = &argv[i][1];
2947 register int c = *p;
2953 if (p[1] == 0 && i + 1 == argc)
2954 fatal ("argument to `-b' is missing");
2956 spec_machine = argv[++i];
2958 spec_machine = p + 1;
2960 warn_std_ptr = &warn_std;
2966 if (p[1] == 0 && i + 1 == argc)
2967 fatal ("argument to `-B' is missing");
2972 add_prefix (&exec_prefixes, value, NULL_PTR, 1, 0, &warn_B);
2973 add_prefix (&startfile_prefixes, value, NULL_PTR,
2975 add_prefix (&include_prefixes, concat (value, "include",
2977 NULL_PTR, 1, 0, NULL_PTR);
2979 /* As a kludge, if the arg is "[foo/]stageN/", just add
2980 "[foo/]include" to the include prefix. */
2982 int len = strlen (value);
2985 && (IS_DIR_SEPARATOR (value[len - 8]))))
2986 && strncmp (value + len - 7, "stage", 5) == 0
2987 && ISDIGIT (value[len - 2])
2988 && (IS_DIR_SEPARATOR (value[len - 1])))
2991 add_prefix (&include_prefixes, "include", NULL_PTR,
2995 char *string = xmalloc (len + 1);
2996 strncpy (string, value, len-7);
2997 strcpy (string+len-7, "include");
2998 add_prefix (&include_prefixes, string, NULL_PTR,
3007 case 'v': /* Print our subcommands and print versions. */
3009 /* If they do anything other than exactly `-v', don't set
3010 verbose_flag; rather, continue on to give the error. */
3018 if (p[1] == 0 && i + 1 == argc)
3019 fatal ("argument to `-V' is missing");
3021 spec_version = argv[++i];
3023 spec_version = p + 1;
3024 compiler_version = spec_version;
3025 warn_std_ptr = &warn_std;
3027 /* Validate the version number. Use the same checks
3028 done when inserting it into a spec.
3030 The format of the version string is
3031 ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)? */
3033 const char *v = compiler_version;
3035 /* Ignore leading non-digits. i.e. "foo-" in "foo-2.7.2". */
3036 while (! ISDIGIT (*v))
3039 if (v > compiler_version && v[-1] != '-')
3040 fatal ("invalid version number format");
3042 /* Set V after the first period. */
3043 while (ISDIGIT (*v))
3047 fatal ("invalid version number format");
3050 while (ISDIGIT (*v))
3053 if (*v != 0 && *v != ' ' && *v != '.' && *v != '-')
3054 fatal ("invalid version number format");
3070 #if defined(HAVE_EXECUTABLE_SUFFIX)
3075 /* Forward scan, just in case -S or -c is specified
3082 if (argv[j][0] == '-')
3084 if (SWITCH_CURTAILS_COMPILATION (argv[j][1])
3090 else if (skip = SWITCH_TAKES_ARG (argv[j][1]))
3091 j += skip - (argv[j][2] != 0);
3092 else if (skip = WORD_SWITCH_TAKES_ARG (argv[j] + 1))
3099 #if defined(HAVE_EXECUTABLE_SUFFIX) || defined(HAVE_OBJECT_SUFFIX)
3101 argv[i+1] = convert_filename (argv[i+1], ! have_c);
3103 argv[i] = convert_filename (argv[i], ! have_c);
3111 if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
3112 i += SWITCH_TAKES_ARG (c) - (p[1] != 0);
3113 else if (WORD_SWITCH_TAKES_ARG (p))
3114 i += WORD_SWITCH_TAKES_ARG (p);
3124 if (have_c && have_o && lang_n_infiles > 1)
3125 fatal ("cannot specify -o with -c or -S and multiple compilations");
3127 /* Set up the search paths before we go looking for config files. */
3129 /* These come before the md prefixes so that we will find gcc's subcommands
3130 (such as cpp) rather than those of the host system. */
3131 /* Use 2 as fourth arg meaning try just the machine as a suffix,
3132 as well as trying the machine and the version. */
3133 #ifdef FREEBSD_NATIVE
3134 add_prefix (&exec_prefixes, PREFIX"/libexec/" BINUTILS "/", "BINUTILS",
3139 n_switches++; /* add implied -maout */
3140 add_prefix (&exec_prefixes, PREFIX"/libexec/" BINUTILS "/aout/", "BINUTILS",
3144 add_prefix (&exec_prefixes, PREFIX"/libexec/" BINUTILS "/elf/", "BINUTILS",
3147 case OBJFMT_UNKNOWN:
3148 fatal ("object format unknown");
3150 #endif /* FREEBSD_NATIVE */
3153 add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
3154 0, 2, warn_std_ptr);
3155 #ifndef FREEBSD_NATIVE
3156 add_prefix (&exec_prefixes, standard_exec_prefix_1, "BINUTILS",
3157 0, 2, warn_std_ptr);
3158 #endif /* not FREEBSD_NATIVE */
3161 #ifndef FREEBSD_NATIVE
3162 add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
3163 0, 1, warn_std_ptr);
3164 add_prefix (&startfile_prefixes, standard_exec_prefix_1, "BINUTILS",
3165 0, 1, warn_std_ptr);
3166 #endif /* not FREEBSD_NATIVE */
3168 tooldir_prefix = concat (tooldir_base_prefix, spec_machine,
3169 dir_separator_str, NULL_PTR);
3171 /* If tooldir is relative, base it on exec_prefixes. A relative
3172 tooldir lets us move the installed tree as a unit.
3174 If GCC_EXEC_PREFIX is defined, then we want to add two relative
3175 directories, so that we can search both the user specified directory
3176 and the standard place. */
3178 if (!IS_DIR_SEPARATOR (*tooldir_prefix))
3180 if (gcc_exec_prefix)
3182 char *gcc_exec_tooldir_prefix
3183 = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
3184 spec_version, dir_separator_str, tooldir_prefix, NULL_PTR);
3186 add_prefix (&exec_prefixes,
3187 concat (gcc_exec_tooldir_prefix, "bin",
3188 dir_separator_str, NULL_PTR),
3189 NULL_PTR, 0, 0, NULL_PTR);
3190 add_prefix (&startfile_prefixes,
3191 concat (gcc_exec_tooldir_prefix, "lib",
3192 dir_separator_str, NULL_PTR),
3193 NULL_PTR, 0, 0, NULL_PTR);
3196 tooldir_prefix = concat (standard_exec_prefix, spec_machine,
3197 dir_separator_str, spec_version,
3198 dir_separator_str, tooldir_prefix, NULL_PTR);
3201 #ifndef FREEBSD_NATIVE
3202 add_prefix (&exec_prefixes,
3203 concat (tooldir_prefix, "bin", dir_separator_str, NULL_PTR),
3204 "BINUTILS", 0, 0, NULL_PTR);
3205 add_prefix (&startfile_prefixes,
3206 concat (tooldir_prefix, "lib", dir_separator_str, NULL_PTR),
3207 "BINUTILS", 0, 0, NULL_PTR);
3208 #endif /* not FREEBSD_NATIVE */
3210 /* More prefixes are enabled in main, after we read the specs file
3211 and determine whether this is cross-compilation or not. */
3214 /* Then create the space for the vectors and scan again. */
3216 switches = ((struct switchstr *)
3217 xmalloc ((n_switches + 1) * sizeof (struct switchstr)));
3218 infiles = (struct infile *) xmalloc ((n_infiles + 1) * sizeof (struct infile));
3221 last_language_n_infiles = -1;
3223 /* This, time, copy the text of each switch and store a pointer
3224 to the copy in the vector of switches.
3225 Store all the infiles in their vector. */
3227 #if defined(FREEBSD_NATIVE)
3231 switches[n_switches].part1 = "maout";
3232 switches[n_switches].args = 0;
3233 switches[n_switches].live_cond = 0;
3234 switches[n_switches].validated = 0;
3236 putenv("OBJFORMAT=aout");
3239 putenv("OBJFORMAT=elf");
3241 case OBJFMT_UNKNOWN:
3242 fatal ("object format unknown");
3244 #endif /* FREEBSD_NATIVE */
3246 for (i = 1; i < argc; i++)
3248 /* Just skip the switches that were handled by the preceding loop. */
3249 if (! strncmp (argv[i], "-Wa,", 4))
3251 else if (! strncmp (argv[i], "-Wp,", 4))
3253 else if (! strcmp (argv[i], "-print-search-dirs"))
3255 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3257 else if (! strncmp (argv[i], "-print-file-name=", 17))
3259 else if (! strncmp (argv[i], "-print-prog-name=", 17))
3261 else if (! strcmp (argv[i], "-print-multi-lib"))
3263 else if (! strcmp (argv[i], "-print-multi-directory"))
3265 else if (strcmp (argv[i], "-fhelp") == 0)
3269 /* Create a dummy input file, so that we can pass --help on to
3270 the various sub-processes. */
3271 infiles[n_infiles].language = "c";
3272 infiles[n_infiles++].name = "help-dummy";
3274 /* Preserve the --help switch so that it can be caught by the
3276 switches[n_switches].part1 = "--help";
3277 switches[n_switches].args = 0;
3278 switches[n_switches].live_cond = 0;
3279 switches[n_switches].validated = 0;
3284 else if (argv[i][0] == '+' && argv[i][1] == 'e')
3286 /* Compensate for the +e options to the C++ front-end;
3287 they're there simply for cfront call-compatibility. We do
3288 some magic in default_compilers to pass them down properly.
3289 Note we deliberately start at the `+' here, to avoid passing
3290 -e0 or -e1 down into the linker. */
3291 switches[n_switches].part1 = &argv[i][0];
3292 switches[n_switches].args = 0;
3293 switches[n_switches].live_cond = 0;
3294 switches[n_switches].validated = 0;
3297 else if (strncmp (argv[i], "-Wl,", 4) == 0)
3300 /* Split the argument at commas. */
3302 for (j = 4; argv[i][j]; j++)
3303 if (argv[i][j] == ',')
3305 infiles[n_infiles].language = "*";
3306 infiles[n_infiles++].name
3307 = save_string (argv[i] + prev, j - prev);
3310 /* Record the part after the last comma. */
3311 infiles[n_infiles].language = "*";
3312 infiles[n_infiles++].name = argv[i] + prev;
3314 else if (strcmp (argv[i], "-Xlinker") == 0)
3316 infiles[n_infiles].language = "*";
3317 infiles[n_infiles++].name = argv[++i];
3319 else if (strcmp (argv[i], "-l") == 0)
3320 { /* POSIX allows separation of -l and the lib arg;
3321 canonicalize by concatenating -l with its arg */
3322 infiles[n_infiles].language = "*";
3323 infiles[n_infiles++].name = concat ("-l", argv[++i], NULL);
3325 else if (strncmp (argv[i], "-l", 2) == 0)
3327 infiles[n_infiles].language = "*";
3328 infiles[n_infiles++].name = argv[i];
3330 else if (strcmp (argv[i], "-specs") == 0)
3332 else if (strncmp (argv[i], "-specs=", 7) == 0)
3334 /* -save-temps overrides -pipe, so that temp files are produced */
3335 else if (save_temps_flag && strcmp (argv[i], "-pipe") == 0)
3336 error ("Warning: -pipe ignored since -save-temps specified");
3337 else if (argv[i][0] == '-' && argv[i][1] != 0)
3339 register char *p = &argv[i][1];
3340 register int c = *p;
3344 if (p[1] == 0 && i + 1 == argc)
3345 fatal ("argument to `-x' is missing");
3347 spec_lang = argv[++i];
3350 if (! strcmp (spec_lang, "none"))
3351 /* Suppress the warning if -xnone comes after the last input
3352 file, because alternate command interfaces like g++ might
3353 find it useful to place -xnone after each input file. */
3356 last_language_n_infiles = n_infiles;
3359 switches[n_switches].part1 = p;
3360 /* Deal with option arguments in separate argv elements. */
3361 if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
3362 || WORD_SWITCH_TAKES_ARG (p))
3365 int n_args = WORD_SWITCH_TAKES_ARG (p);
3369 /* Count only the option arguments in separate argv elements. */
3370 n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
3372 if (i + n_args >= argc)
3373 fatal ("argument to `-%s' is missing", p);
3374 switches[n_switches].args
3375 = (char **) xmalloc ((n_args + 1) * sizeof (char *));
3377 switches[n_switches].args[j++] = argv[++i];
3378 /* Null-terminate the vector. */
3379 switches[n_switches].args[j] = 0;
3381 else if (index (switches_need_spaces, c))
3383 /* On some systems, ld cannot handle some options without
3384 a space. So split the option from its argument. */
3385 char *part1 = (char *) xmalloc (2);
3389 switches[n_switches].part1 = part1;
3390 switches[n_switches].args = (char **) xmalloc (2 * sizeof (char *));
3391 switches[n_switches].args[0] = xmalloc (strlen (p));
3392 strcpy (switches[n_switches].args[0], &p[1]);
3393 switches[n_switches].args[1] = 0;
3396 switches[n_switches].args = 0;
3398 switches[n_switches].live_cond = 0;
3399 switches[n_switches].validated = 0;
3400 /* This is always valid, since gcc.c itself understands it. */
3401 if (!strcmp (p, "save-temps"))
3402 switches[n_switches].validated = 1;
3405 char ch = switches[n_switches].part1[0];
3406 if (ch == 'V' || ch == 'b' || ch == 'B')
3407 switches[n_switches].validated = 1;
3413 #ifdef HAVE_OBJECT_SUFFIX
3414 argv[i] = convert_filename (argv[i], 0);
3417 if (strcmp (argv[i], "-") != 0 && access (argv[i], R_OK) < 0)
3419 perror_with_name (argv[i]);
3424 infiles[n_infiles].language = spec_lang;
3425 infiles[n_infiles++].name = argv[i];
3430 if (n_infiles == last_language_n_infiles && spec_lang != 0)
3431 error ("Warning: `-x %s' after last input file has no effect", spec_lang);
3433 switches[n_switches].part1 = 0;
3434 infiles[n_infiles].name = 0;
3437 /* Process a spec string, accumulating and running commands. */
3439 /* These variables describe the input file name.
3440 input_file_number is the index on outfiles of this file,
3441 so that the output file name can be stored for later use by %o.
3442 input_basename is the start of the part of the input file
3443 sans all directory names, and basename_length is the number
3444 of characters starting there excluding the suffix .c or whatever. */
3446 const char *input_filename;
3447 static int input_file_number;
3448 size_t input_filename_length;
3449 static int basename_length;
3450 static const char *input_basename;
3451 static const char *input_suffix;
3453 /* These are variables used within do_spec and do_spec_1. */
3455 /* Nonzero if an arg has been started and not yet terminated
3456 (with space, tab or newline). */
3457 static int arg_going;
3459 /* Nonzero means %d or %g has been seen; the next arg to be terminated
3460 is a temporary file name. */
3461 static int delete_this_arg;
3463 /* Nonzero means %w has been seen; the next arg to be terminated
3464 is the output file name of this compilation. */
3465 static int this_is_output_file;
3467 /* Nonzero means %s has been seen; the next arg to be terminated
3468 is the name of a library file and we should try the standard
3469 search dirs for it. */
3470 static int this_is_library_file;
3472 /* Nonzero means that the input of this command is coming from a pipe. */
3473 static int input_from_pipe;
3475 /* Process the spec SPEC and run the commands specified therein.
3476 Returns 0 if the spec is successfully processed; -1 if failed. */
3486 delete_this_arg = 0;
3487 this_is_output_file = 0;
3488 this_is_library_file = 0;
3489 input_from_pipe = 0;
3491 value = do_spec_1 (spec, 0, NULL_PTR);
3493 /* Force out any unfinished command.
3494 If -pipe, this forces out the last command if it ended in `|'. */
3497 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
3500 if (argbuf_index > 0)
3507 /* Process the sub-spec SPEC as a portion of a larger spec.
3508 This is like processing a whole spec except that we do
3509 not initialize at the beginning and we do not supply a
3510 newline by default at the end.
3511 INSWITCH nonzero means don't process %-sequences in SPEC;
3512 in this case, % is treated as an ordinary character.
3513 This is used while substituting switches.
3514 INSWITCH nonzero also causes SPC not to terminate an argument.
3516 Value is zero unless a line was finished
3517 and the command on that line reported an error. */
3520 do_spec_1 (spec, inswitch, soft_matched_part)
3523 const char *soft_matched_part;
3525 register const char *p = spec;
3532 /* If substituting a switch, treat all chars like letters.
3533 Otherwise, NL, SPC, TAB and % are special. */
3534 switch (inswitch ? 'a' : c)
3537 /* End of line: finish any pending argument,
3538 then run the pending command if one has been started. */
3541 obstack_1grow (&obstack, 0);
3542 string = obstack_finish (&obstack);
3543 if (this_is_library_file)
3544 string = find_file (string);
3545 store_arg (string, delete_this_arg, this_is_output_file);
3546 if (this_is_output_file)
3547 outfiles[input_file_number] = string;
3551 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
3553 for (i = 0; i < n_switches; i++)
3554 if (!strcmp (switches[i].part1, "pipe"))
3557 /* A `|' before the newline means use a pipe here,
3558 but only if -pipe was specified.
3559 Otherwise, execute now and don't pass the `|' as an arg. */
3562 input_from_pipe = 1;
3563 switches[i].validated = 1;
3570 if (argbuf_index > 0)
3576 /* Reinitialize for a new command, and for a new argument. */
3579 delete_this_arg = 0;
3580 this_is_output_file = 0;
3581 this_is_library_file = 0;
3582 input_from_pipe = 0;
3586 /* End any pending argument. */
3589 obstack_1grow (&obstack, 0);
3590 string = obstack_finish (&obstack);
3591 if (this_is_library_file)
3592 string = find_file (string);
3593 store_arg (string, delete_this_arg, this_is_output_file);
3594 if (this_is_output_file)
3595 outfiles[input_file_number] = string;
3599 obstack_1grow (&obstack, c);
3605 /* Space or tab ends an argument if one is pending. */
3608 obstack_1grow (&obstack, 0);
3609 string = obstack_finish (&obstack);
3610 if (this_is_library_file)
3611 string = find_file (string);
3612 store_arg (string, delete_this_arg, this_is_output_file);
3613 if (this_is_output_file)
3614 outfiles[input_file_number] = string;
3616 /* Reinitialize for a new argument. */
3618 delete_this_arg = 0;
3619 this_is_output_file = 0;
3620 this_is_library_file = 0;
3627 fatal ("Invalid specification! Bug in cc.");
3630 obstack_grow (&obstack, input_basename, basename_length);
3635 delete_this_arg = 2;
3638 /* Dump out the directories specified with LIBRARY_PATH,
3639 followed by the absolute directories
3640 that we search for startfiles. */
3643 struct prefix_list *pl = startfile_prefixes.plist;
3644 size_t bufsize = 100;
3645 char *buffer = (char *) xmalloc (bufsize);
3648 for (; pl; pl = pl->next)
3650 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
3651 /* Used on systems which record the specified -L dirs
3652 and use them to search for dynamic linking. */
3653 /* Relative directories always come from -B,
3654 and it is better not to use them for searching
3655 at run time. In particular, stage1 loses */
3656 if (!IS_DIR_SEPARATOR (pl->prefix[0]))
3659 /* Try subdirectory if there is one. */
3660 if (multilib_dir != NULL)
3664 if (strlen (pl->prefix) + strlen (machine_suffix)
3666 bufsize = (strlen (pl->prefix)
3667 + strlen (machine_suffix)) * 2 + 1;
3668 buffer = (char *) xrealloc (buffer, bufsize);
3669 strcpy (buffer, pl->prefix);
3670 strcat (buffer, machine_suffix);
3671 if (is_directory (buffer, multilib_dir, 1))
3673 do_spec_1 ("-L", 0, NULL_PTR);
3674 #ifdef SPACE_AFTER_L_OPTION
3675 do_spec_1 (" ", 0, NULL_PTR);
3677 do_spec_1 (buffer, 1, NULL_PTR);
3678 do_spec_1 (multilib_dir, 1, NULL_PTR);
3679 /* Make this a separate argument. */
3680 do_spec_1 (" ", 0, NULL_PTR);
3683 if (!pl->require_machine_suffix)
3685 if (is_directory (pl->prefix, multilib_dir, 1))
3687 do_spec_1 ("-L", 0, NULL_PTR);
3688 #ifdef SPACE_AFTER_L_OPTION
3689 do_spec_1 (" ", 0, NULL_PTR);
3691 do_spec_1 (pl->prefix, 1, NULL_PTR);
3692 do_spec_1 (multilib_dir, 1, NULL_PTR);
3693 /* Make this a separate argument. */
3694 do_spec_1 (" ", 0, NULL_PTR);
3700 if (is_directory (pl->prefix, machine_suffix, 1))
3702 do_spec_1 ("-L", 0, NULL_PTR);
3703 #ifdef SPACE_AFTER_L_OPTION
3704 do_spec_1 (" ", 0, NULL_PTR);
3706 do_spec_1 (pl->prefix, 1, NULL_PTR);
3707 /* Remove slash from machine_suffix. */
3708 if (strlen (machine_suffix) >= bufsize)
3709 bufsize = strlen (machine_suffix) * 2 + 1;
3710 buffer = (char *) xrealloc (buffer, bufsize);
3711 strcpy (buffer, machine_suffix);
3712 idx = strlen (buffer);
3713 if (IS_DIR_SEPARATOR (buffer[idx - 1]))
3714 buffer[idx - 1] = 0;
3715 do_spec_1 (buffer, 1, NULL_PTR);
3716 /* Make this a separate argument. */
3717 do_spec_1 (" ", 0, NULL_PTR);
3720 if (!pl->require_machine_suffix)
3722 if (is_directory (pl->prefix, "", 1))
3724 do_spec_1 ("-L", 0, NULL_PTR);
3725 #ifdef SPACE_AFTER_L_OPTION
3726 do_spec_1 (" ", 0, NULL_PTR);
3728 /* Remove slash from pl->prefix. */
3729 if (strlen (pl->prefix) >= bufsize)
3730 bufsize = strlen (pl->prefix) * 2 + 1;
3731 buffer = (char *) xrealloc (buffer, bufsize);
3732 strcpy (buffer, pl->prefix);
3733 idx = strlen (buffer);
3734 if (IS_DIR_SEPARATOR (buffer[idx - 1]))
3735 buffer[idx - 1] = 0;
3736 do_spec_1 (buffer, 1, NULL_PTR);
3737 /* Make this a separate argument. */
3738 do_spec_1 (" ", 0, NULL_PTR);
3747 /* %efoo means report an error with `foo' as error message
3748 and don't execute any more commands for this file. */
3752 while (*p != 0 && *p != '\n') p++;
3753 buf = (char *) alloca (p - q + 1);
3754 strncpy (buf, q, p - q);
3764 if (save_temps_flag)
3766 obstack_grow (&obstack, input_basename, basename_length);
3767 delete_this_arg = 0;
3771 #ifdef MKTEMP_EACH_FILE
3772 /* ??? This has a problem: the total number of
3773 values mktemp can return is limited.
3774 That matters for the names of object files.
3775 In 2.4, do something about that. */
3776 struct temp_name *t;
3778 const char *suffix = p;
3780 if (p[0] == '%' && p[1] == 'O')
3783 /* We don't support extra suffix characters after %O. */
3784 if (*p == '.' || ISALPHA ((unsigned char)*p))
3786 suffix = OBJECT_SUFFIX;
3787 suffix_length = strlen (OBJECT_SUFFIX);
3791 while (*p == '.' || ISALPHA ((unsigned char)*p))
3793 suffix_length = p - suffix;
3796 /* See if we already have an association of %g/%u/%U and
3798 for (t = temp_names; t; t = t->next)
3799 if (t->length == suffix_length
3800 && strncmp (t->suffix, suffix, suffix_length) == 0
3801 && t->unique == (c != 'g'))
3804 /* Make a new association if needed. %u requires one. */
3805 if (t == 0 || c == 'u')
3809 t = (struct temp_name *) xmalloc (sizeof (struct temp_name));
3810 t->next = temp_names;
3813 t->length = suffix_length;
3814 t->suffix = save_string (suffix, suffix_length);
3815 t->unique = (c != 'g');
3816 temp_filename = make_temp_file (t->suffix);
3817 temp_filename_length = strlen (temp_filename);
3818 t->filename = temp_filename;
3819 t->filename_length = temp_filename_length;
3822 obstack_grow (&obstack, t->filename, t->filename_length);
3823 delete_this_arg = 1;
3825 obstack_grow (&obstack, temp_filename, temp_filename_length);
3826 if (c == 'u' || c == 'U')
3832 sprintf (buff, "%d", unique);
3833 obstack_grow (&obstack, buff, strlen (buff));
3836 delete_this_arg = 1;
3842 obstack_grow (&obstack, input_filename, input_filename_length);
3848 struct prefix_list *pl = include_prefixes.plist;
3850 if (gcc_exec_prefix)
3852 do_spec_1 ("-iprefix", 1, NULL_PTR);
3853 /* Make this a separate argument. */
3854 do_spec_1 (" ", 0, NULL_PTR);
3855 do_spec_1 (gcc_exec_prefix, 1, NULL_PTR);
3856 do_spec_1 (" ", 0, NULL_PTR);
3859 for (; pl; pl = pl->next)
3861 do_spec_1 ("-isystem", 1, NULL_PTR);
3862 /* Make this a separate argument. */
3863 do_spec_1 (" ", 0, NULL_PTR);
3864 do_spec_1 (pl->prefix, 1, NULL_PTR);
3865 do_spec_1 (" ", 0, NULL_PTR);
3872 int max = n_infiles;
3873 max += lang_specific_extra_outfiles;
3875 for (i = 0; i < max; i++)
3877 store_arg (outfiles[i], 0, 0);
3882 obstack_grow (&obstack, OBJECT_SUFFIX, strlen (OBJECT_SUFFIX));
3887 this_is_library_file = 1;
3891 this_is_output_file = 1;
3896 int cur_index = argbuf_index;
3897 /* Handle the {...} following the %W. */
3900 p = handle_braces (p + 1);
3903 /* If any args were output, mark the last one for deletion
3905 if (argbuf_index != cur_index)
3906 record_temp_file (argbuf[argbuf_index - 1], 0, 1);
3910 /* %x{OPTION} records OPTION for %X to output. */
3916 /* Skip past the option value and make a copy. */
3921 string = save_string (p1 + 1, p - p1 - 2);
3923 /* See if we already recorded this option. */
3924 for (i = 0; i < n_linker_options; i++)
3925 if (! strcmp (string, linker_options[i]))
3931 /* This option is new; add it. */
3932 add_linker_option (string, strlen (string));
3936 /* Dump out the options accumulated previously using %x. */
3938 for (i = 0; i < n_linker_options; i++)
3940 do_spec_1 (linker_options[i], 1, NULL_PTR);
3941 /* Make each accumulated option a separate argument. */
3942 do_spec_1 (" ", 0, NULL_PTR);
3946 /* Dump out the options accumulated previously using -Wa,. */
3948 for (i = 0; i < n_assembler_options; i++)
3950 do_spec_1 (assembler_options[i], 1, NULL_PTR);
3951 /* Make each accumulated option a separate argument. */
3952 do_spec_1 (" ", 0, NULL_PTR);
3956 /* Dump out the options accumulated previously using -Wp,. */
3958 for (i = 0; i < n_preprocessor_options; i++)
3960 do_spec_1 (preprocessor_options[i], 1, NULL_PTR);
3961 /* Make each accumulated option a separate argument. */
3962 do_spec_1 (" ", 0, NULL_PTR);
3966 /* Here are digits and numbers that just process
3967 a certain constant string as a spec. */
3970 value = do_spec_1 (cc1_spec, 0, NULL_PTR);
3976 value = do_spec_1 (cc1plus_spec, 0, NULL_PTR);
3982 value = do_spec_1 (asm_spec, 0, NULL_PTR);
3988 value = do_spec_1 (asm_final_spec, 0, NULL_PTR);
3994 value = do_spec_1 (signed_char_spec, 0, NULL_PTR);
4000 value = do_spec_1 (cpp_spec, 0, NULL_PTR);
4006 value = do_spec_1 (endfile_spec, 0, NULL_PTR);
4012 value = do_spec_1 (link_spec, 0, NULL_PTR);
4018 value = do_spec_1 (lib_spec, 0, NULL_PTR);
4024 value = do_spec_1 (libgcc_spec, 0, NULL_PTR);
4031 char *x = (char *) alloca (strlen (cpp_predefines) + 1);
4035 /* Copy all of the -D options in CPP_PREDEFINES into BUF. */
4039 if (! strncmp (y, "-D", 2))
4040 /* Copy the whole option. */
4041 while (*y && *y != ' ' && *y != '\t')
4043 else if (*y == ' ' || *y == '\t')
4044 /* Copy whitespace to the result. */
4046 /* Don't copy other options. */
4053 value = do_spec_1 (buf, 0, NULL_PTR);
4061 char *x = (char *) alloca (strlen (cpp_predefines) * 4 + 1);
4065 /* Copy all of CPP_PREDEFINES into BUF,
4066 but put __ after every -D and at the end of each arg. */
4070 if (! strncmp (y, "-D", 2))
4079 && ! ISUPPER ((unsigned char)*(y+1))))
4081 /* Stick __ at front of macro name. */
4084 /* Arrange to stick __ at the end as well. */
4088 /* Copy the macro name. */
4089 while (*y && *y != '=' && *y != ' ' && *y != '\t')
4098 /* Copy the value given, if any. */
4099 while (*y && *y != ' ' && *y != '\t')
4102 else if (*y == ' ' || *y == '\t')
4103 /* Copy whitespace to the result. */
4105 /* Don't copy -A options */
4111 /* Copy all of CPP_PREDEFINES into BUF,
4112 but put __ after every -D. */
4116 if (! strncmp (y, "-D", 2))
4122 && ! ISUPPER ((unsigned char)*(y+1))))
4124 /* Stick -D__ at front of macro name. */
4130 /* Copy the macro name. */
4131 while (*y && *y != '=' && *y != ' ' && *y != '\t')
4134 /* Copy the value given, if any. */
4135 while (*y && *y != ' ' && *y != '\t')
4140 /* Do not copy this macro - we have just done it before */
4141 while (*y && *y != ' ' && *y != '\t')
4145 else if (*y == ' ' || *y == '\t')
4146 /* Copy whitespace to the result. */
4148 /* Don't copy -A options */
4154 /* Copy all of the -A options in CPP_PREDEFINES into BUF. */
4158 if (! strncmp (y, "-A", 2))
4159 /* Copy the whole option. */
4160 while (*y && *y != ' ' && *y != '\t')
4162 else if (*y == ' ' || *y == '\t')
4163 /* Copy whitespace to the result. */
4165 /* Don't copy other options. */
4172 value = do_spec_1 (buf, 0, NULL_PTR);
4179 value = do_spec_1 (startfile_spec, 0, NULL_PTR);
4184 /* Here we define characters other than letters and digits. */
4187 p = handle_braces (p);
4193 obstack_1grow (&obstack, '%');
4197 do_spec_1 (soft_matched_part, 1, NULL_PTR);
4198 do_spec_1 (" ", 0, NULL_PTR);
4201 /* Process a string found as the value of a spec given by name.
4202 This feature allows individual machine descriptions
4203 to add and use their own specs.
4204 %[...] modifies -D options the way %P does;
4205 %(...) uses the spec unmodified. */
4207 error ("Warning: use of obsolete %%[ operator in specs");
4210 const char *name = p;
4211 struct spec_list *sl;
4214 /* The string after the S/P is the name of a spec that is to be
4216 while (*p && *p != ')' && *p != ']')
4219 /* See if it's in the list */
4220 for (len = p - name, sl = specs; sl; sl = sl->next)
4221 if (sl->name_len == len && !strncmp (sl->name, name, len))
4223 name = *(sl->ptr_spec);
4225 notice ("Processing spec %c%s%c, which is '%s'\n",
4226 c, sl->name, (c == '(') ? ')' : ']', name);
4235 value = do_spec_1 (name, 0, NULL_PTR);
4241 char *x = (char *) alloca (strlen (name) * 2 + 1);
4243 const char *y = name;
4246 /* Copy all of NAME into BUF, but put __ after
4247 every -D and at the end of each arg, */
4250 if (! strncmp (y, "-D", 2))
4260 else if (flag && (*y == ' ' || *y == '\t' || *y == '='
4261 || *y == '}' || *y == 0))
4274 value = do_spec_1 (buf, 0, NULL_PTR);
4280 /* Discard the closing paren or bracket. */
4288 int c1 = *p++; /* Select first or second version number. */
4289 char *v = compiler_version;
4292 /* The format of the version string is
4293 ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)? */
4295 /* Ignore leading non-digits. i.e. "foo-" in "foo-2.7.2". */
4296 while (! ISDIGIT (*v))
4298 if (v > compiler_version && v[-1] != '-')
4301 /* If desired, advance to second version number. */
4304 /* Set V after the first period. */
4305 while (ISDIGIT (*v))
4312 /* Set Q at the next period or at the end. */
4314 while (ISDIGIT (*q))
4316 if (*q != 0 && *q != ' ' && *q != '.' && *q != '-')
4319 /* Put that part into the command. */
4320 obstack_grow (&obstack, v, q - v);
4326 if (input_from_pipe)
4327 do_spec_1 ("-", 0, NULL_PTR);
4336 /* Backslash: treat next character as ordinary. */
4341 /* Ordinary character: put it into the current argument. */
4342 obstack_1grow (&obstack, c);
4346 return 0; /* End of string */
4349 /* Return 0 if we call do_spec_1 and that returns -1. */
4353 register const char *p;
4355 const char *filter, *body = NULL, *endbody = NULL;
4359 int include_blanks = 1;
4362 /* A '^' after the open-brace means to not give blanks before args. */
4363 include_blanks = 0, ++p;
4366 /* A `|' after the open-brace means,
4367 if the test fails, output a single minus sign rather than nothing.
4368 This is used in %{|!pipe:...}. */
4372 negate = suffix = 0;
4375 /* A `!' after the open-brace negates the condition:
4376 succeed if the specified switch is not present. */
4380 /* A `.' after the open-brace means test against the current suffix. */
4390 while (*p != ':' && *p != '}' && *p != '|') p++;
4392 if (*p == '|' && pipe_p)
4399 register int count = 1;
4400 register const char *q = p;
4402 while (*q++ != ':') continue;
4418 body = p, endbody = p+1;
4423 int found = (input_suffix != 0
4424 && (long) strlen (input_suffix) == (long)(p - filter)
4425 && strncmp (input_suffix, filter, p - filter) == 0);
4431 && do_spec_1 (save_string (body, endbody-body-1), 0, NULL_PTR) < 0)
4434 else if (p[-1] == '*' && p[0] == '}')
4436 /* Substitute all matching switches as separate args. */
4439 for (i = 0; i < n_switches; i++)
4440 if (!strncmp (switches[i].part1, filter, p - filter)
4441 && check_live_switch (i, p - filter))
4442 give_switch (i, 0, include_blanks);
4446 /* Test for presence of the specified switch. */
4450 /* If name specified ends in *, as in {x*:...},
4451 check for %* and handle that case. */
4452 if (p[-1] == '*' && !negate)
4455 const char *r = body;
4457 /* First see whether we have %*. */
4461 if (*r == '%' && r[1] == '*')
4465 /* If we do, handle that case. */
4468 /* Substitute all matching switches as separate args.
4469 But do this by substituting for %*
4470 in the text that follows the colon. */
4472 unsigned hard_match_len = p - filter - 1;
4473 char *string = save_string (body, endbody - body - 1);
4475 for (i = 0; i < n_switches; i++)
4476 if (!strncmp (switches[i].part1, filter, hard_match_len)
4477 && check_live_switch (i, -1))
4479 do_spec_1 (string, 0, &switches[i].part1[hard_match_len]);
4480 /* Pass any arguments this switch has. */
4481 give_switch (i, 1, 1);
4484 /* We didn't match. Try again. */
4491 /* If name specified ends in *, as in {x*:...},
4492 check for presence of any switch name starting with x. */
4495 for (i = 0; i < n_switches; i++)
4497 unsigned hard_match_len = p - filter - 1;
4499 if (!strncmp (switches[i].part1, filter, hard_match_len)
4500 && check_live_switch (i, hard_match_len))
4506 /* Otherwise, check for presence of exact name specified. */
4509 for (i = 0; i < n_switches; i++)
4511 if (!strncmp (switches[i].part1, filter, p - filter)
4512 && switches[i].part1[p - filter] == 0
4513 && check_live_switch (i, -1))
4521 /* If it is as desired (present for %{s...}, absent for %{!s...})
4522 then substitute either the switch or the specified
4523 conditional text. */
4524 if (present != negate)
4528 give_switch (i, 0, include_blanks);
4532 if (do_spec_1 (save_string (body, endbody - body - 1),
4539 /* Here if a %{|...} conditional fails: output a minus sign,
4540 which means "standard output" or "standard input". */
4541 do_spec_1 ("-", 0, NULL_PTR);
4546 /* We didn't match; try again. */
4553 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
4554 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
4555 spec, or -1 if either exact match or %* is used.
4557 A -O switch is obsoleted by a later -O switch. A -f, -m, or -W switch
4558 whose value does not begin with "no-" is obsoleted by the same value
4559 with the "no-", similarly for a switch with the "no-" prefix. */
4562 check_live_switch (switchnum, prefix_length)
4566 const char *name = switches[switchnum].part1;
4569 /* In the common case of {<at-most-one-letter>*}, a negating
4570 switch would always match, so ignore that case. We will just
4571 send the conflicting switches to the compiler phase. */
4572 if (prefix_length >= 0 && prefix_length <= 1)
4575 /* If we already processed this switch and determined if it was
4576 live or not, return our past determination. */
4577 if (switches[switchnum].live_cond != 0)
4578 return switches[switchnum].live_cond > 0;
4580 /* Now search for duplicate in a manner that depends on the name. */
4584 for (i = switchnum + 1; i < n_switches; i++)
4585 if (switches[i].part1[0] == 'O')
4587 switches[switchnum].validated = 1;
4588 switches[switchnum].live_cond = -1;
4593 case 'W': case 'f': case 'm':
4594 if (! strncmp (name + 1, "no-", 3))
4596 /* We have Xno-YYY, search for XYYY. */
4597 for (i = switchnum + 1; i < n_switches; i++)
4598 if (switches[i].part1[0] == name[0]
4599 && ! strcmp (&switches[i].part1[1], &name[4]))
4601 switches[switchnum].validated = 1;
4602 switches[switchnum].live_cond = -1;
4608 /* We have XYYY, search for Xno-YYY. */
4609 for (i = switchnum + 1; i < n_switches; i++)
4610 if (switches[i].part1[0] == name[0]
4611 && switches[i].part1[1] == 'n'
4612 && switches[i].part1[2] == 'o'
4613 && switches[i].part1[3] == '-'
4614 && !strcmp (&switches[i].part1[4], &name[1]))
4616 switches[switchnum].validated = 1;
4617 switches[switchnum].live_cond = -1;
4624 /* Otherwise the switch is live. */
4625 switches[switchnum].live_cond = 1;
4629 /* Pass a switch to the current accumulating command
4630 in the same form that we received it.
4631 SWITCHNUM identifies the switch; it is an index into
4632 the vector of switches gcc received, which is `switches'.
4633 This cannot fail since it never finishes a command line.
4635 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument.
4637 If INCLUDE_BLANKS is nonzero, then we include blanks before each argument
4641 give_switch (switchnum, omit_first_word, include_blanks)
4643 int omit_first_word;
4646 if (!omit_first_word)
4648 do_spec_1 ("-", 0, NULL_PTR);
4649 do_spec_1 (switches[switchnum].part1, 1, NULL_PTR);
4652 if (switches[switchnum].args != 0)
4655 for (p = switches[switchnum].args; *p; p++)
4658 do_spec_1 (" ", 0, NULL_PTR);
4659 do_spec_1 (*p, 1, NULL_PTR);
4663 do_spec_1 (" ", 0, NULL_PTR);
4664 switches[switchnum].validated = 1;
4667 /* Search for a file named NAME trying various prefixes including the
4668 user's -B prefix and some standard ones.
4669 Return the absolute file name found. If nothing is found, return NAME. */
4677 /* Try multilib_dir if it is defined. */
4678 if (multilib_dir != NULL)
4682 try = (char *) alloca (strlen (multilib_dir) + strlen (name) + 2);
4683 strcpy (try, multilib_dir);
4684 strcat (try, dir_separator_str);
4687 newname = find_a_file (&startfile_prefixes, try, R_OK);
4689 /* If we don't find it in the multi library dir, then fall
4690 through and look for it in the normal places. */
4691 if (newname != NULL)
4695 newname = find_a_file (&startfile_prefixes, name, R_OK);
4696 return newname ? newname : name;
4699 /* Determine whether a directory exists. If LINKER, return 0 for
4700 certain fixed names not needed by the linker. If not LINKER, it is
4701 only important to return 0 if the host machine has a small ARG_MAX
4705 is_directory (path1, path2, linker)
4710 int len1 = strlen (path1);
4711 int len2 = strlen (path2);
4712 char *path = (char *) alloca (3 + len1 + len2);
4716 #ifndef SMALL_ARG_MAX
4721 /* Construct the path from the two parts. Ensure the string ends with "/.".
4722 The resulting path will be a directory even if the given path is a
4724 memcpy (path, path1, len1);
4725 memcpy (path + len1, path2, len2);
4726 cp = path + len1 + len2;
4727 if (!IS_DIR_SEPARATOR (cp[-1]))
4728 *cp++ = DIR_SEPARATOR;
4732 #ifndef FREEBSD_NATIVE
4733 /* Exclude directories that the linker is known to search. */
4736 && strcmp (path, concat (dir_separator_str, "lib",
4737 dir_separator_str, ".", NULL_PTR)) == 0)
4739 && strcmp (path, concat (dir_separator_str, "usr",
4740 dir_separator_str, "lib",
4741 dir_separator_str, ".", NULL_PTR)) == 0)))
4743 #endif /* not FREEBSD_NATIVE */
4745 return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
4748 /* On fatal signals, delete all the temporary files. */
4751 fatal_error (signum)
4754 signal (signum, SIG_DFL);
4755 delete_failure_queue ();
4756 delete_temp_files ();
4757 /* Get the same signal again, this time not handled,
4758 so its normal effect occurs. */
4759 kill (getpid (), signum);
4770 int linker_was_run = 0;
4771 char *explicit_link_files;
4774 struct user_specs *uptr;
4776 p = argv[0] + strlen (argv[0]);
4777 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
4781 #ifdef HAVE_LC_MESSAGES
4782 setlocale (LC_MESSAGES, "");
4784 (void) bindtextdomain (PACKAGE, localedir);
4785 (void) textdomain (PACKAGE);
4787 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
4788 signal (SIGINT, fatal_error);
4790 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
4791 signal (SIGHUP, fatal_error);
4793 if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
4794 signal (SIGTERM, fatal_error);
4796 if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
4797 signal (SIGPIPE, fatal_error);
4801 argbuf = (char **) xmalloc (argbuf_length * sizeof (char *));
4803 obstack_init (&obstack);
4805 /* Build multilib_select, et. al from the separate lines that make up each
4806 multilib selection. */
4808 char **q = multilib_raw;
4811 obstack_init (&multilib_obstack);
4812 while ((p = *q++) != (char *) 0)
4813 obstack_grow (&multilib_obstack, p, strlen (p));
4815 obstack_1grow (&multilib_obstack, 0);
4816 multilib_select = obstack_finish (&multilib_obstack);
4818 q = multilib_matches_raw;
4819 while ((p = *q++) != (char *) 0)
4820 obstack_grow (&multilib_obstack, p, strlen (p));
4822 obstack_1grow (&multilib_obstack, 0);
4823 multilib_matches = obstack_finish (&multilib_obstack);
4827 i < sizeof (multilib_defaults_raw) / sizeof (multilib_defaults_raw[0]);
4831 obstack_1grow (&multilib_obstack, ' ');
4832 obstack_grow (&multilib_obstack,
4833 multilib_defaults_raw[i],
4834 strlen (multilib_defaults_raw[i]));
4838 obstack_1grow (&multilib_obstack, 0);
4839 multilib_defaults = obstack_finish (&multilib_obstack);
4842 /* Set up to remember the pathname of gcc and any options
4843 needed for collect. We use argv[0] instead of programname because
4844 we need the complete pathname. */
4845 obstack_init (&collect_obstack);
4846 obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=")-1);
4847 obstack_grow (&collect_obstack, argv[0], strlen (argv[0])+1);
4848 putenv (obstack_finish (&collect_obstack));
4850 #ifdef INIT_ENVIRONMENT
4851 /* Set up any other necessary machine specific environment variables. */
4852 putenv (INIT_ENVIRONMENT);
4855 /* Choose directory for temp files. */
4857 #ifndef MKTEMP_EACH_FILE
4858 temp_filename = choose_temp_base ();
4859 temp_filename_length = strlen (temp_filename);
4862 /* Make a table of what switches there are (switches, n_switches).
4863 Make a table of specified input files (infiles, n_infiles).
4864 Decode switches that are handled locally. */
4866 process_command (argc, argv);
4871 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4873 obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
4874 sizeof ("COLLECT_GCC_OPTIONS=")-1);
4877 for (i = 0; (int)i < n_switches; i++)
4882 obstack_grow (&collect_obstack, " ", 1);
4885 obstack_grow (&collect_obstack, "'-", 2);
4886 q = switches[i].part1;
4887 while ((p = index (q,'\'')))
4889 obstack_grow (&collect_obstack, q, p-q);
4890 obstack_grow (&collect_obstack, "'\\''", 4);
4893 obstack_grow (&collect_obstack, q, strlen (q));
4894 obstack_grow (&collect_obstack, "'", 1);
4896 for (args = switches[i].args; args && *args; args++)
4898 obstack_grow (&collect_obstack, " '", 2);
4900 while ((p = index (q,'\'')))
4902 obstack_grow (&collect_obstack, q, p-q);
4903 obstack_grow (&collect_obstack, "'\\''", 4);
4906 obstack_grow (&collect_obstack, q, strlen (q));
4907 obstack_grow (&collect_obstack, "'", 1);
4910 obstack_grow (&collect_obstack, "\0", 1);
4911 putenv (obstack_finish (&collect_obstack));
4914 /* Initialize the vector of specs to just the default.
4915 This means one element containing 0s, as a terminator. */
4917 compilers = (struct compiler *) xmalloc (sizeof default_compilers);
4918 bcopy ((char *) default_compilers, (char *) compilers,
4919 sizeof default_compilers);
4920 n_compilers = n_default_compilers;
4922 /* Read specs from a file if there is one. */
4924 #ifdef FREEBSD_NATIVE
4925 just_machine_suffix = ""; /* I don't support specs, gives determinism */
4926 #else /* FREEBSD_NATIVE */
4927 machine_suffix = concat (spec_machine, dir_separator_str,
4928 spec_version, dir_separator_str, NULL_PTR);
4929 just_machine_suffix = concat (spec_machine, dir_separator_str, NULL_PTR);
4930 #endif /* FREEBSD_NATIVE */
4932 specs_file = find_a_file (&startfile_prefixes, "specs", R_OK);
4933 /* Read the specs file unless it is a default one. */
4934 if (specs_file != 0 && strcmp (specs_file, "specs"))
4935 read_specs (specs_file, TRUE);
4939 /* We need to check standard_exec_prefix/just_machine_suffix/specs
4940 for any override of as, ld and libraries. */
4941 specs_file = (char *) alloca (strlen (standard_exec_prefix)
4942 + strlen (just_machine_suffix)
4943 + sizeof ("specs"));
4945 strcpy (specs_file, standard_exec_prefix);
4946 strcat (specs_file, just_machine_suffix);
4947 strcat (specs_file, "specs");
4948 if (access (specs_file, R_OK) == 0)
4949 read_specs (specs_file, TRUE);
4951 /* If not cross-compiling, look for startfiles in the standard places. */
4952 if (*cross_compile == '0')
4954 #ifdef MD_EXEC_PREFIX
4955 add_prefix (&exec_prefixes, md_exec_prefix, "GCC", 0, 0, NULL_PTR);
4956 add_prefix (&startfile_prefixes, md_exec_prefix, "GCC", 0, 0, NULL_PTR);
4959 #ifdef MD_STARTFILE_PREFIX
4960 add_prefix (&startfile_prefixes, md_startfile_prefix, "GCC",
4964 #ifdef MD_STARTFILE_PREFIX_1
4965 add_prefix (&startfile_prefixes, md_startfile_prefix_1, "GCC",
4969 /* If standard_startfile_prefix is relative, base it on
4970 standard_exec_prefix. This lets us move the installed tree
4971 as a unit. If GCC_EXEC_PREFIX is defined, base
4972 standard_startfile_prefix on that as well. */
4973 if (IS_DIR_SEPARATOR (*standard_startfile_prefix)
4974 || *standard_startfile_prefix == '$'
4975 #ifdef HAVE_DOS_BASED_FILESYSTEM
4976 /* Check for disk name on MS-DOS-based systems. */
4977 || (standard_startfile_prefix[1] == ':'
4978 && (IS_DIR_SEPARATOR (standard_startfile_prefix[2])))
4981 add_prefix (&startfile_prefixes, standard_startfile_prefix, "BINUTILS",
4985 if (gcc_exec_prefix)
4986 add_prefix (&startfile_prefixes,
4987 concat (gcc_exec_prefix, machine_suffix,
4988 standard_startfile_prefix, NULL_PTR),
4989 NULL_PTR, 0, 0, NULL_PTR);
4990 add_prefix (&startfile_prefixes,
4991 concat (standard_exec_prefix,
4993 standard_startfile_prefix, NULL_PTR),
4994 NULL_PTR, 0, 0, NULL_PTR);
4997 #ifndef FREEBSD_NATIVE
4998 add_prefix (&startfile_prefixes, standard_startfile_prefix_1,
4999 "BINUTILS", 0, 0, NULL_PTR);
5000 add_prefix (&startfile_prefixes, standard_startfile_prefix_2,
5001 "BINUTILS", 0, 0, NULL_PTR);
5002 #endif /* FREEBSD_NATIVE */
5003 #if 0 /* Can cause surprises, and one can use -B./ instead. */
5004 add_prefix (&startfile_prefixes, "./", NULL_PTR, 0, 1, NULL_PTR);
5009 if (!IS_DIR_SEPARATOR (*standard_startfile_prefix) && gcc_exec_prefix)
5010 add_prefix (&startfile_prefixes,
5011 concat (gcc_exec_prefix, machine_suffix,
5012 standard_startfile_prefix, NULL_PTR),
5013 "BINUTILS", 0, 0, NULL_PTR);
5014 #ifdef CROSS_STARTFILE_PREFIX
5015 add_prefix (&startfile_prefixes, CROSS_STARTFILE_PREFIX, "BINUTILS",
5020 /* Process any user specified specs in the order given on the command
5022 for (uptr = user_specs_head; uptr; uptr = uptr->next)
5024 char *filename = find_a_file (&startfile_prefixes, uptr->filename, R_OK);
5025 read_specs (filename ? filename : uptr->filename, FALSE);
5028 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
5029 if (gcc_exec_prefix)
5031 char * temp = (char *) xmalloc (strlen (gcc_exec_prefix)
5032 + strlen (spec_version)
5033 + strlen (spec_machine) + 3);
5034 strcpy (temp, gcc_exec_prefix);
5035 strcat (temp, spec_machine);
5036 strcat (temp, dir_separator_str);
5037 strcat (temp, spec_version);
5038 strcat (temp, dir_separator_str);
5039 gcc_exec_prefix = temp;
5042 /* Now we have the specs.
5043 Set the `valid' bits for switches that match anything in any spec. */
5045 validate_all_switches ();
5047 /* Now that we have the switches and the specs, set
5048 the subdirectory based on the options. */
5049 set_multilib_dir ();
5051 /* Warn about any switches that no pass was interested in. */
5053 for (i = 0; (int)i < n_switches; i++)
5054 if (! switches[i].validated)
5055 error ("unrecognized option `-%s'", switches[i].part1);
5057 /* Obey some of the options. */
5059 if (print_search_dirs)
5061 printf ("install: %s%s\n", standard_exec_prefix, machine_suffix);
5062 printf ("programs: %s\n", build_search_list (&exec_prefixes, "", 0));
5063 printf ("libraries: %s\n", build_search_list (&startfile_prefixes, "", 0));
5067 if (print_file_name)
5069 printf ("%s\n", find_file (print_file_name));
5073 if (print_prog_name)
5075 char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK);
5076 printf ("%s\n", (newname ? newname : print_prog_name));
5080 if (print_multi_lib)
5082 print_multilib_info ();
5086 if (print_multi_directory)
5088 if (multilib_dir == NULL)
5091 printf ("%s\n", multilib_dir);
5095 if (print_help_list)
5101 printf ("\nFor bug reporting instructions, please see:\n");
5102 printf ("%s.\n", GCCBUGURL);
5107 /* We do not exit here. Instead we have created a fake input file
5108 called 'help-dummy' which needs to be compiled, and we pass this
5109 on the the various sub-processes, along with the --help switch. */
5116 /* compiler_version is truncated at the first space when initialized
5117 from version string, so truncate version_string at the first space
5118 before comparing. */
5119 for (n = 0; version_string[n]; n++)
5120 if (version_string[n] == ' ')
5123 if (! strncmp (version_string, compiler_version, n)
5124 && compiler_version[n] == 0)
5125 notice ("gcc version %s\n", version_string);
5127 notice ("gcc driver version %s executing gcc version %s\n",
5128 version_string, compiler_version);
5134 if (n_infiles == added_libraries)
5135 fatal ("No input files specified");
5137 /* Make a place to record the compiler output file names
5138 that correspond to the input files. */
5141 i += lang_specific_extra_outfiles;
5142 outfiles = (const char **) xmalloc (i * sizeof (char *));
5143 bzero ((char *) outfiles, i * sizeof (char *));
5145 /* Record which files were specified explicitly as link input. */
5147 explicit_link_files = xmalloc (n_infiles);
5148 bzero (explicit_link_files, n_infiles);
5150 for (i = 0; (int)i < n_infiles; i++)
5152 register struct compiler *cp = 0;
5153 int this_file_error = 0;
5155 /* Tell do_spec what to substitute for %i. */
5157 input_filename = infiles[i].name;
5158 input_filename_length = strlen (input_filename);
5159 input_file_number = i;
5161 /* Use the same thing in %o, unless cp->spec says otherwise. */
5163 outfiles[i] = input_filename;
5165 /* Figure out which compiler from the file's suffix. */
5167 cp = lookup_compiler (infiles[i].name, input_filename_length,
5168 infiles[i].language);
5172 /* Ok, we found an applicable compiler. Run its spec. */
5173 /* First say how much of input_filename to substitute for %b */
5174 register const char *p;
5177 if (cp->spec[0][0] == '#')
5179 error ("%s: %s compiler not installed on this system",
5180 input_filename, &cp->spec[0][1]);
5181 this_file_error = 1;
5185 input_basename = input_filename;
5186 for (p = input_filename; *p; p++)
5187 if (IS_DIR_SEPARATOR (*p))
5188 input_basename = p + 1;
5190 /* Find a suffix starting with the last period,
5191 and set basename_length to exclude that suffix. */
5192 basename_length = strlen (input_basename);
5193 p = input_basename + basename_length;
5194 while (p != input_basename && *p != '.') --p;
5195 if (*p == '.' && p != input_basename)
5197 basename_length = p - input_basename;
5198 input_suffix = p + 1;
5204 for (j = 0; j < sizeof cp->spec / sizeof cp->spec[0]; j++)
5206 len += strlen (cp->spec[j]);
5209 char *p1 = (char *) xmalloc (len + 1);
5212 for (j = 0; j < sizeof cp->spec / sizeof cp->spec[0]; j++)
5215 strcpy (p1 + len, cp->spec[j]);
5216 len += strlen (cp->spec[j]);
5219 value = do_spec (p1);
5223 this_file_error = 1;
5227 /* If this file's name does not contain a recognized suffix,
5228 record it as explicit linker input. */
5231 explicit_link_files[i] = 1;
5233 /* Clear the delete-on-failure queue, deleting the files in it
5234 if this compilation failed. */
5236 if (this_file_error)
5238 delete_failure_queue ();
5241 /* If this compilation succeeded, don't delete those files later. */
5242 clear_failure_queue ();
5245 if (error_count == 0)
5247 /* Make sure INPUT_FILE_NUMBER points to first available open
5249 input_file_number = n_infiles;
5250 if (lang_specific_pre_link ())
5254 /* Run ld to link all the compiler output files. */
5256 if (error_count == 0)
5258 int tmp = execution_count;
5260 /* We'll use ld if we can't find collect2. */
5261 if (! strcmp (linker_name_spec, "collect2"))
5263 char *s = find_a_file (&exec_prefixes, "collect2", X_OK);
5265 linker_name_spec = "ld";
5267 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
5269 putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH=");
5270 putenv_from_prefixes (&startfile_prefixes, "LIBRARY_PATH=");
5272 value = do_spec (link_command_spec);
5275 linker_was_run = (tmp != execution_count);
5278 /* Warn if a -B option was specified but the prefix was never used. */
5279 unused_prefix_warnings (&exec_prefixes);
5280 unused_prefix_warnings (&startfile_prefixes);
5282 /* If options said don't run linker,
5283 complain about input files to be given to the linker. */
5285 if (! linker_was_run && error_count == 0)
5286 for (i = 0; (int)i < n_infiles; i++)
5287 if (explicit_link_files[i])
5288 error ("%s: linker input file unused since linking not done",
5291 /* Delete some or all of the temporary files we made. */
5294 delete_failure_queue ();
5295 delete_temp_files ();
5297 if (print_help_list)
5299 printf ("\nFor bug reporting instructions, please see:\n");
5300 printf ("%s\n", GCCBUGURL);
5303 exit (error_count > 0 ? (signal_count ? 2 : 1) : 0);
5308 /* Find the proper compilation spec for the file name NAME,
5309 whose length is LENGTH. LANGUAGE is the specified language,
5310 or 0 if this file is to be passed to the linker. */
5312 static struct compiler *
5313 lookup_compiler (name, length, language)
5316 const char *language;
5318 struct compiler *cp;
5320 /* If this was specified by the user to be a linker input, indicate that. */
5321 if (language != 0 && language[0] == '*')
5324 /* Otherwise, look for the language, if one is spec'd. */
5327 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
5328 if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
5331 error ("language %s not recognized", language);
5335 /* Look for a suffix. */
5336 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
5338 if (/* The suffix `-' matches only the file name `-'. */
5339 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
5340 || (strlen (cp->suffix) < length
5341 /* See if the suffix matches the end of NAME. */
5343 && ((!strcmp (cp->suffix,
5344 name + length - strlen (cp->suffix))
5345 || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
5346 && !strcasecmp (cp->suffix,
5347 name + length - strlen (cp->suffix)))
5349 && !strcmp (cp->suffix,
5350 name + length - strlen (cp->suffix))
5354 if (cp->spec[0][0] == '@')
5356 struct compiler *new;
5358 /* An alias entry maps a suffix to a language.
5359 Search for the language; pass 0 for NAME and LENGTH
5360 to avoid infinite recursion if language not found.
5361 Construct the new compiler spec. */
5362 language = cp->spec[0] + 1;
5363 new = (struct compiler *) xmalloc (sizeof (struct compiler));
5364 new->suffix = cp->suffix;
5365 bcopy ((char *) lookup_compiler (NULL_PTR, 0, language)->spec,
5366 (char *) new->spec, sizeof new->spec);
5370 /* A non-alias entry: return it. */
5382 register PTR value = (PTR) malloc (size);
5384 fatal ("virtual memory exhausted");
5389 xrealloc (old, size)
5395 ptr = (PTR) realloc (old, size);
5397 ptr = (PTR) malloc (size);
5399 fatal ("virtual memory exhausted");
5404 save_string (s, len)
5408 register char *result = xmalloc (len + 1);
5410 bcopy (s, result, len);
5416 pfatal_with_name (name)
5419 perror_with_name (name);
5420 delete_temp_files ();
5425 perror_with_name (name)
5428 error ("%s: %s", name, xstrerror (errno));
5432 pfatal_pexecute (errmsg_fmt, errmsg_arg)
5433 const char *errmsg_fmt;
5434 const char *errmsg_arg;
5438 int save_errno = errno;
5440 /* Space for trailing '\0' is in %s. */
5441 char *msg = xmalloc (strlen (errmsg_fmt) + strlen (errmsg_arg));
5442 sprintf (msg, errmsg_fmt, errmsg_arg);
5448 pfatal_with_name (errmsg_fmt);
5451 /* More 'friendly' abort that prints the line and file.
5452 config.h can #define abort fancy_abort if you like that sort of thing. */
5457 fatal ("Internal gcc abort.");
5460 /* Output an error message and exit */
5463 fatal VPROTO((const char *msgid, ...))
5465 #ifndef ANSI_PROTOTYPES
5470 VA_START (ap, msgid);
5472 #ifndef ANSI_PROTOTYPES
5473 msgid = va_arg (ap, const char *);
5476 fprintf (stderr, "%s: ", programname);
5477 vfprintf (stderr, _(msgid), ap);
5479 fprintf (stderr, "\n");
5480 delete_temp_files ();
5485 error VPROTO((const char *msgid, ...))
5487 #ifndef ANSI_PROTOTYPES
5492 VA_START (ap, msgid);
5494 #ifndef ANSI_PROTOTYPES
5495 msgid = va_arg (ap, const char *);
5498 fprintf (stderr, "%s: ", programname);
5499 vfprintf (stderr, _(msgid), ap);
5502 fprintf (stderr, "\n");
5506 notice VPROTO((const char *msgid, ...))
5508 #ifndef ANSI_PROTOTYPES
5513 VA_START (ap, msgid);
5515 #ifndef ANSI_PROTOTYPES
5516 msgid = va_arg (ap, const char *);
5519 vfprintf (stderr, _(msgid), ap);
5525 validate_all_switches ()
5527 struct compiler *comp;
5528 register const char *p;
5530 struct spec_list *spec;
5532 for (comp = compilers; comp->spec[0]; comp++)
5535 for (i = 0; i < sizeof comp->spec / sizeof comp->spec[0] && comp->spec[i]; i++)
5539 if (c == '%' && *p == '{')
5540 /* We have a switch spec. */
5541 validate_switches (p + 1);
5545 /* look through the linked list of specs read from the specs file */
5546 for (spec = specs; spec ; spec = spec->next)
5548 p = *(spec->ptr_spec);
5550 if (c == '%' && *p == '{')
5551 /* We have a switch spec. */
5552 validate_switches (p + 1);
5555 p = link_command_spec;
5557 if (c == '%' && *p == '{')
5558 /* We have a switch spec. */
5559 validate_switches (p + 1);
5562 /* Look at the switch-name that comes after START
5563 and mark as valid all supplied switches that match it. */
5566 validate_switches (start)
5569 register const char *p = start;
5584 while (*p != ':' && *p != '}') p++;
5588 else if (p[-1] == '*')
5590 /* Mark all matching switches as valid. */
5592 for (i = 0; i < n_switches; i++)
5593 if (!strncmp (switches[i].part1, filter, p - filter))
5594 switches[i].validated = 1;
5598 /* Mark an exact matching switch as valid. */
5599 for (i = 0; i < n_switches; i++)
5601 if (!strncmp (switches[i].part1, filter, p - filter)
5602 && switches[i].part1[p - filter] == 0)
5603 switches[i].validated = 1;
5608 /* Check whether a particular argument was used. The first time we
5609 canonicalize the switches to keep only the ones we care about. */
5623 static struct mswitchstr *mswitches;
5624 static int n_mswitches;
5629 struct mswitchstr *matches;
5633 /* Break multilib_matches into the component strings of string and replacement
5635 for (q = multilib_matches; *q != '\0'; q++)
5639 matches = (struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt);
5641 q = multilib_matches;
5652 matches[i].len = q - matches[i].str;
5654 matches[i].replace = ++q;
5655 while (*q != ';' && *q != '\0')
5661 matches[i].rep_len = q - matches[i].replace;
5669 /* Now build a list of the replacement string for switches that we care
5670 about. Make sure we allocate at least one entry. This prevents
5671 xmalloc from calling fatal, and prevents us from re-executing this
5674 = (struct mswitchstr *) xmalloc ((sizeof (struct mswitchstr))
5675 * (n_switches ? n_switches : 1));
5676 for (i = 0; i < n_switches; i++)
5678 int xlen = strlen (switches[i].part1);
5679 for (j = 0; j < cnt; j++)
5680 if (xlen == matches[j].len && ! strcmp (switches[i].part1, matches[j].str))
5682 mswitches[n_mswitches].str = matches[j].replace;
5683 mswitches[n_mswitches].len = matches[j].rep_len;
5684 mswitches[n_mswitches].replace = (char *)0;
5685 mswitches[n_mswitches].rep_len = 0;
5692 for (i = 0; i < n_mswitches; i++)
5693 if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
5700 default_arg (p, len)
5706 for (start = multilib_defaults; *start != '\0'; start = end+1)
5708 while (*start == ' ' || *start == '\t')
5714 for (end = start+1; *end != ' ' && *end != '\t' && *end != '\0'; end++)
5717 if ((end - start) == len && strncmp (p, start, len) == 0)
5727 /* Work out the subdirectory to use based on the
5728 options. The format of multilib_select is a list of elements.
5729 Each element is a subdirectory name followed by a list of options
5730 followed by a semicolon. gcc will consider each line in turn. If
5731 none of the options beginning with an exclamation point are
5732 present, and all of the other options are present, that
5733 subdirectory will be used. */
5738 char *p = multilib_select;
5740 char *this_path, *this_arg;
5746 /* Ignore newlines. */
5753 /* Get the initial path. */
5761 this_path_len = p - this_path;
5763 /* Check the arguments. */
5778 while (*p != ' ' && *p != ';')
5785 if (*this_arg != '!')
5793 /* If this is a default argument, we can just ignore it.
5794 This is true even if this_arg begins with '!'. Beginning
5795 with '!' does not mean that this argument is necessarily
5796 inappropriate for this library: it merely means that
5797 there is a more specific library which uses this
5798 argument. If this argument is a default, we need not
5799 consider that more specific library. */
5800 if (! default_arg (this_arg, p - this_arg))
5802 ok = used_arg (this_arg, p - this_arg);
5813 if (this_path_len != 1
5814 || this_path[0] != '.')
5816 char * new_multilib_dir = xmalloc (this_path_len + 1);
5817 strncpy (new_multilib_dir, this_path, this_path_len);
5818 new_multilib_dir[this_path_len] = '\0';
5819 multilib_dir = new_multilib_dir;
5828 /* Print out the multiple library subdirectory selection
5829 information. This prints out a series of lines. Each line looks
5830 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
5831 required. Only the desired options are printed out, the negative
5832 matches. The options are print without a leading dash. There are
5833 no spaces to make it easy to use the information in the shell.
5834 Each subdirectory is printed only once. This assumes the ordering
5835 generated by the genmultilib script. */
5838 print_multilib_info ()
5840 char *p = multilib_select;
5841 char *last_path = 0, *this_path;
5843 int last_path_len = 0;
5847 /* Ignore newlines. */
5854 /* Get the initial path. */
5863 /* If this is a duplicate, skip it. */
5864 skip = (last_path != 0 && p - this_path == last_path_len
5865 && ! strncmp (last_path, this_path, last_path_len));
5867 last_path = this_path;
5868 last_path_len = p - this_path;
5870 /* If this directory requires any default arguments, we can skip
5871 it. We will already have printed a directory identical to
5872 this one which does not require that default argument. */
5890 while (*q != ' ' && *q != ';')
5898 && default_arg (arg, q - arg))
5913 for (p1 = last_path; p1 < p; p1++)
5932 use_arg = *p != '!';
5937 while (*p != ' ' && *p != ';')
5952 /* If there are extra options, print them now */
5953 if (multilib_extra && *multilib_extra)
5955 int print_at = TRUE;
5958 for (q = multilib_extra; *q != '\0'; q++)