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