![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gcc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to gcc.c CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Compiler driver program that can handle many languages.
2: Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
6: GNU CC is free software; you can redistribute it and/or modify
7: it under the terms of the GNU General Public License as published by
8: the Free Software Foundation; either version 2, or (at your option)
9: any later version.
10:
11: GNU CC is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: GNU General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GNU CC; see the file COPYING. If not, write to
18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
19:
20: This paragraph is here to try to keep Sun CC from dying.
21: The number of chars here seems crucial!!!! */
22:
23: /* This program is the user interface to the C compiler and possibly to
24: other compilers. It is used because compilation is a complicated procedure
25: which involves running several programs and passing temporary files between
26: them, forwarding the users switches to those programs selectively,
27: and deleting the temporary files at the end.
28:
29: CC recognizes how to compile each input file by suffixes in the file names.
30: Once it knows which kind of compilation to perform, the procedure for
31: compilation is specified by a string called a "spec". */
32:
33: #include <sys/types.h>
34: #include <ctype.h>
35: #include <signal.h>
36: #include <sys/stat.h>
1.1.1.3 root 37: #include <sys/file.h> /* May get R_OK, etc. on some systems. */
1.1 root 38:
39: #include "config.h"
40: #include "obstack.h"
41: #include "gvarargs.h"
1.1.1.4 ! root 42: #include <stdio.h>
1.1 root 43:
44: #ifndef R_OK
45: #define R_OK 4
46: #define W_OK 2
47: #define X_OK 1
48: #endif
49:
1.1.1.4 ! root 50: /* Define a generic NULL if one hasn't already been defined. */
! 51:
! 52: #ifndef NULL
! 53: #define NULL 0
! 54: #endif
! 55:
! 56: #ifndef GENERIC_PTR
! 57: #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
! 58: #define GENERIC_PTR void *
! 59: #else
! 60: #define GENERIC_PTR char *
! 61: #endif
! 62: #endif
! 63:
! 64: #ifndef NULL_PTR
! 65: #define NULL_PTR ((GENERIC_PTR)0)
! 66: #endif
! 67:
1.1.1.3 root 68: #ifdef USG
1.1 root 69: #define vfork fork
70: #endif /* USG */
71:
72: /* On MSDOS, write temp files in current dir
73: because there's no place else we can expect to use. */
74: #if __MSDOS__
75: #ifndef P_tmpdir
76: #define P_tmpdir "./"
77: #endif
78: #endif
79:
80: /* Test if something is a normal file. */
81: #ifndef S_ISREG
82: #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
83: #endif
84:
85: /* Test if something is a directory. */
86: #ifndef S_ISDIR
87: #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
88: #endif
89:
90: /* By default there is no special suffix for executables. */
91: #ifndef EXECUTABLE_SUFFIX
92: #define EXECUTABLE_SUFFIX ""
93: #endif
1.1.1.3 root 94:
95: /* By default, colon separates directories in a path. */
96: #ifndef PATH_SEPARATOR
97: #define PATH_SEPARATOR ':'
1.1 root 98: #endif
99:
100: #define obstack_chunk_alloc xmalloc
101: #define obstack_chunk_free free
102:
103: extern void free ();
104: extern char *getenv ();
105:
106: extern int errno, sys_nerr;
107: extern char *sys_errlist[];
108:
109: extern int execv (), execvp ();
110:
111: /* If a stage of compilation returns an exit status >= 1,
112: compilation of that file ceases. */
113:
114: #define MIN_FATAL_STATUS 1
115:
1.1.1.3 root 116: /* Flag saying to print the full filename of libgcc.a
117: as found through our usual search mechanism. */
118:
119: static int print_libgcc_file_name;
120:
1.1 root 121: /* Flag indicating whether we should print the command and arguments */
122:
123: static int verbose_flag;
124:
125: /* Nonzero means write "temp" files in source directory
126: and use the source file's name in them, and don't delete them. */
127:
128: static int save_temps_flag;
129:
130: /* The compiler version specified with -V */
131:
132: static char *spec_version;
133:
134: /* The target machine specified with -b. */
135:
136: static char *spec_machine = DEFAULT_TARGET_MACHINE;
137:
1.1.1.2 root 138: /* Nonzero if cross-compiling.
139: When -b is used, the value comes from the `specs' file. */
140:
141: #ifdef CROSS_COMPILE
142: static int cross_compile = 1;
143: #else
144: static int cross_compile = 0;
145: #endif
146:
1.1 root 147: /* This is the obstack which we use to allocate many strings. */
148:
149: static struct obstack obstack;
150:
1.1.1.2 root 151: /* This is the obstack to build an environment variable to pass to
1.1.1.3 root 152: collect2 that describes all of the relevant switches of what to
1.1.1.2 root 153: pass the compiler in building the list of pointers to constructors
154: and destructors. */
155:
156: static struct obstack collect_obstack;
157:
1.1 root 158: extern char *version_string;
159:
160: static void set_spec ();
161: static struct compiler *lookup_compiler ();
162: static char *find_a_file ();
163: static void add_prefix ();
164: static char *skip_whitespace ();
165: static void record_temp_file ();
166: static char *handle_braces ();
167: static char *save_string ();
168: static char *concat ();
169: static int do_spec ();
170: static int do_spec_1 ();
171: static char *find_file ();
172: static int is_linker_dir ();
173: static void validate_switches ();
174: static void validate_all_switches ();
175: static void give_switch ();
176: static void pfatal_with_name ();
177: static void perror_with_name ();
178: static void perror_exec ();
179: static void fatal ();
180: static void error ();
181: void fancy_abort ();
182: char *xmalloc ();
183: char *xrealloc ();
184:
185: /* Specs are strings containing lines, each of which (if not blank)
186: is made up of a program name, and arguments separated by spaces.
187: The program name must be exact and start from root, since no path
188: is searched and it is unreliable to depend on the current working directory.
189: Redirection of input or output is not supported; the subprograms must
190: accept filenames saying what files to read and write.
191:
192: In addition, the specs can contain %-sequences to substitute variable text
193: or for conditional text. Here is a table of all defined %-sequences.
194: Note that spaces are not generated automatically around the results of
195: expanding these sequences; therefore, you can concatenate them together
196: or with constant text in a single argument.
197:
198: %% substitute one % into the program name or argument.
199: %i substitute the name of the input file being processed.
200: %b substitute the basename of the input file being processed.
201: This is the substring up to (and not including) the last period
202: and not including the directory.
203: %g substitute the temporary-file-name-base. This is a string chosen
204: once per compilation. Different temporary file names are made by
205: concatenation of constant strings on the end, as in `%g.s'.
206: %g also has the same effect of %d.
1.1.1.4 ! root 207: %u like %g, but make the temporary file name unique.
! 208: %U returns the last file name generated with %u.
1.1 root 209: %d marks the argument containing or following the %d as a
210: temporary file name, so that that file will be deleted if CC exits
211: successfully. Unlike %g, this contributes no text to the argument.
212: %w marks the argument containing or following the %w as the
213: "output file" of this compilation. This puts the argument
214: into the sequence of arguments that %o will substitute later.
215: %W{...}
216: like %{...} but mark last argument supplied within
217: as a file to be deleted on failure.
218: %o substitutes the names of all the output files, with spaces
219: automatically placed around them. You should write spaces
220: around the %o as well or the results are undefined.
221: %o is for use in the specs for running the linker.
222: Input files whose names have no recognized suffix are not compiled
223: at all, but they are included among the output files, so they will
224: be linked.
225: %p substitutes the standard macro predefinitions for the
226: current target machine. Use this when running cpp.
227: %P like %p, but puts `__' before and after the name of each macro.
228: (Except macros that already have __.)
229: This is for ANSI C.
1.1.1.3 root 230: %I Substitute a -iprefix option made from GCC_EXEC_PREFIX.
1.1 root 231: %s current argument is the name of a library or startup file of some sort.
232: Search for that file in a standard list of directories
233: and substitute the full name found.
234: %eSTR Print STR as an error message. STR is terminated by a newline.
235: Use this when inconsistent options are detected.
236: %x{OPTION} Accumulate an option for %X.
237: %X Output the accumulated linker options specified by compilations.
1.1.1.4 ! root 238: %Y Output the accumulated assembler options specified by compilations.
1.1 root 239: %a process ASM_SPEC as a spec.
240: This allows config.h to specify part of the spec for running as.
241: %A process ASM_FINAL_SPEC as a spec. A capital A is actually
242: used here. This can be used to run a post-processor after the
243: assembler has done it's job.
244: %D Dump out a -L option for each directory in library_prefix,
245: followed by a -L option for each directory in startfile_prefix.
246: %l process LINK_SPEC as a spec.
247: %L process LIB_SPEC as a spec.
248: %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
249: %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
250: %c process SIGNED_CHAR_SPEC as a spec.
251: %C process CPP_SPEC as a spec. A capital C is actually used here.
252: %1 process CC1_SPEC as a spec.
253: %2 process CC1PLUS_SPEC as a spec.
254: %* substitute the variable part of a matched option. (See below.)
255: Note that each comma in the substituted string is replaced by
256: a single space.
257: %{S} substitutes the -S switch, if that switch was given to CC.
258: If that switch was not specified, this substitutes nothing.
259: Here S is a metasyntactic variable.
260: %{S*} substitutes all the switches specified to CC whose names start
261: with -S. This is used for -o, -D, -I, etc; switches that take
262: arguments. CC considers `-o foo' as being one switch whose
263: name starts with `o'. %{o*} would substitute this text,
264: including the space; thus, two arguments would be generated.
1.1.1.4 ! root 265: %{S*:X} substitutes X if one or more switches whose names start with -S are
1.1 root 266: specified to CC. Note that the tail part of the -S option
267: (i.e. the part matched by the `*') will be substituted for each
1.1.1.3 root 268: occurrence of %* within X.
1.1 root 269: %{S:X} substitutes X, but only if the -S switch was given to CC.
270: %{!S:X} substitutes X, but only if the -S switch was NOT given to CC.
271: %{|S:X} like %{S:X}, but if no S switch, substitute `-'.
272: %{|!S:X} like %{!S:X}, but if there is an S switch, substitute `-'.
273: %{.S:X} substitutes X, but only if processing a file with suffix S.
274: %{!.S:X} substitutes X, but only if NOT processing a file with suffix S.
1.1.1.2 root 275: %(Spec) processes a specification defined in a specs file as *Spec:
276: %[Spec] as above, but put __ around -D arguments
1.1 root 277:
278: The conditional text X in a %{S:X} or %{!S:X} construct may contain
279: other nested % constructs or spaces, or even newlines. They are
280: processed as usual, as described above.
281:
282: The character | is used to indicate that a command should be piped to
283: the following command, but only if -pipe is specified.
284:
285: Note that it is built into CC which switches take arguments and which
286: do not. You might think it would be useful to generalize this to
287: allow each compiler's spec to say which switches take arguments. But
288: this cannot be done in a consistent fashion. CC cannot even decide
289: which input files have been specified without knowing which switches
290: take arguments, and it must know which input files to compile in order
291: to tell which compilers to run.
292:
293: CC also knows implicitly that arguments starting in `-l' are to be
294: treated as compiler output files, and passed to the linker in their
295: proper position among the other output files. */
296:
297: /* Define the macros used for specs %a, %l, %L, %S, %c, %C, %1. */
298:
299: /* config.h can define ASM_SPEC to provide extra args to the assembler
300: or extra switch-translations. */
301: #ifndef ASM_SPEC
302: #define ASM_SPEC ""
303: #endif
304:
305: /* config.h can define ASM_FINAL_SPEC to run a post processor after
306: the assembler has run. */
307: #ifndef ASM_FINAL_SPEC
308: #define ASM_FINAL_SPEC ""
309: #endif
310:
311: /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
312: or extra switch-translations. */
313: #ifndef CPP_SPEC
314: #define CPP_SPEC ""
315: #endif
316:
317: /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
318: or extra switch-translations. */
319: #ifndef CC1_SPEC
320: #define CC1_SPEC ""
321: #endif
322:
323: /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
324: or extra switch-translations. */
325: #ifndef CC1PLUS_SPEC
326: #define CC1PLUS_SPEC ""
327: #endif
328:
329: /* config.h can define LINK_SPEC to provide extra args to the linker
330: or extra switch-translations. */
331: #ifndef LINK_SPEC
332: #define LINK_SPEC ""
333: #endif
334:
335: /* config.h can define LIB_SPEC to override the default libraries. */
336: #ifndef LIB_SPEC
337: #define LIB_SPEC "%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}"
338: #endif
339:
340: /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
341: #ifndef STARTFILE_SPEC
342: #define STARTFILE_SPEC \
343: "%{pg:gcrt0.o%s}%{!pg:%{p:mcrt0.o%s}%{!p:crt0.o%s}}"
344: #endif
345:
346: /* config.h can define SWITCHES_NEED_SPACES to control passing -o and -L.
347: Make the string nonempty to require spaces there. */
348: #ifndef SWITCHES_NEED_SPACES
349: #define SWITCHES_NEED_SPACES ""
350: #endif
351:
352: /* config.h can define ENDFILE_SPEC to override the default crtn files. */
353: #ifndef ENDFILE_SPEC
354: #define ENDFILE_SPEC ""
355: #endif
356:
357: /* This spec is used for telling cpp whether char is signed or not. */
358: #ifndef SIGNED_CHAR_SPEC
1.1.1.4 ! root 359: /* Use #if rather than ?:
! 360: because MIPS C compiler rejects like ?: in initializers. */
! 361: #if DEFAULT_SIGNED_CHAR
! 362: #define SIGNED_CHAR_SPEC "%{funsigned-char:-D__CHAR_UNSIGNED__}"
! 363: #else
! 364: #define SIGNED_CHAR_SPEC "%{!fsigned-char:-D__CHAR_UNSIGNED__}"
! 365: #endif
1.1 root 366: #endif
367:
368: static char *cpp_spec = CPP_SPEC;
369: static char *cpp_predefines = CPP_PREDEFINES;
370: static char *cc1_spec = CC1_SPEC;
371: static char *cc1plus_spec = CC1PLUS_SPEC;
372: static char *signed_char_spec = SIGNED_CHAR_SPEC;
373: static char *asm_spec = ASM_SPEC;
374: static char *asm_final_spec = ASM_FINAL_SPEC;
375: static char *link_spec = LINK_SPEC;
376: static char *lib_spec = LIB_SPEC;
377: static char *endfile_spec = ENDFILE_SPEC;
378: static char *startfile_spec = STARTFILE_SPEC;
379: static char *switches_need_spaces = SWITCHES_NEED_SPACES;
380:
381: /* This defines which switch letters take arguments. */
382:
383: #ifndef SWITCH_TAKES_ARG
384: #define SWITCH_TAKES_ARG(CHAR) \
385: ((CHAR) == 'D' || (CHAR) == 'U' || (CHAR) == 'o' \
386: || (CHAR) == 'e' || (CHAR) == 'T' || (CHAR) == 'u' \
387: || (CHAR) == 'I' || (CHAR) == 'm' \
388: || (CHAR) == 'L' || (CHAR) == 'A')
389: #endif
390:
391: /* This defines which multi-letter switches take arguments. */
392:
393: #ifndef WORD_SWITCH_TAKES_ARG
394: #define WORD_SWITCH_TAKES_ARG(STR) \
1.1.1.4 ! root 395: (!strcmp (STR, "Tdata") || !strcmp (STR, "Ttext") \
! 396: || !strcmp (STR, "Tbss") || !strcmp (STR, "include") \
1.1.1.2 root 397: || !strcmp (STR, "imacros") || !strcmp (STR, "aux-info"))
1.1 root 398: #endif
399:
400: /* Record the mapping from file suffixes for compilation specs. */
401:
402: struct compiler
403: {
404: char *suffix; /* Use this compiler for input files
405: whose names end in this suffix. */
1.1.1.4 ! root 406:
! 407: char *spec[4]; /* To use this compiler, concatenate these
! 408: specs and pass to do_spec. */
1.1 root 409: };
410:
411: /* Pointer to a vector of `struct compiler' that gives the spec for
412: compiling a file, based on its suffix.
413: A file that does not end in any of these suffixes will be passed
414: unchanged to the loader and nothing else will be done to it.
415:
416: An entry containing two 0s is used to terminate the vector.
417:
418: If multiple entries match a file, the last matching one is used. */
419:
420: static struct compiler *compilers;
421:
422: /* Number of entries in `compilers', not counting the null terminator. */
423:
424: static int n_compilers;
425:
426: /* The default list of file name suffixes and their compilation specs. */
427:
428: static struct compiler default_compilers[] =
429: {
430: {".c", "@c"},
431: {"@c",
1.1.1.4 ! root 432: "cpp -lang-c %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
1.1 root 433: %{C:%{!E:%eGNU C does not support -C without using -E}}\
434: %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d}\
435: -undef -D__GNUC__=2 %{ansi:-trigraphs -$ -D__STRICT_ANSI__}\
1.1.1.4 ! root 436: %{!undef:%{!ansi:%p} %P} %{trigraphs} \
1.1 root 437: %c %{O*:-D__OPTIMIZE__} %{traditional} %{ftraditional:-traditional}\
438: %{traditional-cpp:-traditional}\
1.1.1.4 ! root 439: %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
! 440: %i %{!M:%{!MM:%{!E:%{!pipe:%g.i}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
! 441: "%{!M:%{!MM:%{!E:cc1 %{!pipe:%g.i} %1 \
1.1 root 442: %{!Q:-quiet} -dumpbase %b.c %{d*} %{m*} %{a}\
443: %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi} \
444: %{traditional} %{v:-version} %{pg:-p} %{p} %{f*}\
1.1.1.2 root 445: %{aux-info*}\
1.1 root 446: %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
447: %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
1.1.1.4 ! root 448: %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
! 449: %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
1.1 root 450: %{!pipe:%g.s} %A\n }}}}"},
451: {"-",
1.1.1.4 ! root 452: "%{E:cpp -lang-c %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
1.1 root 453: %{C:%{!E:%eGNU C does not support -C without using -E}}\
454: %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d}\
455: -undef -D__GNUC__=2 %{ansi:-trigraphs -$ -D__STRICT_ANSI__}\
456: %{!undef:%{!ansi:%p} %P} %{trigraphs}\
457: %c %{O*:-D__OPTIMIZE__} %{traditional} %{ftraditional:-traditional}\
458: %{traditional-cpp:-traditional}\
1.1.1.4 ! root 459: %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
1.1 root 460: %i %W{o*}}\
461: %{!E:%e-E required when input is from standard input}"},
462: {".m", "@objective-c"},
463: {"@objective-c",
1.1.1.4 ! root 464: "cpp -lang-objc %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
1.1 root 465: %{C:%{!E:%eGNU C does not support -C without using -E}}\
466: %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d}\
467: -undef -D__OBJC__ -D__GNUC__=2 %{ansi:-trigraphs -$ -D__STRICT_ANSI__}\
468: %{!undef:%{!ansi:%p} %P} %{trigraphs}\
469: %c %{O*:-D__OPTIMIZE__} %{traditional} %{ftraditional:-traditional}\
470: %{traditional-cpp:-traditional}\
1.1.1.4 ! root 471: %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
! 472: %i %{!M:%{!MM:%{!E:%{!pipe:%g.i}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
! 473: "%{!M:%{!MM:%{!E:cc1obj %{!pipe:%g.i} %1 \
1.1 root 474: %{!Q:-quiet} -dumpbase %b.m %{d*} %{m*} %{a}\
475: %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi} \
476: %{traditional} %{v:-version} %{pg:-p} %{p} %{f*} \
477: -lang-objc %{gen-decls} \
1.1.1.2 root 478: %{aux-info*}\
1.1 root 479: %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
480: %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
1.1.1.4 ! root 481: %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
! 482: %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
1.1 root 483: %{!pipe:%g.s} %A\n }}}}"},
484: {".h", "@c-header"},
485: {"@c-header",
486: "%{!E:%eCompilation of header file requested} \
1.1.1.4 ! root 487: cpp %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
1.1 root 488: %{C:%{!E:%eGNU C does not support -C without using -E}}\
489: %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} \
490: -undef -D__GNUC__=2 %{ansi:-trigraphs -$ -D__STRICT_ANSI__}\
491: %{!undef:%{!ansi:%p} %P} %{trigraphs}\
492: %c %{O*:-D__OPTIMIZE__} %{traditional} %{ftraditional:-traditional}\
493: %{traditional-cpp:-traditional}\
1.1.1.4 ! root 494: %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
1.1 root 495: %i %W{o*}"},
496: {".cc", "@c++"},
497: {".cxx", "@c++"},
498: {".C", "@c++"},
499: {"@c++",
1.1.1.4 ! root 500: "cpp -lang-c++ %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
1.1 root 501: %{C:%{!E:%eGNU C++ does not support -C without using -E}}\
502: %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} \
503: -undef -D__GNUC__=2 -D__GNUG__=2 -D__cplusplus \
504: %{ansi:-trigraphs -$ -D__STRICT_ANSI__} %{!undef:%{!ansi:%p} %P}\
505: %c %{O*:-D__OPTIMIZE__} %{traditional} %{ftraditional:-traditional}\
506: %{traditional-cpp:-traditional} %{trigraphs}\
1.1.1.4 ! root 507: %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
! 508: %i %{!M:%{!MM:%{!E:%{!pipe:%g.i}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
! 509: "%{!M:%{!MM:%{!E:cc1plus %{!pipe:%g.i} %1 %2\
1.1 root 510: %{!Q:-quiet} -dumpbase %b.cc %{d*} %{m*} %{a}\
511: %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi} %{traditional}\
1.1.1.4 ! root 512: %{v:-version} %{pg:-p} %{p} %{f*} %{+e*}\
1.1.1.2 root 513: %{aux-info*}\
1.1 root 514: %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
515: %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
1.1.1.4 ! root 516: %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
! 517: %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
1.1 root 518: %{!pipe:%g.s} %A\n }}}}"},
519: {".i", "@cpp-output"},
520: {"@cpp-output",
521: "cc1 %i %1 %{!Q:-quiet} %{d*} %{m*} %{a}\
522: %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi} %{traditional}\
523: %{v:-version} %{pg:-p} %{p} %{f*}\
1.1.1.2 root 524: %{aux-info*}\
1.1 root 525: %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
526: %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
1.1.1.4 ! root 527: %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
! 528: %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o} %{!pipe:%g.s} %A\n }"},
1.1 root 529: {".ii", "@c++-cpp-output"},
530: {"@c++-cpp-output",
531: "cc1plus %i %1 %2 %{!Q:-quiet} %{d*} %{m*} %{a}\
532: %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi} %{traditional}\
1.1.1.4 ! root 533: %{v:-version} %{pg:-p} %{p} %{f*} %{+e*}\
1.1.1.2 root 534: %{aux-info*}\
1.1 root 535: %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
536: %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
1.1.1.4 ! root 537: %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
! 538: %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
1.1 root 539: %{!pipe:%g.s} %A\n }"},
540: {".s", "@assembler"},
541: {"@assembler",
1.1.1.4 ! root 542: "%{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
! 543: %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o} %i %A\n }"},
1.1 root 544: {".S", "@assembler-with-cpp"},
545: {"@assembler-with-cpp",
1.1.1.4 ! root 546: "cpp -lang-asm %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
1.1 root 547: %{C:%{!E:%eGNU C does not support -C without using -E}}\
548: %{M} %{MM} %{MD:-MD %b.d} %{MMD:-MMD %b.d} %{trigraphs} \
549: -undef -$ %{!undef:%p %P} -D__ASSEMBLER__ \
550: %c %{O*:-D__OPTIMIZE__} %{traditional} %{ftraditional:-traditional}\
551: %{traditional-cpp:-traditional}\
1.1.1.4 ! root 552: %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
! 553: %i %{!M:%{!MM:%{!E:%{!pipe:%g.s}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
! 554: "%{!M:%{!MM:%{!E:%{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
! 555: %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
1.1 root 556: %{!pipe:%g.s} %A\n }}}}"},
557: /* Mark end of table */
558: {0, 0}
559: };
560:
561: /* Number of elements in default_compilers, not counting the terminator. */
562:
563: static int n_default_compilers
564: = (sizeof default_compilers / sizeof (struct compiler)) - 1;
565:
566: /* Here is the spec for running the linker, after compiling all files. */
567:
1.1.1.3 root 568: /* -u* was put back because both BSD and SysV seem to support it. */
1.1.1.4 ! root 569: /* %{static:} simply prevents an error message if the target machine
! 570: doesn't handle -static. */
! 571: #ifdef LINK_LIBGCC_SPECIAL_1
! 572: /* Have gcc do the search for libgcc.a, but generate -L options as usual. */
1.1 root 573: static char *link_command_spec = "\
1.1.1.3 root 574: %{!c:%{!M:%{!MM:%{!E:%{!S:ld %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} \
575: %{r} %{s} %{T*} %{t} %{u*} %{x} %{z}\
1.1.1.4 ! root 576: %{!A:%{!nostdlib:%S}} %{static:}\
1.1 root 577: %{L*} %D %o %{!nostdlib:libgcc.a%s %L libgcc.a%s %{!A:%E}}\n }}}}}";
578: #else
1.1.1.4 ! root 579: #ifdef LINK_LIBGCC_SPECIAL
! 580: /* Have gcc do the search for libgcc.a, and don't generate -L options. */
! 581: static char *link_command_spec = "\
! 582: %{!c:%{!M:%{!MM:%{!E:%{!S:ld %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} \
! 583: %{r} %{s} %{T*} %{t} %{u*} %{x} %{z}\
! 584: %{!A:%{!nostdlib:%S}} %{static:}\
! 585: %{L*} %o %{!nostdlib:libgcc.a%s %L libgcc.a%s %{!A:%E}}\n }}}}}";
! 586: #else
1.1.1.3 root 587: /* Use -L and have the linker do the search for -lgcc. */
1.1 root 588: static char *link_command_spec = "\
1.1.1.3 root 589: %{!c:%{!M:%{!MM:%{!E:%{!S:ld %l %X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} \
590: %{r} %{s} %{T*} %{t} %{u*} %{x} %{z}\
1.1.1.4 ! root 591: %{!A:%{!nostdlib:%S}} %{static:}\
1.1 root 592: %{L*} %D %o %{!nostdlib:-lgcc %L -lgcc %{!A:%E}}\n }}}}}";
593: #endif
1.1.1.4 ! root 594: #endif
1.1 root 595:
596: /* A vector of options to give to the linker.
1.1.1.4 ! root 597: These options are accumulated by -Xlinker and -Wl,
1.1 root 598: and substituted into the linker command with %X. */
599: static int n_linker_options;
600: static char **linker_options;
1.1.1.4 ! root 601:
! 602: /* A vector of options to give to the assembler.
! 603: These options are accumulated by -Wa,
! 604: and substituted into the assembler command with %X. */
! 605: static int n_assembler_options;
! 606: static char **assembler_options;
1.1 root 607:
608: /* Read compilation specs from a file named FILENAME,
609: replacing the default ones.
610:
611: A suffix which starts with `*' is a definition for
612: one of the machine-specific sub-specs. The "suffix" should be
613: *asm, *cc1, *cpp, *link, *startfile, *signed_char, etc.
614: The corresponding spec is stored in asm_spec, etc.,
615: rather than in the `compilers' vector.
616:
617: Anything invalid in the file is a fatal error. */
618:
619: static void
620: read_specs (filename)
621: char *filename;
622: {
623: int desc;
624: struct stat statbuf;
625: char *buffer;
626: register char *p;
627:
628: if (verbose_flag)
629: fprintf (stderr, "Reading specs from %s\n", filename);
630:
631: /* Open and stat the file. */
632: desc = open (filename, 0, 0);
633: if (desc < 0)
634: pfatal_with_name (filename);
635: if (stat (filename, &statbuf) < 0)
636: pfatal_with_name (filename);
637:
638: /* Read contents of file into BUFFER. */
1.1.1.4 ! root 639: buffer = xmalloc ((unsigned) statbuf.st_size + 1);
! 640: read (desc, buffer, (unsigned) statbuf.st_size);
1.1 root 641: buffer[statbuf.st_size] = 0;
642: close (desc);
643:
644: /* Scan BUFFER for specs, putting them in the vector. */
645: p = buffer;
646: while (1)
647: {
648: char *suffix;
649: char *spec;
650: char *in, *out, *p1, *p2;
651:
652: /* Advance P in BUFFER to the next nonblank nocomment line. */
653: p = skip_whitespace (p);
654: if (*p == 0)
655: break;
656:
657: /* Find the colon that should end the suffix. */
658: p1 = p;
659: while (*p1 && *p1 != ':' && *p1 != '\n') p1++;
660: /* The colon shouldn't be missing. */
661: if (*p1 != ':')
662: fatal ("specs file malformed after %d characters", p1 - buffer);
663: /* Skip back over trailing whitespace. */
664: p2 = p1;
665: while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t')) p2--;
666: /* Copy the suffix to a string. */
667: suffix = save_string (p, p2 - p);
668: /* Find the next line. */
669: p = skip_whitespace (p1 + 1);
670: if (p[1] == 0)
671: fatal ("specs file malformed after %d characters", p - buffer);
672: p1 = p;
673: /* Find next blank line. */
674: while (*p1 && !(*p1 == '\n' && p1[1] == '\n')) p1++;
675: /* Specs end at the blank line and do not include the newline. */
676: spec = save_string (p, p1 - p);
677: p = p1;
678:
679: /* Delete backslash-newline sequences from the spec. */
680: in = spec;
681: out = spec;
682: while (*in != 0)
683: {
684: if (in[0] == '\\' && in[1] == '\n')
685: in += 2;
686: else if (in[0] == '#')
687: {
688: while (*in && *in != '\n') in++;
689: }
690: else
691: *out++ = *in++;
692: }
693: *out = 0;
694:
695: if (suffix[0] == '*')
696: {
697: if (! strcmp (suffix, "*link_command"))
698: link_command_spec = spec;
699: else
700: set_spec (suffix + 1, spec);
701: }
702: else
703: {
704: /* Add this pair to the vector. */
705: compilers
706: = ((struct compiler *)
707: xrealloc (compilers, (n_compilers + 2) * sizeof (struct compiler)));
708: compilers[n_compilers].suffix = suffix;
1.1.1.4 ! root 709: bzero (compilers[n_compilers].spec,
! 710: sizeof compilers[n_compilers].spec);
! 711: compilers[n_compilers].spec[0] = spec;
1.1 root 712: n_compilers++;
713: }
714:
715: if (*suffix == 0)
716: link_command_spec = spec;
717: }
718:
719: if (link_command_spec == 0)
720: fatal ("spec file has no spec for linking");
721: }
722:
723: static char *
724: skip_whitespace (p)
725: char *p;
726: {
727: while (1)
728: {
729: /* A fully-blank line is a delimiter in the SPEC file and shouldn't
730: be considered whitespace. */
731: if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
732: return p + 1;
733: else if (*p == '\n' || *p == ' ' || *p == '\t')
734: p++;
735: else if (*p == '#')
736: {
737: while (*p != '\n') p++;
738: p++;
739: }
740: else
741: break;
742: }
743:
744: return p;
745: }
746:
747: /* Structure to keep track of the specs that have been defined so far. These
1.1.1.2 root 748: are accessed using %(specname) or %[specname] in a compiler or link spec. */
1.1 root 749:
750: struct spec_list
751: {
752: char *name; /* Name of the spec. */
753: char *spec; /* The spec itself. */
754: struct spec_list *next; /* Next spec in linked list. */
755: };
756:
757: /* List of specs that have been defined so far. */
758:
759: static struct spec_list *specs = (struct spec_list *) 0;
760:
761: /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
762: removed; If the spec starts with a + then SPEC is added to the end of the
763: current spec. */
764:
765: static void
766: set_spec (name, spec)
767: char *name;
768: char *spec;
769: {
770: struct spec_list *sl;
771: char *old_spec;
772:
773: /* See if the spec already exists */
774: for (sl = specs; sl; sl = sl->next)
775: if (strcmp (sl->name, name) == 0)
776: break;
777:
778: if (!sl)
779: {
780: /* Not found - make it */
781: sl = (struct spec_list *) xmalloc (sizeof (struct spec_list));
782: sl->name = save_string (name, strlen (name));
783: sl->spec = save_string ("", 0);
784: sl->next = specs;
785: specs = sl;
786: }
787:
788: old_spec = sl->spec;
789: if (name && spec[0] == '+' && isspace (spec[1]))
1.1.1.3 root 790: sl->spec = concat (old_spec, spec + 1, "");
1.1 root 791: else
792: sl->spec = save_string (spec, strlen (spec));
793:
794: if (! strcmp (name, "asm"))
795: asm_spec = sl->spec;
796: else if (! strcmp (name, "asm_final"))
797: asm_final_spec = sl->spec;
798: else if (! strcmp (name, "cc1"))
799: cc1_spec = sl->spec;
800: else if (! strcmp (name, "cc1plus"))
801: cc1plus_spec = sl->spec;
802: else if (! strcmp (name, "cpp"))
803: cpp_spec = sl->spec;
804: else if (! strcmp (name, "endfile"))
805: endfile_spec = sl->spec;
806: else if (! strcmp (name, "lib"))
807: lib_spec = sl->spec;
808: else if (! strcmp (name, "link"))
809: link_spec = sl->spec;
810: else if (! strcmp (name, "predefines"))
811: cpp_predefines = sl->spec;
812: else if (! strcmp (name, "signed_char"))
813: signed_char_spec = sl->spec;
814: else if (! strcmp (name, "startfile"))
815: startfile_spec = sl->spec;
816: else if (! strcmp (name, "switches_need_spaces"))
817: switches_need_spaces = sl->spec;
1.1.1.2 root 818: else if (! strcmp (name, "cross_compile"))
819: cross_compile = atoi (sl->spec);
1.1 root 820: /* Free the old spec */
821: if (old_spec)
822: free (old_spec);
823: }
824:
825: /* Accumulate a command (program name and args), and run it. */
826:
827: /* Vector of pointers to arguments in the current line of specifications. */
828:
829: static char **argbuf;
830:
831: /* Number of elements allocated in argbuf. */
832:
833: static int argbuf_length;
834:
835: /* Number of elements in argbuf currently in use (containing args). */
836:
837: static int argbuf_index;
838:
1.1.1.4 ! root 839: /* This is the list of suffixes and codes (%g/%u/%U) and the associated
! 840: temp file. Used only if MKTEMP_EACH_FILE. */
! 841:
! 842: static struct temp_name {
! 843: char *suffix; /* suffix associated with the code. */
! 844: int length; /* strlen (suffix). */
! 845: int unique; /* Indicates whether %g or %u/%U was used. */
! 846: char *filename; /* associated filename. */
! 847: int filename_length; /* strlen (filename). */
! 848: struct temp_name *next;
! 849: } *temp_names;
! 850:
1.1 root 851: /* Number of commands executed so far. */
852:
853: static int execution_count;
854:
1.1.1.4 ! root 855: /* Number of commands that exited with a signal. */
! 856:
! 857: static int signal_count;
! 858:
1.1 root 859: /* Name with which this program was invoked. */
860:
861: static char *programname;
862:
863: /* Structures to keep track of prefixes to try when looking for files. */
864:
865: struct prefix_list
866: {
867: char *prefix; /* String to prepend to the path. */
868: struct prefix_list *next; /* Next in linked list. */
869: int require_machine_suffix; /* Don't use without machine_suffix. */
1.1.1.4 ! root 870: /* 2 means try both machine_suffix and just_machine_suffix. */
1.1 root 871: int *used_flag_ptr; /* 1 if a file was found with this prefix. */
872: };
873:
874: struct path_prefix
875: {
876: struct prefix_list *plist; /* List of prefixes to try */
877: int max_len; /* Max length of a prefix in PLIST */
878: char *name; /* Name of this list (used in config stuff) */
879: };
880:
881: /* List of prefixes to try when looking for executables. */
882:
883: static struct path_prefix exec_prefix = { 0, 0, "exec" };
884:
885: /* List of prefixes to try when looking for startup (crt0) files. */
886:
887: static struct path_prefix startfile_prefix = { 0, 0, "startfile" };
888:
889: /* List of prefixes to try when looking for libraries. */
890:
891: static struct path_prefix library_prefix = { 0, 0, "libraryfile" };
892:
1.1.1.4 ! root 893: /* Suffix to attach to directories searched for commands.
! 894: This looks like `MACHINE/VERSION/'. */
1.1 root 895:
896: static char *machine_suffix = 0;
897:
1.1.1.4 ! root 898: /* Suffix to attach to directories searched for commands.
! 899: This is just `MACHINE/'. */
! 900:
! 901: static char *just_machine_suffix = 0;
! 902:
1.1.1.3 root 903: /* Adjusted value of GCC_EXEC_PREFIX envvar. */
904:
905: static char *gcc_exec_prefix;
906:
1.1 root 907: /* Default prefixes to attach to command names. */
908:
909: #ifdef CROSS_COMPILE /* Don't use these prefixes for a cross compiler. */
910: #undef MD_EXEC_PREFIX
911: #undef MD_STARTFILE_PREFIX
1.1.1.3 root 912: #undef MD_STARTFILE_PREFIX_1
1.1 root 913: #endif
914:
915: #ifndef STANDARD_EXEC_PREFIX
1.1.1.2 root 916: #define STANDARD_EXEC_PREFIX "/usr/local/lib/gcc-lib/"
1.1 root 917: #endif /* !defined STANDARD_EXEC_PREFIX */
918:
919: static char *standard_exec_prefix = STANDARD_EXEC_PREFIX;
920: static char *standard_exec_prefix_1 = "/usr/lib/gcc/";
921: #ifdef MD_EXEC_PREFIX
922: static char *md_exec_prefix = MD_EXEC_PREFIX;
923: #endif
924:
925: #ifndef STANDARD_STARTFILE_PREFIX
926: #define STANDARD_STARTFILE_PREFIX "/usr/local/lib/"
927: #endif /* !defined STANDARD_STARTFILE_PREFIX */
928:
929: #ifdef MD_STARTFILE_PREFIX
930: static char *md_startfile_prefix = MD_STARTFILE_PREFIX;
931: #endif
1.1.1.3 root 932: #ifdef MD_STARTFILE_PREFIX_1
933: static char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
934: #endif
1.1 root 935: static char *standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
936: static char *standard_startfile_prefix_1 = "/lib/";
937: static char *standard_startfile_prefix_2 = "/usr/lib/";
938:
939: /* Clear out the vector of arguments (after a command is executed). */
940:
941: static void
942: clear_args ()
943: {
944: argbuf_index = 0;
945: }
946:
947: /* Add one argument to the vector at the end.
948: This is done when a space is seen or at the end of the line.
949: If DELETE_ALWAYS is nonzero, the arg is a filename
950: and the file should be deleted eventually.
951: If DELETE_FAILURE is nonzero, the arg is a filename
952: and the file should be deleted if this compilation fails. */
953:
954: static void
955: store_arg (arg, delete_always, delete_failure)
956: char *arg;
957: int delete_always, delete_failure;
958: {
959: if (argbuf_index + 1 == argbuf_length)
960: {
961: argbuf = (char **) xrealloc (argbuf, (argbuf_length *= 2) * sizeof (char *));
962: }
963:
964: argbuf[argbuf_index++] = arg;
965: argbuf[argbuf_index] = 0;
966:
967: if (delete_always || delete_failure)
968: record_temp_file (arg, delete_always, delete_failure);
969: }
970:
971: /* Record the names of temporary files we tell compilers to write,
972: and delete them at the end of the run. */
973:
974: /* This is the common prefix we use to make temp file names.
975: It is chosen once for each run of this program.
976: It is substituted into a spec by %g.
977: Thus, all temp file names contain this prefix.
978: In practice, all temp file names start with this prefix.
979:
980: This prefix comes from the envvar TMPDIR if it is defined;
981: otherwise, from the P_tmpdir macro if that is defined;
982: otherwise, in /usr/tmp or /tmp. */
983:
984: static char *temp_filename;
985:
986: /* Length of the prefix. */
987:
988: static int temp_filename_length;
989:
990: /* Define the list of temporary files to delete. */
991:
992: struct temp_file
993: {
994: char *name;
995: struct temp_file *next;
996: };
997:
998: /* Queue of files to delete on success or failure of compilation. */
999: static struct temp_file *always_delete_queue;
1000: /* Queue of files to delete on failure of compilation. */
1001: static struct temp_file *failure_delete_queue;
1002:
1003: /* Record FILENAME as a file to be deleted automatically.
1004: ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
1005: otherwise delete it in any case.
1006: FAIL_DELETE nonzero means delete it if a compilation step fails;
1007: otherwise delete it in any case. */
1008:
1009: static void
1010: record_temp_file (filename, always_delete, fail_delete)
1011: char *filename;
1012: int always_delete;
1013: int fail_delete;
1014: {
1015: register char *name;
1016: name = xmalloc (strlen (filename) + 1);
1017: strcpy (name, filename);
1018:
1019: if (always_delete)
1020: {
1021: register struct temp_file *temp;
1022: for (temp = always_delete_queue; temp; temp = temp->next)
1023: if (! strcmp (name, temp->name))
1024: goto already1;
1025: temp = (struct temp_file *) xmalloc (sizeof (struct temp_file));
1026: temp->next = always_delete_queue;
1027: temp->name = name;
1028: always_delete_queue = temp;
1029: already1:;
1030: }
1031:
1032: if (fail_delete)
1033: {
1034: register struct temp_file *temp;
1035: for (temp = failure_delete_queue; temp; temp = temp->next)
1036: if (! strcmp (name, temp->name))
1037: goto already2;
1038: temp = (struct temp_file *) xmalloc (sizeof (struct temp_file));
1039: temp->next = failure_delete_queue;
1040: temp->name = name;
1041: failure_delete_queue = temp;
1042: already2:;
1043: }
1044: }
1045:
1046: /* Delete all the temporary files whose names we previously recorded. */
1047:
1048: static void
1049: delete_temp_files ()
1050: {
1051: register struct temp_file *temp;
1052:
1053: for (temp = always_delete_queue; temp; temp = temp->next)
1054: {
1055: #ifdef DEBUG
1056: int i;
1057: printf ("Delete %s? (y or n) ", temp->name);
1058: fflush (stdout);
1059: i = getchar ();
1060: if (i != '\n')
1061: while (getchar () != '\n') ;
1062: if (i == 'y' || i == 'Y')
1063: #endif /* DEBUG */
1064: {
1065: struct stat st;
1066: if (stat (temp->name, &st) >= 0)
1067: {
1068: /* Delete only ordinary files. */
1069: if (S_ISREG (st.st_mode))
1070: if (unlink (temp->name) < 0)
1071: if (verbose_flag)
1072: perror_with_name (temp->name);
1073: }
1074: }
1075: }
1076:
1077: always_delete_queue = 0;
1078: }
1079:
1080: /* Delete all the files to be deleted on error. */
1081:
1082: static void
1083: delete_failure_queue ()
1084: {
1085: register struct temp_file *temp;
1086:
1087: for (temp = failure_delete_queue; temp; temp = temp->next)
1088: {
1089: #ifdef DEBUG
1090: int i;
1091: printf ("Delete %s? (y or n) ", temp->name);
1092: fflush (stdout);
1093: i = getchar ();
1094: if (i != '\n')
1095: while (getchar () != '\n') ;
1096: if (i == 'y' || i == 'Y')
1097: #endif /* DEBUG */
1098: {
1099: if (unlink (temp->name) < 0)
1100: if (verbose_flag)
1101: perror_with_name (temp->name);
1102: }
1103: }
1104: }
1105:
1106: static void
1107: clear_failure_queue ()
1108: {
1109: failure_delete_queue = 0;
1110: }
1111:
1112: /* Compute a string to use as the base of all temporary file names.
1113: It is substituted for %g. */
1114:
1115: static void
1116: choose_temp_base ()
1117: {
1118: char *base = getenv ("TMPDIR");
1119: int len;
1120:
1121: if (base == (char *)0)
1122: {
1123: #ifdef P_tmpdir
1124: if (access (P_tmpdir, R_OK | W_OK) == 0)
1125: base = P_tmpdir;
1126: #endif
1127: if (base == (char *)0)
1128: {
1129: if (access ("/usr/tmp", R_OK | W_OK) == 0)
1130: base = "/usr/tmp/";
1131: else
1132: base = "/tmp/";
1133: }
1134: }
1135:
1136: len = strlen (base);
1137: temp_filename = xmalloc (len + sizeof("/ccXXXXXX"));
1138: strcpy (temp_filename, base);
1139: if (len > 0 && temp_filename[len-1] != '/')
1140: temp_filename[len++] = '/';
1141: strcpy (temp_filename + len, "ccXXXXXX");
1142:
1143: mktemp (temp_filename);
1144: temp_filename_length = strlen (temp_filename);
1.1.1.4 ! root 1145: if (temp_filename_length == 0)
! 1146: abort ();
1.1 root 1147: }
1148:
1.1.1.2 root 1149:
1150: /* Routine to add variables to the environment. We do this to pass
1151: the pathname of the gcc driver, and the directories search to the
1152: collect2 program, which is being run as ld. This way, we can be
1153: sure of executing the right compiler when collect2 wants to build
1154: constructors and destructors. Since the environment variables we
1155: use come from an obstack, we don't have to worry about allocating
1156: space for them. */
1157:
1158: #ifndef HAVE_PUTENV
1159:
1160: putenv (str)
1161: char *str;
1162: {
1163: #ifndef VMS /* nor about VMS */
1164:
1165: extern char **environ;
1166: char **old_environ = environ;
1167: char **envp;
1168: int num_envs = 0;
1169: int name_len = 1;
1170: int str_len = strlen (str);
1171: char *p = str;
1172: int ch;
1173:
1174: while ((ch = *p++) != '\0' && ch != '=')
1175: name_len++;
1176:
1177: if (!ch)
1178: abort ();
1179:
1180: /* Search for replacing an existing environment variable, and
1181: count the number of total environment variables. */
1182: for (envp = old_environ; *envp; envp++)
1183: {
1184: num_envs++;
1185: if (!strncmp (str, *envp, name_len))
1186: {
1187: *envp = str;
1188: return;
1189: }
1190: }
1191:
1192: /* Add a new environment variable */
1193: environ = (char **) xmalloc (sizeof (char *) * (num_envs+2));
1194: *environ = str;
1195: bcopy (old_environ, environ+1, sizeof (char *) * (num_envs+1));
1196:
1197: #endif /* VMS */
1198: }
1199:
1200: #endif /* HAVE_PUTENV */
1201:
1202:
1203: /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables for collect. */
1204:
1205: static void
1206: putenv_from_prefixes (paths, env_var)
1207: struct path_prefix *paths;
1208: char *env_var;
1209: {
1210: int suffix_len = (machine_suffix) ? strlen (machine_suffix) : 0;
1211: int first_time = TRUE;
1212: struct prefix_list *pprefix;
1213:
1214: obstack_grow (&collect_obstack, env_var, strlen (env_var));
1215:
1216: for (pprefix = paths->plist; pprefix != 0; pprefix = pprefix->next)
1217: {
1218: int len = strlen (pprefix->prefix);
1219:
1220: if (machine_suffix)
1221: {
1222: if (!first_time)
1223: obstack_grow (&collect_obstack, ":", 1);
1224:
1225: first_time = FALSE;
1226: obstack_grow (&collect_obstack, pprefix->prefix, len);
1227: obstack_grow (&collect_obstack, machine_suffix, suffix_len);
1228: }
1229:
1.1.1.4 ! root 1230: if (just_machine_suffix && pprefix->require_machine_suffix == 2)
! 1231: {
! 1232: if (!first_time)
! 1233: obstack_grow (&collect_obstack, ":", 1);
! 1234:
! 1235: first_time = FALSE;
! 1236: obstack_grow (&collect_obstack, pprefix->prefix, len);
! 1237: obstack_grow (&collect_obstack, machine_suffix, suffix_len);
! 1238: }
! 1239:
1.1.1.2 root 1240: if (!pprefix->require_machine_suffix)
1241: {
1242: if (!first_time)
1243: obstack_grow (&collect_obstack, ":", 1);
1244:
1245: first_time = FALSE;
1246: obstack_grow (&collect_obstack, pprefix->prefix, len);
1247: }
1248: }
1249: obstack_grow (&collect_obstack, "\0", 1);
1250: putenv (obstack_finish (&collect_obstack));
1251: }
1252:
1253:
1.1 root 1254: /* Search for NAME using the prefix list PREFIXES. MODE is passed to
1255: access to check permissions.
1256: Return 0 if not found, otherwise return its name, allocated with malloc. */
1257:
1258: static char *
1259: find_a_file (pprefix, name, mode)
1260: struct path_prefix *pprefix;
1261: char *name;
1262: int mode;
1263: {
1264: char *temp;
1.1.1.2 root 1265: char *file_suffix = ((mode & X_OK) != 0 ? EXECUTABLE_SUFFIX : "");
1.1 root 1266: struct prefix_list *pl;
1267: int len = pprefix->max_len + strlen (name) + strlen (file_suffix) + 1;
1268:
1269: if (machine_suffix)
1270: len += strlen (machine_suffix);
1271:
1272: temp = xmalloc (len);
1273:
1274: /* Determine the filename to execute (special case for absolute paths). */
1275:
1276: if (*name == '/')
1277: {
1278: if (access (name, mode))
1279: {
1280: strcpy (temp, name);
1281: return temp;
1282: }
1283: }
1284: else
1285: for (pl = pprefix->plist; pl; pl = pl->next)
1286: {
1287: if (machine_suffix)
1288: {
1289: strcpy (temp, pl->prefix);
1290: strcat (temp, machine_suffix);
1291: strcat (temp, name);
1292: if (access (temp, mode) == 0)
1293: {
1294: if (pl->used_flag_ptr != 0)
1295: *pl->used_flag_ptr = 1;
1296: return temp;
1297: }
1298: /* Some systems have a suffix for executable files.
1299: So try appending that. */
1300: if (file_suffix[0] != 0)
1301: {
1302: strcat (temp, file_suffix);
1303: if (access (temp, mode) == 0)
1304: {
1305: if (pl->used_flag_ptr != 0)
1306: *pl->used_flag_ptr = 1;
1307: return temp;
1308: }
1309: }
1310: }
1.1.1.4 ! root 1311: /* Certain prefixes are tried with just the machine type,
! 1312: not the version. This is used for finding as, ld, etc. */
! 1313: if (just_machine_suffix && pl->require_machine_suffix == 2)
! 1314: {
! 1315: strcpy (temp, pl->prefix);
! 1316: strcat (temp, just_machine_suffix);
! 1317: strcat (temp, name);
! 1318: if (access (temp, mode) == 0)
! 1319: {
! 1320: if (pl->used_flag_ptr != 0)
! 1321: *pl->used_flag_ptr = 1;
! 1322: return temp;
! 1323: }
! 1324: /* Some systems have a suffix for executable files.
! 1325: So try appending that. */
! 1326: if (file_suffix[0] != 0)
! 1327: {
! 1328: strcat (temp, file_suffix);
! 1329: if (access (temp, mode) == 0)
! 1330: {
! 1331: if (pl->used_flag_ptr != 0)
! 1332: *pl->used_flag_ptr = 1;
! 1333: return temp;
! 1334: }
! 1335: }
! 1336: }
1.1 root 1337: /* Certain prefixes can't be used without the machine suffix
1338: when the machine or version is explicitly specified. */
1.1.1.2 root 1339: if (!pl->require_machine_suffix)
1.1 root 1340: {
1341: strcpy (temp, pl->prefix);
1342: strcat (temp, name);
1343: if (access (temp, mode) == 0)
1344: {
1345: if (pl->used_flag_ptr != 0)
1346: *pl->used_flag_ptr = 1;
1347: return temp;
1348: }
1349: /* Some systems have a suffix for executable files.
1350: So try appending that. */
1351: if (file_suffix[0] != 0)
1352: {
1353: strcat (temp, file_suffix);
1354: if (access (temp, mode) == 0)
1355: {
1356: if (pl->used_flag_ptr != 0)
1357: *pl->used_flag_ptr = 1;
1358: return temp;
1359: }
1360: }
1361: }
1362: }
1363:
1364: free (temp);
1365: return 0;
1366: }
1367:
1368: /* Add an entry for PREFIX in PLIST. If FIRST is set, it goes
1369: at the start of the list, otherwise it goes at the end.
1370:
1371: If WARN is nonzero, we will warn if no file is found
1372: through this prefix. WARN should point to an int
1.1.1.4 ! root 1373: which will be set to 1 if this entry is used.
! 1374:
! 1375: REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
! 1376: the complete value of machine_suffix.
! 1377: 2 means try both machine_suffix and just_machine_suffix. */
1.1 root 1378:
1379: static void
1380: add_prefix (pprefix, prefix, first, require_machine_suffix, warn)
1381: struct path_prefix *pprefix;
1382: char *prefix;
1383: int first;
1384: int require_machine_suffix;
1385: int *warn;
1386: {
1387: struct prefix_list *pl, **prev;
1388: int len;
1389:
1390: if (!first && pprefix->plist)
1391: {
1392: for (pl = pprefix->plist; pl->next; pl = pl->next)
1393: ;
1394: prev = &pl->next;
1395: }
1396: else
1397: prev = &pprefix->plist;
1398:
1399: /* Keep track of the longest prefix */
1400:
1401: len = strlen (prefix);
1402: if (len > pprefix->max_len)
1403: pprefix->max_len = len;
1404:
1405: pl = (struct prefix_list *) xmalloc (sizeof (struct prefix_list));
1406: pl->prefix = save_string (prefix, len);
1407: pl->require_machine_suffix = require_machine_suffix;
1408: pl->used_flag_ptr = warn;
1409: if (warn)
1410: *warn = 0;
1411:
1412: if (*prev)
1413: pl->next = *prev;
1414: else
1415: pl->next = (struct prefix_list *) 0;
1416: *prev = pl;
1417: }
1418:
1419: /* Print warnings for any prefixes in the list PPREFIX that were not used. */
1420:
1421: static void
1422: unused_prefix_warnings (pprefix)
1423: struct path_prefix *pprefix;
1424: {
1425: struct prefix_list *pl = pprefix->plist;
1426:
1427: while (pl)
1428: {
1429: if (pl->used_flag_ptr != 0 && !*pl->used_flag_ptr)
1430: {
1431: error ("file path prefix `%s' never used",
1432: pl->prefix);
1433: /* Prevent duplicate warnings. */
1434: *pl->used_flag_ptr = 1;
1435: }
1436: pl = pl->next;
1437: }
1438: }
1439:
1440: /* Get rid of all prefixes built up so far in *PLISTP. */
1441:
1442: static void
1443: free_path_prefix (pprefix)
1444: struct path_prefix *pprefix;
1445: {
1446: struct prefix_list *pl = pprefix->plist;
1447: struct prefix_list *temp;
1448:
1449: while (pl)
1450: {
1451: temp = pl;
1452: pl = pl->next;
1453: free (temp->prefix);
1454: free ((char *) temp);
1455: }
1456: pprefix->plist = (struct prefix_list *) 0;
1457: }
1458:
1459: /* stdin file number. */
1460: #define STDIN_FILE_NO 0
1461:
1462: /* stdout file number. */
1463: #define STDOUT_FILE_NO 1
1464:
1465: /* value of `pipe': port index for reading. */
1466: #define READ_PORT 0
1467:
1468: /* value of `pipe': port index for writing. */
1469: #define WRITE_PORT 1
1470:
1471: /* Pipe waiting from last process, to be used as input for the next one.
1472: Value is STDIN_FILE_NO if no pipe is waiting
1473: (i.e. the next command is the first of a group). */
1474:
1475: static int last_pipe_input;
1476:
1477: /* Fork one piped subcommand. FUNC is the system call to use
1478: (either execv or execvp). ARGV is the arg vector to use.
1479: NOT_LAST is nonzero if this is not the last subcommand
1480: (i.e. its output should be piped to the next one.) */
1481:
1.1.1.3 root 1482: #ifndef OS2
1.1 root 1483: #ifdef __MSDOS__
1484:
1485: /* Declare these to avoid compilation error. They won't be called. */
1486: int execv(const char *a, const char **b){}
1487: int execvp(const char *a, const char **b){}
1488:
1489: static int
1.1.1.3 root 1490: pexecute (search_flag, program, argv, not_last)
1491: int search_flag;
1.1 root 1492: char *program;
1493: char *argv[];
1494: int not_last;
1495: {
1496: char *scmd;
1497: FILE *argfile;
1498: int i;
1499:
1.1.1.3 root 1500: scmd = (char *)malloc (strlen (program) + strlen (temp_filename) + 6);
1501: sprintf (scmd, "%s @%s.gp", program, temp_filename);
1502: argfile = fopen (scmd+strlen (program) + 2, "w");
1.1 root 1503: if (argfile == 0)
1.1.1.3 root 1504: pfatal_with_name (scmd + strlen (program) + 2);
1.1 root 1505:
1506: for (i=1; argv[i]; i++)
1.1.1.3 root 1507: {
1508: char *cp;
1509: for (cp = argv[i]; *cp; cp++)
1510: {
1511: if (*cp == '"' || *cp == '\'' || *cp == '\\' || isspace (*cp))
1512: fputc ('\\', argfile);
1513: fputc (*cp, argfile);
1514: }
1515: fputc ('\n', argfile);
1516: }
1517: fclose (argfile);
1.1 root 1518:
1.1.1.3 root 1519: i = system (scmd);
1.1 root 1520:
1.1.1.3 root 1521: remove (scmd + strlen (program) + 2);
1.1 root 1522: return i << 8;
1523: }
1524:
1525: #else /* not __MSDOS__ */
1526:
1527: static int
1.1.1.3 root 1528: pexecute (search_flag, program, argv, not_last)
1529: int search_flag;
1.1 root 1530: char *program;
1531: char *argv[];
1532: int not_last;
1533: {
1.1.1.3 root 1534: int (*func)() = (search_flag ? execv : execvp);
1.1 root 1535: int pid;
1536: int pdes[2];
1537: int input_desc = last_pipe_input;
1538: int output_desc = STDOUT_FILE_NO;
1539: int retries, sleep_interval;
1540:
1541: /* If this isn't the last process, make a pipe for its output,
1542: and record it as waiting to be the input to the next process. */
1543:
1544: if (not_last)
1545: {
1546: if (pipe (pdes) < 0)
1547: pfatal_with_name ("pipe");
1548: output_desc = pdes[WRITE_PORT];
1549: last_pipe_input = pdes[READ_PORT];
1550: }
1551: else
1552: last_pipe_input = STDIN_FILE_NO;
1553:
1554: /* Fork a subprocess; wait and retry if it fails. */
1555: sleep_interval = 1;
1556: for (retries = 0; retries < 4; retries++)
1557: {
1558: pid = vfork ();
1559: if (pid >= 0)
1560: break;
1561: sleep (sleep_interval);
1562: sleep_interval *= 2;
1563: }
1564:
1565: switch (pid)
1566: {
1567: case -1:
1568: #ifdef vfork
1569: pfatal_with_name ("fork");
1570: #else
1571: pfatal_with_name ("vfork");
1572: #endif
1573: /* NOTREACHED */
1574: return 0;
1575:
1576: case 0: /* child */
1577: /* Move the input and output pipes into place, if nec. */
1578: if (input_desc != STDIN_FILE_NO)
1579: {
1580: close (STDIN_FILE_NO);
1581: dup (input_desc);
1582: close (input_desc);
1583: }
1584: if (output_desc != STDOUT_FILE_NO)
1585: {
1586: close (STDOUT_FILE_NO);
1587: dup (output_desc);
1588: close (output_desc);
1589: }
1590:
1591: /* Close the parent's descs that aren't wanted here. */
1592: if (last_pipe_input != STDIN_FILE_NO)
1593: close (last_pipe_input);
1594:
1595: /* Exec the program. */
1596: (*func) (program, argv);
1597: perror_exec (program);
1598: exit (-1);
1599: /* NOTREACHED */
1600: return 0;
1601:
1602: default:
1603: /* In the parent, after forking.
1604: Close the descriptors that we made for this child. */
1605: if (input_desc != STDIN_FILE_NO)
1606: close (input_desc);
1607: if (output_desc != STDOUT_FILE_NO)
1608: close (output_desc);
1609:
1610: /* Return child's process number. */
1611: return pid;
1612: }
1613: }
1614:
1615: #endif /* not __MSDOS__ */
1.1.1.3 root 1616: #else /* not OS2 */
1617:
1618: static int
1619: pexecute (search_flag, program, argv, not_last)
1620: int search_flag;
1621: char *program;
1622: char *argv[];
1623: int not_last;
1624: {
1625: return (search_flag ? spawnv : spawnvp) (1, program, argv);
1626: }
1627: #endif /* not OS2 */
1.1 root 1628:
1629: /* Execute the command specified by the arguments on the current line of spec.
1630: When using pipes, this includes several piped-together commands
1631: with `|' between them.
1632:
1633: Return 0 if successful, -1 if failed. */
1634:
1635: static int
1636: execute ()
1637: {
1638: int i;
1639: int n_commands; /* # of command. */
1640: char *string;
1641: struct command
1642: {
1643: char *prog; /* program name. */
1644: char **argv; /* vector of args. */
1645: int pid; /* pid of process for this command. */
1646: };
1647:
1648: struct command *commands; /* each command buffer with above info. */
1649:
1650: /* Count # of piped commands. */
1651: for (n_commands = 1, i = 0; i < argbuf_index; i++)
1652: if (strcmp (argbuf[i], "|") == 0)
1653: n_commands++;
1654:
1655: /* Get storage for each command. */
1656: commands
1657: = (struct command *) alloca (n_commands * sizeof (struct command));
1658:
1659: /* Split argbuf into its separate piped processes,
1660: and record info about each one.
1661: Also search for the programs that are to be run. */
1662:
1663: commands[0].prog = argbuf[0]; /* first command. */
1664: commands[0].argv = &argbuf[0];
1665: string = find_a_file (&exec_prefix, commands[0].prog, X_OK);
1666: if (string)
1667: commands[0].argv[0] = string;
1668:
1669: for (n_commands = 1, i = 0; i < argbuf_index; i++)
1670: if (strcmp (argbuf[i], "|") == 0)
1671: { /* each command. */
1672: #ifdef __MSDOS__
1673: fatal ("-pipe not supported under MS-DOS");
1674: #endif
1675: argbuf[i] = 0; /* termination of command args. */
1676: commands[n_commands].prog = argbuf[i + 1];
1677: commands[n_commands].argv = &argbuf[i + 1];
1678: string = find_a_file (&exec_prefix, commands[n_commands].prog, X_OK);
1679: if (string)
1680: commands[n_commands].argv[0] = string;
1681: n_commands++;
1682: }
1683:
1684: argbuf[argbuf_index] = 0;
1685:
1686: /* If -v, print what we are about to do, and maybe query. */
1687:
1688: if (verbose_flag)
1689: {
1690: /* Print each piped command as a separate line. */
1691: for (i = 0; i < n_commands ; i++)
1692: {
1693: char **j;
1694:
1695: for (j = commands[i].argv; *j; j++)
1696: fprintf (stderr, " %s", *j);
1697:
1698: /* Print a pipe symbol after all but the last command. */
1699: if (i + 1 != n_commands)
1700: fprintf (stderr, " |");
1701: fprintf (stderr, "\n");
1702: }
1703: fflush (stderr);
1704: #ifdef DEBUG
1705: fprintf (stderr, "\nGo ahead? (y or n) ");
1706: fflush (stderr);
1707: i = getchar ();
1708: if (i != '\n')
1709: while (getchar () != '\n') ;
1710: if (i != 'y' && i != 'Y')
1711: return 0;
1712: #endif /* DEBUG */
1713: }
1714:
1715: /* Run each piped subprocess. */
1716:
1717: last_pipe_input = STDIN_FILE_NO;
1718: for (i = 0; i < n_commands; i++)
1719: {
1720: char *string = commands[i].argv[0];
1721:
1.1.1.3 root 1722: commands[i].pid = pexecute (string != commands[i].prog,
1.1 root 1723: string, commands[i].argv,
1724: i + 1 < n_commands);
1725:
1726: if (string != commands[i].prog)
1727: free (string);
1728: }
1729:
1730: execution_count++;
1731:
1732: /* Wait for all the subprocesses to finish.
1733: We don't care what order they finish in;
1734: we know that N_COMMANDS waits will get them all. */
1735:
1736: {
1737: int ret_code = 0;
1738:
1739: for (i = 0; i < n_commands; i++)
1740: {
1741: int status;
1742: int pid;
1743: char *prog;
1744:
1745: #ifdef __MSDOS__
1746: status = pid = commands[i].pid;
1747: #else
1748: pid = wait (&status);
1749: #endif
1750: if (pid < 0)
1751: abort ();
1752:
1753: if (status != 0)
1754: {
1755: int j;
1756: for (j = 0; j < n_commands; j++)
1757: if (commands[j].pid == pid)
1758: prog = commands[j].prog;
1759:
1760: if ((status & 0x7F) != 0)
1.1.1.4 ! root 1761: {
! 1762: fatal ("Internal compiler error: program %s got fatal signal %d",
! 1763: prog, (status & 0x7F));
! 1764: signal_count++;
! 1765: }
1.1 root 1766: if (((status & 0xFF00) >> 8) >= MIN_FATAL_STATUS)
1767: ret_code = -1;
1768: }
1769: }
1770: return ret_code;
1771: }
1772: }
1773:
1774: /* Find all the switches given to us
1775: and make a vector describing them.
1776: The elements of the vector are strings, one per switch given.
1777: If a switch uses following arguments, then the `part1' field
1778: is the switch itself and the `args' field
1779: is a null-terminated vector containing the following arguments.
1780: The `valid' field is nonzero if any spec has looked at this switch;
1781: if it remains zero at the end of the run, it must be meaningless. */
1782:
1783: struct switchstr
1784: {
1785: char *part1;
1786: char **args;
1787: int valid;
1788: };
1789:
1790: static struct switchstr *switches;
1791:
1792: static int n_switches;
1793:
1794: struct infile
1795: {
1796: char *name;
1797: char *language;
1798: };
1799:
1800: /* Also a vector of input files specified. */
1801:
1802: static struct infile *infiles;
1803:
1804: static int n_infiles;
1805:
1806: /* And a vector of corresponding output files is made up later. */
1807:
1808: static char **outfiles;
1809:
1810: /* Create the vector `switches' and its contents.
1811: Store its length in `n_switches'. */
1812:
1813: static void
1814: process_command (argc, argv)
1815: int argc;
1816: char **argv;
1817: {
1818: register int i;
1819: char *temp;
1820: char *spec_lang = 0;
1821: int last_language_n_infiles;
1822:
1.1.1.3 root 1823: gcc_exec_prefix = getenv ("GCC_EXEC_PREFIX");
1824:
1.1 root 1825: n_switches = 0;
1826: n_infiles = 0;
1.1.1.4 ! root 1827:
! 1828: /* Default for -V is our version number, ending at first space. */
! 1829: spec_version = save_string (version_string, strlen (version_string));
! 1830: for (temp = spec_version; *temp && *temp != ' '; temp++);
! 1831: if (*temp) *temp = '\0';
1.1 root 1832:
1833: /* Set up the default search paths. */
1834:
1.1.1.3 root 1835: if (gcc_exec_prefix)
1.1 root 1836: {
1.1.1.4 ! root 1837: add_prefix (&exec_prefix, gcc_exec_prefix, 0, 0, NULL_PTR);
! 1838: add_prefix (&startfile_prefix, gcc_exec_prefix, 0, 0, NULL_PTR);
1.1 root 1839: }
1840:
1841: /* COMPILER_PATH and LIBRARY_PATH have values
1842: that are lists of directory names with colons. */
1843:
1844: temp = getenv ("COMPILER_PATH");
1845: if (temp)
1846: {
1847: char *startp, *endp;
1848: char *nstore = (char *) alloca (strlen (temp) + 3);
1849:
1850: startp = endp = temp;
1851: while (1)
1852: {
1.1.1.3 root 1853: if (*endp == PATH_SEPARATOR || *endp == 0)
1.1 root 1854: {
1855: strncpy (nstore, startp, endp-startp);
1856: if (endp == startp)
1857: {
1858: strcpy (nstore, "./");
1859: }
1860: else if (endp[-1] != '/')
1861: {
1862: nstore[endp-startp] = '/';
1863: nstore[endp-startp+1] = 0;
1864: }
1865: else
1866: nstore[endp-startp] = 0;
1.1.1.4 ! root 1867: add_prefix (&exec_prefix, nstore, 0, 0, NULL_PTR);
1.1 root 1868: if (*endp == 0)
1869: break;
1870: endp = startp = endp + 1;
1871: }
1872: else
1873: endp++;
1874: }
1875: }
1876:
1877: temp = getenv ("LIBRARY_PATH");
1878: if (temp)
1879: {
1880: char *startp, *endp;
1881: char *nstore = (char *) alloca (strlen (temp) + 3);
1882:
1883: startp = endp = temp;
1884: while (1)
1885: {
1.1.1.3 root 1886: if (*endp == PATH_SEPARATOR || *endp == 0)
1.1 root 1887: {
1888: strncpy (nstore, startp, endp-startp);
1889: if (endp == startp)
1890: {
1891: strcpy (nstore, "./");
1892: }
1893: else if (endp[-1] != '/')
1894: {
1895: nstore[endp-startp] = '/';
1896: nstore[endp-startp+1] = 0;
1897: }
1898: else
1899: nstore[endp-startp] = 0;
1.1.1.4 ! root 1900: add_prefix (&startfile_prefix, nstore, 0, 0, NULL_PTR);
1.1 root 1901: /* Make separate list of dirs that came from LIBRARY_PATH. */
1.1.1.4 ! root 1902: add_prefix (&library_prefix, nstore, 0, 0, NULL_PTR);
1.1 root 1903: if (*endp == 0)
1904: break;
1905: endp = startp = endp + 1;
1906: }
1907: else
1908: endp++;
1909: }
1910: }
1911:
1912: /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
1913: temp = getenv ("LPATH");
1914: if (temp)
1915: {
1916: char *startp, *endp;
1917: char *nstore = (char *) alloca (strlen (temp) + 3);
1918:
1919: startp = endp = temp;
1920: while (1)
1921: {
1.1.1.3 root 1922: if (*endp == PATH_SEPARATOR || *endp == 0)
1.1 root 1923: {
1924: strncpy (nstore, startp, endp-startp);
1925: if (endp == startp)
1926: {
1927: strcpy (nstore, "./");
1928: }
1929: else if (endp[-1] != '/')
1930: {
1931: nstore[endp-startp] = '/';
1932: nstore[endp-startp+1] = 0;
1933: }
1934: else
1935: nstore[endp-startp] = 0;
1.1.1.4 ! root 1936: add_prefix (&startfile_prefix, nstore, 0, 0, NULL_PTR);
1.1 root 1937: /* Make separate list of dirs that came from LIBRARY_PATH. */
1.1.1.4 ! root 1938: add_prefix (&library_prefix, nstore, 0, 0, NULL_PTR);
1.1 root 1939: if (*endp == 0)
1940: break;
1941: endp = startp = endp + 1;
1942: }
1943: else
1944: endp++;
1945: }
1946: }
1947:
1948: /* Scan argv twice. Here, the first time, just count how many switches
1949: there will be in their vector, and how many input files in theirs.
1950: Here we also parse the switches that cc itself uses (e.g. -v). */
1951:
1952: for (i = 1; i < argc; i++)
1953: {
1954: if (! strcmp (argv[i], "-dumpspecs"))
1955: {
1956: printf ("*asm:\n%s\n\n", asm_spec);
1957: printf ("*asm_final:\n%s\n\n", asm_final_spec);
1958: printf ("*cpp:\n%s\n\n", cpp_spec);
1959: printf ("*cc1:\n%s\n\n", cc1_spec);
1960: printf ("*cc1plus:\n%s\n\n", cc1plus_spec);
1961: printf ("*endfile:\n%s\n\n", endfile_spec);
1962: printf ("*link:\n%s\n\n", link_spec);
1963: printf ("*lib:\n%s\n\n", lib_spec);
1964: printf ("*startfile:\n%s\n\n", startfile_spec);
1965: printf ("*switches_need_spaces:\n%s\n\n", switches_need_spaces);
1966: printf ("*signed_char:\n%s\n\n", signed_char_spec);
1967: printf ("*predefines:\n%s\n\n", cpp_predefines);
1.1.1.2 root 1968: printf ("*cross_compile:\n%d\n\n", cross_compile);
1.1 root 1969:
1970: exit (0);
1971: }
1972: else if (! strcmp (argv[i], "-dumpversion"))
1973: {
1974: printf ("%s\n", version_string);
1975: exit (0);
1976: }
1.1.1.3 root 1977: else if (! strcmp (argv[i], "-print-libgcc-file-name"))
1978: {
1979: print_libgcc_file_name = 1;
1980: }
1.1 root 1981: else if (! strcmp (argv[i], "-Xlinker"))
1982: {
1983: /* Pass the argument of this option to the linker when we link. */
1984:
1985: if (i + 1 == argc)
1986: fatal ("argument to `-Xlinker' is missing");
1987:
1988: n_linker_options++;
1989: if (!linker_options)
1990: linker_options
1991: = (char **) xmalloc (n_linker_options * sizeof (char **));
1992: else
1993: linker_options
1994: = (char **) xrealloc (linker_options,
1995: n_linker_options * sizeof (char **));
1996:
1997: linker_options[n_linker_options - 1] = argv[++i];
1998: }
1.1.1.4 ! root 1999: else if (! strncmp (argv[i], "-Wl,", 4))
! 2000: {
! 2001: int prev, j;
! 2002: /* Pass the rest of this option to the linker when we link. */
! 2003:
! 2004: n_linker_options++;
! 2005: if (!linker_options)
! 2006: linker_options
! 2007: = (char **) xmalloc (n_linker_options * sizeof (char **));
! 2008: else
! 2009: linker_options
! 2010: = (char **) xrealloc (linker_options,
! 2011: n_linker_options * sizeof (char **));
! 2012:
! 2013: /* Split the argument at commas. */
! 2014: prev = 4;
! 2015: for (j = 4; argv[i][j]; j++)
! 2016: if (argv[i][j] == ',')
! 2017: {
! 2018: linker_options[n_linker_options - 1]
! 2019: = save_string (argv[i] + prev, j - prev);
! 2020: n_linker_options++;
! 2021: linker_options
! 2022: = (char **) xrealloc (linker_options,
! 2023: n_linker_options * sizeof (char **));
! 2024: prev = j + 1;
! 2025: }
! 2026: /* Record the part after the last comma. */
! 2027: linker_options[n_linker_options - 1] = argv[i] + prev;
! 2028: }
! 2029: else if (! strncmp (argv[i], "-Wa,", 4))
! 2030: {
! 2031: int prev, j;
! 2032: /* Pass the rest of this option to the assembler. */
! 2033:
! 2034: n_assembler_options++;
! 2035: if (!assembler_options)
! 2036: assembler_options
! 2037: = (char **) xmalloc (n_assembler_options * sizeof (char **));
! 2038: else
! 2039: assembler_options
! 2040: = (char **) xrealloc (assembler_options,
! 2041: n_assembler_options * sizeof (char **));
! 2042:
! 2043: /* Split the argument at commas. */
! 2044: prev = 4;
! 2045: for (j = 4; argv[i][j]; j++)
! 2046: if (argv[i][j] == ',')
! 2047: {
! 2048: assembler_options[n_assembler_options - 1]
! 2049: = save_string (argv[i] + prev, j - prev);
! 2050: n_assembler_options++;
! 2051: assembler_options
! 2052: = (char **) xrealloc (assembler_options,
! 2053: n_assembler_options * sizeof (char **));
! 2054: prev = j + 1;
! 2055: }
! 2056: /* Record the part after the last comma. */
! 2057: assembler_options[n_assembler_options - 1] = argv[i] + prev;
! 2058: }
! 2059: else if (argv[i][0] == '+' && argv[i][1] == 'e')
! 2060: /* Compensate for the +e options to the C++ front-end. */
! 2061: n_switches++;
1.1 root 2062: else if (argv[i][0] == '-' && argv[i][1] != 0 && argv[i][1] != 'l')
2063: {
2064: register char *p = &argv[i][1];
2065: register int c = *p;
2066:
2067: switch (c)
2068: {
2069: case 'b':
2070: if (p[1] == 0 && i + 1 == argc)
2071: fatal ("argument to `-b' is missing");
2072: if (p[1] == 0)
2073: spec_machine = argv[++i];
2074: else
2075: spec_machine = p + 1;
2076: break;
2077:
2078: case 'B':
2079: {
2080: int *temp = (int *) xmalloc (sizeof (int));
2081: char *value;
2082: if (p[1] == 0 && i + 1 == argc)
2083: fatal ("argument to `-B' is missing");
2084: if (p[1] == 0)
2085: value = argv[++i];
2086: else
2087: value = p + 1;
2088: add_prefix (&exec_prefix, value, 1, 0, temp);
2089: add_prefix (&startfile_prefix, value, 1, 0, temp);
2090: }
2091: break;
2092:
2093: case 'v': /* Print our subcommands and print versions. */
2094: n_switches++;
1.1.1.4 ! root 2095: /* If they do anything other than exactly `-v', don't set
! 2096: verbose_flag; rather, continue on to give the error. */
! 2097: if (p[1] != 0)
! 2098: break;
! 2099: verbose_flag++;
1.1 root 2100: break;
2101:
2102: case 'V':
2103: if (p[1] == 0 && i + 1 == argc)
2104: fatal ("argument to `-V' is missing");
2105: if (p[1] == 0)
2106: spec_version = argv[++i];
2107: else
2108: spec_version = p + 1;
2109: break;
2110:
2111: case 's':
2112: if (!strcmp (p, "save-temps"))
2113: {
2114: save_temps_flag = 1;
1.1.1.3 root 2115: n_switches++;
1.1 root 2116: break;
2117: }
2118: default:
2119: n_switches++;
2120:
2121: if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
2122: i += SWITCH_TAKES_ARG (c) - (p[1] != 0);
2123: else if (WORD_SWITCH_TAKES_ARG (p))
2124: i += WORD_SWITCH_TAKES_ARG (p);
2125: }
2126: }
2127: else
2128: n_infiles++;
2129: }
2130:
2131: /* Set up the search paths before we go looking for config files. */
2132:
2133: /* These come before the md prefixes so that we will find gcc's subcommands
2134: (such as cpp) rather than those of the host system. */
1.1.1.4 ! root 2135: /* Use 2 as fourth arg meaning try just the machine as a suffix,
! 2136: as well as trying the machine and the version. */
! 2137: add_prefix (&exec_prefix, standard_exec_prefix, 0, 2, NULL_PTR);
! 2138: add_prefix (&exec_prefix, standard_exec_prefix_1, 0, 2, NULL_PTR);
1.1 root 2139:
1.1.1.4 ! root 2140: add_prefix (&startfile_prefix, standard_exec_prefix, 0, 1, NULL_PTR);
! 2141: add_prefix (&startfile_prefix, standard_exec_prefix_1, 0, 1, NULL_PTR);
1.1 root 2142:
1.1.1.2 root 2143: /* More prefixes are enabled in main, after we read the specs file
2144: and determine whether this is cross-compilation or not. */
1.1 root 2145:
2146:
2147: /* Then create the space for the vectors and scan again. */
2148:
2149: switches = ((struct switchstr *)
2150: xmalloc ((n_switches + 1) * sizeof (struct switchstr)));
2151: infiles = (struct infile *) xmalloc ((n_infiles + 1) * sizeof (struct infile));
2152: n_switches = 0;
2153: n_infiles = 0;
2154: last_language_n_infiles = -1;
2155:
2156: /* This, time, copy the text of each switch and store a pointer
2157: to the copy in the vector of switches.
2158: Store all the infiles in their vector. */
2159:
2160: for (i = 1; i < argc; i++)
2161: {
1.1.1.4 ! root 2162: /* Just skip the switches that were handled by the preceding loop. */
1.1 root 2163: if (!strcmp (argv[i], "-Xlinker"))
2164: i++;
1.1.1.4 ! root 2165: else if (! strncmp (argv[i], "-Wl,", 4))
! 2166: ;
! 2167: else if (! strncmp (argv[i], "-Wa,", 4))
! 2168: ;
1.1.1.3 root 2169: else if (! strcmp (argv[i], "-print-libgcc-file-name"))
1.1.1.4 ! root 2170: ;
! 2171: else if (argv[i][0] == '+' && argv[i][1] == 'e')
! 2172: {
! 2173: /* Compensate for the +e options to the C++ front-end;
! 2174: they're there simply for cfront call-compatability. We do
! 2175: some magic in default_compilers to pass them down properly.
! 2176: Note we deliberately start at the `+' here, to avoid passing
! 2177: -e0 or -e1 down into the linker. */
! 2178: switches[n_switches].part1 = &argv[i][0];
! 2179: switches[n_switches].args = 0;
! 2180: switches[n_switches].valid = 0;
! 2181: n_switches++;
! 2182: }
1.1 root 2183: else if (argv[i][0] == '-' && argv[i][1] != 0 && argv[i][1] != 'l')
2184: {
2185: register char *p = &argv[i][1];
2186: register int c = *p;
2187:
2188: if (c == 'B' || c == 'b' || c == 'V')
2189: {
2190: /* Skip a separate arg, if any. */
2191: if (p[1] == 0)
2192: i++;
2193: continue;
2194: }
2195: if (c == 'x')
2196: {
2197: if (p[1] == 0 && i + 1 == argc)
2198: fatal ("argument to `-x' is missing");
2199: if (p[1] == 0)
2200: spec_lang = argv[++i];
2201: else
2202: spec_lang = p + 1;
2203: if (! strcmp (spec_lang, "none"))
2204: /* Suppress the warning if -xnone comes after the last input file,
2205: because alternate command interfaces like g++ might find it
2206: useful to place -xnone after each input file. */
2207: spec_lang = 0;
2208: else
2209: last_language_n_infiles = n_infiles;
2210: continue;
2211: }
2212: switches[n_switches].part1 = p;
2213: /* Deal with option arguments in separate argv elements. */
2214: if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
2215: || WORD_SWITCH_TAKES_ARG (p)) {
2216: int j = 0;
2217: int n_args = WORD_SWITCH_TAKES_ARG (p);
2218:
2219: if (n_args == 0) {
2220: /* Count only the option arguments in separate argv elements. */
2221: n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
2222: }
1.1.1.4 ! root 2223: if (i + n_args >= argc)
! 2224: fatal ("argument to `-%s' is missing", p);
1.1 root 2225: switches[n_switches].args
2226: = (char **) xmalloc ((n_args + 1) * sizeof (char *));
2227: while (j < n_args)
2228: switches[n_switches].args[j++] = argv[++i];
2229: /* Null-terminate the vector. */
2230: switches[n_switches].args[j] = 0;
2231: } else if (*switches_need_spaces != 0 && (c == 'o' || c == 'L')) {
2232: /* On some systems, ld cannot handle -o or -L without space.
2233: So split the -o or -L from its argument. */
2234: switches[n_switches].part1 = (c == 'o' ? "o" : "L");
2235: switches[n_switches].args = (char **) xmalloc (2 * sizeof (char *));
2236: switches[n_switches].args[0] = xmalloc (strlen (p));
2237: strcpy (switches[n_switches].args[0], &p[1]);
2238: switches[n_switches].args[1] = 0;
2239: } else
2240: switches[n_switches].args = 0;
2241: switches[n_switches].valid = 0;
2242: /* This is always valid, since gcc.c itself understands it. */
2243: if (!strcmp (p, "save-temps"))
2244: switches[n_switches].valid = 1;
2245: n_switches++;
2246: }
2247: else
2248: {
2249: infiles[n_infiles].language = spec_lang;
2250: infiles[n_infiles++].name = argv[i];
2251: }
2252: }
2253:
2254: if (n_infiles == last_language_n_infiles)
2255: error ("Warning: `-x %s' after last input file has no effect", spec_lang);
2256:
2257: switches[n_switches].part1 = 0;
2258: infiles[n_infiles].name = 0;
1.1.1.3 root 2259:
2260: /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
2261: if (gcc_exec_prefix)
2262: {
2263: temp = (char *) xmalloc (strlen (gcc_exec_prefix) + strlen (spec_version)
2264: + strlen (spec_machine) + 3);
2265: strcpy (temp, gcc_exec_prefix);
2266: strcat (temp, spec_machine);
2267: strcat (temp, "/");
2268: strcat (temp, spec_version);
2269: strcat (temp, "/");
2270: gcc_exec_prefix = temp;
2271: }
1.1 root 2272: }
2273:
2274: /* Process a spec string, accumulating and running commands. */
2275:
2276: /* These variables describe the input file name.
2277: input_file_number is the index on outfiles of this file,
2278: so that the output file name can be stored for later use by %o.
2279: input_basename is the start of the part of the input file
2280: sans all directory names, and basename_length is the number
2281: of characters starting there excluding the suffix .c or whatever. */
2282:
2283: static char *input_filename;
2284: static int input_file_number;
2285: static int input_filename_length;
2286: static int basename_length;
2287: static char *input_basename;
2288: static char *input_suffix;
2289:
2290: /* These are variables used within do_spec and do_spec_1. */
2291:
2292: /* Nonzero if an arg has been started and not yet terminated
2293: (with space, tab or newline). */
2294: static int arg_going;
2295:
2296: /* Nonzero means %d or %g has been seen; the next arg to be terminated
2297: is a temporary file name. */
2298: static int delete_this_arg;
2299:
2300: /* Nonzero means %w has been seen; the next arg to be terminated
2301: is the output file name of this compilation. */
2302: static int this_is_output_file;
2303:
2304: /* Nonzero means %s has been seen; the next arg to be terminated
2305: is the name of a library file and we should try the standard
2306: search dirs for it. */
2307: static int this_is_library_file;
2308:
2309: /* Process the spec SPEC and run the commands specified therein.
2310: Returns 0 if the spec is successfully processed; -1 if failed. */
2311:
2312: static int
2313: do_spec (spec)
2314: char *spec;
2315: {
2316: int value;
2317:
2318: clear_args ();
2319: arg_going = 0;
2320: delete_this_arg = 0;
2321: this_is_output_file = 0;
2322: this_is_library_file = 0;
2323:
1.1.1.4 ! root 2324: value = do_spec_1 (spec, 0, NULL_PTR);
1.1 root 2325:
2326: /* Force out any unfinished command.
2327: If -pipe, this forces out the last command if it ended in `|'. */
2328: if (value == 0)
2329: {
2330: if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
2331: argbuf_index--;
2332:
2333: if (argbuf_index > 0)
2334: value = execute ();
2335: }
2336:
2337: return value;
2338: }
2339:
2340: /* Process the sub-spec SPEC as a portion of a larger spec.
2341: This is like processing a whole spec except that we do
2342: not initialize at the beginning and we do not supply a
2343: newline by default at the end.
2344: INSWITCH nonzero means don't process %-sequences in SPEC;
2345: in this case, % is treated as an ordinary character.
2346: This is used while substituting switches.
2347: INSWITCH nonzero also causes SPC not to terminate an argument.
2348:
2349: Value is zero unless a line was finished
2350: and the command on that line reported an error. */
2351:
2352: static int
2353: do_spec_1 (spec, inswitch, soft_matched_part)
2354: char *spec;
2355: int inswitch;
2356: char *soft_matched_part;
2357: {
2358: register char *p = spec;
2359: register int c;
2360: int i;
2361: char *string;
2362:
2363: while (c = *p++)
2364: /* If substituting a switch, treat all chars like letters.
2365: Otherwise, NL, SPC, TAB and % are special. */
2366: switch (inswitch ? 'a' : c)
2367: {
2368: case '\n':
2369: /* End of line: finish any pending argument,
2370: then run the pending command if one has been started. */
2371: if (arg_going)
2372: {
2373: obstack_1grow (&obstack, 0);
2374: string = obstack_finish (&obstack);
2375: if (this_is_library_file)
2376: string = find_file (string);
2377: store_arg (string, delete_this_arg, this_is_output_file);
2378: if (this_is_output_file)
2379: outfiles[input_file_number] = string;
2380: }
2381: arg_going = 0;
2382:
2383: if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
2384: {
2385: int i;
2386: for (i = 0; i < n_switches; i++)
2387: if (!strcmp (switches[i].part1, "pipe"))
2388: break;
2389:
2390: /* A `|' before the newline means use a pipe here,
2391: but only if -pipe was specified.
2392: Otherwise, execute now and don't pass the `|' as an arg. */
2393: if (i < n_switches)
2394: {
2395: switches[i].valid = 1;
2396: break;
2397: }
2398: else
2399: argbuf_index--;
2400: }
2401:
2402: if (argbuf_index > 0)
2403: {
2404: int value = execute ();
2405: if (value)
2406: return value;
2407: }
2408: /* Reinitialize for a new command, and for a new argument. */
2409: clear_args ();
2410: arg_going = 0;
2411: delete_this_arg = 0;
2412: this_is_output_file = 0;
2413: this_is_library_file = 0;
2414: break;
2415:
2416: case '|':
2417: /* End any pending argument. */
2418: if (arg_going)
2419: {
2420: obstack_1grow (&obstack, 0);
2421: string = obstack_finish (&obstack);
2422: if (this_is_library_file)
2423: string = find_file (string);
2424: store_arg (string, delete_this_arg, this_is_output_file);
2425: if (this_is_output_file)
2426: outfiles[input_file_number] = string;
2427: }
2428:
2429: /* Use pipe */
2430: obstack_1grow (&obstack, c);
2431: arg_going = 1;
2432: break;
2433:
2434: case '\t':
2435: case ' ':
2436: /* Space or tab ends an argument if one is pending. */
2437: if (arg_going)
2438: {
2439: obstack_1grow (&obstack, 0);
2440: string = obstack_finish (&obstack);
2441: if (this_is_library_file)
2442: string = find_file (string);
2443: store_arg (string, delete_this_arg, this_is_output_file);
2444: if (this_is_output_file)
2445: outfiles[input_file_number] = string;
2446: }
2447: /* Reinitialize for a new argument. */
2448: arg_going = 0;
2449: delete_this_arg = 0;
2450: this_is_output_file = 0;
2451: this_is_library_file = 0;
2452: break;
2453:
2454: case '%':
2455: switch (c = *p++)
2456: {
2457: case 0:
2458: fatal ("Invalid specification! Bug in cc.");
2459:
2460: case 'b':
2461: obstack_grow (&obstack, input_basename, basename_length);
2462: arg_going = 1;
2463: break;
2464:
2465: case 'd':
2466: delete_this_arg = 2;
2467: break;
2468:
2469: /* Dump out the directories specified with LIBRARY_PATH,
2470: followed by the absolute directories
2471: that we search for startfiles. */
2472: case 'D':
2473: for (i = 0; i < 2; i++)
2474: {
2475: struct prefix_list *pl
2476: = (i == 0 ? library_prefix.plist : startfile_prefix.plist);
1.1.1.3 root 2477: int bufsize = 100;
2478: char *buffer = (char *) xmalloc (bufsize);
2479: int idx;
2480:
1.1 root 2481: for (; pl; pl = pl->next)
2482: {
2483: #ifdef RELATIVE_PREFIX_NOT_LINKDIR
2484: /* Used on systems which record the specified -L dirs
2485: and use them to search for dynamic linking. */
2486: /* Relative directories always come from -B,
2487: and it is better not to use them for searching
2488: at run time. In particular, stage1 loses */
2489: if (pl->prefix[0] != '/')
2490: continue;
2491: #endif
2492: if (machine_suffix)
2493: {
2494: if (is_linker_dir (pl->prefix, machine_suffix))
2495: {
1.1.1.4 ! root 2496: do_spec_1 ("-L", 0, NULL_PTR);
1.1 root 2497: #ifdef SPACE_AFTER_L_OPTION
1.1.1.4 ! root 2498: do_spec_1 (" ", 0, NULL_PTR);
1.1 root 2499: #endif
1.1.1.4 ! root 2500: do_spec_1 (pl->prefix, 1, NULL_PTR);
1.1.1.3 root 2501: /* Remove slash from machine_suffix. */
2502: if (strlen (machine_suffix) >= bufsize)
2503: bufsize = strlen (machine_suffix) * 2 + 1;
2504: buffer = (char *) xrealloc (buffer, bufsize);
2505: strcpy (buffer, machine_suffix);
2506: idx = strlen (buffer);
2507: if (buffer[idx - 1] == '/')
2508: buffer[idx - 1] = 0;
1.1.1.4 ! root 2509: do_spec_1 (buffer, 1, NULL_PTR);
1.1 root 2510: /* Make this a separate argument. */
1.1.1.4 ! root 2511: do_spec_1 (" ", 0, NULL_PTR);
1.1 root 2512: }
2513: }
1.1.1.2 root 2514: if (!pl->require_machine_suffix)
1.1 root 2515: {
2516: if (is_linker_dir (pl->prefix, ""))
2517: {
1.1.1.4 ! root 2518: do_spec_1 ("-L", 0, NULL_PTR);
1.1 root 2519: #ifdef SPACE_AFTER_L_OPTION
1.1.1.4 ! root 2520: do_spec_1 (" ", 0, NULL_PTR);
1.1 root 2521: #endif
1.1.1.3 root 2522: /* Remove slash from pl->prefix. */
2523: if (strlen (pl->prefix) >= bufsize)
2524: bufsize = strlen (pl->prefix) * 2 + 1;
2525: buffer = (char *) xrealloc (buffer, bufsize);
2526: strcpy (buffer, pl->prefix);
2527: idx = strlen (buffer);
2528: if (buffer[idx - 1] == '/')
2529: buffer[idx - 1] = 0;
1.1.1.4 ! root 2530: do_spec_1 (buffer, 1, NULL_PTR);
1.1 root 2531: /* Make this a separate argument. */
1.1.1.4 ! root 2532: do_spec_1 (" ", 0, NULL_PTR);
1.1 root 2533: }
2534: }
2535: }
1.1.1.3 root 2536: free (buffer);
1.1 root 2537: }
2538: break;
2539:
2540: case 'e':
2541: /* {...:%efoo} means report an error with `foo' as error message
2542: and don't execute any more commands for this file. */
2543: {
2544: char *q = p;
2545: char *buf;
2546: while (*p != 0 && *p != '\n') p++;
2547: buf = (char *) alloca (p - q + 1);
2548: strncpy (buf, q, p - q);
2549: buf[p - q] = 0;
2550: error ("%s", buf);
2551: return -1;
2552: }
2553: break;
2554:
2555: case 'g':
1.1.1.4 ! root 2556: case 'u':
! 2557: case 'U':
1.1 root 2558: if (save_temps_flag)
2559: obstack_grow (&obstack, input_basename, basename_length);
2560: else
2561: {
1.1.1.4 ! root 2562: #ifdef MKTEMP_EACH_FILE
! 2563: /* ??? This has a problem: the total number of
! 2564: values mktemp can return is limited.
! 2565: That matters for the names of object files.
! 2566: In 2.4, do something about that. */
! 2567: struct temp_name *t;
! 2568: char *suffix = p;
! 2569: while (*p == '.' || isalpha (*p))
! 2570: p++;
! 2571:
! 2572: /* See if we already have an association of %g/%u/%U and
! 2573: suffix. */
! 2574: for (t = temp_names; t; t = t->next)
! 2575: if (t->length == p - suffix
! 2576: && strncmp (t->suffix, suffix, p - suffix) == 0
! 2577: && t->unique == (c != 'g'))
! 2578: break;
! 2579:
! 2580: /* Make a new association if needed. %u requires one. */
! 2581: if (t == 0 || c == 'u')
! 2582: {
! 2583: if (t == 0)
! 2584: {
! 2585: t = (struct temp_name *) xmalloc (sizeof (struct temp_name));
! 2586: t->next = temp_names;
! 2587: temp_names = t;
! 2588: }
! 2589: t->length = p - suffix;
! 2590: t->suffix = save_string (suffix, p - suffix);
! 2591: t->unique = (c != 'g');
! 2592: choose_temp_base ();
! 2593: t->filename = temp_filename;
! 2594: t->filename_length = temp_filename_length;
! 2595: }
! 2596:
! 2597: obstack_grow (&obstack, t->filename, t->filename_length);
! 2598: delete_this_arg = 1;
! 2599: #else
1.1 root 2600: obstack_grow (&obstack, temp_filename, temp_filename_length);
1.1.1.4 ! root 2601: if (c == 'u' || c == 'U')
! 2602: {
! 2603: static int unique;
! 2604: char buff[9];
! 2605: if (c == 'u')
! 2606: unique++;
! 2607: sprintf (buff, "%d", unique);
! 2608: obstack_grow (&obstack, buff, strlen (buff));
! 2609: }
! 2610: #endif
1.1 root 2611: delete_this_arg = 1;
2612: }
2613: arg_going = 1;
2614: break;
2615:
2616: case 'i':
2617: obstack_grow (&obstack, input_filename, input_filename_length);
2618: arg_going = 1;
2619: break;
2620:
1.1.1.3 root 2621: case 'I':
2622: if (gcc_exec_prefix)
2623: {
1.1.1.4 ! root 2624: do_spec_1 ("-iprefix", 1, NULL_PTR);
1.1.1.3 root 2625: /* Make this a separate argument. */
1.1.1.4 ! root 2626: do_spec_1 (" ", 0, NULL_PTR);
! 2627: do_spec_1 (gcc_exec_prefix, 1, NULL_PTR);
! 2628: do_spec_1 (" ", 0, NULL_PTR);
1.1.1.3 root 2629: }
2630: break;
2631:
1.1 root 2632: case 'o':
2633: {
2634: register int f;
2635: for (f = 0; f < n_infiles; f++)
2636: store_arg (outfiles[f], 0, 0);
2637: }
2638: break;
2639:
2640: case 's':
2641: this_is_library_file = 1;
2642: break;
2643:
2644: case 'w':
2645: this_is_output_file = 1;
2646: break;
2647:
2648: case 'W':
2649: {
2650: int index = argbuf_index;
2651: /* Handle the {...} following the %W. */
2652: if (*p != '{')
2653: abort ();
2654: p = handle_braces (p + 1);
2655: if (p == 0)
2656: return -1;
2657: /* If any args were output, mark the last one for deletion
2658: on failure. */
2659: if (argbuf_index != index)
2660: record_temp_file (argbuf[argbuf_index - 1], 0, 1);
2661: break;
2662: }
2663:
2664: /* %x{OPTION} records OPTION for %X to output. */
2665: case 'x':
2666: {
2667: char *p1 = p;
2668: char *string;
2669:
2670: /* Skip past the option value and make a copy. */
2671: if (*p != '{')
2672: abort ();
2673: while (*p++ != '}')
2674: ;
2675: string = save_string (p1 + 1, p - p1 - 2);
2676:
2677: /* See if we already recorded this option. */
2678: for (i = 0; i < n_linker_options; i++)
2679: if (! strcmp (string, linker_options[i]))
2680: {
2681: free (string);
2682: return 0;
2683: }
2684:
2685: /* This option is new; add it. */
2686: n_linker_options++;
2687: if (!linker_options)
2688: linker_options
2689: = (char **) xmalloc (n_linker_options * sizeof (char **));
2690: else
2691: linker_options
2692: = (char **) xrealloc (linker_options,
2693: n_linker_options * sizeof (char **));
2694:
2695: linker_options[n_linker_options - 1] = string;
2696: }
2697: break;
2698:
1.1.1.4 ! root 2699: /* Dump out the options accumulated previously using %x,
! 2700: -Xlinker and -Wl,. */
1.1 root 2701: case 'X':
2702: for (i = 0; i < n_linker_options; i++)
2703: {
1.1.1.4 ! root 2704: do_spec_1 (linker_options[i], 1, NULL_PTR);
1.1 root 2705: /* Make each accumulated option a separate argument. */
1.1.1.4 ! root 2706: do_spec_1 (" ", 0, NULL_PTR);
! 2707: }
! 2708: break;
! 2709:
! 2710: /* Dump out the options accumulated previously using -Wa,. */
! 2711: case 'Y':
! 2712: for (i = 0; i < n_assembler_options; i++)
! 2713: {
! 2714: do_spec_1 (assembler_options[i], 1, NULL_PTR);
! 2715: /* Make each accumulated option a separate argument. */
! 2716: do_spec_1 (" ", 0, NULL_PTR);
1.1 root 2717: }
2718: break;
2719:
2720: /* Here are digits and numbers that just process
1.1.1.4 ! root 2721: a certain constant string as a spec.
! 2722: /* Here are digits and numbers that just process
1.1 root 2723: a certain constant string as a spec. */
2724:
2725: case '1':
1.1.1.4 ! root 2726: do_spec_1 (cc1_spec, 0, NULL_PTR);
1.1 root 2727: break;
2728:
2729: case '2':
1.1.1.4 ! root 2730: do_spec_1 (cc1plus_spec, 0, NULL_PTR);
1.1 root 2731: break;
2732:
2733: case 'a':
1.1.1.4 ! root 2734: do_spec_1 (asm_spec, 0, NULL_PTR);
1.1 root 2735: break;
2736:
2737: case 'A':
1.1.1.4 ! root 2738: do_spec_1 (asm_final_spec, 0, NULL_PTR);
1.1 root 2739: break;
2740:
2741: case 'c':
1.1.1.4 ! root 2742: do_spec_1 (signed_char_spec, 0, NULL_PTR);
1.1 root 2743: break;
2744:
2745: case 'C':
1.1.1.4 ! root 2746: do_spec_1 (cpp_spec, 0, NULL_PTR);
1.1 root 2747: break;
2748:
2749: case 'E':
1.1.1.4 ! root 2750: do_spec_1 (endfile_spec, 0, NULL_PTR);
1.1 root 2751: break;
2752:
2753: case 'l':
1.1.1.4 ! root 2754: do_spec_1 (link_spec, 0, NULL_PTR);
1.1 root 2755: break;
2756:
2757: case 'L':
1.1.1.4 ! root 2758: do_spec_1 (lib_spec, 0, NULL_PTR);
1.1 root 2759: break;
2760:
2761: case 'p':
2762: {
2763: char *x = (char *) alloca (strlen (cpp_predefines) + 1);
2764: char *buf = x;
2765: char *y;
2766:
2767: /* Copy all of the -D options in CPP_PREDEFINES into BUF. */
2768: y = cpp_predefines;
2769: while (*y != 0)
2770: {
2771: if (! strncmp (y, "-D", 2))
2772: /* Copy the whole option. */
2773: while (*y && *y != ' ' && *y != '\t')
2774: *x++ = *y++;
2775: else if (*y == ' ' || *y == '\t')
2776: /* Copy whitespace to the result. */
2777: *x++ = *y++;
2778: /* Don't copy other options. */
2779: else
2780: y++;
2781: }
2782:
2783: *x = 0;
2784:
1.1.1.4 ! root 2785: do_spec_1 (buf, 0, NULL_PTR);
1.1 root 2786: }
2787: break;
2788:
2789: case 'P':
2790: {
2791: char *x = (char *) alloca (strlen (cpp_predefines) * 4 + 1);
2792: char *buf = x;
2793: char *y;
2794:
2795: /* Copy all of CPP_PREDEFINES into BUF,
2796: but put __ after every -D and at the end of each arg. */
2797: y = cpp_predefines;
2798: while (*y != 0)
2799: {
2800: if (! strncmp (y, "-D", 2))
2801: {
2802: int flag = 0;
2803:
2804: *x++ = *y++;
2805: *x++ = *y++;
2806:
2807: if (strncmp (y, "__", 2))
2808: {
2809: /* Stick __ at front of macro name. */
2810: *x++ = '_';
2811: *x++ = '_';
2812: /* Arrange to stick __ at the end as well. */
2813: flag = 1;
2814: }
2815:
2816: /* Copy the macro name. */
2817: while (*y && *y != '=' && *y != ' ' && *y != '\t')
2818: *x++ = *y++;
2819:
2820: if (flag)
2821: {
2822: *x++ = '_';
2823: *x++ = '_';
2824: }
2825:
2826: /* Copy the value given, if any. */
2827: while (*y && *y != ' ' && *y != '\t')
2828: *x++ = *y++;
2829: }
2830: else if (*y == ' ' || *y == '\t')
2831: /* Copy whitespace to the result. */
2832: *x++ = *y++;
2833: /* Don't copy -A options */
2834: else
2835: y++;
2836: }
2837: *x++ = ' ';
2838:
2839: /* Copy all of CPP_PREDEFINES into BUF,
2840: but put __ after every -D. */
2841: y = cpp_predefines;
2842: while (*y != 0)
2843: {
2844: if (! strncmp (y, "-D", 2))
2845: {
2846: *x++ = *y++;
2847: *x++ = *y++;
2848:
2849: if (strncmp (y, "__", 2))
2850: {
2851: /* Stick __ at front of macro name. */
2852: *x++ = '_';
2853: *x++ = '_';
2854: }
2855:
2856: /* Copy the macro name. */
2857: while (*y && *y != '=' && *y != ' ' && *y != '\t')
2858: *x++ = *y++;
2859:
2860: /* Copy the value given, if any. */
2861: while (*y && *y != ' ' && *y != '\t')
2862: *x++ = *y++;
2863: }
2864: else if (*y == ' ' || *y == '\t')
2865: /* Copy whitespace to the result. */
2866: *x++ = *y++;
2867: /* Don't copy -A options */
2868: else
2869: y++;
2870: }
2871: *x++ = ' ';
2872:
2873: /* Copy all of the -A options in CPP_PREDEFINES into BUF. */
2874: y = cpp_predefines;
2875: while (*y != 0)
2876: {
2877: if (! strncmp (y, "-A", 2))
2878: /* Copy the whole option. */
2879: while (*y && *y != ' ' && *y != '\t')
2880: *x++ = *y++;
2881: else if (*y == ' ' || *y == '\t')
2882: /* Copy whitespace to the result. */
2883: *x++ = *y++;
2884: /* Don't copy other options. */
2885: else
2886: y++;
2887: }
2888:
2889: *x = 0;
2890:
1.1.1.4 ! root 2891: do_spec_1 (buf, 0, NULL_PTR);
1.1 root 2892: }
2893: break;
2894:
2895: case 'S':
1.1.1.4 ! root 2896: do_spec_1 (startfile_spec, 0, NULL_PTR);
1.1 root 2897: break;
2898:
2899: /* Here we define characters other than letters and digits. */
2900:
2901: case '{':
2902: p = handle_braces (p);
2903: if (p == 0)
2904: return -1;
2905: break;
2906:
2907: case '%':
2908: obstack_1grow (&obstack, '%');
2909: break;
2910:
2911: case '*':
1.1.1.4 ! root 2912: do_spec_1 (soft_matched_part, 1, NULL_PTR);
! 2913: do_spec_1 (" ", 0, NULL_PTR);
1.1 root 2914: break;
2915:
2916: /* Process a string found as the value of a spec given by name.
2917: This feature allows individual machine descriptions
2918: to add and use their own specs.
2919: %[...] modifies -D options the way %P does;
2920: %(...) uses the spec unmodified. */
2921: case '(':
2922: case '[':
2923: {
2924: char *name = p;
2925: struct spec_list *sl;
2926: int len;
2927:
2928: /* The string after the S/P is the name of a spec that is to be
2929: processed. */
2930: while (*p && *p != ')' && *p != ']')
2931: p++;
2932:
2933: /* See if it's in the list */
2934: for (len = p - name, sl = specs; sl; sl = sl->next)
2935: if (strncmp (sl->name, name, len) == 0 && !sl->name[len])
2936: {
2937: name = sl->spec;
2938: break;
2939: }
2940:
2941: if (sl)
2942: {
2943: if (c == '(')
1.1.1.4 ! root 2944: do_spec_1 (name, 0, NULL_PTR);
1.1 root 2945: else
2946: {
2947: char *x = (char *) alloca (strlen (name) * 2 + 1);
2948: char *buf = x;
2949: char *y = name;
2950:
2951: /* Copy all of NAME into BUF, but put __ after
2952: every -D and at the end of each arg, */
2953: while (1)
2954: {
2955: if (! strncmp (y, "-D", 2))
2956: {
2957: *x++ = '-';
2958: *x++ = 'D';
2959: *x++ = '_';
2960: *x++ = '_';
2961: y += 2;
2962: }
2963: else if (*y == ' ' || *y == 0)
2964: {
2965: *x++ = '_';
2966: *x++ = '_';
2967: if (*y == 0)
2968: break;
2969: else
2970: *x++ = *y++;
2971: }
2972: else
2973: *x++ = *y++;
2974: }
2975: *x = 0;
2976:
1.1.1.4 ! root 2977: do_spec_1 (buf, 0, NULL_PTR);
1.1 root 2978: }
2979: }
1.1.1.2 root 2980:
2981: /* Discard the closing paren or bracket. */
2982: if (*p)
2983: p++;
1.1 root 2984: }
2985: break;
2986:
2987: default:
2988: abort ();
2989: }
2990: break;
2991:
2992: case '\\':
2993: /* Backslash: treat next character as ordinary. */
2994: c = *p++;
2995:
2996: /* fall through */
2997: default:
2998: /* Ordinary character: put it into the current argument. */
2999: obstack_1grow (&obstack, c);
3000: arg_going = 1;
3001: }
3002:
3003: return 0; /* End of string */
3004: }
3005:
3006: /* Return 0 if we call do_spec_1 and that returns -1. */
3007:
3008: static char *
3009: handle_braces (p)
3010: register char *p;
3011: {
3012: register char *q;
3013: char *filter;
3014: int pipe = 0;
3015: int negate = 0;
3016: int suffix = 0;
3017:
3018: if (*p == '|')
3019: /* A `|' after the open-brace means,
3020: if the test fails, output a single minus sign rather than nothing.
3021: This is used in %{|!pipe:...}. */
3022: pipe = 1, ++p;
3023:
3024: if (*p == '!')
3025: /* A `!' after the open-brace negates the condition:
3026: succeed if the specified switch is not present. */
3027: negate = 1, ++p;
3028:
3029: if (*p == '.')
3030: /* A `.' after the open-brace means test against the current suffix. */
3031: {
3032: if (pipe)
3033: abort ();
3034:
3035: suffix = 1;
3036: ++p;
3037: }
3038:
3039: filter = p;
3040: while (*p != ':' && *p != '}') p++;
3041: if (*p != '}')
3042: {
3043: register int count = 1;
3044: q = p + 1;
3045: while (count > 0)
3046: {
3047: if (*q == '{')
3048: count++;
3049: else if (*q == '}')
3050: count--;
3051: else if (*q == 0)
3052: abort ();
3053: q++;
3054: }
3055: }
3056: else
3057: q = p + 1;
3058:
3059: if (suffix)
3060: {
3061: int found = (input_suffix != 0
1.1.1.2 root 3062: && strlen (input_suffix) == p - filter
1.1 root 3063: && strncmp (input_suffix, filter, p - filter) == 0);
3064:
3065: if (p[0] == '}')
3066: abort ();
3067:
3068: if (negate != found
1.1.1.4 ! root 3069: && do_spec_1 (save_string (p + 1, q - p - 2), 0, NULL_PTR) < 0)
1.1 root 3070: return 0;
3071:
3072: return q;
3073: }
3074: else if (p[-1] == '*' && p[0] == '}')
3075: {
3076: /* Substitute all matching switches as separate args. */
3077: register int i;
3078: --p;
3079: for (i = 0; i < n_switches; i++)
3080: if (!strncmp (switches[i].part1, filter, p - filter))
3081: give_switch (i, 0);
3082: }
3083: else
3084: {
3085: /* Test for presence of the specified switch. */
3086: register int i;
3087: int present = 0;
3088:
3089: /* If name specified ends in *, as in {x*:...},
3090: check for %* and handle that case. */
3091: if (p[-1] == '*' && !negate)
3092: {
3093: int substitution;
3094: char *r = p;
3095:
3096: /* First see whether we have %*. */
3097: substitution = 0;
1.1.1.2 root 3098: while (r < q)
1.1 root 3099: {
3100: if (*r == '%' && r[1] == '*')
3101: substitution = 1;
3102: r++;
3103: }
3104: /* If we do, handle that case. */
3105: if (substitution)
3106: {
3107: /* Substitute all matching switches as separate args.
3108: But do this by substituting for %*
3109: in the text that follows the colon. */
3110:
3111: unsigned hard_match_len = p - filter - 1;
3112: char *string = save_string (p + 1, q - p - 2);
3113:
3114: for (i = 0; i < n_switches; i++)
3115: if (!strncmp (switches[i].part1, filter, hard_match_len))
3116: {
3117: do_spec_1 (string, 0, &switches[i].part1[hard_match_len]);
3118: /* Pass any arguments this switch has. */
3119: give_switch (i, 1);
3120: }
3121:
3122: return q;
3123: }
3124: }
3125:
3126: /* If name specified ends in *, as in {x*:...},
3127: check for presence of any switch name starting with x. */
3128: if (p[-1] == '*')
3129: {
3130: for (i = 0; i < n_switches; i++)
3131: {
3132: unsigned hard_match_len = p - filter - 1;
3133:
3134: if (!strncmp (switches[i].part1, filter, hard_match_len))
3135: {
3136: switches[i].valid = 1;
3137: present = 1;
3138: }
3139: }
3140: }
3141: /* Otherwise, check for presence of exact name specified. */
3142: else
3143: {
3144: for (i = 0; i < n_switches; i++)
3145: {
3146: if (!strncmp (switches[i].part1, filter, p - filter)
3147: && switches[i].part1[p - filter] == 0)
3148: {
3149: switches[i].valid = 1;
3150: present = 1;
3151: break;
3152: }
3153: }
3154: }
3155:
3156: /* If it is as desired (present for %{s...}, absent for %{-s...})
3157: then substitute either the switch or the specified
3158: conditional text. */
3159: if (present != negate)
3160: {
3161: if (*p == '}')
3162: {
3163: give_switch (i, 0);
3164: }
3165: else
3166: {
1.1.1.4 ! root 3167: if (do_spec_1 (save_string (p + 1, q - p - 2), 0, NULL_PTR) < 0)
1.1 root 3168: return 0;
3169: }
3170: }
3171: else if (pipe)
3172: {
3173: /* Here if a %{|...} conditional fails: output a minus sign,
3174: which means "standard output" or "standard input". */
1.1.1.4 ! root 3175: do_spec_1 ("-", 0, NULL_PTR);
1.1 root 3176: }
3177: }
3178:
3179: return q;
3180: }
3181:
3182: /* Pass a switch to the current accumulating command
3183: in the same form that we received it.
3184: SWITCHNUM identifies the switch; it is an index into
3185: the vector of switches gcc received, which is `switches'.
3186: This cannot fail since it never finishes a command line.
3187:
3188: If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
3189:
3190: static void
3191: give_switch (switchnum, omit_first_word)
3192: int switchnum;
3193: int omit_first_word;
3194: {
3195: if (!omit_first_word)
3196: {
1.1.1.4 ! root 3197: do_spec_1 ("-", 0, NULL_PTR);
! 3198: do_spec_1 (switches[switchnum].part1, 1, NULL_PTR);
1.1 root 3199: }
1.1.1.4 ! root 3200: do_spec_1 (" ", 0, NULL_PTR);
1.1 root 3201: if (switches[switchnum].args != 0)
3202: {
3203: char **p;
3204: for (p = switches[switchnum].args; *p; p++)
3205: {
1.1.1.4 ! root 3206: do_spec_1 (*p, 1, NULL_PTR);
! 3207: do_spec_1 (" ", 0, NULL_PTR);
1.1 root 3208: }
3209: }
3210: switches[switchnum].valid = 1;
3211: }
3212:
3213: /* Search for a file named NAME trying various prefixes including the
3214: user's -B prefix and some standard ones.
3215: Return the absolute file name found. If nothing is found, return NAME. */
3216:
3217: static char *
3218: find_file (name)
3219: char *name;
3220: {
3221: char *newname;
3222:
3223: newname = find_a_file (&startfile_prefix, name, R_OK);
3224: return newname ? newname : name;
3225: }
3226:
3227: /* Determine whether a -L option is relevant. Not required for certain
3228: fixed names and for directories that don't exist. */
3229:
3230: static int
3231: is_linker_dir (path1, path2)
3232: char *path1;
3233: char *path2;
3234: {
3235: int len1 = strlen (path1);
3236: int len2 = strlen (path2);
3237: char *path = (char *) alloca (3 + len1 + len2);
3238: char *cp;
3239: struct stat st;
3240:
3241: /* Construct the path from the two parts. Ensure the string ends with "/.".
3242: The resulting path will be a directory even if the given path is a
3243: symbolic link. */
3244: bcopy (path1, path, len1);
3245: bcopy (path2, path + len1, len2);
3246: cp = path + len1 + len2;
3247: if (cp[-1] != '/')
3248: *cp++ = '/';
3249: *cp++ = '.';
3250: *cp = '\0';
3251:
3252: /* Exclude directories that the linker is known to search. */
3253: if ((cp - path == 6 && strcmp (path, "/lib/.") == 0)
3254: || (cp - path == 10 && strcmp (path, "/usr/lib/.") == 0))
3255: return 0;
3256:
3257: return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
3258: }
3259:
3260: /* On fatal signals, delete all the temporary files. */
3261:
3262: static void
3263: fatal_error (signum)
3264: int signum;
3265: {
3266: signal (signum, SIG_DFL);
3267: delete_failure_queue ();
3268: delete_temp_files ();
3269: /* Get the same signal again, this time not handled,
3270: so its normal effect occurs. */
3271: kill (getpid (), signum);
3272: }
3273:
3274: int
3275: main (argc, argv)
3276: int argc;
3277: char **argv;
3278: {
3279: register int i;
1.1.1.4 ! root 3280: int j;
1.1 root 3281: int value;
3282: int error_count = 0;
3283: int linker_was_run = 0;
3284: char *explicit_link_files;
3285: char *specs_file;
3286:
3287: programname = argv[0];
3288:
3289: if (signal (SIGINT, SIG_IGN) != SIG_IGN)
3290: signal (SIGINT, fatal_error);
3291: if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
3292: signal (SIGHUP, fatal_error);
3293: if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
3294: signal (SIGTERM, fatal_error);
3295: #ifdef SIGPIPE
3296: if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
3297: signal (SIGPIPE, fatal_error);
3298: #endif
3299:
3300: argbuf_length = 10;
3301: argbuf = (char **) xmalloc (argbuf_length * sizeof (char *));
3302:
3303: obstack_init (&obstack);
3304:
1.1.1.2 root 3305: /* Set up to remember the pathname of gcc and any options
3306: needed for collect. */
3307: obstack_init (&collect_obstack);
3308: obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=")-1);
3309: obstack_grow (&collect_obstack, programname, strlen (programname)+1);
3310: putenv (obstack_finish (&collect_obstack));
3311:
1.1 root 3312: /* Choose directory for temp files. */
3313:
3314: choose_temp_base ();
3315:
3316: /* Make a table of what switches there are (switches, n_switches).
3317: Make a table of specified input files (infiles, n_infiles).
3318: Decode switches that are handled locally. */
3319:
3320: process_command (argc, argv);
3321:
3322: /* Initialize the vector of specs to just the default.
3323: This means one element containing 0s, as a terminator. */
3324:
3325: compilers = (struct compiler *) xmalloc (sizeof default_compilers);
3326: bcopy (default_compilers, compilers, sizeof default_compilers);
3327: n_compilers = n_default_compilers;
3328:
3329: /* Read specs from a file if there is one. */
3330:
3331: machine_suffix = concat (spec_machine, "/", concat (spec_version, "/", ""));
1.1.1.4 ! root 3332: just_machine_suffix = concat (spec_machine, "/", "");
1.1 root 3333:
3334: specs_file = find_a_file (&startfile_prefix, "specs", R_OK);
3335: /* Read the specs file unless it is a default one. */
3336: if (specs_file != 0 && strcmp (specs_file, "specs"))
3337: read_specs (specs_file);
3338:
1.1.1.2 root 3339: /* If not cross-compiling, look for startfiles in the standard places. */
3340: /* The fact that these are done here, after reading the specs file,
3341: means that it cannot be found in these directories.
3342: But that's okay. It should never be there anyway. */
3343: if (!cross_compile)
3344: {
3345: #ifdef MD_EXEC_PREFIX
1.1.1.4 ! root 3346: add_prefix (&exec_prefix, md_exec_prefix, 0, 0, NULL_PTR);
! 3347: add_prefix (&startfile_prefix, md_exec_prefix, 0, 0, NULL_PTR);
1.1.1.2 root 3348: #endif
3349:
3350: #ifdef MD_STARTFILE_PREFIX
1.1.1.4 ! root 3351: add_prefix (&startfile_prefix, md_startfile_prefix, 0, 0, NULL_PTR);
1.1.1.2 root 3352: #endif
3353:
1.1.1.3 root 3354: #ifdef MD_STARTFILE_PREFIX_1
1.1.1.4 ! root 3355: add_prefix (&startfile_prefix, md_startfile_prefix_1, 0, 0, NULL_PTR);
1.1.1.3 root 3356: #endif
3357:
1.1.1.4 ! root 3358: add_prefix (&startfile_prefix, standard_startfile_prefix, 0, 0,
! 3359: NULL_PTR);
! 3360: add_prefix (&startfile_prefix, standard_startfile_prefix_1, 0, 0,
! 3361: NULL_PTR);
! 3362: add_prefix (&startfile_prefix, standard_startfile_prefix_2, 0, 0,
! 3363: NULL_PTR);
1.1.1.2 root 3364: #if 0 /* Can cause surprises, and one can use -B./ instead. */
1.1.1.4 ! root 3365: add_prefix (&startfile_prefix, "./", 0, 1, NULL_PTR);
1.1.1.2 root 3366: #endif
3367: }
3368:
1.1 root 3369: /* Now we have the specs.
3370: Set the `valid' bits for switches that match anything in any spec. */
3371:
3372: validate_all_switches ();
3373:
3374: /* Warn about any switches that no pass was interested in. */
3375:
3376: for (i = 0; i < n_switches; i++)
3377: if (! switches[i].valid)
3378: error ("unrecognized option `-%s'", switches[i].part1);
3379:
1.1.1.3 root 3380: if (print_libgcc_file_name)
3381: {
3382: printf ("%s\n", find_file ("libgcc.a"));
3383: exit (0);
3384: }
3385:
1.1 root 3386: /* Obey some of the options. */
3387:
3388: if (verbose_flag)
3389: {
3390: fprintf (stderr, "gcc version %s\n", version_string);
3391: if (n_infiles == 0)
3392: exit (0);
3393: }
3394:
3395: if (n_infiles == 0)
3396: fatal ("No input files specified.");
3397:
3398: /* Make a place to record the compiler output file names
3399: that correspond to the input files. */
3400:
3401: outfiles = (char **) xmalloc (n_infiles * sizeof (char *));
3402: bzero (outfiles, n_infiles * sizeof (char *));
3403:
3404: /* Record which files were specified explicitly as link input. */
3405:
3406: explicit_link_files = xmalloc (n_infiles);
3407: bzero (explicit_link_files, n_infiles);
3408:
3409: for (i = 0; i < n_infiles; i++)
3410: {
3411: register struct compiler *cp = 0;
3412: int this_file_error = 0;
3413:
3414: /* Tell do_spec what to substitute for %i. */
3415:
3416: input_filename = infiles[i].name;
3417: input_filename_length = strlen (input_filename);
3418: input_file_number = i;
3419:
3420: /* Use the same thing in %o, unless cp->spec says otherwise. */
3421:
3422: outfiles[i] = input_filename;
3423:
3424: /* Figure out which compiler from the file's suffix. */
3425:
3426: cp = lookup_compiler (infiles[i].name, input_filename_length,
3427: infiles[i].language);
3428:
3429: if (cp)
3430: {
3431: /* Ok, we found an applicable compiler. Run its spec. */
3432: /* First say how much of input_filename to substitute for %b */
3433: register char *p;
1.1.1.4 ! root 3434: int len;
1.1 root 3435:
3436: input_basename = input_filename;
3437: for (p = input_filename; *p; p++)
3438: if (*p == '/')
3439: input_basename = p + 1;
3440:
3441: /* Find a suffix starting with the last period,
3442: and set basename_length to exclude that suffix. */
3443: basename_length = strlen (input_basename);
3444: p = input_basename + basename_length;
3445: while (p != input_basename && *p != '.') --p;
3446: if (*p == '.' && p != input_basename)
3447: {
3448: basename_length = p - input_basename;
3449: input_suffix = p + 1;
3450: }
3451: else
3452: input_suffix = "";
3453:
1.1.1.4 ! root 3454: len = 0;
! 3455: for (j = 0; j < sizeof cp->spec / sizeof cp->spec[0]; j++)
! 3456: if (cp->spec[j])
! 3457: len += strlen (cp->spec[j]);
! 3458:
! 3459: p = (char *) xmalloc (len + 1);
! 3460:
! 3461: len = 0;
! 3462: for (j = 0; j < sizeof cp->spec / sizeof cp->spec[0]; j++)
! 3463: if (cp->spec[j])
! 3464: {
! 3465: strcpy (p + len, cp->spec[j]);
! 3466: len += strlen (cp->spec[j]);
! 3467: }
! 3468:
! 3469: value = do_spec (p);
! 3470: free (p);
1.1 root 3471: if (value < 0)
3472: this_file_error = 1;
3473: }
3474:
3475: /* If this file's name does not contain a recognized suffix,
3476: record it as explicit linker input. */
3477:
3478: else
3479: explicit_link_files[i] = 1;
3480:
3481: /* Clear the delete-on-failure queue, deleting the files in it
3482: if this compilation failed. */
3483:
3484: if (this_file_error)
3485: {
3486: delete_failure_queue ();
3487: error_count++;
3488: }
3489: /* If this compilation succeeded, don't delete those files later. */
3490: clear_failure_queue ();
3491: }
3492:
3493: /* Run ld to link all the compiler output files. */
3494:
3495: if (error_count == 0)
3496: {
3497: int tmp = execution_count;
1.1.1.2 root 3498: int i;
3499: int first_time;
3500:
3501: /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
3502: for collect. */
3503: putenv_from_prefixes (&exec_prefix, "COMPILER_PATH=");
3504: putenv_from_prefixes (&startfile_prefix, "LIBRARY_PATH=");
3505:
3506: /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
3507: the compiler. */
3508: obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
3509: sizeof ("COLLECT_GCC_OPTIONS=")-1);
3510:
3511: first_time = TRUE;
3512: for (i = 0; i < n_switches; i++)
3513: {
3514: char **args;
3515: if (!first_time)
3516: obstack_grow (&collect_obstack, " ", 1);
3517:
3518: first_time = FALSE;
3519: obstack_grow (&collect_obstack, "-", 1);
3520: obstack_grow (&collect_obstack, switches[i].part1,
3521: strlen (switches[i].part1));
3522:
3523: for (args = switches[i].args; args && *args; args++)
3524: {
3525: obstack_grow (&collect_obstack, " ", 1);
3526: obstack_grow (&collect_obstack, *args, strlen (*args));
3527: }
3528: }
3529: obstack_grow (&collect_obstack, "\0", 1);
3530: putenv (obstack_finish (&collect_obstack));
3531:
1.1 root 3532: value = do_spec (link_command_spec);
3533: if (value < 0)
3534: error_count = 1;
3535: linker_was_run = (tmp != execution_count);
3536: }
3537:
3538: /* Warn if a -B option was specified but the prefix was never used. */
3539: unused_prefix_warnings (&exec_prefix);
3540: unused_prefix_warnings (&startfile_prefix);
3541:
3542: /* If options said don't run linker,
3543: complain about input files to be given to the linker. */
3544:
3545: if (! linker_was_run && error_count == 0)
3546: for (i = 0; i < n_infiles; i++)
3547: if (explicit_link_files[i])
3548: error ("%s: linker input file unused since linking not done",
3549: outfiles[i]);
3550:
3551: /* Delete some or all of the temporary files we made. */
3552:
3553: if (error_count)
3554: delete_failure_queue ();
3555: delete_temp_files ();
3556:
1.1.1.4 ! root 3557: exit (error_count > 0 ? (signal_count ? 2 : 1) : 0);
1.1 root 3558: /* NOTREACHED */
3559: return 0;
3560: }
3561:
3562: /* Find the proper compilation spec for the file name NAME,
3563: whose length is LENGTH. LANGUAGE is the specified language,
3564: or 0 if none specified. */
3565:
3566: static struct compiler *
3567: lookup_compiler (name, length, language)
3568: char *name;
3569: int length;
3570: char *language;
3571: {
3572: struct compiler *cp;
3573:
3574: /* Look for the language, if one is spec'd. */
3575: if (language != 0)
3576: {
3577: for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
3578: {
3579: if (language != 0)
3580: {
3581: if (cp->suffix[0] == '@'
3582: && !strcmp (cp->suffix + 1, language))
3583: return cp;
3584: }
3585: }
3586: error ("language %s not recognized", language);
3587: }
3588:
3589: /* Look for a suffix. */
3590: for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
3591: {
3592: if (strlen (cp->suffix) < length
3593: /* See if the suffix matches the end of NAME. */
3594: && !strcmp (cp->suffix,
3595: name + length - strlen (cp->suffix))
3596: /* The suffix `-' matches only the file name `-'. */
3597: && !(!strcmp (cp->suffix, "-") && length != 1))
3598: {
1.1.1.4 ! root 3599: if (cp->spec[0][0] == '@')
1.1 root 3600: {
3601: struct compiler *new;
3602: /* An alias entry maps a suffix to a language.
3603: Search for the language; pass 0 for NAME and LENGTH
3604: to avoid infinite recursion if language not found.
3605: Construct the new compiler spec. */
1.1.1.4 ! root 3606: language = cp->spec[0] + 1;
1.1 root 3607: new = (struct compiler *) xmalloc (sizeof (struct compiler));
3608: new->suffix = cp->suffix;
1.1.1.4 ! root 3609: bcopy (lookup_compiler (NULL_PTR, 0, language)->spec,
! 3610: new->spec, sizeof new->spec);
1.1 root 3611: return new;
3612: }
3613: /* A non-alias entry: return it. */
3614: return cp;
3615: }
3616: }
3617:
3618: return 0;
3619: }
3620:
3621: char *
3622: xmalloc (size)
3623: unsigned size;
3624: {
3625: register char *value = (char *) malloc (size);
3626: if (value == 0)
3627: fatal ("virtual memory exhausted");
3628: return value;
3629: }
3630:
3631: char *
3632: xrealloc (ptr, size)
3633: char *ptr;
3634: unsigned size;
3635: {
3636: register char *value = (char *) realloc (ptr, size);
3637: if (value == 0)
3638: fatal ("virtual memory exhausted");
3639: return value;
3640: }
3641:
3642: /* Return a newly-allocated string whose contents concatenate those of s1, s2, s3. */
3643:
3644: static char *
3645: concat (s1, s2, s3)
3646: char *s1, *s2, *s3;
3647: {
3648: int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
3649: char *result = xmalloc (len1 + len2 + len3 + 1);
3650:
3651: strcpy (result, s1);
3652: strcpy (result + len1, s2);
3653: strcpy (result + len1 + len2, s3);
3654: *(result + len1 + len2 + len3) = 0;
3655:
3656: return result;
3657: }
3658:
3659: static char *
3660: save_string (s, len)
3661: char *s;
3662: int len;
3663: {
3664: register char *result = xmalloc (len + 1);
3665:
3666: bcopy (s, result, len);
3667: result[len] = 0;
3668: return result;
3669: }
3670:
3671: static void
3672: pfatal_with_name (name)
3673: char *name;
3674: {
3675: char *s;
3676:
3677: if (errno < sys_nerr)
3678: s = concat ("%s: ", sys_errlist[errno], "");
3679: else
3680: s = "cannot open %s";
3681: fatal (s, name);
3682: }
3683:
3684: static void
3685: perror_with_name (name)
3686: char *name;
3687: {
3688: char *s;
3689:
3690: if (errno < sys_nerr)
3691: s = concat ("%s: ", sys_errlist[errno], "");
3692: else
3693: s = "cannot open %s";
3694: error (s, name);
3695: }
3696:
3697: static void
3698: perror_exec (name)
3699: char *name;
3700: {
3701: char *s;
3702:
3703: if (errno < sys_nerr)
3704: s = concat ("installation problem, cannot exec %s: ",
3705: sys_errlist[errno], "");
3706: else
3707: s = "installation problem, cannot exec %s";
3708: error (s, name);
3709: }
3710:
3711: /* More 'friendly' abort that prints the line and file.
3712: config.h can #define abort fancy_abort if you like that sort of thing. */
3713:
3714: void
3715: fancy_abort ()
3716: {
3717: fatal ("Internal gcc abort.");
3718: }
3719:
3720: #ifdef HAVE_VPRINTF
3721:
3722: /* Output an error message and exit */
3723:
3724: static void
3725: fatal (va_alist)
3726: va_dcl
3727: {
3728: va_list ap;
3729: char *format;
3730:
3731: va_start (ap);
3732: format = va_arg (ap, char *);
3733: fprintf (stderr, "%s: ", programname);
3734: vfprintf (stderr, format, ap);
3735: va_end (ap);
3736: fprintf (stderr, "\n");
3737: delete_temp_files ();
3738: exit (1);
3739: }
3740:
3741: static void
3742: error (va_alist)
3743: va_dcl
3744: {
3745: va_list ap;
3746: char *format;
3747:
3748: va_start (ap);
3749: format = va_arg (ap, char *);
3750: fprintf (stderr, "%s: ", programname);
3751: vfprintf (stderr, format, ap);
3752: va_end (ap);
3753:
3754: fprintf (stderr, "\n");
3755: }
3756:
3757: #else /* not HAVE_VPRINTF */
3758:
3759: static void
3760: fatal (msg, arg1, arg2)
3761: char *msg, *arg1, *arg2;
3762: {
3763: error (msg, arg1, arg2);
3764: delete_temp_files ();
3765: exit (1);
3766: }
3767:
3768: static void
3769: error (msg, arg1, arg2)
3770: char *msg, *arg1, *arg2;
3771: {
3772: fprintf (stderr, "%s: ", programname);
3773: fprintf (stderr, msg, arg1, arg2);
3774: fprintf (stderr, "\n");
3775: }
3776:
3777: #endif /* not HAVE_VPRINTF */
3778:
3779:
3780: static void
3781: validate_all_switches ()
3782: {
3783: struct compiler *comp;
3784: register char *p;
3785: register char c;
1.1.1.2 root 3786: struct spec_list *spec;
1.1 root 3787:
1.1.1.4 ! root 3788: for (comp = compilers; comp->spec[0]; comp++)
1.1 root 3789: {
1.1.1.4 ! root 3790: int i;
! 3791: for (i = 0; i < sizeof comp->spec / sizeof comp->spec[0] && comp->spec[i]; i++)
! 3792: {
! 3793: p = comp->spec[i];
! 3794: while (c = *p++)
! 3795: if (c == '%' && *p == '{')
! 3796: /* We have a switch spec. */
! 3797: validate_switches (p + 1);
! 3798: }
1.1 root 3799: }
3800:
1.1.1.2 root 3801: /* look through the linked list of extra specs read from the specs file */
1.1.1.4 ! root 3802: for (spec = specs; spec ; spec = spec->next)
1.1.1.2 root 3803: {
3804: p = spec->spec;
3805: while (c = *p++)
3806: if (c == '%' && *p == '{')
3807: /* We have a switch spec. */
3808: validate_switches (p + 1);
3809: }
3810:
1.1 root 3811: p = link_command_spec;
3812: while (c = *p++)
3813: if (c == '%' && *p == '{')
3814: /* We have a switch spec. */
3815: validate_switches (p + 1);
3816:
3817: /* Now notice switches mentioned in the machine-specific specs. */
3818:
3819: p = asm_spec;
3820: while (c = *p++)
3821: if (c == '%' && *p == '{')
3822: /* We have a switch spec. */
3823: validate_switches (p + 1);
3824:
3825: p = asm_final_spec;
3826: while (c = *p++)
3827: if (c == '%' && *p == '{')
3828: /* We have a switch spec. */
3829: validate_switches (p + 1);
3830:
3831: p = cpp_spec;
3832: while (c = *p++)
3833: if (c == '%' && *p == '{')
3834: /* We have a switch spec. */
3835: validate_switches (p + 1);
3836:
3837: p = signed_char_spec;
3838: while (c = *p++)
3839: if (c == '%' && *p == '{')
3840: /* We have a switch spec. */
3841: validate_switches (p + 1);
3842:
3843: p = cc1_spec;
3844: while (c = *p++)
3845: if (c == '%' && *p == '{')
3846: /* We have a switch spec. */
3847: validate_switches (p + 1);
3848:
3849: p = cc1plus_spec;
3850: while (c = *p++)
3851: if (c == '%' && *p == '{')
3852: /* We have a switch spec. */
3853: validate_switches (p + 1);
3854:
3855: p = link_spec;
3856: while (c = *p++)
3857: if (c == '%' && *p == '{')
3858: /* We have a switch spec. */
3859: validate_switches (p + 1);
3860:
3861: p = lib_spec;
3862: while (c = *p++)
3863: if (c == '%' && *p == '{')
3864: /* We have a switch spec. */
3865: validate_switches (p + 1);
3866:
3867: p = startfile_spec;
3868: while (c = *p++)
3869: if (c == '%' && *p == '{')
3870: /* We have a switch spec. */
3871: validate_switches (p + 1);
3872: }
3873:
3874: /* Look at the switch-name that comes after START
3875: and mark as valid all supplied switches that match it. */
3876:
3877: static void
3878: validate_switches (start)
3879: char *start;
3880: {
3881: register char *p = start;
3882: char *filter;
3883: register int i;
3884: int suffix = 0;
3885:
3886: if (*p == '|')
3887: ++p;
3888:
3889: if (*p == '!')
3890: ++p;
3891:
3892: if (*p == '.')
3893: suffix = 1, ++p;
3894:
3895: filter = p;
3896: while (*p != ':' && *p != '}') p++;
3897:
3898: if (suffix)
3899: ;
3900: else if (p[-1] == '*')
3901: {
3902: /* Mark all matching switches as valid. */
3903: --p;
3904: for (i = 0; i < n_switches; i++)
3905: if (!strncmp (switches[i].part1, filter, p - filter))
3906: switches[i].valid = 1;
3907: }
3908: else
3909: {
3910: /* Mark an exact matching switch as valid. */
3911: for (i = 0; i < n_switches; i++)
3912: {
3913: if (!strncmp (switches[i].part1, filter, p - filter)
3914: && switches[i].part1[p - filter] == 0)
3915: switches[i].valid = 1;
3916: }
3917: }
3918: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.