OSDN Git Service

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