Merge tree-ssa-20020619-branch into mainline.
[gcc.git] / gcc / gcc.c
1 /* Compiler driver program that can handle many languages.
2 Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA.
21
22 This paragraph is here to try to keep Sun CC from dying.
23 The number of chars here seems crucial!!!! */
24
25 /* This program is the user interface to the C compiler and possibly to
26 other compilers. It is used because compilation is a complicated procedure
27 which involves running several programs and passing temporary files between
28 them, forwarding the users switches to those programs selectively,
29 and deleting the temporary files at the end.
30
31 CC recognizes how to compile each input file by suffixes in the file names.
32 Once it knows which kind of compilation to perform, the procedure for
33 compilation is specified by a string called a "spec". */
34
35 /* A Short Introduction to Adding a Command-Line Option.
36
37 Before adding a command-line option, consider if it is really
38 necessary. Each additional command-line option adds complexity and
39 is difficult to remove in subsequent versions.
40
41 In the following, consider adding the command-line argument
42 `--bar'.
43
44 1. Each command-line option is specified in the specs file. The
45 notation is described below in the comment entitled "The Specs
46 Language". Read it.
47
48 2. In this file, add an entry to "option_map" equating the long
49 `--' argument version and any shorter, single letter version. Read
50 the comments in the declaration of "struct option_map" for an
51 explanation. Do not omit the first `-'.
52
53 3. Look in the "specs" file to determine which program or option
54 list should be given the argument, e.g., "cc1_options". Add the
55 appropriate syntax for the shorter option version to the
56 corresponding "const char *" entry in this file. Omit the first
57 `-' from the option. For example, use `-bar', rather than `--bar'.
58
59 4. If the argument takes an argument, e.g., `--baz argument1',
60 modify either DEFAULT_SWITCH_TAKES_ARG or
61 DEFAULT_WORD_SWITCH_TAKES_ARG in this file. Omit the first `-'
62 from `--baz'.
63
64 5. Document the option in this file's display_help(). If the
65 option is passed to a subprogram, modify its corresponding
66 function, e.g., cppinit.c:print_help() or toplev.c:display_help(),
67 instead.
68
69 6. Compile and test. Make sure that your new specs file is being
70 read. For example, use a debugger to investigate the value of
71 "specs_file" in main(). */
72
73 #include "config.h"
74 #include "system.h"
75 #include "coretypes.h"
76 #include "multilib.h" /* before tm.h */
77 #include "tm.h"
78 #include <signal.h>
79 #if ! defined( SIGCHLD ) && defined( SIGCLD )
80 # define SIGCHLD SIGCLD
81 #endif
82 #include "obstack.h"
83 #include "intl.h"
84 #include "prefix.h"
85 #include "gcc.h"
86 #include "flags.h"
87
88 #ifdef HAVE_SYS_RESOURCE_H
89 #include <sys/resource.h>
90 #endif
91 #if defined (HAVE_DECL_GETRUSAGE) && !HAVE_DECL_GETRUSAGE
92 extern int getrusage (int, struct rusage *);
93 #endif
94
95 /* By default there is no special suffix for target executables. */
96 /* FIXME: when autoconf is fixed, remove the host check - dj */
97 #if defined(TARGET_EXECUTABLE_SUFFIX) && defined(HOST_EXECUTABLE_SUFFIX)
98 #define HAVE_TARGET_EXECUTABLE_SUFFIX
99 #endif
100
101 /* By default there is no special suffix for host executables. */
102 #ifdef HOST_EXECUTABLE_SUFFIX
103 #define HAVE_HOST_EXECUTABLE_SUFFIX
104 #else
105 #define HOST_EXECUTABLE_SUFFIX ""
106 #endif
107
108 /* By default, the suffix for target object files is ".o". */
109 #ifdef TARGET_OBJECT_SUFFIX
110 #define HAVE_TARGET_OBJECT_SUFFIX
111 #else
112 #define TARGET_OBJECT_SUFFIX ".o"
113 #endif
114
115 static const char dir_separator_str[] = { DIR_SEPARATOR, 0 };
116
117 /* Most every one is fine with LIBRARY_PATH. For some, it conflicts. */
118 #ifndef LIBRARY_PATH_ENV
119 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
120 #endif
121
122 #ifndef HAVE_KILL
123 #define kill(p,s) raise(s)
124 #endif
125
126 /* If a stage of compilation returns an exit status >= 1,
127 compilation of that file ceases. */
128
129 #define MIN_FATAL_STATUS 1
130
131 /* Flag set by cppspec.c to 1. */
132 int is_cpp_driver;
133
134 /* Flag saying to pass the greatest exit code returned by a sub-process
135 to the calling program. */
136 static int pass_exit_codes;
137
138 /* Definition of string containing the arguments given to configure. */
139 #include "configargs.h"
140
141 /* Flag saying to print the directories gcc will search through looking for
142 programs, libraries, etc. */
143
144 static int print_search_dirs;
145
146 /* Flag saying to print the full filename of this file
147 as found through our usual search mechanism. */
148
149 static const char *print_file_name = NULL;
150
151 /* As print_file_name, but search for executable file. */
152
153 static const char *print_prog_name = NULL;
154
155 /* Flag saying to print the relative path we'd use to
156 find libgcc.a given the current compiler flags. */
157
158 static int print_multi_directory;
159
160 /* Flag saying to print the relative path we'd use to
161 find OS libraries given the current compiler flags. */
162
163 static int print_multi_os_directory;
164
165 /* Flag saying to print the list of subdirectories and
166 compiler flags used to select them in a standard form. */
167
168 static int print_multi_lib;
169
170 /* Flag saying to print the command line options understood by gcc and its
171 sub-processes. */
172
173 static int print_help_list;
174
175 /* Flag indicating whether we should print the command and arguments */
176
177 static int verbose_flag;
178
179 /* Flag indicating whether we should ONLY print the command and
180 arguments (like verbose_flag) without executing the command.
181 Displayed arguments are quoted so that the generated command
182 line is suitable for execution. This is intended for use in
183 shell scripts to capture the driver-generated command line. */
184 static int verbose_only_flag;
185
186 /* Flag indicating to print target specific command line options. */
187
188 static int target_help_flag;
189
190 /* Flag indicating whether we should report subprocess execution times
191 (if this is supported by the system - see pexecute.c). */
192
193 static int report_times;
194
195 /* Nonzero means place this string before uses of /, so that include
196 and library files can be found in an alternate location. */
197
198 #ifdef TARGET_SYSTEM_ROOT
199 static const char *target_system_root = TARGET_SYSTEM_ROOT;
200 #else
201 static const char *target_system_root = 0;
202 #endif
203
204 /* Nonzero means pass the updated target_system_root to the compiler. */
205
206 static int target_system_root_changed;
207
208 /* Nonzero means append this string to target_system_root. */
209
210 static const char *target_sysroot_suffix = 0;
211
212 /* Nonzero means append this string to target_system_root for headers. */
213
214 static const char *target_sysroot_hdrs_suffix = 0;
215
216 /* Nonzero means write "temp" files in source directory
217 and use the source file's name in them, and don't delete them. */
218
219 static int save_temps_flag;
220
221 /* Nonzero means pass multiple source files to the compiler at one time. */
222
223 static int combine_flag = 0;
224
225 /* Nonzero means use pipes to communicate between subprocesses.
226 Overridden by either of the above two flags. */
227
228 static int use_pipes;
229
230 /* The compiler version. */
231
232 static const char *compiler_version;
233
234 /* The target version specified with -V */
235
236 static const char *const spec_version = DEFAULT_TARGET_VERSION;
237
238 /* The target machine specified with -b. */
239
240 static const char *spec_machine = DEFAULT_TARGET_MACHINE;
241
242 /* Nonzero if cross-compiling.
243 When -b is used, the value comes from the `specs' file. */
244
245 #ifdef CROSS_COMPILE
246 static const char *cross_compile = "1";
247 #else
248 static const char *cross_compile = "0";
249 #endif
250
251 #ifdef MODIFY_TARGET_NAME
252
253 /* Information on how to alter the target name based on a command-line
254 switch. The only case we support now is simply appending or deleting a
255 string to or from the end of the first part of the configuration name. */
256
257 static const struct modify_target
258 {
259 const char *const sw;
260 const enum add_del {ADD, DELETE} add_del;
261 const char *const str;
262 }
263 modify_target[] = MODIFY_TARGET_NAME;
264 #endif
265
266 /* The number of errors that have occurred; the link phase will not be
267 run if this is nonzero. */
268 static int error_count = 0;
269
270 /* Greatest exit code of sub-processes that has been encountered up to
271 now. */
272 static int greatest_status = 1;
273
274 /* This is the obstack which we use to allocate many strings. */
275
276 static struct obstack obstack;
277
278 /* This is the obstack to build an environment variable to pass to
279 collect2 that describes all of the relevant switches of what to
280 pass the compiler in building the list of pointers to constructors
281 and destructors. */
282
283 static struct obstack collect_obstack;
284
285 /* These structs are used to collect resource usage information for
286 subprocesses. */
287 #ifdef HAVE_GETRUSAGE
288 static struct rusage rus, prus;
289 #endif
290
291 /* Forward declaration for prototypes. */
292 struct path_prefix;
293
294 static void init_spec (void);
295 static void store_arg (const char *, int, int);
296 static char *load_specs (const char *);
297 static void read_specs (const char *, int);
298 static void set_spec (const char *, const char *);
299 static struct compiler *lookup_compiler (const char *, size_t, const char *);
300 static char *build_search_list (struct path_prefix *, const char *, int);
301 static void putenv_from_prefixes (struct path_prefix *, const char *);
302 static int access_check (const char *, int);
303 static char *find_a_file (struct path_prefix *, const char *, int, int);
304 static void add_prefix (struct path_prefix *, const char *, const char *,
305 int, int, int *, int);
306 static void add_sysrooted_prefix (struct path_prefix *, const char *,
307 const char *, int, int, int *, int);
308 static void translate_options (int *, const char *const **);
309 static char *skip_whitespace (char *);
310 static void delete_if_ordinary (const char *);
311 static void delete_temp_files (void);
312 static void delete_failure_queue (void);
313 static void clear_failure_queue (void);
314 static int check_live_switch (int, int);
315 static const char *handle_braces (const char *);
316 static inline bool input_suffix_matches (const char *, const char *);
317 static inline bool switch_matches (const char *, const char *, int);
318 static inline void mark_matching_switches (const char *, const char *, int);
319 static inline void process_marked_switches (void);
320 static const char *process_brace_body (const char *, const char *, const char *, int, int);
321 static const struct spec_function *lookup_spec_function (const char *);
322 static const char *eval_spec_function (const char *, const char *);
323 static const char *handle_spec_function (const char *);
324 static char *save_string (const char *, int);
325 static void set_collect_gcc_options (void);
326 static int do_spec_1 (const char *, int, const char *);
327 static int do_spec_2 (const char *);
328 static void do_option_spec (const char *, const char *);
329 static void do_self_spec (const char *);
330 static const char *find_file (const char *);
331 static int is_directory (const char *, const char *, int);
332 static const char *validate_switches (const char *);
333 static void validate_all_switches (void);
334 static inline void validate_switches_from_spec (const char *);
335 static void give_switch (int, int);
336 static int used_arg (const char *, int);
337 static int default_arg (const char *, int);
338 static void set_multilib_dir (void);
339 static void print_multilib_info (void);
340 static void perror_with_name (const char *);
341 static void pfatal_pexecute (const char *, const char *) ATTRIBUTE_NORETURN;
342 static void notice (const char *, ...) ATTRIBUTE_PRINTF_1;
343 static void display_help (void);
344 static void add_preprocessor_option (const char *, int);
345 static void add_assembler_option (const char *, int);
346 static void add_linker_option (const char *, int);
347 static void process_command (int, const char **);
348 static int execute (void);
349 static void alloc_args (void);
350 static void clear_args (void);
351 static void fatal_error (int);
352 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
353 static void init_gcc_specs (struct obstack *, const char *, const char *,
354 const char *);
355 #endif
356 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
357 static const char *convert_filename (const char *, int, int);
358 #endif
359
360 static const char *if_exists_spec_function (int, const char **);
361 static const char *if_exists_else_spec_function (int, const char **);
362 \f
363 /* The Specs Language
364
365 Specs are strings containing lines, each of which (if not blank)
366 is made up of a program name, and arguments separated by spaces.
367 The program name must be exact and start from root, since no path
368 is searched and it is unreliable to depend on the current working directory.
369 Redirection of input or output is not supported; the subprograms must
370 accept filenames saying what files to read and write.
371
372 In addition, the specs can contain %-sequences to substitute variable text
373 or for conditional text. Here is a table of all defined %-sequences.
374 Note that spaces are not generated automatically around the results of
375 expanding these sequences; therefore, you can concatenate them together
376 or with constant text in a single argument.
377
378 %% substitute one % into the program name or argument.
379 %i substitute the name of the input file being processed.
380 %b substitute the basename of the input file being processed.
381 This is the substring up to (and not including) the last period
382 and not including the directory.
383 %B same as %b, but include the file suffix (text after the last period).
384 %gSUFFIX
385 substitute a file name that has suffix SUFFIX and is chosen
386 once per compilation, and mark the argument a la %d. To reduce
387 exposure to denial-of-service attacks, the file name is now
388 chosen in a way that is hard to predict even when previously
389 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
390 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
391 the regexp "[.A-Za-z]*%O"; "%O" is treated exactly as if it
392 had been pre-processed. Previously, %g was simply substituted
393 with a file name chosen once per compilation, without regard
394 to any appended suffix (which was therefore treated just like
395 ordinary text), making such attacks more likely to succeed.
396 %|SUFFIX
397 like %g, but if -pipe is in effect, expands simply to "-".
398 %mSUFFIX
399 like %g, but if -pipe is in effect, expands to nothing. (We have both
400 %| and %m to accommodate differences between system assemblers; see
401 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
402 %uSUFFIX
403 like %g, but generates a new temporary file name even if %uSUFFIX
404 was already seen.
405 %USUFFIX
406 substitutes the last file name generated with %uSUFFIX, generating a
407 new one if there is no such last file name. In the absence of any
408 %uSUFFIX, this is just like %gSUFFIX, except they don't share
409 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
410 would involve the generation of two distinct file names, one
411 for each `%g.s' and another for each `%U.s'. Previously, %U was
412 simply substituted with a file name chosen for the previous %u,
413 without regard to any appended suffix.
414 %jSUFFIX
415 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
416 writable, and if save-temps is off; otherwise, substitute the name
417 of a temporary file, just like %u. This temporary file is not
418 meant for communication between processes, but rather as a junk
419 disposal mechanism.
420 %.SUFFIX
421 substitutes .SUFFIX for the suffixes of a matched switch's args when
422 it is subsequently output with %*. SUFFIX is terminated by the next
423 space or %.
424 %d marks the argument containing or following the %d as a
425 temporary file name, so that that file will be deleted if CC exits
426 successfully. Unlike %g, this contributes no text to the argument.
427 %w marks the argument containing or following the %w as the
428 "output file" of this compilation. This puts the argument
429 into the sequence of arguments that %o will substitute later.
430 %V indicates that this compilation produces no "output file".
431 %W{...}
432 like %{...} but mark last argument supplied within
433 as a file to be deleted on failure.
434 %o substitutes the names of all the output files, with spaces
435 automatically placed around them. You should write spaces
436 around the %o as well or the results are undefined.
437 %o is for use in the specs for running the linker.
438 Input files whose names have no recognized suffix are not compiled
439 at all, but they are included among the output files, so they will
440 be linked.
441 %O substitutes the suffix for object files. Note that this is
442 handled specially when it immediately follows %g, %u, or %U
443 (with or without a suffix argument) because of the need for
444 those to form complete file names. The handling is such that
445 %O is treated exactly as if it had already been substituted,
446 except that %g, %u, and %U do not currently support additional
447 SUFFIX characters following %O as they would following, for
448 example, `.o'.
449 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
450 (made from TARGET_SYSTEM_ROOT), and -isystem (made from COMPILER_PATH
451 and -B options) as necessary.
452 %s current argument is the name of a library or startup file of some sort.
453 Search for that file in a standard list of directories
454 and substitute the full name found.
455 %eSTR Print STR as an error message. STR is terminated by a newline.
456 Use this when inconsistent options are detected.
457 %nSTR Print STR as a notice. STR is terminated by a newline.
458 %x{OPTION} Accumulate an option for %X.
459 %X Output the accumulated linker options specified by compilations.
460 %Y Output the accumulated assembler options specified by compilations.
461 %Z Output the accumulated preprocessor options specified by compilations.
462 %a process ASM_SPEC as a spec.
463 This allows config.h to specify part of the spec for running as.
464 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
465 used here. This can be used to run a post-processor after the
466 assembler has done its job.
467 %D Dump out a -L option for each directory in startfile_prefixes.
468 If multilib_dir is set, extra entries are generated with it affixed.
469 %l process LINK_SPEC as a spec.
470 %L process LIB_SPEC as a spec.
471 %G process LIBGCC_SPEC as a spec.
472 %M output multilib_dir with directory separators replaced with "_";
473 if multilib_dir is not set or is ".", output "".
474 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
475 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
476 %C process CPP_SPEC as a spec.
477 %1 process CC1_SPEC as a spec.
478 %2 process CC1PLUS_SPEC as a spec.
479 %* substitute the variable part of a matched option. (See below.)
480 Note that each comma in the substituted string is replaced by
481 a single space.
482 %<S remove all occurrences of -S from the command line.
483 Note - this command is position dependent. % commands in the
484 spec string before this one will see -S, % commands in the
485 spec string after this one will not.
486 %<S* remove all occurrences of all switches beginning with -S from the
487 command line.
488 %:function(args)
489 Call the named function FUNCTION, passing it ARGS. ARGS is
490 first processed as a nested spec string, then split into an
491 argument vector in the usual fashion. The function returns
492 a string which is processed as if it had appeared literally
493 as part of the current spec.
494 %{S} substitutes the -S switch, if that switch was given to CC.
495 If that switch was not specified, this substitutes nothing.
496 Here S is a metasyntactic variable.
497 %{S*} substitutes all the switches specified to CC whose names start
498 with -S. This is used for -o, -I, etc; switches that take
499 arguments. CC considers `-o foo' as being one switch whose
500 name starts with `o'. %{o*} would substitute this text,
501 including the space; thus, two arguments would be generated.
502 %{S*&T*} likewise, but preserve order of S and T options (the order
503 of S and T in the spec is not significant). Can be any number
504 of ampersand-separated variables; for each the wild card is
505 optional. Useful for CPP as %{D*&U*&A*}.
506
507 %{S:X} substitutes X, if the -S switch was given to CC.
508 %{!S:X} substitutes X, if the -S switch was NOT given to CC.
509 %{S*:X} substitutes X if one or more switches whose names start
510 with -S was given to CC. Normally X is substituted only
511 once, no matter how many such switches appeared. However,
512 if %* appears somewhere in X, then X will be substituted
513 once for each matching switch, with the %* replaced by the
514 part of that switch that matched the '*'.
515 %{.S:X} substitutes X, if processing a file with suffix S.
516 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
517
518 %{S|T:X} substitutes X if either -S or -T was given to CC. This may be
519 combined with !, ., and * as above binding stronger than the OR.
520 If %* appears in X, all of the alternatives must be starred, and
521 only the first matching alternative is substituted.
522 %{S:X; if S was given to CC, substitutes X;
523 T:Y; else if T was given to CC, substitutes Y;
524 :D} else substitutes D. There can be as many clauses as you need.
525 This may be combined with ., !, |, and * as above.
526
527 %(Spec) processes a specification defined in a specs file as *Spec:
528 %[Spec] as above, but put __ around -D arguments
529
530 The conditional text X in a %{S:X} or similar construct may contain
531 other nested % constructs or spaces, or even newlines. They are
532 processed as usual, as described above. Trailing white space in X is
533 ignored. White space may also appear anywhere on the left side of the
534 colon in these constructs, except between . or * and the corresponding
535 word.
536
537 The -O, -f, -m, and -W switches are handled specifically in these
538 constructs. If another value of -O or the negated form of a -f, -m, or
539 -W switch is found later in the command line, the earlier switch
540 value is ignored, except with {S*} where S is just one letter; this
541 passes all matching options.
542
543 The character | at the beginning of the predicate text is used to indicate
544 that a command should be piped to the following command, but only if -pipe
545 is specified.
546
547 Note that it is built into CC which switches take arguments and which
548 do not. You might think it would be useful to generalize this to
549 allow each compiler's spec to say which switches take arguments. But
550 this cannot be done in a consistent fashion. CC cannot even decide
551 which input files have been specified without knowing which switches
552 take arguments, and it must know which input files to compile in order
553 to tell which compilers to run.
554
555 CC also knows implicitly that arguments starting in `-l' are to be
556 treated as compiler output files, and passed to the linker in their
557 proper position among the other output files. */
558 \f
559 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
560
561 /* config.h can define ASM_SPEC to provide extra args to the assembler
562 or extra switch-translations. */
563 #ifndef ASM_SPEC
564 #define ASM_SPEC ""
565 #endif
566
567 /* config.h can define ASM_FINAL_SPEC to run a post processor after
568 the assembler has run. */
569 #ifndef ASM_FINAL_SPEC
570 #define ASM_FINAL_SPEC ""
571 #endif
572
573 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
574 or extra switch-translations. */
575 #ifndef CPP_SPEC
576 #define CPP_SPEC ""
577 #endif
578
579 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
580 or extra switch-translations. */
581 #ifndef CC1_SPEC
582 #define CC1_SPEC ""
583 #endif
584
585 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
586 or extra switch-translations. */
587 #ifndef CC1PLUS_SPEC
588 #define CC1PLUS_SPEC ""
589 #endif
590
591 /* config.h can define LINK_SPEC to provide extra args to the linker
592 or extra switch-translations. */
593 #ifndef LINK_SPEC
594 #define LINK_SPEC ""
595 #endif
596
597 /* config.h can define LIB_SPEC to override the default libraries. */
598 #ifndef LIB_SPEC
599 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
600 #endif
601
602 /* mudflap specs */
603 #ifndef MFWRAP_SPEC
604 /* XXX: valid only for GNU ld */
605 /* XXX: should exactly match hooks provided by libmudflap.a */
606 #define MFWRAP_SPEC " %{static: %{fmudflap|fmudflapth: \
607 --wrap=malloc --wrap=free --wrap=calloc --wrap=realloc\
608 --wrap=mmap --wrap=munmap --wrap=alloca\
609 } %{fmudflapth: --wrap=pthread_create --wrap=pthread_join --wrap=pthread_exit\
610 }} %{fmudflap|fmudflapth: --wrap=main}"
611 #endif
612 #ifndef MFLIB_SPEC
613 #define MFLIB_SPEC " %{fmudflap: -export-dynamic -lmudflap %{static:%(link_gcc_c_sequence) -lmudflap}} %{fmudflapth: -export-dynamic -lmudflapth -lpthread %{static:%(link_gcc_c_sequence) -lmudflapth}} "
614 #endif
615
616 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
617 included. */
618 #ifndef LIBGCC_SPEC
619 #if defined(REAL_LIBGCC_SPEC)
620 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
621 #elif defined(LINK_LIBGCC_SPECIAL) || defined(LINK_LIBGCC_SPECIAL_1)
622 /* Have gcc do the search for libgcc.a. */
623 #define LIBGCC_SPEC "libgcc.a%s"
624 #else
625 #define LIBGCC_SPEC "-lgcc"
626 #endif
627 #endif
628
629 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
630 #ifndef STARTFILE_SPEC
631 #define STARTFILE_SPEC \
632 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
633 #endif
634
635 /* config.h can define SWITCHES_NEED_SPACES to control which options
636 require spaces between the option and the argument. */
637 #ifndef SWITCHES_NEED_SPACES
638 #define SWITCHES_NEED_SPACES ""
639 #endif
640
641 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
642 #ifndef ENDFILE_SPEC
643 #define ENDFILE_SPEC ""
644 #endif
645
646 #ifndef LINKER_NAME
647 #define LINKER_NAME "collect2"
648 #endif
649
650 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
651 to the assembler. */
652 #ifndef ASM_DEBUG_SPEC
653 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
654 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
655 # define ASM_DEBUG_SPEC \
656 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
657 ? "%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}" \
658 : "%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}")
659 # else
660 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
661 # define ASM_DEBUG_SPEC "%{g*:--gstabs}"
662 # endif
663 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
664 # define ASM_DEBUG_SPEC "%{g*:--gdwarf2}"
665 # endif
666 # endif
667 #endif
668 #ifndef ASM_DEBUG_SPEC
669 # define ASM_DEBUG_SPEC ""
670 #endif
671
672 /* Here is the spec for running the linker, after compiling all files. */
673
674 /* This is overridable by the target in case they need to specify the
675 -lgcc and -lc order specially, yet not require them to override all
676 of LINK_COMMAND_SPEC. */
677 #ifndef LINK_GCC_C_SEQUENCE_SPEC
678 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
679 #endif
680
681 #ifndef LINK_PIE_SPEC
682 #ifdef HAVE_LD_PIE
683 #define LINK_PIE_SPEC "%{pie:-pie} "
684 #else
685 #define LINK_PIE_SPEC "%{pie:} "
686 #endif
687 #endif
688
689 /* -u* was put back because both BSD and SysV seem to support it. */
690 /* %{static:} simply prevents an error message if the target machine
691 doesn't handle -static. */
692 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
693 scripts which exist in user specified directories, or in standard
694 directories. */
695 #ifndef LINK_COMMAND_SPEC
696 #define LINK_COMMAND_SPEC "\
697 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
698 %(linker) %l " LINK_PIE_SPEC "%X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} %{r}\
699 %{s} %{t} %{u*} %{x} %{z} %{Z} %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
700 %{static:} %{L*} %(mfwrap) %(link_libgcc) %o %(mflib)\
701 %{fprofile-arcs|fprofile-generate:-lgcov}\
702 %{!nostdlib:%{!nodefaultlibs:%(link_gcc_c_sequence)}}\
703 %{!A:%{!nostdlib:%{!nostartfiles:%E}}} %{T*} }}}}}}"
704 #endif
705
706 #ifndef LINK_LIBGCC_SPEC
707 # ifdef LINK_LIBGCC_SPECIAL
708 /* Don't generate -L options for startfile prefix list. */
709 # define LINK_LIBGCC_SPEC ""
710 # else
711 /* Do generate them. */
712 # define LINK_LIBGCC_SPEC "%D"
713 # endif
714 #endif
715
716 #ifndef STARTFILE_PREFIX_SPEC
717 # define STARTFILE_PREFIX_SPEC ""
718 #endif
719
720 #ifndef SYSROOT_SUFFIX_SPEC
721 # define SYSROOT_SUFFIX_SPEC ""
722 #endif
723
724 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
725 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
726 #endif
727
728 static const char *asm_debug;
729 static const char *cpp_spec = CPP_SPEC;
730 static const char *cc1_spec = CC1_SPEC;
731 static const char *cc1plus_spec = CC1PLUS_SPEC;
732 static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC;
733 static const char *asm_spec = ASM_SPEC;
734 static const char *asm_final_spec = ASM_FINAL_SPEC;
735 static const char *link_spec = LINK_SPEC;
736 static const char *lib_spec = LIB_SPEC;
737 static const char *mfwrap_spec = MFWRAP_SPEC;
738 static const char *mflib_spec = MFLIB_SPEC;
739 static const char *libgcc_spec = LIBGCC_SPEC;
740 static const char *endfile_spec = ENDFILE_SPEC;
741 static const char *startfile_spec = STARTFILE_SPEC;
742 static const char *switches_need_spaces = SWITCHES_NEED_SPACES;
743 static const char *linker_name_spec = LINKER_NAME;
744 static const char *link_command_spec = LINK_COMMAND_SPEC;
745 static const char *link_libgcc_spec = LINK_LIBGCC_SPEC;
746 static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC;
747 static const char *sysroot_suffix_spec = SYSROOT_SUFFIX_SPEC;
748 static const char *sysroot_hdrs_suffix_spec = SYSROOT_HEADERS_SUFFIX_SPEC;
749
750 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
751 There should be no need to override these in target dependent files,
752 but we need to copy them to the specs file so that newer versions
753 of the GCC driver can correctly drive older tool chains with the
754 appropriate -B options. */
755
756 /* When cpplib handles traditional preprocessing, get rid of this, and
757 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
758 that we default the front end language better. */
759 static const char *trad_capable_cpp =
760 "cc1 -E %{traditional|ftraditional|traditional-cpp:-traditional-cpp}";
761
762 /* We don't wrap .d files in %W{} since a missing .d file, and
763 therefore no dependency entry, confuses make into thinking a .o
764 file that happens to exist is up-to-date. */
765 static const char *cpp_unique_options =
766 "%{C|CC:%{!E:%eGCC does not support -C or -CC without -E}}\
767 %{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\
768 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
769 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
770 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
771 %{!E:%{!M:%{!MM:%{MD|MMD:%{o*:-MQ %*}}}}}\
772 %{trigraphs} %{remap} %{g3:-dD} %{H} %C %{D*&U*&A*} %{i*} %Z %i\
773 %{fmudflap:-D_MUDFLAP -include mf-runtime.h}\
774 %{fmudflapth:-D_MUDFLAP -D_MUDFLAPTH -include mf-runtime.h}\
775 %{E|M|MM:%W{o*}}";
776
777 /* This contains cpp options which are common with cc1_options and are passed
778 only when preprocessing only to avoid duplication. We pass the cc1 spec
779 options to the preprocessor so that it the cc1 spec may manipulate
780 options used to set target flags. Those special target flags settings may
781 in turn cause preprocessor symbols to be defined specially. */
782 static const char *cpp_options =
783 "%(cpp_unique_options) %1 %{m*} %{std*} %{ansi} %{W*&pedantic*} %{w} %{f*}\
784 %{g*:%{!g0:%{!fno-working-directory:-fworking-directory}}} %{O*} %{undef}";
785
786 /* This contains cpp options which are not passed when the preprocessor
787 output will be used by another program. */
788 static const char *cpp_debug_options = "%{d*}";
789
790 /* NB: This is shared amongst all front-ends. */
791 static const char *cc1_options =
792 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
793 %1 %{!Q:-quiet} -dumpbase %B %{d*} %{m*} %{a*}\
794 %{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}%{!c:%{!S:-auxbase %b}}\
795 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*} %{ansi}\
796 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
797 %{Qn:-fno-ident} %{--help:--help}\
798 %{--target-help:--target-help}\
799 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
800 %{fsyntax-only:-o %j} %{-param*}\
801 %{fmudflap|fmudflapth:-fno-builtin -fno-merge-constants}";
802
803 static const char *asm_options =
804 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
805
806 static const char *invoke_as =
807 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
808 "%{!S:-o %|.s |\n as %(asm_options) %|.s %A }";
809 #else
810 "%{!S:-o %|.s |\n as %(asm_options) %m.s %A }";
811 #endif
812
813 /* Some compilers have limits on line lengths, and the multilib_select
814 and/or multilib_matches strings can be very long, so we build them at
815 run time. */
816 static struct obstack multilib_obstack;
817 static const char *multilib_select;
818 static const char *multilib_matches;
819 static const char *multilib_defaults;
820 static const char *multilib_exclusions;
821
822 /* Check whether a particular argument is a default argument. */
823
824 #ifndef MULTILIB_DEFAULTS
825 #define MULTILIB_DEFAULTS { "" }
826 #endif
827
828 static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
829
830 #ifndef DRIVER_SELF_SPECS
831 #define DRIVER_SELF_SPECS ""
832 #endif
833
834 static const char *const driver_self_specs[] = { DRIVER_SELF_SPECS };
835
836 #ifndef OPTION_DEFAULT_SPECS
837 #define OPTION_DEFAULT_SPECS { "", "" }
838 #endif
839
840 struct default_spec
841 {
842 const char *name;
843 const char *spec;
844 };
845
846 static const struct default_spec
847 option_default_specs[] = { OPTION_DEFAULT_SPECS };
848
849 struct user_specs
850 {
851 struct user_specs *next;
852 const char *filename;
853 };
854
855 static struct user_specs *user_specs_head, *user_specs_tail;
856
857 #ifndef SWITCH_TAKES_ARG
858 #define SWITCH_TAKES_ARG(CHAR) DEFAULT_SWITCH_TAKES_ARG(CHAR)
859 #endif
860
861 #ifndef WORD_SWITCH_TAKES_ARG
862 #define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR)
863 #endif
864 \f
865 #ifdef HAVE_TARGET_EXECUTABLE_SUFFIX
866 /* This defines which switches stop a full compilation. */
867 #define DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) \
868 ((CHAR) == 'c' || (CHAR) == 'S')
869
870 #ifndef SWITCH_CURTAILS_COMPILATION
871 #define SWITCH_CURTAILS_COMPILATION(CHAR) \
872 DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR)
873 #endif
874 #endif
875
876 /* Record the mapping from file suffixes for compilation specs. */
877
878 struct compiler
879 {
880 const char *suffix; /* Use this compiler for input files
881 whose names end in this suffix. */
882
883 const char *spec; /* To use this compiler, run this spec. */
884
885 const char *cpp_spec; /* If non-NULL, substitute this spec
886 for `%C', rather than the usual
887 cpp_spec. */
888 const int combinable; /* If non-zero, compiler can deal with
889 multiple source files at once (IMA). */
890 const int needs_preprocessing; /* If non-zero, source files need to
891 be run through a preprocessor. */
892 };
893
894 /* Pointer to a vector of `struct compiler' that gives the spec for
895 compiling a file, based on its suffix.
896 A file that does not end in any of these suffixes will be passed
897 unchanged to the loader and nothing else will be done to it.
898
899 An entry containing two 0s is used to terminate the vector.
900
901 If multiple entries match a file, the last matching one is used. */
902
903 static struct compiler *compilers;
904
905 /* Number of entries in `compilers', not counting the null terminator. */
906
907 static int n_compilers;
908
909 /* The default list of file name suffixes and their compilation specs. */
910
911 static const struct compiler default_compilers[] =
912 {
913 /* Add lists of suffixes of known languages here. If those languages
914 were not present when we built the driver, we will hit these copies
915 and be given a more meaningful error than "file not used since
916 linking is not done". */
917 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0},
918 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
919 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
920 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
921 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
922 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
923 {".f", "#Fortran", 0, 0, 0}, {".for", "#Fortran", 0, 0, 0},
924 {".F", "#Fortran", 0}, {".FOR", "#Fortran", 0}, {".FPP", "#Fortran", 0},
925 {".f90", "#Fortran 95", 0}, {".f95", "#Fortran 95", 0},
926 {".fpp", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
927 {".FOR", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
928 {".r", "#Ratfor", 0, 0, 0},
929 {".p", "#Pascal", 0, 0, 0}, {".pas", "#Pascal", 0, 0, 0},
930 {".java", "#Java", 0, 0, 0}, {".class", "#Java", 0, 0, 0},
931 {".zip", "#Java", 0, 0, 0}, {".jar", "#Java", 0, 0, 0},
932 /* Next come the entries for C. */
933 {".c", "@c", 0, 1, 1},
934 {"@c",
935 /* cc1 has an integrated ISO C preprocessor. We should invoke the
936 external preprocessor if -save-temps is given. */
937 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
938 %{!E:%{!M:%{!MM:\
939 %{traditional|ftraditional:\
940 %eGNU C no longer supports -traditional without -E}\
941 %{!combine:\
942 %{save-temps|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
943 %(cpp_options) -o %{save-temps:%b.i} %{!save-temps:%g.i} \n\
944 cc1 -fpreprocessed %{save-temps:%b.i} %{!save-temps:%g.i} \
945 %(cc1_options)}\
946 %{!save-temps:%{!traditional-cpp:%{!no-integrated-cpp:\
947 cc1 %(cpp_unique_options) %(cc1_options)}}}\
948 %{!fsyntax-only:%(invoke_as)}} \
949 %{combine:\
950 %{save-temps|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
951 %(cpp_options) -o %{save-temps:%b.i} %{!save-temps:%g.i}}\
952 %{!save-temps:%{!traditional-cpp:%{!no-integrated-cpp:\
953 cc1 %(cpp_unique_options) %(cc1_options)}}\
954 %{!fsyntax-only:%(invoke_as)}}}}}}", 0, 1, 1},
955 {"-",
956 "%{!E:%e-E required when input is from standard input}\
957 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
958 {".h", "@c-header", 0, 0, 0},
959 {"@c-header",
960 /* cc1 has an integrated ISO C preprocessor. We should invoke the
961 external preprocessor if -save-temps is given. */
962 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
963 %{!E:%{!M:%{!MM:\
964 %{save-temps|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
965 %(cpp_options) -o %{save-temps:%b.i} %{!save-temps:%g.i} \n\
966 cc1 -fpreprocessed %{save-temps:%b.i} %{!save-temps:%g.i} \
967 %(cc1_options)\
968 -o %g.s %{!o*:--output-pch=%i.gch}\
969 %W{o*:--output-pch=%*}%V}\
970 %{!save-temps:%{!traditional-cpp:%{!no-integrated-cpp:\
971 cc1 %(cpp_unique_options) %(cc1_options)\
972 -o %g.s %{!o*:--output-pch=%i.gch}\
973 %W{o*:--output-pch=%*}%V}}}}}}", 0, 0, 0},
974 {".i", "@cpp-output", 0, 1, 0},
975 {"@cpp-output",
976 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 1, 0},
977 {".s", "@assembler", 0, 1, 0},
978 {"@assembler",
979 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 1, 0},
980 {".S", "@assembler-with-cpp", 0, 1, 0},
981 {"@assembler-with-cpp",
982 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
983 "%(trad_capable_cpp) -lang-asm %(cpp_options)\
984 %{E|M|MM:%(cpp_debug_options)}\
985 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
986 as %(asm_debug) %(asm_options) %|.s %A }}}}"
987 #else
988 "%(trad_capable_cpp) -lang-asm %(cpp_options)\
989 %{E|M|MM:%(cpp_debug_options)}\
990 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
991 as %(asm_debug) %(asm_options) %m.s %A }}}}"
992 #endif
993 , 0, 1, 0},
994
995 #include "specs.h"
996 /* Mark end of table. */
997 {0, 0, 0, 0, 0}
998 };
999
1000 /* Number of elements in default_compilers, not counting the terminator. */
1001
1002 static const int n_default_compilers = ARRAY_SIZE (default_compilers) - 1;
1003
1004 /* A vector of options to give to the linker.
1005 These options are accumulated by %x,
1006 and substituted into the linker command with %X. */
1007 static int n_linker_options;
1008 static char **linker_options;
1009
1010 /* A vector of options to give to the assembler.
1011 These options are accumulated by -Wa,
1012 and substituted into the assembler command with %Y. */
1013 static int n_assembler_options;
1014 static char **assembler_options;
1015
1016 /* A vector of options to give to the preprocessor.
1017 These options are accumulated by -Wp,
1018 and substituted into the preprocessor command with %Z. */
1019 static int n_preprocessor_options;
1020 static char **preprocessor_options;
1021 \f
1022 /* Define how to map long options into short ones. */
1023
1024 /* This structure describes one mapping. */
1025 struct option_map
1026 {
1027 /* The long option's name. */
1028 const char *const name;
1029 /* The equivalent short option. */
1030 const char *const equivalent;
1031 /* Argument info. A string of flag chars; NULL equals no options.
1032 a => argument required.
1033 o => argument optional.
1034 j => join argument to equivalent, making one word.
1035 * => require other text after NAME as an argument. */
1036 const char *const arg_info;
1037 };
1038
1039 /* This is the table of mappings. Mappings are tried sequentially
1040 for each option encountered; the first one that matches, wins. */
1041
1042 static const struct option_map option_map[] =
1043 {
1044 {"--all-warnings", "-Wall", 0},
1045 {"--ansi", "-ansi", 0},
1046 {"--assemble", "-S", 0},
1047 {"--assert", "-A", "a"},
1048 {"--classpath", "-fclasspath=", "aj"},
1049 {"--bootclasspath", "-fbootclasspath=", "aj"},
1050 {"--CLASSPATH", "-fclasspath=", "aj"},
1051 {"--combine", "-combine", 0},
1052 {"--comments", "-C", 0},
1053 {"--comments-in-macros", "-CC", 0},
1054 {"--compile", "-c", 0},
1055 {"--debug", "-g", "oj"},
1056 {"--define-macro", "-D", "aj"},
1057 {"--dependencies", "-M", 0},
1058 {"--dump", "-d", "a"},
1059 {"--dumpbase", "-dumpbase", "a"},
1060 {"--entry", "-e", 0},
1061 {"--extra-warnings", "-W", 0},
1062 {"--for-assembler", "-Wa", "a"},
1063 {"--for-linker", "-Xlinker", "a"},
1064 {"--force-link", "-u", "a"},
1065 {"--imacros", "-imacros", "a"},
1066 {"--include", "-include", "a"},
1067 {"--include-barrier", "-I-", 0},
1068 {"--include-directory", "-I", "aj"},
1069 {"--include-directory-after", "-idirafter", "a"},
1070 {"--include-prefix", "-iprefix", "a"},
1071 {"--include-with-prefix", "-iwithprefix", "a"},
1072 {"--include-with-prefix-before", "-iwithprefixbefore", "a"},
1073 {"--include-with-prefix-after", "-iwithprefix", "a"},
1074 {"--language", "-x", "a"},
1075 {"--library-directory", "-L", "a"},
1076 {"--machine", "-m", "aj"},
1077 {"--machine-", "-m", "*j"},
1078 {"--no-integrated-cpp", "-no-integrated-cpp", 0},
1079 {"--no-line-commands", "-P", 0},
1080 {"--no-precompiled-includes", "-noprecomp", 0},
1081 {"--no-standard-includes", "-nostdinc", 0},
1082 {"--no-standard-libraries", "-nostdlib", 0},
1083 {"--no-warnings", "-w", 0},
1084 {"--optimize", "-O", "oj"},
1085 {"--output", "-o", "a"},
1086 {"--output-class-directory", "-foutput-class-dir=", "ja"},
1087 {"--param", "--param", "a"},
1088 {"--pedantic", "-pedantic", 0},
1089 {"--pedantic-errors", "-pedantic-errors", 0},
1090 {"--pie", "-pie", 0},
1091 {"--pipe", "-pipe", 0},
1092 {"--prefix", "-B", "a"},
1093 {"--preprocess", "-E", 0},
1094 {"--print-search-dirs", "-print-search-dirs", 0},
1095 {"--print-file-name", "-print-file-name=", "aj"},
1096 {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
1097 {"--print-missing-file-dependencies", "-MG", 0},
1098 {"--print-multi-lib", "-print-multi-lib", 0},
1099 {"--print-multi-directory", "-print-multi-directory", 0},
1100 {"--print-multi-os-directory", "-print-multi-os-directory", 0},
1101 {"--print-prog-name", "-print-prog-name=", "aj"},
1102 {"--profile", "-p", 0},
1103 {"--profile-blocks", "-a", 0},
1104 {"--quiet", "-q", 0},
1105 {"--resource", "-fcompile-resource=", "aj"},
1106 {"--save-temps", "-save-temps", 0},
1107 {"--shared", "-shared", 0},
1108 {"--silent", "-q", 0},
1109 {"--specs", "-specs=", "aj"},
1110 {"--static", "-static", 0},
1111 {"--std", "-std=", "aj"},
1112 {"--symbolic", "-symbolic", 0},
1113 {"--time", "-time", 0},
1114 {"--trace-includes", "-H", 0},
1115 {"--traditional", "-traditional", 0},
1116 {"--traditional-cpp", "-traditional-cpp", 0},
1117 {"--trigraphs", "-trigraphs", 0},
1118 {"--undefine-macro", "-U", "aj"},
1119 {"--user-dependencies", "-MM", 0},
1120 {"--verbose", "-v", 0},
1121 {"--warn-", "-W", "*j"},
1122 {"--write-dependencies", "-MD", 0},
1123 {"--write-user-dependencies", "-MMD", 0},
1124 {"--", "-f", "*j"}
1125 };
1126 \f
1127
1128 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1129 static const struct {
1130 const char *const option_found;
1131 const char *const replacements;
1132 } target_option_translations[] =
1133 {
1134 TARGET_OPTION_TRANSLATE_TABLE,
1135 { 0, 0 }
1136 };
1137 #endif
1138
1139 /* Translate the options described by *ARGCP and *ARGVP.
1140 Make a new vector and store it back in *ARGVP,
1141 and store its length in *ARGVC. */
1142
1143 static void
1144 translate_options (int *argcp, const char *const **argvp)
1145 {
1146 int i;
1147 int argc = *argcp;
1148 const char *const *argv = *argvp;
1149 int newvsize = (argc + 2) * 2 * sizeof (const char *);
1150 const char **newv = xmalloc (newvsize);
1151 int newindex = 0;
1152
1153 i = 0;
1154 newv[newindex++] = argv[i++];
1155
1156 while (i < argc)
1157 {
1158 #ifdef TARGET_OPTION_TRANSLATE_TABLE
1159 int tott_idx;
1160
1161 for (tott_idx = 0;
1162 target_option_translations[tott_idx].option_found;
1163 tott_idx++)
1164 {
1165 if (strcmp (target_option_translations[tott_idx].option_found,
1166 argv[i]) == 0)
1167 {
1168 int spaces = 1;
1169 const char *sp;
1170 char *np;
1171
1172 for (sp = target_option_translations[tott_idx].replacements;
1173 *sp; sp++)
1174 {
1175 if (*sp == ' ')
1176 spaces ++;
1177 }
1178
1179 newvsize += spaces * sizeof (const char *);
1180 newv = xrealloc (newv, newvsize);
1181
1182 sp = target_option_translations[tott_idx].replacements;
1183 np = xstrdup (sp);
1184
1185 while (1)
1186 {
1187 while (*np == ' ')
1188 np++;
1189 if (*np == 0)
1190 break;
1191 newv[newindex++] = np;
1192 while (*np != ' ' && *np)
1193 np++;
1194 if (*np == 0)
1195 break;
1196 *np++ = 0;
1197 }
1198
1199 i ++;
1200 break;
1201 }
1202 }
1203 if (target_option_translations[tott_idx].option_found)
1204 continue;
1205 #endif
1206
1207 /* Translate -- options. */
1208 if (argv[i][0] == '-' && argv[i][1] == '-')
1209 {
1210 size_t j;
1211 /* Find a mapping that applies to this option. */
1212 for (j = 0; j < ARRAY_SIZE (option_map); j++)
1213 {
1214 size_t optlen = strlen (option_map[j].name);
1215 size_t arglen = strlen (argv[i]);
1216 size_t complen = arglen > optlen ? optlen : arglen;
1217 const char *arginfo = option_map[j].arg_info;
1218
1219 if (arginfo == 0)
1220 arginfo = "";
1221
1222 if (!strncmp (argv[i], option_map[j].name, complen))
1223 {
1224 const char *arg = 0;
1225
1226 if (arglen < optlen)
1227 {
1228 size_t k;
1229 for (k = j + 1; k < ARRAY_SIZE (option_map); k++)
1230 if (strlen (option_map[k].name) >= arglen
1231 && !strncmp (argv[i], option_map[k].name, arglen))
1232 {
1233 error ("ambiguous abbreviation %s", argv[i]);
1234 break;
1235 }
1236
1237 if (k != ARRAY_SIZE (option_map))
1238 break;
1239 }
1240
1241 if (arglen > optlen)
1242 {
1243 /* If the option has an argument, accept that. */
1244 if (argv[i][optlen] == '=')
1245 arg = argv[i] + optlen + 1;
1246
1247 /* If this mapping requires extra text at end of name,
1248 accept that as "argument". */
1249 else if (strchr (arginfo, '*') != 0)
1250 arg = argv[i] + optlen;
1251
1252 /* Otherwise, extra text at end means mismatch.
1253 Try other mappings. */
1254 else
1255 continue;
1256 }
1257
1258 else if (strchr (arginfo, '*') != 0)
1259 {
1260 error ("incomplete `%s' option", option_map[j].name);
1261 break;
1262 }
1263
1264 /* Handle arguments. */
1265 if (strchr (arginfo, 'a') != 0)
1266 {
1267 if (arg == 0)
1268 {
1269 if (i + 1 == argc)
1270 {
1271 error ("missing argument to `%s' option",
1272 option_map[j].name);
1273 break;
1274 }
1275
1276 arg = argv[++i];
1277 }
1278 }
1279 else if (strchr (arginfo, '*') != 0)
1280 ;
1281 else if (strchr (arginfo, 'o') == 0)
1282 {
1283 if (arg != 0)
1284 error ("extraneous argument to `%s' option",
1285 option_map[j].name);
1286 arg = 0;
1287 }
1288
1289 /* Store the translation as one argv elt or as two. */
1290 if (arg != 0 && strchr (arginfo, 'j') != 0)
1291 newv[newindex++] = concat (option_map[j].equivalent, arg,
1292 NULL);
1293 else if (arg != 0)
1294 {
1295 newv[newindex++] = option_map[j].equivalent;
1296 newv[newindex++] = arg;
1297 }
1298 else
1299 newv[newindex++] = option_map[j].equivalent;
1300
1301 break;
1302 }
1303 }
1304 i++;
1305 }
1306
1307 /* Handle old-fashioned options--just copy them through,
1308 with their arguments. */
1309 else if (argv[i][0] == '-')
1310 {
1311 const char *p = argv[i] + 1;
1312 int c = *p;
1313 int nskip = 1;
1314
1315 if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
1316 nskip += SWITCH_TAKES_ARG (c) - (p[1] != 0);
1317 else if (WORD_SWITCH_TAKES_ARG (p))
1318 nskip += WORD_SWITCH_TAKES_ARG (p);
1319 else if ((c == 'B' || c == 'b' || c == 'x')
1320 && p[1] == 0)
1321 nskip += 1;
1322 else if (! strcmp (p, "Xlinker"))
1323 nskip += 1;
1324 else if (! strcmp (p, "Xpreprocessor"))
1325 nskip += 1;
1326 else if (! strcmp (p, "Xassembler"))
1327 nskip += 1;
1328
1329 /* Watch out for an option at the end of the command line that
1330 is missing arguments, and avoid skipping past the end of the
1331 command line. */
1332 if (nskip + i > argc)
1333 nskip = argc - i;
1334
1335 while (nskip > 0)
1336 {
1337 newv[newindex++] = argv[i++];
1338 nskip--;
1339 }
1340 }
1341 else
1342 /* Ordinary operands, or +e options. */
1343 newv[newindex++] = argv[i++];
1344 }
1345
1346 newv[newindex] = 0;
1347
1348 *argvp = newv;
1349 *argcp = newindex;
1350 }
1351 \f
1352 static char *
1353 skip_whitespace (char *p)
1354 {
1355 while (1)
1356 {
1357 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1358 be considered whitespace. */
1359 if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
1360 return p + 1;
1361 else if (*p == '\n' || *p == ' ' || *p == '\t')
1362 p++;
1363 else if (*p == '#')
1364 {
1365 while (*p != '\n')
1366 p++;
1367 p++;
1368 }
1369 else
1370 break;
1371 }
1372
1373 return p;
1374 }
1375 /* Structures to keep track of prefixes to try when looking for files. */
1376
1377 struct prefix_list
1378 {
1379 const char *prefix; /* String to prepend to the path. */
1380 struct prefix_list *next; /* Next in linked list. */
1381 int require_machine_suffix; /* Don't use without machine_suffix. */
1382 /* 2 means try both machine_suffix and just_machine_suffix. */
1383 int *used_flag_ptr; /* 1 if a file was found with this prefix. */
1384 int priority; /* Sort key - priority within list. */
1385 int os_multilib; /* 1 if OS multilib scheme should be used,
1386 0 for GCC multilib scheme. */
1387 };
1388
1389 struct path_prefix
1390 {
1391 struct prefix_list *plist; /* List of prefixes to try */
1392 int max_len; /* Max length of a prefix in PLIST */
1393 const char *name; /* Name of this list (used in config stuff) */
1394 };
1395
1396 /* List of prefixes to try when looking for executables. */
1397
1398 static struct path_prefix exec_prefixes = { 0, 0, "exec" };
1399
1400 /* List of prefixes to try when looking for startup (crt0) files. */
1401
1402 static struct path_prefix startfile_prefixes = { 0, 0, "startfile" };
1403
1404 /* List of prefixes to try when looking for include files. */
1405
1406 static struct path_prefix include_prefixes = { 0, 0, "include" };
1407
1408 /* Suffix to attach to directories searched for commands.
1409 This looks like `MACHINE/VERSION/'. */
1410
1411 static const char *machine_suffix = 0;
1412
1413 /* Suffix to attach to directories searched for commands.
1414 This is just `MACHINE/'. */
1415
1416 static const char *just_machine_suffix = 0;
1417
1418 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1419
1420 static const char *gcc_exec_prefix;
1421
1422 /* Adjusted value of standard_libexec_prefix. */
1423
1424 static const char *gcc_libexec_prefix;
1425
1426 /* Default prefixes to attach to command names. */
1427
1428 #ifdef CROSS_COMPILE /* Don't use these prefixes for a cross compiler. */
1429 #undef MD_EXEC_PREFIX
1430 #undef MD_STARTFILE_PREFIX
1431 #undef MD_STARTFILE_PREFIX_1
1432 #endif
1433
1434 /* If no prefixes defined, use the null string, which will disable them. */
1435 #ifndef MD_EXEC_PREFIX
1436 #define MD_EXEC_PREFIX ""
1437 #endif
1438 #ifndef MD_STARTFILE_PREFIX
1439 #define MD_STARTFILE_PREFIX ""
1440 #endif
1441 #ifndef MD_STARTFILE_PREFIX_1
1442 #define MD_STARTFILE_PREFIX_1 ""
1443 #endif
1444
1445 static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
1446 static const char *const standard_exec_prefix_1 = "/usr/libexec/gcc/";
1447 static const char *const standard_exec_prefix_2 = "/usr/lib/gcc/";
1448 static const char *md_exec_prefix = MD_EXEC_PREFIX;
1449
1450 static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1451 static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1452 static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1453 static const char *const standard_startfile_prefix_1 = "/lib/";
1454 static const char *const standard_startfile_prefix_2 = "/usr/lib/";
1455
1456 static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1457 static const char *tooldir_prefix;
1458
1459 static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
1460
1461 static const char *standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX;
1462
1463 /* Subdirectory to use for locating libraries. Set by
1464 set_multilib_dir based on the compilation options. */
1465
1466 static const char *multilib_dir;
1467
1468 /* Subdirectory to use for locating libraries in OS conventions. Set by
1469 set_multilib_dir based on the compilation options. */
1470
1471 static const char *multilib_os_dir;
1472 \f
1473 /* Structure to keep track of the specs that have been defined so far.
1474 These are accessed using %(specname) or %[specname] in a compiler
1475 or link spec. */
1476
1477 struct spec_list
1478 {
1479 /* The following 2 fields must be first */
1480 /* to allow EXTRA_SPECS to be initialized */
1481 const char *name; /* name of the spec. */
1482 const char *ptr; /* available ptr if no static pointer */
1483
1484 /* The following fields are not initialized */
1485 /* by EXTRA_SPECS */
1486 const char **ptr_spec; /* pointer to the spec itself. */
1487 struct spec_list *next; /* Next spec in linked list. */
1488 int name_len; /* length of the name */
1489 int alloc_p; /* whether string was allocated */
1490 };
1491
1492 #define INIT_STATIC_SPEC(NAME,PTR) \
1493 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 }
1494
1495 /* List of statically defined specs. */
1496 static struct spec_list static_specs[] =
1497 {
1498 INIT_STATIC_SPEC ("asm", &asm_spec),
1499 INIT_STATIC_SPEC ("asm_debug", &asm_debug),
1500 INIT_STATIC_SPEC ("asm_final", &asm_final_spec),
1501 INIT_STATIC_SPEC ("asm_options", &asm_options),
1502 INIT_STATIC_SPEC ("invoke_as", &invoke_as),
1503 INIT_STATIC_SPEC ("cpp", &cpp_spec),
1504 INIT_STATIC_SPEC ("cpp_options", &cpp_options),
1505 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options),
1506 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options),
1507 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp),
1508 INIT_STATIC_SPEC ("cc1", &cc1_spec),
1509 INIT_STATIC_SPEC ("cc1_options", &cc1_options),
1510 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec),
1511 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec),
1512 INIT_STATIC_SPEC ("endfile", &endfile_spec),
1513 INIT_STATIC_SPEC ("link", &link_spec),
1514 INIT_STATIC_SPEC ("lib", &lib_spec),
1515 INIT_STATIC_SPEC ("mfwrap", &mfwrap_spec),
1516 INIT_STATIC_SPEC ("mflib", &mflib_spec),
1517 INIT_STATIC_SPEC ("libgcc", &libgcc_spec),
1518 INIT_STATIC_SPEC ("startfile", &startfile_spec),
1519 INIT_STATIC_SPEC ("switches_need_spaces", &switches_need_spaces),
1520 INIT_STATIC_SPEC ("cross_compile", &cross_compile),
1521 INIT_STATIC_SPEC ("version", &compiler_version),
1522 INIT_STATIC_SPEC ("multilib", &multilib_select),
1523 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults),
1524 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra),
1525 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches),
1526 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions),
1527 INIT_STATIC_SPEC ("multilib_options", &multilib_options),
1528 INIT_STATIC_SPEC ("linker", &linker_name_spec),
1529 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec),
1530 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix),
1531 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix),
1532 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1),
1533 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec),
1534 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec),
1535 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec),
1536 };
1537
1538 #ifdef EXTRA_SPECS /* additional specs needed */
1539 /* Structure to keep track of just the first two args of a spec_list.
1540 That is all that the EXTRA_SPECS macro gives us. */
1541 struct spec_list_1
1542 {
1543 const char *const name;
1544 const char *const ptr;
1545 };
1546
1547 static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1548 static struct spec_list *extra_specs = (struct spec_list *) 0;
1549 #endif
1550
1551 /* List of dynamically allocates specs that have been defined so far. */
1552
1553 static struct spec_list *specs = (struct spec_list *) 0;
1554 \f
1555 /* List of static spec functions. */
1556
1557 static const struct spec_function static_spec_functions[] =
1558 {
1559 { "if-exists", if_exists_spec_function },
1560 { "if-exists-else", if_exists_else_spec_function },
1561 { 0, 0 }
1562 };
1563
1564 static int processing_spec_function;
1565 \f
1566 /* Add appropriate libgcc specs to OBSTACK, taking into account
1567 various permutations of -shared-libgcc, -shared, and such. */
1568
1569 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1570
1571 #ifndef USE_LD_AS_NEEDED
1572 #define USE_LD_AS_NEEDED 0
1573 #endif
1574
1575 static void
1576 init_gcc_specs (struct obstack *obstack, const char *shared_name,
1577 const char *static_name, const char *eh_name)
1578 {
1579 char *buf;
1580
1581 buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name,
1582 "}%{!static:%{!static-libgcc:",
1583 #if USE_LD_AS_NEEDED
1584 "%{!shared-libgcc:", static_name,
1585 " --as-needed ", shared_name, " --no-as-needed}"
1586 "%{shared-libgcc:", shared_name, "%{!shared: ", static_name,
1587 "}",
1588 #else
1589 "%{!shared:%{!shared-libgcc:", static_name, " ",
1590 eh_name, "}%{shared-libgcc:", shared_name, " ",
1591 static_name, "}}%{shared:",
1592 #ifdef LINK_EH_SPEC
1593 "%{shared-libgcc:", shared_name,
1594 "}%{!shared-libgcc:", static_name, "}",
1595 #else
1596 shared_name,
1597 #endif
1598 #endif
1599 "}}}", NULL);
1600
1601 obstack_grow (obstack, buf, strlen (buf));
1602 free (buf);
1603 }
1604 #endif /* ENABLE_SHARED_LIBGCC */
1605
1606 /* Initialize the specs lookup routines. */
1607
1608 static void
1609 init_spec (void)
1610 {
1611 struct spec_list *next = (struct spec_list *) 0;
1612 struct spec_list *sl = (struct spec_list *) 0;
1613 int i;
1614
1615 if (specs)
1616 return; /* Already initialized. */
1617
1618 if (verbose_flag)
1619 notice ("Using built-in specs.\n");
1620
1621 #ifdef EXTRA_SPECS
1622 extra_specs = xcalloc (sizeof (struct spec_list),
1623 ARRAY_SIZE (extra_specs_1));
1624
1625 for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--)
1626 {
1627 sl = &extra_specs[i];
1628 sl->name = extra_specs_1[i].name;
1629 sl->ptr = extra_specs_1[i].ptr;
1630 sl->next = next;
1631 sl->name_len = strlen (sl->name);
1632 sl->ptr_spec = &sl->ptr;
1633 next = sl;
1634 }
1635 #endif
1636
1637 /* Initialize here, not in definition. The IRIX 6 O32 cc sometimes chokes
1638 on ?: in file-scope variable initializations. */
1639 asm_debug = ASM_DEBUG_SPEC;
1640
1641 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1642 {
1643 sl = &static_specs[i];
1644 sl->next = next;
1645 next = sl;
1646 }
1647
1648 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1649 /* ??? If neither -shared-libgcc nor --static-libgcc was
1650 seen, then we should be making an educated guess. Some proposed
1651 heuristics for ELF include:
1652
1653 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1654 program will be doing dynamic loading, which will likely
1655 need the shared libgcc.
1656
1657 (2) If "-ldl", then it's also a fair bet that we're doing
1658 dynamic loading.
1659
1660 (3) For each ET_DYN we're linking against (either through -lfoo
1661 or /some/path/foo.so), check to see whether it or one of
1662 its dependencies depends on a shared libgcc.
1663
1664 (4) If "-shared"
1665
1666 If the runtime is fixed to look for program headers instead
1667 of calling __register_frame_info at all, for each object,
1668 use the shared libgcc if any EH symbol referenced.
1669
1670 If crtstuff is fixed to not invoke __register_frame_info
1671 automatically, for each object, use the shared libgcc if
1672 any non-empty unwind section found.
1673
1674 Doing any of this probably requires invoking an external program to
1675 do the actual object file scanning. */
1676 {
1677 const char *p = libgcc_spec;
1678 int in_sep = 1;
1679
1680 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1681 when given the proper command line arguments. */
1682 while (*p)
1683 {
1684 if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
1685 {
1686 init_gcc_specs (&obstack,
1687 #ifdef NO_SHARED_LIBGCC_MULTILIB
1688 "-lgcc_s"
1689 #else
1690 "-lgcc_s%M"
1691 #endif
1692 ,
1693 "-lgcc",
1694 "-lgcc_eh"
1695 #ifdef USE_LIBUNWIND_EXCEPTIONS
1696 " -lunwind"
1697 #endif
1698 );
1699
1700 p += 5;
1701 in_sep = 0;
1702 }
1703 else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0)
1704 {
1705 /* Ug. We don't know shared library extensions. Hope that
1706 systems that use this form don't do shared libraries. */
1707 init_gcc_specs (&obstack,
1708 #ifdef NO_SHARED_LIBGCC_MULTILIB
1709 "-lgcc_s"
1710 #else
1711 "-lgcc_s%M"
1712 #endif
1713 ,
1714 "libgcc.a%s",
1715 "libgcc_eh.a%s"
1716 #ifdef USE_LIBUNWIND_EXCEPTIONS
1717 " -lunwind"
1718 #endif
1719 );
1720 p += 10;
1721 in_sep = 0;
1722 }
1723 else
1724 {
1725 obstack_1grow (&obstack, *p);
1726 in_sep = (*p == ' ');
1727 p += 1;
1728 }
1729 }
1730
1731 obstack_1grow (&obstack, '\0');
1732 libgcc_spec = obstack_finish (&obstack);
1733 }
1734 #endif
1735 #ifdef USE_AS_TRADITIONAL_FORMAT
1736 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1737 {
1738 static const char tf[] = "--traditional-format ";
1739 obstack_grow (&obstack, tf, sizeof(tf) - 1);
1740 obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
1741 asm_spec = obstack_finish (&obstack);
1742 }
1743 #endif
1744 #ifdef LINK_EH_SPEC
1745 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1746 obstack_grow (&obstack, LINK_EH_SPEC, sizeof(LINK_EH_SPEC) - 1);
1747 obstack_grow0 (&obstack, link_spec, strlen (link_spec));
1748 link_spec = obstack_finish (&obstack);
1749 #endif
1750
1751 specs = sl;
1752 }
1753 \f
1754 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1755 removed; If the spec starts with a + then SPEC is added to the end of the
1756 current spec. */
1757
1758 static void
1759 set_spec (const char *name, const char *spec)
1760 {
1761 struct spec_list *sl;
1762 const char *old_spec;
1763 int name_len = strlen (name);
1764 int i;
1765
1766 /* If this is the first call, initialize the statically allocated specs. */
1767 if (!specs)
1768 {
1769 struct spec_list *next = (struct spec_list *) 0;
1770 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1771 {
1772 sl = &static_specs[i];
1773 sl->next = next;
1774 next = sl;
1775 }
1776 specs = sl;
1777 }
1778
1779 /* See if the spec already exists. */
1780 for (sl = specs; sl; sl = sl->next)
1781 if (name_len == sl->name_len && !strcmp (sl->name, name))
1782 break;
1783
1784 if (!sl)
1785 {
1786 /* Not found - make it. */
1787 sl = xmalloc (sizeof (struct spec_list));
1788 sl->name = xstrdup (name);
1789 sl->name_len = name_len;
1790 sl->ptr_spec = &sl->ptr;
1791 sl->alloc_p = 0;
1792 *(sl->ptr_spec) = "";
1793 sl->next = specs;
1794 specs = sl;
1795 }
1796
1797 old_spec = *(sl->ptr_spec);
1798 *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
1799 ? concat (old_spec, spec + 1, NULL)
1800 : xstrdup (spec));
1801
1802 #ifdef DEBUG_SPECS
1803 if (verbose_flag)
1804 notice ("Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
1805 #endif
1806
1807 /* Free the old spec. */
1808 if (old_spec && sl->alloc_p)
1809 free ((void *) old_spec);
1810
1811 sl->alloc_p = 1;
1812 }
1813 \f
1814 /* Accumulate a command (program name and args), and run it. */
1815
1816 /* Vector of pointers to arguments in the current line of specifications. */
1817
1818 static const char **argbuf;
1819
1820 /* Number of elements allocated in argbuf. */
1821
1822 static int argbuf_length;
1823
1824 /* Number of elements in argbuf currently in use (containing args). */
1825
1826 static int argbuf_index;
1827
1828 /* Position in the argbuf array containing the name of the output file
1829 (the value associated with the "-o" flag). */
1830
1831 static int have_o_argbuf_index = 0;
1832
1833 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1834 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
1835 it here. */
1836
1837 static struct temp_name {
1838 const char *suffix; /* suffix associated with the code. */
1839 int length; /* strlen (suffix). */
1840 int unique; /* Indicates whether %g or %u/%U was used. */
1841 const char *filename; /* associated filename. */
1842 int filename_length; /* strlen (filename). */
1843 struct temp_name *next;
1844 } *temp_names;
1845
1846 /* Number of commands executed so far. */
1847
1848 static int execution_count;
1849
1850 /* Number of commands that exited with a signal. */
1851
1852 static int signal_count;
1853
1854 /* Name with which this program was invoked. */
1855
1856 static const char *programname;
1857 \f
1858 /* Allocate the argument vector. */
1859
1860 static void
1861 alloc_args (void)
1862 {
1863 argbuf_length = 10;
1864 argbuf = xmalloc (argbuf_length * sizeof (const char *));
1865 }
1866
1867 /* Clear out the vector of arguments (after a command is executed). */
1868
1869 static void
1870 clear_args (void)
1871 {
1872 argbuf_index = 0;
1873 }
1874
1875 /* Add one argument to the vector at the end.
1876 This is done when a space is seen or at the end of the line.
1877 If DELETE_ALWAYS is nonzero, the arg is a filename
1878 and the file should be deleted eventually.
1879 If DELETE_FAILURE is nonzero, the arg is a filename
1880 and the file should be deleted if this compilation fails. */
1881
1882 static void
1883 store_arg (const char *arg, int delete_always, int delete_failure)
1884 {
1885 if (argbuf_index + 1 == argbuf_length)
1886 argbuf = xrealloc (argbuf, (argbuf_length *= 2) * sizeof (const char *));
1887
1888 argbuf[argbuf_index++] = arg;
1889 argbuf[argbuf_index] = 0;
1890
1891 if (strcmp (arg, "-o") == 0)
1892 have_o_argbuf_index = argbuf_index;
1893 if (delete_always || delete_failure)
1894 record_temp_file (arg, delete_always, delete_failure);
1895 }
1896 \f
1897 /* Load specs from a file name named FILENAME, replacing occurrences of
1898 various different types of line-endings, \r\n, \n\r and just \r, with
1899 a single \n. */
1900
1901 static char *
1902 load_specs (const char *filename)
1903 {
1904 int desc;
1905 int readlen;
1906 struct stat statbuf;
1907 char *buffer;
1908 char *buffer_p;
1909 char *specs;
1910 char *specs_p;
1911
1912 if (verbose_flag)
1913 notice ("Reading specs from %s\n", filename);
1914
1915 /* Open and stat the file. */
1916 desc = open (filename, O_RDONLY, 0);
1917 if (desc < 0)
1918 pfatal_with_name (filename);
1919 if (stat (filename, &statbuf) < 0)
1920 pfatal_with_name (filename);
1921
1922 /* Read contents of file into BUFFER. */
1923 buffer = xmalloc ((unsigned) statbuf.st_size + 1);
1924 readlen = read (desc, buffer, (unsigned) statbuf.st_size);
1925 if (readlen < 0)
1926 pfatal_with_name (filename);
1927 buffer[readlen] = 0;
1928 close (desc);
1929
1930 specs = xmalloc (readlen + 1);
1931 specs_p = specs;
1932 for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
1933 {
1934 int skip = 0;
1935 char c = *buffer_p;
1936 if (c == '\r')
1937 {
1938 if (buffer_p > buffer && *(buffer_p - 1) == '\n') /* \n\r */
1939 skip = 1;
1940 else if (*(buffer_p + 1) == '\n') /* \r\n */
1941 skip = 1;
1942 else /* \r */
1943 c = '\n';
1944 }
1945 if (! skip)
1946 *specs_p++ = c;
1947 }
1948 *specs_p = '\0';
1949
1950 free (buffer);
1951 return (specs);
1952 }
1953
1954 /* Read compilation specs from a file named FILENAME,
1955 replacing the default ones.
1956
1957 A suffix which starts with `*' is a definition for
1958 one of the machine-specific sub-specs. The "suffix" should be
1959 *asm, *cc1, *cpp, *link, *startfile, etc.
1960 The corresponding spec is stored in asm_spec, etc.,
1961 rather than in the `compilers' vector.
1962
1963 Anything invalid in the file is a fatal error. */
1964
1965 static void
1966 read_specs (const char *filename, int main_p)
1967 {
1968 char *buffer;
1969 char *p;
1970
1971 buffer = load_specs (filename);
1972
1973 /* Scan BUFFER for specs, putting them in the vector. */
1974 p = buffer;
1975 while (1)
1976 {
1977 char *suffix;
1978 char *spec;
1979 char *in, *out, *p1, *p2, *p3;
1980
1981 /* Advance P in BUFFER to the next nonblank nocomment line. */
1982 p = skip_whitespace (p);
1983 if (*p == 0)
1984 break;
1985
1986 /* Is this a special command that starts with '%'? */
1987 /* Don't allow this for the main specs file, since it would
1988 encourage people to overwrite it. */
1989 if (*p == '%' && !main_p)
1990 {
1991 p1 = p;
1992 while (*p && *p != '\n')
1993 p++;
1994
1995 /* Skip '\n'. */
1996 p++;
1997
1998 if (!strncmp (p1, "%include", sizeof ("%include") - 1)
1999 && (p1[sizeof "%include" - 1] == ' '
2000 || p1[sizeof "%include" - 1] == '\t'))
2001 {
2002 char *new_filename;
2003
2004 p1 += sizeof ("%include");
2005 while (*p1 == ' ' || *p1 == '\t')
2006 p1++;
2007
2008 if (*p1++ != '<' || p[-2] != '>')
2009 fatal ("specs %%include syntax malformed after %ld characters",
2010 (long) (p1 - buffer + 1));
2011
2012 p[-2] = '\0';
2013 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, 0);
2014 read_specs (new_filename ? new_filename : p1, FALSE);
2015 continue;
2016 }
2017 else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
2018 && (p1[sizeof "%include_noerr" - 1] == ' '
2019 || p1[sizeof "%include_noerr" - 1] == '\t'))
2020 {
2021 char *new_filename;
2022
2023 p1 += sizeof "%include_noerr";
2024 while (*p1 == ' ' || *p1 == '\t')
2025 p1++;
2026
2027 if (*p1++ != '<' || p[-2] != '>')
2028 fatal ("specs %%include syntax malformed after %ld characters",
2029 (long) (p1 - buffer + 1));
2030
2031 p[-2] = '\0';
2032 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, 0);
2033 if (new_filename)
2034 read_specs (new_filename, FALSE);
2035 else if (verbose_flag)
2036 notice ("could not find specs file %s\n", p1);
2037 continue;
2038 }
2039 else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
2040 && (p1[sizeof "%rename" - 1] == ' '
2041 || p1[sizeof "%rename" - 1] == '\t'))
2042 {
2043 int name_len;
2044 struct spec_list *sl;
2045 struct spec_list *newsl;
2046
2047 /* Get original name. */
2048 p1 += sizeof "%rename";
2049 while (*p1 == ' ' || *p1 == '\t')
2050 p1++;
2051
2052 if (! ISALPHA ((unsigned char) *p1))
2053 fatal ("specs %%rename syntax malformed after %ld characters",
2054 (long) (p1 - buffer));
2055
2056 p2 = p1;
2057 while (*p2 && !ISSPACE ((unsigned char) *p2))
2058 p2++;
2059
2060 if (*p2 != ' ' && *p2 != '\t')
2061 fatal ("specs %%rename syntax malformed after %ld characters",
2062 (long) (p2 - buffer));
2063
2064 name_len = p2 - p1;
2065 *p2++ = '\0';
2066 while (*p2 == ' ' || *p2 == '\t')
2067 p2++;
2068
2069 if (! ISALPHA ((unsigned char) *p2))
2070 fatal ("specs %%rename syntax malformed after %ld characters",
2071 (long) (p2 - buffer));
2072
2073 /* Get new spec name. */
2074 p3 = p2;
2075 while (*p3 && !ISSPACE ((unsigned char) *p3))
2076 p3++;
2077
2078 if (p3 != p - 1)
2079 fatal ("specs %%rename syntax malformed after %ld characters",
2080 (long) (p3 - buffer));
2081 *p3 = '\0';
2082
2083 for (sl = specs; sl; sl = sl->next)
2084 if (name_len == sl->name_len && !strcmp (sl->name, p1))
2085 break;
2086
2087 if (!sl)
2088 fatal ("specs %s spec was not found to be renamed", p1);
2089
2090 if (strcmp (p1, p2) == 0)
2091 continue;
2092
2093 for (newsl = specs; newsl; newsl = newsl->next)
2094 if (strcmp (newsl->name, p2) == 0)
2095 fatal ("%s: attempt to rename spec '%s' to already defined spec '%s'",
2096 filename, p1, p2);
2097
2098 if (verbose_flag)
2099 {
2100 notice ("rename spec %s to %s\n", p1, p2);
2101 #ifdef DEBUG_SPECS
2102 notice ("spec is '%s'\n\n", *(sl->ptr_spec));
2103 #endif
2104 }
2105
2106 set_spec (p2, *(sl->ptr_spec));
2107 if (sl->alloc_p)
2108 free ((void *) *(sl->ptr_spec));
2109
2110 *(sl->ptr_spec) = "";
2111 sl->alloc_p = 0;
2112 continue;
2113 }
2114 else
2115 fatal ("specs unknown %% command after %ld characters",
2116 (long) (p1 - buffer));
2117 }
2118
2119 /* Find the colon that should end the suffix. */
2120 p1 = p;
2121 while (*p1 && *p1 != ':' && *p1 != '\n')
2122 p1++;
2123
2124 /* The colon shouldn't be missing. */
2125 if (*p1 != ':')
2126 fatal ("specs file malformed after %ld characters",
2127 (long) (p1 - buffer));
2128
2129 /* Skip back over trailing whitespace. */
2130 p2 = p1;
2131 while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
2132 p2--;
2133
2134 /* Copy the suffix to a string. */
2135 suffix = save_string (p, p2 - p);
2136 /* Find the next line. */
2137 p = skip_whitespace (p1 + 1);
2138 if (p[1] == 0)
2139 fatal ("specs file malformed after %ld characters",
2140 (long) (p - buffer));
2141
2142 p1 = p;
2143 /* Find next blank line or end of string. */
2144 while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
2145 p1++;
2146
2147 /* Specs end at the blank line and do not include the newline. */
2148 spec = save_string (p, p1 - p);
2149 p = p1;
2150
2151 /* Delete backslash-newline sequences from the spec. */
2152 in = spec;
2153 out = spec;
2154 while (*in != 0)
2155 {
2156 if (in[0] == '\\' && in[1] == '\n')
2157 in += 2;
2158 else if (in[0] == '#')
2159 while (*in && *in != '\n')
2160 in++;
2161
2162 else
2163 *out++ = *in++;
2164 }
2165 *out = 0;
2166
2167 if (suffix[0] == '*')
2168 {
2169 if (! strcmp (suffix, "*link_command"))
2170 link_command_spec = spec;
2171 else
2172 set_spec (suffix + 1, spec);
2173 }
2174 else
2175 {
2176 /* Add this pair to the vector. */
2177 compilers
2178 = xrealloc (compilers,
2179 (n_compilers + 2) * sizeof (struct compiler));
2180
2181 compilers[n_compilers].suffix = suffix;
2182 compilers[n_compilers].spec = spec;
2183 n_compilers++;
2184 memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
2185 }
2186
2187 if (*suffix == 0)
2188 link_command_spec = spec;
2189 }
2190
2191 if (link_command_spec == 0)
2192 fatal ("spec file has no spec for linking");
2193 }
2194 \f
2195 /* Record the names of temporary files we tell compilers to write,
2196 and delete them at the end of the run. */
2197
2198 /* This is the common prefix we use to make temp file names.
2199 It is chosen once for each run of this program.
2200 It is substituted into a spec by %g or %j.
2201 Thus, all temp file names contain this prefix.
2202 In practice, all temp file names start with this prefix.
2203
2204 This prefix comes from the envvar TMPDIR if it is defined;
2205 otherwise, from the P_tmpdir macro if that is defined;
2206 otherwise, in /usr/tmp or /tmp;
2207 or finally the current directory if all else fails. */
2208
2209 static const char *temp_filename;
2210
2211 /* Length of the prefix. */
2212
2213 static int temp_filename_length;
2214
2215 /* Define the list of temporary files to delete. */
2216
2217 struct temp_file
2218 {
2219 const char *name;
2220 struct temp_file *next;
2221 };
2222
2223 /* Queue of files to delete on success or failure of compilation. */
2224 static struct temp_file *always_delete_queue;
2225 /* Queue of files to delete on failure of compilation. */
2226 static struct temp_file *failure_delete_queue;
2227
2228 /* Record FILENAME as a file to be deleted automatically.
2229 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2230 otherwise delete it in any case.
2231 FAIL_DELETE nonzero means delete it if a compilation step fails;
2232 otherwise delete it in any case. */
2233
2234 void
2235 record_temp_file (const char *filename, int always_delete, int fail_delete)
2236 {
2237 char *const name = xstrdup (filename);
2238
2239 if (always_delete)
2240 {
2241 struct temp_file *temp;
2242 for (temp = always_delete_queue; temp; temp = temp->next)
2243 if (! strcmp (name, temp->name))
2244 goto already1;
2245
2246 temp = xmalloc (sizeof (struct temp_file));
2247 temp->next = always_delete_queue;
2248 temp->name = name;
2249 always_delete_queue = temp;
2250
2251 already1:;
2252 }
2253
2254 if (fail_delete)
2255 {
2256 struct temp_file *temp;
2257 for (temp = failure_delete_queue; temp; temp = temp->next)
2258 if (! strcmp (name, temp->name))
2259 goto already2;
2260
2261 temp = xmalloc (sizeof (struct temp_file));
2262 temp->next = failure_delete_queue;
2263 temp->name = name;
2264 failure_delete_queue = temp;
2265
2266 already2:;
2267 }
2268 }
2269
2270 /* Delete all the temporary files whose names we previously recorded. */
2271
2272 #ifndef DELETE_IF_ORDINARY
2273 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2274 do \
2275 { \
2276 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2277 if (unlink (NAME) < 0) \
2278 if (VERBOSE_FLAG) \
2279 perror_with_name (NAME); \
2280 } while (0)
2281 #endif
2282
2283 static void
2284 delete_if_ordinary (const char *name)
2285 {
2286 struct stat st;
2287 #ifdef DEBUG
2288 int i, c;
2289
2290 printf ("Delete %s? (y or n) ", name);
2291 fflush (stdout);
2292 i = getchar ();
2293 if (i != '\n')
2294 while ((c = getchar ()) != '\n' && c != EOF)
2295 ;
2296
2297 if (i == 'y' || i == 'Y')
2298 #endif /* DEBUG */
2299 DELETE_IF_ORDINARY (name, st, verbose_flag);
2300 }
2301
2302 static void
2303 delete_temp_files (void)
2304 {
2305 struct temp_file *temp;
2306
2307 for (temp = always_delete_queue; temp; temp = temp->next)
2308 delete_if_ordinary (temp->name);
2309 always_delete_queue = 0;
2310 }
2311
2312 /* Delete all the files to be deleted on error. */
2313
2314 static void
2315 delete_failure_queue (void)
2316 {
2317 struct temp_file *temp;
2318
2319 for (temp = failure_delete_queue; temp; temp = temp->next)
2320 delete_if_ordinary (temp->name);
2321 }
2322
2323 static void
2324 clear_failure_queue (void)
2325 {
2326 failure_delete_queue = 0;
2327 }
2328 \f
2329 /* Build a list of search directories from PATHS.
2330 PREFIX is a string to prepend to the list.
2331 If CHECK_DIR_P is nonzero we ensure the directory exists.
2332 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2333 It is also used by the --print-search-dirs flag. */
2334
2335 static char *
2336 build_search_list (struct path_prefix *paths, const char *prefix,
2337 int check_dir_p)
2338 {
2339 int suffix_len = (machine_suffix) ? strlen (machine_suffix) : 0;
2340 int just_suffix_len
2341 = (just_machine_suffix) ? strlen (just_machine_suffix) : 0;
2342 int first_time = TRUE;
2343 struct prefix_list *pprefix;
2344
2345 obstack_grow (&collect_obstack, prefix, strlen (prefix));
2346 obstack_1grow (&collect_obstack, '=');
2347
2348 for (pprefix = paths->plist; pprefix != 0; pprefix = pprefix->next)
2349 {
2350 int len = strlen (pprefix->prefix);
2351
2352 if (machine_suffix
2353 && (! check_dir_p
2354 || is_directory (pprefix->prefix, machine_suffix, 0)))
2355 {
2356 if (!first_time)
2357 obstack_1grow (&collect_obstack, PATH_SEPARATOR);
2358
2359 first_time = FALSE;
2360 obstack_grow (&collect_obstack, pprefix->prefix, len);
2361 obstack_grow (&collect_obstack, machine_suffix, suffix_len);
2362 }
2363
2364 if (just_machine_suffix
2365 && pprefix->require_machine_suffix == 2
2366 && (! check_dir_p
2367 || is_directory (pprefix->prefix, just_machine_suffix, 0)))
2368 {
2369 if (! first_time)
2370 obstack_1grow (&collect_obstack, PATH_SEPARATOR);
2371
2372 first_time = FALSE;
2373 obstack_grow (&collect_obstack, pprefix->prefix, len);
2374 obstack_grow (&collect_obstack, just_machine_suffix,
2375 just_suffix_len);
2376 }
2377
2378 if (! pprefix->require_machine_suffix)
2379 {
2380 if (! first_time)
2381 obstack_1grow (&collect_obstack, PATH_SEPARATOR);
2382
2383 first_time = FALSE;
2384 obstack_grow (&collect_obstack, pprefix->prefix, len);
2385 }
2386 }
2387
2388 obstack_1grow (&collect_obstack, '\0');
2389 return obstack_finish (&collect_obstack);
2390 }
2391
2392 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2393 for collect. */
2394
2395 static void
2396 putenv_from_prefixes (struct path_prefix *paths, const char *env_var)
2397 {
2398 putenv (build_search_list (paths, env_var, 1));
2399 }
2400 \f
2401 /* Check whether NAME can be accessed in MODE. This is like access,
2402 except that it never considers directories to be executable. */
2403
2404 static int
2405 access_check (const char *name, int mode)
2406 {
2407 if (mode == X_OK)
2408 {
2409 struct stat st;
2410
2411 if (stat (name, &st) < 0
2412 || S_ISDIR (st.st_mode))
2413 return -1;
2414 }
2415
2416 return access (name, mode);
2417 }
2418
2419 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
2420 access to check permissions.
2421 Return 0 if not found, otherwise return its name, allocated with malloc. */
2422
2423 static char *
2424 find_a_file (struct path_prefix *pprefix, const char *name, int mode,
2425 int multilib)
2426 {
2427 char *temp;
2428 const char *const file_suffix =
2429 ((mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "");
2430 struct prefix_list *pl;
2431 int len = pprefix->max_len + strlen (name) + strlen (file_suffix) + 1;
2432 const char *multilib_name, *multilib_os_name;
2433
2434 #ifdef DEFAULT_ASSEMBLER
2435 if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
2436 return xstrdup (DEFAULT_ASSEMBLER);
2437 #endif
2438
2439 #ifdef DEFAULT_LINKER
2440 if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0)
2441 return xstrdup (DEFAULT_LINKER);
2442 #endif
2443
2444 if (machine_suffix)
2445 len += strlen (machine_suffix);
2446
2447 multilib_name = name;
2448 multilib_os_name = name;
2449 if (multilib && multilib_os_dir)
2450 {
2451 int len1 = multilib_dir ? strlen (multilib_dir) + 1 : 0;
2452 int len2 = strlen (multilib_os_dir) + 1;
2453
2454 len += len1 > len2 ? len1 : len2;
2455 if (multilib_dir)
2456 multilib_name = ACONCAT ((multilib_dir, dir_separator_str, name,
2457 NULL));
2458 if (strcmp (multilib_os_dir, ".") != 0)
2459 multilib_os_name = ACONCAT ((multilib_os_dir, dir_separator_str, name,
2460 NULL));
2461 }
2462
2463 temp = xmalloc (len);
2464
2465 /* Determine the filename to execute (special case for absolute paths). */
2466
2467 if (IS_ABSOLUTE_PATH (name))
2468 {
2469 if (access (name, mode) == 0)
2470 {
2471 strcpy (temp, name);
2472 return temp;
2473 }
2474 }
2475 else
2476 for (pl = pprefix->plist; pl; pl = pl->next)
2477 {
2478 const char *this_name
2479 = pl->os_multilib ? multilib_os_name : multilib_name;
2480
2481 if (machine_suffix)
2482 {
2483 /* Some systems have a suffix for executable files.
2484 So try appending that first. */
2485 if (file_suffix[0] != 0)
2486 {
2487 strcpy (temp, pl->prefix);
2488 strcat (temp, machine_suffix);
2489 strcat (temp, multilib_name);
2490 strcat (temp, file_suffix);
2491 if (access_check (temp, mode) == 0)
2492 {
2493 if (pl->used_flag_ptr != 0)
2494 *pl->used_flag_ptr = 1;
2495 return temp;
2496 }
2497 }
2498
2499 /* Now try just the multilib_name. */
2500 strcpy (temp, pl->prefix);
2501 strcat (temp, machine_suffix);
2502 strcat (temp, multilib_name);
2503 if (access_check (temp, mode) == 0)
2504 {
2505 if (pl->used_flag_ptr != 0)
2506 *pl->used_flag_ptr = 1;
2507 return temp;
2508 }
2509 }
2510
2511 /* Certain prefixes are tried with just the machine type,
2512 not the version. This is used for finding as, ld, etc. */
2513 if (just_machine_suffix && pl->require_machine_suffix == 2)
2514 {
2515 /* Some systems have a suffix for executable files.
2516 So try appending that first. */
2517 if (file_suffix[0] != 0)
2518 {
2519 strcpy (temp, pl->prefix);
2520 strcat (temp, just_machine_suffix);
2521 strcat (temp, multilib_name);
2522 strcat (temp, file_suffix);
2523 if (access_check (temp, mode) == 0)
2524 {
2525 if (pl->used_flag_ptr != 0)
2526 *pl->used_flag_ptr = 1;
2527 return temp;
2528 }
2529 }
2530
2531 strcpy (temp, pl->prefix);
2532 strcat (temp, just_machine_suffix);
2533 strcat (temp, multilib_name);
2534 if (access_check (temp, mode) == 0)
2535 {
2536 if (pl->used_flag_ptr != 0)
2537 *pl->used_flag_ptr = 1;
2538 return temp;
2539 }
2540 }
2541
2542 /* Certain prefixes can't be used without the machine suffix
2543 when the machine or version is explicitly specified. */
2544 if (! pl->require_machine_suffix)
2545 {
2546 /* Some systems have a suffix for executable files.
2547 So try appending that first. */
2548 if (file_suffix[0] != 0)
2549 {
2550 strcpy (temp, pl->prefix);
2551 strcat (temp, this_name);
2552 strcat (temp, file_suffix);
2553 if (access_check (temp, mode) == 0)
2554 {
2555 if (pl->used_flag_ptr != 0)
2556 *pl->used_flag_ptr = 1;
2557 return temp;
2558 }
2559 }
2560
2561 strcpy (temp, pl->prefix);
2562 strcat (temp, this_name);
2563 if (access_check (temp, mode) == 0)
2564 {
2565 if (pl->used_flag_ptr != 0)
2566 *pl->used_flag_ptr = 1;
2567 return temp;
2568 }
2569 }
2570 }
2571
2572 free (temp);
2573 return 0;
2574 }
2575
2576 /* Ranking of prefixes in the sort list. -B prefixes are put before
2577 all others. */
2578
2579 enum path_prefix_priority
2580 {
2581 PREFIX_PRIORITY_B_OPT,
2582 PREFIX_PRIORITY_LAST
2583 };
2584
2585 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
2586 order according to PRIORITY. Within each PRIORITY, new entries are
2587 appended.
2588
2589 If WARN is nonzero, we will warn if no file is found
2590 through this prefix. WARN should point to an int
2591 which will be set to 1 if this entry is used.
2592
2593 COMPONENT is the value to be passed to update_path.
2594
2595 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2596 the complete value of machine_suffix.
2597 2 means try both machine_suffix and just_machine_suffix. */
2598
2599 static void
2600 add_prefix (struct path_prefix *pprefix, const char *prefix,
2601 const char *component, /* enum prefix_priority */ int priority,
2602 int require_machine_suffix, int *warn, int os_multilib)
2603 {
2604 struct prefix_list *pl, **prev;
2605 int len;
2606
2607 for (prev = &pprefix->plist;
2608 (*prev) != NULL && (*prev)->priority <= priority;
2609 prev = &(*prev)->next)
2610 ;
2611
2612 /* Keep track of the longest prefix. */
2613
2614 prefix = update_path (prefix, component);
2615 len = strlen (prefix);
2616 if (len > pprefix->max_len)
2617 pprefix->max_len = len;
2618
2619 pl = xmalloc (sizeof (struct prefix_list));
2620 pl->prefix = prefix;
2621 pl->require_machine_suffix = require_machine_suffix;
2622 pl->used_flag_ptr = warn;
2623 pl->priority = priority;
2624 pl->os_multilib = os_multilib;
2625 if (warn)
2626 *warn = 0;
2627
2628 /* Insert after PREV. */
2629 pl->next = (*prev);
2630 (*prev) = pl;
2631 }
2632
2633 /* Same as add_prefix, but prepending target_system_root to prefix. */
2634 static void
2635 add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
2636 const char *component,
2637 /* enum prefix_priority */ int priority,
2638 int require_machine_suffix, int *warn, int os_multilib)
2639 {
2640 if (!IS_ABSOLUTE_PATH (prefix))
2641 abort ();
2642
2643 if (target_system_root)
2644 {
2645 if (target_sysroot_suffix)
2646 prefix = concat (target_sysroot_suffix, prefix, NULL);
2647 prefix = concat (target_system_root, prefix, NULL);
2648
2649 /* We have to override this because GCC's notion of sysroot
2650 moves along with GCC. */
2651 component = "GCC";
2652 }
2653
2654 add_prefix (pprefix, prefix, component, priority,
2655 require_machine_suffix, warn, os_multilib);
2656 }
2657 \f
2658 /* Execute the command specified by the arguments on the current line of spec.
2659 When using pipes, this includes several piped-together commands
2660 with `|' between them.
2661
2662 Return 0 if successful, -1 if failed. */
2663
2664 static int
2665 execute (void)
2666 {
2667 int i;
2668 int n_commands; /* # of command. */
2669 char *string;
2670 struct command
2671 {
2672 const char *prog; /* program name. */
2673 const char **argv; /* vector of args. */
2674 int pid; /* pid of process for this command. */
2675 };
2676
2677 struct command *commands; /* each command buffer with above info. */
2678
2679 if (processing_spec_function)
2680 abort ();
2681
2682 /* Count # of piped commands. */
2683 for (n_commands = 1, i = 0; i < argbuf_index; i++)
2684 if (strcmp (argbuf[i], "|") == 0)
2685 n_commands++;
2686
2687 /* Get storage for each command. */
2688 commands = alloca (n_commands * sizeof (struct command));
2689
2690 /* Split argbuf into its separate piped processes,
2691 and record info about each one.
2692 Also search for the programs that are to be run. */
2693
2694 commands[0].prog = argbuf[0]; /* first command. */
2695 commands[0].argv = &argbuf[0];
2696 string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, 0);
2697
2698 if (string)
2699 commands[0].argv[0] = string;
2700
2701 for (n_commands = 1, i = 0; i < argbuf_index; i++)
2702 if (strcmp (argbuf[i], "|") == 0)
2703 { /* each command. */
2704 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2705 fatal ("-pipe not supported");
2706 #endif
2707 argbuf[i] = 0; /* termination of command args. */
2708 commands[n_commands].prog = argbuf[i + 1];
2709 commands[n_commands].argv = &argbuf[i + 1];
2710 string = find_a_file (&exec_prefixes, commands[n_commands].prog,
2711 X_OK, 0);
2712 if (string)
2713 commands[n_commands].argv[0] = string;
2714 n_commands++;
2715 }
2716
2717 argbuf[argbuf_index] = 0;
2718
2719 /* If -v, print what we are about to do, and maybe query. */
2720
2721 if (verbose_flag)
2722 {
2723 /* For help listings, put a blank line between sub-processes. */
2724 if (print_help_list)
2725 fputc ('\n', stderr);
2726
2727 /* Print each piped command as a separate line. */
2728 for (i = 0; i < n_commands; i++)
2729 {
2730 const char *const *j;
2731
2732 if (verbose_only_flag)
2733 {
2734 for (j = commands[i].argv; *j; j++)
2735 {
2736 const char *p;
2737 fprintf (stderr, " \"");
2738 for (p = *j; *p; ++p)
2739 {
2740 if (*p == '"' || *p == '\\' || *p == '$')
2741 fputc ('\\', stderr);
2742 fputc (*p, stderr);
2743 }
2744 fputc ('"', stderr);
2745 }
2746 }
2747 else
2748 for (j = commands[i].argv; *j; j++)
2749 fprintf (stderr, " %s", *j);
2750
2751 /* Print a pipe symbol after all but the last command. */
2752 if (i + 1 != n_commands)
2753 fprintf (stderr, " |");
2754 fprintf (stderr, "\n");
2755 }
2756 fflush (stderr);
2757 if (verbose_only_flag != 0)
2758 {
2759 /* verbose_only_flag should act as if the spec was
2760 executed, so increment execution_count before
2761 returning. This prevents spurious warnings about
2762 unused linker input files, etc. */
2763 execution_count++;
2764 return 0;
2765 }
2766 #ifdef DEBUG
2767 notice ("\nGo ahead? (y or n) ");
2768 fflush (stderr);
2769 i = getchar ();
2770 if (i != '\n')
2771 while (getchar () != '\n')
2772 ;
2773
2774 if (i != 'y' && i != 'Y')
2775 return 0;
2776 #endif /* DEBUG */
2777 }
2778
2779 #ifdef ENABLE_VALGRIND_CHECKING
2780 /* Run the each command through valgrind. To simplify prepending the
2781 path to valgrind and the option "-q" (for quiet operation unless
2782 something triggers), we allocate a separate argv array. */
2783
2784 for (i = 0; i < n_commands; i++)
2785 {
2786 const char **argv;
2787 int argc;
2788 int j;
2789
2790 for (argc = 0; commands[i].argv[argc] != NULL; argc++)
2791 ;
2792
2793 argv = alloca ((argc + 3) * sizeof (char *));
2794
2795 argv[0] = VALGRIND_PATH;
2796 argv[1] = "-q";
2797 for (j = 2; j < argc + 2; j++)
2798 argv[j] = commands[i].argv[j - 2];
2799 argv[j] = NULL;
2800
2801 commands[i].argv = argv;
2802 commands[i].prog = argv[0];
2803 }
2804 #endif
2805
2806 /* Run each piped subprocess. */
2807
2808 for (i = 0; i < n_commands; i++)
2809 {
2810 char *errmsg_fmt, *errmsg_arg;
2811 const char *string = commands[i].argv[0];
2812
2813 /* For some bizarre reason, the second argument of execvp() is
2814 char *const *, not const char *const *. */
2815 commands[i].pid = pexecute (string, (char *const *) commands[i].argv,
2816 programname, temp_filename,
2817 &errmsg_fmt, &errmsg_arg,
2818 ((i == 0 ? PEXECUTE_FIRST : 0)
2819 | (i + 1 == n_commands ? PEXECUTE_LAST : 0)
2820 | (string == commands[i].prog
2821 ? PEXECUTE_SEARCH : 0)
2822 | (verbose_flag ? PEXECUTE_VERBOSE : 0)));
2823
2824 if (commands[i].pid == -1)
2825 pfatal_pexecute (errmsg_fmt, errmsg_arg);
2826
2827 if (string != commands[i].prog)
2828 free ((void *) string);
2829 }
2830
2831 execution_count++;
2832
2833 /* Wait for all the subprocesses to finish.
2834 We don't care what order they finish in;
2835 we know that N_COMMANDS waits will get them all.
2836 Ignore subprocesses that we don't know about,
2837 since they can be spawned by the process that exec'ed us. */
2838
2839 {
2840 int ret_code = 0;
2841 #ifdef HAVE_GETRUSAGE
2842 struct timeval d;
2843 double ut = 0.0, st = 0.0;
2844 #endif
2845
2846 for (i = 0; i < n_commands;)
2847 {
2848 int j;
2849 int status;
2850 int pid;
2851
2852 pid = pwait (commands[i].pid, &status, 0);
2853 if (pid < 0)
2854 abort ();
2855
2856 #ifdef HAVE_GETRUSAGE
2857 if (report_times)
2858 {
2859 /* getrusage returns the total resource usage of all children
2860 up to now. Copy the previous values into prus, get the
2861 current statistics, then take the difference. */
2862
2863 prus = rus;
2864 getrusage (RUSAGE_CHILDREN, &rus);
2865 d.tv_sec = rus.ru_utime.tv_sec - prus.ru_utime.tv_sec;
2866 d.tv_usec = rus.ru_utime.tv_usec - prus.ru_utime.tv_usec;
2867 ut = (double) d.tv_sec + (double) d.tv_usec / 1.0e6;
2868
2869 d.tv_sec = rus.ru_stime.tv_sec - prus.ru_stime.tv_sec;
2870 d.tv_usec = rus.ru_stime.tv_usec - prus.ru_stime.tv_usec;
2871 st = (double) d.tv_sec + (double) d.tv_usec / 1.0e6;
2872 }
2873 #endif
2874
2875 for (j = 0; j < n_commands; j++)
2876 if (commands[j].pid == pid)
2877 {
2878 i++;
2879 if (WIFSIGNALED (status))
2880 {
2881 #ifdef SIGPIPE
2882 /* SIGPIPE is a special case. It happens in -pipe mode
2883 when the compiler dies before the preprocessor is
2884 done, or the assembler dies before the compiler is
2885 done. There's generally been an error already, and
2886 this is just fallout. So don't generate another error
2887 unless we would otherwise have succeeded. */
2888 if (WTERMSIG (status) == SIGPIPE
2889 && (signal_count || greatest_status >= MIN_FATAL_STATUS))
2890 ;
2891 else
2892 #endif
2893 fatal ("\
2894 Internal error: %s (program %s)\n\
2895 Please submit a full bug report.\n\
2896 See %s for instructions.",
2897 strsignal (WTERMSIG (status)), commands[j].prog,
2898 bug_report_url);
2899 signal_count++;
2900 ret_code = -1;
2901 }
2902 else if (WIFEXITED (status)
2903 && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
2904 {
2905 if (WEXITSTATUS (status) > greatest_status)
2906 greatest_status = WEXITSTATUS (status);
2907 ret_code = -1;
2908 }
2909 #ifdef HAVE_GETRUSAGE
2910 if (report_times && ut + st != 0)
2911 notice ("# %s %.2f %.2f\n", commands[j].prog, ut, st);
2912 #endif
2913 break;
2914 }
2915 }
2916 return ret_code;
2917 }
2918 }
2919 \f
2920 /* Find all the switches given to us
2921 and make a vector describing them.
2922 The elements of the vector are strings, one per switch given.
2923 If a switch uses following arguments, then the `part1' field
2924 is the switch itself and the `args' field
2925 is a null-terminated vector containing the following arguments.
2926 The `live_cond' field is:
2927 0 when initialized
2928 1 if the switch is true in a conditional spec,
2929 -1 if false (overridden by a later switch)
2930 -2 if this switch should be ignored (used in %<S)
2931 The `validated' field is nonzero if any spec has looked at this switch;
2932 if it remains zero at the end of the run, it must be meaningless. */
2933
2934 #define SWITCH_OK 0
2935 #define SWITCH_FALSE -1
2936 #define SWITCH_IGNORE -2
2937 #define SWITCH_LIVE 1
2938
2939 struct switchstr
2940 {
2941 const char *part1;
2942 const char **args;
2943 int live_cond;
2944 unsigned char validated;
2945 unsigned char ordering;
2946 };
2947
2948 static struct switchstr *switches;
2949
2950 static int n_switches;
2951
2952 struct infile
2953 {
2954 const char *name;
2955 const char *language;
2956 struct compiler *incompiler;
2957 bool compiled;
2958 bool preprocessed;
2959 };
2960
2961 /* Also a vector of input files specified. */
2962
2963 static struct infile *infiles;
2964
2965 int n_infiles;
2966
2967 /* True if multiple input files are being compiled to a single
2968 assembly file. */
2969
2970 static bool combine_inputs;
2971
2972 /* This counts the number of libraries added by lang_specific_driver, so that
2973 we can tell if there were any user supplied any files or libraries. */
2974
2975 static int added_libraries;
2976
2977 /* And a vector of corresponding output files is made up later. */
2978
2979 const char **outfiles;
2980
2981 /* Used to track if none of the -B paths are used. */
2982 static int warn_B;
2983
2984 /* Gives value to pass as "warn" to add_prefix for standard prefixes. */
2985 static int *warn_std_ptr = 0;
2986 \f
2987 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2988
2989 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
2990 is true if we should look for an executable suffix. DO_OBJ
2991 is true if we should look for an object suffix. */
2992
2993 static const char *
2994 convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
2995 int do_obj ATTRIBUTE_UNUSED)
2996 {
2997 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2998 int i;
2999 #endif
3000 int len;
3001
3002 if (name == NULL)
3003 return NULL;
3004
3005 len = strlen (name);
3006
3007 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3008 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
3009 if (do_obj && len > 2
3010 && name[len - 2] == '.'
3011 && name[len - 1] == 'o')
3012 {
3013 obstack_grow (&obstack, name, len - 2);
3014 obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
3015 name = obstack_finish (&obstack);
3016 }
3017 #endif
3018
3019 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3020 /* If there is no filetype, make it the executable suffix (which includes
3021 the "."). But don't get confused if we have just "-o". */
3022 if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
3023 return name;
3024
3025 for (i = len - 1; i >= 0; i--)
3026 if (IS_DIR_SEPARATOR (name[i]))
3027 break;
3028
3029 for (i++; i < len; i++)
3030 if (name[i] == '.')
3031 return name;
3032
3033 obstack_grow (&obstack, name, len);
3034 obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
3035 strlen (TARGET_EXECUTABLE_SUFFIX));
3036 name = obstack_finish (&obstack);
3037 #endif
3038
3039 return name;
3040 }
3041 #endif
3042 \f
3043 /* Display the command line switches accepted by gcc. */
3044 static void
3045 display_help (void)
3046 {
3047 printf (_("Usage: %s [options] file...\n"), programname);
3048 fputs (_("Options:\n"), stdout);
3049
3050 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout);
3051 fputs (_(" --help Display this information\n"), stdout);
3052 fputs (_(" --target-help Display target specific command line options\n"), stdout);
3053 if (! verbose_flag)
3054 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
3055 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout);
3056 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout);
3057 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout);
3058 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout);
3059 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout);
3060 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout);
3061 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout);
3062 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout);
3063 fputs (_("\
3064 -print-multi-lib Display the mapping between command line options and\n\
3065 multiple library search directories\n"), stdout);
3066 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries\n"), stdout);
3067 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout);
3068 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout);
3069 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout);
3070 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler\n"), stdout);
3071 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n"), stdout);
3072 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout);
3073 fputs (_(" -combine Pass multiple source files to compiler at once\n"), stdout);
3074 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout);
3075 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout);
3076 fputs (_(" -time Time the execution of each subprocess\n"), stdout);
3077 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout);
3078 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout);
3079 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout);
3080 fputs (_(" -b <machine> Run gcc for target <machine>, if installed\n"), stdout);
3081 fputs (_(" -V <version> Run gcc version number <version>, if installed\n"), stdout);
3082 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout);
3083 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout);
3084 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout);
3085 fputs (_(" -S Compile only; do not assemble or link\n"), stdout);
3086 fputs (_(" -c Compile and assemble, but do not link\n"), stdout);
3087 fputs (_(" -o <file> Place the output into <file>\n"), stdout);
3088 fputs (_("\
3089 -x <language> Specify the language of the following input files\n\
3090 Permissible languages include: c c++ assembler none\n\
3091 'none' means revert to the default behavior of\n\
3092 guessing the language based on the file's extension\n\
3093 "), stdout);
3094
3095 printf (_("\
3096 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3097 passed on to the various sub-processes invoked by %s. In order to pass\n\
3098 other options on to these processes the -W<letter> options must be used.\n\
3099 "), programname);
3100
3101 /* The rest of the options are displayed by invocations of the various
3102 sub-processes. */
3103 }
3104
3105 static void
3106 add_preprocessor_option (const char *option, int len)
3107 {
3108 n_preprocessor_options++;
3109
3110 if (! preprocessor_options)
3111 preprocessor_options = xmalloc (n_preprocessor_options * sizeof (char *));
3112 else
3113 preprocessor_options = xrealloc (preprocessor_options,
3114 n_preprocessor_options * sizeof (char *));
3115
3116 preprocessor_options [n_preprocessor_options - 1] =
3117 save_string (option, len);
3118 }
3119
3120 static void
3121 add_assembler_option (const char *option, int len)
3122 {
3123 n_assembler_options++;
3124
3125 if (! assembler_options)
3126 assembler_options = xmalloc (n_assembler_options * sizeof (char *));
3127 else
3128 assembler_options = xrealloc (assembler_options,
3129 n_assembler_options * sizeof (char *));
3130
3131 assembler_options [n_assembler_options - 1] = save_string (option, len);
3132 }
3133
3134 static void
3135 add_linker_option (const char *option, int len)
3136 {
3137 n_linker_options++;
3138
3139 if (! linker_options)
3140 linker_options = xmalloc (n_linker_options * sizeof (char *));
3141 else
3142 linker_options = xrealloc (linker_options,
3143 n_linker_options * sizeof (char *));
3144
3145 linker_options [n_linker_options - 1] = save_string (option, len);
3146 }
3147 \f
3148 /* Create the vector `switches' and its contents.
3149 Store its length in `n_switches'. */
3150
3151 static void
3152 process_command (int argc, const char **argv)
3153 {
3154 int i;
3155 const char *temp;
3156 char *temp1;
3157 const char *spec_lang = 0;
3158 int last_language_n_infiles;
3159 int have_c = 0;
3160 int lang_n_infiles = 0;
3161 #ifdef MODIFY_TARGET_NAME
3162 int is_modify_target_name;
3163 int j;
3164 #endif
3165
3166 GET_ENVIRONMENT (gcc_exec_prefix, "GCC_EXEC_PREFIX");
3167
3168 n_switches = 0;
3169 n_infiles = 0;
3170 added_libraries = 0;
3171
3172 /* Figure compiler version from version string. */
3173
3174 compiler_version = temp1 = xstrdup (version_string);
3175
3176 for (; *temp1; ++temp1)
3177 {
3178 if (*temp1 == ' ')
3179 {
3180 *temp1 = '\0';
3181 break;
3182 }
3183 }
3184
3185 /* If there is a -V or -b option (or both), process it now, before
3186 trying to interpret the rest of the command line. */
3187 if (argc > 1 && argv[1][0] == '-'
3188 && (argv[1][1] == 'V' || argv[1][1] == 'b'))
3189 {
3190 const char *new_version = DEFAULT_TARGET_VERSION;
3191 const char *new_machine = DEFAULT_TARGET_MACHINE;
3192 const char *progname = argv[0];
3193 char **new_argv;
3194 char *new_argv0;
3195 int baselen;
3196
3197 while (argc > 1 && argv[1][0] == '-'
3198 && (argv[1][1] == 'V' || argv[1][1] == 'b'))
3199 {
3200 char opt = argv[1][1];
3201 const char *arg;
3202 if (argv[1][2] != '\0')
3203 {
3204 arg = argv[1] + 2;
3205 argc -= 1;
3206 argv += 1;
3207 }
3208 else if (argc > 2)
3209 {
3210 arg = argv[2];
3211 argc -= 2;
3212 argv += 2;
3213 }
3214 else
3215 fatal ("`-%c' option must have argument", opt);
3216 if (opt == 'V')
3217 new_version = arg;
3218 else
3219 new_machine = arg;
3220 }
3221
3222 for (baselen = strlen (progname); baselen > 0; baselen--)
3223 if (IS_DIR_SEPARATOR (progname[baselen-1]))
3224 break;
3225 new_argv0 = xmemdup (progname, baselen,
3226 baselen + concat_length (new_version, new_machine,
3227 "-gcc-", NULL) + 1);
3228 strcpy (new_argv0 + baselen, new_machine);
3229 strcat (new_argv0, "-gcc-");
3230 strcat (new_argv0, new_version);
3231
3232 new_argv = xmemdup (argv, (argc + 1) * sizeof (argv[0]),
3233 (argc + 1) * sizeof (argv[0]));
3234 new_argv[0] = new_argv0;
3235
3236 execvp (new_argv0, new_argv);
3237 fatal ("couldn't run `%s': %s", new_argv0, xstrerror (errno));
3238 }
3239
3240 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
3241 see if we can create it from the pathname specified in argv[0]. */
3242
3243 gcc_libexec_prefix = standard_libexec_prefix;
3244 #ifndef VMS
3245 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
3246 if (!gcc_exec_prefix)
3247 {
3248 gcc_exec_prefix = make_relative_prefix (argv[0], standard_bindir_prefix,
3249 standard_exec_prefix);
3250 gcc_libexec_prefix = make_relative_prefix (argv[0],
3251 standard_bindir_prefix,
3252 standard_libexec_prefix);
3253 if (gcc_exec_prefix)
3254 putenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
3255 }
3256 else
3257 gcc_libexec_prefix = make_relative_prefix (gcc_exec_prefix,
3258 standard_exec_prefix,
3259 standard_libexec_prefix);
3260 #else
3261 #endif
3262
3263 if (gcc_exec_prefix)
3264 {
3265 int len = strlen (gcc_exec_prefix);
3266
3267 if (len > (int) sizeof ("/lib/gcc/") - 1
3268 && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
3269 {
3270 temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1;
3271 if (IS_DIR_SEPARATOR (*temp)
3272 && strncmp (temp + 1, "lib", 3) == 0
3273 && IS_DIR_SEPARATOR (temp[4])
3274 && strncmp (temp + 5, "gcc", 3) == 0)
3275 len -= sizeof ("/lib/gcc/") - 1;
3276 }
3277
3278 set_std_prefix (gcc_exec_prefix, len);
3279 add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC",
3280 PREFIX_PRIORITY_LAST, 0, NULL, 0);
3281 add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
3282 PREFIX_PRIORITY_LAST, 0, NULL, 0);
3283 }
3284
3285 /* COMPILER_PATH and LIBRARY_PATH have values
3286 that are lists of directory names with colons. */
3287
3288 GET_ENVIRONMENT (temp, "COMPILER_PATH");
3289 if (temp)
3290 {
3291 const char *startp, *endp;
3292 char *nstore = alloca (strlen (temp) + 3);
3293
3294 startp = endp = temp;
3295 while (1)
3296 {
3297 if (*endp == PATH_SEPARATOR || *endp == 0)
3298 {
3299 strncpy (nstore, startp, endp - startp);
3300 if (endp == startp)
3301 strcpy (nstore, concat (".", dir_separator_str, NULL));
3302 else if (!IS_DIR_SEPARATOR (endp[-1]))
3303 {
3304 nstore[endp - startp] = DIR_SEPARATOR;
3305 nstore[endp - startp + 1] = 0;
3306 }
3307 else
3308 nstore[endp - startp] = 0;
3309 add_prefix (&exec_prefixes, nstore, 0,
3310 PREFIX_PRIORITY_LAST, 0, NULL, 0);
3311 add_prefix (&include_prefixes,
3312 concat (nstore, "include", NULL),
3313 0, PREFIX_PRIORITY_LAST, 0, NULL, 0);
3314 if (*endp == 0)
3315 break;
3316 endp = startp = endp + 1;
3317 }
3318 else
3319 endp++;
3320 }
3321 }
3322
3323 GET_ENVIRONMENT (temp, LIBRARY_PATH_ENV);
3324 if (temp && *cross_compile == '0')
3325 {
3326 const char *startp, *endp;
3327 char *nstore = alloca (strlen (temp) + 3);
3328
3329 startp = endp = temp;
3330 while (1)
3331 {
3332 if (*endp == PATH_SEPARATOR || *endp == 0)
3333 {
3334 strncpy (nstore, startp, endp - startp);
3335 if (endp == startp)
3336 strcpy (nstore, concat (".", dir_separator_str, NULL));
3337 else if (!IS_DIR_SEPARATOR (endp[-1]))
3338 {
3339 nstore[endp - startp] = DIR_SEPARATOR;
3340 nstore[endp - startp + 1] = 0;
3341 }
3342 else
3343 nstore[endp - startp] = 0;
3344 add_prefix (&startfile_prefixes, nstore, NULL,
3345 PREFIX_PRIORITY_LAST, 0, NULL, 1);
3346 if (*endp == 0)
3347 break;
3348 endp = startp = endp + 1;
3349 }
3350 else
3351 endp++;
3352 }
3353 }
3354
3355 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
3356 GET_ENVIRONMENT (temp, "LPATH");
3357 if (temp && *cross_compile == '0')
3358 {
3359 const char *startp, *endp;
3360 char *nstore = alloca (strlen (temp) + 3);
3361
3362 startp = endp = temp;
3363 while (1)
3364 {
3365 if (*endp == PATH_SEPARATOR || *endp == 0)
3366 {
3367 strncpy (nstore, startp, endp - startp);
3368 if (endp == startp)
3369 strcpy (nstore, concat (".", dir_separator_str, NULL));
3370 else if (!IS_DIR_SEPARATOR (endp[-1]))
3371 {
3372 nstore[endp - startp] = DIR_SEPARATOR;
3373 nstore[endp - startp + 1] = 0;
3374 }
3375 else
3376 nstore[endp - startp] = 0;
3377 add_prefix (&startfile_prefixes, nstore, NULL,
3378 PREFIX_PRIORITY_LAST, 0, NULL, 1);
3379 if (*endp == 0)
3380 break;
3381 endp = startp = endp + 1;
3382 }
3383 else
3384 endp++;
3385 }
3386 }
3387
3388 /* Convert new-style -- options to old-style. */
3389 translate_options (&argc, (const char *const **) &argv);
3390
3391 /* Do language-specific adjustment/addition of flags. */
3392 lang_specific_driver (&argc, (const char *const **) &argv, &added_libraries);
3393
3394 /* Scan argv twice. Here, the first time, just count how many switches
3395 there will be in their vector, and how many input files in theirs.
3396 Here we also parse the switches that cc itself uses (e.g. -v). */
3397
3398 for (i = 1; i < argc; i++)
3399 {
3400 if (! strcmp (argv[i], "-dumpspecs"))
3401 {
3402 struct spec_list *sl;
3403 init_spec ();
3404 for (sl = specs; sl; sl = sl->next)
3405 printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3406 if (link_command_spec)
3407 printf ("*link_command:\n%s\n\n", link_command_spec);
3408 exit (0);
3409 }
3410 else if (! strcmp (argv[i], "-dumpversion"))
3411 {
3412 printf ("%s\n", spec_version);
3413 exit (0);
3414 }
3415 else if (! strcmp (argv[i], "-dumpmachine"))
3416 {
3417 printf ("%s\n", spec_machine);
3418 exit (0);
3419 }
3420 else if (strcmp (argv[i], "-fversion") == 0)
3421 {
3422 /* translate_options () has turned --version into -fversion. */
3423 printf (_("%s (GCC) %s\n"), programname, version_string);
3424 printf ("Copyright %s 2004 Free Software Foundation, Inc.\n",
3425 _("(C)"));
3426 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
3427 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
3428 stdout);
3429 exit (0);
3430 }
3431 else if (strcmp (argv[i], "-fhelp") == 0)
3432 {
3433 /* translate_options () has turned --help into -fhelp. */
3434 print_help_list = 1;
3435
3436 /* We will be passing a dummy file on to the sub-processes. */
3437 n_infiles++;
3438 n_switches++;
3439
3440 /* CPP driver cannot obtain switch from cc1_options. */
3441 if (is_cpp_driver)
3442 add_preprocessor_option ("--help", 6);
3443 add_assembler_option ("--help", 6);
3444 add_linker_option ("--help", 6);
3445 }
3446 else if (strcmp (argv[i], "-ftarget-help") == 0)
3447 {
3448 /* translate_options() has turned --target-help into -ftarget-help. */
3449 target_help_flag = 1;
3450
3451 /* We will be passing a dummy file on to the sub-processes. */
3452 n_infiles++;
3453 n_switches++;
3454
3455 /* CPP driver cannot obtain switch from cc1_options. */
3456 if (is_cpp_driver)
3457 add_preprocessor_option ("--target-help", 13);
3458 add_assembler_option ("--target-help", 13);
3459 add_linker_option ("--target-help", 13);
3460 }
3461 else if (! strcmp (argv[i], "-pass-exit-codes"))
3462 {
3463 pass_exit_codes = 1;
3464 n_switches++;
3465 }
3466 else if (! strcmp (argv[i], "-print-search-dirs"))
3467 print_search_dirs = 1;
3468 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3469 print_file_name = "libgcc.a";
3470 else if (! strncmp (argv[i], "-print-file-name=", 17))
3471 print_file_name = argv[i] + 17;
3472 else if (! strncmp (argv[i], "-print-prog-name=", 17))
3473 print_prog_name = argv[i] + 17;
3474 else if (! strcmp (argv[i], "-print-multi-lib"))
3475 print_multi_lib = 1;
3476 else if (! strcmp (argv[i], "-print-multi-directory"))
3477 print_multi_directory = 1;
3478 else if (! strcmp (argv[i], "-print-multi-os-directory"))
3479 print_multi_os_directory = 1;
3480 else if (! strncmp (argv[i], "-Wa,", 4))
3481 {
3482 int prev, j;
3483 /* Pass the rest of this option to the assembler. */
3484
3485 /* Split the argument at commas. */
3486 prev = 4;
3487 for (j = 4; argv[i][j]; j++)
3488 if (argv[i][j] == ',')
3489 {
3490 add_assembler_option (argv[i] + prev, j - prev);
3491 prev = j + 1;
3492 }
3493
3494 /* Record the part after the last comma. */
3495 add_assembler_option (argv[i] + prev, j - prev);
3496 }
3497 else if (! strncmp (argv[i], "-Wp,", 4))
3498 {
3499 int prev, j;
3500 /* Pass the rest of this option to the preprocessor. */
3501
3502 /* Split the argument at commas. */
3503 prev = 4;
3504 for (j = 4; argv[i][j]; j++)
3505 if (argv[i][j] == ',')
3506 {
3507 add_preprocessor_option (argv[i] + prev, j - prev);
3508 prev = j + 1;
3509 }
3510
3511 /* Record the part after the last comma. */
3512 add_preprocessor_option (argv[i] + prev, j - prev);
3513 }
3514 else if (argv[i][0] == '+' && argv[i][1] == 'e')
3515 /* The +e options to the C++ front-end. */
3516 n_switches++;
3517 else if (strncmp (argv[i], "-Wl,", 4) == 0)
3518 {
3519 int j;
3520 /* Split the argument at commas. */
3521 for (j = 3; argv[i][j]; j++)
3522 n_infiles += (argv[i][j] == ',');
3523 }
3524 else if (strcmp (argv[i], "-Xlinker") == 0)
3525 {
3526 if (i + 1 == argc)
3527 fatal ("argument to `-Xlinker' is missing");
3528
3529 n_infiles++;
3530 i++;
3531 }
3532 else if (strcmp (argv[i], "-Xpreprocessor") == 0)
3533 {
3534 if (i + 1 == argc)
3535 fatal ("argument to `-Xpreprocessor' is missing");
3536
3537 add_preprocessor_option (argv[i+1], strlen (argv[i+1]));
3538 }
3539 else if (strcmp (argv[i], "-Xassembler") == 0)
3540 {
3541 if (i + 1 == argc)
3542 fatal ("argument to `-Xassembler' is missing");
3543
3544 add_assembler_option (argv[i+1], strlen (argv[i+1]));
3545 }
3546 else if (strcmp (argv[i], "-l") == 0)
3547 {
3548 if (i + 1 == argc)
3549 fatal ("argument to `-l' is missing");
3550
3551 n_infiles++;
3552 i++;
3553 }
3554 else if (strncmp (argv[i], "-l", 2) == 0)
3555 n_infiles++;
3556 else if (strcmp (argv[i], "-save-temps") == 0)
3557 {
3558 save_temps_flag = 1;
3559 n_switches++;
3560 }
3561 else if (strcmp (argv[i], "-combine") == 0)
3562 {
3563 combine_flag = 1;
3564 n_switches++;
3565 }
3566 else if (strcmp (argv[i], "-specs") == 0)
3567 {
3568 struct user_specs *user = xmalloc (sizeof (struct user_specs));
3569 if (++i >= argc)
3570 fatal ("argument to `-specs' is missing");
3571
3572 user->next = (struct user_specs *) 0;
3573 user->filename = argv[i];
3574 if (user_specs_tail)
3575 user_specs_tail->next = user;
3576 else
3577 user_specs_head = user;
3578 user_specs_tail = user;
3579 }
3580 else if (strncmp (argv[i], "-specs=", 7) == 0)
3581 {
3582 struct user_specs *user = xmalloc (sizeof (struct user_specs));
3583 if (strlen (argv[i]) == 7)
3584 fatal ("argument to `-specs=' is missing");
3585
3586 user->next = (struct user_specs *) 0;
3587 user->filename = argv[i] + 7;
3588 if (user_specs_tail)
3589 user_specs_tail->next = user;
3590 else
3591 user_specs_head = user;
3592 user_specs_tail = user;
3593 }
3594 else if (strcmp (argv[i], "-time") == 0)
3595 report_times = 1;
3596 else if (strcmp (argv[i], "-pipe") == 0)
3597 {
3598 /* -pipe has to go into the switches array as well as
3599 setting a flag. */
3600 use_pipes = 1;
3601 n_switches++;
3602 }
3603 else if (strcmp (argv[i], "-###") == 0)
3604 {
3605 /* This is similar to -v except that there is no execution
3606 of the commands and the echoed arguments are quoted. It
3607 is intended for use in shell scripts to capture the
3608 driver-generated command line. */
3609 verbose_only_flag++;
3610 verbose_flag++;
3611 }
3612 else if (argv[i][0] == '-' && argv[i][1] != 0)
3613 {
3614 const char *p = &argv[i][1];
3615 int c = *p;
3616
3617 switch (c)
3618 {
3619 case 'b':
3620 case 'V':
3621 fatal ("`-%c' must come at the start of the command line", c);
3622 break;
3623
3624 case 'B':
3625 {
3626 const char *value;
3627 int len;
3628
3629 if (p[1] == 0 && i + 1 == argc)
3630 fatal ("argument to `-B' is missing");
3631 if (p[1] == 0)
3632 value = argv[++i];
3633 else
3634 value = p + 1;
3635
3636 len = strlen (value);
3637
3638 /* Catch the case where the user has forgotten to append a
3639 directory separator to the path. Note, they may be using
3640 -B to add an executable name prefix, eg "i386-elf-", in
3641 order to distinguish between multiple installations of
3642 GCC in the same directory. Hence we must check to see
3643 if appending a directory separator actually makes a
3644 valid directory name. */
3645 if (! IS_DIR_SEPARATOR (value [len - 1])
3646 && is_directory (value, "", 0))
3647 {
3648 char *tmp = xmalloc (len + 2);
3649 strcpy (tmp, value);
3650 tmp[len] = DIR_SEPARATOR;
3651 tmp[++ len] = 0;
3652 value = tmp;
3653 }
3654
3655 /* As a kludge, if the arg is "[foo/]stageN/", just
3656 add "[foo/]include" to the include prefix. */
3657 if ((len == 7
3658 || (len > 7
3659 && (IS_DIR_SEPARATOR (value[len - 8]))))
3660 && strncmp (value + len - 7, "stage", 5) == 0
3661 && ISDIGIT (value[len - 2])
3662 && (IS_DIR_SEPARATOR (value[len - 1])))
3663 {
3664 if (len == 7)
3665 add_prefix (&include_prefixes, "include", NULL,
3666 PREFIX_PRIORITY_B_OPT, 0, NULL, 0);
3667 else
3668 {
3669 char * string = xmalloc (len + 1);
3670
3671 strncpy (string, value, len - 7);
3672 strcpy (string + len - 7, "include");
3673 add_prefix (&include_prefixes, string, NULL,
3674 PREFIX_PRIORITY_B_OPT, 0, NULL, 0);
3675 }
3676 }
3677
3678 add_prefix (&exec_prefixes, value, NULL,
3679 PREFIX_PRIORITY_B_OPT, 0, &warn_B, 0);
3680 add_prefix (&startfile_prefixes, value, NULL,
3681 PREFIX_PRIORITY_B_OPT, 0, &warn_B, 0);
3682 add_prefix (&include_prefixes, concat (value, "include", NULL),
3683 NULL, PREFIX_PRIORITY_B_OPT, 0, NULL, 0);
3684 n_switches++;
3685 }
3686 break;
3687
3688 case 'v': /* Print our subcommands and print versions. */
3689 n_switches++;
3690 /* If they do anything other than exactly `-v', don't set
3691 verbose_flag; rather, continue on to give the error. */
3692 if (p[1] != 0)
3693 break;
3694 verbose_flag++;
3695 break;
3696
3697 case 'S':
3698 case 'c':
3699 if (p[1] == 0)
3700 {
3701 have_c = 1;
3702 n_switches++;
3703 break;
3704 }
3705 goto normal_switch;
3706
3707 case 'o':
3708 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3709 if (! have_c)
3710 {
3711 int skip;
3712
3713 /* Forward scan, just in case -S or -c is specified
3714 after -o. */
3715 int j = i + 1;
3716 if (p[1] == 0)
3717 ++j;
3718 while (j < argc)
3719 {
3720 if (argv[j][0] == '-')
3721 {
3722 if (SWITCH_CURTAILS_COMPILATION (argv[j][1])
3723 && argv[j][2] == 0)
3724 {
3725 have_c = 1;
3726 break;
3727 }
3728 else if ((skip = SWITCH_TAKES_ARG (argv[j][1])))
3729 j += skip - (argv[j][2] != 0);
3730 else if ((skip = WORD_SWITCH_TAKES_ARG (argv[j] + 1)))
3731 j += skip;
3732 }
3733 j++;
3734 }
3735 }
3736 #endif
3737 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3738 if (p[1] == 0)
3739 argv[i + 1] = convert_filename (argv[i + 1], ! have_c, 0);
3740 else
3741 argv[i] = convert_filename (argv[i], ! have_c, 0);
3742 #endif
3743 goto normal_switch;
3744
3745 default:
3746 normal_switch:
3747
3748 #ifdef MODIFY_TARGET_NAME
3749 is_modify_target_name = 0;
3750
3751 for (j = 0; j < ARRAY_SIZE (modify_target); j++)
3752 if (! strcmp (argv[i], modify_target[j].sw))
3753 {
3754 char *new_name = xmalloc (strlen (modify_target[j].str)
3755 + strlen (spec_machine));
3756 const char *p, *r;
3757 char *q;
3758 int made_addition = 0;
3759
3760 is_modify_target_name = 1;
3761 for (p = spec_machine, q = new_name; *p != 0; )
3762 {
3763 if (modify_target[j].add_del == DELETE
3764 && (! strncmp (q, modify_target[j].str,
3765 strlen (modify_target[j].str))))
3766 p += strlen (modify_target[j].str);
3767 else if (modify_target[j].add_del == ADD
3768 && ! made_addition && *p == '-')
3769 {
3770 for (r = modify_target[j].str; *r != 0; )
3771 *q++ = *r++;
3772 made_addition = 1;
3773 }
3774
3775 *q++ = *p++;
3776 }
3777
3778 spec_machine = new_name;
3779 }
3780
3781 if (is_modify_target_name)
3782 break;
3783 #endif
3784
3785 n_switches++;
3786
3787 if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
3788 i += SWITCH_TAKES_ARG (c) - (p[1] != 0);
3789 else if (WORD_SWITCH_TAKES_ARG (p))
3790 i += WORD_SWITCH_TAKES_ARG (p);
3791 }
3792 }
3793 else
3794 {
3795 n_infiles++;
3796 lang_n_infiles++;
3797 }
3798 }
3799
3800 if ((save_temps_flag || report_times) && use_pipes)
3801 {
3802 /* -save-temps overrides -pipe, so that temp files are produced */
3803 if (save_temps_flag)
3804 error ("warning: -pipe ignored because -save-temps specified");
3805 /* -time overrides -pipe because we can't get correct stats when
3806 multiple children are running at once. */
3807 else if (report_times)
3808 error ("warning: -pipe ignored because -time specified");
3809
3810 use_pipes = 0;
3811 }
3812
3813 /* Set up the search paths before we go looking for config files. */
3814
3815 /* These come before the md prefixes so that we will find gcc's subcommands
3816 (such as cpp) rather than those of the host system. */
3817 /* Use 2 as fourth arg meaning try just the machine as a suffix,
3818 as well as trying the machine and the version. */
3819 #ifndef OS2
3820 add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC",
3821 PREFIX_PRIORITY_LAST, 1, warn_std_ptr, 0);
3822 add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS",
3823 PREFIX_PRIORITY_LAST, 2, warn_std_ptr, 0);
3824 add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
3825 PREFIX_PRIORITY_LAST, 2, warn_std_ptr, 0);
3826 add_prefix (&exec_prefixes, standard_exec_prefix_1, "BINUTILS",
3827 PREFIX_PRIORITY_LAST, 2, warn_std_ptr, 0);
3828 add_prefix (&exec_prefixes, standard_exec_prefix_2, "BINUTILS",
3829 PREFIX_PRIORITY_LAST, 2, warn_std_ptr, 0);
3830 #endif
3831
3832 add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
3833 PREFIX_PRIORITY_LAST, 1, warn_std_ptr, 0);
3834 add_prefix (&startfile_prefixes, standard_exec_prefix_2, "BINUTILS",
3835 PREFIX_PRIORITY_LAST, 1, warn_std_ptr, 0);
3836
3837 tooldir_prefix = concat (tooldir_base_prefix, spec_machine,
3838 dir_separator_str, NULL);
3839
3840 /* If tooldir is relative, base it on exec_prefixes. A relative
3841 tooldir lets us move the installed tree as a unit.
3842
3843 If GCC_EXEC_PREFIX is defined, then we want to add two relative
3844 directories, so that we can search both the user specified directory
3845 and the standard place. */
3846
3847 if (!IS_ABSOLUTE_PATH (tooldir_prefix))
3848 {
3849 if (gcc_exec_prefix)
3850 {
3851 char *gcc_exec_tooldir_prefix
3852 = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
3853 spec_version, dir_separator_str, tooldir_prefix, NULL);
3854
3855 add_prefix (&exec_prefixes,
3856 concat (gcc_exec_tooldir_prefix, "bin",
3857 dir_separator_str, NULL),
3858 NULL, PREFIX_PRIORITY_LAST, 0, NULL, 0);
3859 add_prefix (&startfile_prefixes,
3860 concat (gcc_exec_tooldir_prefix, "lib",
3861 dir_separator_str, NULL),
3862 NULL, PREFIX_PRIORITY_LAST, 0, NULL, 1);
3863 }
3864
3865 tooldir_prefix = concat (standard_exec_prefix, spec_machine,
3866 dir_separator_str, spec_version,
3867 dir_separator_str, tooldir_prefix, NULL);
3868 }
3869
3870 add_prefix (&exec_prefixes,
3871 concat (tooldir_prefix, "bin", dir_separator_str, NULL),
3872 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL, 0);
3873 add_prefix (&startfile_prefixes,
3874 concat (tooldir_prefix, "lib", dir_separator_str, NULL),
3875 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL, 1);
3876
3877 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
3878 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
3879 then consider it to relocate with the rest of the GCC installation
3880 if GCC_EXEC_PREFIX is set.
3881 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
3882 if (target_system_root && gcc_exec_prefix)
3883 {
3884 char *tmp_prefix = make_relative_prefix (argv[0],
3885 standard_bindir_prefix,
3886 target_system_root);
3887 if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0)
3888 {
3889 target_system_root = tmp_prefix;
3890 target_system_root_changed = 1;
3891 }
3892 }
3893 #endif
3894
3895 /* More prefixes are enabled in main, after we read the specs file
3896 and determine whether this is cross-compilation or not. */
3897
3898 /* Then create the space for the vectors and scan again. */
3899
3900 switches = xmalloc ((n_switches + 1) * sizeof (struct switchstr));
3901 infiles = xmalloc ((n_infiles + 1) * sizeof (struct infile));
3902 n_switches = 0;
3903 n_infiles = 0;
3904 last_language_n_infiles = -1;
3905
3906 /* This, time, copy the text of each switch and store a pointer
3907 to the copy in the vector of switches.
3908 Store all the infiles in their vector. */
3909
3910 for (i = 1; i < argc; i++)
3911 {
3912 /* Just skip the switches that were handled by the preceding loop. */
3913 #ifdef MODIFY_TARGET_NAME
3914 is_modify_target_name = 0;
3915
3916 for (j = 0; j < ARRAY_SIZE (modify_target); j++)
3917 if (! strcmp (argv[i], modify_target[j].sw))
3918 is_modify_target_name = 1;
3919
3920 if (is_modify_target_name)
3921 ;
3922 else
3923 #endif
3924 if (! strncmp (argv[i], "-Wa,", 4))
3925 ;
3926 else if (! strncmp (argv[i], "-Wp,", 4))
3927 ;
3928 else if (! strcmp (argv[i], "-pass-exit-codes"))
3929 ;
3930 else if (! strcmp (argv[i], "-print-search-dirs"))
3931 ;
3932 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3933 ;
3934 else if (! strncmp (argv[i], "-print-file-name=", 17))
3935 ;
3936 else if (! strncmp (argv[i], "-print-prog-name=", 17))
3937 ;
3938 else if (! strcmp (argv[i], "-print-multi-lib"))
3939 ;
3940 else if (! strcmp (argv[i], "-print-multi-directory"))
3941 ;
3942 else if (! strcmp (argv[i], "-print-multi-os-directory"))
3943 ;
3944 else if (! strcmp (argv[i], "-ftarget-help"))
3945 ;
3946 else if (! strcmp (argv[i], "-fhelp"))
3947 ;
3948 else if (argv[i][0] == '+' && argv[i][1] == 'e')
3949 {
3950 /* Compensate for the +e options to the C++ front-end;
3951 they're there simply for cfront call-compatibility. We do
3952 some magic in default_compilers to pass them down properly.
3953 Note we deliberately start at the `+' here, to avoid passing
3954 -e0 or -e1 down into the linker. */
3955 switches[n_switches].part1 = &argv[i][0];
3956 switches[n_switches].args = 0;
3957 switches[n_switches].live_cond = SWITCH_OK;
3958 switches[n_switches].validated = 0;
3959 n_switches++;
3960 }
3961 else if (strncmp (argv[i], "-Wl,", 4) == 0)
3962 {
3963 int prev, j;
3964 /* Split the argument at commas. */
3965 prev = 4;
3966 for (j = 4; argv[i][j]; j++)
3967 if (argv[i][j] == ',')
3968 {
3969 infiles[n_infiles].language = "*";
3970 infiles[n_infiles++].name
3971 = save_string (argv[i] + prev, j - prev);
3972 prev = j + 1;
3973 }
3974 /* Record the part after the last comma. */
3975 infiles[n_infiles].language = "*";
3976 infiles[n_infiles++].name = argv[i] + prev;
3977 }
3978 else if (strcmp (argv[i], "-Xlinker") == 0)
3979 {
3980 infiles[n_infiles].language = "*";
3981 infiles[n_infiles++].name = argv[++i];
3982 }
3983 else if (strcmp (argv[i], "-Xassembler") == 0)
3984 {
3985 infiles[n_infiles].language = "*";
3986 infiles[n_infiles++].name = argv[++i];
3987 }
3988 else if (strcmp (argv[i], "-Xpreprocessor") == 0)
3989 {
3990 infiles[n_infiles].language = "*";
3991 infiles[n_infiles++].name = argv[++i];
3992 }
3993 else if (strcmp (argv[i], "-l") == 0)
3994 { /* POSIX allows separation of -l and the lib arg;
3995 canonicalize by concatenating -l with its arg */
3996 infiles[n_infiles].language = "*";
3997 infiles[n_infiles++].name = concat ("-l", argv[++i], NULL);
3998 }
3999 else if (strncmp (argv[i], "-l", 2) == 0)
4000 {
4001 infiles[n_infiles].language = "*";
4002 infiles[n_infiles++].name = argv[i];
4003 }
4004 else if (strcmp (argv[i], "-specs") == 0)
4005 i++;
4006 else if (strncmp (argv[i], "-specs=", 7) == 0)
4007 ;
4008 else if (strcmp (argv[i], "-time") == 0)
4009 ;
4010 else if (strcmp (argv[i], "-###") == 0)
4011 ;
4012 else if (argv[i][0] == '-' && argv[i][1] != 0)
4013 {
4014 const char *p = &argv[i][1];
4015 int c = *p;
4016
4017 if (c == 'x')
4018 {
4019 if (p[1] == 0 && i + 1 == argc)
4020 fatal ("argument to `-x' is missing");
4021 if (p[1] == 0)
4022 spec_lang = argv[++i];
4023 else
4024 spec_lang = p + 1;
4025 if (! strcmp (spec_lang, "none"))
4026 /* Suppress the warning if -xnone comes after the last input
4027 file, because alternate command interfaces like g++ might
4028 find it useful to place -xnone after each input file. */
4029 spec_lang = 0;
4030 else
4031 last_language_n_infiles = n_infiles;
4032 continue;
4033 }
4034 switches[n_switches].part1 = p;
4035 /* Deal with option arguments in separate argv elements. */
4036 if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
4037 || WORD_SWITCH_TAKES_ARG (p))
4038 {
4039 int j = 0;
4040 int n_args = WORD_SWITCH_TAKES_ARG (p);
4041
4042 if (n_args == 0)
4043 {
4044 /* Count only the option arguments in separate argv elements. */
4045 n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
4046 }
4047 if (i + n_args >= argc)
4048 fatal ("argument to `-%s' is missing", p);
4049 switches[n_switches].args
4050 = xmalloc ((n_args + 1) * sizeof(const char *));
4051 while (j < n_args)
4052 switches[n_switches].args[j++] = argv[++i];
4053 /* Null-terminate the vector. */
4054 switches[n_switches].args[j] = 0;
4055 }
4056 else if (strchr (switches_need_spaces, c))
4057 {
4058 /* On some systems, ld cannot handle some options without
4059 a space. So split the option from its argument. */
4060 char *part1 = xmalloc (2);
4061 part1[0] = c;
4062 part1[1] = '\0';
4063
4064 switches[n_switches].part1 = part1;
4065 switches[n_switches].args = xmalloc (2 * sizeof (const char *));
4066 switches[n_switches].args[0] = xstrdup (p+1);
4067 switches[n_switches].args[1] = 0;
4068 }
4069 else
4070 switches[n_switches].args = 0;
4071
4072 switches[n_switches].live_cond = SWITCH_OK;
4073 switches[n_switches].validated = 0;
4074 switches[n_switches].ordering = 0;
4075 /* These are always valid, since gcc.c itself understands them. */
4076 if (!strcmp (p, "save-temps")
4077 || !strcmp (p, "static-libgcc")
4078 || !strcmp (p, "shared-libgcc")
4079 || !strcmp (p, "pipe"))
4080 switches[n_switches].validated = 1;
4081 else
4082 {
4083 char ch = switches[n_switches].part1[0];
4084 if (ch == 'B')
4085 switches[n_switches].validated = 1;
4086 }
4087 n_switches++;
4088 }
4089 else
4090 {
4091 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4092 argv[i] = convert_filename (argv[i], 0, access (argv[i], F_OK));
4093 #endif
4094
4095 if (strcmp (argv[i], "-") != 0 && access (argv[i], F_OK) < 0)
4096 {
4097 perror_with_name (argv[i]);
4098 error_count++;
4099 }
4100 else
4101 {
4102 infiles[n_infiles].language = spec_lang;
4103 infiles[n_infiles++].name = argv[i];
4104 }
4105 }
4106 }
4107
4108 if (n_infiles == last_language_n_infiles && spec_lang != 0)
4109 error ("warning: `-x %s' after last input file has no effect", spec_lang);
4110
4111 /* Ensure we only invoke each subprocess once. */
4112 if (target_help_flag || print_help_list)
4113 {
4114 n_infiles = 1;
4115
4116 /* Create a dummy input file, so that we can pass --target-help on to
4117 the various sub-processes. */
4118 infiles[0].language = "c";
4119 infiles[0].name = "help-dummy";
4120
4121 if (target_help_flag)
4122 {
4123 switches[n_switches].part1 = "--target-help";
4124 switches[n_switches].args = 0;
4125 switches[n_switches].live_cond = SWITCH_OK;
4126 switches[n_switches].validated = 0;
4127
4128 n_switches++;
4129 }
4130
4131 if (print_help_list)
4132 {
4133 switches[n_switches].part1 = "--help";
4134 switches[n_switches].args = 0;
4135 switches[n_switches].live_cond = SWITCH_OK;
4136 switches[n_switches].validated = 0;
4137
4138 n_switches++;
4139 }
4140 }
4141
4142 switches[n_switches].part1 = 0;
4143 infiles[n_infiles].name = 0;
4144 }
4145
4146 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4147 and place that in the environment. */
4148
4149 static void
4150 set_collect_gcc_options (void)
4151 {
4152 int i;
4153 int first_time;
4154
4155 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4156 the compiler. */
4157 obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
4158 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4159
4160 first_time = TRUE;
4161 for (i = 0; (int) i < n_switches; i++)
4162 {
4163 const char *const *args;
4164 const char *p, *q;
4165 if (!first_time)
4166 obstack_grow (&collect_obstack, " ", 1);
4167
4168 first_time = FALSE;
4169
4170 /* Ignore elided switches. */
4171 if (switches[i].live_cond == SWITCH_IGNORE)
4172 continue;
4173
4174 obstack_grow (&collect_obstack, "'-", 2);
4175 q = switches[i].part1;
4176 while ((p = strchr (q, '\'')))
4177 {
4178 obstack_grow (&collect_obstack, q, p - q);
4179 obstack_grow (&collect_obstack, "'\\''", 4);
4180 q = ++p;
4181 }
4182 obstack_grow (&collect_obstack, q, strlen (q));
4183 obstack_grow (&collect_obstack, "'", 1);
4184
4185 for (args = switches[i].args; args && *args; args++)
4186 {
4187 obstack_grow (&collect_obstack, " '", 2);
4188 q = *args;
4189 while ((p = strchr (q, '\'')))
4190 {
4191 obstack_grow (&collect_obstack, q, p - q);
4192 obstack_grow (&collect_obstack, "'\\''", 4);
4193 q = ++p;
4194 }
4195 obstack_grow (&collect_obstack, q, strlen (q));
4196 obstack_grow (&collect_obstack, "'", 1);
4197 }
4198 }
4199 obstack_grow (&collect_obstack, "\0", 1);
4200 putenv (obstack_finish (&collect_obstack));
4201 }
4202 \f
4203 /* Process a spec string, accumulating and running commands. */
4204
4205 /* These variables describe the input file name.
4206 input_file_number is the index on outfiles of this file,
4207 so that the output file name can be stored for later use by %o.
4208 input_basename is the start of the part of the input file
4209 sans all directory names, and basename_length is the number
4210 of characters starting there excluding the suffix .c or whatever. */
4211
4212 static const char *input_filename;
4213 static int input_file_number;
4214 size_t input_filename_length;
4215 static int basename_length;
4216 static int suffixed_basename_length;
4217 static const char *input_basename;
4218 static const char *input_suffix;
4219 static struct stat input_stat;
4220 static int input_stat_set;
4221
4222 /* The compiler used to process the current input file. */
4223 static struct compiler *input_file_compiler;
4224
4225 /* These are variables used within do_spec and do_spec_1. */
4226
4227 /* Nonzero if an arg has been started and not yet terminated
4228 (with space, tab or newline). */
4229 static int arg_going;
4230
4231 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4232 is a temporary file name. */
4233 static int delete_this_arg;
4234
4235 /* Nonzero means %w has been seen; the next arg to be terminated
4236 is the output file name of this compilation. */
4237 static int this_is_output_file;
4238
4239 /* Nonzero means %s has been seen; the next arg to be terminated
4240 is the name of a library file and we should try the standard
4241 search dirs for it. */
4242 static int this_is_library_file;
4243
4244 /* Nonzero means that the input of this command is coming from a pipe. */
4245 static int input_from_pipe;
4246
4247 /* Nonnull means substitute this for any suffix when outputting a switches
4248 arguments. */
4249 static const char *suffix_subst;
4250
4251 /* Process the spec SPEC and run the commands specified therein.
4252 Returns 0 if the spec is successfully processed; -1 if failed. */
4253
4254 int
4255 do_spec (const char *spec)
4256 {
4257 int value;
4258
4259 value = do_spec_2 (spec);
4260
4261 /* Force out any unfinished command.
4262 If -pipe, this forces out the last command if it ended in `|'. */
4263 if (value == 0)
4264 {
4265 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
4266 argbuf_index--;
4267
4268 set_collect_gcc_options ();
4269
4270 if (argbuf_index > 0)
4271 value = execute ();
4272 }
4273
4274 return value;
4275 }
4276
4277 static int
4278 do_spec_2 (const char *spec)
4279 {
4280 const char *string;
4281 int result;
4282
4283 clear_args ();
4284 arg_going = 0;
4285 delete_this_arg = 0;
4286 this_is_output_file = 0;
4287 this_is_library_file = 0;
4288 input_from_pipe = 0;
4289 suffix_subst = NULL;
4290
4291 result = do_spec_1 (spec, 0, NULL);
4292
4293 /* End any pending argument. */
4294 if (arg_going)
4295 {
4296 obstack_1grow (&obstack, 0);
4297 string = obstack_finish (&obstack);
4298 if (this_is_library_file)
4299 string = find_file (string);
4300 store_arg (string, delete_this_arg, this_is_output_file);
4301 if (this_is_output_file)
4302 outfiles[input_file_number] = string;
4303 arg_going = 0;
4304 }
4305
4306 return result;
4307 }
4308
4309
4310 /* Process the given spec string and add any new options to the end
4311 of the switches/n_switches array. */
4312
4313 static void
4314 do_option_spec (const char *name, const char *spec)
4315 {
4316 unsigned int i, value_count, value_len;
4317 const char *p, *q, *value;
4318 char *tmp_spec, *tmp_spec_p;
4319
4320 if (configure_default_options[0].name == NULL)
4321 return;
4322
4323 for (i = 0; i < ARRAY_SIZE (configure_default_options); i++)
4324 if (strcmp (configure_default_options[i].name, name) == 0)
4325 break;
4326 if (i == ARRAY_SIZE (configure_default_options))
4327 return;
4328
4329 value = configure_default_options[i].value;
4330 value_len = strlen (value);
4331
4332 /* Compute the size of the final spec. */
4333 value_count = 0;
4334 p = spec;
4335 while ((p = strstr (p, "%(VALUE)")) != NULL)
4336 {
4337 p ++;
4338 value_count ++;
4339 }
4340
4341 /* Replace each %(VALUE) by the specified value. */
4342 tmp_spec = alloca (strlen (spec) + 1
4343 + value_count * (value_len - strlen ("%(VALUE)")));
4344 tmp_spec_p = tmp_spec;
4345 q = spec;
4346 while ((p = strstr (q, "%(VALUE)")) != NULL)
4347 {
4348 memcpy (tmp_spec_p, q, p - q);
4349 tmp_spec_p = tmp_spec_p + (p - q);
4350 memcpy (tmp_spec_p, value, value_len);
4351 tmp_spec_p += value_len;
4352 q = p + strlen ("%(VALUE)");
4353 }
4354 strcpy (tmp_spec_p, q);
4355
4356 do_self_spec (tmp_spec);
4357 }
4358
4359 /* Process the given spec string and add any new options to the end
4360 of the switches/n_switches array. */
4361
4362 static void
4363 do_self_spec (const char *spec)
4364 {
4365 do_spec_2 (spec);
4366 do_spec_1 (" ", 0, NULL);
4367
4368 if (argbuf_index > 0)
4369 {
4370 int i, first;
4371
4372 first = n_switches;
4373 n_switches += argbuf_index;
4374 switches = xrealloc (switches,
4375 sizeof (struct switchstr) * (n_switches + 1));
4376
4377 switches[n_switches] = switches[first];
4378 for (i = 0; i < argbuf_index; i++)
4379 {
4380 struct switchstr *sw;
4381
4382 /* Each switch should start with '-'. */
4383 if (argbuf[i][0] != '-')
4384 abort ();
4385
4386 sw = &switches[i + first];
4387 sw->part1 = &argbuf[i][1];
4388 sw->args = 0;
4389 sw->live_cond = SWITCH_OK;
4390 sw->validated = 0;
4391 sw->ordering = 0;
4392 }
4393 }
4394 }
4395
4396 /* Process the sub-spec SPEC as a portion of a larger spec.
4397 This is like processing a whole spec except that we do
4398 not initialize at the beginning and we do not supply a
4399 newline by default at the end.
4400 INSWITCH nonzero means don't process %-sequences in SPEC;
4401 in this case, % is treated as an ordinary character.
4402 This is used while substituting switches.
4403 INSWITCH nonzero also causes SPC not to terminate an argument.
4404
4405 Value is zero unless a line was finished
4406 and the command on that line reported an error. */
4407
4408 static int
4409 do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
4410 {
4411 const char *p = spec;
4412 int c;
4413 int i;
4414 const char *string;
4415 int value;
4416
4417 while ((c = *p++))
4418 /* If substituting a switch, treat all chars like letters.
4419 Otherwise, NL, SPC, TAB and % are special. */
4420 switch (inswitch ? 'a' : c)
4421 {
4422 case '\n':
4423 /* End of line: finish any pending argument,
4424 then run the pending command if one has been started. */
4425 if (arg_going)
4426 {
4427 obstack_1grow (&obstack, 0);
4428 string = obstack_finish (&obstack);
4429 if (this_is_library_file)
4430 string = find_file (string);
4431 store_arg (string, delete_this_arg, this_is_output_file);
4432 if (this_is_output_file)
4433 outfiles[input_file_number] = string;
4434 }
4435 arg_going = 0;
4436
4437 if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
4438 {
4439 /* A `|' before the newline means use a pipe here,
4440 but only if -pipe was specified.
4441 Otherwise, execute now and don't pass the `|' as an arg. */
4442 if (use_pipes)
4443 {
4444 input_from_pipe = 1;
4445 break;
4446 }
4447 else
4448 argbuf_index--;
4449 }
4450
4451 set_collect_gcc_options ();
4452
4453 if (argbuf_index > 0)
4454 {
4455 value = execute ();
4456 if (value)
4457 return value;
4458 }
4459 /* Reinitialize for a new command, and for a new argument. */
4460 clear_args ();
4461 arg_going = 0;
4462 delete_this_arg = 0;
4463 this_is_output_file = 0;
4464 this_is_library_file = 0;
4465 input_from_pipe = 0;
4466 break;
4467
4468 case '|':
4469 /* End any pending argument. */
4470 if (arg_going)
4471 {
4472 obstack_1grow (&obstack, 0);
4473 string = obstack_finish (&obstack);
4474 if (this_is_library_file)
4475 string = find_file (string);
4476 store_arg (string, delete_this_arg, this_is_output_file);
4477 if (this_is_output_file)
4478 outfiles[input_file_number] = string;
4479 }
4480
4481 /* Use pipe */
4482 obstack_1grow (&obstack, c);
4483 arg_going = 1;
4484 break;
4485
4486 case '\t':
4487 case ' ':
4488 /* Space or tab ends an argument if one is pending. */
4489 if (arg_going)
4490 {
4491 obstack_1grow (&obstack, 0);
4492 string = obstack_finish (&obstack);
4493 if (this_is_library_file)
4494 string = find_file (string);
4495 store_arg (string, delete_this_arg, this_is_output_file);
4496 if (this_is_output_file)
4497 outfiles[input_file_number] = string;
4498 }
4499 /* Reinitialize for a new argument. */
4500 arg_going = 0;
4501 delete_this_arg = 0;
4502 this_is_output_file = 0;
4503 this_is_library_file = 0;
4504 break;
4505
4506 case '%':
4507 switch (c = *p++)
4508 {
4509 case 0:
4510 fatal ("invalid specification! Bug in cc");
4511
4512 case 'b':
4513 obstack_grow (&obstack, input_basename, basename_length);
4514 arg_going = 1;
4515 break;
4516
4517 case 'B':
4518 obstack_grow (&obstack, input_basename, suffixed_basename_length);
4519 arg_going = 1;
4520 break;
4521
4522 case 'd':
4523 delete_this_arg = 2;
4524 break;
4525
4526 /* Dump out the directories specified with LIBRARY_PATH,
4527 followed by the absolute directories
4528 that we search for startfiles. */
4529 case 'D':
4530 {
4531 struct prefix_list *pl = startfile_prefixes.plist;
4532 size_t bufsize = 100;
4533 char *buffer = xmalloc (bufsize);
4534 int idx;
4535
4536 for (; pl; pl = pl->next)
4537 {
4538 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
4539 /* Used on systems which record the specified -L dirs
4540 and use them to search for dynamic linking. */
4541 /* Relative directories always come from -B,
4542 and it is better not to use them for searching
4543 at run time. In particular, stage1 loses. */
4544 if (!IS_ABSOLUTE_PATH (pl->prefix))
4545 continue;
4546 #endif
4547 /* Try subdirectory if there is one. */
4548 if (multilib_dir != NULL
4549 || (pl->os_multilib && multilib_os_dir != NULL))
4550 {
4551 const char *multi_dir;
4552
4553 multi_dir = pl->os_multilib ? multilib_os_dir
4554 : multilib_dir;
4555 if (machine_suffix && multilib_dir)
4556 {
4557 if (strlen (pl->prefix) + strlen (machine_suffix)
4558 >= bufsize)
4559 bufsize = (strlen (pl->prefix)
4560 + strlen (machine_suffix)) * 2 + 1;
4561 buffer = xrealloc (buffer, bufsize);
4562 strcpy (buffer, pl->prefix);
4563 strcat (buffer, machine_suffix);
4564 if (is_directory (buffer, multilib_dir, 1))
4565 {
4566 do_spec_1 ("-L", 0, NULL);
4567 #ifdef SPACE_AFTER_L_OPTION
4568 do_spec_1 (" ", 0, NULL);
4569 #endif
4570 do_spec_1 (buffer, 1, NULL);
4571 do_spec_1 (multilib_dir, 1, NULL);
4572 /* Make this a separate argument. */
4573 do_spec_1 (" ", 0, NULL);
4574 }
4575 }
4576 if (!pl->require_machine_suffix)
4577 {
4578 if (is_directory (pl->prefix, multi_dir, 1))
4579 {
4580 do_spec_1 ("-L", 0, NULL);
4581 #ifdef SPACE_AFTER_L_OPTION
4582 do_spec_1 (" ", 0, NULL);
4583 #endif
4584 do_spec_1 (pl->prefix, 1, NULL);
4585 do_spec_1 (multi_dir, 1, NULL);
4586 /* Make this a separate argument. */
4587 do_spec_1 (" ", 0, NULL);
4588 }
4589 }
4590 }
4591 if (machine_suffix)
4592 {
4593 if (is_directory (pl->prefix, machine_suffix, 1))
4594 {
4595 do_spec_1 ("-L", 0, NULL);
4596 #ifdef SPACE_AFTER_L_OPTION
4597 do_spec_1 (" ", 0, NULL);
4598 #endif
4599 do_spec_1 (pl->prefix, 1, NULL);
4600 /* Remove slash from machine_suffix. */
4601 if (strlen (machine_suffix) >= bufsize)
4602 bufsize = strlen (machine_suffix) * 2 + 1;
4603 buffer = xrealloc (buffer, bufsize);
4604 strcpy (buffer, machine_suffix);
4605 idx = strlen (buffer);
4606 if (IS_DIR_SEPARATOR (buffer[idx - 1]))
4607 buffer[idx - 1] = 0;
4608 do_spec_1 (buffer, 1, NULL);
4609 /* Make this a separate argument. */
4610 do_spec_1 (" ", 0, NULL);
4611 }
4612 }
4613 if (!pl->require_machine_suffix)
4614 {
4615 if (is_directory (pl->prefix, "", 1))
4616 {
4617 do_spec_1 ("-L", 0, NULL);
4618 #ifdef SPACE_AFTER_L_OPTION
4619 do_spec_1 (" ", 0, NULL);
4620 #endif
4621 /* Remove slash from pl->prefix. */
4622 if (strlen (pl->prefix) >= bufsize)
4623 bufsize = strlen (pl->prefix) * 2 + 1;
4624 buffer = xrealloc (buffer, bufsize);
4625 strcpy (buffer, pl->prefix);
4626 idx = strlen (buffer);
4627 if (IS_DIR_SEPARATOR (buffer[idx - 1]))
4628 buffer[idx - 1] = 0;
4629 do_spec_1 (buffer, 1, NULL);
4630 /* Make this a separate argument. */
4631 do_spec_1 (" ", 0, NULL);
4632 }
4633 }
4634 }
4635 free (buffer);
4636 }
4637 break;
4638
4639 case 'e':
4640 /* %efoo means report an error with `foo' as error message
4641 and don't execute any more commands for this file. */
4642 {
4643 const char *q = p;
4644 char *buf;
4645 while (*p != 0 && *p != '\n')
4646 p++;
4647 buf = alloca (p - q + 1);
4648 strncpy (buf, q, p - q);
4649 buf[p - q] = 0;
4650 error ("%s", buf);
4651 return -1;
4652 }
4653 break;
4654 case 'n':
4655 /* %nfoo means report a notice with `foo' on stderr. */
4656 {
4657 const char *q = p;
4658 char *buf;
4659 while (*p != 0 && *p != '\n')
4660 p++;
4661 buf = alloca (p - q + 1);
4662 strncpy (buf, q, p - q);
4663 buf[p - q] = 0;
4664 notice ("%s\n", buf);
4665 if (*p)
4666 p++;
4667 }
4668 break;
4669
4670 case 'j':
4671 {
4672 struct stat st;
4673
4674 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
4675 defined, and it is not a directory, and it is
4676 writable, use it. Otherwise, treat this like any
4677 other temporary file. */
4678
4679 if ((!save_temps_flag)
4680 && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode))
4681 && (access (HOST_BIT_BUCKET, W_OK) == 0))
4682 {
4683 obstack_grow (&obstack, HOST_BIT_BUCKET,
4684 strlen (HOST_BIT_BUCKET));
4685 delete_this_arg = 0;
4686 arg_going = 1;
4687 break;
4688 }
4689 }
4690 goto create_temp_file;
4691 case '|':
4692 if (use_pipes)
4693 {
4694 obstack_1grow (&obstack, '-');
4695 delete_this_arg = 0;
4696 arg_going = 1;
4697
4698 /* consume suffix */
4699 while (*p == '.' || ISALPHA ((unsigned char) *p))
4700 p++;
4701 if (p[0] == '%' && p[1] == 'O')
4702 p += 2;
4703
4704 break;
4705 }
4706 goto create_temp_file;
4707 case 'm':
4708 if (use_pipes)
4709 {
4710 /* consume suffix */
4711 while (*p == '.' || ISALPHA ((unsigned char) *p))
4712 p++;
4713 if (p[0] == '%' && p[1] == 'O')
4714 p += 2;
4715
4716 break;
4717 }
4718 goto create_temp_file;
4719 case 'g':
4720 case 'u':
4721 case 'U':
4722 create_temp_file:
4723 {
4724 struct temp_name *t;
4725 int suffix_length;
4726 const char *suffix = p;
4727 char *saved_suffix = NULL;
4728
4729 while (*p == '.' || ISALPHA ((unsigned char) *p))
4730 p++;
4731 suffix_length = p - suffix;
4732 if (p[0] == '%' && p[1] == 'O')
4733 {
4734 p += 2;
4735 /* We don't support extra suffix characters after %O. */
4736 if (*p == '.' || ISALPHA ((unsigned char) *p))
4737 abort ();
4738 if (suffix_length == 0)
4739 suffix = TARGET_OBJECT_SUFFIX;
4740 else
4741 {
4742 saved_suffix
4743 = xmalloc (suffix_length
4744 + strlen (TARGET_OBJECT_SUFFIX));
4745 strncpy (saved_suffix, suffix, suffix_length);
4746 strcpy (saved_suffix + suffix_length,
4747 TARGET_OBJECT_SUFFIX);
4748 }
4749 suffix_length += strlen (TARGET_OBJECT_SUFFIX);
4750 }
4751
4752 /* If the input_filename has the same suffix specified
4753 for the %g, %u, or %U, and -save-temps is specified,
4754 we could end up using that file as an intermediate
4755 thus clobbering the user's source file (.e.g.,
4756 gcc -save-temps foo.s would clobber foo.s with the
4757 output of cpp0). So check for this condition and
4758 generate a temp file as the intermediate. */
4759
4760 if (save_temps_flag)
4761 {
4762 temp_filename_length = basename_length + suffix_length;
4763 temp_filename = alloca (temp_filename_length + 1);
4764 strncpy ((char *) temp_filename, input_basename, basename_length);
4765 strncpy ((char *) temp_filename + basename_length, suffix,
4766 suffix_length);
4767 *((char *) temp_filename + temp_filename_length) = '\0';
4768 if (strcmp (temp_filename, input_filename) != 0)
4769 {
4770 struct stat st_temp;
4771
4772 /* Note, set_input() resets input_stat_set to 0. */
4773 if (input_stat_set == 0)
4774 {
4775 input_stat_set = stat (input_filename, &input_stat);
4776 if (input_stat_set >= 0)
4777 input_stat_set = 1;
4778 }
4779
4780 /* If we have the stat for the input_filename
4781 and we can do the stat for the temp_filename
4782 then the they could still refer to the same
4783 file if st_dev/st_ino's are the same. */
4784
4785 if (input_stat_set != 1
4786 || stat (temp_filename, &st_temp) < 0
4787 || input_stat.st_dev != st_temp.st_dev
4788 || input_stat.st_ino != st_temp.st_ino)
4789 {
4790 temp_filename = save_string (temp_filename,
4791 temp_filename_length + 1);
4792 obstack_grow (&obstack, temp_filename,
4793 temp_filename_length);
4794 arg_going = 1;
4795 delete_this_arg = 0;
4796 break;
4797 }
4798 }
4799 }
4800
4801 /* See if we already have an association of %g/%u/%U and
4802 suffix. */
4803 for (t = temp_names; t; t = t->next)
4804 if (t->length == suffix_length
4805 && strncmp (t->suffix, suffix, suffix_length) == 0
4806 && t->unique == (c == 'u' || c == 'U' || c == 'j'))
4807 break;
4808
4809 /* Make a new association if needed. %u and %j
4810 require one. */
4811 if (t == 0 || c == 'u' || c == 'j')
4812 {
4813 if (t == 0)
4814 {
4815 t = xmalloc (sizeof (struct temp_name));
4816 t->next = temp_names;
4817 temp_names = t;
4818 }
4819 t->length = suffix_length;
4820 if (saved_suffix)
4821 {
4822 t->suffix = saved_suffix;
4823 saved_suffix = NULL;
4824 }
4825 else
4826 t->suffix = save_string (suffix, suffix_length);
4827 t->unique = (c == 'u' || c == 'U' || c == 'j');
4828 temp_filename = make_temp_file (t->suffix);
4829 temp_filename_length = strlen (temp_filename);
4830 t->filename = temp_filename;
4831 t->filename_length = temp_filename_length;
4832 }
4833
4834 if (saved_suffix)
4835 free (saved_suffix);
4836
4837 obstack_grow (&obstack, t->filename, t->filename_length);
4838 delete_this_arg = 1;
4839 }
4840 arg_going = 1;
4841 break;
4842
4843 case 'i':
4844 if (combine_inputs)
4845 {
4846 for (i = 0; (int) i < n_infiles; i++)
4847 if ((!infiles[i].language) || (infiles[i].language[0] != '*'))
4848 if (infiles[i].incompiler == input_file_compiler)
4849 {
4850 store_arg (infiles[i].name, 0, 0);
4851 infiles[i].compiled = true;
4852 }
4853 }
4854 else
4855 {
4856 obstack_grow (&obstack, input_filename, input_filename_length);
4857 arg_going = 1;
4858 }
4859 break;
4860
4861 case 'I':
4862 {
4863 struct prefix_list *pl = include_prefixes.plist;
4864
4865 if (gcc_exec_prefix)
4866 {
4867 do_spec_1 ("-iprefix", 1, NULL);
4868 /* Make this a separate argument. */
4869 do_spec_1 (" ", 0, NULL);
4870 do_spec_1 (gcc_exec_prefix, 1, NULL);
4871 do_spec_1 (" ", 0, NULL);
4872 }
4873
4874 if (target_system_root_changed ||
4875 (target_system_root && target_sysroot_hdrs_suffix))
4876 {
4877 do_spec_1 ("-isysroot", 1, NULL);
4878 /* Make this a separate argument. */
4879 do_spec_1 (" ", 0, NULL);
4880 do_spec_1 (target_system_root, 1, NULL);
4881 if (target_sysroot_hdrs_suffix)
4882 do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL);
4883 do_spec_1 (" ", 0, NULL);
4884 }
4885
4886 for (; pl; pl = pl->next)
4887 {
4888 do_spec_1 ("-isystem", 1, NULL);
4889 /* Make this a separate argument. */
4890 do_spec_1 (" ", 0, NULL);
4891 do_spec_1 (pl->prefix, 1, NULL);
4892 do_spec_1 (" ", 0, NULL);
4893 }
4894 }
4895 break;
4896
4897 case 'o':
4898 {
4899 int max = n_infiles;
4900 max += lang_specific_extra_outfiles;
4901
4902 for (i = 0; i < max; i++)
4903 if (outfiles[i])
4904 store_arg (outfiles[i], 0, 0);
4905 break;
4906 }
4907
4908 case 'O':
4909 obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
4910 arg_going = 1;
4911 break;
4912
4913 case 's':
4914 this_is_library_file = 1;
4915 break;
4916
4917 case 'V':
4918 outfiles[input_file_number] = NULL;
4919 break;
4920
4921 case 'w':
4922 this_is_output_file = 1;
4923 break;
4924
4925 case 'W':
4926 {
4927 int cur_index = argbuf_index;
4928 /* Handle the {...} following the %W. */
4929 if (*p != '{')
4930 abort ();
4931 p = handle_braces (p + 1);
4932 if (p == 0)
4933 return -1;
4934 /* End any pending argument. */
4935 if (arg_going)
4936 {
4937 obstack_1grow (&obstack, 0);
4938 string = obstack_finish (&obstack);
4939 if (this_is_library_file)
4940 string = find_file (string);
4941 store_arg (string, delete_this_arg, this_is_output_file);
4942 if (this_is_output_file)
4943 outfiles[input_file_number] = string;
4944 arg_going = 0;
4945 }
4946 /* If any args were output, mark the last one for deletion
4947 on failure. */
4948 if (argbuf_index != cur_index)
4949 record_temp_file (argbuf[argbuf_index - 1], 0, 1);
4950 break;
4951 }
4952
4953 /* %x{OPTION} records OPTION for %X to output. */
4954 case 'x':
4955 {
4956 const char *p1 = p;
4957 char *string;
4958
4959 /* Skip past the option value and make a copy. */
4960 if (*p != '{')
4961 abort ();
4962 while (*p++ != '}')
4963 ;
4964 string = save_string (p1 + 1, p - p1 - 2);
4965
4966 /* See if we already recorded this option. */
4967 for (i = 0; i < n_linker_options; i++)
4968 if (! strcmp (string, linker_options[i]))
4969 {
4970 free (string);
4971 return 0;
4972 }
4973
4974 /* This option is new; add it. */
4975 add_linker_option (string, strlen (string));
4976 }
4977 break;
4978
4979 /* Dump out the options accumulated previously using %x. */
4980 case 'X':
4981 for (i = 0; i < n_linker_options; i++)
4982 {
4983 do_spec_1 (linker_options[i], 1, NULL);
4984 /* Make each accumulated option a separate argument. */
4985 do_spec_1 (" ", 0, NULL);
4986 }
4987 break;
4988
4989 /* Dump out the options accumulated previously using -Wa,. */
4990 case 'Y':
4991 for (i = 0; i < n_assembler_options; i++)
4992 {
4993 do_spec_1 (assembler_options[i], 1, NULL);
4994 /* Make each accumulated option a separate argument. */
4995 do_spec_1 (" ", 0, NULL);
4996 }
4997 break;
4998
4999 /* Dump out the options accumulated previously using -Wp,. */
5000 case 'Z':
5001 for (i = 0; i < n_preprocessor_options; i++)
5002 {
5003 do_spec_1 (preprocessor_options[i], 1, NULL);
5004 /* Make each accumulated option a separate argument. */
5005 do_spec_1 (" ", 0, NULL);
5006 }
5007 break;
5008
5009 /* Here are digits and numbers that just process
5010 a certain constant string as a spec. */
5011
5012 case '1':
5013 value = do_spec_1 (cc1_spec, 0, NULL);
5014 if (value != 0)
5015 return value;
5016 break;
5017
5018 case '2':
5019 value = do_spec_1 (cc1plus_spec, 0, NULL);
5020 if (value != 0)
5021 return value;
5022 break;
5023
5024 case 'a':
5025 value = do_spec_1 (asm_spec, 0, NULL);
5026 if (value != 0)
5027 return value;
5028 break;
5029
5030 case 'A':
5031 value = do_spec_1 (asm_final_spec, 0, NULL);
5032 if (value != 0)
5033 return value;
5034 break;
5035
5036 case 'C':
5037 {
5038 const char *const spec
5039 = (input_file_compiler->cpp_spec
5040 ? input_file_compiler->cpp_spec
5041 : cpp_spec);
5042 value = do_spec_1 (spec, 0, NULL);
5043 if (value != 0)
5044 return value;
5045 }
5046 break;
5047
5048 case 'E':
5049 value = do_spec_1 (endfile_spec, 0, NULL);
5050 if (value != 0)
5051 return value;
5052 break;
5053
5054 case 'l':
5055 value = do_spec_1 (link_spec, 0, NULL);
5056 if (value != 0)
5057 return value;
5058 break;
5059
5060 case 'L':
5061 value = do_spec_1 (lib_spec, 0, NULL);
5062 if (value != 0)
5063 return value;
5064 break;
5065
5066 case 'G':
5067 value = do_spec_1 (libgcc_spec, 0, NULL);
5068 if (value != 0)
5069 return value;
5070 break;
5071
5072 case 'M':
5073 if (multilib_dir && strcmp (multilib_dir, ".") != 0)
5074 {
5075 char *p;
5076 const char *q;
5077 size_t len;
5078
5079 len = strlen (multilib_dir);
5080 obstack_blank (&obstack, len + 1);
5081 p = obstack_next_free (&obstack) - (len + 1);
5082
5083 *p++ = '_';
5084 for (q = multilib_dir; *q ; ++q, ++p)
5085 *p = (IS_DIR_SEPARATOR (*q) ? '_' : *q);
5086 }
5087 break;
5088
5089 case 'R':
5090 /* We assume there is a directory
5091 separator at the end of this string. */
5092 if (target_system_root)
5093 {
5094 obstack_grow (&obstack, target_system_root,
5095 strlen (target_system_root));
5096 if (target_sysroot_suffix)
5097 obstack_grow (&obstack, target_sysroot_suffix,
5098 strlen (target_sysroot_suffix));
5099 }
5100 break;
5101
5102 case 'S':
5103 value = do_spec_1 (startfile_spec, 0, NULL);
5104 if (value != 0)
5105 return value;
5106 break;
5107
5108 /* Here we define characters other than letters and digits. */
5109
5110 case '{':
5111 p = handle_braces (p);
5112 if (p == 0)
5113 return -1;
5114 break;
5115
5116 case ':':
5117 p = handle_spec_function (p);
5118 if (p == 0)
5119 return -1;
5120 break;
5121
5122 case '%':
5123 obstack_1grow (&obstack, '%');
5124 break;
5125
5126 case '.':
5127 {
5128 unsigned len = 0;
5129
5130 while (p[len] && p[len] != ' ' && p[len] != '%')
5131 len++;
5132 suffix_subst = save_string (p - 1, len + 1);
5133 p += len;
5134 }
5135 break;
5136
5137 /* Henceforth ignore the option(s) matching the pattern
5138 after the %<. */
5139 case '<':
5140 {
5141 unsigned len = 0;
5142 int have_wildcard = 0;
5143 int i;
5144
5145 while (p[len] && p[len] != ' ' && p[len] != '\t')
5146 len++;
5147
5148 if (p[len-1] == '*')
5149 have_wildcard = 1;
5150
5151 for (i = 0; i < n_switches; i++)
5152 if (!strncmp (switches[i].part1, p, len - have_wildcard)
5153 && (have_wildcard || switches[i].part1[len] == '\0'))
5154 {
5155 switches[i].live_cond = SWITCH_IGNORE;
5156 switches[i].validated = 1;
5157 }
5158
5159 p += len;
5160 }
5161 break;
5162
5163 case '*':
5164 if (soft_matched_part)
5165 {
5166 do_spec_1 (soft_matched_part, 1, NULL);
5167 do_spec_1 (" ", 0, NULL);
5168 }
5169 else
5170 /* Catch the case where a spec string contains something like
5171 '%{foo:%*}'. ie there is no * in the pattern on the left
5172 hand side of the :. */
5173 error ("spec failure: '%%*' has not been initialized by pattern match");
5174 break;
5175
5176 /* Process a string found as the value of a spec given by name.
5177 This feature allows individual machine descriptions
5178 to add and use their own specs.
5179 %[...] modifies -D options the way %P does;
5180 %(...) uses the spec unmodified. */
5181 case '[':
5182 error ("warning: use of obsolete %%[ operator in specs");
5183 case '(':
5184 {
5185 const char *name = p;
5186 struct spec_list *sl;
5187 int len;
5188
5189 /* The string after the S/P is the name of a spec that is to be
5190 processed. */
5191 while (*p && *p != ')' && *p != ']')
5192 p++;
5193
5194 /* See if it's in the list. */
5195 for (len = p - name, sl = specs; sl; sl = sl->next)
5196 if (sl->name_len == len && !strncmp (sl->name, name, len))
5197 {
5198 name = *(sl->ptr_spec);
5199 #ifdef DEBUG_SPECS
5200 notice ("Processing spec %c%s%c, which is '%s'\n",
5201 c, sl->name, (c == '(') ? ')' : ']', name);
5202 #endif
5203 break;
5204 }
5205
5206 if (sl)
5207 {
5208 if (c == '(')
5209 {
5210 value = do_spec_1 (name, 0, NULL);
5211 if (value != 0)
5212 return value;
5213 }
5214 else
5215 {
5216 char *x = alloca (strlen (name) * 2 + 1);
5217 char *buf = x;
5218 const char *y = name;
5219 int flag = 0;
5220
5221 /* Copy all of NAME into BUF, but put __ after
5222 every -D and at the end of each arg. */
5223 while (1)
5224 {
5225 if (! strncmp (y, "-D", 2))
5226 {
5227 *x++ = '-';
5228 *x++ = 'D';
5229 *x++ = '_';
5230 *x++ = '_';
5231 y += 2;
5232 flag = 1;
5233 continue;
5234 }
5235 else if (flag
5236 && (*y == ' ' || *y == '\t' || *y == '='
5237 || *y == '}' || *y == 0))
5238 {
5239 *x++ = '_';
5240 *x++ = '_';
5241 flag = 0;
5242 }
5243 if (*y == 0)
5244 break;
5245 else
5246 *x++ = *y++;
5247 }
5248 *x = 0;
5249
5250 value = do_spec_1 (buf, 0, NULL);
5251 if (value != 0)
5252 return value;
5253 }
5254 }
5255
5256 /* Discard the closing paren or bracket. */
5257 if (*p)
5258 p++;
5259 }
5260 break;
5261
5262 default:
5263 error ("spec failure: unrecognized spec option '%c'", c);
5264 break;
5265 }
5266 break;
5267
5268 case '\\':
5269 /* Backslash: treat next character as ordinary. */
5270 c = *p++;
5271
5272 /* Fall through. */
5273 default:
5274 /* Ordinary character: put it into the current argument. */
5275 obstack_1grow (&obstack, c);
5276 arg_going = 1;
5277 }
5278
5279 /* End of string. If we are processing a spec function, we need to
5280 end any pending argument. */
5281 if (processing_spec_function && arg_going)
5282 {
5283 obstack_1grow (&obstack, 0);
5284 string = obstack_finish (&obstack);
5285 if (this_is_library_file)
5286 string = find_file (string);
5287 store_arg (string, delete_this_arg, this_is_output_file);
5288 if (this_is_output_file)
5289 outfiles[input_file_number] = string;
5290 arg_going = 0;
5291 }
5292
5293 return 0;
5294 }
5295
5296 /* Look up a spec function. */
5297
5298 static const struct spec_function *
5299 lookup_spec_function (const char *name)
5300 {
5301 static const struct spec_function * const spec_function_tables[] =
5302 {
5303 static_spec_functions,
5304 lang_specific_spec_functions,
5305 };
5306 const struct spec_function *sf;
5307 unsigned int i;
5308
5309 for (i = 0; i < ARRAY_SIZE (spec_function_tables); i++)
5310 {
5311 for (sf = spec_function_tables[i]; sf->name != NULL; sf++)
5312 if (strcmp (sf->name, name) == 0)
5313 return sf;
5314 }
5315
5316 return NULL;
5317 }
5318
5319 /* Evaluate a spec function. */
5320
5321 static const char *
5322 eval_spec_function (const char *func, const char *args)
5323 {
5324 const struct spec_function *sf;
5325 const char *funcval;
5326
5327 /* Saved spec processing context. */
5328 int save_argbuf_index;
5329 int save_argbuf_length;
5330 const char **save_argbuf;
5331
5332 int save_arg_going;
5333 int save_delete_this_arg;
5334 int save_this_is_output_file;
5335 int save_this_is_library_file;
5336 int save_input_from_pipe;
5337 const char *save_suffix_subst;
5338
5339
5340 sf = lookup_spec_function (func);
5341 if (sf == NULL)
5342 fatal ("unknown spec function `%s'", func);
5343
5344 /* Push the spec processing context. */
5345 save_argbuf_index = argbuf_index;
5346 save_argbuf_length = argbuf_length;
5347 save_argbuf = argbuf;
5348
5349 save_arg_going = arg_going;
5350 save_delete_this_arg = delete_this_arg;
5351 save_this_is_output_file = this_is_output_file;
5352 save_this_is_library_file = this_is_library_file;
5353 save_input_from_pipe = input_from_pipe;
5354 save_suffix_subst = suffix_subst;
5355
5356 /* Create a new spec processing context, and build the function
5357 arguments. */
5358
5359 alloc_args ();
5360 if (do_spec_2 (args) < 0)
5361 fatal ("error in args to spec function `%s'", func);
5362
5363 /* argbuf_index is an index for the next argument to be inserted, and
5364 so contains the count of the args already inserted. */
5365
5366 funcval = (*sf->func) (argbuf_index, argbuf);
5367
5368 /* Pop the spec processing context. */
5369 argbuf_index = save_argbuf_index;
5370 argbuf_length = save_argbuf_length;
5371 free (argbuf);
5372 argbuf = save_argbuf;
5373
5374 arg_going = save_arg_going;
5375 delete_this_arg = save_delete_this_arg;
5376 this_is_output_file = save_this_is_output_file;
5377 this_is_library_file = save_this_is_library_file;
5378 input_from_pipe = save_input_from_pipe;
5379 suffix_subst = save_suffix_subst;
5380
5381 return funcval;
5382 }
5383
5384 /* Handle a spec function call of the form:
5385
5386 %:function(args)
5387
5388 ARGS is processed as a spec in a separate context and split into an
5389 argument vector in the normal fashion. The function returns a string
5390 containing a spec which we then process in the caller's context, or
5391 NULL if no processing is required. */
5392
5393 static const char *
5394 handle_spec_function (const char *p)
5395 {
5396 char *func, *args;
5397 const char *endp, *funcval;
5398 int count;
5399
5400 processing_spec_function++;
5401
5402 /* Get the function name. */
5403 for (endp = p; *endp != '\0'; endp++)
5404 {
5405 if (*endp == '(') /* ) */
5406 break;
5407 /* Only allow [A-Za-z0-9], -, and _ in function names. */
5408 if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_'))
5409 fatal ("malformed spec function name");
5410 }
5411 if (*endp != '(') /* ) */
5412 fatal ("no arguments for spec function");
5413 func = save_string (p, endp - p);
5414 p = ++endp;
5415
5416 /* Get the arguments. */
5417 for (count = 0; *endp != '\0'; endp++)
5418 {
5419 /* ( */
5420 if (*endp == ')')
5421 {
5422 if (count == 0)
5423 break;
5424 count--;
5425 }
5426 else if (*endp == '(') /* ) */
5427 count++;
5428 }
5429 /* ( */
5430 if (*endp != ')')
5431 fatal ("malformed spec function arguments");
5432 args = save_string (p, endp - p);
5433 p = ++endp;
5434
5435 /* p now points to just past the end of the spec function expression. */
5436
5437 funcval = eval_spec_function (func, args);
5438 if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0)
5439 p = NULL;
5440
5441 free (func);
5442 free (args);
5443
5444 processing_spec_function--;
5445
5446 return p;
5447 }
5448
5449 /* Inline subroutine of handle_braces. Returns true if the current
5450 input suffix matches the atom bracketed by ATOM and END_ATOM. */
5451 static inline bool
5452 input_suffix_matches (const char *atom, const char *end_atom)
5453 {
5454 return (input_suffix
5455 && !strncmp (input_suffix, atom, end_atom - atom)
5456 && input_suffix[end_atom - atom] == '\0');
5457 }
5458
5459 /* Inline subroutine of handle_braces. Returns true if a switch
5460 matching the atom bracketed by ATOM and END_ATOM appeared on the
5461 command line. */
5462 static inline bool
5463 switch_matches (const char *atom, const char *end_atom, int starred)
5464 {
5465 int i;
5466 int len = end_atom - atom;
5467 int plen = starred ? len : -1;
5468
5469 for (i = 0; i < n_switches; i++)
5470 if (!strncmp (switches[i].part1, atom, len)
5471 && (starred || switches[i].part1[len] == '\0')
5472 && check_live_switch (i, plen))
5473 return true;
5474
5475 return false;
5476 }
5477
5478 /* Inline subroutine of handle_braces. Mark all of the switches which
5479 match ATOM (extends to END_ATOM; STARRED indicates whether there
5480 was a star after the atom) for later processing. */
5481 static inline void
5482 mark_matching_switches (const char *atom, const char *end_atom, int starred)
5483 {
5484 int i;
5485 int len = end_atom - atom;
5486 int plen = starred ? len : -1;
5487
5488 for (i = 0; i < n_switches; i++)
5489 if (!strncmp (switches[i].part1, atom, len)
5490 && (starred || switches[i].part1[len] == '\0')
5491 && check_live_switch (i, plen))
5492 switches[i].ordering = 1;
5493 }
5494
5495 /* Inline subroutine of handle_braces. Process all the currently
5496 marked switches through give_switch, and clear the marks. */
5497 static inline void
5498 process_marked_switches (void)
5499 {
5500 int i;
5501
5502 for (i = 0; i < n_switches; i++)
5503 if (switches[i].ordering == 1)
5504 {
5505 switches[i].ordering = 0;
5506 give_switch (i, 0);
5507 }
5508 }
5509
5510 /* Handle a %{ ... } construct. P points just inside the leading {.
5511 Returns a pointer one past the end of the brace block, or 0
5512 if we call do_spec_1 and that returns -1. */
5513
5514 static const char *
5515 handle_braces (const char *p)
5516 {
5517 const char *atom, *end_atom;
5518 const char *d_atom = NULL, *d_end_atom = NULL;
5519
5520 bool a_is_suffix;
5521 bool a_is_starred;
5522 bool a_is_negated;
5523 bool a_matched;
5524
5525 bool a_must_be_last = false;
5526 bool ordered_set = false;
5527 bool disjunct_set = false;
5528 bool disj_matched = false;
5529 bool disj_starred = true;
5530 bool n_way_choice = false;
5531 bool n_way_matched = false;
5532
5533 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
5534
5535 do
5536 {
5537 if (a_must_be_last)
5538 abort ();
5539
5540 /* Scan one "atom" (S in the description above of %{}, possibly
5541 with !, ., or * modifiers). */
5542 a_matched = a_is_suffix = a_is_starred = a_is_negated = false;
5543
5544 SKIP_WHITE();
5545 if (*p == '!')
5546 p++, a_is_negated = true;
5547
5548 SKIP_WHITE();
5549 if (*p == '.')
5550 p++, a_is_suffix = true;
5551
5552 atom = p;
5553 while (ISIDNUM(*p) || *p == '-' || *p == '+' || *p == '='
5554 || *p == ',' || *p == '.' || *p == '@')
5555 p++;
5556 end_atom = p;
5557
5558 if (*p == '*')
5559 p++, a_is_starred = 1;
5560
5561 SKIP_WHITE();
5562 if (*p == '&' || *p == '}')
5563 {
5564 /* Substitute the switch(es) indicated by the current atom. */
5565 ordered_set = true;
5566 if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix
5567 || atom == end_atom)
5568 abort ();
5569
5570 mark_matching_switches (atom, end_atom, a_is_starred);
5571
5572 if (*p == '}')
5573 process_marked_switches ();
5574 }
5575 else if (*p == '|' || *p == ':')
5576 {
5577 /* Substitute some text if the current atom appears as a switch
5578 or suffix. */
5579 disjunct_set = true;
5580 if (ordered_set)
5581 abort ();
5582
5583 if (atom == end_atom)
5584 {
5585 if (!n_way_choice || disj_matched || *p == '|'
5586 || a_is_negated || a_is_suffix || a_is_starred)
5587 abort ();
5588
5589 /* An empty term may appear as the last choice of an
5590 N-way choice set; it means "otherwise". */
5591 a_must_be_last = true;
5592 disj_matched = !n_way_matched;
5593 disj_starred = false;
5594 }
5595 else
5596 {
5597 if (a_is_suffix && a_is_starred)
5598 abort ();
5599
5600 if (!a_is_starred)
5601 disj_starred = false;
5602
5603 /* Don't bother testing this atom if we already have a
5604 match. */
5605 if (!disj_matched && !n_way_matched)
5606 {
5607 if (a_is_suffix)
5608 a_matched = input_suffix_matches (atom, end_atom);
5609 else
5610 a_matched = switch_matches (atom, end_atom, a_is_starred);
5611
5612 if (a_matched != a_is_negated)
5613 {
5614 disj_matched = true;
5615 d_atom = atom;
5616 d_end_atom = end_atom;
5617 }
5618 }
5619 }
5620
5621 if (*p == ':')
5622 {
5623 /* Found the body, that is, the text to substitute if the
5624 current disjunction matches. */
5625 p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred,
5626 disj_matched && !n_way_matched);
5627 if (p == 0)
5628 return 0;
5629
5630 /* If we have an N-way choice, reset state for the next
5631 disjunction. */
5632 if (*p == ';')
5633 {
5634 n_way_choice = true;
5635 n_way_matched |= disj_matched;
5636 disj_matched = false;
5637 disj_starred = true;
5638 d_atom = d_end_atom = NULL;
5639 }
5640 }
5641 }
5642 else
5643 abort ();
5644 }
5645 while (*p++ != '}');
5646
5647 return p;
5648
5649 #undef SKIP_WHITE
5650 }
5651
5652 /* Subroutine of handle_braces. Scan and process a brace substitution body
5653 (X in the description of %{} syntax). P points one past the colon;
5654 ATOM and END_ATOM bracket the first atom which was found to be true
5655 (present) in the current disjunction; STARRED indicates whether all
5656 the atoms in the current disjunction were starred (for syntax validation);
5657 MATCHED indicates whether the disjunction matched or not, and therefore
5658 whether or not the body is to be processed through do_spec_1 or just
5659 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
5660 returns -1. */
5661
5662 static const char *
5663 process_brace_body (const char *p, const char *atom, const char *end_atom,
5664 int starred, int matched)
5665 {
5666 const char *body, *end_body;
5667 unsigned int nesting_level;
5668 bool have_subst = false;
5669
5670 /* Locate the closing } or ;, honoring nested braces.
5671 Trim trailing whitespace. */
5672 body = p;
5673 nesting_level = 1;
5674 for (;;)
5675 {
5676 if (*p == '{')
5677 nesting_level++;
5678 else if (*p == '}')
5679 {
5680 if (!--nesting_level)
5681 break;
5682 }
5683 else if (*p == ';' && nesting_level == 1)
5684 break;
5685 else if (*p == '%' && p[1] == '*' && nesting_level == 1)
5686 have_subst = true;
5687 else if (*p == '\0')
5688 abort ();
5689 p++;
5690 }
5691
5692 end_body = p;
5693 while (end_body[-1] == ' ' || end_body[-1] == '\t')
5694 end_body--;
5695
5696 if (have_subst && !starred)
5697 abort ();
5698
5699 if (matched)
5700 {
5701 /* Copy the substitution body to permanent storage and execute it.
5702 If have_subst is false, this is a simple matter of running the
5703 body through do_spec_1... */
5704 char *string = save_string (body, end_body - body);
5705 if (!have_subst)
5706 {
5707 if (do_spec_1 (string, 0, NULL) < 0)
5708 return 0;
5709 }
5710 else
5711 {
5712 /* ... but if have_subst is true, we have to process the
5713 body once for each matching switch, with %* set to the
5714 variant part of the switch. */
5715 unsigned int hard_match_len = end_atom - atom;
5716 int i;
5717
5718 for (i = 0; i < n_switches; i++)
5719 if (!strncmp (switches[i].part1, atom, hard_match_len)
5720 && check_live_switch (i, hard_match_len))
5721 {
5722 if (do_spec_1 (string, 0,
5723 &switches[i].part1[hard_match_len]) < 0)
5724 return 0;
5725 /* Pass any arguments this switch has. */
5726 give_switch (i, 1);
5727 suffix_subst = NULL;
5728 }
5729 }
5730 }
5731
5732 return p;
5733 }
5734 \f
5735 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
5736 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
5737 spec, or -1 if either exact match or %* is used.
5738
5739 A -O switch is obsoleted by a later -O switch. A -f, -m, or -W switch
5740 whose value does not begin with "no-" is obsoleted by the same value
5741 with the "no-", similarly for a switch with the "no-" prefix. */
5742
5743 static int
5744 check_live_switch (int switchnum, int prefix_length)
5745 {
5746 const char *name = switches[switchnum].part1;
5747 int i;
5748
5749 /* In the common case of {<at-most-one-letter>*}, a negating
5750 switch would always match, so ignore that case. We will just
5751 send the conflicting switches to the compiler phase. */
5752 if (prefix_length >= 0 && prefix_length <= 1)
5753 return 1;
5754
5755 /* If we already processed this switch and determined if it was
5756 live or not, return our past determination. */
5757 if (switches[switchnum].live_cond != 0)
5758 return switches[switchnum].live_cond > 0;
5759
5760 /* Now search for duplicate in a manner that depends on the name. */
5761 switch (*name)
5762 {
5763 case 'O':
5764 for (i = switchnum + 1; i < n_switches; i++)
5765 if (switches[i].part1[0] == 'O')
5766 {
5767 switches[switchnum].validated = 1;
5768 switches[switchnum].live_cond = SWITCH_FALSE;
5769 return 0;
5770 }
5771 break;
5772
5773 case 'W': case 'f': case 'm':
5774 if (! strncmp (name + 1, "no-", 3))
5775 {
5776 /* We have Xno-YYY, search for XYYY. */
5777 for (i = switchnum + 1; i < n_switches; i++)
5778 if (switches[i].part1[0] == name[0]
5779 && ! strcmp (&switches[i].part1[1], &name[4]))
5780 {
5781 switches[switchnum].validated = 1;
5782 switches[switchnum].live_cond = SWITCH_FALSE;
5783 return 0;
5784 }
5785 }
5786 else
5787 {
5788 /* We have XYYY, search for Xno-YYY. */
5789 for (i = switchnum + 1; i < n_switches; i++)
5790 if (switches[i].part1[0] == name[0]
5791 && switches[i].part1[1] == 'n'
5792 && switches[i].part1[2] == 'o'
5793 && switches[i].part1[3] == '-'
5794 && !strcmp (&switches[i].part1[4], &name[1]))
5795 {
5796 switches[switchnum].validated = 1;
5797 switches[switchnum].live_cond = SWITCH_FALSE;
5798 return 0;
5799 }
5800 }
5801 break;
5802 }
5803
5804 /* Otherwise the switch is live. */
5805 switches[switchnum].live_cond = SWITCH_LIVE;
5806 return 1;
5807 }
5808 \f
5809 /* Pass a switch to the current accumulating command
5810 in the same form that we received it.
5811 SWITCHNUM identifies the switch; it is an index into
5812 the vector of switches gcc received, which is `switches'.
5813 This cannot fail since it never finishes a command line.
5814
5815 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
5816
5817 static void
5818 give_switch (int switchnum, int omit_first_word)
5819 {
5820 if (switches[switchnum].live_cond == SWITCH_IGNORE)
5821 return;
5822
5823 if (!omit_first_word)
5824 {
5825 do_spec_1 ("-", 0, NULL);
5826 do_spec_1 (switches[switchnum].part1, 1, NULL);
5827 }
5828
5829 if (switches[switchnum].args != 0)
5830 {
5831 const char **p;
5832 for (p = switches[switchnum].args; *p; p++)
5833 {
5834 const char *arg = *p;
5835
5836 do_spec_1 (" ", 0, NULL);
5837 if (suffix_subst)
5838 {
5839 unsigned length = strlen (arg);
5840 int dot = 0;
5841
5842 while (length-- && !IS_DIR_SEPARATOR (arg[length]))
5843 if (arg[length] == '.')
5844 {
5845 ((char *)arg)[length] = 0;
5846 dot = 1;
5847 break;
5848 }
5849 do_spec_1 (arg, 1, NULL);
5850 if (dot)
5851 ((char *)arg)[length] = '.';
5852 do_spec_1 (suffix_subst, 1, NULL);
5853 }
5854 else
5855 do_spec_1 (arg, 1, NULL);
5856 }
5857 }
5858
5859 do_spec_1 (" ", 0, NULL);
5860 switches[switchnum].validated = 1;
5861 }
5862 \f
5863 /* Search for a file named NAME trying various prefixes including the
5864 user's -B prefix and some standard ones.
5865 Return the absolute file name found. If nothing is found, return NAME. */
5866
5867 static const char *
5868 find_file (const char *name)
5869 {
5870 char *newname;
5871
5872 /* Try multilib_dir if it is defined. */
5873 if (multilib_os_dir != NULL)
5874 {
5875 newname = find_a_file (&startfile_prefixes, name, R_OK, 1);
5876
5877 /* If we don't find it in the multi library dir, then fall
5878 through and look for it in the normal places. */
5879 if (newname != NULL)
5880 return newname;
5881 }
5882
5883 newname = find_a_file (&startfile_prefixes, name, R_OK, 0);
5884 return newname ? newname : name;
5885 }
5886
5887 /* Determine whether a directory exists. If LINKER, return 0 for
5888 certain fixed names not needed by the linker. If not LINKER, it is
5889 only important to return 0 if the host machine has a small ARG_MAX
5890 limit. */
5891
5892 static int
5893 is_directory (const char *path1, const char *path2, int linker)
5894 {
5895 int len1 = strlen (path1);
5896 int len2 = strlen (path2);
5897 char *path = alloca (3 + len1 + len2);
5898 char *cp;
5899 struct stat st;
5900
5901 #ifndef SMALL_ARG_MAX
5902 if (! linker)
5903 return 1;
5904 #endif
5905
5906 /* Construct the path from the two parts. Ensure the string ends with "/.".
5907 The resulting path will be a directory even if the given path is a
5908 symbolic link. */
5909 memcpy (path, path1, len1);
5910 memcpy (path + len1, path2, len2);
5911 cp = path + len1 + len2;
5912 if (!IS_DIR_SEPARATOR (cp[-1]))
5913 *cp++ = DIR_SEPARATOR;
5914 *cp++ = '.';
5915 *cp = '\0';
5916
5917 /* Exclude directories that the linker is known to search. */
5918 if (linker
5919 && ((cp - path == 6
5920 && strcmp (path, concat (dir_separator_str, "lib",
5921 dir_separator_str, ".", NULL)) == 0)
5922 || (cp - path == 10
5923 && strcmp (path, concat (dir_separator_str, "usr",
5924 dir_separator_str, "lib",
5925 dir_separator_str, ".", NULL)) == 0)))
5926 return 0;
5927
5928 return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
5929 }
5930
5931 /* Set up the various global variables to indicate that we're processing
5932 the input file named FILENAME. */
5933
5934 void
5935 set_input (const char *filename)
5936 {
5937 const char *p;
5938
5939 input_filename = filename;
5940 input_filename_length = strlen (input_filename);
5941
5942 input_basename = input_filename;
5943 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
5944 /* Skip drive name so 'x:foo' is handled properly. */
5945 if (input_basename[1] == ':')
5946 input_basename += 2;
5947 #endif
5948 for (p = input_basename; *p; p++)
5949 if (IS_DIR_SEPARATOR (*p))
5950 input_basename = p + 1;
5951
5952 /* Find a suffix starting with the last period,
5953 and set basename_length to exclude that suffix. */
5954 basename_length = strlen (input_basename);
5955 suffixed_basename_length = basename_length;
5956 p = input_basename + basename_length;
5957 while (p != input_basename && *p != '.')
5958 --p;
5959 if (*p == '.' && p != input_basename)
5960 {
5961 basename_length = p - input_basename;
5962 input_suffix = p + 1;
5963 }
5964 else
5965 input_suffix = "";
5966
5967 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
5968 we will need to do a stat on the input_filename. The
5969 INPUT_STAT_SET signals that the stat is needed. */
5970 input_stat_set = 0;
5971 }
5972 \f
5973 /* On fatal signals, delete all the temporary files. */
5974
5975 static void
5976 fatal_error (int signum)
5977 {
5978 signal (signum, SIG_DFL);
5979 delete_failure_queue ();
5980 delete_temp_files ();
5981 /* Get the same signal again, this time not handled,
5982 so its normal effect occurs. */
5983 kill (getpid (), signum);
5984 }
5985
5986 extern int main (int, const char **);
5987
5988 int
5989 main (int argc, const char **argv)
5990 {
5991 size_t i;
5992 int value;
5993 int linker_was_run = 0;
5994 int lang_n_infiles = 0;
5995 int num_linker_inputs = 0;
5996 char *explicit_link_files;
5997 char *specs_file;
5998 const char *p;
5999 struct user_specs *uptr;
6000
6001 p = argv[0] + strlen (argv[0]);
6002 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
6003 --p;
6004 programname = p;
6005
6006 xmalloc_set_program_name (programname);
6007
6008 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6009 /* Perform host dependent initialization when needed. */
6010 GCC_DRIVER_HOST_INITIALIZATION;
6011 #endif
6012
6013 gcc_init_libintl ();
6014
6015 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
6016 signal (SIGINT, fatal_error);
6017 #ifdef SIGHUP
6018 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
6019 signal (SIGHUP, fatal_error);
6020 #endif
6021 if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
6022 signal (SIGTERM, fatal_error);
6023 #ifdef SIGPIPE
6024 if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
6025 signal (SIGPIPE, fatal_error);
6026 #endif
6027 #ifdef SIGCHLD
6028 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6029 receive the signal. A different setting is inheritable */
6030 signal (SIGCHLD, SIG_DFL);
6031 #endif
6032
6033 /* Allocate the argument vector. */
6034 alloc_args ();
6035
6036 obstack_init (&obstack);
6037
6038 /* Build multilib_select, et. al from the separate lines that make up each
6039 multilib selection. */
6040 {
6041 const char *const *q = multilib_raw;
6042 int need_space;
6043
6044 obstack_init (&multilib_obstack);
6045 while ((p = *q++) != (char *) 0)
6046 obstack_grow (&multilib_obstack, p, strlen (p));
6047
6048 obstack_1grow (&multilib_obstack, 0);
6049 multilib_select = obstack_finish (&multilib_obstack);
6050
6051 q = multilib_matches_raw;
6052 while ((p = *q++) != (char *) 0)
6053 obstack_grow (&multilib_obstack, p, strlen (p));
6054
6055 obstack_1grow (&multilib_obstack, 0);
6056 multilib_matches = obstack_finish (&multilib_obstack);
6057
6058 q = multilib_exclusions_raw;
6059 while ((p = *q++) != (char *) 0)
6060 obstack_grow (&multilib_obstack, p, strlen (p));
6061
6062 obstack_1grow (&multilib_obstack, 0);
6063 multilib_exclusions = obstack_finish (&multilib_obstack);
6064
6065 need_space = FALSE;
6066 for (i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++)
6067 {
6068 if (need_space)
6069 obstack_1grow (&multilib_obstack, ' ');
6070 obstack_grow (&multilib_obstack,
6071 multilib_defaults_raw[i],
6072 strlen (multilib_defaults_raw[i]));
6073 need_space = TRUE;
6074 }
6075
6076 obstack_1grow (&multilib_obstack, 0);
6077 multilib_defaults = obstack_finish (&multilib_obstack);
6078 }
6079
6080 /* Set up to remember the pathname of gcc and any options
6081 needed for collect. We use argv[0] instead of programname because
6082 we need the complete pathname. */
6083 obstack_init (&collect_obstack);
6084 obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
6085 obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1);
6086 putenv (obstack_finish (&collect_obstack));
6087
6088 #ifdef INIT_ENVIRONMENT
6089 /* Set up any other necessary machine specific environment variables. */
6090 putenv (INIT_ENVIRONMENT);
6091 #endif
6092
6093 /* Make a table of what switches there are (switches, n_switches).
6094 Make a table of specified input files (infiles, n_infiles).
6095 Decode switches that are handled locally. */
6096
6097 process_command (argc, argv);
6098
6099 /* Initialize the vector of specs to just the default.
6100 This means one element containing 0s, as a terminator. */
6101
6102 compilers = xmalloc (sizeof default_compilers);
6103 memcpy (compilers, default_compilers, sizeof default_compilers);
6104 n_compilers = n_default_compilers;
6105
6106 /* Read specs from a file if there is one. */
6107
6108 machine_suffix = concat (spec_machine, dir_separator_str,
6109 spec_version, dir_separator_str, NULL);
6110 just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
6111
6112 specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, 0);
6113 /* Read the specs file unless it is a default one. */
6114 if (specs_file != 0 && strcmp (specs_file, "specs"))
6115 read_specs (specs_file, TRUE);
6116 else
6117 init_spec ();
6118
6119 /* We need to check standard_exec_prefix/just_machine_suffix/specs
6120 for any override of as, ld and libraries. */
6121 specs_file = alloca (strlen (standard_exec_prefix)
6122 + strlen (just_machine_suffix) + sizeof ("specs"));
6123
6124 strcpy (specs_file, standard_exec_prefix);
6125 strcat (specs_file, just_machine_suffix);
6126 strcat (specs_file, "specs");
6127 if (access (specs_file, R_OK) == 0)
6128 read_specs (specs_file, TRUE);
6129
6130 /* Process any configure-time defaults specified for the command line
6131 options, via OPTION_DEFAULT_SPECS. */
6132 for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
6133 do_option_spec (option_default_specs[i].name,
6134 option_default_specs[i].spec);
6135
6136 /* Process DRIVER_SELF_SPECS, adding any new options to the end
6137 of the command line. */
6138
6139 for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++)
6140 do_self_spec (driver_self_specs[i]);
6141
6142 /* If not cross-compiling, look for executables in the standard
6143 places. */
6144 if (*cross_compile == '0')
6145 {
6146 if (*md_exec_prefix)
6147 {
6148 add_prefix (&exec_prefixes, md_exec_prefix, "GCC",
6149 PREFIX_PRIORITY_LAST, 0, NULL, 0);
6150 }
6151 }
6152
6153 /* Process sysroot_suffix_spec. */
6154 if (*sysroot_suffix_spec != 0
6155 && do_spec_2 (sysroot_suffix_spec) == 0)
6156 {
6157 if (argbuf_index > 1)
6158 error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC.");
6159 else if (argbuf_index == 1)
6160 target_sysroot_suffix = xstrdup (argbuf[argbuf_index -1]);
6161 }
6162
6163 /* Process sysroot_hdrs_suffix_spec. */
6164 if (*sysroot_hdrs_suffix_spec != 0
6165 && do_spec_2 (sysroot_hdrs_suffix_spec) == 0)
6166 {
6167 if (argbuf_index > 1)
6168 error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC.");
6169 else if (argbuf_index == 1)
6170 target_sysroot_hdrs_suffix = xstrdup (argbuf[argbuf_index -1]);
6171 }
6172
6173 /* Look for startfiles in the standard places. */
6174 if (*startfile_prefix_spec != 0
6175 && do_spec_2 (startfile_prefix_spec) == 0
6176 && do_spec_1 (" ", 0, NULL) == 0)
6177 {
6178 int ndx;
6179 for (ndx = 0; ndx < argbuf_index; ndx++)
6180 add_sysrooted_prefix (&startfile_prefixes, argbuf[ndx], "BINUTILS",
6181 PREFIX_PRIORITY_LAST, 0, NULL, 1);
6182 }
6183 /* We should eventually get rid of all these and stick to
6184 startfile_prefix_spec exclusively. */
6185 else if (*cross_compile == '0' || target_system_root)
6186 {
6187 if (*md_exec_prefix)
6188 add_sysrooted_prefix (&startfile_prefixes, md_exec_prefix, "GCC",
6189 PREFIX_PRIORITY_LAST, 0, NULL, 1);
6190
6191 if (*md_startfile_prefix)
6192 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix,
6193 "GCC", PREFIX_PRIORITY_LAST, 0, NULL, 1);
6194
6195 if (*md_startfile_prefix_1)
6196 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix_1,
6197 "GCC", PREFIX_PRIORITY_LAST, 0, NULL, 1);
6198
6199 /* If standard_startfile_prefix is relative, base it on
6200 standard_exec_prefix. This lets us move the installed tree
6201 as a unit. If GCC_EXEC_PREFIX is defined, base
6202 standard_startfile_prefix on that as well.
6203
6204 If the prefix is relative, only search it for native compilers;
6205 otherwise we will search a directory containing host libraries. */
6206 if (IS_ABSOLUTE_PATH (standard_startfile_prefix))
6207 add_sysrooted_prefix (&startfile_prefixes,
6208 standard_startfile_prefix, "BINUTILS",
6209 PREFIX_PRIORITY_LAST, 0, NULL, 1);
6210 else if (*cross_compile == '0')
6211 {
6212 if (gcc_exec_prefix)
6213 add_prefix (&startfile_prefixes,
6214 concat (gcc_exec_prefix, machine_suffix,
6215 standard_startfile_prefix, NULL),
6216 NULL, PREFIX_PRIORITY_LAST, 0, NULL, 1);
6217 add_prefix (&startfile_prefixes,
6218 concat (standard_exec_prefix,
6219 machine_suffix,
6220 standard_startfile_prefix, NULL),
6221 NULL, PREFIX_PRIORITY_LAST, 0, NULL, 1);
6222 }
6223
6224 add_sysrooted_prefix (&startfile_prefixes, standard_startfile_prefix_1,
6225 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL, 1);
6226 add_sysrooted_prefix (&startfile_prefixes, standard_startfile_prefix_2,
6227 "BINUTILS", PREFIX_PRIORITY_LAST, 0, NULL, 1);
6228 #if 0 /* Can cause surprises, and one can use -B./ instead. */
6229 add_prefix (&startfile_prefixes, "./", NULL,
6230 PREFIX_PRIORITY_LAST, 1, NULL, 0);
6231 #endif
6232 }
6233
6234 /* Process any user specified specs in the order given on the command
6235 line. */
6236 for (uptr = user_specs_head; uptr; uptr = uptr->next)
6237 {
6238 char *filename = find_a_file (&startfile_prefixes, uptr->filename,
6239 R_OK, 0);
6240 read_specs (filename ? filename : uptr->filename, FALSE);
6241 }
6242
6243 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
6244 if (gcc_exec_prefix)
6245 gcc_exec_prefix = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
6246 spec_version, dir_separator_str, NULL);
6247
6248 /* Now we have the specs.
6249 Set the `valid' bits for switches that match anything in any spec. */
6250
6251 validate_all_switches ();
6252
6253 /* Now that we have the switches and the specs, set
6254 the subdirectory based on the options. */
6255 set_multilib_dir ();
6256
6257 /* Warn about any switches that no pass was interested in. */
6258
6259 for (i = 0; (int) i < n_switches; i++)
6260 if (! switches[i].validated)
6261 error ("unrecognized option `-%s'", switches[i].part1);
6262
6263 /* Obey some of the options. */
6264
6265 if (print_search_dirs)
6266 {
6267 printf (_("install: %s%s\n"), standard_exec_prefix, machine_suffix);
6268 printf (_("programs: %s\n"), build_search_list (&exec_prefixes, "", 0));
6269 printf (_("libraries: %s\n"), build_search_list (&startfile_prefixes, "", 0));
6270 return (0);
6271 }
6272
6273 if (print_file_name)
6274 {
6275 printf ("%s\n", find_file (print_file_name));
6276 return (0);
6277 }
6278
6279 if (print_prog_name)
6280 {
6281 char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK, 0);
6282 printf ("%s\n", (newname ? newname : print_prog_name));
6283 return (0);
6284 }
6285
6286 if (print_multi_lib)
6287 {
6288 print_multilib_info ();
6289 return (0);
6290 }
6291
6292 if (print_multi_directory)
6293 {
6294 if (multilib_dir == NULL)
6295 printf (".\n");
6296 else
6297 printf ("%s\n", multilib_dir);
6298 return (0);
6299 }
6300
6301 if (print_multi_os_directory)
6302 {
6303 if (multilib_os_dir == NULL)
6304 printf (".\n");
6305 else
6306 printf ("%s\n", multilib_os_dir);
6307 return (0);
6308 }
6309
6310 if (target_help_flag)
6311 {
6312 /* Print if any target specific options. */
6313
6314 /* We do not exit here. Instead we have created a fake input file
6315 called 'target-dummy' which needs to be compiled, and we pass this
6316 on to the various sub-processes, along with the --target-help
6317 switch. */
6318 }
6319
6320 if (print_help_list)
6321 {
6322 display_help ();
6323
6324 if (! verbose_flag)
6325 {
6326 printf (_("\nFor bug reporting instructions, please see:\n"));
6327 printf ("%s.\n", bug_report_url);
6328
6329 return (0);
6330 }
6331
6332 /* We do not exit here. Instead we have created a fake input file
6333 called 'help-dummy' which needs to be compiled, and we pass this
6334 on the various sub-processes, along with the --help switch. */
6335 }
6336
6337 if (verbose_flag)
6338 {
6339 int n;
6340 const char *thrmod;
6341
6342 notice ("Configured with: %s\n", configuration_arguments);
6343
6344 #ifdef THREAD_MODEL_SPEC
6345 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
6346 but there's no point in doing all this processing just to get
6347 thread_model back. */
6348 obstack_init (&obstack);
6349 do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model);
6350 obstack_1grow (&obstack, '\0');
6351 thrmod = obstack_finish (&obstack);
6352 #else
6353 thrmod = thread_model;
6354 #endif
6355
6356 notice ("Thread model: %s\n", thrmod);
6357
6358 /* compiler_version is truncated at the first space when initialized
6359 from version string, so truncate version_string at the first space
6360 before comparing. */
6361 for (n = 0; version_string[n]; n++)
6362 if (version_string[n] == ' ')
6363 break;
6364
6365 if (! strncmp (version_string, compiler_version, n)
6366 && compiler_version[n] == 0)
6367 notice ("gcc version %s\n", version_string);
6368 else
6369 notice ("gcc driver version %s executing gcc version %s\n",
6370 version_string, compiler_version);
6371
6372 if (n_infiles == 0)
6373 return (0);
6374 }
6375
6376 if (n_infiles == added_libraries)
6377 fatal ("no input files");
6378
6379 /* Make a place to record the compiler output file names
6380 that correspond to the input files. */
6381
6382 i = n_infiles;
6383 i += lang_specific_extra_outfiles;
6384 outfiles = xcalloc (i, sizeof (char *));
6385
6386 /* Record which files were specified explicitly as link input. */
6387
6388 explicit_link_files = xcalloc (1, n_infiles);
6389
6390 if (combine_flag)
6391 combine_inputs = true;
6392 else
6393 combine_inputs = false;
6394
6395 for (i = 0; (int) i < n_infiles; i++)
6396 {
6397 const char *name = infiles[i].name;
6398 struct compiler *compiler = lookup_compiler (name,
6399 strlen (name),
6400 infiles[i].language);
6401
6402 if (compiler && !(compiler->combinable))
6403 combine_inputs = false;
6404
6405 if (lang_n_infiles > 0 && compiler != input_file_compiler
6406 && infiles[i].language && infiles[i].language[0] != '*')
6407 infiles[i].incompiler = compiler;
6408 else if (compiler)
6409 {
6410 lang_n_infiles++;
6411 input_file_compiler = compiler;
6412 infiles[i].incompiler = compiler;
6413 }
6414 else
6415 {
6416 /* Since there is no compiler for this input file, assume it is a
6417 linker file. */
6418 explicit_link_files[i] = 1;
6419 infiles[i].incompiler = NULL;
6420 }
6421 infiles[i].compiled = false;
6422 infiles[i].preprocessed = false;
6423 }
6424
6425 if (combine_flag && save_temps_flag)
6426 {
6427 bool save_combine_inputs = combine_inputs;
6428 /* Must do a separate pre-processing pass for C & Objective-C files, to
6429 obtain individual .i files. */
6430
6431 combine_inputs = false;
6432 for (i = 0; (int) i < n_infiles; i++)
6433 {
6434 int this_file_error = 0;
6435
6436 input_file_number = i;
6437 set_input (infiles[i].name);
6438 if (infiles[i].incompiler
6439 && (infiles[i].incompiler)->needs_preprocessing)
6440 input_file_compiler = infiles[i].incompiler;
6441 else
6442 continue;
6443
6444 if (input_file_compiler)
6445 {
6446 if (input_file_compiler->spec[0] == '#')
6447 {
6448 error ("%s: %s compiler not installed on this system",
6449 input_filename, &input_file_compiler->spec[1]);
6450 this_file_error = 1;
6451 }
6452 else
6453 {
6454 value = do_spec (input_file_compiler->spec);
6455 infiles[i].preprocessed = true;
6456 if (have_o_argbuf_index)
6457 infiles[i].name = argbuf[have_o_argbuf_index];
6458 else
6459 abort ();
6460 infiles[i].incompiler = lookup_compiler (infiles[i].name,
6461 strlen (infiles[i].name),
6462 infiles[i].language);
6463
6464 if (value < 0)
6465 this_file_error = 1;
6466 }
6467 }
6468
6469 if (this_file_error)
6470 {
6471 delete_failure_queue ();
6472 error_count++;
6473 break;
6474 }
6475 clear_failure_queue ();
6476 }
6477 combine_inputs = save_combine_inputs;
6478 }
6479
6480 for (i = 0; (int) i < n_infiles; i++)
6481 {
6482 int this_file_error = 0;
6483
6484 /* Tell do_spec what to substitute for %i. */
6485
6486 input_file_number = i;
6487 set_input (infiles[i].name);
6488
6489 if (infiles[i].compiled)
6490 continue;
6491
6492 /* Use the same thing in %o, unless cp->spec says otherwise. */
6493
6494 outfiles[i] = input_filename;
6495
6496 /* Figure out which compiler from the file's suffix. */
6497
6498 if (! combine_inputs)
6499 input_file_compiler
6500 = lookup_compiler (infiles[i].name, input_filename_length,
6501 infiles[i].language);
6502 else
6503 input_file_compiler = infiles[i].incompiler;
6504
6505 if (input_file_compiler)
6506 {
6507 /* Ok, we found an applicable compiler. Run its spec. */
6508
6509 if (input_file_compiler->spec[0] == '#')
6510 {
6511 error ("%s: %s compiler not installed on this system",
6512 input_filename, &input_file_compiler->spec[1]);
6513 this_file_error = 1;
6514 }
6515 else
6516 {
6517 value = do_spec (input_file_compiler->spec);
6518 infiles[i].compiled = true;
6519 if (value < 0)
6520 this_file_error = 1;
6521 }
6522 }
6523
6524 /* If this file's name does not contain a recognized suffix,
6525 record it as explicit linker input. */
6526
6527 else
6528 explicit_link_files[i] = 1;
6529
6530 /* Clear the delete-on-failure queue, deleting the files in it
6531 if this compilation failed. */
6532
6533 if (this_file_error)
6534 {
6535 delete_failure_queue ();
6536 error_count++;
6537 break;
6538 }
6539 /* If this compilation succeeded, don't delete those files later. */
6540 clear_failure_queue ();
6541 }
6542
6543 /* Reset the output file name to the first input file name, for use
6544 with %b in LINK_SPEC on a target that prefers not to emit a.out
6545 by default. */
6546 if (n_infiles > 0)
6547 set_input (infiles[0].name);
6548
6549 if (error_count == 0)
6550 {
6551 /* Make sure INPUT_FILE_NUMBER points to first available open
6552 slot. */
6553 input_file_number = n_infiles;
6554 if (lang_specific_pre_link ())
6555 error_count++;
6556 }
6557
6558 /* Determine if there are any linker input files. */
6559 num_linker_inputs = 0;
6560 for (i = 0; (int) i < n_infiles; i++)
6561 if (explicit_link_files[i] || outfiles[i] != NULL)
6562 num_linker_inputs++;
6563
6564 /* Run ld to link all the compiler output files. */
6565
6566 if (num_linker_inputs > 0 && error_count == 0)
6567 {
6568 int tmp = execution_count;
6569
6570 /* We'll use ld if we can't find collect2. */
6571 if (! strcmp (linker_name_spec, "collect2"))
6572 {
6573 char *s = find_a_file (&exec_prefixes, "collect2", X_OK, 0);
6574 if (s == NULL)
6575 linker_name_spec = "ld";
6576 }
6577 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
6578 for collect. */
6579 putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH");
6580 putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV);
6581
6582 value = do_spec (link_command_spec);
6583 if (value < 0)
6584 error_count = 1;
6585 linker_was_run = (tmp != execution_count);
6586 }
6587
6588 /* If options said don't run linker,
6589 complain about input files to be given to the linker. */
6590
6591 if (! linker_was_run && error_count == 0)
6592 for (i = 0; (int) i < n_infiles; i++)
6593 if (explicit_link_files[i])
6594 error ("%s: linker input file unused because linking not done",
6595 outfiles[i]);
6596
6597 /* Delete some or all of the temporary files we made. */
6598
6599 if (error_count)
6600 delete_failure_queue ();
6601 delete_temp_files ();
6602
6603 if (print_help_list)
6604 {
6605 printf (("\nFor bug reporting instructions, please see:\n"));
6606 printf ("%s\n", bug_report_url);
6607 }
6608
6609 return (signal_count != 0 ? 2
6610 : error_count > 0 ? (pass_exit_codes ? greatest_status : 1)
6611 : 0);
6612 }
6613
6614 /* Find the proper compilation spec for the file name NAME,
6615 whose length is LENGTH. LANGUAGE is the specified language,
6616 or 0 if this file is to be passed to the linker. */
6617
6618 static struct compiler *
6619 lookup_compiler (const char *name, size_t length, const char *language)
6620 {
6621 struct compiler *cp;
6622
6623 /* If this was specified by the user to be a linker input, indicate that. */
6624 if (language != 0 && language[0] == '*')
6625 return 0;
6626
6627 /* Otherwise, look for the language, if one is spec'd. */
6628 if (language != 0)
6629 {
6630 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
6631 if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
6632 return cp;
6633
6634 error ("language %s not recognized", language);
6635 return 0;
6636 }
6637
6638 /* Look for a suffix. */
6639 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
6640 {
6641 if (/* The suffix `-' matches only the file name `-'. */
6642 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
6643 || (strlen (cp->suffix) < length
6644 /* See if the suffix matches the end of NAME. */
6645 && !strcmp (cp->suffix,
6646 name + length - strlen (cp->suffix))
6647 ))
6648 break;
6649 }
6650
6651 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
6652 /* Look again, but case-insensitively this time. */
6653 if (cp < compilers)
6654 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
6655 {
6656 if (/* The suffix `-' matches only the file name `-'. */
6657 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
6658 || (strlen (cp->suffix) < length
6659 /* See if the suffix matches the end of NAME. */
6660 && ((!strcmp (cp->suffix,
6661 name + length - strlen (cp->suffix))
6662 || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
6663 && !strcasecmp (cp->suffix,
6664 name + length - strlen (cp->suffix)))
6665 ))
6666 break;
6667 }
6668 #endif
6669
6670 if (cp >= compilers)
6671 {
6672 if (cp->spec[0] != '@')
6673 /* A non-alias entry: return it. */
6674 return cp;
6675
6676 /* An alias entry maps a suffix to a language.
6677 Search for the language; pass 0 for NAME and LENGTH
6678 to avoid infinite recursion if language not found. */
6679 return lookup_compiler (NULL, 0, cp->spec + 1);
6680 }
6681 return 0;
6682 }
6683 \f
6684 static char *
6685 save_string (const char *s, int len)
6686 {
6687 char *result = xmalloc (len + 1);
6688
6689 memcpy (result, s, len);
6690 result[len] = 0;
6691 return result;
6692 }
6693
6694 void
6695 pfatal_with_name (const char *name)
6696 {
6697 perror_with_name (name);
6698 delete_temp_files ();
6699 exit (1);
6700 }
6701
6702 static void
6703 perror_with_name (const char *name)
6704 {
6705 error ("%s: %s", name, xstrerror (errno));
6706 }
6707
6708 static void
6709 pfatal_pexecute (const char *errmsg_fmt, const char *errmsg_arg)
6710 {
6711 if (errmsg_arg)
6712 {
6713 int save_errno = errno;
6714
6715 /* Space for trailing '\0' is in %s. */
6716 char *msg = xmalloc (strlen (errmsg_fmt) + strlen (errmsg_arg));
6717 sprintf (msg, errmsg_fmt, errmsg_arg);
6718 errmsg_fmt = msg;
6719
6720 errno = save_errno;
6721 }
6722
6723 pfatal_with_name (errmsg_fmt);
6724 }
6725
6726 /* Output an error message and exit. */
6727
6728 void
6729 fancy_abort (void)
6730 {
6731 fatal ("internal gcc abort");
6732 }
6733 \f
6734 /* Output an error message and exit. */
6735
6736 void
6737 fatal (const char *msgid, ...)
6738 {
6739 va_list ap;
6740
6741 va_start (ap, msgid);
6742
6743 fprintf (stderr, "%s: ", programname);
6744 vfprintf (stderr, _(msgid), ap);
6745 va_end (ap);
6746 fprintf (stderr, "\n");
6747 delete_temp_files ();
6748 exit (1);
6749 }
6750
6751 void
6752 error (const char *msgid, ...)
6753 {
6754 va_list ap;
6755
6756 va_start (ap, msgid);
6757 fprintf (stderr, "%s: ", programname);
6758 vfprintf (stderr, _(msgid), ap);
6759 va_end (ap);
6760
6761 fprintf (stderr, "\n");
6762 }
6763
6764 static void
6765 notice (const char *msgid, ...)
6766 {
6767 va_list ap;
6768
6769 va_start (ap, msgid);
6770 vfprintf (stderr, _(msgid), ap);
6771 va_end (ap);
6772 }
6773 \f
6774 static inline void
6775 validate_switches_from_spec (const char *spec)
6776 {
6777 const char *p = spec;
6778 char c;
6779 while ((c = *p++))
6780 if (c == '%' && (*p == '{' || *p == '<' || (*p == 'W' && *++p == '{')))
6781 /* We have a switch spec. */
6782 p = validate_switches (p + 1);
6783 }
6784
6785 static void
6786 validate_all_switches (void)
6787 {
6788 struct compiler *comp;
6789 struct spec_list *spec;
6790
6791 for (comp = compilers; comp->spec; comp++)
6792 validate_switches_from_spec (comp->spec);
6793
6794 /* Look through the linked list of specs read from the specs file. */
6795 for (spec = specs; spec; spec = spec->next)
6796 validate_switches_from_spec (*spec->ptr_spec);
6797
6798 validate_switches_from_spec (link_command_spec);
6799 }
6800
6801 /* Look at the switch-name that comes after START
6802 and mark as valid all supplied switches that match it. */
6803
6804 static const char *
6805 validate_switches (const char *start)
6806 {
6807 const char *p = start;
6808 const char *atom;
6809 size_t len;
6810 int i;
6811 bool suffix = false;
6812 bool starred = false;
6813
6814 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
6815
6816 next_member:
6817 SKIP_WHITE ();
6818
6819 if (*p == '!')
6820 p++;
6821
6822 SKIP_WHITE ();
6823 if (*p == '.')
6824 suffix = true, p++;
6825
6826 atom = p;
6827 while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
6828 || *p == ',' || *p == '.' || *p == '@')
6829 p++;
6830 len = p - atom;
6831
6832 if (*p == '*')
6833 starred = true, p++;
6834
6835 SKIP_WHITE ();
6836
6837 if (!suffix)
6838 {
6839 /* Mark all matching switches as valid. */
6840 for (i = 0; i < n_switches; i++)
6841 if (!strncmp (switches[i].part1, atom, len)
6842 && (starred || switches[i].part1[len] == 0))
6843 switches[i].validated = 1;
6844 }
6845
6846 if (*p) p++;
6847 if (*p && (p[-1] == '|' || p[-1] == '&'))
6848 goto next_member;
6849
6850 if (*p && p[-1] == ':')
6851 {
6852 while (*p && *p != ';' && *p != '}')
6853 {
6854 if (*p == '%')
6855 {
6856 p++;
6857 if (*p == '{' || *p == '<')
6858 p = validate_switches (p+1);
6859 else if (p[0] == 'W' && p[1] == '{')
6860 p = validate_switches (p+2);
6861 }
6862 else
6863 p++;
6864 }
6865
6866 if (*p) p++;
6867 if (*p && p[-1] == ';')
6868 goto next_member;
6869 }
6870
6871 return p;
6872 #undef SKIP_WHITE
6873 }
6874 \f
6875 struct mdswitchstr
6876 {
6877 const char *str;
6878 int len;
6879 };
6880
6881 static struct mdswitchstr *mdswitches;
6882 static int n_mdswitches;
6883
6884 /* Check whether a particular argument was used. The first time we
6885 canonicalize the switches to keep only the ones we care about. */
6886
6887 static int
6888 used_arg (const char *p, int len)
6889 {
6890 struct mswitchstr
6891 {
6892 const char *str;
6893 const char *replace;
6894 int len;
6895 int rep_len;
6896 };
6897
6898 static struct mswitchstr *mswitches;
6899 static int n_mswitches;
6900 int i, j;
6901
6902 if (!mswitches)
6903 {
6904 struct mswitchstr *matches;
6905 const char *q;
6906 int cnt = 0;
6907
6908 /* Break multilib_matches into the component strings of string
6909 and replacement string. */
6910 for (q = multilib_matches; *q != '\0'; q++)
6911 if (*q == ';')
6912 cnt++;
6913
6914 matches = alloca ((sizeof (struct mswitchstr)) * cnt);
6915 i = 0;
6916 q = multilib_matches;
6917 while (*q != '\0')
6918 {
6919 matches[i].str = q;
6920 while (*q != ' ')
6921 {
6922 if (*q == '\0')
6923 abort ();
6924 q++;
6925 }
6926 matches[i].len = q - matches[i].str;
6927
6928 matches[i].replace = ++q;
6929 while (*q != ';' && *q != '\0')
6930 {
6931 if (*q == ' ')
6932 abort ();
6933 q++;
6934 }
6935 matches[i].rep_len = q - matches[i].replace;
6936 i++;
6937 if (*q == ';')
6938 q++;
6939 }
6940
6941 /* Now build a list of the replacement string for switches that we care
6942 about. Make sure we allocate at least one entry. This prevents
6943 xmalloc from calling fatal, and prevents us from re-executing this
6944 block of code. */
6945 mswitches
6946 = xmalloc (sizeof (struct mswitchstr)
6947 * (n_mdswitches + (n_switches ? n_switches : 1)));
6948 for (i = 0; i < n_switches; i++)
6949 if (switches[i].live_cond != SWITCH_IGNORE)
6950 {
6951 int xlen = strlen (switches[i].part1);
6952 for (j = 0; j < cnt; j++)
6953 if (xlen == matches[j].len
6954 && ! strncmp (switches[i].part1, matches[j].str, xlen))
6955 {
6956 mswitches[n_mswitches].str = matches[j].replace;
6957 mswitches[n_mswitches].len = matches[j].rep_len;
6958 mswitches[n_mswitches].replace = (char *) 0;
6959 mswitches[n_mswitches].rep_len = 0;
6960 n_mswitches++;
6961 break;
6962 }
6963 }
6964
6965 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
6966 on the command line nor any options mutually incompatible with
6967 them. */
6968 for (i = 0; i < n_mdswitches; i++)
6969 {
6970 const char *r;
6971
6972 for (q = multilib_options; *q != '\0'; q++)
6973 {
6974 while (*q == ' ')
6975 q++;
6976
6977 r = q;
6978 while (strncmp (q, mdswitches[i].str, mdswitches[i].len) != 0
6979 || strchr (" /", q[mdswitches[i].len]) == NULL)
6980 {
6981 while (*q != ' ' && *q != '/' && *q != '\0')
6982 q++;
6983 if (*q != '/')
6984 break;
6985 q++;
6986 }
6987
6988 if (*q != ' ' && *q != '\0')
6989 {
6990 while (*r != ' ' && *r != '\0')
6991 {
6992 q = r;
6993 while (*q != ' ' && *q != '/' && *q != '\0')
6994 q++;
6995
6996 if (used_arg (r, q - r))
6997 break;
6998
6999 if (*q != '/')
7000 {
7001 mswitches[n_mswitches].str = mdswitches[i].str;
7002 mswitches[n_mswitches].len = mdswitches[i].len;
7003 mswitches[n_mswitches].replace = (char *) 0;
7004 mswitches[n_mswitches].rep_len = 0;
7005 n_mswitches++;
7006 break;
7007 }
7008
7009 r = q + 1;
7010 }
7011 break;
7012 }
7013 }
7014 }
7015 }
7016
7017 for (i = 0; i < n_mswitches; i++)
7018 if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
7019 return 1;
7020
7021 return 0;
7022 }
7023
7024 static int
7025 default_arg (const char *p, int len)
7026 {
7027 int i;
7028
7029 for (i = 0; i < n_mdswitches; i++)
7030 if (len == mdswitches[i].len && ! strncmp (p, mdswitches[i].str, len))
7031 return 1;
7032
7033 return 0;
7034 }
7035
7036 /* Work out the subdirectory to use based on the options. The format of
7037 multilib_select is a list of elements. Each element is a subdirectory
7038 name followed by a list of options followed by a semicolon. The format
7039 of multilib_exclusions is the same, but without the preceding
7040 directory. First gcc will check the exclusions, if none of the options
7041 beginning with an exclamation point are present, and all of the other
7042 options are present, then we will ignore this completely. Passing
7043 that, gcc will consider each multilib_select in turn using the same
7044 rules for matching the options. If a match is found, that subdirectory
7045 will be used. */
7046
7047 static void
7048 set_multilib_dir (void)
7049 {
7050 const char *p;
7051 unsigned int this_path_len;
7052 const char *this_path, *this_arg;
7053 const char *start, *end;
7054 int not_arg;
7055 int ok, ndfltok, first;
7056
7057 n_mdswitches = 0;
7058 start = multilib_defaults;
7059 while (*start == ' ' || *start == '\t')
7060 start++;
7061 while (*start != '\0')
7062 {
7063 n_mdswitches++;
7064 while (*start != ' ' && *start != '\t' && *start != '\0')
7065 start++;
7066 while (*start == ' ' || *start == '\t')
7067 start++;
7068 }
7069
7070 if (n_mdswitches)
7071 {
7072 int i = 0;
7073
7074 mdswitches = xmalloc (sizeof (struct mdswitchstr) * n_mdswitches);
7075 for (start = multilib_defaults; *start != '\0'; start = end + 1)
7076 {
7077 while (*start == ' ' || *start == '\t')
7078 start++;
7079
7080 if (*start == '\0')
7081 break;
7082
7083 for (end = start + 1;
7084 *end != ' ' && *end != '\t' && *end != '\0'; end++)
7085 ;
7086
7087 obstack_grow (&multilib_obstack, start, end - start);
7088 obstack_1grow (&multilib_obstack, 0);
7089 mdswitches[i].str = obstack_finish (&multilib_obstack);
7090 mdswitches[i++].len = end - start;
7091
7092 if (*end == '\0')
7093 break;
7094 }
7095 }
7096
7097 p = multilib_exclusions;
7098 while (*p != '\0')
7099 {
7100 /* Ignore newlines. */
7101 if (*p == '\n')
7102 {
7103 ++p;
7104 continue;
7105 }
7106
7107 /* Check the arguments. */
7108 ok = 1;
7109 while (*p != ';')
7110 {
7111 if (*p == '\0')
7112 abort ();
7113
7114 if (! ok)
7115 {
7116 ++p;
7117 continue;
7118 }
7119
7120 this_arg = p;
7121 while (*p != ' ' && *p != ';')
7122 {
7123 if (*p == '\0')
7124 abort ();
7125 ++p;
7126 }
7127
7128 if (*this_arg != '!')
7129 not_arg = 0;
7130 else
7131 {
7132 not_arg = 1;
7133 ++this_arg;
7134 }
7135
7136 ok = used_arg (this_arg, p - this_arg);
7137 if (not_arg)
7138 ok = ! ok;
7139
7140 if (*p == ' ')
7141 ++p;
7142 }
7143
7144 if (ok)
7145 return;
7146
7147 ++p;
7148 }
7149
7150 first = 1;
7151 p = multilib_select;
7152 while (*p != '\0')
7153 {
7154 /* Ignore newlines. */
7155 if (*p == '\n')
7156 {
7157 ++p;
7158 continue;
7159 }
7160
7161 /* Get the initial path. */
7162 this_path = p;
7163 while (*p != ' ')
7164 {
7165 if (*p == '\0')
7166 abort ();
7167 ++p;
7168 }
7169 this_path_len = p - this_path;
7170
7171 /* Check the arguments. */
7172 ok = 1;
7173 ndfltok = 1;
7174 ++p;
7175 while (*p != ';')
7176 {
7177 if (*p == '\0')
7178 abort ();
7179
7180 if (! ok)
7181 {
7182 ++p;
7183 continue;
7184 }
7185
7186 this_arg = p;
7187 while (*p != ' ' && *p != ';')
7188 {
7189 if (*p == '\0')
7190 abort ();
7191 ++p;
7192 }
7193
7194 if (*this_arg != '!')
7195 not_arg = 0;
7196 else
7197 {
7198 not_arg = 1;
7199 ++this_arg;
7200 }
7201
7202 /* If this is a default argument, we can just ignore it.
7203 This is true even if this_arg begins with '!'. Beginning
7204 with '!' does not mean that this argument is necessarily
7205 inappropriate for this library: it merely means that
7206 there is a more specific library which uses this
7207 argument. If this argument is a default, we need not
7208 consider that more specific library. */
7209 ok = used_arg (this_arg, p - this_arg);
7210 if (not_arg)
7211 ok = ! ok;
7212
7213 if (! ok)
7214 ndfltok = 0;
7215
7216 if (default_arg (this_arg, p - this_arg))
7217 ok = 1;
7218
7219 if (*p == ' ')
7220 ++p;
7221 }
7222
7223 if (ok && first)
7224 {
7225 if (this_path_len != 1
7226 || this_path[0] != '.')
7227 {
7228 char *new_multilib_dir = xmalloc (this_path_len + 1);
7229 char *q;
7230
7231 strncpy (new_multilib_dir, this_path, this_path_len);
7232 new_multilib_dir[this_path_len] = '\0';
7233 q = strchr (new_multilib_dir, ':');
7234 if (q != NULL)
7235 *q = '\0';
7236 multilib_dir = new_multilib_dir;
7237 }
7238 first = 0;
7239 }
7240
7241 if (ndfltok)
7242 {
7243 const char *q = this_path, *end = this_path + this_path_len;
7244
7245 while (q < end && *q != ':')
7246 q++;
7247 if (q < end)
7248 {
7249 char *new_multilib_os_dir = xmalloc (end - q);
7250 memcpy (new_multilib_os_dir, q + 1, end - q - 1);
7251 new_multilib_os_dir[end - q - 1] = '\0';
7252 multilib_os_dir = new_multilib_os_dir;
7253 break;
7254 }
7255 }
7256
7257 ++p;
7258 }
7259
7260 if (multilib_dir == NULL && multilib_os_dir != NULL
7261 && strcmp (multilib_os_dir, ".") == 0)
7262 {
7263 free ((char *) multilib_os_dir);
7264 multilib_os_dir = NULL;
7265 }
7266 else if (multilib_dir != NULL && multilib_os_dir == NULL)
7267 multilib_os_dir = multilib_dir;
7268 }
7269
7270 /* Print out the multiple library subdirectory selection
7271 information. This prints out a series of lines. Each line looks
7272 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
7273 required. Only the desired options are printed out, the negative
7274 matches. The options are print without a leading dash. There are
7275 no spaces to make it easy to use the information in the shell.
7276 Each subdirectory is printed only once. This assumes the ordering
7277 generated by the genmultilib script. Also, we leave out ones that match
7278 the exclusions. */
7279
7280 static void
7281 print_multilib_info (void)
7282 {
7283 const char *p = multilib_select;
7284 const char *last_path = 0, *this_path;
7285 int skip;
7286 unsigned int last_path_len = 0;
7287
7288 while (*p != '\0')
7289 {
7290 skip = 0;
7291 /* Ignore newlines. */
7292 if (*p == '\n')
7293 {
7294 ++p;
7295 continue;
7296 }
7297
7298 /* Get the initial path. */
7299 this_path = p;
7300 while (*p != ' ')
7301 {
7302 if (*p == '\0')
7303 abort ();
7304 ++p;
7305 }
7306
7307 /* When --disable-multilib was used but target defines
7308 MULTILIB_OSDIRNAMES, entries starting with .: are there just
7309 to find multilib_os_dir, so skip them from output. */
7310 if (this_path[0] == '.' && this_path[1] == ':')
7311 skip = 1;
7312
7313 /* Check for matches with the multilib_exclusions. We don't bother
7314 with the '!' in either list. If any of the exclusion rules match
7315 all of its options with the select rule, we skip it. */
7316 {
7317 const char *e = multilib_exclusions;
7318 const char *this_arg;
7319
7320 while (*e != '\0')
7321 {
7322 int m = 1;
7323 /* Ignore newlines. */
7324 if (*e == '\n')
7325 {
7326 ++e;
7327 continue;
7328 }
7329
7330 /* Check the arguments. */
7331 while (*e != ';')
7332 {
7333 const char *q;
7334 int mp = 0;
7335
7336 if (*e == '\0')
7337 abort ();
7338
7339 if (! m)
7340 {
7341 ++e;
7342 continue;
7343 }
7344
7345 this_arg = e;
7346
7347 while (*e != ' ' && *e != ';')
7348 {
7349 if (*e == '\0')
7350 abort ();
7351 ++e;
7352 }
7353
7354 q = p + 1;
7355 while (*q != ';')
7356 {
7357 const char *arg;
7358 int len = e - this_arg;
7359
7360 if (*q == '\0')
7361 abort ();
7362
7363 arg = q;
7364
7365 while (*q != ' ' && *q != ';')
7366 {
7367 if (*q == '\0')
7368 abort ();
7369 ++q;
7370 }
7371
7372 if (! strncmp (arg, this_arg, (len < q - arg) ? q - arg : len) ||
7373 default_arg (this_arg, e - this_arg))
7374 {
7375 mp = 1;
7376 break;
7377 }
7378
7379 if (*q == ' ')
7380 ++q;
7381 }
7382
7383 if (! mp)
7384 m = 0;
7385
7386 if (*e == ' ')
7387 ++e;
7388 }
7389
7390 if (m)
7391 {
7392 skip = 1;
7393 break;
7394 }
7395
7396 if (*e != '\0')
7397 ++e;
7398 }
7399 }
7400
7401 if (! skip)
7402 {
7403 /* If this is a duplicate, skip it. */
7404 skip = (last_path != 0 && (unsigned int) (p - this_path) == last_path_len
7405 && ! strncmp (last_path, this_path, last_path_len));
7406
7407 last_path = this_path;
7408 last_path_len = p - this_path;
7409 }
7410
7411 /* If this directory requires any default arguments, we can skip
7412 it. We will already have printed a directory identical to
7413 this one which does not require that default argument. */
7414 if (! skip)
7415 {
7416 const char *q;
7417
7418 q = p + 1;
7419 while (*q != ';')
7420 {
7421 const char *arg;
7422
7423 if (*q == '\0')
7424 abort ();
7425
7426 if (*q == '!')
7427 arg = NULL;
7428 else
7429 arg = q;
7430
7431 while (*q != ' ' && *q != ';')
7432 {
7433 if (*q == '\0')
7434 abort ();
7435 ++q;
7436 }
7437
7438 if (arg != NULL
7439 && default_arg (arg, q - arg))
7440 {
7441 skip = 1;
7442 break;
7443 }
7444
7445 if (*q == ' ')
7446 ++q;
7447 }
7448 }
7449
7450 if (! skip)
7451 {
7452 const char *p1;
7453
7454 for (p1 = last_path; p1 < p && *p1 != ':'; p1++)
7455 putchar (*p1);
7456 putchar (';');
7457 }
7458
7459 ++p;
7460 while (*p != ';')
7461 {
7462 int use_arg;
7463
7464 if (*p == '\0')
7465 abort ();
7466
7467 if (skip)
7468 {
7469 ++p;
7470 continue;
7471 }
7472
7473 use_arg = *p != '!';
7474
7475 if (use_arg)
7476 putchar ('@');
7477
7478 while (*p != ' ' && *p != ';')
7479 {
7480 if (*p == '\0')
7481 abort ();
7482 if (use_arg)
7483 putchar (*p);
7484 ++p;
7485 }
7486
7487 if (*p == ' ')
7488 ++p;
7489 }
7490
7491 if (! skip)
7492 {
7493 /* If there are extra options, print them now. */
7494 if (multilib_extra && *multilib_extra)
7495 {
7496 int print_at = TRUE;
7497 const char *q;
7498
7499 for (q = multilib_extra; *q != '\0'; q++)
7500 {
7501 if (*q == ' ')
7502 print_at = TRUE;
7503 else
7504 {
7505 if (print_at)
7506 putchar ('@');
7507 putchar (*q);
7508 print_at = FALSE;
7509 }
7510 }
7511 }
7512
7513 putchar ('\n');
7514 }
7515
7516 ++p;
7517 }
7518 }
7519 \f
7520 /* if-exists built-in spec function.
7521
7522 Checks to see if the file specified by the absolute pathname in
7523 ARGS exists. Returns that pathname if found.
7524
7525 The usual use for this function is to check for a library file
7526 (whose name has been expanded with %s). */
7527
7528 static const char *
7529 if_exists_spec_function (int argc, const char **argv)
7530 {
7531 /* Must have only one argument. */
7532 if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
7533 return argv[0];
7534
7535 return NULL;
7536 }
7537
7538 /* if-exists-else built-in spec function.
7539
7540 This is like if-exists, but takes an additional argument which
7541 is returned if the first argument does not exist. */
7542
7543 static const char *
7544 if_exists_else_spec_function (int argc, const char **argv)
7545 {
7546 /* Must have exactly two arguments. */
7547 if (argc != 2)
7548 return NULL;
7549
7550 if (IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
7551 return argv[0];
7552
7553 return argv[1];
7554 }