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