Fold patches into contrib.
[dragonfly.git] / contrib / gcc-4.1 / gcc / gcc.c
CommitLineData
144812d8
SS
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, 2005, 2006 Free Software Foundation,
4 Inc.
5
6This file is part of GCC.
7
8GCC is free software; you can redistribute it and/or modify it under
9the terms of the GNU General Public License as published by the Free
10Software Foundation; either version 2, or (at your option) any later
11version.
12
13GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14WARRANTY; without even the implied warranty of MERCHANTABILITY or
15FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16for more details.
17
18You should have received a copy of the GNU General Public License
19along with GCC; see the file COPYING. If not, write to the Free
20Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
2102110-1301, USA.
22
23This paragraph is here to try to keep Sun CC from dying.
24The number of chars here seems crucial!!!! */
25
26/* This program is the user interface to the C compiler and possibly to
27other compilers. It is used because compilation is a complicated procedure
28which involves running several programs and passing temporary files between
29them, forwarding the users switches to those programs selectively,
30and deleting the temporary files at the end.
31
32CC recognizes how to compile each input file by suffixes in the file names.
33Once it knows which kind of compilation to perform, the procedure for
34compilation is specified by a string called a "spec". */
35
36/* A Short Introduction to Adding a Command-Line Option.
37
38 Before adding a command-line option, consider if it is really
39 necessary. Each additional command-line option adds complexity and
40 is difficult to remove in subsequent versions.
41
42 In the following, consider adding the command-line argument
43 `--bar'.
44
45 1. Each command-line option is specified in the specs file. The
46 notation is described below in the comment entitled "The Specs
47 Language". Read it.
48
49 2. In this file, add an entry to "option_map" equating the long
50 `--' argument version and any shorter, single letter version. Read
51 the comments in the declaration of "struct option_map" for an
52 explanation. Do not omit the first `-'.
53
54 3. Look in the "specs" file to determine which program or option
55 list should be given the argument, e.g., "cc1_options". Add the
56 appropriate syntax for the shorter option version to the
57 corresponding "const char *" entry in this file. Omit the first
58 `-' from the option. For example, use `-bar', rather than `--bar'.
59
60 4. If the argument takes an argument, e.g., `--baz argument1',
61 modify either DEFAULT_SWITCH_TAKES_ARG or
62 DEFAULT_WORD_SWITCH_TAKES_ARG in gcc.h. Omit the first `-'
63 from `--baz'.
64
65 5. Document the option in this file's display_help(). If the
66 option is passed to a subprogram, modify its corresponding
67 function, e.g., cppinit.c:print_help() or toplev.c:display_help(),
68 instead.
69
70 6. Compile and test. Make sure that your new specs file is being
71 read. For example, use a debugger to investigate the value of
72 "specs_file" in main(). */
73
74#include "config.h"
75#include "system.h"
76#include "coretypes.h"
77#include "multilib.h" /* before tm.h */
78#include "tm.h"
79#include <signal.h>
80#if ! defined( SIGCHLD ) && defined( SIGCLD )
81# define SIGCHLD SIGCLD
82#endif
83#include "xregex.h"
84#include "obstack.h"
85#include "intl.h"
86#include "prefix.h"
87#include "gcc.h"
88#include "flags.h"
89
90/* By default there is no special suffix for target executables. */
91/* FIXME: when autoconf is fixed, remove the host check - dj */
92#if defined(TARGET_EXECUTABLE_SUFFIX) && defined(HOST_EXECUTABLE_SUFFIX)
93#define HAVE_TARGET_EXECUTABLE_SUFFIX
94#endif
95
96/* By default there is no special suffix for host executables. */
97#ifdef HOST_EXECUTABLE_SUFFIX
98#define HAVE_HOST_EXECUTABLE_SUFFIX
99#else
100#define HOST_EXECUTABLE_SUFFIX ""
101#endif
102
103/* By default, the suffix for target object files is ".o". */
104#ifdef TARGET_OBJECT_SUFFIX
105#define HAVE_TARGET_OBJECT_SUFFIX
106#else
107#define TARGET_OBJECT_SUFFIX ".o"
108#endif
109
110static const char dir_separator_str[] = { DIR_SEPARATOR, 0 };
111
112/* Most every one is fine with LIBRARY_PATH. For some, it conflicts. */
113#ifndef LIBRARY_PATH_ENV
114#define LIBRARY_PATH_ENV "LIBRARY_PATH"
115#endif
116
117#ifndef HAVE_KILL
118#define kill(p,s) raise(s)
119#endif
120
121/* If a stage of compilation returns an exit status >= 1,
122 compilation of that file ceases. */
123
124#define MIN_FATAL_STATUS 1
125
126/* Flag set by cppspec.c to 1. */
127int is_cpp_driver;
128
129/* Flag saying to pass the greatest exit code returned by a sub-process
130 to the calling program. */
131static int pass_exit_codes;
132
133/* Definition of string containing the arguments given to configure. */
134#include "configargs.h"
135
136/* Flag saying to print the directories gcc will search through looking for
137 programs, libraries, etc. */
138
139static int print_search_dirs;
140
141/* Flag saying to print the full filename of this file
142 as found through our usual search mechanism. */
143
144static const char *print_file_name = NULL;
145
146/* As print_file_name, but search for executable file. */
147
148static const char *print_prog_name = NULL;
149
150/* Flag saying to print the relative path we'd use to
151 find libgcc.a given the current compiler flags. */
152
153static int print_multi_directory;
154
155/* Flag saying to print the relative path we'd use to
156 find OS libraries given the current compiler flags. */
157
158static int print_multi_os_directory;
159
160/* Flag saying to print the list of subdirectories and
161 compiler flags used to select them in a standard form. */
162
163static int print_multi_lib;
164
165/* Flag saying to print the command line options understood by gcc and its
166 sub-processes. */
167
168static int print_help_list;
169
170/* Flag indicating whether we should print the command and arguments */
171
172static int verbose_flag;
173
174/* Flag indicating whether we should ONLY print the command and
175 arguments (like verbose_flag) without executing the command.
176 Displayed arguments are quoted so that the generated command
177 line is suitable for execution. This is intended for use in
178 shell scripts to capture the driver-generated command line. */
179static int verbose_only_flag;
180
181/* Flag indicating to print target specific command line options. */
182
183static int target_help_flag;
184
185/* Flag indicating whether we should report subprocess execution times
186 (if this is supported by the system - see pexecute.c). */
187
188static int report_times;
189
190/* Nonzero means place this string before uses of /, so that include
191 and library files can be found in an alternate location. */
192
193#ifdef TARGET_SYSTEM_ROOT
194static const char *target_system_root = TARGET_SYSTEM_ROOT;
195#else
196static const char *target_system_root = 0;
197#endif
198
199/* Nonzero means pass the updated target_system_root to the compiler. */
200
201static int target_system_root_changed;
202
203/* Nonzero means append this string to target_system_root. */
204
205static const char *target_sysroot_suffix = 0;
206
207/* Nonzero means append this string to target_system_root for headers. */
208
209static const char *target_sysroot_hdrs_suffix = 0;
210
211/* Nonzero means write "temp" files in source directory
212 and use the source file's name in them, and don't delete them. */
213
214static int save_temps_flag;
215
216/* Nonzero means pass multiple source files to the compiler at one time. */
217
218static int combine_flag = 0;
219
220/* Nonzero means use pipes to communicate between subprocesses.
221 Overridden by either of the above two flags. */
222
223static int use_pipes;
224
225/* The compiler version. */
226
227static const char *compiler_version;
228
229/* The target version specified with -V */
230
231static const char *const spec_version = DEFAULT_TARGET_VERSION;
232
233/* The target machine specified with -b. */
234
235static const char *spec_machine = DEFAULT_TARGET_MACHINE;
236
237/* Nonzero if cross-compiling.
238 When -b is used, the value comes from the `specs' file. */
239
240#ifdef CROSS_COMPILE
241static const char *cross_compile = "1";
242#else
243static const char *cross_compile = "0";
244#endif
245
246#ifdef MODIFY_TARGET_NAME
247
248/* Information on how to alter the target name based on a command-line
249 switch. The only case we support now is simply appending or deleting a
250 string to or from the end of the first part of the configuration name. */
251
252static const struct modify_target
253{
254 const char *const sw;
255 const enum add_del {ADD, DELETE} add_del;
256 const char *const str;
257}
258modify_target[] = MODIFY_TARGET_NAME;
259#endif
260
261/* The number of errors that have occurred; the link phase will not be
262 run if this is nonzero. */
263static int error_count = 0;
264
265/* Greatest exit code of sub-processes that has been encountered up to
266 now. */
267static int greatest_status = 1;
268
269/* This is the obstack which we use to allocate many strings. */
270
271static struct obstack obstack;
272
273/* This is the obstack to build an environment variable to pass to
274 collect2 that describes all of the relevant switches of what to
275 pass the compiler in building the list of pointers to constructors
276 and destructors. */
277
278static struct obstack collect_obstack;
279
280/* Forward declaration for prototypes. */
281struct path_prefix;
282struct prefix_list;
283
284static void init_spec (void);
285static void store_arg (const char *, int, int);
286static char *load_specs (const char *);
287static void read_specs (const char *, int);
288static void set_spec (const char *, const char *);
289static struct compiler *lookup_compiler (const char *, size_t, const char *);
290static char *build_search_list (struct path_prefix *, const char *, int);
291static void putenv_from_prefixes (struct path_prefix *, const char *);
292static int access_check (const char *, int);
293static char *find_a_file (struct path_prefix *, const char *, int, int);
294static void add_prefix (struct path_prefix *, const char *, const char *,
295 int, int, int);
296static void add_sysrooted_prefix (struct path_prefix *, const char *,
297 const char *, int, int, int);
298static void translate_options (int *, const char *const **);
299static char *skip_whitespace (char *);
300static void delete_if_ordinary (const char *);
301static void delete_temp_files (void);
302static void delete_failure_queue (void);
303static void clear_failure_queue (void);
304static int check_live_switch (int, int);
305static const char *handle_braces (const char *);
306static inline bool input_suffix_matches (const char *, const char *);
307static inline bool switch_matches (const char *, const char *, int);
308static inline void mark_matching_switches (const char *, const char *, int);
309static inline void process_marked_switches (void);
310static const char *process_brace_body (const char *, const char *, const char *, int, int);
311static const struct spec_function *lookup_spec_function (const char *);
312static const char *eval_spec_function (const char *, const char *);
313static const char *handle_spec_function (const char *);
314static char *save_string (const char *, int);
315static void set_collect_gcc_options (void);
316static void do_spec_path (struct prefix_list *, const char *, int, int, int, const char *, const char *);
317static int do_spec_1 (const char *, int, const char *);
318static int do_spec_2 (const char *);
319static void do_option_spec (const char *, const char *);
320static void do_self_spec (const char *);
321static const char *find_file (const char *);
322static int is_directory (const char *, const char *, int);
323static const char *validate_switches (const char *);
324static void validate_all_switches (void);
325static inline void validate_switches_from_spec (const char *);
326static void give_switch (int, int);
327static int used_arg (const char *, int);
328static int default_arg (const char *, int);
329static void set_multilib_dir (void);
330static void print_multilib_info (void);
331static void perror_with_name (const char *);
332static void notice (const char *, ...) ATTRIBUTE_PRINTF_1;
333static void display_help (void);
334static void add_preprocessor_option (const char *, int);
335static void add_assembler_option (const char *, int);
336static void add_linker_option (const char *, int);
337static void process_command (int, const char **);
338static int execute (void);
339static void alloc_args (void);
340static void clear_args (void);
341static void fatal_error (int);
342#if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
343static void init_gcc_specs (struct obstack *, const char *, const char *,
344 const char *);
345#endif
346#if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
347static const char *convert_filename (const char *, int, int);
348#endif
349
350static const char *if_exists_spec_function (int, const char **);
351static const char *if_exists_else_spec_function (int, const char **);
352static const char *replace_outfile_spec_function (int, const char **);
353static const char *version_compare_spec_function (int, const char **);
354\f
355/* The Specs Language
356
357Specs are strings containing lines, each of which (if not blank)
358is made up of a program name, and arguments separated by spaces.
359The program name must be exact and start from root, since no path
360is searched and it is unreliable to depend on the current working directory.
361Redirection of input or output is not supported; the subprograms must
362accept filenames saying what files to read and write.
363
364In addition, the specs can contain %-sequences to substitute variable text
365or for conditional text. Here is a table of all defined %-sequences.
366Note that spaces are not generated automatically around the results of
367expanding these sequences; therefore, you can concatenate them together
368or with constant text in a single argument.
369
370 %% substitute one % into the program name or argument.
371 %i substitute the name of the input file being processed.
372 %b substitute the basename of the input file being processed.
373 This is the substring up to (and not including) the last period
374 and not including the directory.
375 %B same as %b, but include the file suffix (text after the last period).
376 %gSUFFIX
377 substitute a file name that has suffix SUFFIX and is chosen
378 once per compilation, and mark the argument a la %d. To reduce
379 exposure to denial-of-service attacks, the file name is now
380 chosen in a way that is hard to predict even when previously
381 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
382 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
383 the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
384 had been pre-processed. Previously, %g was simply substituted
385 with a file name chosen once per compilation, without regard
386 to any appended suffix (which was therefore treated just like
387 ordinary text), making such attacks more likely to succeed.
388 %|SUFFIX
389 like %g, but if -pipe is in effect, expands simply to "-".
390 %mSUFFIX
391 like %g, but if -pipe is in effect, expands to nothing. (We have both
392 %| and %m to accommodate differences between system assemblers; see
393 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
394 %uSUFFIX
395 like %g, but generates a new temporary file name even if %uSUFFIX
396 was already seen.
397 %USUFFIX
398 substitutes the last file name generated with %uSUFFIX, generating a
399 new one if there is no such last file name. In the absence of any
400 %uSUFFIX, this is just like %gSUFFIX, except they don't share
401 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
402 would involve the generation of two distinct file names, one
403 for each `%g.s' and another for each `%U.s'. Previously, %U was
404 simply substituted with a file name chosen for the previous %u,
405 without regard to any appended suffix.
406 %jSUFFIX
407 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
408 writable, and if save-temps is off; otherwise, substitute the name
409 of a temporary file, just like %u. This temporary file is not
410 meant for communication between processes, but rather as a junk
411 disposal mechanism.
412 %.SUFFIX
413 substitutes .SUFFIX for the suffixes of a matched switch's args when
414 it is subsequently output with %*. SUFFIX is terminated by the next
415 space or %.
416 %d marks the argument containing or following the %d as a
417 temporary file name, so that that file will be deleted if CC exits
418 successfully. Unlike %g, this contributes no text to the argument.
419 %w marks the argument containing or following the %w as the
420 "output file" of this compilation. This puts the argument
421 into the sequence of arguments that %o will substitute later.
422 %V indicates that this compilation produces no "output file".
423 %W{...}
424 like %{...} but mark last argument supplied within
425 as a file to be deleted on failure.
426 %o substitutes the names of all the output files, with spaces
427 automatically placed around them. You should write spaces
428 around the %o as well or the results are undefined.
429 %o is for use in the specs for running the linker.
430 Input files whose names have no recognized suffix are not compiled
431 at all, but they are included among the output files, so they will
432 be linked.
433 %O substitutes the suffix for object files. Note that this is
434 handled specially when it immediately follows %g, %u, or %U
435 (with or without a suffix argument) because of the need for
436 those to form complete file names. The handling is such that
437 %O is treated exactly as if it had already been substituted,
438 except that %g, %u, and %U do not currently support additional
439 SUFFIX characters following %O as they would following, for
440 example, `.o'.
441 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
442 (made from TARGET_SYSTEM_ROOT), and -isystem (made from COMPILER_PATH
443 and -B options) as necessary.
444 %s current argument is the name of a library or startup file of some sort.
445 Search for that file in a standard list of directories
446 and substitute the full name found.
447 %eSTR Print STR as an error message. STR is terminated by a newline.
448 Use this when inconsistent options are detected.
449 %nSTR Print STR as a notice. STR is terminated by a newline.
450 %x{OPTION} Accumulate an option for %X.
451 %X Output the accumulated linker options specified by compilations.
452 %Y Output the accumulated assembler options specified by compilations.
453 %Z Output the accumulated preprocessor options specified by compilations.
454 %a process ASM_SPEC as a spec.
455 This allows config.h to specify part of the spec for running as.
456 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
457 used here. This can be used to run a post-processor after the
458 assembler has done its job.
459 %D Dump out a -L option for each directory in startfile_prefixes.
460 If multilib_dir is set, extra entries are generated with it affixed.
461 %l process LINK_SPEC as a spec.
462 %L process LIB_SPEC as a spec.
463 %G process LIBGCC_SPEC as a spec.
464 %R Output the concatenation of target_system_root and
465 target_sysroot_suffix.
466 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
467 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
468 %C process CPP_SPEC as a spec.
469 %1 process CC1_SPEC as a spec.
470 %2 process CC1PLUS_SPEC as a spec.
471 %* substitute the variable part of a matched option. (See below.)
472 Note that each comma in the substituted string is replaced by
473 a single space.
474 %<S remove all occurrences of -S from the command line.
475 Note - this command is position dependent. % commands in the
476 spec string before this one will see -S, % commands in the
477 spec string after this one will not.
478 %<S* remove all occurrences of all switches beginning with -S from the
479 command line.
480 %:function(args)
481 Call the named function FUNCTION, passing it ARGS. ARGS is
482 first processed as a nested spec string, then split into an
483 argument vector in the usual fashion. The function returns
484 a string which is processed as if it had appeared literally
485 as part of the current spec.
486 %{S} substitutes the -S switch, if that switch was given to CC.
487 If that switch was not specified, this substitutes nothing.
488 Here S is a metasyntactic variable.
489 %{S*} substitutes all the switches specified to CC whose names start
490 with -S. This is used for -o, -I, etc; switches that take
491 arguments. CC considers `-o foo' as being one switch whose
492 name starts with `o'. %{o*} would substitute this text,
493 including the space; thus, two arguments would be generated.
494 %{S*&T*} likewise, but preserve order of S and T options (the order
495 of S and T in the spec is not significant). Can be any number
496 of ampersand-separated variables; for each the wild card is
497 optional. Useful for CPP as %{D*&U*&A*}.
498
499 %{S:X} substitutes X, if the -S switch was given to CC.
500 %{!S:X} substitutes X, if the -S switch was NOT given to CC.
501 %{S*:X} substitutes X if one or more switches whose names start
502 with -S was given to CC. Normally X is substituted only
503 once, no matter how many such switches appeared. However,
504 if %* appears somewhere in X, then X will be substituted
505 once for each matching switch, with the %* replaced by the
506 part of that switch that matched the '*'.
507 %{.S:X} substitutes X, if processing a file with suffix S.
508 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
509
510 %{S|T:X} substitutes X if either -S or -T was given to CC. This may be
511 combined with !, ., and * as above binding stronger than the OR.
512 If %* appears in X, all of the alternatives must be starred, and
513 only the first matching alternative is substituted.
514 %{S:X; if S was given to CC, substitutes X;
515 T:Y; else if T was given to CC, substitutes Y;
516 :D} else substitutes D. There can be as many clauses as you need.
517 This may be combined with ., !, |, and * as above.
518
519 %(Spec) processes a specification defined in a specs file as *Spec:
520 %[Spec] as above, but put __ around -D arguments
521
522The conditional text X in a %{S:X} or similar construct may contain
523other nested % constructs or spaces, or even newlines. They are
524processed as usual, as described above. Trailing white space in X is
525ignored. White space may also appear anywhere on the left side of the
526colon in these constructs, except between . or * and the corresponding
527word.
528
529The -O, -f, -m, and -W switches are handled specifically in these
530constructs. If another value of -O or the negated form of a -f, -m, or
531-W switch is found later in the command line, the earlier switch
532value is ignored, except with {S*} where S is just one letter; this
533passes all matching options.
534
535The character | at the beginning of the predicate text is used to indicate
536that a command should be piped to the following command, but only if -pipe
537is specified.
538
539Note that it is built into CC which switches take arguments and which
540do not. You might think it would be useful to generalize this to
541allow each compiler's spec to say which switches take arguments. But
542this cannot be done in a consistent fashion. CC cannot even decide
543which input files have been specified without knowing which switches
544take arguments, and it must know which input files to compile in order
545to tell which compilers to run.
546
547CC also knows implicitly that arguments starting in `-l' are to be
548treated as compiler output files, and passed to the linker in their
549proper position among the other output files. */
550\f
551/* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
552
553/* config.h can define ASM_SPEC to provide extra args to the assembler
554 or extra switch-translations. */
555#ifndef ASM_SPEC
556#define ASM_SPEC ""
557#endif
558
559/* config.h can define ASM_FINAL_SPEC to run a post processor after
560 the assembler has run. */
561#ifndef ASM_FINAL_SPEC
562#define ASM_FINAL_SPEC ""
563#endif
564
565/* config.h can define CPP_SPEC to provide extra args to the C preprocessor
566 or extra switch-translations. */
567#ifndef CPP_SPEC
568#define CPP_SPEC ""
569#endif
570
571/* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
572 or extra switch-translations. */
573#ifndef CC1_SPEC
574#define CC1_SPEC ""
575#endif
576
577/* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
578 or extra switch-translations. */
579#ifndef CC1PLUS_SPEC
580#define CC1PLUS_SPEC ""
581#endif
582
583/* config.h can define LINK_SPEC to provide extra args to the linker
584 or extra switch-translations. */
585#ifndef LINK_SPEC
586#define LINK_SPEC ""
587#endif
588
589/* config.h can define LIB_SPEC to override the default libraries. */
590#ifndef LIB_SPEC
591#define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
592#endif
593
594/* mudflap specs */
595#ifndef MFWRAP_SPEC
596/* XXX: valid only for GNU ld */
597/* XXX: should exactly match hooks provided by libmudflap.a */
598#define MFWRAP_SPEC " %{static: %{fmudflap|fmudflapth: \
599 --wrap=malloc --wrap=free --wrap=calloc --wrap=realloc\
600 --wrap=mmap --wrap=munmap --wrap=alloca\
601} %{fmudflapth: --wrap=pthread_create\
602}} %{fmudflap|fmudflapth: --wrap=main}"
603#endif
604#ifndef MFLIB_SPEC
605#define MFLIB_SPEC "%{fmudflap|fmudflapth: -export-dynamic}"
606#endif
607
608/* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
609 included. */
610#ifndef LIBGCC_SPEC
611#if defined(REAL_LIBGCC_SPEC)
612#define LIBGCC_SPEC REAL_LIBGCC_SPEC
613#elif defined(LINK_LIBGCC_SPECIAL_1)
614/* Have gcc do the search for libgcc.a. */
615#define LIBGCC_SPEC "libgcc.a%s"
616#else
617#define LIBGCC_SPEC "-lgcc"
618#endif
619#endif
620
621/* config.h can define STARTFILE_SPEC to override the default crt0 files. */
622#ifndef STARTFILE_SPEC
623#define STARTFILE_SPEC \
624 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
625#endif
626
627/* config.h can define SWITCHES_NEED_SPACES to control which options
628 require spaces between the option and the argument. */
629#ifndef SWITCHES_NEED_SPACES
630#define SWITCHES_NEED_SPACES ""
631#endif
632
633/* config.h can define ENDFILE_SPEC to override the default crtn files. */
634#ifndef ENDFILE_SPEC
635#define ENDFILE_SPEC ""
636#endif
637
638#ifndef LINKER_NAME
639#define LINKER_NAME "collect2"
640#endif
641
642/* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
643 to the assembler. */
644#ifndef ASM_DEBUG_SPEC
645# if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
646 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
647# define ASM_DEBUG_SPEC \
648 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
649 ? "%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}" \
650 : "%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}")
651# else
652# if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
653# define ASM_DEBUG_SPEC "%{g*:--gstabs}"
654# endif
655# if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
656# define ASM_DEBUG_SPEC "%{g*:--gdwarf2}"
657# endif
658# endif
659#endif
660#ifndef ASM_DEBUG_SPEC
661# define ASM_DEBUG_SPEC ""
662#endif
663
664/* Here is the spec for running the linker, after compiling all files. */
665
666/* This is overridable by the target in case they need to specify the
667 -lgcc and -lc order specially, yet not require them to override all
668 of LINK_COMMAND_SPEC. */
669#ifndef LINK_GCC_C_SEQUENCE_SPEC
670#define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
671#endif
672
673#ifndef LINK_SSP_SPEC
674#ifdef TARGET_LIBC_PROVIDES_SSP
675#define LINK_SSP_SPEC "%{fstack-protector:}"
676#else
677#define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all:-lssp_nonshared -lssp}"
678#endif
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|coverage:-lgcov}\
702 %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\
703 %{!A:%{!nostdlib:%{!nostartfiles:%E}}} %{T*} }}}}}}"
704#endif
705
706#ifndef LINK_LIBGCC_SPEC
707/* Generate -L options for startfile prefix list. */
708# define LINK_LIBGCC_SPEC "%D"
709#endif
710
711#ifndef STARTFILE_PREFIX_SPEC
712# define STARTFILE_PREFIX_SPEC ""
713#endif
714
715#ifndef SYSROOT_SPEC
716# define SYSROOT_SPEC "--sysroot=%R"
717#endif
718
719#ifndef SYSROOT_SUFFIX_SPEC
720# define SYSROOT_SUFFIX_SPEC ""
721#endif
722
723#ifndef SYSROOT_HEADERS_SUFFIX_SPEC
724# define SYSROOT_HEADERS_SUFFIX_SPEC ""
725#endif
726
727static const char *asm_debug;
728static const char *cpp_spec = CPP_SPEC;
729static const char *cc1_spec = CC1_SPEC;
730static const char *cc1plus_spec = CC1PLUS_SPEC;
731static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC;
732static const char *link_ssp_spec = LINK_SSP_SPEC;
733static const char *asm_spec = ASM_SPEC;
734static const char *asm_final_spec = ASM_FINAL_SPEC;
735static const char *link_spec = LINK_SPEC;
390b4252 736static const char *pre_lib_spec = PRE_LIB_SPEC;
144812d8
SS
737static const char *lib_spec = LIB_SPEC;
738static const char *mfwrap_spec = MFWRAP_SPEC;
739static const char *mflib_spec = MFLIB_SPEC;
740static const char *libgcc_spec = LIBGCC_SPEC;
741static const char *endfile_spec = ENDFILE_SPEC;
742static const char *startfile_spec = STARTFILE_SPEC;
743static const char *switches_need_spaces = SWITCHES_NEED_SPACES;
744static const char *linker_name_spec = LINKER_NAME;
745static const char *link_command_spec = LINK_COMMAND_SPEC;
746static const char *link_libgcc_spec = LINK_LIBGCC_SPEC;
747static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC;
748static const char *sysroot_spec = SYSROOT_SPEC;
749static const char *sysroot_suffix_spec = SYSROOT_SUFFIX_SPEC;
750static const char *sysroot_hdrs_suffix_spec = SYSROOT_HEADERS_SUFFIX_SPEC;
751
752/* Standard options to cpp, cc1, and as, to reduce duplication in specs.
753 There should be no need to override these in target dependent files,
754 but we need to copy them to the specs file so that newer versions
755 of the GCC driver can correctly drive older tool chains with the
756 appropriate -B options. */
757
758/* When cpplib handles traditional preprocessing, get rid of this, and
759 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
760 that we default the front end language better. */
761static const char *trad_capable_cpp =
762"cc1 -E %{traditional|ftraditional|traditional-cpp:-traditional-cpp}";
763
764/* We don't wrap .d files in %W{} since a missing .d file, and
765 therefore no dependency entry, confuses make into thinking a .o
766 file that happens to exist is up-to-date. */
767static const char *cpp_unique_options =
768"%{C|CC:%{!E:%eGCC does not support -C or -CC without -E}}\
769 %{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\
770 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
771 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
772 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
773 %{!E:%{!M:%{!MM:%{MD|MMD:%{o*:-MQ %*}}}}}\
774 %{remap} %{g3:-dD} %{H} %C %{D*&U*&A*} %{i*} %Z %i\
775 %{fmudflap:-D_MUDFLAP -include mf-runtime.h}\
776 %{fmudflapth:-D_MUDFLAP -D_MUDFLAPTH -include mf-runtime.h}\
777 %{E|M|MM:%W{o*}}";
778
779/* This contains cpp options which are common with cc1_options and are passed
780 only when preprocessing only to avoid duplication. We pass the cc1 spec
781 options to the preprocessor so that it the cc1 spec may manipulate
782 options used to set target flags. Those special target flags settings may
783 in turn cause preprocessor symbols to be defined specially. */
784static const char *cpp_options =
785"%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
786 %{f*} %{g*:%{!g0:%{!fno-working-directory:-fworking-directory}}} %{O*}\
787 %{undef} %{save-temps:-fpch-preprocess}";
788
789/* This contains cpp options which are not passed when the preprocessor
790 output will be used by another program. */
791static const char *cpp_debug_options = "%{d*}";
792
793/* NB: This is shared amongst all front-ends. */
794static const char *cc1_options =
795"%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
796 %1 %{!Q:-quiet} -dumpbase %B %{d*} %{m*} %{a*}\
797 %{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}%{!c:%{!S:-auxbase %b}}\
798 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
799 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
800 %{Qn:-fno-ident} %{--help:--help}\
801 %{--target-help:--target-help}\
802 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
803 %{fsyntax-only:-o %j} %{-param*}\
804 %{fmudflap|fmudflapth:-fno-builtin -fno-merge-constants}\
805 %{coverage:-fprofile-arcs -ftest-coverage}";
806
807static const char *asm_options =
808"%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
809
810static const char *invoke_as =
811#ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
812"%{!S:-o %|.s |\n as %(asm_options) %|.s %A }";
813#else
814"%{!S:-o %|.s |\n as %(asm_options) %m.s %A }";
815#endif
816
817/* Some compilers have limits on line lengths, and the multilib_select
818 and/or multilib_matches strings can be very long, so we build them at
819 run time. */
820static struct obstack multilib_obstack;
821static const char *multilib_select;
822static const char *multilib_matches;
823static const char *multilib_defaults;
824static const char *multilib_exclusions;
825
826/* Check whether a particular argument is a default argument. */
827
828#ifndef MULTILIB_DEFAULTS
829#define MULTILIB_DEFAULTS { "" }
830#endif
831
832static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
833
834#ifndef DRIVER_SELF_SPECS
835#define DRIVER_SELF_SPECS ""
836#endif
837
838static const char *const driver_self_specs[] = { DRIVER_SELF_SPECS };
839
840#ifndef OPTION_DEFAULT_SPECS
841#define OPTION_DEFAULT_SPECS { "", "" }
842#endif
843
844struct default_spec
845{
846 const char *name;
847 const char *spec;
848};
849
850static const struct default_spec
851 option_default_specs[] = { OPTION_DEFAULT_SPECS };
852
853struct user_specs
854{
855 struct user_specs *next;
856 const char *filename;
857};
858
859static struct user_specs *user_specs_head, *user_specs_tail;
860
861#ifndef SWITCH_TAKES_ARG
862#define SWITCH_TAKES_ARG(CHAR) DEFAULT_SWITCH_TAKES_ARG(CHAR)
863#endif
864
865#ifndef WORD_SWITCH_TAKES_ARG
866#define WORD_SWITCH_TAKES_ARG(STR) DEFAULT_WORD_SWITCH_TAKES_ARG (STR)
867#endif
868\f
869#ifdef HAVE_TARGET_EXECUTABLE_SUFFIX
870/* This defines which switches stop a full compilation. */
871#define DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR) \
872 ((CHAR) == 'c' || (CHAR) == 'S')
873
874#ifndef SWITCH_CURTAILS_COMPILATION
875#define SWITCH_CURTAILS_COMPILATION(CHAR) \
876 DEFAULT_SWITCH_CURTAILS_COMPILATION(CHAR)
877#endif
878#endif
879
880/* Record the mapping from file suffixes for compilation specs. */
881
882struct compiler
883{
884 const char *suffix; /* Use this compiler for input files
885 whose names end in this suffix. */
886
887 const char *spec; /* To use this compiler, run this spec. */
888
889 const char *cpp_spec; /* If non-NULL, substitute this spec
890 for `%C', rather than the usual
891 cpp_spec. */
892 const int combinable; /* If nonzero, compiler can deal with
893 multiple source files at once (IMA). */
894 const int needs_preprocessing; /* If nonzero, source files need to
895 be run through a preprocessor. */
896};
897
898/* Pointer to a vector of `struct compiler' that gives the spec for
899 compiling a file, based on its suffix.
900 A file that does not end in any of these suffixes will be passed
901 unchanged to the loader and nothing else will be done to it.
902
903 An entry containing two 0s is used to terminate the vector.
904
905 If multiple entries match a file, the last matching one is used. */
906
907static struct compiler *compilers;
908
909/* Number of entries in `compilers', not counting the null terminator. */
910
911static int n_compilers;
912
913/* The default list of file name suffixes and their compilation specs. */
914
915static const struct compiler default_compilers[] =
916{
917 /* Add lists of suffixes of known languages here. If those languages
918 were not present when we built the driver, we will hit these copies
919 and be given a more meaningful error than "file not used since
920 linking is not done". */
921 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0},
922 {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
923 {".mii", "#Objective-C++", 0, 0, 0},
924 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
925 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
926 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
927 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
928 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
929 {".f", "#Fortran", 0, 0, 0}, {".for", "#Fortran", 0, 0, 0},
930 {".fpp", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
931 {".FOR", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
932 {".f90", "#Fortran", 0, 0, 0}, {".f95", "#Fortran", 0, 0, 0},
933 {".F90", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
934 {".r", "#Ratfor", 0, 0, 0},
935 {".p", "#Pascal", 0, 0, 0}, {".pas", "#Pascal", 0, 0, 0},
936 {".java", "#Java", 0, 0, 0}, {".class", "#Java", 0, 0, 0},
937 {".zip", "#Java", 0, 0, 0}, {".jar", "#Java", 0, 0, 0},
938 /* Next come the entries for C. */
939 {".c", "@c", 0, 1, 1},
940 {"@c",
941 /* cc1 has an integrated ISO C preprocessor. We should invoke the
942 external preprocessor if -save-temps is given. */
943 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
944 %{!E:%{!M:%{!MM:\
945 %{traditional|ftraditional:\
946%eGNU C no longer supports -traditional without -E}\
947 %{!combine:\
948 %{save-temps|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
949 %(cpp_options) -o %{save-temps:%b.i} %{!save-temps:%g.i} \n\
950 cc1 -fpreprocessed %{save-temps:%b.i} %{!save-temps:%g.i} \
951 %(cc1_options)}\
952 %{!save-temps:%{!traditional-cpp:%{!no-integrated-cpp:\
953 cc1 %(cpp_unique_options) %(cc1_options)}}}\
954 %{!fsyntax-only:%(invoke_as)}} \
955 %{combine:\
956 %{save-temps|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
957 %(cpp_options) -o %{save-temps:%b.i} %{!save-temps:%g.i}}\
958 %{!save-temps:%{!traditional-cpp:%{!no-integrated-cpp:\
959 cc1 %(cpp_unique_options) %(cc1_options)}}\
960 %{!fsyntax-only:%(invoke_as)}}}}}}", 0, 1, 1},
961 {"-",
962 "%{!E:%e-E or -x required when input is from standard input}\
963 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
964 {".h", "@c-header", 0, 0, 0},
965 {"@c-header",
966 /* cc1 has an integrated ISO C preprocessor. We should invoke the
967 external preprocessor if -save-temps is given. */
968 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
969 %{!E:%{!M:%{!MM:\
970 %{save-temps|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
971 %(cpp_options) -o %{save-temps:%b.i} %{!save-temps:%g.i} \n\
972 cc1 -fpreprocessed %{save-temps:%b.i} %{!save-temps:%g.i} \
973 %(cc1_options)\
974 -o %g.s %{!o*:--output-pch=%i.gch}\
975 %W{o*:--output-pch=%*}%V}\
976 %{!save-temps:%{!traditional-cpp:%{!no-integrated-cpp:\
977 cc1 %(cpp_unique_options) %(cc1_options)\
978 -o %g.s %{!o*:--output-pch=%i.gch}\
979 %W{o*:--output-pch=%*}%V}}}}}}", 0, 0, 0},
980 {".i", "@cpp-output", 0, 1, 0},
981 {"@cpp-output",
982 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 1, 0},
983 {".s", "@assembler", 0, 1, 0},
984 {"@assembler",
985 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 1, 0},
986 {".S", "@assembler-with-cpp", 0, 1, 0},
987 {"@assembler-with-cpp",
988#ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
989 "%(trad_capable_cpp) -lang-asm %(cpp_options)\
990 %{E|M|MM:%(cpp_debug_options)}\
991 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
992 as %(asm_debug) %(asm_options) %|.s %A }}}}"
993#else
994 "%(trad_capable_cpp) -lang-asm %(cpp_options)\
995 %{E|M|MM:%(cpp_debug_options)}\
996 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
997 as %(asm_debug) %(asm_options) %m.s %A }}}}"
998#endif
999 , 0, 1, 0},
1000
1001#include "specs.h"
1002 /* Mark end of table. */
1003 {0, 0, 0, 0, 0}
1004};
1005
1006/* Number of elements in default_compilers, not counting the terminator. */
1007
1008static const int n_default_compilers = ARRAY_SIZE (default_compilers) - 1;
1009
1010/* A vector of options to give to the linker.
1011 These options are accumulated by %x,
1012 and substituted into the linker command with %X. */
1013static int n_linker_options;
1014static char **linker_options;
1015
1016/* A vector of options to give to the assembler.
1017 These options are accumulated by -Wa,
1018 and substituted into the assembler command with %Y. */
1019static int n_assembler_options;
1020static char **assembler_options;
1021
1022/* A vector of options to give to the preprocessor.
1023 These options are accumulated by -Wp,
1024 and substituted into the preprocessor command with %Z. */
1025static int n_preprocessor_options;
1026static char **preprocessor_options;
1027\f
1028/* Define how to map long options into short ones. */
1029
1030/* This structure describes one mapping. */
1031struct option_map
1032{
1033 /* The long option's name. */
1034 const char *const name;
1035 /* The equivalent short option. */
1036 const char *const equivalent;
1037 /* Argument info. A string of flag chars; NULL equals no options.
1038 a => argument required.
1039 o => argument optional.
1040 j => join argument to equivalent, making one word.
1041 * => require other text after NAME as an argument. */
1042 const char *const arg_info;
1043};
1044
1045/* This is the table of mappings. Mappings are tried sequentially
1046 for each option encountered; the first one that matches, wins. */
1047
1048static const struct option_map option_map[] =
1049 {
1050 {"--all-warnings", "-Wall", 0},
1051 {"--ansi", "-ansi", 0},
1052 {"--assemble", "-S", 0},
1053 {"--assert", "-A", "a"},
1054 {"--classpath", "-fclasspath=", "aj"},
1055 {"--bootclasspath", "-fbootclasspath=", "aj"},
1056 {"--CLASSPATH", "-fclasspath=", "aj"},
1057 {"--combine", "-combine", 0},
1058 {"--comments", "-C", 0},
1059 {"--comments-in-macros", "-CC", 0},
1060 {"--compile", "-c", 0},
1061 {"--debug", "-g", "oj"},
1062 {"--define-macro", "-D", "aj"},
1063 {"--dependencies", "-M", 0},
1064 {"--dump", "-d", "a"},
1065 {"--dumpbase", "-dumpbase", "a"},
1066 {"--encoding", "-fencoding=", "aj"},
1067 {"--entry", "-e", 0},
1068 {"--extra-warnings", "-W", 0},
1069 {"--extdirs", "-fextdirs=", "aj"},
1070 {"--for-assembler", "-Wa", "a"},
1071 {"--for-linker", "-Xlinker", "a"},
1072 {"--force-link", "-u", "a"},
1073 {"--coverage", "-coverage", 0},
1074 {"--imacros", "-imacros", "a"},
1075 {"--include", "-include", "a"},
1076 {"--include-barrier", "-I-", 0},
1077 {"--include-directory", "-I", "aj"},
1078 {"--include-directory-after", "-idirafter", "a"},
1079 {"--include-prefix", "-iprefix", "a"},
1080 {"--include-with-prefix", "-iwithprefix", "a"},
1081 {"--include-with-prefix-before", "-iwithprefixbefore", "a"},
1082 {"--include-with-prefix-after", "-iwithprefix", "a"},
1083 {"--language", "-x", "a"},
1084 {"--library-directory", "-L", "a"},
1085 {"--machine", "-m", "aj"},
1086 {"--machine-", "-m", "*j"},
1087 {"--no-integrated-cpp", "-no-integrated-cpp", 0},
1088 {"--no-line-commands", "-P", 0},
1089 {"--no-precompiled-includes", "-noprecomp", 0},
1090 {"--no-standard-includes", "-nostdinc", 0},
1091 {"--no-standard-libraries", "-nostdlib", 0},
1092 {"--no-warnings", "-w", 0},
1093 {"--optimize", "-O", "oj"},
1094 {"--output", "-o", "a"},
1095 {"--output-class-directory", "-foutput-class-dir=", "ja"},
1096 {"--param", "--param", "a"},
1097 {"--pass-exit-codes", "-pass-exit-codes", 0},
1098 {"--pedantic", "-pedantic", 0},
1099 {"--pedantic-errors", "-pedantic-errors", 0},
1100 {"--pie", "-pie", 0},
1101 {"--pipe", "-pipe", 0},
1102 {"--prefix", "-B", "a"},
1103 {"--preprocess", "-E", 0},
1104 {"--print-search-dirs", "-print-search-dirs", 0},
1105 {"--print-file-name", "-print-file-name=", "aj"},
1106 {"--print-libgcc-file-name", "-print-libgcc-file-name", 0},
1107 {"--print-missing-file-dependencies", "-MG", 0},
1108 {"--print-multi-lib", "-print-multi-lib", 0},
1109 {"--print-multi-directory", "-print-multi-directory", 0},
1110 {"--print-multi-os-directory", "-print-multi-os-directory", 0},
1111 {"--print-prog-name", "-print-prog-name=", "aj"},
1112 {"--profile", "-p", 0},
1113 {"--profile-blocks", "-a", 0},
1114 {"--quiet", "-q", 0},
1115 {"--resource", "-fcompile-resource=", "aj"},
1116 {"--save-temps", "-save-temps", 0},
1117 {"--shared", "-shared", 0},
1118 {"--silent", "-q", 0},
1119 {"--specs", "-specs=", "aj"},
1120 {"--static", "-static", 0},
1121 {"--std", "-std=", "aj"},
1122 {"--symbolic", "-symbolic", 0},
1123 {"--sysroot", "--sysroot=", "aj"},
1124 {"--time", "-time", 0},
1125 {"--trace-includes", "-H", 0},
1126 {"--traditional", "-traditional", 0},
1127 {"--traditional-cpp", "-traditional-cpp", 0},
1128 {"--trigraphs", "-trigraphs", 0},
1129 {"--undefine-macro", "-U", "aj"},
1130 {"--user-dependencies", "-MM", 0},
1131 {"--verbose", "-v", 0},
1132 {"--warn-", "-W", "*j"},
1133 {"--write-dependencies", "-MD", 0},
1134 {"--write-user-dependencies", "-MMD", 0},
1135 {"--", "-f", "*j"}
1136 };
1137\f
1138
1139#ifdef TARGET_OPTION_TRANSLATE_TABLE
1140static const struct {
1141 const char *const option_found;
1142 const char *const replacements;
1143} target_option_translations[] =
1144{
1145 TARGET_OPTION_TRANSLATE_TABLE,
1146 { 0, 0 }
1147};
1148#endif
1149
1150/* Translate the options described by *ARGCP and *ARGVP.
1151 Make a new vector and store it back in *ARGVP,
1152 and store its length in *ARGVC. */
1153
1154static void
1155translate_options (int *argcp, const char *const **argvp)
1156{
1157 int i;
1158 int argc = *argcp;
1159 const char *const *argv = *argvp;
1160 int newvsize = (argc + 2) * 2 * sizeof (const char *);
1161 const char **newv = xmalloc (newvsize);
1162 int newindex = 0;
1163
1164 i = 0;
1165 newv[newindex++] = argv[i++];
1166
1167 while (i < argc)
1168 {
1169#ifdef TARGET_OPTION_TRANSLATE_TABLE
1170 int tott_idx;
1171
1172 for (tott_idx = 0;
1173 target_option_translations[tott_idx].option_found;
1174 tott_idx++)
1175 {
1176 if (strcmp (target_option_translations[tott_idx].option_found,
1177 argv[i]) == 0)
1178 {
1179 int spaces = 1;
1180 const char *sp;
1181 char *np;
1182
1183 for (sp = target_option_translations[tott_idx].replacements;
1184 *sp; sp++)
1185 {
1186 if (*sp == ' ')
1187 spaces ++;
1188 }
1189
1190 newvsize += spaces * sizeof (const char *);
1191 newv = xrealloc (newv, newvsize);
1192
1193 sp = target_option_translations[tott_idx].replacements;
1194 np = xstrdup (sp);
1195
1196 while (1)
1197 {
1198 while (*np == ' ')
1199 np++;
1200 if (*np == 0)
1201 break;
1202 newv[newindex++] = np;
1203 while (*np != ' ' && *np)
1204 np++;
1205 if (*np == 0)
1206 break;
1207 *np++ = 0;
1208 }
1209
1210 i ++;
1211 break;
1212 }
1213 }
1214 if (target_option_translations[tott_idx].option_found)
1215 continue;
1216#endif
1217
1218 /* Translate -- options. */
1219 if (argv[i][0] == '-' && argv[i][1] == '-')
1220 {
1221 size_t j;
1222 /* Find a mapping that applies to this option. */
1223 for (j = 0; j < ARRAY_SIZE (option_map); j++)
1224 {
1225 size_t optlen = strlen (option_map[j].name);
1226 size_t arglen = strlen (argv[i]);
1227 size_t complen = arglen > optlen ? optlen : arglen;
1228 const char *arginfo = option_map[j].arg_info;
1229
1230 if (arginfo == 0)
1231 arginfo = "";
1232
1233 if (!strncmp (argv[i], option_map[j].name, complen))
1234 {
1235 const char *arg = 0;
1236
1237 if (arglen < optlen)
1238 {
1239 size_t k;
1240 for (k = j + 1; k < ARRAY_SIZE (option_map); k++)
1241 if (strlen (option_map[k].name) >= arglen
1242 && !strncmp (argv[i], option_map[k].name, arglen))
1243 {
1244 error ("ambiguous abbreviation %s", argv[i]);
1245 break;
1246 }
1247
1248 if (k != ARRAY_SIZE (option_map))
1249 break;
1250 }
1251
1252 if (arglen > optlen)
1253 {
1254 /* If the option has an argument, accept that. */
1255 if (argv[i][optlen] == '=')
1256 arg = argv[i] + optlen + 1;
1257
1258 /* If this mapping requires extra text at end of name,
1259 accept that as "argument". */
1260 else if (strchr (arginfo, '*') != 0)
1261 arg = argv[i] + optlen;
1262
1263 /* Otherwise, extra text at end means mismatch.
1264 Try other mappings. */
1265 else
1266 continue;
1267 }
1268
1269 else if (strchr (arginfo, '*') != 0)
1270 {
1271 error ("incomplete '%s' option", option_map[j].name);
1272 break;
1273 }
1274
1275 /* Handle arguments. */
1276 if (strchr (arginfo, 'a') != 0)
1277 {
1278 if (arg == 0)
1279 {
1280 if (i + 1 == argc)
1281 {
1282 error ("missing argument to '%s' option",
1283 option_map[j].name);
1284 break;
1285 }
1286
1287 arg = argv[++i];
1288 }
1289 }
1290 else if (strchr (arginfo, '*') != 0)
1291 ;
1292 else if (strchr (arginfo, 'o') == 0)
1293 {
1294 if (arg != 0)
1295 error ("extraneous argument to '%s' option",
1296 option_map[j].name);
1297 arg = 0;
1298 }
1299
1300 /* Store the translation as one argv elt or as two. */
1301 if (arg != 0 && strchr (arginfo, 'j') != 0)
1302 newv[newindex++] = concat (option_map[j].equivalent, arg,
1303 NULL);
1304 else if (arg != 0)
1305 {
1306 newv[newindex++] = option_map[j].equivalent;
1307 newv[newindex++] = arg;
1308 }
1309 else
1310 newv[newindex++] = option_map[j].equivalent;
1311
1312 break;
1313 }
1314 }
1315 i++;
1316 }
1317
1318 /* Handle old-fashioned options--just copy them through,
1319 with their arguments. */
1320 else if (argv[i][0] == '-')
1321 {
1322 const char *p = argv[i] + 1;
1323 int c = *p;
1324 int nskip = 1;
1325
1326 if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
1327 nskip += SWITCH_TAKES_ARG (c) - (p[1] != 0);
1328 else if (WORD_SWITCH_TAKES_ARG (p))
1329 nskip += WORD_SWITCH_TAKES_ARG (p);
1330 else if ((c == 'B' || c == 'b' || c == 'x')
1331 && p[1] == 0)
1332 nskip += 1;
1333 else if (! strcmp (p, "Xlinker"))
1334 nskip += 1;
1335 else if (! strcmp (p, "Xpreprocessor"))
1336 nskip += 1;
1337 else if (! strcmp (p, "Xassembler"))
1338 nskip += 1;
1339
1340 /* Watch out for an option at the end of the command line that
1341 is missing arguments, and avoid skipping past the end of the
1342 command line. */
1343 if (nskip + i > argc)
1344 nskip = argc - i;
1345
1346 while (nskip > 0)
1347 {
1348 newv[newindex++] = argv[i++];
1349 nskip--;
1350 }
1351 }
1352 else
1353 /* Ordinary operands, or +e options. */
1354 newv[newindex++] = argv[i++];
1355 }
1356
1357 newv[newindex] = 0;
1358
1359 *argvp = newv;
1360 *argcp = newindex;
1361}
1362\f
1363static char *
1364skip_whitespace (char *p)
1365{
1366 while (1)
1367 {
1368 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1369 be considered whitespace. */
1370 if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
1371 return p + 1;
1372 else if (*p == '\n' || *p == ' ' || *p == '\t')
1373 p++;
1374 else if (*p == '#')
1375 {
1376 while (*p != '\n')
1377 p++;
1378 p++;
1379 }
1380 else
1381 break;
1382 }
1383
1384 return p;
1385}
1386/* Structures to keep track of prefixes to try when looking for files. */
1387
1388struct prefix_list
1389{
1390 const char *prefix; /* String to prepend to the path. */
1391 struct prefix_list *next; /* Next in linked list. */
1392 int require_machine_suffix; /* Don't use without machine_suffix. */
1393 /* 2 means try both machine_suffix and just_machine_suffix. */
1394 int priority; /* Sort key - priority within list. */
1395 int os_multilib; /* 1 if OS multilib scheme should be used,
1396 0 for GCC multilib scheme. */
1397};
1398
1399struct path_prefix
1400{
1401 struct prefix_list *plist; /* List of prefixes to try */
1402 int max_len; /* Max length of a prefix in PLIST */
1403 const char *name; /* Name of this list (used in config stuff) */
1404};
1405
1406/* List of prefixes to try when looking for executables. */
1407
1408static struct path_prefix exec_prefixes = { 0, 0, "exec" };
1409
1410/* List of prefixes to try when looking for startup (crt0) files. */
1411
1412static struct path_prefix startfile_prefixes = { 0, 0, "startfile" };
1413
1414/* List of prefixes to try when looking for include files. */
1415
1416static struct path_prefix include_prefixes = { 0, 0, "include" };
1417
1418/* Suffix to attach to directories searched for commands.
1419 This looks like `MACHINE/VERSION/'. */
1420
1421static const char *machine_suffix = 0;
1422
1423/* Suffix to attach to directories searched for commands.
1424 This is just `MACHINE/'. */
1425
1426static const char *just_machine_suffix = 0;
1427
1428/* Adjusted value of GCC_EXEC_PREFIX envvar. */
1429
1430static const char *gcc_exec_prefix;
1431
1432/* Adjusted value of standard_libexec_prefix. */
1433
1434static const char *gcc_libexec_prefix;
1435
1436/* Default prefixes to attach to command names. */
1437
1438#ifndef STANDARD_STARTFILE_PREFIX_1
1439#define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1440#endif
1441#ifndef STANDARD_STARTFILE_PREFIX_2
1442#define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1443#endif
1444
144812d8
SS
1445static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
1446static const char *const standard_exec_prefix_1 = "/usr/libexec/gcc/";
1447static const char *const standard_exec_prefix_2 = "/usr/lib/gcc/";
144812d8 1448
144812d8
SS
1449static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1450static const char *const standard_startfile_prefix_1
1451 = STANDARD_STARTFILE_PREFIX_1;
1452static const char *const standard_startfile_prefix_2
1453 = STANDARD_STARTFILE_PREFIX_2;
1454
1455static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1456static const char *tooldir_prefix;
1457
1458static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
1459
1460static const char *standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX;
1461
1462/* Subdirectory to use for locating libraries. Set by
1463 set_multilib_dir based on the compilation options. */
1464
1465static const char *multilib_dir;
1466
1467/* Subdirectory to use for locating libraries in OS conventions. Set by
1468 set_multilib_dir based on the compilation options. */
1469
1470static const char *multilib_os_dir;
1471\f
1472/* Structure to keep track of the specs that have been defined so far.
1473 These are accessed using %(specname) or %[specname] in a compiler
1474 or link spec. */
1475
1476struct spec_list
1477{
1478 /* The following 2 fields must be first */
1479 /* to allow EXTRA_SPECS to be initialized */
1480 const char *name; /* name of the spec. */
1481 const char *ptr; /* available ptr if no static pointer */
1482
1483 /* The following fields are not initialized */
1484 /* by EXTRA_SPECS */
1485 const char **ptr_spec; /* pointer to the spec itself. */
1486 struct spec_list *next; /* Next spec in linked list. */
1487 int name_len; /* length of the name */
1488 int alloc_p; /* whether string was allocated */
1489};
1490
1491#define INIT_STATIC_SPEC(NAME,PTR) \
1492{ NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 }
1493
1494/* List of statically defined specs. */
1495static struct spec_list static_specs[] =
1496{
1497 INIT_STATIC_SPEC ("asm", &asm_spec),
1498 INIT_STATIC_SPEC ("asm_debug", &asm_debug),
1499 INIT_STATIC_SPEC ("asm_final", &asm_final_spec),
1500 INIT_STATIC_SPEC ("asm_options", &asm_options),
1501 INIT_STATIC_SPEC ("invoke_as", &invoke_as),
1502 INIT_STATIC_SPEC ("cpp", &cpp_spec),
1503 INIT_STATIC_SPEC ("cpp_options", &cpp_options),
1504 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options),
1505 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options),
1506 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp),
1507 INIT_STATIC_SPEC ("cc1", &cc1_spec),
1508 INIT_STATIC_SPEC ("cc1_options", &cc1_options),
1509 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec),
1510 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec),
1511 INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec),
1512 INIT_STATIC_SPEC ("endfile", &endfile_spec),
1513 INIT_STATIC_SPEC ("link", &link_spec),
390b4252 1514 INIT_STATIC_SPEC ("pre_lib", &pre_lib_spec),
144812d8
SS
1515 INIT_STATIC_SPEC ("lib", &lib_spec),
1516 INIT_STATIC_SPEC ("mfwrap", &mfwrap_spec),
1517 INIT_STATIC_SPEC ("mflib", &mflib_spec),
1518 INIT_STATIC_SPEC ("libgcc", &libgcc_spec),
1519 INIT_STATIC_SPEC ("startfile", &startfile_spec),
1520 INIT_STATIC_SPEC ("switches_need_spaces", &switches_need_spaces),
1521 INIT_STATIC_SPEC ("cross_compile", &cross_compile),
1522 INIT_STATIC_SPEC ("version", &compiler_version),
1523 INIT_STATIC_SPEC ("multilib", &multilib_select),
1524 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults),
1525 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra),
1526 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches),
1527 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions),
1528 INIT_STATIC_SPEC ("multilib_options", &multilib_options),
1529 INIT_STATIC_SPEC ("linker", &linker_name_spec),
1530 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec),
144812d8
SS
1531 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec),
1532 INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec),
1533 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec),
1534 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec),
1535};
1536
1537#ifdef EXTRA_SPECS /* additional specs needed */
1538/* Structure to keep track of just the first two args of a spec_list.
1539 That is all that the EXTRA_SPECS macro gives us. */
1540struct spec_list_1
1541{
1542 const char *const name;
1543 const char *const ptr;
1544};
1545
1546static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1547static struct spec_list *extra_specs = (struct spec_list *) 0;
1548#endif
1549
1550/* List of dynamically allocates specs that have been defined so far. */
1551
1552static struct spec_list *specs = (struct spec_list *) 0;
1553\f
1554/* List of static spec functions. */
1555
1556static const struct spec_function static_spec_functions[] =
1557{
1558 { "if-exists", if_exists_spec_function },
1559 { "if-exists-else", if_exists_else_spec_function },
1560 { "replace-outfile", replace_outfile_spec_function },
1561 { "version-compare", version_compare_spec_function },
1562 { 0, 0 }
1563};
1564
1565static int processing_spec_function;
1566\f
1567/* Add appropriate libgcc specs to OBSTACK, taking into account
1568 various permutations of -shared-libgcc, -shared, and such. */
1569
1570#if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1571
1572#ifndef USE_LD_AS_NEEDED
1573#define USE_LD_AS_NEEDED 0
1574#endif
1575
1576static void
1577init_gcc_specs (struct obstack *obstack, const char *shared_name,
1578 const char *static_name, const char *eh_name)
1579{
1580 char *buf;
1581
1582 buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name,
1583 "}%{!static:%{!static-libgcc:",
1584#if USE_LD_AS_NEEDED
1585 "%{!shared-libgcc:", static_name,
1586 " --as-needed ", shared_name, " --no-as-needed}"
1587 "%{shared-libgcc:", shared_name, "%{!shared: ", static_name,
1588 "}",
1589#else
1590 "%{!shared:%{!shared-libgcc:", static_name, " ",
1591 eh_name, "}%{shared-libgcc:", shared_name, " ",
1592 static_name, "}}%{shared:",
1593#ifdef LINK_EH_SPEC
1594 "%{shared-libgcc:", shared_name,
1595 "}%{!shared-libgcc:", static_name, "}",
1596#else
1597 shared_name,
1598#endif
1599#endif
1600 "}}}", NULL);
1601
1602 obstack_grow (obstack, buf, strlen (buf));
1603 free (buf);
1604}
1605#endif /* ENABLE_SHARED_LIBGCC */
1606
1607/* Initialize the specs lookup routines. */
1608
1609static void
1610init_spec (void)
1611{
1612 struct spec_list *next = (struct spec_list *) 0;
1613 struct spec_list *sl = (struct spec_list *) 0;
1614 int i;
1615
1616 if (specs)
1617 return; /* Already initialized. */
1618
1619 if (verbose_flag)
1620 notice ("Using built-in specs.\n");
1621
1622#ifdef EXTRA_SPECS
1623 extra_specs = xcalloc (sizeof (struct spec_list),
1624 ARRAY_SIZE (extra_specs_1));
1625
1626 for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--)
1627 {
1628 sl = &extra_specs[i];
1629 sl->name = extra_specs_1[i].name;
1630 sl->ptr = extra_specs_1[i].ptr;
1631 sl->next = next;
1632 sl->name_len = strlen (sl->name);
1633 sl->ptr_spec = &sl->ptr;
1634 next = sl;
1635 }
1636#endif
1637
1638 /* Initialize here, not in definition. The IRIX 6 O32 cc sometimes chokes
1639 on ?: in file-scope variable initializations. */
1640 asm_debug = ASM_DEBUG_SPEC;
1641
1642 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1643 {
1644 sl = &static_specs[i];
1645 sl->next = next;
1646 next = sl;
1647 }
1648
1649#if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1650 /* ??? If neither -shared-libgcc nor --static-libgcc was
1651 seen, then we should be making an educated guess. Some proposed
1652 heuristics for ELF include:
1653
1654 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1655 program will be doing dynamic loading, which will likely
1656 need the shared libgcc.
1657
1658 (2) If "-ldl", then it's also a fair bet that we're doing
1659 dynamic loading.
1660
1661 (3) For each ET_DYN we're linking against (either through -lfoo
1662 or /some/path/foo.so), check to see whether it or one of
1663 its dependencies depends on a shared libgcc.
1664
1665 (4) If "-shared"
1666
1667 If the runtime is fixed to look for program headers instead
1668 of calling __register_frame_info at all, for each object,
1669 use the shared libgcc if any EH symbol referenced.
1670
1671 If crtstuff is fixed to not invoke __register_frame_info
1672 automatically, for each object, use the shared libgcc if
1673 any non-empty unwind section found.
1674
1675 Doing any of this probably requires invoking an external program to
1676 do the actual object file scanning. */
1677 {
1678 const char *p = libgcc_spec;
1679 int in_sep = 1;
1680
1681 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1682 when given the proper command line arguments. */
1683 while (*p)
1684 {
1685 if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
1686 {
1687 init_gcc_specs (&obstack,
1688 "-lgcc_s"
1689#ifdef USE_LIBUNWIND_EXCEPTIONS
1690 " -lunwind"
1691#endif
1692 ,
1693 "-lgcc",
1694 "-lgcc_eh"
1695#ifdef USE_LIBUNWIND_EXCEPTIONS
1696# ifdef HAVE_LD_STATIC_DYNAMIC
1697 " %{!static:-Bstatic} -lunwind %{!static:-Bdynamic}"
1698# else
1699 " -lunwind"
1700# endif
1701#endif
1702 );
1703
1704 p += 5;
1705 in_sep = 0;
1706 }
1707 else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0)
1708 {
1709 /* Ug. We don't know shared library extensions. Hope that
1710 systems that use this form don't do shared libraries. */
1711 init_gcc_specs (&obstack,
1712 "-lgcc_s",
1713 "libgcc.a%s",
1714 "libgcc_eh.a%s"
1715#ifdef USE_LIBUNWIND_EXCEPTIONS
1716 " -lunwind"
1717#endif
1718 );
1719 p += 10;
1720 in_sep = 0;
1721 }
1722 else
1723 {
1724 obstack_1grow (&obstack, *p);
1725 in_sep = (*p == ' ');
1726 p += 1;
1727 }
1728 }
1729
1730 obstack_1grow (&obstack, '\0');
1731 libgcc_spec = XOBFINISH (&obstack, const char *);
1732 }
1733#endif
1734#ifdef USE_AS_TRADITIONAL_FORMAT
1735 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1736 {
1737 static const char tf[] = "--traditional-format ";
1738 obstack_grow (&obstack, tf, sizeof(tf) - 1);
1739 obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
1740 asm_spec = XOBFINISH (&obstack, const char *);
1741 }
1742#endif
1743#ifdef LINK_EH_SPEC
1744 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1745 obstack_grow (&obstack, LINK_EH_SPEC, sizeof(LINK_EH_SPEC) - 1);
1746 obstack_grow0 (&obstack, link_spec, strlen (link_spec));
1747 link_spec = XOBFINISH (&obstack, const char *);
1748#endif
1749
1750 specs = sl;
1751}
1752\f
1753/* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
1754 removed; If the spec starts with a + then SPEC is added to the end of the
1755 current spec. */
1756
1757static void
1758set_spec (const char *name, const char *spec)
1759{
1760 struct spec_list *sl;
1761 const char *old_spec;
1762 int name_len = strlen (name);
1763 int i;
1764
1765 /* If this is the first call, initialize the statically allocated specs. */
1766 if (!specs)
1767 {
1768 struct spec_list *next = (struct spec_list *) 0;
1769 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1770 {
1771 sl = &static_specs[i];
1772 sl->next = next;
1773 next = sl;
1774 }
1775 specs = sl;
1776 }
1777
1778 /* See if the spec already exists. */
1779 for (sl = specs; sl; sl = sl->next)
1780 if (name_len == sl->name_len && !strcmp (sl->name, name))
1781 break;
1782
1783 if (!sl)
1784 {
1785 /* Not found - make it. */
1786 sl = xmalloc (sizeof (struct spec_list));
1787 sl->name = xstrdup (name);
1788 sl->name_len = name_len;
1789 sl->ptr_spec = &sl->ptr;
1790 sl->alloc_p = 0;
1791 *(sl->ptr_spec) = "";
1792 sl->next = specs;
1793 specs = sl;
1794 }
1795
1796 old_spec = *(sl->ptr_spec);
1797 *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
1798 ? concat (old_spec, spec + 1, NULL)
1799 : xstrdup (spec));
1800
1801#ifdef DEBUG_SPECS
1802 if (verbose_flag)
1803 notice ("Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
1804#endif
1805
1806 /* Free the old spec. */
1807 if (old_spec && sl->alloc_p)
1808 free ((void *) old_spec);
1809
1810 sl->alloc_p = 1;
1811}
1812\f
1813/* Accumulate a command (program name and args), and run it. */
1814
1815/* Vector of pointers to arguments in the current line of specifications. */
1816
1817static const char **argbuf;
1818
1819/* Number of elements allocated in argbuf. */
1820
1821static int argbuf_length;
1822
1823/* Number of elements in argbuf currently in use (containing args). */
1824
1825static int argbuf_index;
1826
1827/* Position in the argbuf array containing the name of the output file
1828 (the value associated with the "-o" flag). */
1829
1830static int have_o_argbuf_index = 0;
1831
1832/* Were the options -c or -S passed. */
1833static int have_c = 0;
1834
1835/* Was the option -o passed. */
1836static int have_o = 0;
1837
1838/* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1839 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
1840 it here. */
1841
1842static struct temp_name {
1843 const char *suffix; /* suffix associated with the code. */
1844 int length; /* strlen (suffix). */
1845 int unique; /* Indicates whether %g or %u/%U was used. */
1846 const char *filename; /* associated filename. */
1847 int filename_length; /* strlen (filename). */
1848 struct temp_name *next;
1849} *temp_names;
1850
1851/* Number of commands executed so far. */
1852
1853static int execution_count;
1854
1855/* Number of commands that exited with a signal. */
1856
1857static int signal_count;
1858
1859/* Name with which this program was invoked. */
1860
1861static const char *programname;
1862\f
1863/* Allocate the argument vector. */
1864
1865static void
1866alloc_args (void)
1867{
1868 argbuf_length = 10;
1869 argbuf = xmalloc (argbuf_length * sizeof (const char *));
1870}
1871
1872/* Clear out the vector of arguments (after a command is executed). */
1873
1874static void
1875clear_args (void)
1876{
1877 argbuf_index = 0;
1878}
1879
1880/* Add one argument to the vector at the end.
1881 This is done when a space is seen or at the end of the line.
1882 If DELETE_ALWAYS is nonzero, the arg is a filename
1883 and the file should be deleted eventually.
1884 If DELETE_FAILURE is nonzero, the arg is a filename
1885 and the file should be deleted if this compilation fails. */
1886
1887static void
1888store_arg (const char *arg, int delete_always, int delete_failure)
1889{
1890 if (argbuf_index + 1 == argbuf_length)
1891 argbuf = xrealloc (argbuf, (argbuf_length *= 2) * sizeof (const char *));
1892
1893 argbuf[argbuf_index++] = arg;
1894 argbuf[argbuf_index] = 0;
1895
1896 if (strcmp (arg, "-o") == 0)
1897 have_o_argbuf_index = argbuf_index;
1898 if (delete_always || delete_failure)
1899 record_temp_file (arg, delete_always, delete_failure);
1900}
1901\f
1902/* Load specs from a file name named FILENAME, replacing occurrences of
1903 various different types of line-endings, \r\n, \n\r and just \r, with
1904 a single \n. */
1905
1906static char *
1907load_specs (const char *filename)
1908{
1909 int desc;
1910 int readlen;
1911 struct stat statbuf;
1912 char *buffer;
1913 char *buffer_p;
1914 char *specs;
1915 char *specs_p;
1916
1917 if (verbose_flag)
1918 notice ("Reading specs from %s\n", filename);
1919
1920 /* Open and stat the file. */
1921 desc = open (filename, O_RDONLY, 0);
1922 if (desc < 0)
1923 pfatal_with_name (filename);
1924 if (stat (filename, &statbuf) < 0)
1925 pfatal_with_name (filename);
1926
1927 /* Read contents of file into BUFFER. */
1928 buffer = xmalloc ((unsigned) statbuf.st_size + 1);
1929 readlen = read (desc, buffer, (unsigned) statbuf.st_size);
1930 if (readlen < 0)
1931 pfatal_with_name (filename);
1932 buffer[readlen] = 0;
1933 close (desc);
1934
1935 specs = xmalloc (readlen + 1);
1936 specs_p = specs;
1937 for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
1938 {
1939 int skip = 0;
1940 char c = *buffer_p;
1941 if (c == '\r')
1942 {
1943 if (buffer_p > buffer && *(buffer_p - 1) == '\n') /* \n\r */
1944 skip = 1;
1945 else if (*(buffer_p + 1) == '\n') /* \r\n */
1946 skip = 1;
1947 else /* \r */
1948 c = '\n';
1949 }
1950 if (! skip)
1951 *specs_p++ = c;
1952 }
1953 *specs_p = '\0';
1954
1955 free (buffer);
1956 return (specs);
1957}
1958
1959/* Read compilation specs from a file named FILENAME,
1960 replacing the default ones.
1961
1962 A suffix which starts with `*' is a definition for
1963 one of the machine-specific sub-specs. The "suffix" should be
1964 *asm, *cc1, *cpp, *link, *startfile, etc.
1965 The corresponding spec is stored in asm_spec, etc.,
1966 rather than in the `compilers' vector.
1967
1968 Anything invalid in the file is a fatal error. */
1969
1970static void
1971read_specs (const char *filename, int main_p)
1972{
1973 char *buffer;
1974 char *p;
1975
1976 buffer = load_specs (filename);
1977
1978 /* Scan BUFFER for specs, putting them in the vector. */
1979 p = buffer;
1980 while (1)
1981 {
1982 char *suffix;
1983 char *spec;
1984 char *in, *out, *p1, *p2, *p3;
1985
1986 /* Advance P in BUFFER to the next nonblank nocomment line. */
1987 p = skip_whitespace (p);
1988 if (*p == 0)
1989 break;
1990
1991 /* Is this a special command that starts with '%'? */
1992 /* Don't allow this for the main specs file, since it would
1993 encourage people to overwrite it. */
1994 if (*p == '%' && !main_p)
1995 {
1996 p1 = p;
1997 while (*p && *p != '\n')
1998 p++;
1999
2000 /* Skip '\n'. */
2001 p++;
2002
2003 if (!strncmp (p1, "%include", sizeof ("%include") - 1)
2004 && (p1[sizeof "%include" - 1] == ' '
2005 || p1[sizeof "%include" - 1] == '\t'))
2006 {
2007 char *new_filename;
2008
2009 p1 += sizeof ("%include");
2010 while (*p1 == ' ' || *p1 == '\t')
2011 p1++;
2012
2013 if (*p1++ != '<' || p[-2] != '>')
2014 fatal ("specs %%include syntax malformed after %ld characters",
2015 (long) (p1 - buffer + 1));
2016
2017 p[-2] = '\0';
2018 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, 0);
2019 read_specs (new_filename ? new_filename : p1, FALSE);
2020 continue;
2021 }
2022 else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
2023 && (p1[sizeof "%include_noerr" - 1] == ' '
2024 || p1[sizeof "%include_noerr" - 1] == '\t'))
2025 {
2026 char *new_filename;
2027
2028 p1 += sizeof "%include_noerr";
2029 while (*p1 == ' ' || *p1 == '\t')
2030 p1++;
2031
2032 if (*p1++ != '<' || p[-2] != '>')
2033 fatal ("specs %%include syntax malformed after %ld characters",
2034 (long) (p1 - buffer + 1));
2035
2036 p[-2] = '\0';
2037 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, 0);
2038 if (new_filename)
2039 read_specs (new_filename, FALSE);
2040 else if (verbose_flag)
2041 notice ("could not find specs file %s\n", p1);
2042 continue;
2043 }
2044 else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
2045 && (p1[sizeof "%rename" - 1] == ' '
2046 || p1[sizeof "%rename" - 1] == '\t'))
2047 {
2048 int name_len;
2049 struct spec_list *sl;
2050 struct spec_list *newsl;
2051
2052 /* Get original name. */
2053 p1 += sizeof "%rename";
2054 while (*p1 == ' ' || *p1 == '\t')
2055 p1++;
2056
2057 if (! ISALPHA ((unsigned char) *p1))
2058 fatal ("specs %%rename syntax malformed after %ld characters",
2059 (long) (p1 - buffer));
2060
2061 p2 = p1;
2062 while (*p2 && !ISSPACE ((unsigned char) *p2))
2063 p2++;
2064
2065 if (*p2 != ' ' && *p2 != '\t')
2066 fatal ("specs %%rename syntax malformed after %ld characters",
2067 (long) (p2 - buffer));
2068
2069 name_len = p2 - p1;
2070 *p2++ = '\0';
2071 while (*p2 == ' ' || *p2 == '\t')
2072 p2++;
2073
2074 if (! ISALPHA ((unsigned char) *p2))
2075 fatal ("specs %%rename syntax malformed after %ld characters",
2076 (long) (p2 - buffer));
2077
2078 /* Get new spec name. */
2079 p3 = p2;
2080 while (*p3 && !ISSPACE ((unsigned char) *p3))
2081 p3++;
2082
2083 if (p3 != p - 1)
2084 fatal ("specs %%rename syntax malformed after %ld characters",
2085 (long) (p3 - buffer));
2086 *p3 = '\0';
2087
2088 for (sl = specs; sl; sl = sl->next)
2089 if (name_len == sl->name_len && !strcmp (sl->name, p1))
2090 break;
2091
2092 if (!sl)
2093 fatal ("specs %s spec was not found to be renamed", p1);
2094
2095 if (strcmp (p1, p2) == 0)
2096 continue;
2097
2098 for (newsl = specs; newsl; newsl = newsl->next)
2099 if (strcmp (newsl->name, p2) == 0)
2100 fatal ("%s: attempt to rename spec '%s' to already defined spec '%s'",
2101 filename, p1, p2);
2102
2103 if (verbose_flag)
2104 {
2105 notice ("rename spec %s to %s\n", p1, p2);
2106#ifdef DEBUG_SPECS
2107 notice ("spec is '%s'\n\n", *(sl->ptr_spec));
2108#endif
2109 }
2110
2111 set_spec (p2, *(sl->ptr_spec));
2112 if (sl->alloc_p)
2113 free ((void *) *(sl->ptr_spec));
2114
2115 *(sl->ptr_spec) = "";
2116 sl->alloc_p = 0;
2117 continue;
2118 }
2119 else
2120 fatal ("specs unknown %% command after %ld characters",
2121 (long) (p1 - buffer));
2122 }
2123
2124 /* Find the colon that should end the suffix. */
2125 p1 = p;
2126 while (*p1 && *p1 != ':' && *p1 != '\n')
2127 p1++;
2128
2129 /* The colon shouldn't be missing. */
2130 if (*p1 != ':')
2131 fatal ("specs file malformed after %ld characters",
2132 (long) (p1 - buffer));
2133
2134 /* Skip back over trailing whitespace. */
2135 p2 = p1;
2136 while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
2137 p2--;
2138
2139 /* Copy the suffix to a string. */
2140 suffix = save_string (p, p2 - p);
2141 /* Find the next line. */
2142 p = skip_whitespace (p1 + 1);
2143 if (p[1] == 0)
2144 fatal ("specs file malformed after %ld characters",
2145 (long) (p - buffer));
2146
2147 p1 = p;
2148 /* Find next blank line or end of string. */
2149 while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
2150 p1++;
2151
2152 /* Specs end at the blank line and do not include the newline. */
2153 spec = save_string (p, p1 - p);
2154 p = p1;
2155
2156 /* Delete backslash-newline sequences from the spec. */
2157 in = spec;
2158 out = spec;
2159 while (*in != 0)
2160 {
2161 if (in[0] == '\\' && in[1] == '\n')
2162 in += 2;
2163 else if (in[0] == '#')
2164 while (*in && *in != '\n')
2165 in++;
2166
2167 else
2168 *out++ = *in++;
2169 }
2170 *out = 0;
2171
2172 if (suffix[0] == '*')
2173 {
2174 if (! strcmp (suffix, "*link_command"))
2175 link_command_spec = spec;
2176 else
2177 set_spec (suffix + 1, spec);
2178 }
2179 else
2180 {
2181 /* Add this pair to the vector. */
2182 compilers
2183 = xrealloc (compilers,
2184 (n_compilers + 2) * sizeof (struct compiler));
2185
2186 compilers[n_compilers].suffix = suffix;
2187 compilers[n_compilers].spec = spec;
2188 n_compilers++;
2189 memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
2190 }
2191
2192 if (*suffix == 0)
2193 link_command_spec = spec;
2194 }
2195
2196 if (link_command_spec == 0)
2197 fatal ("spec file has no spec for linking");
2198}
2199\f
2200/* Record the names of temporary files we tell compilers to write,
2201 and delete them at the end of the run. */
2202
2203/* This is the common prefix we use to make temp file names.
2204 It is chosen once for each run of this program.
2205 It is substituted into a spec by %g or %j.
2206 Thus, all temp file names contain this prefix.
2207 In practice, all temp file names start with this prefix.
2208
2209 This prefix comes from the envvar TMPDIR if it is defined;
2210 otherwise, from the P_tmpdir macro if that is defined;
2211 otherwise, in /usr/tmp or /tmp;
2212 or finally the current directory if all else fails. */
2213
2214static const char *temp_filename;
2215
2216/* Length of the prefix. */
2217
2218static int temp_filename_length;
2219
2220/* Define the list of temporary files to delete. */
2221
2222struct temp_file
2223{
2224 const char *name;
2225 struct temp_file *next;
2226};
2227
2228/* Queue of files to delete on success or failure of compilation. */
2229static struct temp_file *always_delete_queue;
2230/* Queue of files to delete on failure of compilation. */
2231static struct temp_file *failure_delete_queue;
2232
2233/* Record FILENAME as a file to be deleted automatically.
2234 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2235 otherwise delete it in any case.
2236 FAIL_DELETE nonzero means delete it if a compilation step fails;
2237 otherwise delete it in any case. */
2238
2239void
2240record_temp_file (const char *filename, int always_delete, int fail_delete)
2241{
2242 char *const name = xstrdup (filename);
2243
2244 if (always_delete)
2245 {
2246 struct temp_file *temp;
2247 for (temp = always_delete_queue; temp; temp = temp->next)
2248 if (! strcmp (name, temp->name))
2249 goto already1;
2250
2251 temp = xmalloc (sizeof (struct temp_file));
2252 temp->next = always_delete_queue;
2253 temp->name = name;
2254 always_delete_queue = temp;
2255
2256 already1:;
2257 }
2258
2259 if (fail_delete)
2260 {
2261 struct temp_file *temp;
2262 for (temp = failure_delete_queue; temp; temp = temp->next)
2263 if (! strcmp (name, temp->name))
2264 goto already2;
2265
2266 temp = xmalloc (sizeof (struct temp_file));
2267 temp->next = failure_delete_queue;
2268 temp->name = name;
2269 failure_delete_queue = temp;
2270
2271 already2:;
2272 }
2273}
2274
2275/* Delete all the temporary files whose names we previously recorded. */
2276
2277#ifndef DELETE_IF_ORDINARY
2278#define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2279do \
2280 { \
2281 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2282 if (unlink (NAME) < 0) \
2283 if (VERBOSE_FLAG) \
2284 perror_with_name (NAME); \
2285 } while (0)
2286#endif
2287
2288static void
2289delete_if_ordinary (const char *name)
2290{
2291 struct stat st;
2292#ifdef DEBUG
2293 int i, c;
2294
2295 printf ("Delete %s? (y or n) ", name);
2296 fflush (stdout);
2297 i = getchar ();
2298 if (i != '\n')
2299 while ((c = getchar ()) != '\n' && c != EOF)
2300 ;
2301
2302 if (i == 'y' || i == 'Y')
2303#endif /* DEBUG */
2304 DELETE_IF_ORDINARY (name, st, verbose_flag);
2305}
2306
2307static void
2308delete_temp_files (void)
2309{
2310 struct temp_file *temp;
2311
2312 for (temp = always_delete_queue; temp; temp = temp->next)
2313 delete_if_ordinary (temp->name);
2314 always_delete_queue = 0;
2315}
2316
2317/* Delete all the files to be deleted on error. */
2318
2319static void
2320delete_failure_queue (void)
2321{
2322 struct temp_file *temp;
2323
2324 for (temp = failure_delete_queue; temp; temp = temp->next)
2325 delete_if_ordinary (temp->name);
2326}
2327
2328static void
2329clear_failure_queue (void)
2330{
2331 failure_delete_queue = 0;
2332}
2333\f
2334/* Build a list of search directories from PATHS.
2335 PREFIX is a string to prepend to the list.
2336 If CHECK_DIR_P is nonzero we ensure the directory exists.
2337 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2338 It is also used by the --print-search-dirs flag. */
2339
2340static char *
2341build_search_list (struct path_prefix *paths, const char *prefix,
2342 int check_dir_p)
2343{
2344 int suffix_len = (machine_suffix) ? strlen (machine_suffix) : 0;
2345 int just_suffix_len
2346 = (just_machine_suffix) ? strlen (just_machine_suffix) : 0;
2347 int first_time = TRUE;
2348 struct prefix_list *pprefix;
2349
2350 obstack_grow (&collect_obstack, prefix, strlen (prefix));
2351 obstack_1grow (&collect_obstack, '=');
2352
2353 for (pprefix = paths->plist; pprefix != 0; pprefix = pprefix->next)
2354 {
2355 int len = strlen (pprefix->prefix);
2356
2357 if (machine_suffix
2358 && (! check_dir_p
2359 || is_directory (pprefix->prefix, machine_suffix, 0)))
2360 {
2361 if (!first_time)
2362 obstack_1grow (&collect_obstack, PATH_SEPARATOR);
2363
2364 first_time = FALSE;
2365 obstack_grow (&collect_obstack, pprefix->prefix, len);
2366 obstack_grow (&collect_obstack, machine_suffix, suffix_len);
2367 }
2368
2369 if (just_machine_suffix
2370 && pprefix->require_machine_suffix == 2
2371 && (! check_dir_p
2372 || is_directory (pprefix->prefix, just_machine_suffix, 0)))
2373 {
2374 if (! first_time)
2375 obstack_1grow (&collect_obstack, PATH_SEPARATOR);
2376
2377 first_time = FALSE;
2378 obstack_grow (&collect_obstack, pprefix->prefix, len);
2379 obstack_grow (&collect_obstack, just_machine_suffix,
2380 just_suffix_len);
2381 }
2382
2383 if (! pprefix->require_machine_suffix)
2384 {
2385 if (! first_time)
2386 obstack_1grow (&collect_obstack, PATH_SEPARATOR);
2387
2388 first_time = FALSE;
2389 obstack_grow (&collect_obstack, pprefix->prefix, len);
2390 }
2391 }
2392
2393 obstack_1grow (&collect_obstack, '\0');
2394 return XOBFINISH (&collect_obstack, char *);
2395}
2396
2397/* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2398 for collect. */
2399
2400static void
2401putenv_from_prefixes (struct path_prefix *paths, const char *env_var)
2402{
2403 putenv (build_search_list (paths, env_var, 1));
2404}
2405\f
2406/* Check whether NAME can be accessed in MODE. This is like access,
2407 except that it never considers directories to be executable. */
2408
2409static int
2410access_check (const char *name, int mode)
2411{
2412 if (mode == X_OK)
2413 {
2414 struct stat st;
2415
2416 if (stat (name, &st) < 0
2417 || S_ISDIR (st.st_mode))
2418 return -1;
2419 }
2420
2421 return access (name, mode);
2422}
2423
2424/* Search for NAME using the prefix list PREFIXES. MODE is passed to
2425 access to check permissions.
2426 Return 0 if not found, otherwise return its name, allocated with malloc. */
2427
2428static char *
2429find_a_file (struct path_prefix *pprefix, const char *name, int mode,
2430 int multilib)
2431{
2432 char *temp;
2433 const char *const file_suffix =
2434 ((mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "");
2435 struct prefix_list *pl;
2436 int len = pprefix->max_len + strlen (name) + strlen (file_suffix) + 1;
2437 const char *multilib_name, *multilib_os_name;
2438
2439#ifdef DEFAULT_ASSEMBLER
2440 if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
2441 return xstrdup (DEFAULT_ASSEMBLER);
2442#endif
2443
2444#ifdef DEFAULT_LINKER
2445 if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0)
2446 return xstrdup (DEFAULT_LINKER);
2447#endif
2448
2449 if (machine_suffix)
2450 len += strlen (machine_suffix);
2451
2452 multilib_name = name;
2453 multilib_os_name = name;
2454 if (multilib && multilib_os_dir)
2455 {
2456 int len1 = multilib_dir ? strlen (multilib_dir) + 1 : 0;
2457 int len2 = strlen (multilib_os_dir) + 1;
2458
2459 len += len1 > len2 ? len1 : len2;
2460 if (multilib_dir)
2461 multilib_name = ACONCAT ((multilib_dir, dir_separator_str, name,
2462 NULL));
2463 if (strcmp (multilib_os_dir, ".") != 0)
2464 multilib_os_name = ACONCAT ((multilib_os_dir, dir_separator_str, name,
2465 NULL));
2466 }
2467
2468 temp = xmalloc (len);
2469
2470 /* Determine the filename to execute (special case for absolute paths). */
2471
2472 if (IS_ABSOLUTE_PATH (name))
2473 {
2474 if (access (name, mode) == 0)
2475 {
2476 strcpy (temp, name);
2477 return temp;
2478 }
2479 }
2480 else
2481 for (pl = pprefix->plist; pl; pl = pl->next)
2482 {
2483 const char *this_name
2484 = pl->os_multilib ? multilib_os_name : multilib_name;
2485
2486 if (machine_suffix)
2487 {
2488 /* Some systems have a suffix for executable files.
2489 So try appending that first. */
2490 if (file_suffix[0] != 0)
2491 {
2492 strcpy (temp, pl->prefix);
2493 strcat (temp, machine_suffix);
2494 strcat (temp, multilib_name);
2495 strcat (temp, file_suffix);
2496 if (access_check (temp, mode) == 0)
2497 return temp;
2498 }
2499
2500 /* Now try just the multilib_name. */
2501 strcpy (temp, pl->prefix);
2502 strcat (temp, machine_suffix);
2503 strcat (temp, multilib_name);
2504 if (access_check (temp, mode) == 0)
2505 return temp;
2506 }
2507
2508 /* Certain prefixes are tried with just the machine type,
2509 not the version. This is used for finding as, ld, etc. */
2510 if (just_machine_suffix && pl->require_machine_suffix == 2)
2511 {
2512 /* Some systems have a suffix for executable files.
2513 So try appending that first. */
2514 if (file_suffix[0] != 0)
2515 {
2516 strcpy (temp, pl->prefix);
2517 strcat (temp, just_machine_suffix);
2518 strcat (temp, multilib_name);
2519 strcat (temp, file_suffix);
2520 if (access_check (temp, mode) == 0)
2521 return temp;
2522 }
2523
2524 strcpy (temp, pl->prefix);
2525 strcat (temp, just_machine_suffix);
2526 strcat (temp, multilib_name);
2527 if (access_check (temp, mode) == 0)
2528 return temp;
2529 }
2530
2531 /* Certain prefixes can't be used without the machine suffix
2532 when the machine or version is explicitly specified. */
2533 if (! pl->require_machine_suffix)
2534 {
2535 /* Some systems have a suffix for executable files.
2536 So try appending that first. */
2537 if (file_suffix[0] != 0)
2538 {
2539 strcpy (temp, pl->prefix);
2540 strcat (temp, this_name);
2541 strcat (temp, file_suffix);
2542 if (access_check (temp, mode) == 0)
2543 return temp;
2544 }
2545
2546 strcpy (temp, pl->prefix);
2547 strcat (temp, this_name);
2548 if (access_check (temp, mode) == 0)
2549 return temp;
2550 }
2551 }
2552
2553 free (temp);
2554 return 0;
2555}
2556
2557/* Ranking of prefixes in the sort list. -B prefixes are put before
2558 all others. */
2559
2560enum path_prefix_priority
2561{
2562 PREFIX_PRIORITY_B_OPT,
2563 PREFIX_PRIORITY_LAST
2564};
2565
2566/* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
2567 order according to PRIORITY. Within each PRIORITY, new entries are
2568 appended.
2569
2570 If WARN is nonzero, we will warn if no file is found
2571 through this prefix. WARN should point to an int
2572 which will be set to 1 if this entry is used.
2573
2574 COMPONENT is the value to be passed to update_path.
2575
2576 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2577 the complete value of machine_suffix.
2578 2 means try both machine_suffix and just_machine_suffix. */
2579
2580static void
2581add_prefix (struct path_prefix *pprefix, const char *prefix,
2582 const char *component, /* enum prefix_priority */ int priority,
2583 int require_machine_suffix, int os_multilib)
2584{
2585 struct prefix_list *pl, **prev;
2586 int len;
2587
2588 for (prev = &pprefix->plist;
2589 (*prev) != NULL && (*prev)->priority <= priority;
2590 prev = &(*prev)->next)
2591 ;
2592
2593 /* Keep track of the longest prefix. */
2594
2595 prefix = update_path (prefix, component);
2596 len = strlen (prefix);
2597 if (len > pprefix->max_len)
2598 pprefix->max_len = len;
2599
2600 pl = xmalloc (sizeof (struct prefix_list));
2601 pl->prefix = prefix;
2602 pl->require_machine_suffix = require_machine_suffix;
2603 pl->priority = priority;
2604 pl->os_multilib = os_multilib;
2605
2606 /* Insert after PREV. */
2607 pl->next = (*prev);
2608 (*prev) = pl;
2609}
2610
2611/* Same as add_prefix, but prepending target_system_root to prefix. */
2612static void
2613add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
2614 const char *component,
2615 /* enum prefix_priority */ int priority,
2616 int require_machine_suffix, int os_multilib)
2617{
2618 if (!IS_ABSOLUTE_PATH (prefix))
2619 fatal ("system path '%s' is not absolute", prefix);
2620
2621 if (target_system_root)
2622 {
2623 if (target_sysroot_suffix)
2624 prefix = concat (target_sysroot_suffix, prefix, NULL);
2625 prefix = concat (target_system_root, prefix, NULL);
2626
2627 /* We have to override this because GCC's notion of sysroot
2628 moves along with GCC. */
2629 component = "GCC";
2630 }
2631
2632 add_prefix (pprefix, prefix, component, priority,
2633 require_machine_suffix, os_multilib);
2634}
2635\f
2636/* Execute the command specified by the arguments on the current line of spec.
2637 When using pipes, this includes several piped-together commands
2638 with `|' between them.
2639
2640 Return 0 if successful, -1 if failed. */
2641
2642static int
2643execute (void)
2644{
2645 int i;
2646 int n_commands; /* # of command. */
2647 char *string;
2648 struct pex_obj *pex;
2649 struct command
2650 {
2651 const char *prog; /* program name. */
2652 const char **argv; /* vector of args. */
2653 };
2654
2655 struct command *commands; /* each command buffer with above info. */
2656
2657 gcc_assert (!processing_spec_function);
2658
2659 /* Count # of piped commands. */
2660 for (n_commands = 1, i = 0; i < argbuf_index; i++)
2661 if (strcmp (argbuf[i], "|") == 0)
2662 n_commands++;
2663
2664 /* Get storage for each command. */
2665 commands = alloca (n_commands * sizeof (struct command));
2666
2667 /* Split argbuf into its separate piped processes,
2668 and record info about each one.
2669 Also search for the programs that are to be run. */
2670
2671 commands[0].prog = argbuf[0]; /* first command. */
2672 commands[0].argv = &argbuf[0];
2673 string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, 0);
2674
2675 if (string)
2676 commands[0].argv[0] = string;
2677
2678 for (n_commands = 1, i = 0; i < argbuf_index; i++)
2679 if (strcmp (argbuf[i], "|") == 0)
2680 { /* each command. */
2681#if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2682 fatal ("-pipe not supported");
2683#endif
2684 argbuf[i] = 0; /* termination of command args. */
2685 commands[n_commands].prog = argbuf[i + 1];
2686 commands[n_commands].argv = &argbuf[i + 1];
2687 string = find_a_file (&exec_prefixes, commands[n_commands].prog,
2688 X_OK, 0);
2689 if (string)
2690 commands[n_commands].argv[0] = string;
2691 n_commands++;
2692 }
2693
2694 argbuf[argbuf_index] = 0;
2695
2696 /* If -v, print what we are about to do, and maybe query. */
2697
2698 if (verbose_flag)
2699 {
2700 /* For help listings, put a blank line between sub-processes. */
2701 if (print_help_list)
2702 fputc ('\n', stderr);
2703
2704 /* Print each piped command as a separate line. */
2705 for (i = 0; i < n_commands; i++)
2706 {
2707 const char *const *j;
2708
2709 if (verbose_only_flag)
2710 {
2711 for (j = commands[i].argv; *j; j++)
2712 {
2713 const char *p;
2714 fprintf (stderr, " \"");
2715 for (p = *j; *p; ++p)
2716 {
2717 if (*p == '"' || *p == '\\' || *p == '$')
2718 fputc ('\\', stderr);
2719 fputc (*p, stderr);
2720 }
2721 fputc ('"', stderr);
2722 }
2723 }
2724 else
2725 for (j = commands[i].argv; *j; j++)
2726 fprintf (stderr, " %s", *j);
2727
2728 /* Print a pipe symbol after all but the last command. */
2729 if (i + 1 != n_commands)
2730 fprintf (stderr, " |");
2731 fprintf (stderr, "\n");
2732 }
2733 fflush (stderr);
2734 if (verbose_only_flag != 0)
2735 {
2736 /* verbose_only_flag should act as if the spec was
2737 executed, so increment execution_count before
2738 returning. This prevents spurious warnings about
2739 unused linker input files, etc. */
2740 execution_count++;
2741 return 0;
2742 }
2743#ifdef DEBUG
2744 notice ("\nGo ahead? (y or n) ");
2745 fflush (stderr);
2746 i = getchar ();
2747 if (i != '\n')
2748 while (getchar () != '\n')
2749 ;
2750
2751 if (i != 'y' && i != 'Y')
2752 return 0;
2753#endif /* DEBUG */
2754 }
2755
2756#ifdef ENABLE_VALGRIND_CHECKING
2757 /* Run the each command through valgrind. To simplify prepending the
2758 path to valgrind and the option "-q" (for quiet operation unless
2759 something triggers), we allocate a separate argv array. */
2760
2761 for (i = 0; i < n_commands; i++)
2762 {
2763 const char **argv;
2764 int argc;
2765 int j;
2766
2767 for (argc = 0; commands[i].argv[argc] != NULL; argc++)
2768 ;
2769
2770 argv = alloca ((argc + 3) * sizeof (char *));
2771
2772 argv[0] = VALGRIND_PATH;
2773 argv[1] = "-q";
2774 for (j = 2; j < argc + 2; j++)
2775 argv[j] = commands[i].argv[j - 2];
2776 argv[j] = NULL;
2777
2778 commands[i].argv = argv;
2779 commands[i].prog = argv[0];
2780 }
2781#endif
2782
2783 /* Run each piped subprocess. */
2784
2785 pex = pex_init (PEX_USE_PIPES | (report_times ? PEX_RECORD_TIMES : 0),
2786 programname, temp_filename);
2787 if (pex == NULL)
2788 pfatal_with_name (_("pex_init failed"));
2789
2790 for (i = 0; i < n_commands; i++)
2791 {
2792 const char *errmsg;
2793 int err;
2794 const char *string = commands[i].argv[0];
2795
2796 errmsg = pex_run (pex,
2797 ((i + 1 == n_commands ? PEX_LAST : 0)
2798 | (string == commands[i].prog ? PEX_SEARCH : 0)),
2799 string, (char * const *) commands[i].argv,
2800 NULL, NULL, &err);
2801 if (errmsg != NULL)
2802 {
2803 if (err == 0)
2804 fatal (errmsg);
2805 else
2806 {
2807 errno = err;
2808 pfatal_with_name (errmsg);
2809 }
2810 }
2811
2812 if (string != commands[i].prog)
2813 free ((void *) string);
2814 }
2815
2816 execution_count++;
2817
2818 /* Wait for all the subprocesses to finish. */
2819
2820 {
2821 int *statuses;
2822 struct pex_time *times = NULL;
2823 int ret_code = 0;
2824
2825 statuses = alloca (n_commands * sizeof (int));
2826 if (!pex_get_status (pex, n_commands, statuses))
2827 pfatal_with_name (_("failed to get exit status"));
2828
2829 if (report_times)
2830 {
2831 times = alloca (n_commands * sizeof (struct pex_time));
2832 if (!pex_get_times (pex, n_commands, times))
2833 pfatal_with_name (_("failed to get process times"));
2834 }
2835
2836 pex_free (pex);
2837
2838 for (i = 0; i < n_commands; ++i)
2839 {
2840 int status = statuses[i];
2841
2842 if (WIFSIGNALED (status))
2843 {
2844#ifdef SIGPIPE
2845 /* SIGPIPE is a special case. It happens in -pipe mode
2846 when the compiler dies before the preprocessor is done,
2847 or the assembler dies before the compiler is done.
2848 There's generally been an error already, and this is
2849 just fallout. So don't generate another error unless
2850 we would otherwise have succeeded. */
2851 if (WTERMSIG (status) == SIGPIPE
2852 && (signal_count || greatest_status >= MIN_FATAL_STATUS))
2853 ;
2854 else
2855#endif
2856 fatal ("\
2857Internal error: %s (program %s)\n\
2858Please submit a full bug report.\n\
2859See %s for instructions.",
2860 strsignal (WTERMSIG (status)), commands[i].prog,
2861 bug_report_url);
2862 signal_count++;
2863 ret_code = -1;
2864 }
2865 else if (WIFEXITED (status)
2866 && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
2867 {
2868 if (WEXITSTATUS (status) > greatest_status)
2869 greatest_status = WEXITSTATUS (status);
2870 ret_code = -1;
2871 }
2872
2873 if (report_times)
2874 {
2875 struct pex_time *pt = &times[i];
2876 double ut, st;
2877
2878 ut = ((double) pt->user_seconds
2879 + (double) pt->user_microseconds / 1.0e6);
2880 st = ((double) pt->system_seconds
2881 + (double) pt->system_microseconds / 1.0e6);
2882
2883 if (ut + st != 0)
2884 notice ("# %s %.2f %.2f\n", commands[i].prog, ut, st);
2885 }
2886 }
2887
2888 return ret_code;
2889 }
2890}
2891\f
2892/* Find all the switches given to us
2893 and make a vector describing them.
2894 The elements of the vector are strings, one per switch given.
2895 If a switch uses following arguments, then the `part1' field
2896 is the switch itself and the `args' field
2897 is a null-terminated vector containing the following arguments.
2898 The `live_cond' field is:
2899 0 when initialized
2900 1 if the switch is true in a conditional spec,
2901 -1 if false (overridden by a later switch)
2902 -2 if this switch should be ignored (used in %<S)
2903 The `validated' field is nonzero if any spec has looked at this switch;
2904 if it remains zero at the end of the run, it must be meaningless. */
2905
2906#define SWITCH_OK 0
2907#define SWITCH_FALSE -1
2908#define SWITCH_IGNORE -2
2909#define SWITCH_LIVE 1
2910
2911struct switchstr
2912{
2913 const char *part1;
2914 const char **args;
2915 int live_cond;
2916 unsigned char validated;
2917 unsigned char ordering;
2918};
2919
2920static struct switchstr *switches;
2921
2922static int n_switches;
2923
2924/* Language is one of three things:
2925
2926 1) The name of a real programming language.
2927 2) NULL, indicating that no one has figured out
2928 what it is yet.
2929 3) '*', indicating that the file should be passed
2930 to the linker. */
2931struct infile
2932{
2933 const char *name;
2934 const char *language;
2935 struct compiler *incompiler;
2936 bool compiled;
2937 bool preprocessed;
2938};
2939
2940/* Also a vector of input files specified. */
2941
2942static struct infile *infiles;
2943
2944int n_infiles;
2945
2946/* True if multiple input files are being compiled to a single
2947 assembly file. */
2948
2949static bool combine_inputs;
2950
2951/* This counts the number of libraries added by lang_specific_driver, so that
2952 we can tell if there were any user supplied any files or libraries. */
2953
2954static int added_libraries;
2955
2956/* And a vector of corresponding output files is made up later. */
2957
2958const char **outfiles;
2959\f
2960#if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2961
2962/* Convert NAME to a new name if it is the standard suffix. DO_EXE
2963 is true if we should look for an executable suffix. DO_OBJ
2964 is true if we should look for an object suffix. */
2965
2966static const char *
2967convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
2968 int do_obj ATTRIBUTE_UNUSED)
2969{
2970#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2971 int i;
2972#endif
2973 int len;
2974
2975 if (name == NULL)
2976 return NULL;
2977
2978 len = strlen (name);
2979
2980#ifdef HAVE_TARGET_OBJECT_SUFFIX
2981 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
2982 if (do_obj && len > 2
2983 && name[len - 2] == '.'
2984 && name[len - 1] == 'o')
2985 {
2986 obstack_grow (&obstack, name, len - 2);
2987 obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
2988 name = XOBFINISH (&obstack, const char *);
2989 }
2990#endif
2991
2992#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2993 /* If there is no filetype, make it the executable suffix (which includes
2994 the "."). But don't get confused if we have just "-o". */
2995 if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
2996 return name;
2997
2998 for (i = len - 1; i >= 0; i--)
2999 if (IS_DIR_SEPARATOR (name[i]))
3000 break;
3001
3002 for (i++; i < len; i++)
3003 if (name[i] == '.')
3004 return name;
3005
3006 obstack_grow (&obstack, name, len);
3007 obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
3008 strlen (TARGET_EXECUTABLE_SUFFIX));
3009 name = XOBFINISH (&obstack, const char *);
3010#endif
3011
3012 return name;
3013}
3014#endif
3015\f
3016/* Display the command line switches accepted by gcc. */
3017static void
3018display_help (void)
3019{
3020 printf (_("Usage: %s [options] file...\n"), programname);
3021 fputs (_("Options:\n"), stdout);
3022
3023 fputs (_(" -pass-exit-codes Exit with highest error code from a phase\n"), stdout);
3024 fputs (_(" --help Display this information\n"), stdout);
3025 fputs (_(" --target-help Display target specific command line options\n"), stdout);
3026 if (! verbose_flag)
3027 fputs (_(" (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
3028 fputs (_(" -dumpspecs Display all of the built in spec strings\n"), stdout);
3029 fputs (_(" -dumpversion Display the version of the compiler\n"), stdout);
3030 fputs (_(" -dumpmachine Display the compiler's target processor\n"), stdout);
3031 fputs (_(" -print-search-dirs Display the directories in the compiler's search path\n"), stdout);
3032 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library\n"), stdout);
3033 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>\n"), stdout);
3034 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>\n"), stdout);
3035 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc\n"), stdout);
3036 fputs (_("\
3037 -print-multi-lib Display the mapping between command line options and\n\
3038 multiple library search directories\n"), stdout);
3039 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries\n"), stdout);
3040 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler\n"), stdout);
3041 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor\n"), stdout);
3042 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker\n"), stdout);
3043 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler\n"), stdout);
3044 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n"), stdout);
3045 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker\n"), stdout);
3046 fputs (_(" -combine Pass multiple source files to compiler at once\n"), stdout);
3047 fputs (_(" -save-temps Do not delete intermediate files\n"), stdout);
3048 fputs (_(" -pipe Use pipes rather than intermediate files\n"), stdout);
3049 fputs (_(" -time Time the execution of each subprocess\n"), stdout);
3050 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>\n"), stdout);
3051 fputs (_(" -std=<standard> Assume that the input sources are for <standard>\n"), stdout);
3052 fputs (_("\
3053 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3054 for headers and libraries\n"), stdout);
3055 fputs (_(" -B <directory> Add <directory> to the compiler's search paths\n"), stdout);
3056 fputs (_(" -b <machine> Run gcc for target <machine>, if installed\n"), stdout);
3057 fputs (_(" -V <version> Run gcc version number <version>, if installed\n"), stdout);
3058 fputs (_(" -v Display the programs invoked by the compiler\n"), stdout);
3059 fputs (_(" -### Like -v but options quoted and commands not executed\n"), stdout);
3060 fputs (_(" -E Preprocess only; do not compile, assemble or link\n"), stdout);
3061 fputs (_(" -S Compile only; do not assemble or link\n"), stdout);
3062 fputs (_(" -c Compile and assemble, but do not link\n"), stdout);
3063 fputs (_(" -o <file> Place the output into <file>\n"), stdout);
3064 fputs (_("\
3065 -x <language> Specify the language of the following input files\n\
3066 Permissible languages include: c c++ assembler none\n\
3067 'none' means revert to the default behavior of\n\
3068 guessing the language based on the file's extension\n\
3069"), stdout);
3070
3071 printf (_("\
3072\nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3073 passed on to the various sub-processes invoked by %s. In order to pass\n\
3074 other options on to these processes the -W<letter> options must be used.\n\
3075"), programname);
3076
3077 /* The rest of the options are displayed by invocations of the various
3078 sub-processes. */
3079}
3080
3081static void
3082add_preprocessor_option (const char *option, int len)
3083{
3084 n_preprocessor_options++;
3085
3086 if (! preprocessor_options)
3087 preprocessor_options = xmalloc (n_preprocessor_options * sizeof (char *));
3088 else
3089 preprocessor_options = xrealloc (preprocessor_options,
3090 n_preprocessor_options * sizeof (char *));
3091
3092 preprocessor_options [n_preprocessor_options - 1] =
3093 save_string (option, len);
3094}
3095
3096static void
3097add_assembler_option (const char *option, int len)
3098{
3099 n_assembler_options++;
3100
3101 if (! assembler_options)
3102 assembler_options = xmalloc (n_assembler_options * sizeof (char *));
3103 else
3104 assembler_options = xrealloc (assembler_options,
3105 n_assembler_options * sizeof (char *));
3106
3107 assembler_options [n_assembler_options - 1] = save_string (option, len);
3108}
3109
3110static void
3111add_linker_option (const char *option, int len)
3112{
3113 n_linker_options++;
3114
3115 if (! linker_options)
3116 linker_options = xmalloc (n_linker_options * sizeof (char *));
3117 else
3118 linker_options = xrealloc (linker_options,
3119 n_linker_options * sizeof (char *));
3120
3121 linker_options [n_linker_options - 1] = save_string (option, len);
3122}
3123\f
3124/* Create the vector `switches' and its contents.
3125 Store its length in `n_switches'. */
3126
3127static void
3128process_command (int argc, const char **argv)
3129{
3130 int i;
3131 const char *temp;
3132 char *temp1;
3133 const char *spec_lang = 0;
3134 int last_language_n_infiles;
3135 int lang_n_infiles = 0;
3136#ifdef MODIFY_TARGET_NAME
3137 int is_modify_target_name;
3138 int j;
3139#endif
3140
3141 GET_ENVIRONMENT (gcc_exec_prefix, "GCC_EXEC_PREFIX");
3142
3143 n_switches = 0;
3144 n_infiles = 0;
3145 added_libraries = 0;
3146
3147 /* Figure compiler version from version string. */
3148
3149 compiler_version = temp1 = xstrdup (version_string);
3150
3151 for (; *temp1; ++temp1)
3152 {
3153 if (*temp1 == ' ')
3154 {
3155 *temp1 = '\0';
3156 break;
3157 }
3158 }
3159
3160 /* If there is a -V or -b option (or both), process it now, before
3161 trying to interpret the rest of the command line.
3162 Use heuristic that all configuration names must have at least
3163 one dash '-'. This allows us to pass options starting with -b. */
3164 if (argc > 1 && argv[1][0] == '-'
3165 && (argv[1][1] == 'V' ||
3166 ((argv[1][1] == 'b') && (NULL != strchr(argv[1] + 2,'-')))))
3167 {
3168 const char *new_version = DEFAULT_TARGET_VERSION;
3169 const char *new_machine = DEFAULT_TARGET_MACHINE;
3170 const char *progname = argv[0];
3171 char **new_argv;
3172 char *new_argv0;
3173 int baselen;
3174
3175 while (argc > 1 && argv[1][0] == '-'
3176 && (argv[1][1] == 'V' ||
3177 ((argv[1][1] == 'b') && ( NULL != strchr(argv[1] + 2,'-')))))
3178 {
3179 char opt = argv[1][1];
3180 const char *arg;
3181 if (argv[1][2] != '\0')
3182 {
3183 arg = argv[1] + 2;
3184 argc -= 1;
3185 argv += 1;
3186 }
3187 else if (argc > 2)
3188 {
3189 arg = argv[2];
3190 argc -= 2;
3191 argv += 2;
3192 }
3193 else
3194 fatal ("'-%c' option must have argument", opt);
3195 if (opt == 'V')
3196 new_version = arg;
3197 else
3198 new_machine = arg;
3199 }
3200
3201 for (baselen = strlen (progname); baselen > 0; baselen--)
3202 if (IS_DIR_SEPARATOR (progname[baselen-1]))
3203 break;
3204 new_argv0 = xmemdup (progname, baselen,
3205 baselen + concat_length (new_version, new_machine,
3206 "-gcc-", NULL) + 1);
3207 strcpy (new_argv0 + baselen, new_machine);
3208 strcat (new_argv0, "-gcc-");
3209 strcat (new_argv0, new_version);
3210
3211 new_argv = xmemdup (argv, (argc + 1) * sizeof (argv[0]),
3212 (argc + 1) * sizeof (argv[0]));
3213 new_argv[0] = new_argv0;
3214
3215 execvp (new_argv0, new_argv);
3216 fatal ("couldn't run '%s': %s", new_argv0, xstrerror (errno));
3217 }
3218
3219 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
3220 see if we can create it from the pathname specified in argv[0]. */
3221
3222 gcc_libexec_prefix = standard_libexec_prefix;
3223#ifndef VMS
3224 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
3225 if (!gcc_exec_prefix)
3226 {
3227 gcc_exec_prefix = make_relative_prefix (argv[0], standard_bindir_prefix,
3228 standard_exec_prefix);
3229 gcc_libexec_prefix = make_relative_prefix (argv[0],
3230 standard_bindir_prefix,
3231 standard_libexec_prefix);
3232 if (gcc_exec_prefix)
3233 putenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
3234 }
3235 else
3236 gcc_libexec_prefix = make_relative_prefix (gcc_exec_prefix,
3237 standard_exec_prefix,
3238 standard_libexec_prefix);
3239#else
3240#endif
3241
3242 if (gcc_exec_prefix)
3243 {
3244 int len = strlen (gcc_exec_prefix);
3245
3246 if (len > (int) sizeof ("/lib/gcc/") - 1
3247 && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
3248 {
3249 temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1;
3250 if (IS_DIR_SEPARATOR (*temp)
3251 && strncmp (temp + 1, "lib", 3) == 0
3252 && IS_DIR_SEPARATOR (temp[4])
3253 && strncmp (temp + 5, "gcc", 3) == 0)
3254 len -= sizeof ("/lib/gcc/") - 1;
3255 }
3256
3257 set_std_prefix (gcc_exec_prefix, len);
3258 add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC",
3259 PREFIX_PRIORITY_LAST, 0, 0);
144812d8
SS
3260 }
3261
3262 /* COMPILER_PATH and LIBRARY_PATH have values
3263 that are lists of directory names with colons. */
3264
3265 GET_ENVIRONMENT (temp, "COMPILER_PATH");
3266 if (temp)
3267 {
3268 const char *startp, *endp;
3269 char *nstore = alloca (strlen (temp) + 3);
3270
3271 startp = endp = temp;
3272 while (1)
3273 {
3274 if (*endp == PATH_SEPARATOR || *endp == 0)
3275 {
3276 strncpy (nstore, startp, endp - startp);
3277 if (endp == startp)
3278 strcpy (nstore, concat (".", dir_separator_str, NULL));
3279 else if (!IS_DIR_SEPARATOR (endp[-1]))
3280 {
3281 nstore[endp - startp] = DIR_SEPARATOR;
3282 nstore[endp - startp + 1] = 0;
3283 }
3284 else
3285 nstore[endp - startp] = 0;
3286 add_prefix (&exec_prefixes, nstore, 0,
3287 PREFIX_PRIORITY_LAST, 0, 0);
3288 add_prefix (&include_prefixes, nstore, 0,
3289 PREFIX_PRIORITY_LAST, 0, 0);
3290 if (*endp == 0)
3291 break;
3292 endp = startp = endp + 1;
3293 }
3294 else
3295 endp++;
3296 }
3297 }
3298
3299 GET_ENVIRONMENT (temp, LIBRARY_PATH_ENV);
3300 if (temp && *cross_compile == '0')
3301 {
3302 const char *startp, *endp;
3303 char *nstore = alloca (strlen (temp) + 3);
3304
3305 startp = endp = temp;
3306 while (1)
3307 {
3308 if (*endp == PATH_SEPARATOR || *endp == 0)
3309 {
3310 strncpy (nstore, startp, endp - startp);
3311 if (endp == startp)
3312 strcpy (nstore, concat (".", dir_separator_str, NULL));
3313 else if (!IS_DIR_SEPARATOR (endp[-1]))
3314 {
3315 nstore[endp - startp] = DIR_SEPARATOR;
3316 nstore[endp - startp + 1] = 0;
3317 }
3318 else
3319 nstore[endp - startp] = 0;
3320 add_prefix (&startfile_prefixes, nstore, NULL,
3321 PREFIX_PRIORITY_LAST, 0, 1);
3322 if (*endp == 0)
3323 break;
3324 endp = startp = endp + 1;
3325 }
3326 else
3327 endp++;
3328 }
3329 }
3330
3331 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
3332 GET_ENVIRONMENT (temp, "LPATH");
3333 if (temp && *cross_compile == '0')
3334 {
3335 const char *startp, *endp;
3336 char *nstore = alloca (strlen (temp) + 3);
3337
3338 startp = endp = temp;
3339 while (1)
3340 {
3341 if (*endp == PATH_SEPARATOR || *endp == 0)
3342 {
3343 strncpy (nstore, startp, endp - startp);
3344 if (endp == startp)
3345 strcpy (nstore, concat (".", dir_separator_str, NULL));
3346 else if (!IS_DIR_SEPARATOR (endp[-1]))
3347 {
3348 nstore[endp - startp] = DIR_SEPARATOR;
3349 nstore[endp - startp + 1] = 0;
3350 }
3351 else
3352 nstore[endp - startp] = 0;
3353 add_prefix (&startfile_prefixes, nstore, NULL,
3354 PREFIX_PRIORITY_LAST, 0, 1);
3355 if (*endp == 0)
3356 break;
3357 endp = startp = endp + 1;
3358 }
3359 else
3360 endp++;
3361 }
3362 }
3363
3364 /* Convert new-style -- options to old-style. */
3365 translate_options (&argc, (const char *const **) &argv);
3366
3367 /* Do language-specific adjustment/addition of flags. */
3368 lang_specific_driver (&argc, (const char *const **) &argv, &added_libraries);
3369
3370 /* Scan argv twice. Here, the first time, just count how many switches
3371 there will be in their vector, and how many input files in theirs.
3372 Here we also parse the switches that cc itself uses (e.g. -v). */
3373
3374 for (i = 1; i < argc; i++)
3375 {
3376 if (! strcmp (argv[i], "-dumpspecs"))
3377 {
3378 struct spec_list *sl;
3379 init_spec ();
3380 for (sl = specs; sl; sl = sl->next)
3381 printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3382 if (link_command_spec)
3383 printf ("*link_command:\n%s\n\n", link_command_spec);
3384 exit (0);
3385 }
3386 else if (! strcmp (argv[i], "-dumpversion"))
3387 {
3388 printf ("%s\n", spec_version);
3389 exit (0);
3390 }
3391 else if (! strcmp (argv[i], "-dumpmachine"))
3392 {
3393 printf ("%s\n", spec_machine);
3394 exit (0);
3395 }
3396 else if (strcmp (argv[i], "-fversion") == 0)
3397 {
3398 /* translate_options () has turned --version into -fversion. */
3399 printf (_("%s (GCC) %s\n"), programname, version_string);
3400 printf ("Copyright %s 2006 Free Software Foundation, Inc.\n",
3401 _("(C)"));
3402 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
3403warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
3404 stdout);
3405 exit (0);
3406 }
3407 else if (strcmp (argv[i], "-fhelp") == 0)
3408 {
3409 /* translate_options () has turned --help into -fhelp. */
3410 print_help_list = 1;
3411
3412 /* We will be passing a dummy file on to the sub-processes. */
3413 n_infiles++;
3414 n_switches++;
3415
3416 /* CPP driver cannot obtain switch from cc1_options. */
3417 if (is_cpp_driver)
3418 add_preprocessor_option ("--help", 6);
3419 add_assembler_option ("--help", 6);
3420 add_linker_option ("--help", 6);
3421 }
3422 else if (strcmp (argv[i], "-ftarget-help") == 0)
3423 {
3424 /* translate_options() has turned --target-help into -ftarget-help. */
3425 target_help_flag = 1;
3426
3427 /* We will be passing a dummy file on to the sub-processes. */
3428 n_infiles++;
3429 n_switches++;
3430
3431 /* CPP driver cannot obtain switch from cc1_options. */
3432 if (is_cpp_driver)
3433 add_preprocessor_option ("--target-help", 13);
3434 add_assembler_option ("--target-help", 13);
3435 add_linker_option ("--target-help", 13);
3436 }
3437 else if (! strcmp (argv[i], "-pass-exit-codes"))
3438 {
3439 pass_exit_codes = 1;
3440 n_switches++;
3441 }
3442 else if (! strcmp (argv[i], "-print-search-dirs"))
3443 print_search_dirs = 1;
3444 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3445 print_file_name = "libgcc.a";
3446 else if (! strncmp (argv[i], "-print-file-name=", 17))
3447 print_file_name = argv[i] + 17;
3448 else if (! strncmp (argv[i], "-print-prog-name=", 17))
3449 print_prog_name = argv[i] + 17;
3450 else if (! strcmp (argv[i], "-print-multi-lib"))
3451 print_multi_lib = 1;
3452 else if (! strcmp (argv[i], "-print-multi-directory"))
3453 print_multi_directory = 1;
3454 else if (! strcmp (argv[i], "-print-multi-os-directory"))
3455 print_multi_os_directory = 1;
3456 else if (! strncmp (argv[i], "-Wa,", 4))
3457 {
3458 int prev, j;
3459 /* Pass the rest of this option to the assembler. */
3460
3461 /* Split the argument at commas. */
3462 prev = 4;
3463 for (j = 4; argv[i][j]; j++)
3464 if (argv[i][j] == ',')
3465 {
3466 add_assembler_option (argv[i] + prev, j - prev);
3467 prev = j + 1;
3468 }
3469
3470 /* Record the part after the last comma. */
3471 add_assembler_option (argv[i] + prev, j - prev);
3472 }
3473 else if (! strncmp (argv[i], "-Wp,", 4))
3474 {
3475 int prev, j;
3476 /* Pass the rest of this option to the preprocessor. */
3477
3478 /* Split the argument at commas. */
3479 prev = 4;
3480 for (j = 4; argv[i][j]; j++)
3481 if (argv[i][j] == ',')
3482 {
3483 add_preprocessor_option (argv[i] + prev, j - prev);
3484 prev = j + 1;
3485 }
3486
3487 /* Record the part after the last comma. */
3488 add_preprocessor_option (argv[i] + prev, j - prev);
3489 }
3490 else if (argv[i][0] == '+' && argv[i][1] == 'e')
3491 /* The +e options to the C++ front-end. */
3492 n_switches++;
3493 else if (strncmp (argv[i], "-Wl,", 4) == 0)
3494 {
3495 int j;
3496 /* Split the argument at commas. */
3497 for (j = 3; argv[i][j]; j++)
3498 n_infiles += (argv[i][j] == ',');
3499 }
3500 else if (strcmp (argv[i], "-Xlinker") == 0)
3501 {
3502 if (i + 1 == argc)
3503 fatal ("argument to '-Xlinker' is missing");
3504
3505 n_infiles++;
3506 i++;
3507 }
3508 else if (strcmp (argv[i], "-Xpreprocessor") == 0)
3509 {
3510 if (i + 1 == argc)
3511 fatal ("argument to '-Xpreprocessor' is missing");
3512
3513 add_preprocessor_option (argv[i+1], strlen (argv[i+1]));
3514 }
3515 else if (strcmp (argv[i], "-Xassembler") == 0)
3516 {
3517 if (i + 1 == argc)
3518 fatal ("argument to '-Xassembler' is missing");
3519
3520 add_assembler_option (argv[i+1], strlen (argv[i+1]));
3521 }
3522 else if (strcmp (argv[i], "-l") == 0)
3523 {
3524 if (i + 1 == argc)
3525 fatal ("argument to '-l' is missing");
3526
3527 n_infiles++;
3528 i++;
3529 }
3530 else if (strncmp (argv[i], "-l", 2) == 0)
3531 n_infiles++;
3532 else if (strcmp (argv[i], "-save-temps") == 0)
3533 {
3534 save_temps_flag = 1;
3535 n_switches++;
3536 }
3537 else if (strcmp (argv[i], "-combine") == 0)
3538 {
3539 combine_flag = 1;
3540 n_switches++;
3541 }
3542 else if (strcmp (argv[i], "-specs") == 0)
3543 {
3544 struct user_specs *user = xmalloc (sizeof (struct user_specs));
3545 if (++i >= argc)
3546 fatal ("argument to '-specs' is missing");
3547
3548 user->next = (struct user_specs *) 0;
3549 user->filename = argv[i];
3550 if (user_specs_tail)
3551 user_specs_tail->next = user;
3552 else
3553 user_specs_head = user;
3554 user_specs_tail = user;
3555 }
3556 else if (strncmp (argv[i], "-specs=", 7) == 0)
3557 {
3558 struct user_specs *user = xmalloc (sizeof (struct user_specs));
3559 if (strlen (argv[i]) == 7)
3560 fatal ("argument to '-specs=' is missing");
3561
3562 user->next = (struct user_specs *) 0;
3563 user->filename = argv[i] + 7;
3564 if (user_specs_tail)
3565 user_specs_tail->next = user;
3566 else
3567 user_specs_head = user;
3568 user_specs_tail = user;
3569 }
3570 else if (strcmp (argv[i], "-time") == 0)
3571 report_times = 1;
3572 else if (strcmp (argv[i], "-pipe") == 0)
3573 {
3574 /* -pipe has to go into the switches array as well as
3575 setting a flag. */
3576 use_pipes = 1;
3577 n_switches++;
3578 }
3579 else if (strcmp (argv[i], "-###") == 0)
3580 {
3581 /* This is similar to -v except that there is no execution
3582 of the commands and the echoed arguments are quoted. It
3583 is intended for use in shell scripts to capture the
3584 driver-generated command line. */
3585 verbose_only_flag++;
3586 verbose_flag++;
3587 }
3588 else if (argv[i][0] == '-' && argv[i][1] != 0)
3589 {
3590 const char *p = &argv[i][1];
3591 int c = *p;
3592
3593 switch (c)
3594 {
3595 case 'b':
6610fcc6
SS
3596 if (NULL == strchr(argv[i] + 2, '-'))
3597 goto normal_switch;
3598
3599 /* Fall through. */
144812d8
SS
3600 case 'V':
3601 fatal ("'-%c' must come at the start of the command line", c);
3602 break;
3603
3604 case 'B':
3605 {
3606 const char *value;
3607 int len;
3608
3609 if (p[1] == 0 && i + 1 == argc)
3610 fatal ("argument to '-B' is missing");
3611 if (p[1] == 0)
3612 value = argv[++i];
3613 else
3614 value = p + 1;
3615
3616 len = strlen (value);
3617
3618 /* Catch the case where the user has forgotten to append a
3619 directory separator to the path. Note, they may be using
3620 -B to add an executable name prefix, eg "i386-elf-", in
3621 order to distinguish between multiple installations of
3622 GCC in the same directory. Hence we must check to see
3623 if appending a directory separator actually makes a
3624 valid directory name. */
3625 if (! IS_DIR_SEPARATOR (value [len - 1])
3626 && is_directory (value, "", 0))
3627 {
3628 char *tmp = xmalloc (len + 2);
3629 strcpy (tmp, value);
3630 tmp[len] = DIR_SEPARATOR;
3631 tmp[++ len] = 0;
3632 value = tmp;
3633 }
3634
3635 /* As a kludge, if the arg is "[foo/]stageN/", just
3636 add "[foo/]include" to the include prefix. */
3637 if ((len == 7
3638 || (len > 7
3639 && (IS_DIR_SEPARATOR (value[len - 8]))))
3640 && strncmp (value + len - 7, "stage", 5) == 0
3641 && ISDIGIT (value[len - 2])
3642 && (IS_DIR_SEPARATOR (value[len - 1])))
3643 {
3644 if (len == 7)
3645 add_prefix (&include_prefixes, "./", NULL,
3646 PREFIX_PRIORITY_B_OPT, 0, 0);
3647 else
3648 {
3649 char *string = xmalloc (len - 6);
3650 memcpy (string, value, len - 7);
3651 string[len - 7] = 0;
3652 add_prefix (&include_prefixes, string, NULL,
3653 PREFIX_PRIORITY_B_OPT, 0, 0);
3654 }
3655 }
3656
3657 add_prefix (&exec_prefixes, value, NULL,
3658 PREFIX_PRIORITY_B_OPT, 0, 0);
3659 add_prefix (&startfile_prefixes, value, NULL,
3660 PREFIX_PRIORITY_B_OPT, 0, 0);
3661 add_prefix (&include_prefixes, value, NULL,
3662 PREFIX_PRIORITY_B_OPT, 0, 0);
3663 n_switches++;
3664 }
3665 break;
3666
3667 case 'v': /* Print our subcommands and print versions. */
3668 n_switches++;
3669 /* If they do anything other than exactly `-v', don't set
3670 verbose_flag; rather, continue on to give the error. */
3671 if (p[1] != 0)
3672 break;
3673 verbose_flag++;
3674 break;
3675
3676 case 'S':
3677 case 'c':
3678 if (p[1] == 0)
3679 {
3680 have_c = 1;
3681 n_switches++;
3682 break;
3683 }
3684 goto normal_switch;
3685
3686 case 'o':
3687 have_o = 1;
3688#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3689 if (! have_c)
3690 {
3691 int skip;
3692
3693 /* Forward scan, just in case -S or -c is specified
3694 after -o. */
3695 int j = i + 1;
3696 if (p[1] == 0)
3697 ++j;
3698 while (j < argc)
3699 {
3700 if (argv[j][0] == '-')
3701 {
3702 if (SWITCH_CURTAILS_COMPILATION (argv[j][1])
3703 && argv[j][2] == 0)
3704 {
3705 have_c = 1;
3706 break;
3707 }
3708 else if ((skip = SWITCH_TAKES_ARG (argv[j][1])))
3709 j += skip - (argv[j][2] != 0);
3710 else if ((skip = WORD_SWITCH_TAKES_ARG (argv[j] + 1)))
3711 j += skip;
3712 }
3713 j++;
3714 }
3715 }
3716#endif
3717#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3718 if (p[1] == 0)
3719 argv[i + 1] = convert_filename (argv[i + 1], ! have_c, 0);
3720 else
3721 argv[i] = convert_filename (argv[i], ! have_c, 0);
3722#endif
3723 goto normal_switch;
3724
3725 default:
3726 normal_switch:
3727
3728#ifdef MODIFY_TARGET_NAME
3729 is_modify_target_name = 0;
3730
3731 for (j = 0; j < ARRAY_SIZE (modify_target); j++)
3732 if (! strcmp (argv[i], modify_target[j].sw))
3733 {
3734 char *new_name = xmalloc (strlen (modify_target[j].str)
3735 + strlen (spec_machine));
3736 const char *p, *r;
3737 char *q;
3738 int made_addition = 0;
3739
3740 is_modify_target_name = 1;
3741 for (p = spec_machine, q = new_name; *p != 0; )
3742 {
3743 if (modify_target[j].add_del == DELETE
3744 && (! strncmp (q, modify_target[j].str,
3745 strlen (modify_target[j].str))))
3746 p += strlen (modify_target[j].str);
3747 else if (modify_target[j].add_del == ADD
3748 && ! made_addition && *p == '-')
3749 {
3750 for (r = modify_target[j].str; *r != 0; )
3751 *q++ = *r++;
3752 made_addition = 1;
3753 }
3754
3755 *q++ = *p++;
3756 }
3757
3758 spec_machine = new_name;
3759 }
3760
3761 if (is_modify_target_name)
3762 break;
3763#endif
3764
3765 n_switches++;
3766
3767 if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
3768 i += SWITCH_TAKES_ARG (c) - (p[1] != 0);
3769 else if (WORD_SWITCH_TAKES_ARG (p))
3770 i += WORD_SWITCH_TAKES_ARG (p);
3771 }
3772 }
3773 else
3774 {
3775 n_infiles++;
3776 lang_n_infiles++;
3777 }
3778 }
3779
3780 if (save_temps_flag && use_pipes)
3781 {
3782 /* -save-temps overrides -pipe, so that temp files are produced */
3783 if (save_temps_flag)
3784 error ("warning: -pipe ignored because -save-temps specified");
3785 use_pipes = 0;
3786 }
3787
3788 /* Set up the search paths before we go looking for config files. */
3789
3790 /* These come before the md prefixes so that we will find gcc's subcommands
3791 (such as cpp) rather than those of the host system. */
3792 /* Use 2 as fourth arg meaning try just the machine as a suffix,
3793 as well as trying the machine and the version. */
3794#ifndef OS2
3795 add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC",
3796 PREFIX_PRIORITY_LAST, 1, 0);
3797 add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS",
3798 PREFIX_PRIORITY_LAST, 2, 0);
3799 add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
3800 PREFIX_PRIORITY_LAST, 2, 0);
3801 add_prefix (&exec_prefixes, standard_exec_prefix_1, "BINUTILS",
3802 PREFIX_PRIORITY_LAST, 2, 0);
3803 add_prefix (&exec_prefixes, standard_exec_prefix_2, "BINUTILS",
3804 PREFIX_PRIORITY_LAST, 2, 0);
3805#endif
3806
144812d8
SS
3807 tooldir_prefix = concat (tooldir_base_prefix, spec_machine,
3808 dir_separator_str, NULL);
3809
3810 /* If tooldir is relative, base it on exec_prefixes. A relative
3811 tooldir lets us move the installed tree as a unit.
3812
3813 If GCC_EXEC_PREFIX is defined, then we want to add two relative
3814 directories, so that we can search both the user specified directory
3815 and the standard place. */
3816
3817 if (!IS_ABSOLUTE_PATH (tooldir_prefix))
3818 {
3819 if (gcc_exec_prefix)
3820 {
3821 char *gcc_exec_tooldir_prefix
3822 = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
3823 spec_version, dir_separator_str, tooldir_prefix, NULL);
3824
3825 add_prefix (&exec_prefixes,
3826 concat (gcc_exec_tooldir_prefix, "bin",
3827 dir_separator_str, NULL),
3828 NULL, PREFIX_PRIORITY_LAST, 0, 0);
144812d8
SS
3829 }
3830
3831 tooldir_prefix = concat (standard_exec_prefix, spec_machine,
3832 dir_separator_str, spec_version,
3833 dir_separator_str, tooldir_prefix, NULL);
3834 }
3835
144812d8
SS
3836#if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
3837 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
3838 then consider it to relocate with the rest of the GCC installation
3839 if GCC_EXEC_PREFIX is set.
3840 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
3841 if (target_system_root && gcc_exec_prefix)
3842 {
3843 char *tmp_prefix = make_relative_prefix (argv[0],
3844 standard_bindir_prefix,
3845 target_system_root);
3846 if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0)
3847 {
3848 target_system_root = tmp_prefix;
3849 target_system_root_changed = 1;
3850 }
3851 }
3852#endif
3853
3854 /* More prefixes are enabled in main, after we read the specs file
3855 and determine whether this is cross-compilation or not. */
3856
3857 /* Then create the space for the vectors and scan again. */
3858
3859 switches = xmalloc ((n_switches + 1) * sizeof (struct switchstr));
3860 infiles = xmalloc ((n_infiles + 1) * sizeof (struct infile));
3861 n_switches = 0;
3862 n_infiles = 0;
3863 last_language_n_infiles = -1;
3864
3865 /* This, time, copy the text of each switch and store a pointer
3866 to the copy in the vector of switches.
3867 Store all the infiles in their vector. */
3868
3869 for (i = 1; i < argc; i++)
3870 {
3871 /* Just skip the switches that were handled by the preceding loop. */
3872#ifdef MODIFY_TARGET_NAME
3873 is_modify_target_name = 0;
3874
3875 for (j = 0; j < ARRAY_SIZE (modify_target); j++)
3876 if (! strcmp (argv[i], modify_target[j].sw))
3877 is_modify_target_name = 1;
3878
3879 if (is_modify_target_name)
3880 ;
3881 else
3882#endif
3883 if (! strncmp (argv[i], "-Wa,", 4))
3884 ;
3885 else if (! strncmp (argv[i], "-Wp,", 4))
3886 ;
3887 else if (! strcmp (argv[i], "-pass-exit-codes"))
3888 ;
3889 else if (! strcmp (argv[i], "-print-search-dirs"))
3890 ;
3891 else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3892 ;
3893 else if (! strncmp (argv[i], "-print-file-name=", 17))
3894 ;
3895 else if (! strncmp (argv[i], "-print-prog-name=", 17))
3896 ;
3897 else if (! strcmp (argv[i], "-print-multi-lib"))
3898 ;
3899 else if (! strcmp (argv[i], "-print-multi-directory"))
3900 ;
3901 else if (! strcmp (argv[i], "-print-multi-os-directory"))
3902 ;
3903 else if (! strcmp (argv[i], "-ftarget-help"))
3904 ;
3905 else if (! strcmp (argv[i], "-fhelp"))
3906 ;
3907 else if (! strncmp (argv[i], "--sysroot=", strlen ("--sysroot=")))
3908 {
3909 target_system_root = argv[i] + strlen ("--sysroot=");
3910 target_system_root_changed = 1;
3911 }
3912 else if (argv[i][0] == '+' && argv[i][1] == 'e')
3913 {
3914 /* Compensate for the +e options to the C++ front-end;
3915 they're there simply for cfront call-compatibility. We do
3916 some magic in default_compilers to pass them down properly.
3917 Note we deliberately start at the `+' here, to avoid passing
3918 -e0 or -e1 down into the linker. */
3919 switches[n_switches].part1 = &argv[i][0];
3920 switches[n_switches].args = 0;
3921 switches[n_switches].live_cond = SWITCH_OK;
3922 switches[n_switches].validated = 0;
3923 n_switches++;
3924 }
3925 else if (strncmp (argv[i], "-Wl,", 4) == 0)
3926 {
3927 int prev, j;
3928 /* Split the argument at commas. */
3929 prev = 4;
3930 for (j = 4; argv[i][j]; j++)
3931 if (argv[i][j] == ',')
3932 {
3933 infiles[n_infiles].language = "*";
3934 infiles[n_infiles++].name
3935 = save_string (argv[i] + prev, j - prev);
3936 prev = j + 1;
3937 }
3938 /* Record the part after the last comma. */
3939 infiles[n_infiles].language = "*";
3940 infiles[n_infiles++].name = argv[i] + prev;
3941 }
3942 else if (strcmp (argv[i], "-Xlinker") == 0)
3943 {
3944 infiles[n_infiles].language = "*";
3945 infiles[n_infiles++].name = argv[++i];
3946 }
3947 /* Xassembler and Xpreprocessor were already handled in the first argv
3948 scan, so all we need to do here is ignore them and their argument. */
3949 else if (strcmp (argv[i], "-Xassembler") == 0)
3950 i++;
3951 else if (strcmp (argv[i], "-Xpreprocessor") == 0)
3952 i++;
3953 else if (strcmp (argv[i], "-l") == 0)
3954 { /* POSIX allows separation of -l and the lib arg;
3955 canonicalize by concatenating -l with its arg */
3956 infiles[n_infiles].language = "*";
3957 infiles[n_infiles++].name = concat ("-l", argv[++i], NULL);
3958 }
3959 else if (strncmp (argv[i], "-l", 2) == 0)
3960 {
3961 infiles[n_infiles].language = "*";
3962 infiles[n_infiles++].name = argv[i];
3963 }
3964 else if (strcmp (argv[i], "-specs") == 0)
3965 i++;
3966 else if (strncmp (argv[i], "-specs=", 7) == 0)
3967 ;
3968 else if (strcmp (argv[i], "-time") == 0)
3969 ;
3970 else if (strcmp (argv[i], "-###") == 0)
3971 ;
3972 else if (argv[i][0] == '-' && argv[i][1] != 0)
3973 {
3974 const char *p = &argv[i][1];
3975 int c = *p;
3976
3977 if (c == 'x')
3978 {
3979 if (p[1] == 0 && i + 1 == argc)
3980 fatal ("argument to '-x' is missing");
3981 if (p[1] == 0)
3982 spec_lang = argv[++i];
3983 else
3984 spec_lang = p + 1;
3985 if (! strcmp (spec_lang, "none"))
3986 /* Suppress the warning if -xnone comes after the last input
3987 file, because alternate command interfaces like g++ might
3988 find it useful to place -xnone after each input file. */
3989 spec_lang = 0;
3990 else
3991 last_language_n_infiles = n_infiles;
3992 continue;
3993 }
3994 switches[n_switches].part1 = p;
3995 /* Deal with option arguments in separate argv elements. */
3996 if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
3997 || WORD_SWITCH_TAKES_ARG (p))
3998 {
3999 int j = 0;
4000 int n_args = WORD_SWITCH_TAKES_ARG (p);
4001
4002 if (n_args == 0)
4003 {
4004 /* Count only the option arguments in separate argv elements. */
4005 n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
4006 }
4007 if (i + n_args >= argc)
4008 fatal ("argument to '-%s' is missing", p);
4009 switches[n_switches].args
4010 = xmalloc ((n_args + 1) * sizeof(const char *));
4011 while (j < n_args)
4012 switches[n_switches].args[j++] = argv[++i];
4013 /* Null-terminate the vector. */
4014 switches[n_switches].args[j] = 0;
4015 }
4016 else if (strchr (switches_need_spaces, c))
4017 {
4018 /* On some systems, ld cannot handle some options without
4019 a space. So split the option from its argument. */
4020 char *part1 = xmalloc (2);
4021 part1[0] = c;
4022 part1[1] = '\0';
4023
4024 switches[n_switches].part1 = part1;
4025 switches[n_switches].args = xmalloc (2 * sizeof (const char *));
4026 switches[n_switches].args[0] = xstrdup (p+1);
4027 switches[n_switches].args[1] = 0;
4028 }
4029 else
4030 switches[n_switches].args = 0;
4031
4032 switches[n_switches].live_cond = SWITCH_OK;
4033 switches[n_switches].validated = 0;
4034 switches[n_switches].ordering = 0;
4035 /* These are always valid, since gcc.c itself understands them. */
4036 if (!strcmp (p, "save-temps")
4037 || !strcmp (p, "static-libgcc")
4038 || !strcmp (p, "shared-libgcc")
4039 || !strcmp (p, "pipe"))
4040 switches[n_switches].validated = 1;
4041 else
4042 {
4043 char ch = switches[n_switches].part1[0];
4044 if (ch == 'B')
4045 switches[n_switches].validated = 1;
4046 }
4047 n_switches++;
4048 }
4049 else
4050 {
4051#ifdef HAVE_TARGET_OBJECT_SUFFIX
4052 argv[i] = convert_filename (argv[i], 0, access (argv[i], F_OK));
4053#endif
4054
4055 if (strcmp (argv[i], "-") != 0 && access (argv[i], F_OK) < 0)
4056 {
4057 perror_with_name (argv[i]);
4058 error_count++;
4059 }
4060 else
4061 {
4062 infiles[n_infiles].language = spec_lang;
4063 infiles[n_infiles++].name = argv[i];
4064 }
4065 }
4066 }
4067
4068 if (n_infiles == last_language_n_infiles && spec_lang != 0)
4069 error ("warning: '-x %s' after last input file has no effect", spec_lang);
4070
4071 /* Ensure we only invoke each subprocess once. */
4072 if (target_help_flag || print_help_list)
4073 {
4074 n_infiles = 1;
4075
4076 /* Create a dummy input file, so that we can pass --target-help on to
4077 the various sub-processes. */
4078 infiles[0].language = "c";
4079 infiles[0].name = "help-dummy";
4080
4081 if (target_help_flag)
4082 {
4083 switches[n_switches].part1 = "--target-help";
4084 switches[n_switches].args = 0;
4085 switches[n_switches].live_cond = SWITCH_OK;
4086 switches[n_switches].validated = 0;
4087
4088 n_switches++;
4089 }
4090
4091 if (print_help_list)
4092 {
4093 switches[n_switches].part1 = "--help";
4094 switches[n_switches].args = 0;
4095 switches[n_switches].live_cond = SWITCH_OK;
4096 switches[n_switches].validated = 0;
4097
4098 n_switches++;
4099 }
4100 }
4101
4102 switches[n_switches].part1 = 0;
4103 infiles[n_infiles].name = 0;
4104}
4105
4106/* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4107 and place that in the environment. */
4108
4109static void