1 /* Compiler driver program that can handle many languages.
2 Copyright (C) 1987-2021 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
10
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
19
20 /* This program is the user interface to the C compiler and possibly to
21 other compilers. It is used because compilation is a complicated procedure
22 which involves running several programs and passing temporary files between
23 them, forwarding the users switches to those programs selectively,
24 and deleting the temporary files at the end.
25
26 CC recognizes how to compile each input file by suffixes in the file names.
27 Once it knows which kind of compilation to perform, the procedure for
28 compilation is specified by a string called a "spec". */
29
30 #include "config.h"
31 #include "system.h"
32 #include "coretypes.h"
33 #include "multilib.h" /* before tm.h */
34 #include "tm.h"
35 #include "xregex.h"
36 #include "obstack.h"
37 #include "intl.h"
38 #include "prefix.h"
39 #include "opt-suggestions.h"
40 #include "gcc.h"
41 #include "diagnostic.h"
42 #include "flags.h"
43 #include "opts.h"
44 #include "filenames.h"
45 #include "spellcheck.h"
46
47
48
49 /* Manage the manipulation of env vars.
50
51 We poison "getenv" and "putenv", so that all enviroment-handling is
52 done through this class. Note that poisoning happens in the
53 preprocessor at the identifier level, and doesn't distinguish between
54 env.getenv ();
55 and
56 getenv ();
57 Hence we need to use "get" for the accessor method, not "getenv". */
58
59 struct env_manager
60 {
61 public:
62 void init (bool can_restore, bool debug);
63 const char *get (const char *name);
64 void xput (const char *string);
65 void restore ();
66
67 private:
68 bool m_can_restore;
69 bool m_debug;
70 struct kv
71 {
72 char *m_key;
73 char *m_value;
74 };
75 vec<kv> m_keys;
76
77 };
78
79 /* The singleton instance of class env_manager. */
80
81 static env_manager env;
82
83 /* Initializer for class env_manager.
84
85 We can't do this as a constructor since we have a statically
86 allocated instance ("env" above). */
87
88 void
init(bool can_restore,bool debug)89 env_manager::init (bool can_restore, bool debug)
90 {
91 m_can_restore = can_restore;
92 m_debug = debug;
93 }
94
95 /* Get the value of NAME within the environment. Essentially
96 a wrapper for ::getenv, but adding logging, and the possibility
97 of caching results. */
98
99 const char *
get(const char * name)100 env_manager::get (const char *name)
101 {
102 const char *result = ::getenv (name);
103 if (m_debug)
104 fprintf (stderr, "env_manager::getenv (%s) -> %s\n", name, result);
105 return result;
106 }
107
108 /* Put the given KEY=VALUE entry STRING into the environment.
109 If the env_manager was initialized with CAN_RESTORE set, then
110 also record the old value of KEY within the environment, so that it
111 can be later restored. */
112
113 void
xput(const char * string)114 env_manager::xput (const char *string)
115 {
116 if (m_debug)
117 fprintf (stderr, "env_manager::xput (%s)\n", string);
118 if (verbose_flag)
119 fnotice (stderr, "%s\n", string);
120
121 if (m_can_restore)
122 {
123 char *equals = strchr (const_cast <char *> (string), '=');
124 gcc_assert (equals);
125
126 struct kv kv;
127 kv.m_key = xstrndup (string, equals - string);
128 const char *cur_value = ::getenv (kv.m_key);
129 if (m_debug)
130 fprintf (stderr, "saving old value: %s\n",cur_value);
131 kv.m_value = cur_value ? xstrdup (cur_value) : NULL;
132 m_keys.safe_push (kv);
133 }
134
135 ::putenv (CONST_CAST (char *, string));
136 }
137
138 /* Undo any xputenv changes made since last restore.
139 Can only be called if the env_manager was initialized with
140 CAN_RESTORE enabled. */
141
142 void
restore()143 env_manager::restore ()
144 {
145 unsigned int i;
146 struct kv *item;
147
148 gcc_assert (m_can_restore);
149
150 FOR_EACH_VEC_ELT_REVERSE (m_keys, i, item)
151 {
152 if (m_debug)
153 printf ("restoring saved key: %s value: %s\n", item->m_key, item->m_value);
154 if (item->m_value)
155 ::setenv (item->m_key, item->m_value, 1);
156 else
157 ::unsetenv (item->m_key);
158 free (item->m_key);
159 free (item->m_value);
160 }
161
162 m_keys.truncate (0);
163 }
164
165 /* Forbid other uses of getenv and putenv. */
166 #if (GCC_VERSION >= 3000)
167 #pragma GCC poison getenv putenv
168 #endif
169
170
171
172 /* By default there is no special suffix for target executables. */
173 #ifdef TARGET_EXECUTABLE_SUFFIX
174 #define HAVE_TARGET_EXECUTABLE_SUFFIX
175 #else
176 #define TARGET_EXECUTABLE_SUFFIX ""
177 #endif
178
179 /* By default there is no special suffix for host executables. */
180 #ifdef HOST_EXECUTABLE_SUFFIX
181 #define HAVE_HOST_EXECUTABLE_SUFFIX
182 #else
183 #define HOST_EXECUTABLE_SUFFIX ""
184 #endif
185
186 /* By default, the suffix for target object files is ".o". */
187 #ifdef TARGET_OBJECT_SUFFIX
188 #define HAVE_TARGET_OBJECT_SUFFIX
189 #else
190 #define TARGET_OBJECT_SUFFIX ".o"
191 #endif
192
193 static const char dir_separator_str[] = { DIR_SEPARATOR, 0 };
194
195 /* Most every one is fine with LIBRARY_PATH. For some, it conflicts. */
196 #ifndef LIBRARY_PATH_ENV
197 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
198 #endif
199
200 /* If a stage of compilation returns an exit status >= 1,
201 compilation of that file ceases. */
202
203 #define MIN_FATAL_STATUS 1
204
205 /* Flag set by cppspec.c to 1. */
206 int is_cpp_driver;
207
208 /* Flag set to nonzero if an @file argument has been supplied to gcc. */
209 static bool at_file_supplied;
210
211 /* Definition of string containing the arguments given to configure. */
212 #include "configargs.h"
213
214 /* Flag saying to print the command line options understood by gcc and its
215 sub-processes. */
216
217 static int print_help_list;
218
219 /* Flag saying to print the version of gcc and its sub-processes. */
220
221 static int print_version;
222
223 /* Flag that stores string prefix for which we provide bash completion. */
224
225 static const char *completion = NULL;
226
227 /* Flag indicating whether we should ONLY print the command and
228 arguments (like verbose_flag) without executing the command.
229 Displayed arguments are quoted so that the generated command
230 line is suitable for execution. This is intended for use in
231 shell scripts to capture the driver-generated command line. */
232 static int verbose_only_flag;
233
234 /* Flag indicating how to print command line options of sub-processes. */
235
236 static int print_subprocess_help;
237
238 /* Linker suffix passed to -fuse-ld=... */
239 static const char *use_ld;
240
241 /* Whether we should report subprocess execution times to a file. */
242
243 FILE *report_times_to_file = NULL;
244
245 /* Nonzero means place this string before uses of /, so that include
246 and library files can be found in an alternate location. */
247
248 #ifdef TARGET_SYSTEM_ROOT
249 #define DEFAULT_TARGET_SYSTEM_ROOT (TARGET_SYSTEM_ROOT)
250 #else
251 #define DEFAULT_TARGET_SYSTEM_ROOT (0)
252 #endif
253 static const char *target_system_root = DEFAULT_TARGET_SYSTEM_ROOT;
254
255 /* Nonzero means pass the updated target_system_root to the compiler. */
256
257 static int target_system_root_changed;
258
259 /* Nonzero means append this string to target_system_root. */
260
261 static const char *target_sysroot_suffix = 0;
262
263 /* Nonzero means append this string to target_system_root for headers. */
264
265 static const char *target_sysroot_hdrs_suffix = 0;
266
267 /* Nonzero means write "temp" files in source directory
268 and use the source file's name in them, and don't delete them. */
269
270 static enum save_temps {
271 SAVE_TEMPS_NONE, /* no -save-temps */
272 SAVE_TEMPS_CWD, /* -save-temps in current directory */
273 SAVE_TEMPS_DUMP, /* -save-temps in dumpdir */
274 SAVE_TEMPS_OBJ /* -save-temps in object directory */
275 } save_temps_flag;
276
277 /* Set this iff the dumppfx implied by a -save-temps=* option is to
278 override a -dumpdir option, if any. */
279 static bool save_temps_overrides_dumpdir = false;
280
281 /* -dumpdir, -dumpbase and -dumpbase-ext flags passed in, possibly
282 rearranged as they are to be passed down, e.g., dumpbase and
283 dumpbase_ext may be cleared if integrated with dumpdir or
284 dropped. */
285 static char *dumpdir, *dumpbase, *dumpbase_ext;
286
287 /* Usually the length of the string in dumpdir. However, during
288 linking, it may be shortened to omit a driver-added trailing dash,
289 by then replaced with a trailing period, that is still to be passed
290 to sub-processes in -dumpdir, but not to be generally used in spec
291 filename expansions. See maybe_run_linker. */
292 static size_t dumpdir_length = 0;
293
294 /* Set if the last character in dumpdir is (or was) a dash that the
295 driver added to dumpdir after dumpbase or linker output name. */
296 static bool dumpdir_trailing_dash_added = false;
297
298 /* Basename of dump and aux outputs, computed from dumpbase (given or
299 derived from output name), to override input_basename in non-%w %b
300 et al. */
301 static char *outbase;
302 static size_t outbase_length = 0;
303
304 /* The compiler version. */
305
306 static const char *compiler_version;
307
308 /* The target version. */
309
310 static const char *const spec_version = DEFAULT_TARGET_VERSION;
311
312 /* The target machine. */
313
314 static const char *spec_machine = DEFAULT_TARGET_MACHINE;
315 static const char *spec_host_machine = DEFAULT_REAL_TARGET_MACHINE;
316
317 /* List of offload targets. Separated by colon. Empty string for
318 -foffload=disable. */
319
320 static char *offload_targets = NULL;
321
322 /* Nonzero if cross-compiling.
323 When -b is used, the value comes from the `specs' file. */
324
325 #ifdef CROSS_DIRECTORY_STRUCTURE
326 static const char *cross_compile = "1";
327 #else
328 static const char *cross_compile = "0";
329 #endif
330
331 /* Greatest exit code of sub-processes that has been encountered up to
332 now. */
333 static int greatest_status = 1;
334
335 /* This is the obstack which we use to allocate many strings. */
336
337 static struct obstack obstack;
338
339 /* This is the obstack to build an environment variable to pass to
340 collect2 that describes all of the relevant switches of what to
341 pass the compiler in building the list of pointers to constructors
342 and destructors. */
343
344 static struct obstack collect_obstack;
345
346 /* Forward declaration for prototypes. */
347 struct path_prefix;
348 struct prefix_list;
349
350 static void init_spec (void);
351 static void store_arg (const char *, int, int);
352 static void insert_wrapper (const char *);
353 static char *load_specs (const char *);
354 static void read_specs (const char *, bool, bool);
355 static void set_spec (const char *, const char *, bool);
356 static struct compiler *lookup_compiler (const char *, size_t, const char *);
357 static char *build_search_list (const struct path_prefix *, const char *,
358 bool, bool);
359 static void xputenv (const char *);
360 static void putenv_from_prefixes (const struct path_prefix *, const char *,
361 bool);
362 static int access_check (const char *, int);
363 static char *find_a_file (const struct path_prefix *, const char *, int, bool);
364 static void add_prefix (struct path_prefix *, const char *, const char *,
365 int, int, int);
366 static void add_sysrooted_prefix (struct path_prefix *, const char *,
367 const char *, int, int, int);
368 static char *skip_whitespace (char *);
369 static void delete_if_ordinary (const char *);
370 static void delete_temp_files (void);
371 static void delete_failure_queue (void);
372 static void clear_failure_queue (void);
373 static int check_live_switch (int, int);
374 static const char *handle_braces (const char *);
375 static inline bool input_suffix_matches (const char *, const char *);
376 static inline bool switch_matches (const char *, const char *, int);
377 static inline void mark_matching_switches (const char *, const char *, int);
378 static inline void process_marked_switches (void);
379 static const char *process_brace_body (const char *, const char *, const char *, int, int);
380 static const struct spec_function *lookup_spec_function (const char *);
381 static const char *eval_spec_function (const char *, const char *, const char *);
382 static const char *handle_spec_function (const char *, bool *, const char *);
383 static char *save_string (const char *, int);
384 static void set_collect_gcc_options (void);
385 static int do_spec_1 (const char *, int, const char *);
386 static int do_spec_2 (const char *, const char *);
387 static void do_option_spec (const char *, const char *);
388 static void do_self_spec (const char *);
389 static const char *find_file (const char *);
390 static int is_directory (const char *, bool);
391 static const char *validate_switches (const char *, bool, bool);
392 static void validate_all_switches (void);
393 static inline void validate_switches_from_spec (const char *, bool);
394 static void give_switch (int, int);
395 static int default_arg (const char *, int);
396 static void set_multilib_dir (void);
397 static void print_multilib_info (void);
398 static void display_help (void);
399 static void add_preprocessor_option (const char *, int);
400 static void add_assembler_option (const char *, int);
401 static void add_linker_option (const char *, int);
402 static void process_command (unsigned int, struct cl_decoded_option *);
403 static int execute (void);
404 static void alloc_args (void);
405 static void clear_args (void);
406 static void fatal_signal (int);
407 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
408 static void init_gcc_specs (struct obstack *, const char *, const char *,
409 const char *);
410 #endif
411 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
412 static const char *convert_filename (const char *, int, int);
413 #endif
414
415 static void try_generate_repro (const char **argv);
416 static const char *getenv_spec_function (int, const char **);
417 static const char *if_exists_spec_function (int, const char **);
418 static const char *if_exists_else_spec_function (int, const char **);
419 static const char *if_exists_then_else_spec_function (int, const char **);
420 static const char *sanitize_spec_function (int, const char **);
421 static const char *replace_outfile_spec_function (int, const char **);
422 static const char *remove_outfile_spec_function (int, const char **);
423 static const char *version_compare_spec_function (int, const char **);
424 static const char *include_spec_function (int, const char **);
425 static const char *find_file_spec_function (int, const char **);
426 static const char *find_plugindir_spec_function (int, const char **);
427 static const char *print_asm_header_spec_function (int, const char **);
428 static const char *compare_debug_dump_opt_spec_function (int, const char **);
429 static const char *compare_debug_self_opt_spec_function (int, const char **);
430 static const char *pass_through_libs_spec_func (int, const char **);
431 static const char *dumps_spec_func (int, const char **);
432 static const char *greater_than_spec_func (int, const char **);
433 static const char *debug_level_greater_than_spec_func (int, const char **);
434 static const char *dwarf_version_greater_than_spec_func (int, const char **);
435 static const char *find_fortran_preinclude_file (int, const char **);
436 static char *convert_white_space (char *);
437 static char *quote_spec (char *);
438 static char *quote_spec_arg (char *);
439 static bool not_actual_file_p (const char *);
440
441
442 /* The Specs Language
443
444 Specs are strings containing lines, each of which (if not blank)
445 is made up of a program name, and arguments separated by spaces.
446 The program name must be exact and start from root, since no path
447 is searched and it is unreliable to depend on the current working directory.
448 Redirection of input or output is not supported; the subprograms must
449 accept filenames saying what files to read and write.
450
451 In addition, the specs can contain %-sequences to substitute variable text
452 or for conditional text. Here is a table of all defined %-sequences.
453 Note that spaces are not generated automatically around the results of
454 expanding these sequences; therefore, you can concatenate them together
455 or with constant text in a single argument.
456
457 %% substitute one % into the program name or argument.
458 %" substitute an empty argument.
459 %i substitute the name of the input file being processed.
460 %b substitute the basename for outputs related with the input file
461 being processed. This is often a substring of the input file name,
462 up to (and not including) the last period but, unless %w is active,
463 it is affected by the directory selected by -save-temps=*, by
464 -dumpdir, and, in case of multiple compilations, even by -dumpbase
465 and -dumpbase-ext and, in case of linking, by the linker output
466 name. When %w is active, it derives the main output name only from
467 the input file base name; when it is not, it names aux/dump output
468 file.
469 %B same as %b, but include the input file suffix (text after the last
470 period).
471 %gSUFFIX
472 substitute a file name that has suffix SUFFIX and is chosen
473 once per compilation, and mark the argument a la %d. To reduce
474 exposure to denial-of-service attacks, the file name is now
475 chosen in a way that is hard to predict even when previously
476 chosen file names are known. For example, `%g.s ... %g.o ... %g.s'
477 might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'. SUFFIX matches
478 the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
479 had been pre-processed. Previously, %g was simply substituted
480 with a file name chosen once per compilation, without regard
481 to any appended suffix (which was therefore treated just like
482 ordinary text), making such attacks more likely to succeed.
483 %|SUFFIX
484 like %g, but if -pipe is in effect, expands simply to "-".
485 %mSUFFIX
486 like %g, but if -pipe is in effect, expands to nothing. (We have both
487 %| and %m to accommodate differences between system assemblers; see
488 the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
489 %uSUFFIX
490 like %g, but generates a new temporary file name even if %uSUFFIX
491 was already seen.
492 %USUFFIX
493 substitutes the last file name generated with %uSUFFIX, generating a
494 new one if there is no such last file name. In the absence of any
495 %uSUFFIX, this is just like %gSUFFIX, except they don't share
496 the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
497 would involve the generation of two distinct file names, one
498 for each `%g.s' and another for each `%U.s'. Previously, %U was
499 simply substituted with a file name chosen for the previous %u,
500 without regard to any appended suffix.
501 %jSUFFIX
502 substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
503 writable, and if save-temps is off; otherwise, substitute the name
504 of a temporary file, just like %u. This temporary file is not
505 meant for communication between processes, but rather as a junk
506 disposal mechanism.
507 %.SUFFIX
508 substitutes .SUFFIX for the suffixes of a matched switch's args when
509 it is subsequently output with %*. SUFFIX is terminated by the next
510 space or %.
511 %d marks the argument containing or following the %d as a
512 temporary file name, so that file will be deleted if GCC exits
513 successfully. Unlike %g, this contributes no text to the argument.
514 %w marks the argument containing or following the %w as the
515 "output file" of this compilation. This puts the argument
516 into the sequence of arguments that %o will substitute later.
517 %V indicates that this compilation produces no "output file".
518 %W{...}
519 like %{...} but marks the last argument supplied within as a file
520 to be deleted on failure.
521 %@{...}
522 like %{...} but puts the result into a FILE and substitutes @FILE
523 if an @file argument has been supplied.
524 %o substitutes the names of all the output files, with spaces
525 automatically placed around them. You should write spaces
526 around the %o as well or the results are undefined.
527 %o is for use in the specs for running the linker.
528 Input files whose names have no recognized suffix are not compiled
529 at all, but they are included among the output files, so they will
530 be linked.
531 %O substitutes the suffix for object files. Note that this is
532 handled specially when it immediately follows %g, %u, or %U
533 (with or without a suffix argument) because of the need for
534 those to form complete file names. The handling is such that
535 %O is treated exactly as if it had already been substituted,
536 except that %g, %u, and %U do not currently support additional
537 SUFFIX characters following %O as they would following, for
538 example, `.o'.
539 %I Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
540 (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
541 and -B options) and -imultilib as necessary.
542 %s current argument is the name of a library or startup file of some sort.
543 Search for that file in a standard list of directories
544 and substitute the full name found.
545 %T current argument is the name of a linker script.
546 Search for that file in the current list of directories to scan for
547 libraries. If the file is located, insert a --script option into the
548 command line followed by the full path name found. If the file is
549 not found then generate an error message.
550 Note: the current working directory is not searched.
551 %eSTR Print STR as an error message. STR is terminated by a newline.
552 Use this when inconsistent options are detected.
553 %nSTR Print STR as a notice. STR is terminated by a newline.
554 %x{OPTION} Accumulate an option for %X.
555 %X Output the accumulated linker options specified by compilations.
556 %Y Output the accumulated assembler options specified by compilations.
557 %Z Output the accumulated preprocessor options specified by compilations.
558 %a process ASM_SPEC as a spec.
559 This allows config.h to specify part of the spec for running as.
560 %A process ASM_FINAL_SPEC as a spec. A capital A is actually
561 used here. This can be used to run a post-processor after the
562 assembler has done its job.
563 %D Dump out a -L option for each directory in startfile_prefixes.
564 If multilib_dir is set, extra entries are generated with it affixed.
565 %l process LINK_SPEC as a spec.
566 %L process LIB_SPEC as a spec.
567 %M Output multilib_os_dir.
568 %G process LIBGCC_SPEC as a spec.
569 %R Output the concatenation of target_system_root and
570 target_sysroot_suffix.
571 %S process STARTFILE_SPEC as a spec. A capital S is actually used here.
572 %E process ENDFILE_SPEC as a spec. A capital E is actually used here.
573 %C process CPP_SPEC as a spec.
574 %1 process CC1_SPEC as a spec.
575 %2 process CC1PLUS_SPEC as a spec.
576 %* substitute the variable part of a matched option. (See below.)
577 Note that each comma in the substituted string is replaced by
578 a single space. A space is appended after the last substition
579 unless there is more text in current sequence.
580 %<S remove all occurrences of -S from the command line.
581 Note - this command is position dependent. % commands in the
582 spec string before this one will see -S, % commands in the
583 spec string after this one will not.
584 %>S Similar to "%<S", but keep it in the GCC command line.
585 %<S* remove all occurrences of all switches beginning with -S from the
586 command line.
587 %:function(args)
588 Call the named function FUNCTION, passing it ARGS. ARGS is
589 first processed as a nested spec string, then split into an
590 argument vector in the usual fashion. The function returns
591 a string which is processed as if it had appeared literally
592 as part of the current spec.
593 %{S} substitutes the -S switch, if that switch was given to GCC.
594 If that switch was not specified, this substitutes nothing.
595 Here S is a metasyntactic variable.
596 %{S*} substitutes all the switches specified to GCC whose names start
597 with -S. This is used for -o, -I, etc; switches that take
598 arguments. GCC considers `-o foo' as being one switch whose
599 name starts with `o'. %{o*} would substitute this text,
600 including the space; thus, two arguments would be generated.
601 %{S*&T*} likewise, but preserve order of S and T options (the order
602 of S and T in the spec is not significant). Can be any number
603 of ampersand-separated variables; for each the wild card is
604 optional. Useful for CPP as %{D*&U*&A*}.
605
606 %{S:X} substitutes X, if the -S switch was given to GCC.
607 %{!S:X} substitutes X, if the -S switch was NOT given to GCC.
608 %{S*:X} substitutes X if one or more switches whose names start
609 with -S was given to GCC. Normally X is substituted only
610 once, no matter how many such switches appeared. However,
611 if %* appears somewhere in X, then X will be substituted
612 once for each matching switch, with the %* replaced by the
613 part of that switch that matched the '*'. A space will be
614 appended after the last substition unless there is more
615 text in current sequence.
616 %{.S:X} substitutes X, if processing a file with suffix S.
617 %{!.S:X} substitutes X, if NOT processing a file with suffix S.
618 %{,S:X} substitutes X, if processing a file which will use spec S.
619 %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
620
621 %{S|T:X} substitutes X if either -S or -T was given to GCC. This may be
622 combined with '!', '.', ',', and '*' as above binding stronger
623 than the OR.
624 If %* appears in X, all of the alternatives must be starred, and
625 only the first matching alternative is substituted.
626 %{%:function(args):X}
627 Call function named FUNCTION with args ARGS. If the function
628 returns non-NULL, then X is substituted, if it returns
629 NULL, it isn't substituted.
630 %{S:X; if S was given to GCC, substitutes X;
631 T:Y; else if T was given to GCC, substitutes Y;
632 :D} else substitutes D. There can be as many clauses as you need.
633 This may be combined with '.', '!', ',', '|', and '*' as above.
634
635 %(Spec) processes a specification defined in a specs file as *Spec:
636
637 The switch matching text S in a %{S}, %{S:X}, or similar construct can use
638 a backslash to ignore the special meaning of the character following it,
639 thus allowing literal matching of a character that is otherwise specially
640 treated. For example, %{std=iso9899\:1999:X} substitutes X if the
641 -std=iso9899:1999 option is given.
642
643 The conditional text X in a %{S:X} or similar construct may contain
644 other nested % constructs or spaces, or even newlines. They are
645 processed as usual, as described above. Trailing white space in X is
646 ignored. White space may also appear anywhere on the left side of the
647 colon in these constructs, except between . or * and the corresponding
648 word.
649
650 The -O, -f, -g, -m, and -W switches are handled specifically in these
651 constructs. If another value of -O or the negated form of a -f, -m, or
652 -W switch is found later in the command line, the earlier switch
653 value is ignored, except with {S*} where S is just one letter; this
654 passes all matching options.
655
656 The character | at the beginning of the predicate text is used to indicate
657 that a command should be piped to the following command, but only if -pipe
658 is specified.
659
660 Note that it is built into GCC which switches take arguments and which
661 do not. You might think it would be useful to generalize this to
662 allow each compiler's spec to say which switches take arguments. But
663 this cannot be done in a consistent fashion. GCC cannot even decide
664 which input files have been specified without knowing which switches
665 take arguments, and it must know which input files to compile in order
666 to tell which compilers to run.
667
668 GCC also knows implicitly that arguments starting in `-l' are to be
669 treated as compiler output files, and passed to the linker in their
670 proper position among the other output files. */
671
672 /* Define the macros used for specs %a, %l, %L, %S, %C, %1. */
673
674 /* config.h can define ASM_SPEC to provide extra args to the assembler
675 or extra switch-translations. */
676 #ifndef ASM_SPEC
677 #define ASM_SPEC ""
678 #endif
679
680 /* config.h can define ASM_FINAL_SPEC to run a post processor after
681 the assembler has run. */
682 #ifndef ASM_FINAL_SPEC
683 #define ASM_FINAL_SPEC \
684 "%{gsplit-dwarf: \n\
685 objcopy --extract-dwo \
686 %{c:%{o*:%*}%{!o*:%w%b%O}}%{!c:%U%O} \
687 %b.dwo \n\
688 objcopy --strip-dwo \
689 %{c:%{o*:%*}%{!o*:%w%b%O}}%{!c:%U%O} \
690 }"
691 #endif
692
693 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
694 or extra switch-translations. */
695 #ifndef CPP_SPEC
696 #define CPP_SPEC ""
697 #endif
698
699 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
700 or extra switch-translations. */
701 #ifndef CC1_SPEC
702 #define CC1_SPEC ""
703 #endif
704
705 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
706 or extra switch-translations. */
707 #ifndef CC1PLUS_SPEC
708 #define CC1PLUS_SPEC ""
709 #endif
710
711 /* config.h can define LINK_SPEC to provide extra args to the linker
712 or extra switch-translations. */
713 #ifndef LINK_SPEC
714 #define LINK_SPEC ""
715 #endif
716
717 /* config.h can define LIB_SPEC to override the default libraries. */
718 #ifndef LIB_SPEC
719 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
720 #endif
721
722 /* When using -fsplit-stack we need to wrap pthread_create, in order
723 to initialize the stack guard. We always use wrapping, rather than
724 shared library ordering, and we keep the wrapper function in
725 libgcc. This is not yet a real spec, though it could become one;
726 it is currently just stuffed into LINK_SPEC. FIXME: This wrapping
727 only works with GNU ld and gold. */
728 #ifdef HAVE_GOLD_NON_DEFAULT_SPLIT_STACK
729 #define STACK_SPLIT_SPEC " %{fsplit-stack: -fuse-ld=gold --wrap=pthread_create}"
730 #else
731 #define STACK_SPLIT_SPEC " %{fsplit-stack: --wrap=pthread_create}"
732 #endif
733
734 #ifndef LIBASAN_SPEC
735 #define STATIC_LIBASAN_LIBS \
736 " %{static-libasan|static:%:include(libsanitizer.spec)%(link_libasan)}"
737 #ifdef LIBASAN_EARLY_SPEC
738 #define LIBASAN_SPEC STATIC_LIBASAN_LIBS
739 #elif defined(HAVE_LD_STATIC_DYNAMIC)
740 #define LIBASAN_SPEC "%{static-libasan:" LD_STATIC_OPTION \
741 "} -lasan %{static-libasan:" LD_DYNAMIC_OPTION "}" \
742 STATIC_LIBASAN_LIBS
743 #else
744 #define LIBASAN_SPEC "-lasan" STATIC_LIBASAN_LIBS
745 #endif
746 #endif
747
748 #ifndef LIBASAN_EARLY_SPEC
749 #define LIBASAN_EARLY_SPEC ""
750 #endif
751
752 #ifndef LIBHWASAN_SPEC
753 #define STATIC_LIBHWASAN_LIBS \
754 " %{static-libhwasan|static:%:include(libsanitizer.spec)%(link_libhwasan)}"
755 #ifdef LIBHWASAN_EARLY_SPEC
756 #define LIBHWASAN_SPEC STATIC_LIBHWASAN_LIBS
757 #elif defined(HAVE_LD_STATIC_DYNAMIC)
758 #define LIBHWASAN_SPEC "%{static-libhwasan:" LD_STATIC_OPTION \
759 "} -lhwasan %{static-libhwasan:" LD_DYNAMIC_OPTION "}" \
760 STATIC_LIBHWASAN_LIBS
761 #else
762 #define LIBHWASAN_SPEC "-lhwasan" STATIC_LIBHWASAN_LIBS
763 #endif
764 #endif
765
766 #ifndef LIBHWASAN_EARLY_SPEC
767 #define LIBHWASAN_EARLY_SPEC ""
768 #endif
769
770 #ifndef LIBTSAN_SPEC
771 #define STATIC_LIBTSAN_LIBS \
772 " %{static-libtsan|static:%:include(libsanitizer.spec)%(link_libtsan)}"
773 #ifdef LIBTSAN_EARLY_SPEC
774 #define LIBTSAN_SPEC STATIC_LIBTSAN_LIBS
775 #elif defined(HAVE_LD_STATIC_DYNAMIC)
776 #define LIBTSAN_SPEC "%{static-libtsan:" LD_STATIC_OPTION \
777 "} -ltsan %{static-libtsan:" LD_DYNAMIC_OPTION "}" \
778 STATIC_LIBTSAN_LIBS
779 #else
780 #define LIBTSAN_SPEC "-ltsan" STATIC_LIBTSAN_LIBS
781 #endif
782 #endif
783
784 #ifndef LIBTSAN_EARLY_SPEC
785 #define LIBTSAN_EARLY_SPEC ""
786 #endif
787
788 #ifndef LIBLSAN_SPEC
789 #define STATIC_LIBLSAN_LIBS \
790 " %{static-liblsan|static:%:include(libsanitizer.spec)%(link_liblsan)}"
791 #ifdef LIBLSAN_EARLY_SPEC
792 #define LIBLSAN_SPEC STATIC_LIBLSAN_LIBS
793 #elif defined(HAVE_LD_STATIC_DYNAMIC)
794 #define LIBLSAN_SPEC "%{static-liblsan:" LD_STATIC_OPTION \
795 "} -llsan %{static-liblsan:" LD_DYNAMIC_OPTION "}" \
796 STATIC_LIBLSAN_LIBS
797 #else
798 #define LIBLSAN_SPEC "-llsan" STATIC_LIBLSAN_LIBS
799 #endif
800 #endif
801
802 #ifndef LIBLSAN_EARLY_SPEC
803 #define LIBLSAN_EARLY_SPEC ""
804 #endif
805
806 #ifndef LIBUBSAN_SPEC
807 #define STATIC_LIBUBSAN_LIBS \
808 " %{static-libubsan|static:%:include(libsanitizer.spec)%(link_libubsan)}"
809 #ifdef HAVE_LD_STATIC_DYNAMIC
810 #define LIBUBSAN_SPEC "%{static-libubsan:" LD_STATIC_OPTION \
811 "} -lubsan %{static-libubsan:" LD_DYNAMIC_OPTION "}" \
812 STATIC_LIBUBSAN_LIBS
813 #else
814 #define LIBUBSAN_SPEC "-lubsan" STATIC_LIBUBSAN_LIBS
815 #endif
816 #endif
817
818 /* Linker options for compressed debug sections. */
819 #if HAVE_LD_COMPRESS_DEBUG == 0
820 /* No linker support. */
821 #define LINK_COMPRESS_DEBUG_SPEC \
822 " %{gz*:%e-gz is not supported in this configuration} "
823 #elif HAVE_LD_COMPRESS_DEBUG == 1
824 /* GNU style on input, GNU ld options. Reject, not useful. */
825 #define LINK_COMPRESS_DEBUG_SPEC \
826 " %{gz*:%e-gz is not supported in this configuration} "
827 #elif HAVE_LD_COMPRESS_DEBUG == 2
828 /* GNU style, GNU gold options. */
829 #define LINK_COMPRESS_DEBUG_SPEC \
830 " %{gz|gz=zlib-gnu:" LD_COMPRESS_DEBUG_OPTION "=zlib}" \
831 " %{gz=none:" LD_COMPRESS_DEBUG_OPTION "=none}" \
832 " %{gz=zlib:%e-gz=zlib is not supported in this configuration} "
833 #elif HAVE_LD_COMPRESS_DEBUG == 3
834 /* ELF gABI style. */
835 #define LINK_COMPRESS_DEBUG_SPEC \
836 " %{gz|gz=zlib:" LD_COMPRESS_DEBUG_OPTION "=zlib}" \
837 " %{gz=none:" LD_COMPRESS_DEBUG_OPTION "=none}" \
838 " %{gz=zlib-gnu:" LD_COMPRESS_DEBUG_OPTION "=zlib-gnu} "
839 #else
840 #error Unknown value for HAVE_LD_COMPRESS_DEBUG.
841 #endif
842
843 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
844 included. */
845 #ifndef LIBGCC_SPEC
846 #if defined(REAL_LIBGCC_SPEC)
847 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
848 #elif defined(LINK_LIBGCC_SPECIAL_1)
849 /* Have gcc do the search for libgcc.a. */
850 #define LIBGCC_SPEC "libgcc.a%s"
851 #else
852 #define LIBGCC_SPEC "-lgcc"
853 #endif
854 #endif
855
856 /* config.h can define STARTFILE_SPEC to override the default crt0 files. */
857 #ifndef STARTFILE_SPEC
858 #define STARTFILE_SPEC \
859 "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
860 #endif
861
862 /* config.h can define ENDFILE_SPEC to override the default crtn files. */
863 #ifndef ENDFILE_SPEC
864 #define ENDFILE_SPEC ""
865 #endif
866
867 #ifndef LINKER_NAME
868 #define LINKER_NAME "collect2"
869 #endif
870
871 #ifdef HAVE_AS_DEBUG_PREFIX_MAP
872 #define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
873 #else
874 #define ASM_MAP ""
875 #endif
876
877 /* Assembler options for compressed debug sections. */
878 #if HAVE_LD_COMPRESS_DEBUG < 2
879 /* Reject if the linker cannot write compressed debug sections. */
880 #define ASM_COMPRESS_DEBUG_SPEC \
881 " %{gz*:%e-gz is not supported in this configuration} "
882 #else /* HAVE_LD_COMPRESS_DEBUG >= 2 */
883 #if HAVE_AS_COMPRESS_DEBUG == 0
884 /* No assembler support. Ignore silently. */
885 #define ASM_COMPRESS_DEBUG_SPEC \
886 " %{gz*:} "
887 #elif HAVE_AS_COMPRESS_DEBUG == 1
888 /* GNU style, GNU as options. */
889 #define ASM_COMPRESS_DEBUG_SPEC \
890 " %{gz|gz=zlib-gnu:" AS_COMPRESS_DEBUG_OPTION "}" \
891 " %{gz=none:" AS_NO_COMPRESS_DEBUG_OPTION "}" \
892 " %{gz=zlib:%e-gz=zlib is not supported in this configuration} "
893 #elif HAVE_AS_COMPRESS_DEBUG == 2
894 /* ELF gABI style. */
895 #define ASM_COMPRESS_DEBUG_SPEC \
896 " %{gz|gz=zlib:" AS_COMPRESS_DEBUG_OPTION "=zlib}" \
897 " %{gz=none:" AS_COMPRESS_DEBUG_OPTION "=none}" \
898 " %{gz=zlib-gnu:" AS_COMPRESS_DEBUG_OPTION "=zlib-gnu} "
899 #else
900 #error Unknown value for HAVE_AS_COMPRESS_DEBUG.
901 #endif
902 #endif /* HAVE_LD_COMPRESS_DEBUG >= 2 */
903
904 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
905 to the assembler, when compiling assembly sources only. */
906 #ifndef ASM_DEBUG_SPEC
907 # if defined(HAVE_AS_GDWARF_5_DEBUG_FLAG) && defined(HAVE_AS_WORKING_DWARF_N_FLAG)
908 /* If --gdwarf-N is supported and as can handle even compiler generated
909 .debug_line with it, supply --gdwarf-N in ASM_DEBUG_OPTION_SPEC rather
910 than in ASM_DEBUG_SPEC, so that it applies to both .s and .c etc.
911 compilations. */
912 # define ASM_DEBUG_DWARF_OPTION ""
913 # elif defined(HAVE_AS_GDWARF_5_DEBUG_FLAG) && !defined(HAVE_LD_BROKEN_PE_DWARF5)
914 # define ASM_DEBUG_DWARF_OPTION "%{%:dwarf-version-gt(4):--gdwarf-5;" \
915 "%:dwarf-version-gt(3):--gdwarf-4;" \
916 "%:dwarf-version-gt(2):--gdwarf-3;" \
917 ":--gdwarf2}"
918 # else
919 # define ASM_DEBUG_DWARF_OPTION "--gdwarf2"
920 # endif
921 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
922 && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
923 # define ASM_DEBUG_SPEC \
924 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
925 ? "%{%:debug-level-gt(0):" \
926 "%{gdwarf*:" ASM_DEBUG_DWARF_OPTION "};" \
927 ":%{g*:--gstabs}}" ASM_MAP \
928 : "%{%:debug-level-gt(0):" \
929 "%{gstabs*:--gstabs;" \
930 ":%{g*:" ASM_DEBUG_DWARF_OPTION "}}}" ASM_MAP)
931 # else
932 # if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
933 # define ASM_DEBUG_SPEC "%{g*:%{%:debug-level-gt(0):--gstabs}}" ASM_MAP
934 # endif
935 # if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
936 # define ASM_DEBUG_SPEC "%{g*:%{%:debug-level-gt(0):" \
937 ASM_DEBUG_DWARF_OPTION "}}" ASM_MAP
938 # endif
939 # endif
940 #endif
941 #ifndef ASM_DEBUG_SPEC
942 # define ASM_DEBUG_SPEC ""
943 #endif
944
945 /* Define ASM_DEBUG_OPTION_SPEC to be a spec suitable for translating '-g'
946 to the assembler when compiling all sources. */
947 #ifndef ASM_DEBUG_OPTION_SPEC
948 # if defined(HAVE_AS_GDWARF_5_DEBUG_FLAG) && defined(HAVE_AS_WORKING_DWARF_N_FLAG)
949 # define ASM_DEBUG_OPTION_DWARF_OPT \
950 "%{%:dwarf-version-gt(4):--gdwarf-5 ;" \
951 "%:dwarf-version-gt(3):--gdwarf-4 ;" \
952 "%:dwarf-version-gt(2):--gdwarf-3 ;" \
953 ":--gdwarf2 }"
954 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO)
955 # define ASM_DEBUG_OPTION_SPEC \
956 (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG \
957 ? "%{%:debug-level-gt(0):" \
958 "%{gdwarf*:" ASM_DEBUG_OPTION_DWARF_OPT "}}" \
959 : "%{%:debug-level-gt(0):" \
960 "%{!gstabs*:%{g*:" ASM_DEBUG_OPTION_DWARF_OPT "}}}")
961 # elif defined(DWARF2_DEBUGGING_INFO)
962 # define ASM_DEBUG_OPTION_SPEC "%{g*:%{%:debug-level-gt(0):" \
963 ASM_DEBUG_OPTION_DWARF_OPT "}}"
964 # endif
965 # endif
966 #endif
967 #ifndef ASM_DEBUG_OPTION_SPEC
968 # define ASM_DEBUG_OPTION_SPEC ""
969 #endif
970
971 /* Here is the spec for running the linker, after compiling all files. */
972
973 /* This is overridable by the target in case they need to specify the
974 -lgcc and -lc order specially, yet not require them to override all
975 of LINK_COMMAND_SPEC. */
976 #ifndef LINK_GCC_C_SEQUENCE_SPEC
977 #define LINK_GCC_C_SEQUENCE_SPEC "%G %{!nolibc:%L %G}"
978 #endif
979
980 #ifndef LINK_SSP_SPEC
981 #ifdef TARGET_LIBC_PROVIDES_SSP
982 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all" \
983 "|fstack-protector-strong|fstack-protector-explicit:}"
984 #else
985 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all" \
986 "|fstack-protector-strong|fstack-protector-explicit" \
987 ":-lssp_nonshared -lssp}"
988 #endif
989 #endif
990
991 #ifdef ENABLE_DEFAULT_PIE
992 #define PIE_SPEC "!no-pie"
993 #define NO_FPIE1_SPEC "fno-pie"
994 #define FPIE1_SPEC NO_FPIE1_SPEC ":;"
995 #define NO_FPIE2_SPEC "fno-PIE"
996 #define FPIE2_SPEC NO_FPIE2_SPEC ":;"
997 #define NO_FPIE_SPEC NO_FPIE1_SPEC "|" NO_FPIE2_SPEC
998 #define FPIE_SPEC NO_FPIE_SPEC ":;"
999 #define NO_FPIC1_SPEC "fno-pic"
1000 #define FPIC1_SPEC NO_FPIC1_SPEC ":;"
1001 #define NO_FPIC2_SPEC "fno-PIC"
1002 #define FPIC2_SPEC NO_FPIC2_SPEC ":;"
1003 #define NO_FPIC_SPEC NO_FPIC1_SPEC "|" NO_FPIC2_SPEC
1004 #define FPIC_SPEC NO_FPIC_SPEC ":;"
1005 #define NO_FPIE1_AND_FPIC1_SPEC NO_FPIE1_SPEC "|" NO_FPIC1_SPEC
1006 #define FPIE1_OR_FPIC1_SPEC NO_FPIE1_AND_FPIC1_SPEC ":;"
1007 #define NO_FPIE2_AND_FPIC2_SPEC NO_FPIE2_SPEC "|" NO_FPIC2_SPEC
1008 #define FPIE2_OR_FPIC2_SPEC NO_FPIE2_AND_FPIC2_SPEC ":;"
1009 #define NO_FPIE_AND_FPIC_SPEC NO_FPIE_SPEC "|" NO_FPIC_SPEC
1010 #define FPIE_OR_FPIC_SPEC NO_FPIE_AND_FPIC_SPEC ":;"
1011 #else
1012 #define PIE_SPEC "pie"
1013 #define FPIE1_SPEC "fpie"
1014 #define NO_FPIE1_SPEC FPIE1_SPEC ":;"
1015 #define FPIE2_SPEC "fPIE"
1016 #define NO_FPIE2_SPEC FPIE2_SPEC ":;"
1017 #define FPIE_SPEC FPIE1_SPEC "|" FPIE2_SPEC
1018 #define NO_FPIE_SPEC FPIE_SPEC ":;"
1019 #define FPIC1_SPEC "fpic"
1020 #define NO_FPIC1_SPEC FPIC1_SPEC ":;"
1021 #define FPIC2_SPEC "fPIC"
1022 #define NO_FPIC2_SPEC FPIC2_SPEC ":;"
1023 #define FPIC_SPEC FPIC1_SPEC "|" FPIC2_SPEC
1024 #define NO_FPIC_SPEC FPIC_SPEC ":;"
1025 #define FPIE1_OR_FPIC1_SPEC FPIE1_SPEC "|" FPIC1_SPEC
1026 #define NO_FPIE1_AND_FPIC1_SPEC FPIE1_OR_FPIC1_SPEC ":;"
1027 #define FPIE2_OR_FPIC2_SPEC FPIE2_SPEC "|" FPIC2_SPEC
1028 #define NO_FPIE2_AND_FPIC2_SPEC FPIE1_OR_FPIC2_SPEC ":;"
1029 #define FPIE_OR_FPIC_SPEC FPIE_SPEC "|" FPIC_SPEC
1030 #define NO_FPIE_AND_FPIC_SPEC FPIE_OR_FPIC_SPEC ":;"
1031 #endif
1032
1033 #ifndef LINK_PIE_SPEC
1034 #ifdef HAVE_LD_PIE
1035 #ifndef LD_PIE_SPEC
1036 #define LD_PIE_SPEC "-pie"
1037 #endif
1038 #else
1039 #define LD_PIE_SPEC ""
1040 #endif
1041 #define LINK_PIE_SPEC "%{static|shared|r:;" PIE_SPEC ":" LD_PIE_SPEC "} "
1042 #endif
1043
1044 #ifndef LINK_BUILDID_SPEC
1045 # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
1046 # define LINK_BUILDID_SPEC "%{!r:--build-id} "
1047 # endif
1048 #endif
1049
1050 #ifndef LTO_PLUGIN_SPEC
1051 #define LTO_PLUGIN_SPEC ""
1052 #endif
1053
1054 /* Conditional to test whether the LTO plugin is used or not.
1055 FIXME: For slim LTO we will need to enable plugin unconditionally. This
1056 still cause problems with PLUGIN_LD != LD and when plugin is built but
1057 not useable. For GCC 4.6 we don't support slim LTO and thus we can enable
1058 plugin only when LTO is enabled. We still honor explicit
1059 -fuse-linker-plugin if the linker used understands -plugin. */
1060
1061 /* The linker has some plugin support. */
1062 #if HAVE_LTO_PLUGIN > 0
1063 /* The linker used has full plugin support, use LTO plugin by default. */
1064 #if HAVE_LTO_PLUGIN == 2
1065 #define PLUGIN_COND "!fno-use-linker-plugin:%{!fno-lto"
1066 #define PLUGIN_COND_CLOSE "}"
1067 #else
1068 /* The linker used has limited plugin support, use LTO plugin with explicit
1069 -fuse-linker-plugin. */
1070 #define PLUGIN_COND "fuse-linker-plugin"
1071 #define PLUGIN_COND_CLOSE ""
1072 #endif
1073 #define LINK_PLUGIN_SPEC \
1074 "%{" PLUGIN_COND": \
1075 -plugin %(linker_plugin_file) \
1076 -plugin-opt=%(lto_wrapper) \
1077 -plugin-opt=-fresolution=%u.res \
1078 " LTO_PLUGIN_SPEC "\
1079 %{flinker-output=*:-plugin-opt=-linker-output-known} \
1080 %{!nostdlib:%{!nodefaultlibs:%:pass-through-libs(%(link_gcc_c_sequence))}} \
1081 }" PLUGIN_COND_CLOSE
1082 #else
1083 /* The linker used doesn't support -plugin, reject -fuse-linker-plugin. */
1084 #define LINK_PLUGIN_SPEC "%{fuse-linker-plugin:\
1085 %e-fuse-linker-plugin is not supported in this configuration}"
1086 #endif
1087
1088 /* Linker command line options for -fsanitize= early on the command line. */
1089 #ifndef SANITIZER_EARLY_SPEC
1090 #define SANITIZER_EARLY_SPEC "\
1091 %{!nostdlib:%{!r:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_EARLY_SPEC "} \
1092 %{%:sanitize(hwaddress):" LIBHWASAN_EARLY_SPEC "} \
1093 %{%:sanitize(thread):" LIBTSAN_EARLY_SPEC "} \
1094 %{%:sanitize(leak):" LIBLSAN_EARLY_SPEC "}}}}"
1095 #endif
1096
1097 /* Linker command line options for -fsanitize= late on the command line. */
1098 #ifndef SANITIZER_SPEC
1099 #define SANITIZER_SPEC "\
1100 %{!nostdlib:%{!r:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_SPEC "\
1101 %{static:%ecannot specify -static with -fsanitize=address}}\
1102 %{%:sanitize(hwaddress):" LIBHWASAN_SPEC "\
1103 %{static:%ecannot specify -static with -fsanitize=hwaddress}}\
1104 %{%:sanitize(thread):" LIBTSAN_SPEC "\
1105 %{static:%ecannot specify -static with -fsanitize=thread}}\
1106 %{%:sanitize(undefined):" LIBUBSAN_SPEC "}\
1107 %{%:sanitize(leak):" LIBLSAN_SPEC "}}}}"
1108 #endif
1109
1110 #ifndef POST_LINK_SPEC
1111 #define POST_LINK_SPEC ""
1112 #endif
1113
1114 /* This is the spec to use, once the code for creating the vtable
1115 verification runtime library, libvtv.so, has been created. Currently
1116 the vtable verification runtime functions are in libstdc++, so we use
1117 the spec just below this one. */
1118 #ifndef VTABLE_VERIFICATION_SPEC
1119 #if ENABLE_VTABLE_VERIFY
1120 #define VTABLE_VERIFICATION_SPEC "\
1121 %{!nostdlib:%{!r:%{fvtable-verify=std: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}\
1122 %{fvtable-verify=preinit: -lvtv -u_vtable_map_vars_start -u_vtable_map_vars_end}}}"
1123 #else
1124 #define VTABLE_VERIFICATION_SPEC "\
1125 %{fvtable-verify=none:} \
1126 %{fvtable-verify=std: \
1127 %e-fvtable-verify=std is not supported in this configuration} \
1128 %{fvtable-verify=preinit: \
1129 %e-fvtable-verify=preinit is not supported in this configuration}"
1130 #endif
1131 #endif
1132
1133 /* -u* was put back because both BSD and SysV seem to support it. */
1134 /* %{static|no-pie|static-pie:} simply prevents an error message:
1135 1. If the target machine doesn't handle -static.
1136 2. If PIE isn't enabled by default.
1137 3. If the target machine doesn't handle -static-pie.
1138 */
1139 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
1140 scripts which exist in user specified directories, or in standard
1141 directories. */
1142 /* We pass any -flto flags on to the linker, which is expected
1143 to understand them. In practice, this means it had better be collect2. */
1144 /* %{e*} includes -export-dynamic; see comment in common.opt. */
1145 #ifndef LINK_COMMAND_SPEC
1146 #define LINK_COMMAND_SPEC "\
1147 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
1148 %(linker) " \
1149 LINK_PLUGIN_SPEC \
1150 "%{flto|flto=*:%<fcompare-debug*} \
1151 %{flto} %{fno-lto} %{flto=*} %l " LINK_PIE_SPEC \
1152 "%{fuse-ld=*:-fuse-ld=%*} " LINK_COMPRESS_DEBUG_SPEC \
1153 "%X %{o*} %{e*} %{N} %{n} %{r}\
1154 %{s} %{t} %{u*} %{z} %{Z} %{!nostdlib:%{!r:%{!nostartfiles:%S}}} \
1155 %{static|no-pie|static-pie:} %@{L*} %(mfwrap) %(link_libgcc) " \
1156 VTABLE_VERIFICATION_SPEC " " SANITIZER_EARLY_SPEC " %o "" \
1157 %{fopenacc|fopenmp|%:gt(%{ftree-parallelize-loops=*:%*} 1):\
1158 %:include(libgomp.spec)%(link_gomp)}\
1159 %{fgnu-tm:%:include(libitm.spec)%(link_itm)}\
1160 %(mflib) " STACK_SPLIT_SPEC "\
1161 %{fprofile-arcs|fprofile-generate*|coverage:-lgcov} " SANITIZER_SPEC " \
1162 %{!nostdlib:%{!r:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}}\
1163 %{!nostdlib:%{!r:%{!nostartfiles:%E}}} %{T*} \n%(post_link) }}}}}}"
1164 #endif
1165
1166 #ifndef LINK_LIBGCC_SPEC
1167 /* Generate -L options for startfile prefix list. */
1168 # define LINK_LIBGCC_SPEC "%D"
1169 #endif
1170
1171 #ifndef STARTFILE_PREFIX_SPEC
1172 # define STARTFILE_PREFIX_SPEC ""
1173 #endif
1174
1175 #ifndef SYSROOT_SPEC
1176 # define SYSROOT_SPEC "--sysroot=%R"
1177 #endif
1178
1179 #ifndef SYSROOT_SUFFIX_SPEC
1180 # define SYSROOT_SUFFIX_SPEC ""
1181 #endif
1182
1183 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
1184 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
1185 #endif
1186
1187 static const char *asm_debug = ASM_DEBUG_SPEC;
1188 static const char *asm_debug_option = ASM_DEBUG_OPTION_SPEC;
1189 static const char *cpp_spec = CPP_SPEC;
1190 static const char *cc1_spec = CC1_SPEC;
1191 static const char *cc1plus_spec = CC1PLUS_SPEC;
1192 static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC;
1193 static const char *link_ssp_spec = LINK_SSP_SPEC;
1194 static const char *asm_spec = ASM_SPEC;
1195 static const char *asm_final_spec = ASM_FINAL_SPEC;
1196 static const char *link_spec = LINK_SPEC;
1197 static const char *lib_spec = LIB_SPEC;
1198 static const char *link_gomp_spec = "";
1199 static const char *libgcc_spec = LIBGCC_SPEC;
1200 static const char *endfile_spec = ENDFILE_SPEC;
1201 static const char *startfile_spec = STARTFILE_SPEC;
1202 static const char *linker_name_spec = LINKER_NAME;
1203 static const char *linker_plugin_file_spec = "";
1204 static const char *lto_wrapper_spec = "";
1205 static const char *lto_gcc_spec = "";
1206 static const char *post_link_spec = POST_LINK_SPEC;
1207 static const char *link_command_spec = LINK_COMMAND_SPEC;
1208 static const char *link_libgcc_spec = LINK_LIBGCC_SPEC;
1209 static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC;
1210 static const char *sysroot_spec = SYSROOT_SPEC;
1211 static const char *sysroot_suffix_spec = SYSROOT_SUFFIX_SPEC;
1212 static const char *sysroot_hdrs_suffix_spec = SYSROOT_HEADERS_SUFFIX_SPEC;
1213 static const char *self_spec = "";
1214
1215 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
1216 There should be no need to override these in target dependent files,
1217 but we need to copy them to the specs file so that newer versions
1218 of the GCC driver can correctly drive older tool chains with the
1219 appropriate -B options. */
1220
1221 /* When cpplib handles traditional preprocessing, get rid of this, and
1222 call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
1223 that we default the front end language better. */
1224 static const char *trad_capable_cpp =
1225 "cc1 -E %{traditional|traditional-cpp:-traditional-cpp}";
1226
1227 /* We don't wrap .d files in %W{} since a missing .d file, and
1228 therefore no dependency entry, confuses make into thinking a .o
1229 file that happens to exist is up-to-date. */
1230 static const char *cpp_unique_options =
1231 "%{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %@{I*&F*} %{P} %I\
1232 %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
1233 %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
1234 %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
1235 %{Mmodules} %{Mno-modules}\
1236 %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
1237 %{remap} %{%:debug-level-gt(2):-dD}\
1238 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
1239 %{H} %C %{D*&U*&A*} %{i*} %Z %i\
1240 %{E|M|MM:%W{o*}}";
1241
1242 /* This contains cpp options which are common with cc1_options and are passed
1243 only when preprocessing only to avoid duplication. We pass the cc1 spec
1244 options to the preprocessor so that it the cc1 spec may manipulate
1245 options used to set target flags. Those special target flags settings may
1246 in turn cause preprocessor symbols to be defined specially. */
1247 static const char *cpp_options =
1248 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
1249 %{f*} %{g*:%{%:debug-level-gt(0):%{g*}\
1250 %{!fno-working-directory:-fworking-directory}}} %{O*}\
1251 %{undef} %{save-temps*:-fpch-preprocess}";
1252
1253 /* Pass -d* flags, possibly modifying -dumpdir, -dumpbase et al.
1254
1255 Make it easy for a language to override the argument for the
1256 %:dumps specs function call. */
1257 #define DUMPS_OPTIONS(EXTS) \
1258 "%<dumpdir %<dumpbase %<dumpbase-ext %{d*} %:dumps(" EXTS ")"
1259
1260 /* This contains cpp options which are not passed when the preprocessor
1261 output will be used by another program. */
1262 static const char *cpp_debug_options = DUMPS_OPTIONS ("");
1263
1264 /* NB: This is shared amongst all front-ends, except for Ada. */
1265 static const char *cc1_options =
1266 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
1267 %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
1268 %1 %{!Q:-quiet} %(cpp_debug_options) %{m*} %{aux-info*}\
1269 %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
1270 %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
1271 %{Qn:-fno-ident} %{Qy:} %{-help:--help}\
1272 %{-target-help:--target-help}\
1273 %{-version:--version}\
1274 %{-help=*:--help=%*}\
1275 %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %w%b.s}}}\
1276 %{fsyntax-only:-o %j} %{-param*}\
1277 %{coverage:-fprofile-arcs -ftest-coverage}\
1278 %{fprofile-arcs|fprofile-generate*|coverage:\
1279 %{!fprofile-update=single:\
1280 %{pthread:-fprofile-update=prefer-atomic}}}";
1281
1282 static const char *asm_options =
1283 "%{-target-help:%:print-asm-header()} "
1284 #if HAVE_GNU_AS
1285 /* If GNU AS is used, then convert -w (no warnings), -I, and -v
1286 to the assembler equivalents. */
1287 "%{v} %{w:-W} %{I*} "
1288 #endif
1289 "%(asm_debug_option)"
1290 ASM_COMPRESS_DEBUG_SPEC
1291 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
1292
1293 static const char *invoke_as =
1294 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1295 "%{!fwpa*:\
1296 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
1297 %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
1298 }";
1299 #else
1300 "%{!fwpa*:\
1301 %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
1302 %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
1303 }";
1304 #endif
1305
1306 /* Some compilers have limits on line lengths, and the multilib_select
1307 and/or multilib_matches strings can be very long, so we build them at
1308 run time. */
1309 static struct obstack multilib_obstack;
1310 static const char *multilib_select;
1311 static const char *multilib_matches;
1312 static const char *multilib_defaults;
1313 static const char *multilib_exclusions;
1314 static const char *multilib_reuse;
1315
1316 /* Check whether a particular argument is a default argument. */
1317
1318 #ifndef MULTILIB_DEFAULTS
1319 #define MULTILIB_DEFAULTS { "" }
1320 #endif
1321
1322 static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
1323
1324 #ifndef DRIVER_SELF_SPECS
1325 #define DRIVER_SELF_SPECS ""
1326 #endif
1327
1328 /* Linking to libgomp implies pthreads. This is particularly important
1329 for targets that use different start files and suchlike. */
1330 #ifndef GOMP_SELF_SPECS
1331 #define GOMP_SELF_SPECS \
1332 "%{fopenacc|fopenmp|%:gt(%{ftree-parallelize-loops=*:%*} 1): " \
1333 "-pthread}"
1334 #endif
1335
1336 /* Likewise for -fgnu-tm. */
1337 #ifndef GTM_SELF_SPECS
1338 #define GTM_SELF_SPECS "%{fgnu-tm: -pthread}"
1339 #endif
1340
1341 static const char *const driver_self_specs[] = {
1342 "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
1343 DRIVER_SELF_SPECS, CONFIGURE_SPECS, GOMP_SELF_SPECS, GTM_SELF_SPECS
1344 };
1345
1346 #ifndef OPTION_DEFAULT_SPECS
1347 #define OPTION_DEFAULT_SPECS { "", "" }
1348 #endif
1349
1350 struct default_spec
1351 {
1352 const char *name;
1353 const char *spec;
1354 };
1355
1356 static const struct default_spec
1357 option_default_specs[] = { OPTION_DEFAULT_SPECS };
1358
1359 struct user_specs
1360 {
1361 struct user_specs *next;
1362 const char *filename;
1363 };
1364
1365 static struct user_specs *user_specs_head, *user_specs_tail;
1366
1367
1368 /* Record the mapping from file suffixes for compilation specs. */
1369
1370 struct compiler
1371 {
1372 const char *suffix; /* Use this compiler for input files
1373 whose names end in this suffix. */
1374
1375 const char *spec; /* To use this compiler, run this spec. */
1376
1377 const char *cpp_spec; /* If non-NULL, substitute this spec
1378 for `%C', rather than the usual
1379 cpp_spec. */
1380 int combinable; /* If nonzero, compiler can deal with
1381 multiple source files at once (IMA). */
1382 int needs_preprocessing; /* If nonzero, source files need to
1383 be run through a preprocessor. */
1384 };
1385
1386 /* Pointer to a vector of `struct compiler' that gives the spec for
1387 compiling a file, based on its suffix.
1388 A file that does not end in any of these suffixes will be passed
1389 unchanged to the loader and nothing else will be done to it.
1390
1391 An entry containing two 0s is used to terminate the vector.
1392
1393 If multiple entries match a file, the last matching one is used. */
1394
1395 static struct compiler *compilers;
1396
1397 /* Number of entries in `compilers', not counting the null terminator. */
1398
1399 static int n_compilers;
1400
1401 /* The default list of file name suffixes and their compilation specs. */
1402
1403 static const struct compiler default_compilers[] =
1404 {
1405 /* Add lists of suffixes of known languages here. If those languages
1406 were not present when we built the driver, we will hit these copies
1407 and be given a more meaningful error than "file not used since
1408 linking is not done". */
1409 {".m", "#Objective-C", 0, 0, 0}, {".mi", "#Objective-C", 0, 0, 0},
1410 {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
1411 {".mii", "#Objective-C++", 0, 0, 0},
1412 {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
1413 {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
1414 {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
1415 {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
1416 {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
1417 {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
1418 {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
1419 {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
1420 {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
1421 {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
1422 {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
1423 {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
1424 {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
1425 {".r", "#Ratfor", 0, 0, 0},
1426 {".go", "#Go", 0, 1, 0},
1427 {".d", "#D", 0, 1, 0}, {".dd", "#D", 0, 1, 0}, {".di", "#D", 0, 1, 0},
1428 /* Next come the entries for C. */
1429 {".c", "@c", 0, 0, 1},
1430 {"@c",
1431 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1432 external preprocessor if -save-temps is given. */
1433 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1434 %{!E:%{!M:%{!MM:\
1435 %{traditional:\
1436 %eGNU C no longer supports -traditional without -E}\
1437 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1438 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1439 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1440 %(cc1_options)}\
1441 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1442 cc1 %(cpp_unique_options) %(cc1_options)}}}\
1443 %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 1},
1444 {"-",
1445 "%{!E:%e-E or -x required when input is from standard input}\
1446 %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
1447 {".h", "@c-header", 0, 0, 0},
1448 {"@c-header",
1449 /* cc1 has an integrated ISO C preprocessor. We should invoke the
1450 external preprocessor if -save-temps is given. */
1451 "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
1452 %{!E:%{!M:%{!MM:\
1453 %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
1454 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1455 cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1456 %(cc1_options)\
1457 %{!fsyntax-only:%{!S:-o %g.s} \
1458 %{!fdump-ada-spec*:%{!o*:--output-pch=%i.gch}\
1459 %W{o*:--output-pch=%*}}%V}}\
1460 %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1461 cc1 %(cpp_unique_options) %(cc1_options)\
1462 %{!fsyntax-only:%{!S:-o %g.s} \
1463 %{!fdump-ada-spec*:%{!o*:--output-pch=%i.gch}\
1464 %W{o*:--output-pch=%*}}%V}}}}}}}", 0, 0, 0},
1465 {".i", "@cpp-output", 0, 0, 0},
1466 {"@cpp-output",
1467 "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 0},
1468 {".s", "@assembler", 0, 0, 0},
1469 {"@assembler",
1470 "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 0, 0},
1471 {".sx", "@assembler-with-cpp", 0, 0, 0},
1472 {".S", "@assembler-with-cpp", 0, 0, 0},
1473 {"@assembler-with-cpp",
1474 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1475 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1476 %{E|M|MM:%(cpp_debug_options)}\
1477 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1478 as %(asm_debug) %(asm_options) %|.s %A }}}}"
1479 #else
1480 "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1481 %{E|M|MM:%(cpp_debug_options)}\
1482 %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1483 as %(asm_debug) %(asm_options) %m.s %A }}}}"
1484 #endif
1485 , 0, 0, 0},
1486
1487 #include "specs.h"
1488 /* Mark end of table. */
1489 {0, 0, 0, 0, 0}
1490 };
1491
1492 /* Number of elements in default_compilers, not counting the terminator. */
1493
1494 static const int n_default_compilers = ARRAY_SIZE (default_compilers) - 1;
1495
1496 typedef char *char_p; /* For DEF_VEC_P. */
1497
1498 /* A vector of options to give to the linker.
1499 These options are accumulated by %x,
1500 and substituted into the linker command with %X. */
1501 static vec<char_p> linker_options;
1502
1503 /* A vector of options to give to the assembler.
1504 These options are accumulated by -Wa,
1505 and substituted into the assembler command with %Y. */
1506 static vec<char_p> assembler_options;
1507
1508 /* A vector of options to give to the preprocessor.
1509 These options are accumulated by -Wp,
1510 and substituted into the preprocessor command with %Z. */
1511 static vec<char_p> preprocessor_options;
1512
1513 static char *
skip_whitespace(char * p)1514 skip_whitespace (char *p)
1515 {
1516 while (1)
1517 {
1518 /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1519 be considered whitespace. */
1520 if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
1521 return p + 1;
1522 else if (*p == '\n' || *p == ' ' || *p == '\t')
1523 p++;
1524 else if (*p == '#')
1525 {
1526 while (*p != '\n')
1527 p++;
1528 p++;
1529 }
1530 else
1531 break;
1532 }
1533
1534 return p;
1535 }
1536 /* Structures to keep track of prefixes to try when looking for files. */
1537
1538 struct prefix_list
1539 {
1540 const char *prefix; /* String to prepend to the path. */
1541 struct prefix_list *next; /* Next in linked list. */
1542 int require_machine_suffix; /* Don't use without machine_suffix. */
1543 /* 2 means try both machine_suffix and just_machine_suffix. */
1544 int priority; /* Sort key - priority within list. */
1545 int os_multilib; /* 1 if OS multilib scheme should be used,
1546 0 for GCC multilib scheme. */
1547 };
1548
1549 struct path_prefix
1550 {
1551 struct prefix_list *plist; /* List of prefixes to try */
1552 int max_len; /* Max length of a prefix in PLIST */
1553 const char *name; /* Name of this list (used in config stuff) */
1554 };
1555
1556 /* List of prefixes to try when looking for executables. */
1557
1558 static struct path_prefix exec_prefixes = { 0, 0, "exec" };
1559
1560 /* List of prefixes to try when looking for startup (crt0) files. */
1561
1562 static struct path_prefix startfile_prefixes = { 0, 0, "startfile" };
1563
1564 /* List of prefixes to try when looking for include files. */
1565
1566 static struct path_prefix include_prefixes = { 0, 0, "include" };
1567
1568 /* Suffix to attach to directories searched for commands.
1569 This looks like `MACHINE/VERSION/'. */
1570
1571 static const char *machine_suffix = 0;
1572
1573 /* Suffix to attach to directories searched for commands.
1574 This is just `MACHINE/'. */
1575
1576 static const char *just_machine_suffix = 0;
1577
1578 /* Adjusted value of GCC_EXEC_PREFIX envvar. */
1579
1580 static const char *gcc_exec_prefix;
1581
1582 /* Adjusted value of standard_libexec_prefix. */
1583
1584 static const char *gcc_libexec_prefix;
1585
1586 /* Default prefixes to attach to command names. */
1587
1588 #ifndef STANDARD_STARTFILE_PREFIX_1
1589 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1590 #endif
1591 #ifndef STANDARD_STARTFILE_PREFIX_2
1592 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1593 #endif
1594
1595 #ifdef CROSS_DIRECTORY_STRUCTURE /* Don't use these prefixes for a cross compiler. */
1596 #undef MD_EXEC_PREFIX
1597 #undef MD_STARTFILE_PREFIX
1598 #undef MD_STARTFILE_PREFIX_1
1599 #endif
1600
1601 /* If no prefixes defined, use the null string, which will disable them. */
1602 #ifndef MD_EXEC_PREFIX
1603 #define MD_EXEC_PREFIX ""
1604 #endif
1605 #ifndef MD_STARTFILE_PREFIX
1606 #define MD_STARTFILE_PREFIX ""
1607 #endif
1608 #ifndef MD_STARTFILE_PREFIX_1
1609 #define MD_STARTFILE_PREFIX_1 ""
1610 #endif
1611
1612 /* These directories are locations set at configure-time based on the
1613 --prefix option provided to configure. Their initializers are
1614 defined in Makefile.in. These paths are not *directly* used when
1615 gcc_exec_prefix is set because, in that case, we know where the
1616 compiler has been installed, and use paths relative to that
1617 location instead. */
1618 static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
1619 static const char *const standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX;
1620 static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
1621 static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1622
1623 /* For native compilers, these are well-known paths containing
1624 components that may be provided by the system. For cross
1625 compilers, these paths are not used. */
1626 static const char *md_exec_prefix = MD_EXEC_PREFIX;
1627 static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1628 static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1629 static const char *const standard_startfile_prefix_1
1630 = STANDARD_STARTFILE_PREFIX_1;
1631 static const char *const standard_startfile_prefix_2
1632 = STANDARD_STARTFILE_PREFIX_2;
1633
1634 /* A relative path to be used in finding the location of tools
1635 relative to the driver. */
1636 static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1637
1638 /* A prefix to be used when this is an accelerator compiler. */
1639 static const char *const accel_dir_suffix = ACCEL_DIR_SUFFIX;
1640
1641 /* Subdirectory to use for locating libraries. Set by
1642 set_multilib_dir based on the compilation options. */
1643
1644 static const char *multilib_dir;
1645
1646 /* Subdirectory to use for locating libraries in OS conventions. Set by
1647 set_multilib_dir based on the compilation options. */
1648
1649 static const char *multilib_os_dir;
1650
1651 /* Subdirectory to use for locating libraries in multiarch conventions. Set by
1652 set_multilib_dir based on the compilation options. */
1653
1654 static const char *multiarch_dir;
1655
1656 /* Structure to keep track of the specs that have been defined so far.
1657 These are accessed using %(specname) in a compiler or link
1658 spec. */
1659
1660 struct spec_list
1661 {
1662 /* The following 2 fields must be first */
1663 /* to allow EXTRA_SPECS to be initialized */
1664 const char *name; /* name of the spec. */
1665 const char *ptr; /* available ptr if no static pointer */
1666
1667 /* The following fields are not initialized */
1668 /* by EXTRA_SPECS */
1669 const char **ptr_spec; /* pointer to the spec itself. */
1670 struct spec_list *next; /* Next spec in linked list. */
1671 int name_len; /* length of the name */
1672 bool user_p; /* whether string come from file spec. */
1673 bool alloc_p; /* whether string was allocated */
1674 const char *default_ptr; /* The default value of *ptr_spec. */
1675 };
1676
1677 #define INIT_STATIC_SPEC(NAME,PTR) \
1678 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, false, false, \
1679 *PTR }
1680
1681 /* List of statically defined specs. */
1682 static struct spec_list static_specs[] =
1683 {
1684 INIT_STATIC_SPEC ("asm", &asm_spec),
1685 INIT_STATIC_SPEC ("asm_debug", &asm_debug),
1686 INIT_STATIC_SPEC ("asm_debug_option", &asm_debug_option),
1687 INIT_STATIC_SPEC ("asm_final", &asm_final_spec),
1688 INIT_STATIC_SPEC ("asm_options", &asm_options),
1689 INIT_STATIC_SPEC ("invoke_as", &invoke_as),
1690 INIT_STATIC_SPEC ("cpp", &cpp_spec),
1691 INIT_STATIC_SPEC ("cpp_options", &cpp_options),
1692 INIT_STATIC_SPEC ("cpp_debug_options", &cpp_debug_options),
1693 INIT_STATIC_SPEC ("cpp_unique_options", &cpp_unique_options),
1694 INIT_STATIC_SPEC ("trad_capable_cpp", &trad_capable_cpp),
1695 INIT_STATIC_SPEC ("cc1", &cc1_spec),
1696 INIT_STATIC_SPEC ("cc1_options", &cc1_options),
1697 INIT_STATIC_SPEC ("cc1plus", &cc1plus_spec),
1698 INIT_STATIC_SPEC ("link_gcc_c_sequence", &link_gcc_c_sequence_spec),
1699 INIT_STATIC_SPEC ("link_ssp", &link_ssp_spec),
1700 INIT_STATIC_SPEC ("endfile", &endfile_spec),
1701 INIT_STATIC_SPEC ("link", &link_spec),
1702 INIT_STATIC_SPEC ("lib", &lib_spec),
1703 INIT_STATIC_SPEC ("link_gomp", &link_gomp_spec),
1704 INIT_STATIC_SPEC ("libgcc", &libgcc_spec),
1705 INIT_STATIC_SPEC ("startfile", &startfile_spec),
1706 INIT_STATIC_SPEC ("cross_compile", &cross_compile),
1707 INIT_STATIC_SPEC ("version", &compiler_version),
1708 INIT_STATIC_SPEC ("multilib", &multilib_select),
1709 INIT_STATIC_SPEC ("multilib_defaults", &multilib_defaults),
1710 INIT_STATIC_SPEC ("multilib_extra", &multilib_extra),
1711 INIT_STATIC_SPEC ("multilib_matches", &multilib_matches),
1712 INIT_STATIC_SPEC ("multilib_exclusions", &multilib_exclusions),
1713 INIT_STATIC_SPEC ("multilib_options", &multilib_options),
1714 INIT_STATIC_SPEC ("multilib_reuse", &multilib_reuse),
1715 INIT_STATIC_SPEC ("linker", &linker_name_spec),
1716 INIT_STATIC_SPEC ("linker_plugin_file", &linker_plugin_file_spec),
1717 INIT_STATIC_SPEC ("lto_wrapper", <o_wrapper_spec),
1718 INIT_STATIC_SPEC ("lto_gcc", <o_gcc_spec),
1719 INIT_STATIC_SPEC ("post_link", &post_link_spec),
1720 INIT_STATIC_SPEC ("link_libgcc", &link_libgcc_spec),
1721 INIT_STATIC_SPEC ("md_exec_prefix", &md_exec_prefix),
1722 INIT_STATIC_SPEC ("md_startfile_prefix", &md_startfile_prefix),
1723 INIT_STATIC_SPEC ("md_startfile_prefix_1", &md_startfile_prefix_1),
1724 INIT_STATIC_SPEC ("startfile_prefix_spec", &startfile_prefix_spec),
1725 INIT_STATIC_SPEC ("sysroot_spec", &sysroot_spec),
1726 INIT_STATIC_SPEC ("sysroot_suffix_spec", &sysroot_suffix_spec),
1727 INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec),
1728 INIT_STATIC_SPEC ("self_spec", &self_spec),
1729 };
1730
1731 #ifdef EXTRA_SPECS /* additional specs needed */
1732 /* Structure to keep track of just the first two args of a spec_list.
1733 That is all that the EXTRA_SPECS macro gives us. */
1734 struct spec_list_1
1735 {
1736 const char *const name;
1737 const char *const ptr;
1738 };
1739
1740 static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1741 static struct spec_list *extra_specs = (struct spec_list *) 0;
1742 #endif
1743
1744 /* List of dynamically allocates specs that have been defined so far. */
1745
1746 static struct spec_list *specs = (struct spec_list *) 0;
1747
1748 /* List of static spec functions. */
1749
1750 static const struct spec_function static_spec_functions[] =
1751 {
1752 { "getenv", getenv_spec_function },
1753 { "if-exists", if_exists_spec_function },
1754 { "if-exists-else", if_exists_else_spec_function },
1755 { "if-exists-then-else", if_exists_then_else_spec_function },
1756 { "sanitize", sanitize_spec_function },
1757 { "replace-outfile", replace_outfile_spec_function },
1758 { "remove-outfile", remove_outfile_spec_function },
1759 { "version-compare", version_compare_spec_function },
1760 { "include", include_spec_function },
1761 { "find-file", find_file_spec_function },
1762 { "find-plugindir", find_plugindir_spec_function },
1763 { "print-asm-header", print_asm_header_spec_function },
1764 { "compare-debug-dump-opt", compare_debug_dump_opt_spec_function },
1765 { "compare-debug-self-opt", compare_debug_self_opt_spec_function },
1766 { "pass-through-libs", pass_through_libs_spec_func },
1767 { "dumps", dumps_spec_func },
1768 { "gt", greater_than_spec_func },
1769 { "debug-level-gt", debug_level_greater_than_spec_func },
1770 { "dwarf-version-gt", dwarf_version_greater_than_spec_func },
1771 { "fortran-preinclude-file", find_fortran_preinclude_file},
1772 #ifdef EXTRA_SPEC_FUNCTIONS
1773 EXTRA_SPEC_FUNCTIONS
1774 #endif
1775 { 0, 0 }
1776 };
1777
1778 static int processing_spec_function;
1779
1780 /* Add appropriate libgcc specs to OBSTACK, taking into account
1781 various permutations of -shared-libgcc, -shared, and such. */
1782
1783 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1784
1785 #ifndef USE_LD_AS_NEEDED
1786 #define USE_LD_AS_NEEDED 0
1787 #endif
1788
1789 static void
init_gcc_specs(struct obstack * obstack,const char * shared_name,const char * static_name,const char * eh_name)1790 init_gcc_specs (struct obstack *obstack, const char *shared_name,
1791 const char *static_name, const char *eh_name)
1792 {
1793 char *buf;
1794
1795 #if USE_LD_AS_NEEDED
1796 buf = concat ("%{static|static-libgcc|static-pie:", static_name, " ", eh_name, "}"
1797 "%{!static:%{!static-libgcc:%{!static-pie:"
1798 "%{!shared-libgcc:",
1799 static_name, " " LD_AS_NEEDED_OPTION " ",
1800 shared_name, " " LD_NO_AS_NEEDED_OPTION
1801 "}"
1802 "%{shared-libgcc:",
1803 shared_name, "%{!shared: ", static_name, "}"
1804 "}}"
1805 #else
1806 buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name, "}"
1807 "%{!static:%{!static-libgcc:"
1808 "%{!shared:"
1809 "%{!shared-libgcc:", static_name, " ", eh_name, "}"
1810 "%{shared-libgcc:", shared_name, " ", static_name, "}"
1811 "}"
1812 #ifdef LINK_EH_SPEC
1813 "%{shared:"
1814 "%{shared-libgcc:", shared_name, "}"
1815 "%{!shared-libgcc:", static_name, "}"
1816 "}"
1817 #else
1818 "%{shared:", shared_name, "}"
1819 #endif
1820 #endif
1821 "}}", NULL);
1822
1823 obstack_grow (obstack, buf, strlen (buf));
1824 free (buf);
1825 }
1826 #endif /* ENABLE_SHARED_LIBGCC */
1827
1828 /* Initialize the specs lookup routines. */
1829
1830 static void
init_spec(void)1831 init_spec (void)
1832 {
1833 struct spec_list *next = (struct spec_list *) 0;
1834 struct spec_list *sl = (struct spec_list *) 0;
1835 int i;
1836
1837 if (specs)
1838 return; /* Already initialized. */
1839
1840 if (verbose_flag)
1841 fnotice (stderr, "Using built-in specs.\n");
1842
1843 #ifdef EXTRA_SPECS
1844 extra_specs = XCNEWVEC (struct spec_list, ARRAY_SIZE (extra_specs_1));
1845
1846 for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--)
1847 {
1848 sl = &extra_specs[i];
1849 sl->name = extra_specs_1[i].name;
1850 sl->ptr = extra_specs_1[i].ptr;
1851 sl->next = next;
1852 sl->name_len = strlen (sl->name);
1853 sl->ptr_spec = &sl->ptr;
1854 gcc_assert (sl->ptr_spec != NULL);
1855 sl->default_ptr = sl->ptr;
1856 next = sl;
1857 }
1858 #endif
1859
1860 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1861 {
1862 sl = &static_specs[i];
1863 sl->next = next;
1864 next = sl;
1865 }
1866
1867 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1868 /* ??? If neither -shared-libgcc nor --static-libgcc was
1869 seen, then we should be making an educated guess. Some proposed
1870 heuristics for ELF include:
1871
1872 (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1873 program will be doing dynamic loading, which will likely
1874 need the shared libgcc.
1875
1876 (2) If "-ldl", then it's also a fair bet that we're doing
1877 dynamic loading.
1878
1879 (3) For each ET_DYN we're linking against (either through -lfoo
1880 or /some/path/foo.so), check to see whether it or one of
1881 its dependencies depends on a shared libgcc.
1882
1883 (4) If "-shared"
1884
1885 If the runtime is fixed to look for program headers instead
1886 of calling __register_frame_info at all, for each object,
1887 use the shared libgcc if any EH symbol referenced.
1888
1889 If crtstuff is fixed to not invoke __register_frame_info
1890 automatically, for each object, use the shared libgcc if
1891 any non-empty unwind section found.
1892
1893 Doing any of this probably requires invoking an external program to
1894 do the actual object file scanning. */
1895 {
1896 const char *p = libgcc_spec;
1897 int in_sep = 1;
1898
1899 /* Transform the extant libgcc_spec into one that uses the shared libgcc
1900 when given the proper command line arguments. */
1901 while (*p)
1902 {
1903 if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
1904 {
1905 init_gcc_specs (&obstack,
1906 "-lgcc_s"
1907 #ifdef USE_LIBUNWIND_EXCEPTIONS
1908 " -lunwind"
1909 #endif
1910 ,
1911 "-lgcc",
1912 "-lgcc_eh"
1913 #ifdef USE_LIBUNWIND_EXCEPTIONS
1914 # ifdef HAVE_LD_STATIC_DYNAMIC
1915 " %{!static:%{!static-pie:" LD_STATIC_OPTION "}} -lunwind"
1916 " %{!static:%{!static-pie:" LD_DYNAMIC_OPTION "}}"
1917 # else
1918 " -lunwind"
1919 # endif
1920 #endif
1921 );
1922
1923 p += 5;
1924 in_sep = 0;
1925 }
1926 else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0)
1927 {
1928 /* Ug. We don't know shared library extensions. Hope that
1929 systems that use this form don't do shared libraries. */
1930 init_gcc_specs (&obstack,
1931 "-lgcc_s",
1932 "libgcc.a%s",
1933 "libgcc_eh.a%s"
1934 #ifdef USE_LIBUNWIND_EXCEPTIONS
1935 " -lunwind"
1936 #endif
1937 );
1938 p += 10;
1939 in_sep = 0;
1940 }
1941 else
1942 {
1943 obstack_1grow (&obstack, *p);
1944 in_sep = (*p == ' ');
1945 p += 1;
1946 }
1947 }
1948
1949 obstack_1grow (&obstack, '\0');
1950 libgcc_spec = XOBFINISH (&obstack, const char *);
1951 }
1952 #endif
1953 #ifdef USE_AS_TRADITIONAL_FORMAT
1954 /* Prepend "--traditional-format" to whatever asm_spec we had before. */
1955 {
1956 static const char tf[] = "--traditional-format ";
1957 obstack_grow (&obstack, tf, sizeof (tf) - 1);
1958 obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
1959 asm_spec = XOBFINISH (&obstack, const char *);
1960 }
1961 #endif
1962
1963 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC || \
1964 defined LINKER_HASH_STYLE
1965 # ifdef LINK_BUILDID_SPEC
1966 /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. */
1967 obstack_grow (&obstack, LINK_BUILDID_SPEC, sizeof (LINK_BUILDID_SPEC) - 1);
1968 # endif
1969 # ifdef LINK_EH_SPEC
1970 /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
1971 obstack_grow (&obstack, LINK_EH_SPEC, sizeof (LINK_EH_SPEC) - 1);
1972 # endif
1973 # ifdef LINKER_HASH_STYLE
1974 /* Prepend --hash-style=LINKER_HASH_STYLE to whatever link_spec we had
1975 before. */
1976 {
1977 static const char hash_style[] = "--hash-style=";
1978 obstack_grow (&obstack, hash_style, sizeof (hash_style) - 1);
1979 obstack_grow (&obstack, LINKER_HASH_STYLE, sizeof (LINKER_HASH_STYLE) - 1);
1980 obstack_1grow (&obstack, ' ');
1981 }
1982 # endif
1983 obstack_grow0 (&obstack, link_spec, strlen (link_spec));
1984 link_spec = XOBFINISH (&obstack, const char *);
1985 #endif
1986
1987 specs = sl;
1988 }
1989
1990 /* Update the entry for SPEC in the static_specs table to point to VALUE,
1991 ensuring that we free the previous value if necessary. Set alloc_p for the
1992 entry to ALLOC_P: this determines whether we take ownership of VALUE (i.e.
1993 whether we need to free it later on). */
1994 static void
set_static_spec(const char ** spec,const char * value,bool alloc_p)1995 set_static_spec (const char **spec, const char *value, bool alloc_p)
1996 {
1997 struct spec_list *sl = NULL;
1998
1999 for (unsigned i = 0; i < ARRAY_SIZE (static_specs); i++)
2000 {
2001 if (static_specs[i].ptr_spec == spec)
2002 {
2003 sl = static_specs + i;
2004 break;
2005 }
2006 }
2007
2008 gcc_assert (sl);
2009
2010 if (sl->alloc_p)
2011 {
2012 const char *old = *spec;
2013 free (const_cast <char *> (old));
2014 }
2015
2016 *spec = value;
2017 sl->alloc_p = alloc_p;
2018 }
2019
2020 /* Update a static spec to a new string, taking ownership of that
2021 string's memory. */
set_static_spec_owned(const char ** spec,const char * val)2022 static void set_static_spec_owned (const char **spec, const char *val)
2023 {
2024 return set_static_spec (spec, val, true);
2025 }
2026
2027 /* Update a static spec to point to a new value, but don't take
2028 ownership of (i.e. don't free) that string. */
set_static_spec_shared(const char ** spec,const char * val)2029 static void set_static_spec_shared (const char **spec, const char *val)
2030 {
2031 return set_static_spec (spec, val, false);
2032 }
2033
2034
2035 /* Change the value of spec NAME to SPEC. If SPEC is empty, then the spec is
2036 removed; If the spec starts with a + then SPEC is added to the end of the
2037 current spec. */
2038
2039 static void
set_spec(const char * name,const char * spec,bool user_p)2040 set_spec (const char *name, const char *spec, bool user_p)
2041 {
2042 struct spec_list *sl;
2043 const char *old_spec;
2044 int name_len = strlen (name);
2045 int i;
2046
2047 /* If this is the first call, initialize the statically allocated specs. */
2048 if (!specs)
2049 {
2050 struct spec_list *next = (struct spec_list *) 0;
2051 for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
2052 {
2053 sl = &static_specs[i];
2054 sl->next = next;
2055 next = sl;
2056 }
2057 specs = sl;
2058 }
2059
2060 /* See if the spec already exists. */
2061 for (sl = specs; sl; sl = sl->next)
2062 if (name_len == sl->name_len && !strcmp (sl->name, name))
2063 break;
2064
2065 if (!sl)
2066 {
2067 /* Not found - make it. */
2068 sl = XNEW (struct spec_list);
2069 sl->name = xstrdup (name);
2070 sl->name_len = name_len;
2071 sl->ptr_spec = &sl->ptr;
2072 sl->alloc_p = 0;
2073 *(sl->ptr_spec) = "";
2074 sl->next = specs;
2075 sl->default_ptr = NULL;
2076 specs = sl;
2077 }
2078
2079 old_spec = *(sl->ptr_spec);
2080 *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
2081 ? concat (old_spec, spec + 1, NULL)
2082 : xstrdup (spec));
2083
2084 #ifdef DEBUG_SPECS
2085 if (verbose_flag)
2086 fnotice (stderr, "Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
2087 #endif
2088
2089 /* Free the old spec. */
2090 if (old_spec && sl->alloc_p)
2091 free (CONST_CAST (char *, old_spec));
2092
2093 sl->user_p = user_p;
2094 sl->alloc_p = true;
2095 }
2096
2097 /* Accumulate a command (program name and args), and run it. */
2098
2099 typedef const char *const_char_p; /* For DEF_VEC_P. */
2100
2101 /* Vector of pointers to arguments in the current line of specifications. */
2102 static vec<const_char_p> argbuf;
2103
2104 /* Likewise, but for the current @file. */
2105 static vec<const_char_p> at_file_argbuf;
2106
2107 /* Whether an @file is currently open. */
2108 static bool in_at_file = false;
2109
2110 /* Were the options -c, -S or -E passed. */
2111 static int have_c = 0;
2112
2113 /* Was the option -o passed. */
2114 static int have_o = 0;
2115
2116 /* Was the option -E passed. */
2117 static int have_E = 0;
2118
2119 /* Pointer to output file name passed in with -o. */
2120 static const char *output_file = 0;
2121
2122 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
2123 temp file. If the HOST_BIT_BUCKET is used for %j, no entry is made for
2124 it here. */
2125
2126 static struct temp_name {
2127 const char *suffix; /* suffix associated with the code. */
2128 int length; /* strlen (suffix). */
2129 int unique; /* Indicates whether %g or %u/%U was used. */
2130 const char *filename; /* associated filename. */
2131 int filename_length; /* strlen (filename). */
2132 struct temp_name *next;
2133 } *temp_names;
2134
2135 /* Number of commands executed so far. */
2136
2137 static int execution_count;
2138
2139 /* Number of commands that exited with a signal. */
2140
2141 static int signal_count;
2142
2143 /* Allocate the argument vector. */
2144
2145 static void
alloc_args(void)2146 alloc_args (void)
2147 {
2148 argbuf.create (10);
2149 at_file_argbuf.create (10);
2150 }
2151
2152 /* Clear out the vector of arguments (after a command is executed). */
2153
2154 static void
clear_args(void)2155 clear_args (void)
2156 {
2157 argbuf.truncate (0);
2158 at_file_argbuf.truncate (0);
2159 }
2160
2161 /* Add one argument to the vector at the end.
2162 This is done when a space is seen or at the end of the line.
2163 If DELETE_ALWAYS is nonzero, the arg is a filename
2164 and the file should be deleted eventually.
2165 If DELETE_FAILURE is nonzero, the arg is a filename
2166 and the file should be deleted if this compilation fails. */
2167
2168 static void
store_arg(const char * arg,int delete_always,int delete_failure)2169 store_arg (const char *arg, int delete_always, int delete_failure)
2170 {
2171 if (in_at_file)
2172 at_file_argbuf.safe_push (arg);
2173 else
2174 argbuf.safe_push (arg);
2175
2176 if (delete_always || delete_failure)
2177 {
2178 const char *p;
2179 /* If the temporary file we should delete is specified as
2180 part of a joined argument extract the filename. */
2181 if (arg[0] == '-'
2182 && (p = strrchr (arg, '=')))
2183 arg = p + 1;
2184 record_temp_file (arg, delete_always, delete_failure);
2185 }
2186 }
2187
2188 /* Open a temporary @file into which subsequent arguments will be stored. */
2189
2190 static void
open_at_file(void)2191 open_at_file (void)
2192 {
2193 if (in_at_file)
2194 fatal_error (input_location, "cannot open nested response file");
2195 else
2196 in_at_file = true;
2197 }
2198
2199 /* Create a temporary @file name. */
2200
make_at_file(void)2201 static char *make_at_file (void)
2202 {
2203 static int fileno = 0;
2204 char filename[20];
2205 const char *base, *ext;
2206
2207 if (!save_temps_flag)
2208 return make_temp_file ("");
2209
2210 base = dumpbase;
2211 if (!(base && *base))
2212 base = dumpdir;
2213 if (!(base && *base))
2214 base = "a";
2215
2216 sprintf (filename, ".args.%d", fileno++);
2217 ext = filename;
2218
2219 if (base == dumpdir && dumpdir_trailing_dash_added)
2220 ext++;
2221
2222 return concat (base, ext, NULL);
2223 }
2224
2225 /* Close the temporary @file and add @file to the argument list. */
2226
2227 static void
close_at_file(void)2228 close_at_file (void)
2229 {
2230 if (!in_at_file)
2231 fatal_error (input_location, "cannot close nonexistent response file");
2232
2233 in_at_file = false;
2234
2235 const unsigned int n_args = at_file_argbuf.length ();
2236 if (n_args == 0)
2237 return;
2238
2239 char **argv = (char **) alloca (sizeof (char *) * (n_args + 1));
2240 char *temp_file = make_at_file ();
2241 char *at_argument = concat ("@", temp_file, NULL);
2242 FILE *f = fopen (temp_file, "w");
2243 int status;
2244 unsigned int i;
2245
2246 /* Copy the strings over. */
2247 for (i = 0; i < n_args; i++)
2248 argv[i] = CONST_CAST (char *, at_file_argbuf[i]);
2249 argv[i] = NULL;
2250
2251 at_file_argbuf.truncate (0);
2252
2253 if (f == NULL)
2254 fatal_error (input_location, "could not open temporary response file %s",
2255 temp_file);
2256
2257 status = writeargv (argv, f);
2258
2259 if (status)
2260 fatal_error (input_location,
2261 "could not write to temporary response file %s",
2262 temp_file);
2263
2264 status = fclose (f);
2265
2266 if (status == EOF)
2267 fatal_error (input_location, "could not close temporary response file %s",
2268 temp_file);
2269
2270 store_arg (at_argument, 0, 0);
2271
2272 record_temp_file (temp_file, !save_temps_flag, !save_temps_flag);
2273 }
2274
2275 /* Load specs from a file name named FILENAME, replacing occurrences of
2276 various different types of line-endings, \r\n, \n\r and just \r, with
2277 a single \n. */
2278
2279 static char *
load_specs(const char * filename)2280 load_specs (const char *filename)
2281 {
2282 int desc;
2283 int readlen;
2284 struct stat statbuf;
2285 char *buffer;
2286 char *buffer_p;
2287 char *specs;
2288 char *specs_p;
2289
2290 if (verbose_flag)
2291 fnotice (stderr, "Reading specs from %s\n", filename);
2292
2293 /* Open and stat the file. */
2294 desc = open (filename, O_RDONLY, 0);
2295 if (desc < 0)
2296 {
2297 failed:
2298 /* This leaves DESC open, but the OS will save us. */
2299 fatal_error (input_location, "cannot read spec file %qs: %m", filename);
2300 }
2301
2302 if (stat (filename, &statbuf) < 0)
2303 goto failed;
2304
2305 /* Read contents of file into BUFFER. */
2306 buffer = XNEWVEC (char, statbuf.st_size + 1);
2307 readlen = read (desc, buffer, (unsigned) statbuf.st_size);
2308 if (readlen < 0)
2309 goto failed;
2310 buffer[readlen] = 0;
2311 close (desc);
2312
2313 specs = XNEWVEC (char, readlen + 1);
2314 specs_p = specs;
2315 for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
2316 {
2317 int skip = 0;
2318 char c = *buffer_p;
2319 if (c == '\r')
2320 {
2321 if (buffer_p > buffer && *(buffer_p - 1) == '\n') /* \n\r */
2322 skip = 1;
2323 else if (*(buffer_p + 1) == '\n') /* \r\n */
2324 skip = 1;
2325 else /* \r */
2326 c = '\n';
2327 }
2328 if (! skip)
2329 *specs_p++ = c;
2330 }
2331 *specs_p = '\0';
2332
2333 free (buffer);
2334 return (specs);
2335 }
2336
2337 /* Read compilation specs from a file named FILENAME,
2338 replacing the default ones.
2339
2340 A suffix which starts with `*' is a definition for
2341 one of the machine-specific sub-specs. The "suffix" should be
2342 *asm, *cc1, *cpp, *link, *startfile, etc.
2343 The corresponding spec is stored in asm_spec, etc.,
2344 rather than in the `compilers' vector.
2345
2346 Anything invalid in the file is a fatal error. */
2347
2348 static void
read_specs(const char * filename,bool main_p,bool user_p)2349 read_specs (const char *filename, bool main_p, bool user_p)
2350 {
2351 char *buffer;
2352 char *p;
2353
2354 buffer = load_specs (filename);
2355
2356 /* Scan BUFFER for specs, putting them in the vector. */
2357 p = buffer;
2358 while (1)
2359 {
2360 char *suffix;
2361 char *spec;
2362 char *in, *out, *p1, *p2, *p3;
2363
2364 /* Advance P in BUFFER to the next nonblank nocomment line. */
2365 p = skip_whitespace (p);
2366 if (*p == 0)
2367 break;
2368
2369 /* Is this a special command that starts with '%'? */
2370 /* Don't allow this for the main specs file, since it would
2371 encourage people to overwrite it. */
2372 if (*p == '%' && !main_p)
2373 {
2374 p1 = p;
2375 while (*p && *p != '\n')
2376 p++;
2377
2378 /* Skip '\n'. */
2379 p++;
2380
2381 if (!strncmp (p1, "%include", sizeof ("%include") - 1)
2382 && (p1[sizeof "%include" - 1] == ' '
2383 || p1[sizeof "%include" - 1] == '\t'))
2384 {
2385 char *new_filename;
2386
2387 p1 += sizeof ("%include");
2388 while (*p1 == ' ' || *p1 == '\t')
2389 p1++;
2390
2391 if (*p1++ != '<' || p[-2] != '>')
2392 fatal_error (input_location,
2393 "specs %%include syntax malformed after "
2394 "%ld characters",
2395 (long) (p1 - buffer + 1));
2396
2397 p[-2] = '\0';
2398 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
2399 read_specs (new_filename ? new_filename : p1, false, user_p);
2400 continue;
2401 }
2402 else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
2403 && (p1[sizeof "%include_noerr" - 1] == ' '
2404 || p1[sizeof "%include_noerr" - 1] == '\t'))
2405 {
2406 char *new_filename;
2407
2408 p1 += sizeof "%include_noerr";
2409 while (*p1 == ' ' || *p1 == '\t')
2410 p1++;
2411
2412 if (*p1++ != '<' || p[-2] != '>')
2413 fatal_error (input_location,
2414 "specs %%include syntax malformed after "
2415 "%ld characters",
2416 (long) (p1 - buffer + 1));
2417
2418 p[-2] = '\0';
2419 new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
2420 if (new_filename)
2421 read_specs (new_filename, false, user_p);
2422 else if (verbose_flag)
2423 fnotice (stderr, "could not find specs file %s\n", p1);
2424 continue;
2425 }
2426 else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
2427 && (p1[sizeof "%rename" - 1] == ' '
2428 || p1[sizeof "%rename" - 1] == '\t'))
2429 {
2430 int name_len;
2431 struct spec_list *sl;
2432 struct spec_list *newsl;
2433
2434 /* Get original name. */
2435 p1 += sizeof "%rename";
2436 while (*p1 == ' ' || *p1 == '\t')
2437 p1++;
2438
2439 if (! ISALPHA ((unsigned char) *p1))
2440 fatal_error (input_location,
2441 "specs %%rename syntax malformed after "
2442 "%ld characters",
2443 (long) (p1 - buffer));
2444
2445 p2 = p1;
2446 while (*p2 && !ISSPACE ((unsigned char) *p2))
2447 p2++;
2448
2449 if (*p2 != ' ' && *p2 != '\t')
2450 fatal_error (input_location,
2451 "specs %%rename syntax malformed after "
2452 "%ld characters",
2453 (long) (p2 - buffer));
2454
2455 name_len = p2 - p1;
2456 *p2++ = '\0';
2457 while (*p2 == ' ' || *p2 == '\t')
2458 p2++;
2459
2460 if (! ISALPHA ((unsigned char) *p2))
2461 fatal_error (input_location,
2462 "specs %%rename syntax malformed after "
2463 "%ld characters",
2464 (long) (p2 - buffer));
2465
2466 /* Get new spec name. */
2467 p3 = p2;
2468 while (*p3 && !ISSPACE ((unsigned char) *p3))
2469 p3++;
2470
2471 if (p3 != p - 1)
2472 fatal_error (input_location,
2473 "specs %%rename syntax malformed after "
2474 "%ld characters",
2475 (long) (p3 - buffer));
2476 *p3 = '\0';
2477
2478 for (sl = specs; sl; sl = sl->next)
2479 if (name_len == sl->name_len && !strcmp (sl->name, p1))
2480 break;
2481
2482 if (!sl)
2483 fatal_error (input_location,
2484 "specs %s spec was not found to be renamed", p1);
2485
2486 if (strcmp (p1, p2) == 0)
2487 continue;
2488
2489 for (newsl = specs; newsl; newsl = newsl->next)
2490 if (strcmp (newsl->name, p2) == 0)
2491 fatal_error (input_location,
2492 "%s: attempt to rename spec %qs to "
2493 "already defined spec %qs",
2494 filename, p1, p2);
2495
2496 if (verbose_flag)
2497 {
2498 fnotice (stderr, "rename spec %s to %s\n", p1, p2);
2499 #ifdef DEBUG_SPECS
2500 fnotice (stderr, "spec is '%s'\n\n", *(sl->ptr_spec));
2501 #endif
2502 }
2503
2504 set_spec (p2, *(sl->ptr_spec), user_p);
2505 if (sl->alloc_p)
2506 free (CONST_CAST (char *, *(sl->ptr_spec)));
2507
2508 *(sl->ptr_spec) = "";
2509 sl->alloc_p = 0;
2510 continue;
2511 }
2512 else
2513 fatal_error (input_location,
2514 "specs unknown %% command after %ld characters",
2515 (long) (p1 - buffer));
2516 }
2517
2518 /* Find the colon that should end the suffix. */
2519 p1 = p;
2520 while (*p1 && *p1 != ':' && *p1 != '\n')
2521 p1++;
2522
2523 /* The colon shouldn't be missing. */
2524 if (*p1 != ':')
2525 fatal_error (input_location,
2526 "specs file malformed after %ld characters",
2527 (long) (p1 - buffer));
2528
2529 /* Skip back over trailing whitespace. */
2530 p2 = p1;
2531 while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
2532 p2--;
2533
2534 /* Copy the suffix to a string. */
2535 suffix = save_string (p, p2 - p);
2536 /* Find the next line. */
2537 p = skip_whitespace (p1 + 1);
2538 if (p[1] == 0)
2539 fatal_error (input_location,
2540 "specs file malformed after %ld characters",
2541 (long) (p - buffer));
2542
2543 p1 = p;
2544 /* Find next blank line or end of string. */
2545 while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
2546 p1++;
2547
2548 /* Specs end at the blank line and do not include the newline. */
2549 spec = save_string (p, p1 - p);
2550 p = p1;
2551
2552 /* Delete backslash-newline sequences from the spec. */
2553 in = spec;
2554 out = spec;
2555 while (*in != 0)
2556 {
2557 if (in[0] == '\\' && in[1] == '\n')
2558 in += 2;
2559 else if (in[0] == '#')
2560 while (*in && *in != '\n')
2561 in++;
2562
2563 else
2564 *out++ = *in++;
2565 }
2566 *out = 0;
2567
2568 if (suffix[0] == '*')
2569 {
2570 if (! strcmp (suffix, "*link_command"))
2571 link_command_spec = spec;
2572 else
2573 {
2574 set_spec (suffix + 1, spec, user_p);
2575 free (spec);
2576 }
2577 }
2578 else
2579 {
2580 /* Add this pair to the vector. */
2581 compilers
2582 = XRESIZEVEC (struct compiler, compilers, n_compilers + 2);
2583
2584 compilers[n_compilers].suffix = suffix;
2585 compilers[n_compilers].spec = spec;
2586 n_compilers++;
2587 memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
2588 }
2589
2590 if (*suffix == 0)
2591 link_command_spec = spec;
2592 }
2593
2594 if (link_command_spec == 0)
2595 fatal_error (input_location, "spec file has no spec for linking");
2596
2597 XDELETEVEC (buffer);
2598 }
2599
2600 /* Record the names of temporary files we tell compilers to write,
2601 and delete them at the end of the run. */
2602
2603 /* This is the common prefix we use to make temp file names.
2604 It is chosen once for each run of this program.
2605 It is substituted into a spec by %g or %j.
2606 Thus, all temp file names contain this prefix.
2607 In practice, all temp file names start with this prefix.
2608
2609 This prefix comes from the envvar TMPDIR if it is defined;
2610 otherwise, from the P_tmpdir macro if that is defined;
2611 otherwise, in /usr/tmp or /tmp;
2612 or finally the current directory if all else fails. */
2613
2614 static const char *temp_filename;
2615
2616 /* Length of the prefix. */
2617
2618 static int temp_filename_length;
2619
2620 /* Define the list of temporary files to delete. */
2621
2622 struct temp_file
2623 {
2624 const char *name;
2625 struct temp_file *next;
2626 };
2627
2628 /* Queue of files to delete on success or failure of compilation. */
2629 static struct temp_file *always_delete_queue;
2630 /* Queue of files to delete on failure of compilation. */
2631 static struct temp_file *failure_delete_queue;
2632
2633 /* Record FILENAME as a file to be deleted automatically.
2634 ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2635 otherwise delete it in any case.
2636 FAIL_DELETE nonzero means delete it if a compilation step fails;
2637 otherwise delete it in any case. */
2638
2639 void
record_temp_file(const char * filename,int always_delete,int fail_delete)2640 record_temp_file (const char *filename, int always_delete, int fail_delete)
2641 {
2642 char *const name = xstrdup (filename);
2643
2644 if (always_delete)
2645 {
2646 struct temp_file *temp;
2647 for (temp = always_delete_queue; temp; temp = temp->next)
2648 if (! filename_cmp (name, temp->name))
2649 {
2650 free (name);
2651 goto already1;
2652 }
2653
2654 temp = XNEW (struct temp_file);
2655 temp->next = always_delete_queue;
2656 temp->name = name;
2657 always_delete_queue = temp;
2658
2659 already1:;
2660 }
2661
2662 if (fail_delete)
2663 {
2664 struct temp_file *temp;
2665 for (temp = failure_delete_queue; temp; temp = temp->next)
2666 if (! filename_cmp (name, temp->name))
2667 {
2668 free (name);
2669 goto already2;
2670 }
2671
2672 temp = XNEW (struct temp_file);
2673 temp->next = failure_delete_queue;
2674 temp->name = name;
2675 failure_delete_queue = temp;
2676
2677 already2:;
2678 }
2679 }
2680
2681 /* Delete all the temporary files whose names we previously recorded. */
2682
2683 #ifndef DELETE_IF_ORDINARY
2684 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG) \
2685 do \
2686 { \
2687 if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode)) \
2688 if (unlink (NAME) < 0) \
2689 if (VERBOSE_FLAG) \
2690 error ("%s: %m", (NAME)); \
2691 } while (0)
2692 #endif
2693
2694 static void
delete_if_ordinary(const char * name)2695 delete_if_ordinary (const char *name)
2696 {
2697 struct stat st;
2698 #ifdef DEBUG
2699 int i, c;
2700
2701 printf ("Delete %s? (y or n) ", name);
2702 fflush (stdout);
2703 i = getchar ();
2704 if (i != '\n')
2705 while ((c = getchar ()) != '\n' && c != EOF)
2706 ;
2707
2708 if (i == 'y' || i == 'Y')
2709 #endif /* DEBUG */
2710 DELETE_IF_ORDINARY (name, st, verbose_flag);
2711 }
2712
2713 static void
delete_temp_files(void)2714 delete_temp_files (void)
2715 {
2716 struct temp_file *temp;
2717
2718 for (temp = always_delete_queue; temp; temp = temp->next)
2719 delete_if_ordinary (temp->name);
2720 always_delete_queue = 0;
2721 }
2722
2723 /* Delete all the files to be deleted on error. */
2724
2725 static void
delete_failure_queue(void)2726 delete_failure_queue (void)
2727 {
2728 struct temp_file *temp;
2729
2730 for (temp = failure_delete_queue; temp; temp = temp->next)
2731 delete_if_ordinary (temp->name);
2732 }
2733
2734 static void
clear_failure_queue(void)2735 clear_failure_queue (void)
2736 {
2737 failure_delete_queue = 0;
2738 }
2739
2740 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2741 returns non-NULL.
2742 If DO_MULTI is true iterate over the paths twice, first with multilib
2743 suffix then without, otherwise iterate over the paths once without
2744 adding a multilib suffix. When DO_MULTI is true, some attempt is made
2745 to avoid visiting the same path twice, but we could do better. For
2746 instance, /usr/lib/../lib is considered different from /usr/lib.
2747 At least EXTRA_SPACE chars past the end of the path passed to
2748 CALLBACK are available for use by the callback.
2749 CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2750
2751 Returns the value returned by CALLBACK. */
2752
2753 static void *
for_each_path(const struct path_prefix * paths,bool do_multi,size_t extra_space,void * (* callback)(char *,void *),void * callback_info)2754 for_each_path (const struct path_prefix *paths,
2755 bool do_multi,
2756 size_t extra_space,
2757 void *(*callback) (char *, void *),
2758 void *callback_info)
2759 {
2760 struct prefix_list *pl;
2761 const char *multi_dir = NULL;
2762 const char *multi_os_dir = NULL;
2763 const char *multiarch_suffix = NULL;
2764 const char *multi_suffix;
2765 const char *just_multi_suffix;
2766 char *path = NULL;
2767 void *ret = NULL;
2768 bool skip_multi_dir = false;
2769 bool skip_multi_os_dir = false;
2770
2771 multi_suffix = machine_suffix;
2772 just_multi_suffix = just_machine_suffix;
2773 if (do_multi && multilib_dir && strcmp (multilib_dir, ".") != 0)
2774 {
2775 multi_dir = concat (multilib_dir, dir_separator_str, NULL);
2776 multi_suffix = concat (multi_suffix, multi_dir, NULL);
2777 just_multi_suffix = concat (just_multi_suffix, multi_dir, NULL);
2778 }
2779 if (do_multi && multilib_os_dir && strcmp (multilib_os_dir, ".") != 0)
2780 multi_os_dir = concat (multilib_os_dir, dir_separator_str, NULL);
2781 if (multiarch_dir)
2782 multiarch_suffix = concat (multiarch_dir, dir_separator_str, NULL);
2783
2784 while (1)
2785 {
2786 size_t multi_dir_len = 0;
2787 size_t multi_os_dir_len = 0;
2788 size_t multiarch_len = 0;
2789 size_t suffix_len;
2790 size_t just_suffix_len;
2791 size_t len;
2792
2793 if (multi_dir)
2794 multi_dir_len = strlen (multi_dir);
2795 if (multi_os_dir)
2796 multi_os_dir_len = strlen (multi_os_dir);
2797 if (multiarch_suffix)
2798 multiarch_len = strlen (multiarch_suffix);
2799 suffix_len = strlen (multi_suffix);
2800 just_suffix_len = strlen (just_multi_suffix);
2801
2802 if (path == NULL)
2803 {
2804 len = paths->max_len + extra_space + 1;
2805 len += MAX (MAX (suffix_len, multi_os_dir_len), multiarch_len);
2806 path = XNEWVEC (char, len);
2807 }
2808
2809 for (pl = paths->plist; pl != 0; pl = pl->next)
2810 {
2811 len = strlen (pl->prefix);
2812 memcpy (path, pl->prefix, len);
2813
2814 /* Look first in MACHINE/VERSION subdirectory. */
2815 if (!skip_multi_dir)
2816 {
2817 memcpy (path + len, multi_suffix, suffix_len + 1);
2818 ret = callback (path, callback_info);
2819 if (ret)
2820 break;
2821 }
2822
2823 /* Some paths are tried with just the machine (ie. target)
2824 subdir. This is used for finding as, ld, etc. */
2825 if (!skip_multi_dir
2826 && pl->require_machine_suffix == 2)
2827 {
2828 memcpy (path + len, just_multi_suffix, just_suffix_len + 1);
2829 ret = callback (path, callback_info);
2830 if (ret)
2831 break;
2832 }
2833
2834 /* Now try the multiarch path. */
2835 if (!skip_multi_dir
2836 && !pl->require_machine_suffix && multiarch_dir)
2837 {
2838 memcpy (path + len, multiarch_suffix, multiarch_len + 1);
2839 ret = callback (path, callback_info);
2840 if (ret)
2841 break;
2842 }
2843
2844 /* Now try the base path. */
2845 if (!pl->require_machine_suffix
2846 && !(pl->os_multilib ? skip_multi_os_dir : skip_multi_dir))
2847 {
2848 const char *this_multi;
2849 size_t this_multi_len;
2850
2851 if (pl->os_multilib)
2852 {
2853 this_multi = multi_os_dir;
2854 this_multi_len = multi_os_dir_len;
2855 }
2856 else
2857 {
2858 this_multi = multi_dir;
2859 this_multi_len = multi_dir_len;
2860 }
2861
2862 if (this_multi_len)
2863 memcpy (path + len, this_multi, this_multi_len + 1);
2864 else
2865 path[len] = '\0';
2866
2867 ret = callback (path, callback_info);
2868 if (ret)
2869 break;
2870 }
2871 }
2872 if (pl)
2873 break;
2874
2875 if (multi_dir == NULL && multi_os_dir == NULL)
2876 break;
2877
2878 /* Run through the paths again, this time without multilibs.
2879 Don't repeat any we have already seen. */
2880 if (multi_dir)
2881 {
2882 free (CONST_CAST (char *, multi_dir));
2883 multi_dir = NULL;
2884 free (CONST_CAST (char *, multi_suffix));
2885 multi_suffix = machine_suffix;
2886 free (CONST_CAST (char *, just_multi_suffix));
2887 just_multi_suffix = just_machine_suffix;
2888 }
2889 else
2890 skip_multi_dir = true;
2891 if (multi_os_dir)
2892 {
2893 free (CONST_CAST (char *, multi_os_dir));
2894 multi_os_dir = NULL;
2895 }
2896 else
2897 skip_multi_os_dir = true;
2898 }
2899
2900 if (multi_dir)
2901 {
2902 free (CONST_CAST (char *, multi_dir));
2903 free (CONST_CAST (char *, multi_suffix));
2904 free (CONST_CAST (char *, just_multi_suffix));
2905 }
2906 if (multi_os_dir)
2907 free (CONST_CAST (char *, multi_os_dir));
2908 if (ret != path)
2909 free (path);
2910 return ret;
2911 }
2912
2913 /* Callback for build_search_list. Adds path to obstack being built. */
2914
2915 struct add_to_obstack_info {
2916 struct obstack *ob;
2917 bool check_dir;
2918 bool first_time;
2919 };
2920
2921 static void *
add_to_obstack(char * path,void * data)2922 add_to_obstack (char *path, void *data)
2923 {
2924 struct add_to_obstack_info *info = (struct add_to_obstack_info *) data;
2925
2926 if (info->check_dir && !is_directory (path, false))
2927 return NULL;
2928
2929 if (!info->first_time)
2930 obstack_1grow (info->ob, PATH_SEPARATOR);
2931
2932 obstack_grow (info->ob, path, strlen (path));
2933
2934 info->first_time = false;
2935 return NULL;
2936 }
2937
2938 /* Add or change the value of an environment variable, outputting the
2939 change to standard error if in verbose mode. */
2940 static void
xputenv(const char * string)2941 xputenv (const char *string)
2942 {
2943 env.xput (string);
2944 }
2945
2946 /* Build a list of search directories from PATHS.
2947 PREFIX is a string to prepend to the list.
2948 If CHECK_DIR_P is true we ensure the directory exists.
2949 If DO_MULTI is true, multilib paths are output first, then
2950 non-multilib paths.
2951 This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2952 It is also used by the --print-search-dirs flag. */
2953
2954 static char *
build_search_list(const struct path_prefix * paths,const char * prefix,bool check_dir,bool do_multi)2955 build_search_list (const struct path_prefix *paths, const char *prefix,
2956 bool check_dir, bool do_multi)
2957 {
2958 struct add_to_obstack_info info;
2959
2960 info.ob = &collect_obstack;
2961 info.check_dir = check_dir;
2962 info.first_time = true;
2963
2964 obstack_grow (&collect_obstack, prefix, strlen (prefix));
2965 obstack_1grow (&collect_obstack, '=');
2966
2967 for_each_path (paths, do_multi, 0, add_to_obstack, &info);
2968
2969 obstack_1grow (&collect_obstack, '\0');
2970 return XOBFINISH (&collect_obstack, char *);
2971 }
2972
2973 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2974 for collect. */
2975
2976 static void
putenv_from_prefixes(const struct path_prefix * paths,const char * env_var,bool do_multi)2977 putenv_from_prefixes (const struct path_prefix *paths, const char *env_var,
2978 bool do_multi)
2979 {
2980 xputenv (build_search_list (paths, env_var, true, do_multi));
2981 }
2982
2983 /* Check whether NAME can be accessed in MODE. This is like access,
2984 except that it never considers directories to be executable. */
2985
2986 static int
access_check(const char * name,int mode)2987 access_check (const char *name, int mode)
2988 {
2989 if (mode == X_OK)
2990 {
2991 struct stat st;
2992
2993 if (stat (name, &st) < 0
2994 || S_ISDIR (st.st_mode))
2995 return -1;
2996 }
2997
2998 return access (name, mode);
2999 }
3000
3001 /* Callback for find_a_file. Appends the file name to the directory
3002 path. If the resulting file exists in the right mode, return the
3003 full pathname to the file. */
3004
3005 struct file_at_path_info {
3006 const char *name;
3007 const char *suffix;
3008 int name_len;
3009 int suffix_len;
3010 int mode;
3011 };
3012
3013 static void *
file_at_path(char * path,void * data)3014 file_at_path (char *path, void *data)
3015 {
3016 struct file_at_path_info *info = (struct file_at_path_info *) data;
3017 size_t len = strlen (path);
3018
3019 memcpy (path + len, info->name, info->name_len);
3020 len += info->name_len;
3021
3022 /* Some systems have a suffix for executable files.
3023 So try appending that first. */
3024 if (info->suffix_len)
3025 {
3026 memcpy (path + len, info->suffix, info->suffix_len + 1);
3027 if (access_check (path, info->mode) == 0)
3028 return path;
3029 }
3030
3031 path[len] = '\0';
3032 if (access_check (path, info->mode) == 0)
3033 return path;
3034
3035 return NULL;
3036 }
3037
3038 /* Search for NAME using the prefix list PREFIXES. MODE is passed to
3039 access to check permissions. If DO_MULTI is true, search multilib
3040 paths then non-multilib paths, otherwise do not search multilib paths.
3041 Return 0 if not found, otherwise return its name, allocated with malloc. */
3042
3043 static char *
find_a_file(const struct path_prefix * pprefix,const char * name,int mode,bool do_multi)3044 find_a_file (const struct path_prefix *pprefix, const char *name, int mode,
3045 bool do_multi)
3046 {
3047 struct file_at_path_info info;
3048
3049 #ifdef DEFAULT_ASSEMBLER
3050 if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
3051 return xstrdup (DEFAULT_ASSEMBLER);
3052 #endif
3053
3054 #ifdef DEFAULT_LINKER
3055 if (! strcmp (name, "ld") && access (DEFAULT_LINKER, mode) == 0)
3056 return xstrdup (DEFAULT_LINKER);
3057 #endif
3058
3059 /* Determine the filename to execute (special case for absolute paths). */
3060
3061 if (IS_ABSOLUTE_PATH (name))
3062 {
3063 if (access (name, mode) == 0)
3064 return xstrdup (name);
3065
3066 return NULL;
3067 }
3068
3069 info.name = name;
3070 info.suffix = (mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "";
3071 info.name_len = strlen (info.name);
3072 info.suffix_len = strlen (info.suffix);
3073 info.mode = mode;
3074
3075 return (char*) for_each_path (pprefix, do_multi,
3076 info.name_len + info.suffix_len,
3077 file_at_path, &info);
3078 }
3079
3080 /* Ranking of prefixes in the sort list. -B prefixes are put before
3081 all others. */
3082
3083 enum path_prefix_priority
3084 {
3085 PREFIX_PRIORITY_B_OPT,
3086 PREFIX_PRIORITY_LAST
3087 };
3088
3089 /* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
3090 order according to PRIORITY. Within each PRIORITY, new entries are
3091 appended.
3092
3093 If WARN is nonzero, we will warn if no file is found
3094 through this prefix. WARN should point to an int
3095 which will be set to 1 if this entry is used.
3096
3097 COMPONENT is the value to be passed to update_path.
3098
3099 REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
3100 the complete value of machine_suffix.
3101 2 means try both machine_suffix and just_machine_suffix. */
3102
3103 static void
add_prefix(struct path_prefix * pprefix,const char * prefix,const char * component,int priority,int require_machine_suffix,int os_multilib)3104 add_prefix (struct path_prefix *pprefix, const char *prefix,
3105 const char *component, /* enum prefix_priority */ int priority,
3106 int require_machine_suffix, int os_multilib)
3107 {
3108 struct prefix_list *pl, **prev;
3109 int len;
3110
3111 for (prev = &pprefix->plist;
3112 (*prev) != NULL && (*prev)->priority <= priority;
3113 prev = &(*prev)->next)
3114 ;
3115
3116 /* Keep track of the longest prefix. */
3117
3118 prefix = update_path (prefix, component);
3119 len = strlen (prefix);
3120 if (len > pprefix->max_len)
3121 pprefix->max_len = len;
3122
3123 pl = XNEW (struct prefix_list);
3124 pl->prefix = prefix;
3125 pl->require_machine_suffix = require_machine_suffix;
3126 pl->priority = priority;
3127 pl->os_multilib = os_multilib;
3128
3129 /* Insert after PREV. */
3130 pl->next = (*prev);
3131 (*prev) = pl;
3132 }
3133
3134 /* Same as add_prefix, but prepending target_system_root to prefix. */
3135 /* The target_system_root prefix has been relocated by gcc_exec_prefix. */
3136 static void
add_sysrooted_prefix(struct path_prefix * pprefix,const char * prefix,const char * component,int priority,int require_machine_suffix,int os_multilib)3137 add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
3138 const char *component,
3139 /* enum prefix_priority */ int priority,
3140 int require_machine_suffix, int os_multilib)
3141 {
3142 if (!IS_ABSOLUTE_PATH (prefix))
3143 fatal_error (input_location, "system path %qs is not absolute", prefix);
3144
3145 if (target_system_root)
3146 {
3147 char *sysroot_no_trailing_dir_separator = xstrdup (target_system_root);
3148 size_t sysroot_len = strlen (target_system_root);
3149
3150 if (sysroot_len > 0
3151 && target_system_root[sysroot_len - 1] == DIR_SEPARATOR)
3152 sysroot_no_trailing_dir_separator[sysroot_len - 1] = '\0';
3153
3154 if (target_sysroot_suffix)
3155 prefix = concat (sysroot_no_trailing_dir_separator,
3156 target_sysroot_suffix, prefix, NULL);
3157 else
3158 prefix = concat (sysroot_no_trailing_dir_separator, prefix, NULL);
3159
3160 free (sysroot_no_trailing_dir_separator);
3161
3162 /* We have to override this because GCC's notion of sysroot
3163 moves along with GCC. */
3164 component = "GCC";
3165 }
3166
3167 add_prefix (pprefix, prefix, component, priority,
3168 require_machine_suffix, os_multilib);
3169 }
3170
3171 /* Same as add_prefix, but prepending target_sysroot_hdrs_suffix to prefix. */
3172
3173 static void
add_sysrooted_hdrs_prefix(struct path_prefix * pprefix,const char * prefix,const char * component,int priority,int require_machine_suffix,int os_multilib)3174 add_sysrooted_hdrs_prefix (struct path_prefix *pprefix, const char *prefix,
3175 const char *component,
3176 /* enum prefix_priority */ int priority,
3177 int require_machine_suffix, int os_multilib)
3178 {
3179 if (!IS_ABSOLUTE_PATH (prefix))
3180 fatal_error (input_location, "system path %qs is not absolute", prefix);
3181
3182 if (target_system_root)
3183 {
3184 char *sysroot_no_trailing_dir_separator = xstrdup (target_system_root);
3185 size_t sysroot_len = strlen (target_system_root);
3186
3187 if (sysroot_len > 0
3188 && target_system_root[sysroot_len - 1] == DIR_SEPARATOR)
3189 sysroot_no_trailing_dir_separator[sysroot_len - 1] = '\0';
3190
3191 if (target_sysroot_hdrs_suffix)
3192 prefix = concat (sysroot_no_trailing_dir_separator,
3193 target_sysroot_hdrs_suffix, prefix, NULL);
3194 else
3195 prefix = concat (sysroot_no_trailing_dir_separator, prefix, NULL);
3196
3197 free (sysroot_no_trailing_dir_separator);
3198
3199 /* We have to override this because GCC's notion of sysroot
3200 moves along with GCC. */
3201 component = "GCC";
3202 }
3203
3204 add_prefix (pprefix, prefix, component, priority,
3205 require_machine_suffix, os_multilib);
3206 }
3207
3208
3209 /* Execute the command specified by the arguments on the current line of spec.
3210 When using pipes, this includes several piped-together commands
3211 with `|' between them.
3212
3213 Return 0 if successful, -1 if failed. */
3214
3215 static int
execute(void)3216 execute (void)
3217 {
3218 int i;
3219 int n_commands; /* # of command. */
3220 char *string;
3221 struct pex_obj *pex;
3222 struct command
3223 {
3224 const char *prog; /* program name. */
3225 const char **argv; /* vector of args. */
3226 };
3227 const char *arg;
3228
3229 struct command *commands; /* each command buffer with above info. */
3230
3231 gcc_assert (!processing_spec_function);
3232
3233 if (wrapper_string)
3234 {
3235 string = find_a_file (&exec_prefixes,
3236 argbuf[0], X_OK, false);
3237 if (string)
3238 argbuf[0] = string;
3239 insert_wrapper (wrapper_string);
3240 }
3241
3242 /* Count # of piped commands. */
3243 for (n_commands = 1, i = 0; argbuf.iterate (i, &arg); i++)
3244 if (strcmp (arg, "|") == 0)
3245 n_commands++;
3246
3247 /* Get storage for each command. */
3248 commands = (struct command *) alloca (n_commands * sizeof (struct command));
3249
3250 /* Split argbuf into its separate piped processes,
3251 and record info about each one.
3252 Also search for the programs that are to be run. */
3253
3254 argbuf.safe_push (0);
3255
3256 commands[0].prog = argbuf[0]; /* first command. */
3257 commands[0].argv = argbuf.address ();
3258
3259 if (!wrapper_string)
3260 {
3261 string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, false);
3262 if (string)
3263 commands[0].argv[0] = string;
3264 }
3265
3266 for (n_commands = 1, i = 0; argbuf.iterate (i, &arg); i++)
3267 if (arg && strcmp (arg, "|") == 0)
3268 { /* each command. */
3269 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
3270 fatal_error (input_location, "%<-pipe%> not supported");
3271 #endif
3272 argbuf[i] = 0; /* Termination of command args. */
3273 commands[n_commands].prog = argbuf[i + 1];
3274 commands[n_commands].argv
3275 = &(argbuf.address ())[i + 1];
3276 string = find_a_file (&exec_prefixes, commands[n_commands].prog,
3277 X_OK, false);
3278 if (string)
3279 commands[n_commands].argv[0] = string;
3280 n_commands++;
3281 }
3282
3283 /* If -v, print what we are about to do, and maybe query. */
3284
3285 if (verbose_flag)
3286 {
3287 /* For help listings, put a blank line between sub-processes. */
3288 if (print_help_list)
3289 fputc ('\n', stderr);
3290
3291 /* Print each piped command as a separate line. */
3292 for (i = 0; i < n_commands; i++)
3293 {
3294 const char *const *j;
3295
3296 if (verbose_only_flag)
3297 {
3298 for (j = commands[i].argv; *j; j++)
3299 {
3300 const char *p;
3301 for (p = *j; *p; ++p)
3302 if (!ISALNUM ((unsigned char) *p)
3303 && *p != '_' && *p != '/' && *p != '-' && *p != '.')
3304 break;
3305 if (*p || !*j)
3306 {
3307 fprintf (stderr, " \"");
3308 for (p = *j; *p; ++p)
3309 {
3310 if (*p == '"' || *p == '\\' || *p == '$')
3311 fputc ('\\', stderr);
3312 fputc (*p, stderr);
3313 }
3314 fputc ('"', stderr);
3315 }
3316 /* If it's empty, print "". */
3317 else if (!**j)
3318 fprintf (stderr, " \"\"");
3319 else
3320 fprintf (stderr, " %s", *j);
3321 }
3322 }
3323 else
3324 for (j = commands[i].argv; *j; j++)
3325 /* If it's empty, print "". */
3326 if (!**j)
3327 fprintf (stderr, " \"\"");
3328 else
3329 fprintf (stderr, " %s", *j);
3330
3331 /* Print a pipe symbol after all but the last command. */
3332 if (i + 1 != n_commands)
3333 fprintf (stderr, " |");
3334 fprintf (stderr, "\n");
3335 }
3336 fflush (stderr);
3337 if (verbose_only_flag != 0)
3338 {
3339 /* verbose_only_flag should act as if the spec was
3340 executed, so increment execution_count before
3341 returning. This prevents spurious warnings about
3342 unused linker input files, etc. */
3343 execution_count++;
3344 return 0;
3345 }
3346 #ifdef DEBUG
3347 fnotice (stderr, "\nGo ahead? (y or n) ");
3348 fflush (stderr);
3349 i = getchar ();
3350 if (i != '\n')
3351 while (getchar () != '\n')
3352 ;
3353
3354 if (i != 'y' && i != 'Y')
3355 return 0;
3356 #endif /* DEBUG */
3357 }
3358
3359 #ifdef ENABLE_VALGRIND_CHECKING
3360 /* Run the each command through valgrind. To simplify prepending the
3361 path to valgrind and the option "-q" (for quiet operation unless
3362 something triggers), we allocate a separate argv array. */
3363
3364 for (i = 0; i < n_commands; i++)
3365 {
3366 const char **argv;
3367 int argc;
3368 int j;
3369
3370 for (argc = 0; commands[i].argv[argc] != NULL; argc++)
3371 ;
3372
3373 argv = XALLOCAVEC (const char *, argc + 3);
3374
3375 argv[0] = VALGRIND_PATH;
3376 argv[1] = "-q";
3377 for (j = 2; j < argc + 2; j++)
3378 argv[j] = commands[i].argv[j - 2];
3379 argv[j] = NULL;
3380
3381 commands[i].argv = argv;
3382 commands[i].prog = argv[0];
3383 }
3384 #endif
3385
3386 /* Run each piped subprocess. */
3387
3388 pex = pex_init (PEX_USE_PIPES | ((report_times || report_times_to_file)
3389 ? PEX_RECORD_TIMES : 0),
3390 progname, temp_filename);
3391 if (pex == NULL)
3392 fatal_error (input_location, "%<pex_init%> failed: %m");
3393
3394 for (i = 0; i < n_commands; i++)
3395 {
3396 const char *errmsg;
3397 int err;
3398 const char *string = commands[i].argv[0];
3399
3400 errmsg = pex_run (pex,
3401 ((i + 1 == n_commands ? PEX_LAST : 0)
3402 | (string == commands[i].prog ? PEX_SEARCH : 0)),
3403 string, CONST_CAST (char **, commands[i].argv),
3404 NULL, NULL, &err);
3405 if (errmsg != NULL)
3406 {
3407 errno = err;
3408 fatal_error (input_location,
3409 err ? G_("cannot execute %qs: %s: %m")
3410 : G_("cannot execute %qs: %s"),
3411 string, errmsg);
3412 }
3413
3414 if (i && string != commands[i].prog)
3415 free (CONST_CAST (char *, string));
3416 }
3417
3418 execution_count++;
3419
3420 /* Wait for all the subprocesses to finish. */
3421
3422 {
3423 int *statuses;
3424 struct pex_time *times = NULL;
3425 int ret_code = 0;
3426
3427 statuses = (int *) alloca (n_commands * sizeof (int));
3428 if (!pex_get_status (pex, n_commands, statuses))
3429 fatal_error (input_location, "failed to get exit status: %m");
3430
3431 if (report_times || report_times_to_file)
3432 {
3433 times = (struct pex_time *) alloca (n_commands * sizeof (struct pex_time));
3434 if (!pex_get_times (pex, n_commands, times))
3435 fatal_error (input_location, "failed to get process times: %m");
3436 }
3437
3438 pex_free (pex);
3439
3440 for (i = 0; i < n_commands; ++i)
3441 {
3442 int status = statuses[i];
3443
3444 if (WIFSIGNALED (status))
3445 switch (WTERMSIG (status))
3446 {
3447 case SIGINT:
3448 case SIGTERM:
3449 /* SIGQUIT and SIGKILL are not available on MinGW. */
3450 #ifdef SIGQUIT
3451 case SIGQUIT:
3452 #endif
3453 #ifdef SIGKILL
3454 case SIGKILL:
3455 #endif
3456 /* The user (or environment) did something to the
3457 inferior. Making this an ICE confuses the user into
3458 thinking there's a compiler bug. Much more likely is
3459 the user or OOM killer nuked it. */
3460 fatal_error (input_location,
3461 "%s signal terminated program %s",
3462 strsignal (WTERMSIG (status)),
3463 commands[i].prog);
3464 break;
3465
3466 #ifdef SIGPIPE
3467 case SIGPIPE:
3468 /* SIGPIPE is a special case. It happens in -pipe mode
3469 when the compiler dies before the preprocessor is
3470 done, or the assembler dies before the compiler is
3471 done. There's generally been an error already, and
3472 this is just fallout. So don't generate another
3473 error unless we would otherwise have succeeded. */
3474 if (signal_count || greatest_status >= MIN_FATAL_STATUS)
3475 {
3476 signal_count++;
3477 ret_code = -1;
3478 break;
3479 }
3480 #endif
3481 /* FALLTHROUGH */
3482
3483 default:
3484 /* The inferior failed to catch the signal. */
3485 internal_error_no_backtrace ("%s signal terminated program %s",
3486 strsignal (WTERMSIG (status)),
3487 commands[i].prog);
3488 }
3489 else if (WIFEXITED (status)
3490 && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
3491 {
3492 /* For ICEs in cc1, cc1obj, cc1plus see if it is
3493 reproducible or not. */
3494 const char *p;
3495 if (flag_report_bug
3496 && WEXITSTATUS (status) == ICE_EXIT_CODE
3497 && i == 0
3498 && (p = strrchr (commands[0].argv[0], DIR_SEPARATOR))
3499 && ! strncmp (p + 1, "cc1", 3))
3500 try_generate_repro (commands[0].argv);
3501 if (WEXITSTATUS (status) > greatest_status)
3502 greatest_status = WEXITSTATUS (status);
3503 ret_code = -1;
3504 }
3505
3506 if (report_times || report_times_to_file)
3507 {
3508 struct pex_time *pt = ×[i];
3509 double ut, st;
3510
3511 ut = ((double) pt->user_seconds
3512 + (double) pt->user_microseconds / 1.0e6);
3513 st = ((double) pt->system_seconds
3514 + (double) pt->system_microseconds / 1.0e6);
3515
3516 if (ut + st != 0)
3517 {
3518 if (report_times)
3519 fnotice (stderr, "# %s %.2f %.2f\n",
3520 commands[i].prog, ut, st);
3521
3522 if (report_times_to_file)
3523 {
3524 int c = 0;
3525 const char *const *j;
3526
3527 fprintf (report_times_to_file, "%g %g", ut, st);
3528
3529 for (j = &commands[i].prog; *j; j = &commands[i].argv[++c])
3530 {
3531 const char *p;
3532 for (p = *j; *p; ++p)
3533 if (*p == '"' || *p == '\\' || *p == '$'
3534 || ISSPACE (*p))
3535 break;
3536
3537 if (*p)
3538 {
3539 fprintf (report_times_to_file, " \"");
3540 for (p = *j; *p; ++p)
3541 {
3542 if (*p == '"' || *p == '\\' || *p == '$')
3543 fputc ('\\', report_times_to_file);
3544 fputc (*p, report_times_to_file);
3545 }
3546 fputc ('"', report_times_to_file);
3547 }
3548 else
3549 fprintf (report_times_to_file, " %s", *j);
3550 }
3551
3552 fputc ('\n', report_times_to_file);
3553 }
3554 }
3555 }
3556 }
3557
3558 if (commands[0].argv[0] != commands[0].prog)
3559 free (CONST_CAST (char *, commands[0].argv[0]));
3560
3561 return ret_code;
3562 }
3563 }
3564
3565 /* Find all the switches given to us
3566 and make a vector describing them.
3567 The elements of the vector are strings, one per switch given.
3568 If a switch uses following arguments, then the `part1' field
3569 is the switch itself and the `args' field
3570 is a null-terminated vector containing the following arguments.
3571 Bits in the `live_cond' field are:
3572 SWITCH_LIVE to indicate this switch is true in a conditional spec.
3573 SWITCH_FALSE to indicate this switch is overridden by a later switch.
3574 SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
3575 SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored.
3576 SWITCH_KEEP_FOR_GCC to indicate that this switch, otherwise ignored,
3577 should be included in COLLECT_GCC_OPTIONS.
3578 in all do_spec calls afterwards. Used for %<S from self specs.
3579 The `known' field describes whether this is an internal switch.
3580 The `validated' field describes whether any spec has looked at this switch;
3581 if it remains false at the end of the run, the switch must be meaningless.
3582 The `ordering' field is used to temporarily mark switches that have to be
3583 kept in a specific order. */
3584
3585 #define SWITCH_LIVE (1 << 0)
3586 #define SWITCH_FALSE (1 << 1)
3587 #define SWITCH_IGNORE (1 << 2)
3588 #define SWITCH_IGNORE_PERMANENTLY (1 << 3)
3589 #define SWITCH_KEEP_FOR_GCC (1 << 4)
3590
3591 struct switchstr
3592 {
3593 const char *part1;
3594 const char **args;
3595 unsigned int live_cond;
3596 bool known;
3597 bool validated;
3598 bool ordering;
3599 };
3600
3601 static struct switchstr *switches;
3602
3603 static int n_switches;
3604
3605 static int n_switches_alloc;
3606
3607 /* Set to zero if -fcompare-debug is disabled, positive if it's
3608 enabled and we're running the first compilation, negative if it's
3609 enabled and we're running the second compilation. For most of the
3610 time, it's in the range -1..1, but it can be temporarily set to 2
3611 or 3 to indicate that the -fcompare-debug flags didn't come from
3612 the command-line, but rather from the GCC_COMPARE_DEBUG environment
3613 variable, until a synthesized -fcompare-debug flag is added to the
3614 command line. */
3615 int compare_debug;
3616
3617 /* Set to nonzero if we've seen the -fcompare-debug-second flag. */
3618 int compare_debug_second;
3619
3620 /* Set to the flags that should be passed to the second compilation in
3621 a -fcompare-debug compilation. */
3622 const char *compare_debug_opt;
3623
3624 static struct switchstr *switches_debug_check[2];
3625
3626 static int n_switches_debug_check[2];
3627
3628 static int n_switches_alloc_debug_check[2];
3629
3630 static char *debug_check_temp_file[2];
3631
3632 /* Language is one of three things:
3633
3634 1) The name of a real programming language.
3635 2) NULL, indicating that no one has figured out
3636 what it is yet.
3637 3) '*', indicating that the file should be passed
3638 to the linker. */
3639 struct infile
3640 {
3641 const char *name;
3642 const char *language;
3643 struct compiler *incompiler;
3644 bool compiled;
3645 bool preprocessed;
3646 };
3647
3648 /* Also a vector of input files specified. */
3649
3650 static struct infile *infiles;
3651
3652 int n_infiles;
3653
3654 static int n_infiles_alloc;
3655
3656 /* True if undefined environment variables encountered during spec processing
3657 are ok to ignore, typically when we're running for --help or --version. */
3658
3659 static bool spec_undefvar_allowed;
3660
3661 /* True if multiple input files are being compiled to a single
3662 assembly file. */
3663
3664 static bool combine_inputs;
3665
3666 /* This counts the number of libraries added by lang_specific_driver, so that
3667 we can tell if there were any user supplied any files or libraries. */
3668
3669 static int added_libraries;
3670
3671 /* And a vector of corresponding output files is made up later. */
3672
3673 const char **outfiles;
3674
3675 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3676
3677 /* Convert NAME to a new name if it is the standard suffix. DO_EXE
3678 is true if we should look for an executable suffix. DO_OBJ
3679 is true if we should look for an object suffix. */
3680
3681 static const char *
convert_filename(const char * name,int do_exe ATTRIBUTE_UNUSED,int do_obj ATTRIBUTE_UNUSED)3682 convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
3683 int do_obj ATTRIBUTE_UNUSED)
3684 {
3685 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3686 int i;
3687 #endif
3688 int len;
3689
3690 if (name == NULL)
3691 return NULL;
3692
3693 len = strlen (name);
3694
3695 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3696 /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj". */
3697 if (do_obj && len > 2
3698 && name[len - 2] == '.'
3699 && name[len - 1] == 'o')
3700 {
3701 obstack_grow (&obstack, name, len - 2);
3702 obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
3703 name = XOBFINISH (&obstack, const char *);
3704 }
3705 #endif
3706
3707 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3708 /* If there is no filetype, make it the executable suffix (which includes
3709 the "."). But don't get confused if we have just "-o". */
3710 if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || not_actual_file_p (name))
3711 return name;
3712
3713 for (i = len - 1; i >= 0; i--)
3714 if (IS_DIR_SEPARATOR (name[i]))
3715 break;
3716
3717 for (i++; i < len; i++)
3718 if (name[i] == '.')
3719 return name;
3720
3721 obstack_grow (&obstack, name, len);
3722 obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
3723 strlen (TARGET_EXECUTABLE_SUFFIX));
3724 name = XOBFINISH (&obstack, const char *);
3725 #endif
3726
3727 return name;
3728 }
3729 #endif
3730
3731 /* Display the command line switches accepted by gcc. */
3732 static void
display_help(void)3733 display_help (void)
3734 {
3735 printf (_("Usage: %s [options] file...\n"), progname);
3736 fputs (_("Options:\n"), stdout);
3737
3738 fputs (_(" -pass-exit-codes Exit with highest error code from a phase.\n"), stdout);
3739 fputs (_(" --help Display this information.\n"), stdout);
3740 fputs (_(" --target-help Display target specific command line options.\n"), stdout);
3741 fputs (_(" --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...].\n"), stdout);
3742 fputs (_(" Display specific types of command line options.\n"), stdout);
3743 if (! verbose_flag)
3744 fputs (_(" (Use '-v --help' to display command line options of sub-processes).\n"), stdout);
3745 fputs (_(" --version Display compiler version information.\n"), stdout);
3746 fputs (_(" -dumpspecs Display all of the built in spec strings.\n"), stdout);
3747 fputs (_(" -dumpversion Display the version of the compiler.\n"), stdout);
3748 fputs (_(" -dumpmachine Display the compiler's target processor.\n"), stdout);
3749 fputs (_(" -print-search-dirs Display the directories in the compiler's search path.\n"), stdout);
3750 fputs (_(" -print-libgcc-file-name Display the name of the compiler's companion library.\n"), stdout);
3751 fputs (_(" -print-file-name=<lib> Display the full path to library <lib>.\n"), stdout);
3752 fputs (_(" -print-prog-name=<prog> Display the full path to compiler component <prog>.\n"), stdout);
3753 fputs (_("\
3754 -print-multiarch Display the target's normalized GNU triplet, used as\n\
3755 a component in the library path.\n"), stdout);
3756 fputs (_(" -print-multi-directory Display the root directory for versions of libgcc.\n"), stdout);
3757 fputs (_("\
3758 -print-multi-lib Display the mapping between command line options and\n\
3759 multiple library search directories.\n"), stdout);
3760 fputs (_(" -print-multi-os-directory Display the relative path to OS libraries.\n"), stdout);
3761 fputs (_(" -print-sysroot Display the target libraries directory.\n"), stdout);
3762 fputs (_(" -print-sysroot-headers-suffix Display the sysroot suffix used to find headers.\n"), stdout);
3763 fputs (_(" -Wa,<options> Pass comma-separated <options> on to the assembler.\n"), stdout);
3764 fputs (_(" -Wp,<options> Pass comma-separated <options> on to the preprocessor.\n"), stdout);
3765 fputs (_(" -Wl,<options> Pass comma-separated <options> on to the linker.\n"), stdout);
3766 fputs (_(" -Xassembler <arg> Pass <arg> on to the assembler.\n"), stdout);
3767 fputs (_(" -Xpreprocessor <arg> Pass <arg> on to the preprocessor.\n"), stdout);
3768 fputs (_(" -Xlinker <arg> Pass <arg> on to the linker.\n"), stdout);
3769 fputs (_(" -save-temps Do not delete intermediate files.\n"), stdout);
3770 fputs (_(" -save-temps=<arg> Do not delete intermediate files.\n"), stdout);
3771 fputs (_("\
3772 -no-canonical-prefixes Do not canonicalize paths when building relative\n\
3773 prefixes to other gcc components.\n"), stdout);
3774 fputs (_(" -pipe Use pipes rather than intermediate files.\n"), stdout);
3775 fputs (_(" -time Time the execution of each subprocess.\n"), stdout);
3776 fputs (_(" -specs=<file> Override built-in specs with the contents of <file>.\n"), stdout);
3777 fputs (_(" -std=<standard> Assume that the input sources are for <standard>.\n"), stdout);
3778 fputs (_("\
3779 --sysroot=<directory> Use <directory> as the root directory for headers\n\
3780 and libraries.\n"), stdout);
3781 fputs (_(" -B <directory> Add <directory> to the compiler's search paths.\n"), stdout);
3782 fputs (_(" -v Display the programs invoked by the compiler.\n"), stdout);
3783 fputs (_(" -### Like -v but options quoted and commands not executed.\n"), stdout);
3784 fputs (_(" -E Preprocess only; do not compile, assemble or link.\n"), stdout);
3785 fputs (_(" -S Compile only; do not assemble or link.\n"), stdout);
3786 fputs (_(" -c Compile and assemble, but do not link.\n"), stdout);
3787 fputs (_(" -o <file> Place the output into <file>.\n"), stdout);
3788 fputs (_(" -pie Create a dynamically linked position independent\n\
3789 executable.\n"), stdout);
3790 fputs (_(" -shared Create a shared library.\n"), stdout);
3791 fputs (_("\
3792 -x <language> Specify the language of the following input files.\n\
3793 Permissible languages include: c c++ assembler none\n\
3794 'none' means revert to the default behavior of\n\
3795 guessing the language based on the file's extension.\n\
3796 "), stdout);
3797
3798 printf (_("\
3799 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3800 passed on to the various sub-processes invoked by %s. In order to pass\n\
3801 other options on to these processes the -W<letter> options must be used.\n\
3802 "), progname);
3803
3804 /* The rest of the options are displayed by invocations of the various
3805 sub-processes. */
3806 }
3807
3808 static void
add_preprocessor_option(const char * option,int len)3809 add_preprocessor_option (const char *option, int len)
3810 {
3811 preprocessor_options.safe_push (save_string (option, len));
3812 }
3813
3814 static void
add_assembler_option(const char * option,int len)3815 add_assembler_option (const char *option, int len)
3816 {
3817 assembler_options.safe_push (save_string (option, len));
3818 }
3819
3820 static void
add_linker_option(const char * option,int len)3821 add_linker_option (const char *option, int len)
3822 {
3823 linker_options.safe_push (save_string (option, len));
3824 }
3825
3826 /* Allocate space for an input file in infiles. */
3827
3828 static void
alloc_infile(void)3829 alloc_infile (void)
3830 {
3831 if (n_infiles_alloc == 0)
3832 {
3833 n_infiles_alloc = 16;
3834 infiles = XNEWVEC (struct infile, n_infiles_alloc);
3835 }
3836 else if (n_infiles_alloc == n_infiles)
3837 {
3838 n_infiles_alloc *= 2;
3839 infiles = XRESIZEVEC (struct infile, infiles, n_infiles_alloc);
3840 }
3841 }
3842
3843 /* Store an input file with the given NAME and LANGUAGE in
3844 infiles. */
3845
3846 static void
add_infile(const char * name,const char * language)3847 add_infile (const char *name, const char *language)
3848 {
3849 alloc_infile ();
3850 infiles[n_infiles].name = name;
3851 infiles[n_infiles++].language = language;
3852 }
3853
3854 /* Allocate space for a switch in switches. */
3855
3856 static void
alloc_switch(void)3857 alloc_switch (void)
3858 {
3859 if (n_switches_alloc == 0)
3860 {
3861 n_switches_alloc = 16;
3862 switches = XNEWVEC (struct switchstr, n_switches_alloc);
3863 }
3864 else if (n_switches_alloc == n_switches)
3865 {
3866 n_switches_alloc *= 2;
3867 switches = XRESIZEVEC (struct switchstr, switches, n_switches_alloc);
3868 }
3869 }
3870
3871 /* Save an option OPT with N_ARGS arguments in array ARGS, marking it
3872 as validated if VALIDATED and KNOWN if it is an internal switch. */
3873
3874 static void
save_switch(const char * opt,size_t n_args,const char * const * args,bool validated,bool known)3875 save_switch (const char *opt, size_t n_args, const char *const *args,
3876 bool validated, bool known)
3877 {
3878 alloc_switch ();
3879 switches[n_switches].part1 = opt + 1;
3880 if (n_args == 0)
3881 switches[n_switches].args = 0;
3882 else
3883 {
3884 switches[n_switches].args = XNEWVEC (const char *, n_args + 1);
3885 memcpy (switches[n_switches].args, args, n_args * sizeof (const char *));
3886 switches[n_switches].args[n_args] = NULL;
3887 }
3888
3889 switches[n_switches].live_cond = 0;
3890 switches[n_switches].validated = validated;
3891 switches[n_switches].known = known;
3892 switches[n_switches].ordering = 0;
3893 n_switches++;
3894 }
3895
3896 /* Set the SOURCE_DATE_EPOCH environment variable to the current time if it is
3897 not set already. */
3898
3899 static void
set_source_date_epoch_envvar()3900 set_source_date_epoch_envvar ()
3901 {
3902 /* Array size is 21 = ceil(log_10(2^64)) + 1 to hold string representations
3903 of 64 bit integers. */
3904 char source_date_epoch[21];
3905 time_t tt;
3906
3907 errno = 0;
3908 tt = time (NULL);
3909 if (tt < (time_t) 0 || errno != 0)
3910 tt = (time_t) 0;
3911
3912 snprintf (source_date_epoch, 21, "%llu", (unsigned long long) tt);
3913 /* Using setenv instead of xputenv because we want the variable to remain
3914 after finalizing so that it's still set in the second run when using
3915 -fcompare-debug. */
3916 setenv ("SOURCE_DATE_EPOCH", source_date_epoch, 0);
3917 }
3918
3919 /* Handle an option DECODED that is unknown to the option-processing
3920 machinery. */
3921
3922 static bool
driver_unknown_option_callback(const struct cl_decoded_option * decoded)3923 driver_unknown_option_callback (const struct cl_decoded_option *decoded)
3924 {
3925 const char *opt = decoded->arg;
3926 if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-'
3927 && !(decoded->errors & CL_ERR_NEGATIVE))
3928 {
3929 /* Leave unknown -Wno-* options for the compiler proper, to be
3930 diagnosed only if there are warnings. */
3931 save_switch (decoded->canonical_option[0],
3932 decoded->canonical_option_num_elements - 1,
3933 &decoded->canonical_option[1], false, true);
3934 return false;
3935 }
3936 if (decoded->opt_index == OPT_SPECIAL_unknown)
3937 {
3938 /* Give it a chance to define it a spec file. */
3939 save_switch (decoded->canonical_option[0],
3940 decoded->canonical_option_num_elements - 1,
3941 &decoded->canonical_option[1], false, false);
3942 return false;
3943 }
3944 else
3945 return true;
3946 }
3947
3948 /* Handle an option DECODED that is not marked as CL_DRIVER.
3949 LANG_MASK will always be CL_DRIVER. */
3950
3951 static void
driver_wrong_lang_callback(const struct cl_decoded_option * decoded,unsigned int lang_mask ATTRIBUTE_UNUSED)3952 driver_wrong_lang_callback (const struct cl_decoded_option *decoded,
3953 unsigned int lang_mask ATTRIBUTE_UNUSED)
3954 {
3955 /* At this point, non-driver options are accepted (and expected to
3956 be passed down by specs) unless marked to be rejected by the
3957 driver. Options to be rejected by the driver but accepted by the
3958 compilers proper are treated just like completely unknown
3959 options. */
3960 const struct cl_option *option = &cl_options[decoded->opt_index];
3961
3962 if (option->cl_reject_driver)
3963 error ("unrecognized command-line option %qs",
3964 decoded->orig_option_with_args_text);
3965 else
3966 save_switch (decoded->canonical_option[0],
3967 decoded->canonical_option_num_elements - 1,
3968 &decoded->canonical_option[1], false, true);
3969 }
3970
3971 static const char *spec_lang = 0;
3972 static int last_language_n_infiles;
3973
3974 /* Parse -foffload option argument. */
3975
3976 static void
handle_foffload_option(const char * arg)3977 handle_foffload_option (const char *arg)
3978 {
3979 const char *c, *cur, *n, *next, *end;
3980 char *target;
3981
3982 /* If option argument starts with '-' then no target is specified and we
3983 do not need to parse it. */
3984 if (arg[0] == '-')
3985 return;
3986
3987 end = strchr (arg, '=');
3988 if (end == NULL)
3989 end = strchr (arg, '\0');
3990 cur = arg;
3991
3992 while (cur < end)
3993 {
3994 next = strchr (cur, ',');
3995 if (next == NULL)
3996 next = end;
3997 next = (next > end) ? end : next;
3998
3999 target = XNEWVEC (char, next - cur + 1);
4000 memcpy (target, cur, next - cur);
4001 target[next - cur] = '\0';
4002
4003 /* If 'disable' is passed to the option, stop parsing the option and clean
4004 the list of offload targets. */
4005 if (strcmp (target, "disable") == 0)
4006 {
4007 free (offload_targets);
4008 offload_targets = xstrdup ("");
4009 break;
4010 }
4011
4012 /* Check that GCC is configured to support the offload target. */
4013 c = OFFLOAD_TARGETS;
4014 while (c)
4015 {
4016 n = strchr (c, ',');
4017 if (n == NULL)
4018 n = strchr (c, '\0');
4019
4020 if (next - cur == n - c && strncmp (target, c, n - c) == 0)
4021 break;
4022
4023 c = *n ? n + 1 : NULL;
4024 }
4025
4026 if (!c)
4027 fatal_error (input_location,
4028 "GCC is not configured to support %s as offload target",
4029 target);
4030
4031 if (!offload_targets)
4032 {
4033 offload_targets = target;
4034 target = NULL;
4035 }
4036 else
4037 {
4038 /* Check that the target hasn't already presented in the list. */
4039 c = offload_targets;
4040 do
4041 {
4042 n = strchr (c, ':');
4043 if (n == NULL)
4044 n = strchr (c, '\0');
4045
4046 if (next - cur == n - c && strncmp (c, target, n - c) == 0)
4047 break;
4048
4049 c = n + 1;
4050 }
4051 while (*n);
4052
4053 /* If duplicate is not found, append the target to the list. */
4054 if (c > n)
4055 {
4056 size_t offload_targets_len = strlen (offload_targets);
4057 offload_targets
4058 = XRESIZEVEC (char, offload_targets,
4059 offload_targets_len + 1 + next - cur + 1);
4060 offload_targets[offload_targets_len++] = ':';
4061 memcpy (offload_targets + offload_targets_len, target, next - cur + 1);
4062 }
4063 }
4064
4065 cur = next + 1;
4066 XDELETEVEC (target);
4067 }
4068 }
4069
4070 /* Handle a driver option; arguments and return value as for
4071 handle_option. */
4072
4073 static bool
driver_handle_option(struct gcc_options * opts,struct gcc_options * opts_set,const struct cl_decoded_option * decoded,unsigned int lang_mask ATTRIBUTE_UNUSED,int kind,location_t loc,const struct cl_option_handlers * handlers ATTRIBUTE_UNUSED,diagnostic_context * dc,void (*)(void))4074 driver_handle_option (struct gcc_options *opts,
4075 struct gcc_options *opts_set,
4076 const struct cl_decoded_option *decoded,
4077 unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
4078 location_t loc,
4079 const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED,
4080 diagnostic_context *dc,
4081 void (*) (void))
4082 {
4083 size_t opt_index = decoded->opt_index;
4084 const char *arg = decoded->arg;
4085 const char *compare_debug_replacement_opt;
4086 int value = decoded->value;
4087 bool validated = false;
4088 bool do_save = true;
4089
4090 gcc_assert (opts == &global_options);
4091 gcc_assert (opts_set == &global_options_set);
4092 gcc_assert (kind == DK_UNSPECIFIED);
4093 gcc_assert (loc == UNKNOWN_LOCATION);
4094 gcc_assert (dc == global_dc);
4095
4096 switch (opt_index)
4097 {
4098 case OPT_dumpspecs:
4099 {
4100 struct spec_list *sl;
4101 init_spec ();
4102 for (sl = specs; sl; sl = sl->next)
4103 printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
4104 if (link_command_spec)
4105 printf ("*link_command:\n%s\n\n", link_command_spec);
4106 exit (0);
4107 }
4108
4109 case OPT_dumpversion:
4110 printf ("%s\n", spec_version);
4111 exit (0);
4112
4113 case OPT_dumpmachine:
4114 printf ("%s\n", spec_machine);
4115 exit (0);
4116
4117 case OPT_dumpfullversion:
4118 printf ("%s\n", BASEVER);
4119 exit (0);
4120
4121 case OPT__version:
4122 print_version = 1;
4123
4124 /* CPP driver cannot obtain switch from cc1_options. */
4125 if (is_cpp_driver)
4126 add_preprocessor_option ("--version", strlen ("--version"));
4127 add_assembler_option ("--version", strlen ("--version"));
4128 add_linker_option ("--version", strlen ("--version"));
4129 break;
4130
4131 case OPT__completion_:
4132 validated = true;
4133 completion = decoded->arg;
4134 break;
4135
4136 case OPT__help:
4137 print_help_list = 1;
4138
4139 /* CPP driver cannot obtain switch from cc1_options. */
4140 if (is_cpp_driver)
4141 add_preprocessor_option ("--help", 6);
4142 add_assembler_option ("--help", 6);
4143 add_linker_option ("--help", 6);
4144 break;
4145
4146 case OPT__help_:
4147 print_subprocess_help = 2;
4148 break;
4149
4150 case OPT__target_help:
4151 print_subprocess_help = 1;
4152
4153 /* CPP driver cannot obtain switch from cc1_options. */
4154 if (is_cpp_driver)
4155 add_preprocessor_option ("--target-help", 13);
4156 add_assembler_option ("--target-help", 13);
4157 add_linker_option ("--target-help", 13);
4158 break;
4159
4160 case OPT__no_sysroot_suffix:
4161 case OPT_pass_exit_codes:
4162 case OPT_print_search_dirs:
4163 case OPT_print_file_name_:
4164 case OPT_print_prog_name_:
4165 case OPT_print_multi_lib:
4166 case OPT_print_multi_directory:
4167 case OPT_print_sysroot:
4168 case OPT_print_multi_os_directory:
4169 case OPT_print_multiarch:
4170 case OPT_print_sysroot_headers_suffix:
4171 case OPT_time:
4172 case OPT_wrapper:
4173 /* These options set the variables specified in common.opt
4174 automatically, and do not need to be saved for spec
4175 processing. */
4176 do_save = false;
4177 break;
4178
4179 case OPT_print_libgcc_file_name:
4180 print_file_name = "libgcc.a";
4181 do_save = false;
4182 break;
4183
4184 case OPT_fuse_ld_bfd:
4185 use_ld = ".bfd";
4186 break;
4187
4188 case OPT_fuse_ld_gold:
4189 use_ld = ".gold";
4190 break;
4191
4192 case OPT_fcompare_debug_second:
4193 compare_debug_second = 1;
4194 break;
4195
4196 case OPT_fcompare_debug:
4197 switch (value)
4198 {
4199 case 0:
4200 compare_debug_replacement_opt = "-fcompare-debug=";
4201 arg = "";
4202 goto compare_debug_with_arg;
4203
4204 case 1:
4205 compare_debug_replacement_opt = "-fcompare-debug=-gtoggle";
4206 arg = "-gtoggle";
4207 goto compare_debug_with_arg;
4208
4209 default:
4210 gcc_unreachable ();
4211 }
4212 break;
4213
4214 case OPT_fcompare_debug_:
4215 compare_debug_replacement_opt = decoded->canonical_option[0];
4216 compare_debug_with_arg:
4217 gcc_assert (decoded->canonical_option_num_elements == 1);
4218 gcc_assert (arg != NULL);
4219 if (*arg)
4220 compare_debug = 1;
4221 else
4222 compare_debug = -1;
4223 if (compare_debug < 0)
4224 compare_debug_opt = NULL;
4225 else
4226 compare_debug_opt = arg;
4227 save_switch (compare_debug_replacement_opt, 0, NULL, validated, true);
4228 set_source_date_epoch_envvar ();
4229 return true;
4230
4231 case OPT_fdiagnostics_color_:
4232 diagnostic_color_init (dc, value);
4233 break;
4234
4235 case OPT_fdiagnostics_urls_:
4236 diagnostic_urls_init (dc, value);
4237 break;
4238
4239 case OPT_fdiagnostics_format_:
4240 diagnostic_output_format_init (dc,
4241 (enum diagnostics_output_format)value);
4242 break;
4243
4244 case OPT_Wa_:
4245 {
4246 int prev, j;
4247 /* Pass the rest of this option to the assembler. */
4248
4249 /* Split the argument at commas. */
4250 prev = 0;
4251 for (j = 0; arg[j]; j++)
4252 if (arg[j] == ',')
4253 {
4254 add_assembler_option (arg + prev, j - prev);
4255 prev = j + 1;
4256 }
4257
4258 /* Record the part after the last comma. */
4259 add_assembler_option (arg + prev, j - prev);
4260 }
4261 do_save = false;
4262 break;
4263
4264 case OPT_Wp_:
4265 {
4266 int prev, j;
4267 /* Pass the rest of this option to the preprocessor. */
4268
4269 /* Split the argument at commas. */
4270 prev = 0;
4271 for (j = 0; arg[j]; j++)
4272 if (arg[j] == ',')
4273 {
4274 add_preprocessor_option (arg + prev, j - prev);
4275 prev = j + 1;
4276 }
4277
4278 /* Record the part after the last comma. */
4279 add_preprocessor_option (arg + prev, j - prev);
4280 }
4281 do_save = false;
4282 break;
4283
4284 case OPT_Wl_:
4285 {
4286 int prev, j;
4287 /* Split the argument at commas. */
4288 prev = 0;
4289 for (j = 0; arg[j]; j++)
4290 if (arg[j] == ',')
4291 {
4292 add_infile (save_string (arg + prev, j - prev), "*");
4293 prev = j + 1;
4294 }
4295 /* Record the part after the last comma. */
4296 add_infile (arg + prev, "*");
4297 }
4298 do_save = false;
4299 break;
4300
4301 case OPT_Xlinker:
4302 add_infile (arg, "*");
4303 do_save = false;
4304 break;
4305
4306 case OPT_Xpreprocessor:
4307 add_preprocessor_option (arg, strlen (arg));
4308 do_save = false;
4309 break;
4310
4311 case OPT_Xassembler:
4312 add_assembler_option (arg, strlen (arg));
4313 do_save = false;
4314 break;
4315
4316 case OPT_l:
4317 /* POSIX allows separation of -l and the lib arg; canonicalize
4318 by concatenating -l with its arg */
4319 add_infile (concat ("-l", arg, NULL), "*");
4320 do_save = false;
4321 break;
4322
4323 case OPT_L:
4324 /* Similarly, canonicalize -L for linkers that may not accept
4325 separate arguments. */
4326 save_switch (concat ("-L", arg, NULL), 0, NULL, validated, true);
4327 return true;
4328
4329 case OPT_F:
4330 /* Likewise -F. */
4331 save_switch (concat ("-F", arg, NULL), 0, NULL, validated, true);
4332 return true;
4333
4334 case OPT_save_temps:
4335 if (!save_temps_flag)
4336 save_temps_flag = SAVE_TEMPS_DUMP;
4337 validated = true;
4338 break;
4339
4340 case OPT_save_temps_:
4341 if (strcmp (arg, "cwd") == 0)
4342 save_temps_flag = SAVE_TEMPS_CWD;
4343 else if (strcmp (arg, "obj") == 0
4344 || strcmp (arg, "object") == 0)
4345 save_temps_flag = SAVE_TEMPS_OBJ;
4346 else
4347 fatal_error (input_location, "%qs is an unknown %<-save-temps%> option",
4348 decoded->orig_option_with_args_text);
4349 save_temps_overrides_dumpdir = true;
4350 break;
4351
4352 case OPT_dumpdir:
4353 free (dumpdir);
4354 dumpdir = xstrdup (arg);
4355 save_temps_overrides_dumpdir = false;
4356 break;
4357
4358 case OPT_dumpbase:
4359 free (dumpbase);
4360 dumpbase = xstrdup (arg);
4361 break;
4362
4363 case OPT_dumpbase_ext:
4364 free (dumpbase_ext);
4365 dumpbase_ext = xstrdup (arg);
4366 break;
4367
4368 case OPT_no_canonical_prefixes:
4369 /* Already handled as a special case, so ignored here. */
4370 do_save = false;
4371 break;
4372
4373 case OPT_pipe:
4374 validated = true;
4375 /* These options set the variables specified in common.opt
4376 automatically, but do need to be saved for spec
4377 processing. */
4378 break;
4379
4380 case OPT_specs_:
4381 {
4382 struct user_specs *user = XNEW (struct user_specs);
4383
4384 user->next = (struct user_specs *) 0;
4385 user->filename = arg;
4386 if (user_specs_tail)
4387 user_specs_tail->next = user;
4388 else
4389 user_specs_head = user;
4390 user_specs_tail = user;
4391 }
4392 validated = true;
4393 break;
4394
4395 case OPT__sysroot_:
4396 target_system_root = arg;
4397 target_system_root_changed = 1;
4398 do_save = false;
4399 break;
4400
4401 case OPT_time_:
4402 if (report_times_to_file)
4403 fclose (report_times_to_file);
4404 report_times_to_file = fopen (arg, "a");
4405 do_save = false;
4406 break;
4407
4408 case OPT____:
4409 /* "-###"
4410 This is similar to -v except that there is no execution
4411 of the commands and the echoed arguments are quoted. It
4412 is intended for use in shell scripts to capture the
4413 driver-generated command line. */
4414 verbose_only_flag++;
4415 verbose_flag = 1;
4416 do_save = false;
4417 break;
4418
4419 case OPT_B:
4420 {
4421 size_t len = strlen (arg);
4422
4423 /* Catch the case where the user has forgotten to append a
4424 directory separator to the path. Note, they may be using
4425 -B to add an executable name prefix, eg "i386-elf-", in
4426 order to distinguish between multiple installations of
4427 GCC in the same directory. Hence we must check to see
4428 if appending a directory separator actually makes a
4429 valid directory name. */
4430 if (!IS_DIR_SEPARATOR (arg[len - 1])
4431 && is_directory (arg, false))
4432 {
4433 char *tmp = XNEWVEC (char, len + 2);
4434 strcpy (tmp, arg);
4435 tmp[len] = DIR_SEPARATOR;
4436 tmp[++len] = 0;
4437 arg = tmp;
4438 }
4439
4440 add_prefix (&exec_prefixes, arg, NULL,
4441 PREFIX_PRIORITY_B_OPT, 0, 0);
4442 add_prefix (&startfile_prefixes, arg, NULL,
4443 PREFIX_PRIORITY_B_OPT, 0, 0);
4444 add_prefix (&include_prefixes, arg, NULL,
4445 PREFIX_PRIORITY_B_OPT, 0, 0);
4446 }
4447 validated = true;
4448 break;
4449
4450 case OPT_E:
4451 have_E = true;
4452 break;
4453
4454 case OPT_x:
4455 spec_lang = arg;
4456 if (!strcmp (spec_lang, "none"))
4457 /* Suppress the warning if -xnone comes after the last input
4458 file, because alternate command interfaces like g++ might
4459 find it useful to place -xnone after each input file. */
4460 spec_lang = 0;
4461 else
4462 last_language_n_infiles = n_infiles;
4463 do_save = false;
4464 break;
4465
4466 case OPT_o:
4467 have_o = 1;
4468 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
4469 arg = convert_filename (arg, ! have_c, 0);
4470 #endif
4471 output_file = arg;
4472 /* On some systems, ld cannot handle "-o" without a space. So
4473 split the option from its argument. */
4474 save_switch ("-o", 1, &arg, validated, true);
4475 return true;
4476
4477 #ifdef ENABLE_DEFAULT_PIE
4478 case OPT_pie:
4479 /* -pie is turned on by default. */
4480 #endif
4481
4482 case OPT_static_libgcc:
4483 case OPT_shared_libgcc:
4484 case OPT_static_libgfortran:
4485 case OPT_static_libstdc__:
4486 /* These are always valid, since gcc.c itself understands the
4487 first two, gfortranspec.c understands -static-libgfortran and
4488 g++spec.c understands -static-libstdc++ */
4489 validated = true;
4490 break;
4491
4492 case OPT_fwpa:
4493 flag_wpa = "";
4494 break;
4495
4496 case OPT_foffload_:
4497 handle_foffload_option (arg);
4498 break;
4499
4500 default:
4501 /* Various driver options need no special processing at this
4502 point, having been handled in a prescan above or being
4503 handled by specs. */
4504 break;
4505 }
4506
4507 if (do_save)
4508 save_switch (decoded->canonical_option[0],
4509 decoded->canonical_option_num_elements - 1,
4510 &decoded->canonical_option[1], validated, true);
4511 return true;
4512 }
4513
4514 /* Return true if F2 is F1 followed by a single suffix, i.e., by a
4515 period and additional characters other than a period. */
4516
4517 static inline bool
adds_single_suffix_p(const char * f2,const char * f1)4518 adds_single_suffix_p (const char *f2, const char *f1)
4519 {
4520 size_t len = strlen (f1);
4521
4522 return (strncmp (f1, f2, len) == 0
4523 && f2[len] == '.'
4524 && strchr (f2 + len + 1, '.') == NULL);
4525 }
4526
4527 /* Put the driver's standard set of option handlers in *HANDLERS. */
4528
4529 static void
set_option_handlers(struct cl_option_handlers * handlers)4530 set_option_handlers (struct cl_option_handlers *handlers)
4531 {
4532 handlers->unknown_option_callback = driver_unknown_option_callback;
4533 handlers->wrong_lang_callback = driver_wrong_lang_callback;
4534 handlers->num_handlers = 3;
4535 handlers->handlers[0].handler = driver_handle_option;
4536 handlers->handlers[0].mask = CL_DRIVER;
4537 handlers->handlers[1].handler = common_handle_option;
4538 handlers->handlers[1].mask = CL_COMMON;
4539 handlers->handlers[2].handler = target_handle_option;
4540 handlers->handlers[2].mask = CL_TARGET;
4541 }
4542
4543
4544 /* Return the index into infiles for the single non-library
4545 non-lto-wpa input file, -1 if there isn't any, or -2 if there is
4546 more than one. */
4547 static inline int
single_input_file_index()4548 single_input_file_index ()
4549 {
4550 int ret = -1;
4551
4552 for (int i = 0; i < n_infiles; i++)
4553 {
4554 if (infiles[i].language
4555 && (infiles[i].language[0] == '*'
4556 || (flag_wpa
4557 && strcmp (infiles[i].language, "lto") == 0)))
4558 continue;
4559
4560 if (ret != -1)
4561 return -2;
4562
4563 ret = i;
4564 }
4565
4566 return ret;
4567 }
4568
4569 /* Create the vector `switches' and its contents.
4570 Store its length in `n_switches'. */
4571
4572 static void
process_command(unsigned int decoded_options_count,struct cl_decoded_option * decoded_options)4573 process_command (unsigned int decoded_options_count,
4574 struct cl_decoded_option *decoded_options)
4575 {
4576 const char *temp;
4577 char *temp1;
4578 char *tooldir_prefix, *tooldir_prefix2;
4579 char *(*get_relative_prefix) (const char *, const char *,
4580 const char *) = NULL;
4581 struct cl_option_handlers handlers;
4582 unsigned int j;
4583
4584 gcc_exec_prefix = env.get ("GCC_EXEC_PREFIX");
4585
4586 n_switches = 0;
4587 n_infiles = 0;
4588 added_libraries = 0;
4589
4590 /* Figure compiler version from version string. */
4591
4592 compiler_version = temp1 = xstrdup (version_string);
4593
4594 for (; *temp1; ++temp1)
4595 {
4596 if (*temp1 == ' ')
4597 {
4598 *temp1 = '\0';
4599 break;
4600 }
4601 }
4602
4603 /* Handle any -no-canonical-prefixes flag early, to assign the function
4604 that builds relative prefixes. This function creates default search
4605 paths that are needed later in normal option handling. */
4606
4607 for (j = 1; j < decoded_options_count; j++)
4608 {
4609 if (decoded_options[j].opt_index == OPT_no_canonical_prefixes)
4610 {
4611 get_relative_prefix = make_relative_prefix_ignore_links;
4612 break;
4613 }
4614 }
4615 if (! get_relative_prefix)
4616 get_relative_prefix = make_relative_prefix;
4617
4618 /* Set up the default search paths. If there is no GCC_EXEC_PREFIX,
4619 see if we can create it from the pathname specified in
4620 decoded_options[0].arg. */
4621
4622 gcc_libexec_prefix = standard_libexec_prefix;
4623 #ifndef VMS
4624 /* FIXME: make_relative_prefix doesn't yet work for VMS. */
4625 if (!gcc_exec_prefix)
4626 {
4627 gcc_exec_prefix = get_relative_prefix (decoded_options[0].arg,
4628 standard_bindir_prefix,
4629 standard_exec_prefix);
4630 gcc_libexec_prefix = get_relative_prefix (decoded_options[0].arg,
4631 standard_bindir_prefix,
4632 standard_libexec_prefix);
4633 if (gcc_exec_prefix)
4634 xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
4635 }
4636 else
4637 {
4638 /* make_relative_prefix requires a program name, but
4639 GCC_EXEC_PREFIX is typically a directory name with a trailing
4640 / (which is ignored by make_relative_prefix), so append a
4641 program name. */
4642 char *tmp_prefix = concat (gcc_exec_prefix, "gcc", NULL);
4643 gcc_libexec_prefix = get_relative_prefix (tmp_prefix,
4644 standard_exec_prefix,
4645 standard_libexec_prefix);
4646
4647 /* The path is unrelocated, so fallback to the original setting. */
4648 if (!gcc_libexec_prefix)
4649 gcc_libexec_prefix = standard_libexec_prefix;
4650
4651 free (tmp_prefix);
4652 }
4653 #else
4654 #endif
4655 /* From this point onward, gcc_exec_prefix is non-null if the toolchain
4656 is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
4657 or an automatically created GCC_EXEC_PREFIX from
4658 decoded_options[0].arg. */
4659
4660 /* Do language-specific adjustment/addition of flags. */
4661 lang_specific_driver (&decoded_options, &decoded_options_count,
4662 &added_libraries);
4663
4664 if (gcc_exec_prefix)
4665 {
4666 int len = strlen (gcc_exec_prefix);
4667
4668 if (len > (int) sizeof ("/lib/gcc/") - 1
4669 && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
4670 {
4671 temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1;
4672 if (IS_DIR_SEPARATOR (*temp)
4673 && filename_ncmp (temp + 1, "lib", 3) == 0
4674 && IS_DIR_SEPARATOR (temp[4])
4675 && filename_ncmp (temp + 5, "gcc", 3) == 0)
4676 len -= sizeof ("/lib/gcc/") - 1;
4677 }
4678
4679 set_std_prefix (gcc_exec_prefix, len);
4680 add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC",
4681 PREFIX_PRIORITY_LAST, 0, 0);
4682 add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
4683 PREFIX_PRIORITY_LAST, 0, 0);
4684 }
4685
4686 /* COMPILER_PATH and LIBRARY_PATH have values
4687 that are lists of directory names with colons. */
4688
4689 temp = env.get ("COMPILER_PATH");
4690 if (temp)
4691 {
4692 const char *startp, *endp;
4693 char *nstore = (char *) alloca (strlen (temp) + 3);
4694
4695 startp = endp = temp;
4696 while (1)
4697 {
4698 if (*endp == PATH_SEPARATOR || *endp == 0)
4699 {
4700 strncpy (nstore, startp, endp - startp);
4701 if (endp == startp)
4702 strcpy (nstore, concat (".", dir_separator_str, NULL));
4703 else if (!IS_DIR_SEPARATOR (endp[-1]))
4704 {
4705 nstore[endp - startp] = DIR_SEPARATOR;
4706 nstore[endp - startp + 1] = 0;
4707 }
4708 else
4709 nstore[endp - startp] = 0;
4710 add_prefix (&exec_prefixes, nstore, 0,
4711 PREFIX_PRIORITY_LAST, 0, 0);
4712 add_prefix (&include_prefixes, nstore, 0,
4713 PREFIX_PRIORITY_LAST, 0, 0);
4714 if (*endp == 0)
4715 break;
4716 endp = startp = endp + 1;
4717 }
4718 else
4719 endp++;
4720 }
4721 }
4722
4723 temp = env.get (LIBRARY_PATH_ENV);
4724 if (temp && *cross_compile == '0')
4725 {
4726 const char *startp, *endp;
4727 char *nstore = (char *) alloca (strlen (temp) + 3);
4728
4729 startp = endp = temp;
4730 while (1)
4731 {
4732 if (*endp == PATH_SEPARATOR || *endp == 0)
4733 {
4734 strncpy (nstore, startp, endp - startp);
4735 if (endp == startp)
4736 strcpy (nstore, concat (".", dir_separator_str, NULL));
4737 else if (!IS_DIR_SEPARATOR (endp[-1]))
4738 {
4739 nstore[endp - startp] = DIR_SEPARATOR;
4740 nstore[endp - startp + 1] = 0;
4741 }
4742 else
4743 nstore[endp - startp] = 0;
4744 add_prefix (&startfile_prefixes, nstore, NULL,
4745 PREFIX_PRIORITY_LAST, 0, 1);
4746 if (*endp == 0)
4747 break;
4748 endp = startp = endp + 1;
4749 }
4750 else
4751 endp++;
4752 }
4753 }
4754
4755 /* Use LPATH like LIBRARY_PATH (for the CMU build program). */
4756 temp = env.get ("LPATH");
4757 if (temp && *cross_compile == '0')
4758 {
4759 const char *startp, *endp;
4760 char *nstore = (char *) alloca (strlen (temp) + 3);
4761
4762 startp = endp = temp;
4763 while (1)
4764 {
4765 if (*endp == PATH_SEPARATOR || *endp == 0)
4766 {
4767 strncpy (nstore, startp, endp - startp);
4768 if (endp == startp)
4769 strcpy (nstore, concat (".", dir_separator_str, NULL));
4770 else if (!IS_DIR_SEPARATOR (endp[-1]))
4771 {
4772 nstore[endp - startp] = DIR_SEPARATOR;
4773 nstore[endp - startp + 1] = 0;
4774 }
4775 else
4776 nstore[endp - startp] = 0;
4777 add_prefix (&startfile_prefixes, nstore, NULL,
4778 PREFIX_PRIORITY_LAST, 0, 1);
4779 if (*endp == 0)
4780 break;
4781 endp = startp = endp + 1;
4782 }
4783 else
4784 endp++;
4785 }
4786 }
4787
4788 /* Process the options and store input files and switches in their
4789 vectors. */
4790
4791 last_language_n_infiles = -1;
4792
4793 set_option_handlers (&handlers);
4794
4795 for (j = 1; j < decoded_options_count; j++)
4796 {
4797 switch (decoded_options[j].opt_index)
4798 {
4799 case OPT_S:
4800 case OPT_c:
4801 case OPT_E:
4802 have_c = 1;
4803 break;
4804 }
4805 if (have_c)
4806 break;
4807 }
4808
4809 for (j = 1; j < decoded_options_count; j++)
4810 {
4811 if (decoded_options[j].opt_index == OPT_SPECIAL_input_file)
4812 {
4813 const char *arg = decoded_options[j].arg;
4814
4815 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4816 arg = convert_filename (arg, 0, access (arg, F_OK));
4817 #endif
4818 add_infile (arg, spec_lang);
4819
4820 continue;
4821 }
4822
4823 read_cmdline_option (&global_options, &global_options_set,
4824 decoded_options + j, UNKNOWN_LOCATION,
4825 CL_DRIVER, &handlers, global_dc);
4826 }
4827
4828 /* If the user didn't specify any, default to all configured offload
4829 targets. */
4830 if (ENABLE_OFFLOADING && offload_targets == NULL)
4831 handle_foffload_option (OFFLOAD_TARGETS);
4832
4833 /* Handle -gtoggle as it would later in toplev.c:process_options to
4834 make the debug-level-gt spec function work as expected. */
4835 if (flag_gtoggle)
4836 {
4837 if (debug_info_level == DINFO_LEVEL_NONE)
4838 debug_info_level = DINFO_LEVEL_NORMAL;
4839 else
4840 debug_info_level = DINFO_LEVEL_NONE;
4841 }
4842
4843 if (output_file
4844 && strcmp (output_file, "-") != 0
4845 && strcmp (output_file, HOST_BIT_BUCKET) != 0)
4846 {
4847 int i;
4848 for (i = 0; i < n_infiles; i++)
4849 if ((!infiles[i].language || infiles[i].language[0] != '*')
4850 && canonical_filename_eq (infiles[i].name, output_file))
4851 fatal_error (input_location,
4852 "input file %qs is the same as output file",
4853 output_file);
4854 }
4855
4856 if (output_file != NULL && output_file[0] == '\0')
4857 fatal_error (input_location, "output filename may not be empty");
4858
4859 /* -dumpdir and -save-temps=* both specify the location of aux/dump
4860 outputs; the one that appears last prevails. When compiling
4861 multiple sources, an explicit dumpbase (minus -ext) may be
4862 combined with an explicit or implicit dumpdir, whereas when
4863 linking, a specified or implied link output name (minus
4864 extension) may be combined with a prevailing -save-temps=* or an
4865 otherwise implied dumpdir, but not override a prevailing
4866 -dumpdir. Primary outputs (e.g., linker output when linking
4867 without -o, or .i, .s or .o outputs when processing multiple
4868 inputs with -E, -S or -c, respectively) are NOT affected by these
4869 -save-temps=/-dump* options, always landing in the current
4870 directory and with the same basename as the input when an output
4871 name is not given, but when they're intermediate outputs, they
4872 are named like other aux outputs, so the options affect their
4873 location and name.
4874
4875 Here are some examples. There are several more in the
4876 documentation of -o and -dump*, and some quite exhaustive tests
4877 in gcc.misc-tests/outputs.exp.
4878
4879 When compiling any number of sources, no -dump* nor
4880 -save-temps=*, all outputs in cwd without prefix:
4881
4882 # gcc -c b.c -gsplit-dwarf
4883 -> cc1 [-dumpdir ./] -dumpbase b.c -dumpbase-ext .c # b.o b.dwo
4884
4885 # gcc -c b.c d.c -gsplit-dwarf
4886 -> cc1 [-dumpdir ./] -dumpbase b.c -dumpbase-ext .c # b.o b.dwo
4887 && cc1 [-dumpdir ./] -dumpbase d.c -dumpbase-ext .c # d.o d.dwo
4888
4889 When compiling and linking, no -dump* nor -save-temps=*, .o
4890 outputs are temporary, aux outputs land in the dir of the output,
4891 prefixed with the basename of the linker output:
4892
4893 # gcc b.c d.c -o ab -gsplit-dwarf
4894 -> cc1 -dumpdir ab- -dumpbase b.c -dumpbase-ext .c # ab-b.dwo
4895 && cc1 -dumpdir ab- -dumpbase d.c -dumpbase-ext .c # ab-d.dwo
4896 && link ... -o ab
4897
4898 # gcc b.c d.c [-o a.out] -gsplit-dwarf
4899 -> cc1 -dumpdir a- -dumpbase b.c -dumpbase-ext .c # a-b.dwo
4900 && cc1 -dumpdir a- -dumpbase d.c -dumpbase-ext .c # a-d.dwo
4901 && link ... [-o a.out]
4902
4903 When compiling and linking, a prevailing -dumpdir fully overrides
4904 the prefix of aux outputs given by the output name:
4905
4906 # gcc -dumpdir f b.c d.c -gsplit-dwarf [-o [dir/]whatever]
4907 -> cc1 -dumpdir f -dumpbase b.c -dumpbase-ext .c # fb.dwo
4908 && cc1 -dumpdir f -dumpbase d.c -dumpbase-ext .c # fd.dwo
4909 && link ... [-o whatever]
4910
4911 When compiling multiple inputs, an explicit -dumpbase is combined
4912 with -dumpdir, affecting aux outputs, but not the .o outputs:
4913
4914 # gcc -dumpdir f -dumpbase g- b.c d.c -gsplit-dwarf -c
4915 -> cc1 -dumpdir fg- -dumpbase b.c -dumpbase-ext .c # b.o fg-b.dwo
4916 && cc1 -dumpdir fg- -dumpbase d.c -dumpbase-ext .c # d.o fg-d.dwo
4917
4918 When compiling and linking with -save-temps, the .o outputs that
4919 would have been temporary become aux outputs, so they get
4920 affected by -dump* flags:
4921
4922 # gcc -dumpdir f -dumpbase g- -save-temps b.c d.c
4923 -> cc1 -dumpdir fg- -dumpbase b.c -dumpbase-ext .c # fg-b.o
4924 && cc1 -dumpdir fg- -dumpbase d.c -dumpbase-ext .c # fg-d.o
4925 && link
4926
4927 If -save-temps=* prevails over -dumpdir, however, the explicit
4928 -dumpdir is discarded, as if it wasn't there. The basename of
4929 the implicit linker output, a.out or a.exe, becomes a- as the aux
4930 output prefix for all compilations:
4931
4932 # gcc [-dumpdir f] -save-temps=cwd b.c d.c
4933 -> cc1 -dumpdir a- -dumpbase b.c -dumpbase-ext .c # a-b.o
4934 && cc1 -dumpdir a- -dumpbase d.c -dumpbase-ext .c # a-d.o
4935 && link
4936
4937 A single -dumpbase, applying to multiple inputs, overrides the
4938 linker output name, implied or explicit, as the aux output prefix:
4939
4940 # gcc [-dumpdir f] -dumpbase g- -save-temps=cwd b.c d.c
4941 -> cc1 -dumpdir g- -dumpbase b.c -dumpbase-ext .c # g-b.o
4942 && cc1 -dumpdir g- -dumpbase d.c -dumpbase-ext .c # g-d.o
4943 && link
4944
4945 # gcc [-dumpdir f] -dumpbase g- -save-temps=cwd b.c d.c -o dir/h.out
4946 -> cc1 -dumpdir g- -dumpbase b.c -dumpbase-ext .c # g-b.o
4947 && cc1 -dumpdir g- -dumpbase d.c -dumpbase-ext .c # g-d.o
4948 && link -o dir/h.out
4949
4950 Now, if the linker output is NOT overridden as a prefix, but
4951 -save-temps=* overrides implicit or explicit -dumpdir, the
4952 effective dump dir combines the dir selected by the -save-temps=*
4953 option with the basename of the specified or implied link output:
4954
4955 # gcc [-dumpdir f] -save-temps=cwd b.c d.c -o dir/h.out
4956 -> cc1 -dumpdir h- -dumpbase b.c -dumpbase-ext .c # h-b.o
4957 && cc1 -dumpdir h- -dumpbase d.c -dumpbase-ext .c # h-d.o
4958 && link -o dir/h.out
4959
4960 # gcc [-dumpdir f] -save-temps=obj b.c d.c -o dir/h.out
4961 -> cc1 -dumpdir dir/h- -dumpbase b.c -dumpbase-ext .c # dir/h-b.o
4962 && cc1 -dumpdir dir/h- -dumpbase d.c -dumpbase-ext .c # dir/h-d.o
4963 && link -o dir/h.out
4964
4965 But then again, a single -dumpbase applying to multiple inputs
4966 gets used instead of the linker output basename in the combined
4967 dumpdir:
4968
4969 # gcc [-dumpdir f] -dumpbase g- -save-temps=obj b.c d.c -o dir/h.out
4970 -> cc1 -dumpdir dir/g- -dumpbase b.c -dumpbase-ext .c # dir/g-b.o
4971 && cc1 -dumpdir dir/g- -dumpbase d.c -dumpbase-ext .c # dir/g-d.o
4972 && link -o dir/h.out
4973
4974 With a single input being compiled, the output basename does NOT
4975 affect the dumpdir prefix.
4976
4977 # gcc -save-temps=obj b.c -gsplit-dwarf -c -o dir/b.o
4978 -> cc1 -dumpdir dir/ -dumpbase b.c -dumpbase-ext .c # dir/b.o dir/b.dwo
4979
4980 but when compiling and linking even a single file, it does:
4981
4982 # gcc -save-temps=obj b.c -o dir/h.out
4983 -> cc1 -dumpdir dir/h- -dumpbase b.c -dumpbase-ext .c # dir/h-b.o
4984
4985 unless an explicit -dumpdir prevails:
4986
4987 # gcc -save-temps[=obj] -dumpdir g- b.c -o dir/h.out
4988 -> cc1 -dumpdir g- -dumpbase b.c -dumpbase-ext .c # g-b.o
4989
4990 */
4991
4992 bool explicit_dumpdir = dumpdir;
4993
4994 if (!save_temps_overrides_dumpdir && explicit_dumpdir)
4995 {
4996 /* Do nothing. */
4997 }
4998
4999 /* If -save-temps=obj and -o name, create the prefix to use for %b.
5000 Otherwise just make -save-temps=obj the same as -save-temps=cwd. */
5001 else if (save_temps_flag != SAVE_TEMPS_CWD && output_file != NULL)
5002 {
5003 free (dumpdir);
5004 dumpdir = NULL;
5005 temp = lbasename (output_file);
5006 if (temp != output_file)
5007 dumpdir = xstrndup (output_file,
5008 strlen (output_file) - strlen (temp));
5009 }
5010 else if (dumpdir)
5011 {
5012 free (dumpdir);
5013 dumpdir = NULL;
5014 }
5015
5016 if (save_temps_flag)
5017 save_temps_flag = SAVE_TEMPS_DUMP;
5018
5019 /* If there is any pathname component in an explicit -dumpbase, it
5020 overrides dumpdir entirely, so discard it right away. Although
5021 the presence of an explicit -dumpdir matters for the driver, it
5022 shouldn't matter for other processes, that get all that's needed
5023 from the -dumpdir and -dumpbase always passed to them. */
5024 if (dumpdir && dumpbase && lbasename (dumpbase) != dumpbase)
5025 {
5026 free (dumpdir);
5027 dumpdir = NULL;
5028 }
5029
5030 /* Check that dumpbase_ext matches the end of dumpbase, drop it
5031 otherwise. */
5032 if (dumpbase_ext && dumpbase && *dumpbase)
5033 {
5034 int lendb = strlen (dumpbase);
5035 int lendbx = strlen (dumpbase_ext);
5036
5037 /* -dumpbase-ext must be a suffix proper; discard it if it
5038 matches all of -dumpbase, as that would make for an empty
5039 basename. */
5040 if (lendbx >= lendb
5041 || strcmp (dumpbase + lendb - lendbx, dumpbase_ext) != 0)
5042 {
5043 free (dumpbase_ext);
5044 dumpbase_ext = NULL;
5045 }
5046 }
5047
5048 /* -dumpbase with multiple sources goes into dumpdir. With a single
5049 source, it does only if linking and if dumpdir was not explicitly
5050 specified. */
5051 if (dumpbase && *dumpbase
5052 && (single_input_file_index () == -2
5053 || (!have_c && !explicit_dumpdir)))
5054 {
5055 char *prefix;
5056
5057 if (dumpbase_ext)
5058 /* We checked that they match above. */
5059 dumpbase[strlen (dumpbase) - strlen (dumpbase_ext)] = '\0';
5060
5061 if (dumpdir)
5062 prefix = concat (dumpdir, dumpbase, "-", NULL);
5063 else
5064 prefix = concat (dumpbase, "-", NULL);
5065
5066 free (dumpdir);
5067 free (dumpbase);
5068 free (dumpbase_ext);
5069 dumpbase = dumpbase_ext = NULL;
5070 dumpdir = prefix;
5071 dumpdir_trailing_dash_added = true;
5072 }
5073
5074 /* If dumpbase was not brought into dumpdir but we're linking, bring
5075 output_file into dumpdir unless dumpdir was explicitly specified.
5076 The test for !explicit_dumpdir is further below, because we want
5077 to use the obase computation for a ghost outbase, passed to
5078 GCC_COLLECT_OPTIONS. */
5079 else if (!have_c && (!explicit_dumpdir || (dumpbase && !*dumpbase)))
5080 {
5081 /* If we get here, we know dumpbase was not specified, or it was
5082 specified as an empty string. If it was anything else, it
5083 would have combined with dumpdir above, because the condition
5084 for dumpbase to be used when present is broader than the
5085 condition that gets us here. */
5086 gcc_assert (!dumpbase || !*dumpbase);
5087
5088 const char *obase;
5089 char *tofree = NULL;
5090 if (!output_file || not_actual_file_p (output_file))
5091 obase = "a";
5092 else
5093 {
5094 obase = lbasename (output_file);
5095 size_t blen = strlen (obase), xlen;
5096 /* Drop the suffix if it's dumpbase_ext, if given,
5097 otherwise .exe or the target executable suffix, or if the
5098 output was explicitly named a.out, but not otherwise. */
5099 if (dumpbase_ext
5100 ? (blen > (xlen = strlen (dumpbase_ext))
5101 && strcmp ((temp = (obase + blen - xlen)),
5102 dumpbase_ext) == 0)
5103 : ((temp = strrchr (obase + 1, '.'))
5104 && (xlen = strlen (temp))
5105 && (strcmp (temp, ".exe") == 0
5106 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
5107 || strcmp (temp, TARGET_EXECUTABLE_SUFFIX) == 0
5108 #endif
5109 || strcmp (obase, "a.out") == 0)))
5110 {
5111 tofree = xstrndup (obase, blen - xlen);
5112 obase = tofree;
5113 }
5114 }
5115
5116 /* We wish to save this basename to the -dumpdir passed through
5117 GCC_COLLECT_OPTIONS within maybe_run_linker, for e.g. LTO,
5118 but we do NOT wish to add it to e.g. %b, so we keep
5119 outbase_length as zero. */
5120 gcc_assert (!outbase);
5121 outbase_length = 0;
5122
5123 /* If we're building [dir1/]foo[.exe] out of a single input
5124 [dir2/]foo.c that shares the same basename, dump to
5125 [dir2/]foo.c.* rather than duplicating the basename into
5126 [dir2/]foo-foo.c.*. */
5127 int idxin;
5128 if (dumpbase
5129 || ((idxin = single_input_file_index ()) >= 0
5130 && adds_single_suffix_p (lbasename (infiles[idxin].name),
5131 obase)))
5132 {
5133 if (obase == tofree)
5134 outbase = tofree;
5135 else
5136 {
5137 outbase = xstrdup (obase);
5138 free (tofree);
5139 }
5140 obase = tofree = NULL;
5141 }
5142 else
5143 {
5144 if (dumpdir)
5145 {
5146 char *p = concat (dumpdir, obase, "-", NULL);
5147 free (dumpdir);
5148 dumpdir = p;
5149 }
5150 else
5151 dumpdir = concat (obase, "-", NULL);
5152
5153 dumpdir_trailing_dash_added = true;
5154
5155 free (tofree);
5156 obase = tofree = NULL;
5157 }
5158
5159 if (!explicit_dumpdir || dumpbase)
5160 {
5161 /* Absent -dumpbase and present -dumpbase-ext have been applied
5162 to the linker output name, so compute fresh defaults for each
5163 compilation. */
5164 free (dumpbase_ext);
5165 dumpbase_ext = NULL;
5166 }
5167 }
5168
5169 /* Now, if we're compiling, or if we haven't used the dumpbase
5170 above, then outbase (%B) is derived from dumpbase, if given, or
5171 from the output name, given or implied. We can't precompute
5172 implied output names, but that's ok, since they're derived from
5173 input names. Just make sure we skip this if dumpbase is the
5174 empty string: we want to use input names then, so don't set
5175 outbase. */
5176 if ((dumpbase || have_c)
5177 && !(dumpbase && !*dumpbase))
5178 {
5179 gcc_assert (!outbase);
5180
5181 if (dumpbase)
5182 {
5183 gcc_assert (single_input_file_index () != -2);
5184 /* We do not want lbasename here; dumpbase with dirnames
5185 overrides dumpdir entirely, even if dumpdir is
5186 specified. */
5187 if (dumpbase_ext)
5188 /* We've already checked above that the suffix matches. */
5189 outbase = xstrndup (dumpbase,
5190 strlen (dumpbase) - strlen (dumpbase_ext));
5191 else
5192 outbase = xstrdup (dumpbase);
5193 }
5194 else if (output_file && !not_actual_file_p (output_file))
5195 {
5196 outbase = xstrdup (lbasename (output_file));
5197 char *p = strrchr (outbase + 1, '.');
5198 if (p)
5199 *p = '\0';
5200 }
5201
5202 if (outbase)
5203 outbase_length = strlen (outbase);
5204 }
5205
5206 /* If there is any pathname component in an explicit -dumpbase, do
5207 not use dumpdir, but retain it to pass it on to the compiler. */
5208 if (dumpdir)
5209 dumpdir_length = strlen (dumpdir);
5210 else
5211 dumpdir_length = 0;
5212
5213 /* Check that dumpbase_ext, if still present, still matches the end
5214 of dumpbase, if present, and drop it otherwise. We only retained
5215 it above when dumpbase was absent to maybe use it to drop the
5216 extension from output_name before combining it with dumpdir. We
5217 won't deal with -dumpbase-ext when -dumpbase is not explicitly
5218 given, even if just to activate backward-compatible dumpbase:
5219 dropping it on the floor is correct, expected and documented
5220 behavior. Attempting to deal with a -dumpbase-ext that might
5221 match the end of some input filename, or of the combination of
5222 the output basename with the suffix of the input filename,
5223 possible with an intermediate .gk extension for -fcompare-debug,
5224 is just calling for trouble. */
5225 if (dumpbase_ext)
5226 {
5227 if (!dumpbase || !*dumpbase)
5228 {
5229 free (dumpbase_ext);
5230 dumpbase_ext = NULL;
5231 }
5232 else
5233 gcc_assert (strcmp (dumpbase + strlen (dumpbase)
5234 - strlen (dumpbase_ext), dumpbase_ext) == 0);
5235 }
5236
5237 if (save_temps_flag && use_pipes)
5238 {
5239 /* -save-temps overrides -pipe, so that temp files are produced */
5240 if (save_temps_flag)
5241 warning (0, "%<-pipe%> ignored because %<-save-temps%> specified");
5242 use_pipes = 0;
5243 }
5244
5245 if (!compare_debug)
5246 {
5247 const char *gcd = env.get ("GCC_COMPARE_DEBUG");
5248
5249 if (gcd && gcd[0] == '-')
5250 {
5251 compare_debug = 2;
5252 compare_debug_opt = gcd;
5253 }
5254 else if (gcd && *gcd && strcmp (gcd, "0"))
5255 {
5256 compare_debug = 3;
5257 compare_debug_opt = "-gtoggle";
5258 }
5259 }
5260 else if (compare_debug < 0)
5261 {
5262 compare_debug = 0;
5263 gcc_assert (!compare_debug_opt);
5264 }
5265
5266 /* Set up the search paths. We add directories that we expect to
5267 contain GNU Toolchain components before directories specified by
5268 the machine description so that we will find GNU components (like
5269 the GNU assembler) before those of the host system. */
5270
5271 /* If we don't know where the toolchain has been installed, use the
5272 configured-in locations. */
5273 if (!gcc_exec_prefix)
5274 {
5275 #ifndef OS2
5276 add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC",
5277 PREFIX_PRIORITY_LAST, 1, 0);
5278 add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS",
5279 PREFIX_PRIORITY_LAST, 2, 0);
5280 add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
5281 PREFIX_PRIORITY_LAST, 2, 0);
5282 #endif
5283 add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
5284 PREFIX_PRIORITY_LAST, 1, 0);
5285 }
5286
5287 gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix));
5288 tooldir_prefix2 = concat (tooldir_base_prefix, spec_machine,
5289 dir_separator_str, NULL);
5290
5291 /* Look for tools relative to the location from which the driver is
5292 running, or, if that is not available, the configured prefix. */
5293 tooldir_prefix
5294 = concat (gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
5295 spec_host_machine, dir_separator_str, spec_version,
5296 accel_dir_suffix, dir_separator_str, tooldir_prefix2, NULL);
5297 free (tooldir_prefix2);
5298
5299 add_prefix (&exec_prefixes,
5300 concat (tooldir_prefix, "bin", dir_separator_str, NULL),
5301 "BINUTILS", PREFIX_PRIORITY_LAST, 0, 0);
5302 add_prefix (&startfile_prefixes,
5303 concat (tooldir_prefix, "lib", dir_separator_str, NULL),
5304 "BINUTILS", PREFIX_PRIORITY_LAST, 0, 1);
5305 free (tooldir_prefix);
5306
5307 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
5308 /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
5309 then consider it to relocate with the rest of the GCC installation
5310 if GCC_EXEC_PREFIX is set.
5311 ``make_relative_prefix'' is not compiled for VMS, so don't call it. */
5312 if (target_system_root && !target_system_root_changed && gcc_exec_prefix)
5313 {
5314 char *tmp_prefix = get_relative_prefix (decoded_options[0].arg,
5315 standard_bindir_prefix,
5316 target_system_root);
5317 if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0)
5318 {
5319 target_system_root = tmp_prefix;
5320 target_system_root_changed = 1;
5321 }
5322 }
5323 #endif
5324
5325 /* More prefixes are enabled in main, after we read the specs file
5326 and determine whether this is cross-compilation or not. */
5327
5328 if (n_infiles != 0 && n_infiles == last_language_n_infiles && spec_lang != 0)
5329 warning (0, "%<-x %s%> after last input file has no effect", spec_lang);
5330
5331 /* Synthesize -fcompare-debug flag from the GCC_COMPARE_DEBUG
5332 environment variable. */
5333 if (compare_debug == 2 || compare_debug == 3)
5334 {
5335 const char *opt = concat ("-fcompare-debug=", compare_debug_opt, NULL);
5336 save_switch (opt, 0, NULL, false, true);
5337 compare_debug = 1;
5338 }
5339
5340 /* Ensure we only invoke each subprocess once. */
5341 if (n_infiles == 0
5342 && (print_subprocess_help || print_help_list || print_version))
5343 {
5344 /* Create a dummy input file, so that we can pass
5345 the help option on to the various sub-processes. */
5346 add_infile ("help-dummy", "c");
5347 }
5348
5349 /* Decide if undefined variable references are allowed in specs. */
5350
5351 /* -v alone is safe. --version and --help alone or together are safe. Note
5352 that -v would make them unsafe, as they'd then be run for subprocesses as
5353 well, the location of which might depend on variables possibly coming
5354 from self-specs. Note also that the command name is counted in
5355 decoded_options_count. */
5356
5357 unsigned help_version_count = 0;
5358
5359 if (print_version)
5360 help_version_count++;
5361
5362 if (print_help_list)
5363 help_version_count++;
5364
5365 spec_undefvar_allowed =
5366 ((verbose_flag && decoded_options_count == 2)
5367 || help_version_count == decoded_options_count - 1);
5368
5369 alloc_switch ();
5370 switches[n_switches].part1 = 0;
5371 alloc_infile ();
5372 infiles[n_infiles].name = 0;
5373 }
5374
5375 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
5376 and place that in the environment. */
5377
5378 static void
set_collect_gcc_options(void)5379 set_collect_gcc_options (void)
5380 {
5381 int i;
5382 int first_time;
5383
5384 /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
5385 the compiler. */
5386 obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
5387 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
5388
5389 first_time = TRUE;
5390 for (i = 0; (int) i < n_switches; i++)
5391 {
5392 const char *const *args;
5393 const char *p, *q;
5394 if (!first_time)
5395 obstack_grow (&collect_obstack, " ", 1);
5396
5397 first_time = FALSE;
5398
5399 /* Ignore elided switches. */
5400 if ((switches[i].live_cond
5401 & (SWITCH_IGNORE | SWITCH_KEEP_FOR_GCC))
5402 == SWITCH_IGNORE)
5403 continue;
5404
5405 obstack_grow (&collect_obstack, "'-", 2);
5406 q = switches[i].part1;
5407 while ((p = strchr (q, '\'')))
5408 {
5409 obstack_grow (&collect_obstack, q, p - q);
5410 obstack_grow (&collect_obstack, "'\\''", 4);
5411 q = ++p;
5412 }
5413 obstack_grow (&collect_obstack, q, strlen (q));
5414 obstack_grow (&collect_obstack, "'", 1);
5415
5416 for (args = switches[i].args; args && *args; args++)
5417 {
5418 obstack_grow (&collect_obstack, " '", 2);
5419 q = *args;
5420 while ((p = strchr (q, '\'')))
5421 {
5422 obstack_grow (&collect_obstack, q, p - q);
5423 obstack_grow (&collect_obstack, "'\\''", 4);
5424 q = ++p;
5425 }
5426 obstack_grow (&collect_obstack, q, strlen (q));
5427 obstack_grow (&collect_obstack, "'", 1);
5428 }
5429 }
5430
5431 if (dumpdir)
5432 {
5433 if (!first_time)
5434 obstack_grow (&collect_obstack, " ", 1);
5435 first_time = FALSE;
5436
5437 obstack_grow (&collect_obstack, "'-dumpdir' '", 12);
5438 const char *p, *q;
5439
5440 q = dumpdir;
5441 while ((p = strchr (q, '\'')))
5442 {
5443 obstack_grow (&collect_obstack, q, p - q);
5444 obstack_grow (&collect_obstack, "'\\''", 4);
5445 q = ++p;
5446 }
5447 obstack_grow (&collect_obstack, q, strlen (q));
5448
5449 obstack_grow (&collect_obstack, "'", 1);
5450 }
5451
5452 obstack_grow (&collect_obstack, "\0", 1);
5453 xputenv (XOBFINISH (&collect_obstack, char *));
5454 }
5455
5456 /* Process a spec string, accumulating and running commands. */
5457
5458 /* These variables describe the input file name.
5459 input_file_number is the index on outfiles of this file,
5460 so that the output file name can be stored for later use by %o.
5461 input_basename is the start of the part of the input file
5462 sans all directory names, and basename_length is the number
5463 of characters starting there excluding the suffix .c or whatever. */
5464
5465 static const char *gcc_input_filename;
5466 static int input_file_number;
5467 size_t input_filename_length;
5468 static int basename_length;
5469 static int suffixed_basename_length;
5470 static const char *input_basename;
5471 static const char *input_suffix;
5472 #ifndef HOST_LACKS_INODE_NUMBERS
5473 static struct stat input_stat;
5474 #endif
5475 static int input_stat_set;
5476
5477 /* The compiler used to process the current input file. */
5478 static struct compiler *input_file_compiler;
5479
5480 /* These are variables used within do_spec and do_spec_1. */
5481
5482 /* Nonzero if an arg has been started and not yet terminated
5483 (with space, tab or newline). */
5484 static int arg_going;
5485
5486 /* Nonzero means %d or %g has been seen; the next arg to be terminated
5487 is a temporary file name. */
5488 static int delete_this_arg;
5489
5490 /* Nonzero means %w has been seen; the next arg to be terminated
5491 is the output file name of this compilation. */
5492 static int this_is_output_file;
5493
5494 /* Nonzero means %s has been seen; the next arg to be terminated
5495 is the name of a library file and we should try the standard
5496 search dirs for it. */
5497 static int this_is_library_file;
5498
5499 /* Nonzero means %T has been seen; the next arg to be terminated
5500 is the name of a linker script and we should try all of the
5501 standard search dirs for it. If it is found insert a --script
5502 command line switch and then substitute the full path in place,
5503 otherwise generate an error message. */
5504 static int this_is_linker_script;
5505
5506 /* Nonzero means that the input of this command is coming from a pipe. */
5507 static int input_from_pipe;
5508
5509 /* Nonnull means substitute this for any suffix when outputting a switches
5510 arguments. */
5511 static const char *suffix_subst;
5512
5513 /* If there is an argument being accumulated, terminate it and store it. */
5514
5515 static void
end_going_arg(void)5516 end_going_arg (void)
5517 {
5518 if (arg_going)
5519 {
5520 const char *string;
5521
5522 obstack_1grow (&obstack, 0);
5523 string = XOBFINISH (&obstack, const char *);
5524 if (this_is_library_file)
5525 string = find_file (string);
5526 if (this_is_linker_script)
5527 {
5528 char * full_script_path = find_a_file (&startfile_prefixes, string, R_OK, true);
5529
5530 if (full_script_path == NULL)
5531 {
5532 error ("unable to locate default linker script %qs in the library search paths", string);
5533 /* Script was not found on search path. */
5534 return;
5535 }
5536 store_arg ("--script", false, false);
5537 string = full_script_path;
5538 }
5539 store_arg (string, delete_this_arg, this_is_output_file);
5540 if (this_is_output_file)
5541 outfiles[input_file_number] = string;
5542 arg_going = 0;
5543 }
5544 }
5545
5546
5547 /* Parse the WRAPPER string which is a comma separated list of the command line
5548 and insert them into the beginning of argbuf. */
5549
5550 static void
insert_wrapper(const char * wrapper)5551 insert_wrapper (const char *wrapper)
5552 {
5553 int n = 0;
5554 int i;
5555 char *buf = xstrdup (wrapper);
5556 char *p = buf;
5557 unsigned int old_length = argbuf.length ();
5558
5559 do
5560 {
5561 n++;
5562 while (*p == ',')
5563 p++;
5564 }
5565 while ((p = strchr (p, ',')) != NULL);
5566
5567 argbuf.safe_grow (old_length + n, true);
5568 memmove (argbuf.address () + n,
5569 argbuf.address (),
5570 old_length * sizeof (const_char_p));
5571
5572 i = 0;
5573 p = buf;
5574 do
5575 {
5576 while (*p == ',')
5577 {
5578 *p = 0;
5579 p++;
5580 }
5581 argbuf[i] = p;
5582 i++;
5583 }
5584 while ((p = strchr (p, ',')) != NULL);
5585 gcc_assert (i == n);
5586 }
5587
5588 /* Process the spec SPEC and run the commands specified therein.
5589 Returns 0 if the spec is successfully processed; -1 if failed. */
5590
5591 int
do_spec(const char * spec)5592 do_spec (const char *spec)
5593 {
5594 int value;
5595
5596 value = do_spec_2 (spec, NULL);
5597
5598 /* Force out any unfinished command.
5599 If -pipe, this forces out the last command if it ended in `|'. */
5600 if (value == 0)
5601 {
5602 if (argbuf.length () > 0
5603 && !strcmp (argbuf.last (), "|"))
5604 argbuf.pop ();
5605
5606 set_collect_gcc_options ();
5607
5608 if (argbuf.length () > 0)
5609 value = execute ();
5610 }
5611
5612 return value;
5613 }
5614
5615 /* Process the spec SPEC, with SOFT_MATCHED_PART designating the current value
5616 of a matched * pattern which may be re-injected by way of %*. */
5617
5618 static int
do_spec_2(const char * spec,const char * soft_matched_part)5619 do_spec_2 (const char *spec, const char *soft_matched_part)
5620 {
5621 int result;
5622
5623 clear_args ();
5624 arg_going = 0;
5625 delete_this_arg = 0;
5626 this_is_output_file = 0;
5627 this_is_library_file = 0;
5628 this_is_linker_script = 0;
5629 input_from_pipe = 0;
5630 suffix_subst = NULL;
5631
5632 result = do_spec_1 (spec, 0, soft_matched_part);
5633
5634 end_going_arg ();
5635
5636 return result;
5637 }
5638
5639 /* Process the given spec string and add any new options to the end
5640 of the switches/n_switches array. */
5641
5642 static void
do_option_spec(const char * name,const char * spec)5643 do_option_spec (const char *name, const char *spec)
5644 {
5645 unsigned int i, value_count, value_len;
5646 const char *p, *q, *value;
5647 char *tmp_spec, *tmp_spec_p;
5648
5649 if (configure_default_options[0].name == NULL)
5650 return;
5651
5652 for (i = 0; i < ARRAY_SIZE (configure_default_options); i++)
5653 if (strcmp (configure_default_options[i].name, name) == 0)
5654 break;
5655 if (i == ARRAY_SIZE (configure_default_options))
5656 return;
5657
5658 value = configure_default_options[i].value;
5659 value_len = strlen (value);
5660
5661 /* Compute the size of the final spec. */
5662 value_count = 0;
5663 p = spec;
5664 while ((p = strstr (p, "%(VALUE)")) != NULL)
5665 {
5666 p ++;
5667 value_count ++;
5668 }
5669
5670 /* Replace each %(VALUE) by the specified value. */
5671 tmp_spec = (char *) alloca (strlen (spec) + 1
5672 + value_count * (value_len - strlen ("%(VALUE)")));
5673 tmp_spec_p = tmp_spec;
5674 q = spec;
5675 while ((p = strstr (q, "%(VALUE)")) != NULL)
5676 {
5677 memcpy (tmp_spec_p, q, p - q);
5678 tmp_spec_p = tmp_spec_p + (p - q);
5679 memcpy (tmp_spec_p, value, value_len);
5680 tmp_spec_p += value_len;
5681 q = p + strlen ("%(VALUE)");
5682 }
5683 strcpy (tmp_spec_p, q);
5684
5685 do_self_spec (tmp_spec);
5686 }
5687
5688 /* Process the given spec string and add any new options to the end
5689 of the switches/n_switches array. */
5690
5691 static void
do_self_spec(const char * spec)5692 do_self_spec (const char *spec)
5693 {
5694 int i;
5695
5696 do_spec_2 (spec, NULL);
5697 do_spec_1 (" ", 0, NULL);
5698
5699 /* Mark %<S switches processed by do_self_spec to be ignored permanently.
5700 do_self_specs adds the replacements to switches array, so it shouldn't
5701 be processed afterwards. */
5702 for (i = 0; i < n_switches; i++)
5703 if ((switches[i].live_cond & SWITCH_IGNORE))
5704 switches[i].live_cond |= SWITCH_IGNORE_PERMANENTLY;
5705
5706 if (argbuf.length () > 0)
5707 {
5708 const char **argbuf_copy;
5709 struct cl_decoded_option *decoded_options;
5710 struct cl_option_handlers handlers;
5711 unsigned int decoded_options_count;
5712 unsigned int j;
5713
5714 /* Create a copy of argbuf with a dummy argv[0] entry for
5715 decode_cmdline_options_to_array. */
5716 argbuf_copy = XNEWVEC (const char *,
5717 argbuf.length () + 1);
5718 argbuf_copy[0] = "";
5719 memcpy (argbuf_copy + 1, argbuf.address (),
5720 argbuf.length () * sizeof (const char *));
5721
5722 decode_cmdline_options_to_array (argbuf.length () + 1,
5723 argbuf_copy,
5724 CL_DRIVER, &decoded_options,
5725 &decoded_options_count);
5726 free (argbuf_copy);
5727
5728 set_option_handlers (&handlers);
5729
5730 for (j = 1; j < decoded_options_count; j++)
5731 {
5732 switch (decoded_options[j].opt_index)
5733 {
5734 case OPT_SPECIAL_input_file:
5735 /* Specs should only generate options, not input
5736 files. */
5737 if (strcmp (decoded_options[j].arg, "-") != 0)
5738 fatal_error (input_location,
5739 "switch %qs does not start with %<-%>",
5740 decoded_options[j].arg);
5741 else
5742 fatal_error (input_location,
5743 "spec-generated switch is just %<-%>");
5744 break;
5745
5746 case OPT_fcompare_debug_second:
5747 case OPT_fcompare_debug:
5748 case OPT_fcompare_debug_:
5749 case OPT_o:
5750 /* Avoid duplicate processing of some options from
5751 compare-debug specs; just save them here. */
5752 save_switch (decoded_options[j].canonical_option[0],
5753 (decoded_options[j].canonical_option_num_elements
5754 - 1),
5755 &decoded_options[j].canonical_option[1], false, true);
5756 break;
5757
5758 default:
5759 read_cmdline_option (&global_options, &global_options_set,
5760 decoded_options + j, UNKNOWN_LOCATION,
5761 CL_DRIVER, &handlers, global_dc);
5762 break;
5763 }
5764 }
5765
5766 free (decoded_options);
5767
5768 alloc_switch ();
5769 switches[n_switches].part1 = 0;
5770 }
5771 }
5772
5773 /* Callback for processing %D and %I specs. */
5774
5775 struct spec_path_info {
5776 const char *option;
5777 const char *append;
5778 size_t append_len;
5779 bool omit_relative;
5780 bool separate_options;
5781 };
5782
5783 static void *
spec_path(char * path,void * data)5784 spec_path (char *path, void *data)
5785 {
5786 struct spec_path_info *info = (struct spec_path_info *) data;
5787 size_t len = 0;
5788 char save = 0;
5789
5790 if (info->omit_relative && !IS_ABSOLUTE_PATH (path))
5791 return NULL;
5792
5793 if (info->append_len != 0)
5794 {
5795 len = strlen (path);
5796 memcpy (path + len, info->append, info->append_len + 1);
5797 }
5798
5799 if (!is_directory (path, true))
5800 return NULL;
5801
5802 do_spec_1 (info->option, 1, NULL);
5803 if (info->separate_options)
5804 do_spec_1 (" ", 0, NULL);
5805
5806 if (info->append_len == 0)
5807 {
5808 len = strlen (path);
5809 save = path[len - 1];
5810 if (IS_DIR_SEPARATOR (path[len - 1]))
5811 path[len - 1] = '\0';
5812 }
5813
5814 do_spec_1 (path, 1, NULL);
5815 do_spec_1 (" ", 0, NULL);
5816
5817 /* Must not damage the original path. */
5818 if (info->append_len == 0)
5819 path[len - 1] = save;
5820
5821 return NULL;
5822 }
5823
5824 /* True if we should compile INFILE. */
5825
5826 static bool
compile_input_file_p(struct infile * infile)5827 compile_input_file_p (struct infile *infile)
5828 {
5829 if ((!infile->language) || (infile->language[0] != '*'))
5830 if (infile->incompiler == input_file_compiler)
5831 return true;
5832 return false;
5833 }
5834
5835 /* Process each member of VEC as a spec. */
5836
5837 static void
do_specs_vec(vec<char_p> vec)5838 do_specs_vec (vec<char_p> vec)
5839 {
5840 unsigned ix;
5841 char *opt;
5842
5843 FOR_EACH_VEC_ELT (vec, ix, opt)
5844 {
5845 do_spec_1 (opt, 1, NULL);
5846 /* Make each accumulated option a separate argument. */
5847 do_spec_1 (" ", 0, NULL);
5848 }
5849 }
5850
5851 /* Add options passed via -Xassembler or -Wa to COLLECT_AS_OPTIONS. */
5852
5853 static void
putenv_COLLECT_AS_OPTIONS(vec<char_p> vec)5854 putenv_COLLECT_AS_OPTIONS (vec<char_p> vec)
5855 {
5856 if (vec.is_empty ())
5857 return;
5858
5859 obstack_init (&collect_obstack);
5860 obstack_grow (&collect_obstack, "COLLECT_AS_OPTIONS=",
5861 strlen ("COLLECT_AS_OPTIONS="));
5862
5863 char *opt;
5864 unsigned ix;
5865
5866 FOR_EACH_VEC_ELT (vec, ix, opt)
5867 {
5868 obstack_1grow (&collect_obstack, '\'');
5869 obstack_grow (&collect_obstack, opt, strlen (opt));
5870 obstack_1grow (&collect_obstack, '\'');
5871 if (ix < vec.length () - 1)
5872 obstack_1grow(&collect_obstack, ' ');
5873 }
5874
5875 obstack_1grow (&collect_obstack, '\0');
5876 xputenv (XOBFINISH (&collect_obstack, char *));
5877 }
5878
5879 /* Process the sub-spec SPEC as a portion of a larger spec.
5880 This is like processing a whole spec except that we do
5881 not initialize at the beginning and we do not supply a
5882 newline by default at the end.
5883 INSWITCH nonzero means don't process %-sequences in SPEC;
5884 in this case, % is treated as an ordinary character.
5885 This is used while substituting switches.
5886 INSWITCH nonzero also causes SPC not to terminate an argument.
5887
5888 Value is zero unless a line was finished
5889 and the command on that line reported an error. */
5890
5891 static int
do_spec_1(const char * spec,int inswitch,const char * soft_matched_part)5892 do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
5893 {
5894 const char *p = spec;
5895 int c;
5896 int i;
5897 int value;
5898
5899 /* If it's an empty string argument to a switch, keep it as is. */
5900 if (inswitch && !*p)
5901 arg_going = 1;
5902
5903 while ((c = *p++))
5904 /* If substituting a switch, treat all chars like letters.
5905 Otherwise, NL, SPC, TAB and % are special. */
5906 switch (inswitch ? 'a' : c)
5907 {
5908 case '\n':
5909 end_going_arg ();
5910
5911 if (argbuf.length () > 0
5912 && !strcmp (argbuf.last (), "|"))
5913 {
5914 /* A `|' before the newline means use a pipe here,
5915 but only if -pipe was specified.
5916 Otherwise, execute now and don't pass the `|' as an arg. */
5917 if (use_pipes)
5918 {
5919 input_from_pipe = 1;
5920 break;
5921 }
5922 else
5923 argbuf.pop ();
5924 }
5925
5926 set_collect_gcc_options ();
5927
5928 if (argbuf.length () > 0)
5929 {
5930 value = execute ();
5931 if (value)
5932 return value;
5933 }
5934 /* Reinitialize for a new command, and for a new argument. */
5935 clear_args ();
5936 arg_going = 0;
5937 delete_this_arg = 0;
5938 this_is_output_file = 0;
5939 this_is_library_file = 0;
5940 this_is_linker_script = 0;
5941 input_from_pipe = 0;
5942 break;
5943
5944 case '|':
5945 end_going_arg ();
5946
5947 /* Use pipe */
5948 obstack_1grow (&obstack, c);
5949 arg_going = 1;
5950 break;
5951
5952 case '\t':
5953 case ' ':
5954 end_going_arg ();
5955
5956 /* Reinitialize for a new argument. */
5957 delete_this_arg = 0;
5958 this_is_output_file = 0;
5959 this_is_library_file = 0;
5960 this_is_linker_script = 0;
5961 break;
5962
5963 case '%':
5964 switch (c = *p++)
5965 {
5966 case 0:
5967 fatal_error (input_location, "spec %qs invalid", spec);
5968
5969 case 'b':
5970 /* Don't use %b in the linker command. */
5971 gcc_assert (suffixed_basename_length);
5972 if (!this_is_output_file && dumpdir_length)
5973 obstack_grow (&obstack, dumpdir, dumpdir_length);
5974 if (this_is_output_file || !outbase_length)
5975 obstack_grow (&obstack, input_basename, basename_length);
5976 else
5977 obstack_grow (&obstack, outbase, outbase_length);
5978 if (compare_debug < 0)
5979 obstack_grow (&obstack, ".gk", 3);
5980 arg_going = 1;
5981 break;
5982
5983 case 'B':
5984 /* Don't use %B in the linker command. */
5985 gcc_assert (suffixed_basename_length);
5986 if (!this_is_output_file && dumpdir_length)
5987 obstack_grow (&obstack, dumpdir, dumpdir_length);
5988 if (this_is_output_file || !outbase_length)
5989 obstack_grow (&obstack, input_basename, basename_length);
5990 else
5991 obstack_grow (&obstack, outbase, outbase_length);
5992 if (compare_debug < 0)
5993 obstack_grow (&obstack, ".gk", 3);
5994 obstack_grow (&obstack, input_basename + basename_length,
5995 suffixed_basename_length - basename_length);
5996
5997 arg_going = 1;
5998 break;
5999
6000 case 'd':
6001 delete_this_arg = 2;
6002 break;
6003
6004 /* Dump out the directories specified with LIBRARY_PATH,
6005 followed by the absolute directories
6006 that we search for startfiles. */
6007 case 'D':
6008 {
6009 struct spec_path_info info;
6010
6011 info.option = "-L";
6012 info.append_len = 0;
6013 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
6014 /* Used on systems which record the specified -L dirs
6015 and use them to search for dynamic linking.
6016 Relative directories always come from -B,
6017 and it is better not to use them for searching
6018 at run time. In particular, stage1 loses. */
6019 info.omit_relative = true;
6020 #else
6021 info.omit_relative = false;
6022 #endif
6023 info.separate_options = false;
6024
6025 for_each_path (&startfile_prefixes, true, 0, spec_path, &info);
6026 }
6027 break;
6028
6029 case 'e':
6030 /* %efoo means report an error with `foo' as error message
6031 and don't execute any more commands for this file. */
6032 {
6033 const char *q = p;
6034 char *buf;
6035 while (*p != 0 && *p != '\n')
6036 p++;
6037 buf = (char *) alloca (p - q + 1);
6038 strncpy (buf, q, p - q);
6039 buf[p - q] = 0;
6040 error ("%s", _(buf));
6041 return -1;
6042 }
6043 break;
6044 case 'n':
6045 /* %nfoo means report a notice with `foo' on stderr. */
6046 {
6047 const char *q = p;
6048 char *buf;
6049 while (*p != 0 && *p != '\n')
6050 p++;
6051 buf = (char *) alloca (p - q + 1);
6052 strncpy (buf, q, p - q);
6053 buf[p - q] = 0;
6054 inform (UNKNOWN_LOCATION, "%s", _(buf));
6055 if (*p)
6056 p++;
6057 }
6058 break;
6059
6060 case 'j':
6061 {
6062 struct stat st;
6063
6064 /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
6065 defined, and it is not a directory, and it is
6066 writable, use it. Otherwise, treat this like any
6067 other temporary file. */
6068
6069 if ((!save_temps_flag)
6070 && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode))
6071 && (access (HOST_BIT_BUCKET, W_OK) == 0))
6072 {
6073 obstack_grow (&obstack, HOST_BIT_BUCKET,
6074 strlen (HOST_BIT_BUCKET));
6075 delete_this_arg = 0;
6076 arg_going = 1;
6077 break;
6078 }
6079 }
6080 goto create_temp_file;
6081 case '|':
6082 if (use_pipes)
6083 {
6084 obstack_1grow (&obstack, '-');
6085 delete_this_arg = 0;
6086 arg_going = 1;
6087
6088 /* consume suffix */
6089 while (*p == '.' || ISALNUM ((unsigned char) *p))
6090 p++;
6091 if (p[0] == '%' && p[1] == 'O')
6092 p += 2;
6093
6094 break;
6095 }
6096 goto create_temp_file;
6097 case 'm':
6098 if (use_pipes)
6099 {
6100 /* consume suffix */
6101 while (*p == '.' || ISALNUM ((unsigned char) *p))
6102 p++;
6103 if (p[0] == '%' && p[1] == 'O')
6104 p += 2;
6105
6106 break;
6107 }
6108 goto create_temp_file;
6109 case 'g':
6110 case 'u':
6111 case 'U':
6112 create_temp_file:
6113 {
6114 struct temp_name *t;
6115 int suffix_length;
6116 const char *suffix = p;
6117 char *saved_suffix = NULL;
6118
6119 while (*p == '.' || ISALNUM ((unsigned char) *p))
6120 p++;
6121 suffix_length = p - suffix;
6122 if (p[0] == '%' && p[1] == 'O')
6123 {
6124 p += 2;
6125 /* We don't support extra suffix characters after %O. */
6126 if (*p == '.' || ISALNUM ((unsigned char) *p))
6127 fatal_error (input_location,
6128 "spec %qs has invalid %<%%0%c%>", spec, *p);
6129 if (suffix_length == 0)
6130 suffix = TARGET_OBJECT_SUFFIX;
6131 else
6132 {
6133 saved_suffix
6134 = XNEWVEC (char, suffix_length
6135 + strlen (TARGET_OBJECT_SUFFIX) + 1);
6136 strncpy (saved_suffix, suffix, suffix_length);
6137 strcpy (saved_suffix + suffix_length,
6138 TARGET_OBJECT_SUFFIX);
6139 }
6140 suffix_length += strlen (TARGET_OBJECT_SUFFIX);
6141 }
6142
6143 if (compare_debug < 0)
6144 {
6145 suffix = concat (".gk", suffix, NULL);
6146 suffix_length += 3;
6147 }
6148
6149 /* If -save-temps was specified, use that for the
6150 temp file. */
6151 if (save_temps_flag)
6152 {
6153 char *tmp;
6154 bool adjusted_suffix = false;
6155 if (suffix_length
6156 && !outbase_length && !basename_length
6157 && !dumpdir_trailing_dash_added)
6158 {
6159 adjusted_suffix = true;
6160 suffix++;
6161 suffix_length--;
6162 }
6163 temp_filename_length
6164 = dumpdir_length + suffix_length + 1;
6165 if (outbase_length)
6166 temp_filename_length += outbase_length;
6167 else
6168 temp_filename_length += basename_length;
6169 tmp = (char *) alloca (temp_filename_length);
6170 if (dumpdir_length)
6171 memcpy (tmp, dumpdir, dumpdir_length);
6172 if (outbase_length)
6173 memcpy (tmp + dumpdir_length, outbase,
6174 outbase_length);
6175 else if (basename_length)
6176 memcpy (tmp + dumpdir_length, input_basename,
6177 basename_length);
6178 memcpy (tmp + temp_filename_length - suffix_length - 1,
6179 suffix, suffix_length);
6180 if (adjusted_suffix)
6181 {
6182 adjusted_suffix = false;
6183 suffix--;
6184 suffix_length++;
6185 }
6186 tmp[temp_filename_length - 1] = '\0';
6187 temp_filename = tmp;
6188
6189 if (filename_cmp (temp_filename, gcc_input_filename) != 0)
6190 {
6191 #ifndef HOST_LACKS_INODE_NUMBERS
6192 struct stat st_temp;
6193
6194 /* Note, set_input() resets input_stat_set to 0. */
6195 if (input_stat_set == 0)
6196 {
6197 input_stat_set = stat (gcc_input_filename,
6198 &input_stat);
6199 if (input_stat_set >= 0)
6200 input_stat_set = 1;
6201 }
6202
6203 /* If we have the stat for the gcc_input_filename
6204 and we can do the stat for the temp_filename
6205 then the they could still refer to the same
6206 file if st_dev/st_ino's are the same. */
6207 if (input_stat_set != 1
6208 || stat (temp_filename, &st_temp) < 0
6209 || input_stat.st_dev != st_temp.st_dev
6210 || input_stat.st_ino != st_temp.st_ino)
6211 #else
6212 /* Just compare canonical pathnames. */
6213 char* input_realname = lrealpath (gcc_input_filename);
6214 char* temp_realname = lrealpath (temp_filename);
6215 bool files_differ = filename_cmp (input_realname, temp_realname);
6216 free (input_realname);
6217 free (temp_realname);
6218 if (files_differ)
6219 #endif
6220 {
6221 temp_filename
6222 = save_string (temp_filename,
6223 temp_filename_length - 1);
6224 obstack_grow (&obstack, temp_filename,
6225 temp_filename_length);
6226 arg_going = 1;
6227 delete_this_arg = 0;
6228 break;
6229 }
6230 }
6231 }
6232
6233 /* See if we already have an association of %g/%u/%U and
6234 suffix. */
6235 for (t = temp_names; t; t = t->next)
6236 if (t->length == suffix_length
6237 && strncmp (t->suffix, suffix, suffix_length) == 0
6238 && t->unique == (c == 'u' || c == 'U' || c == 'j'))
6239 break;
6240
6241 /* Make a new association if needed. %u and %j
6242 require one. */
6243 if (t == 0 || c == 'u' || c == 'j')
6244 {
6245 if (t == 0)
6246 {
6247 t = XNEW (struct temp_name);
6248 t->next = temp_names;
6249 temp_names = t;
6250 }
6251 t->length = suffix_length;
6252 if (saved_suffix)
6253 {
6254 t->suffix = saved_suffix;
6255 saved_suffix = NULL;
6256 }
6257 else
6258 t->suffix = save_string (suffix, suffix_length);
6259 t->unique = (c == 'u' || c == 'U' || c == 'j');
6260 temp_filename = make_temp_file (t->suffix);
6261 temp_filename_length = strlen (temp_filename);
6262 t->filename = temp_filename;
6263 t->filename_length = temp_filename_length;
6264 }
6265
6266 free (saved_suffix);
6267
6268 obstack_grow (&obstack, t->filename, t->filename_length);
6269 delete_this_arg = 1;
6270 }
6271 arg_going = 1;
6272 break;
6273
6274 case 'i':
6275 if (combine_inputs)
6276 {
6277 /* We are going to expand `%i' into `@FILE', where FILE
6278 is a newly-created temporary filename. The filenames
6279 that would usually be expanded in place of %o will be
6280 written to the temporary file. */
6281 if (at_file_supplied)
6282 open_at_file ();
6283
6284 for (i = 0; (int) i < n_infiles; i++)
6285 if (compile_input_file_p (&infiles[i]))
6286 {
6287 store_arg (infiles[i].name, 0, 0);
6288 infiles[i].compiled = true;
6289 }
6290
6291 if (at_file_supplied)
6292 close_at_file ();
6293 }
6294 else
6295 {
6296 obstack_grow (&obstack, gcc_input_filename,
6297 input_filename_length);
6298 arg_going = 1;
6299 }
6300 break;
6301
6302 case 'I':
6303 {
6304 struct spec_path_info info;
6305
6306 if (multilib_dir)
6307 {
6308 do_spec_1 ("-imultilib", 1, NULL);
6309 /* Make this a separate argument. */
6310 do_spec_1 (" ", 0, NULL);
6311 do_spec_1 (multilib_dir, 1, NULL);
6312 do_spec_1 (" ", 0, NULL);
6313 }
6314
6315 if (multiarch_dir)
6316 {
6317 do_spec_1 ("-imultiarch", 1, NULL);
6318 /* Make this a separate argument. */
6319 do_spec_1 (" ", 0, NULL);
6320 do_spec_1 (multiarch_dir, 1, NULL);
6321 do_spec_1 (" ", 0, NULL);
6322 }
6323
6324 if (gcc_exec_prefix)
6325 {
6326 do_spec_1 ("-iprefix", 1, NULL);
6327 /* Make this a separate argument. */
6328 do_spec_1 (" ", 0, NULL);
6329 do_spec_1 (gcc_exec_prefix, 1, NULL);
6330 do_spec_1 (" ", 0, NULL);
6331 }
6332
6333 if (target_system_root_changed ||
6334 (target_system_root && target_sysroot_hdrs_suffix))
6335 {
6336 do_spec_1 ("-isysroot", 1, NULL);
6337 /* Make this a separate argument. */
6338 do_spec_1 (" ", 0, NULL);
6339 do_spec_1 (target_system_root, 1, NULL);
6340 if (target_sysroot_hdrs_suffix)
6341 do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL);
6342 do_spec_1 (" ", 0, NULL);
6343 }
6344
6345 info.option = "-isystem";
6346 info.append = "include";
6347 info.append_len = strlen (info.append);
6348 info.omit_relative = false;
6349 info.separate_options = true;
6350
6351 for_each_path (&include_prefixes, false, info.append_len,
6352 spec_path, &info);
6353
6354 info.append = "include-fixed";
6355 if (*sysroot_hdrs_suffix_spec)
6356 info.append = concat (info.append, dir_separator_str,
6357 multilib_dir, NULL);
6358 info.append_len = strlen (info.append);
6359 for_each_path (&include_prefixes, false, info.append_len,
6360 spec_path, &info);
6361 }
6362 break;
6363
6364 case 'o':
6365 /* We are going to expand `%o' into `@FILE', where FILE
6366 is a newly-created temporary filename. The filenames
6367 that would usually be expanded in place of %o will be
6368 written to the temporary file. */
6369 if (at_file_supplied)
6370 open_at_file ();
6371
6372 for (i = 0; i < n_infiles + lang_specific_extra_outfiles; i++)
6373 if (outfiles[i])
6374 store_arg (outfiles[i], 0, 0);
6375
6376 if (at_file_supplied)
6377 close_at_file ();
6378 break;
6379
6380 case 'O':
6381 obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
6382 arg_going = 1;
6383 break;
6384
6385 case 's':
6386 this_is_library_file = 1;
6387 break;
6388
6389 case 'T':
6390 this_is_linker_script = 1;
6391 break;
6392
6393 case 'V':
6394 outfiles[input_file_number] = NULL;
6395 break;
6396
6397 case 'w':
6398 this_is_output_file = 1;
6399 break;
6400
6401 case 'W':
6402 {
6403 unsigned int cur_index = argbuf.length ();
6404 /* Handle the {...} following the %W. */
6405 if (*p != '{')
6406 fatal_error (input_location,
6407 "spec %qs has invalid %<%%W%c%>", spec, *p);
6408 p = handle_braces (p + 1);
6409 if (p == 0)
6410 return -1;
6411 end_going_arg ();
6412 /* If any args were output, mark the last one for deletion
6413 on failure. */
6414 if (argbuf.length () != cur_index)
6415 record_temp_file (argbuf.last (), 0, 1);
6416 break;
6417 }
6418
6419 case '@':
6420 /* Handle the {...} following the %@. */
6421 if (*p != '{')
6422 fatal_error (input_location,
6423 "spec %qs has invalid %<%%@%c%>", spec, *p);
6424 if (at_file_supplied)
6425 open_at_file ();
6426 p = handle_braces (p + 1);
6427 if (at_file_supplied)
6428 close_at_file ();
6429 if (p == 0)
6430 return -1;
6431 break;
6432
6433 /* %x{OPTION} records OPTION for %X to output. */
6434 case 'x':
6435 {
6436 const char *p1 = p;
6437 char *string;
6438 char *opt;
6439 unsigned ix;
6440
6441 /* Skip past the option value and make a copy. */
6442 if (*p != '{')
6443 fatal_error (input_location,
6444 "spec %qs has invalid %<%%x%c%>", spec, *p);
6445 while (*p++ != '}')
6446 ;
6447 string = save_string (p1 + 1, p - p1 - 2);
6448
6449 /* See if we already recorded this option. */
6450 FOR_EACH_VEC_ELT (linker_options, ix, opt)
6451 if (! strcmp (string, opt))
6452 {
6453 free (string);
6454 return 0;
6455 }
6456
6457 /* This option is new; add it. */
6458 add_linker_option (string, strlen (string));
6459 free (string);
6460 }
6461 break;
6462
6463 /* Dump out the options accumulated previously using %x. */
6464 case 'X':
6465 do_specs_vec (linker_options);
6466 break;
6467
6468 /* Dump out the options accumulated previously using -Wa,. */
6469 case 'Y':
6470 do_specs_vec (assembler_options);
6471 break;
6472
6473 /* Dump out the options accumulated previously using -Wp,. */
6474 case 'Z':
6475 do_specs_vec (preprocessor_options);
6476 break;
6477
6478 /* Here are digits and numbers that just process
6479 a certain constant string as a spec. */
6480
6481 case '1':
6482 value = do_spec_1 (cc1_spec, 0, NULL);
6483 if (value != 0)
6484 return value;
6485 break;
6486
6487 case '2':
6488 value = do_spec_1 (cc1plus_spec, 0, NULL);
6489 if (value != 0)
6490 return value;
6491 break;
6492
6493 case 'a':
6494 value = do_spec_1 (asm_spec, 0, NULL);
6495 if (value != 0)
6496 return value;
6497 break;
6498
6499 case 'A':
6500 value = do_spec_1 (asm_final_spec, 0, NULL);
6501 if (value != 0)
6502 return value;
6503 break;
6504
6505 case 'C':
6506 {
6507 const char *const spec
6508 = (input_file_compiler->cpp_spec
6509 ? input_file_compiler->cpp_spec
6510 : cpp_spec);
6511 value = do_spec_1 (spec, 0, NULL);
6512 if (value != 0)
6513 return value;
6514 }
6515 break;
6516
6517 case 'E':
6518 value = do_spec_1 (endfile_spec, 0, NULL);
6519 if (value != 0)
6520 return value;
6521 break;
6522
6523 case 'l':
6524 value = do_spec_1 (link_spec, 0, NULL);
6525 if (value != 0)
6526 return value;
6527 break;
6528
6529 case 'L':
6530 value = do_spec_1 (lib_spec, 0, NULL);
6531 if (value != 0)
6532 return value;
6533 break;
6534
6535 case 'M':
6536 if (multilib_os_dir == NULL)
6537 obstack_1grow (&obstack, '.');
6538 else
6539 obstack_grow (&obstack, multilib_os_dir,
6540 strlen (multilib_os_dir));
6541 break;
6542
6543 case 'G':
6544 value = do_spec_1 (libgcc_spec, 0, NULL);
6545 if (value != 0)
6546 return value;
6547 break;
6548
6549 case 'R':
6550 /* We assume there is a directory
6551 separator at the end of this string. */
6552 if (target_system_root)
6553 {
6554 obstack_grow (&obstack, target_system_root,
6555 strlen (target_system_root));
6556 if (target_sysroot_suffix)
6557 obstack_grow (&obstack, target_sysroot_suffix,
6558 strlen (target_sysroot_suffix));
6559 }
6560 break;
6561
6562 case 'S':
6563 value = do_spec_1 (startfile_spec, 0, NULL);
6564 if (value != 0)
6565 return value;
6566 break;
6567
6568 /* Here we define characters other than letters and digits. */
6569
6570 case '{':
6571 p = handle_braces (p);
6572 if (p == 0)
6573 return -1;
6574 break;
6575
6576 case ':':
6577 p = handle_spec_function (p, NULL, soft_matched_part);
6578 if (p == 0)
6579 return -1;
6580 break;
6581
6582 case '%':
6583 obstack_1grow (&obstack, '%');
6584 break;
6585
6586 case '.':
6587 {
6588 unsigned len = 0;
6589
6590 while (p[len] && p[len] != ' ' && p[len] != '%')
6591 len++;
6592 suffix_subst = save_string (p - 1, len + 1);
6593 p += len;
6594 }
6595 break;
6596
6597 /* Henceforth ignore the option(s) matching the pattern
6598 after the %<. */
6599 case '<':
6600 case '>':
6601 {
6602 unsigned len = 0;
6603 int have_wildcard = 0;
6604 int i;
6605 int switch_option;
6606
6607 if (c == '>')
6608 switch_option = SWITCH_IGNORE | SWITCH_KEEP_FOR_GCC;
6609 else
6610 switch_option = SWITCH_IGNORE;
6611
6612 while (p[len] && p[len] != ' ' && p[len] != '\t')
6613 len++;
6614
6615 if (p[len-1] == '*')
6616 have_wildcard = 1;
6617
6618 for (i = 0; i < n_switches; i++)
6619 if (!strncmp (switches[i].part1, p, len - have_wildcard)
6620 && (have_wildcard || switches[i].part1[len] == '\0'))
6621 {
6622 switches[i].live_cond |= switch_option;
6623 /* User switch be validated from validate_all_switches.
6624 when the definition is seen from the spec file.
6625 If not defined anywhere, will be rejected. */
6626 if (switches[i].known)
6627 switches[i].validated = true;
6628 }
6629
6630 p += len;
6631 }
6632 break;
6633
6634 case '*':
6635 if (soft_matched_part)
6636 {
6637 if (soft_matched_part[0])
6638 do_spec_1 (soft_matched_part, 1, NULL);
6639 /* Only insert a space after the substitution if it is at the
6640 end of the current sequence. So if:
6641
6642 "%{foo=*:bar%*}%{foo=*:one%*two}"
6643
6644 matches -foo=hello then it will produce:
6645
6646 barhello onehellotwo
6647 */
6648 if (*p == 0 || *p == '}')
6649 do_spec_1 (" ", 0, NULL);
6650 }
6651 else
6652 /* Catch the case where a spec string contains something like
6653 '%{foo:%*}'. i.e. there is no * in the pattern on the left
6654 hand side of the :. */
6655 error ("spec failure: %<%%*%> has not been initialized by pattern match");
6656 break;
6657
6658 /* Process a string found as the value of a spec given by name.
6659 This feature allows individual machine descriptions
6660 to add and use their own specs. */
6661 case '(':
6662 {
6663 const char *name = p;
6664 struct spec_list *sl;
6665 int len;
6666
6667 /* The string after the S/P is the name of a spec that is to be
6668 processed. */
6669 while (*p && *p != ')')
6670 p++;
6671
6672 /* See if it's in the list. */
6673 for (len = p - name, sl = specs; sl; sl = sl->next)
6674 if (sl->name_len == len && !strncmp (sl->name, name, len))
6675 {
6676 name = *(sl->ptr_spec);
6677 #ifdef DEBUG_SPECS
6678 fnotice (stderr, "Processing spec (%s), which is '%s'\n",
6679 sl->name, name);
6680 #endif
6681 break;
6682 }
6683
6684 if (sl)
6685 {
6686 value = do_spec_1 (name, 0, NULL);
6687 if (value != 0)
6688 return value;
6689 }
6690
6691 /* Discard the closing paren. */
6692 if (*p)
6693 p++;
6694 }
6695 break;
6696
6697 case '"':
6698 /* End a previous argument, if there is one, then issue an
6699 empty argument. */
6700 end_going_arg ();
6701 arg_going = 1;
6702 end_going_arg ();
6703 break;
6704
6705 default:
6706 error ("spec failure: unrecognized spec option %qc", c);
6707 break;
6708 }
6709 break;
6710
6711 case '\\':
6712 /* Backslash: treat next character as ordinary. */
6713 c = *p++;
6714
6715 /* When adding more cases that previously matched default, make
6716 sure to adjust quote_spec_char_p as well. */
6717
6718 /* Fall through. */
6719 default:
6720 /* Ordinary character: put it into the current argument. */
6721 obstack_1grow (&obstack, c);
6722 arg_going = 1;
6723 }
6724
6725 /* End of string. If we are processing a spec function, we need to
6726 end any pending argument. */
6727 if (processing_spec_function)
6728 end_going_arg ();
6729
6730 return 0;
6731 }
6732
6733 /* Look up a spec function. */
6734
6735 static const struct spec_function *
lookup_spec_function(const char * name)6736 lookup_spec_function (const char *name)
6737 {
6738 const struct spec_function *sf;
6739
6740 for (sf = static_spec_functions; sf->name != NULL; sf++)
6741 if (strcmp (sf->name, name) == 0)
6742 return sf;
6743
6744 return NULL;
6745 }
6746
6747 /* Evaluate a spec function. */
6748
6749 static const char *
eval_spec_function(const char * func,const char * args,const char * soft_matched_part)6750 eval_spec_function (const char *func, const char *args,
6751 const char *soft_matched_part)
6752 {
6753 const struct spec_function *sf;
6754 const char *funcval;
6755
6756 /* Saved spec processing context. */
6757 vec<const_char_p> save_argbuf;
6758
6759 int save_arg_going;
6760 int save_delete_this_arg;
6761 int save_this_is_output_file;
6762 int save_this_is_library_file;
6763 int save_input_from_pipe;
6764 int save_this_is_linker_script;
6765 const char *save_suffix_subst;
6766
6767 int save_growing_size;
6768 void *save_growing_value = NULL;
6769
6770 sf = lookup_spec_function (func);
6771 if (sf == NULL)
6772 fatal_error (input_location, "unknown spec function %qs", func);
6773
6774 /* Push the spec processing context. */
6775 save_argbuf = argbuf;
6776
6777 save_arg_going = arg_going;
6778 save_delete_this_arg = delete_this_arg;
6779 save_this_is_output_file = this_is_output_file;
6780 save_this_is_library_file = this_is_library_file;
6781 save_this_is_linker_script = this_is_linker_script;
6782 save_input_from_pipe = input_from_pipe;
6783 save_suffix_subst = suffix_subst;
6784
6785 /* If we have some object growing now, finalize it so the args and function
6786 eval proceed from a cleared context. This is needed to prevent the first
6787 constructed arg from mistakenly including the growing value. We'll push
6788 this value back on the obstack once the function evaluation is done, to
6789 restore a consistent processing context for our caller. This is fine as
6790 the address of growing objects isn't guaranteed to remain stable until
6791 they are finalized, and we expect this situation to be rare enough for
6792 the extra copy not to be an issue. */
6793 save_growing_size = obstack_object_size (&obstack);
6794 if (save_growing_size > 0)
6795 save_growing_value = obstack_finish (&obstack);
6796
6797 /* Create a new spec processing context, and build the function
6798 arguments. */
6799
6800 alloc_args ();
6801 if (do_spec_2 (args, soft_matched_part) < 0)
6802 fatal_error (input_location, "error in arguments to spec function %qs",
6803 func);
6804
6805 /* argbuf_index is an index for the next argument to be inserted, and
6806 so contains the count of the args already inserted. */
6807
6808 funcval = (*sf->func) (argbuf.length (),
6809 argbuf.address ());
6810
6811 /* Pop the spec processing context. */
6812 argbuf.release ();
6813 argbuf = save_argbuf;
6814
6815 arg_going = save_arg_going;
6816 delete_this_arg = save_delete_this_arg;
6817 this_is_output_file = save_this_is_output_file;
6818 this_is_library_file = save_this_is_library_file;
6819 this_is_linker_script = save_this_is_linker_script;
6820 input_from_pipe = save_input_from_pipe;
6821 suffix_subst = save_suffix_subst;
6822
6823 if (save_growing_size > 0)
6824 obstack_grow (&obstack, save_growing_value, save_growing_size);
6825
6826 return funcval;
6827 }
6828
6829 /* Handle a spec function call of the form:
6830
6831 %:function(args)
6832
6833 ARGS is processed as a spec in a separate context and split into an
6834 argument vector in the normal fashion. The function returns a string
6835 containing a spec which we then process in the caller's context, or
6836 NULL if no processing is required.
6837
6838 If RETVAL_NONNULL is not NULL, then store a bool whether function
6839 returned non-NULL.
6840
6841 SOFT_MATCHED_PART holds the current value of a matched * pattern, which
6842 may be re-expanded with a %* as part of the function arguments. */
6843
6844 static const char *
handle_spec_function(const char * p,bool * retval_nonnull,const char * soft_matched_part)6845 handle_spec_function (const char *p, bool *retval_nonnull,
6846 const char *soft_matched_part)
6847 {
6848 char *func, *args;
6849 const char *endp, *funcval;
6850 int count;
6851
6852 processing_spec_function++;
6853
6854 /* Get the function name. */
6855 for (endp = p; *endp != '\0'; endp++)
6856 {
6857 if (*endp == '(') /* ) */
6858 break;
6859 /* Only allow [A-Za-z0-9], -, and _ in function names. */
6860 if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_'))
6861 fatal_error (input_location, "malformed spec function name");
6862 }
6863 if (*endp != '(') /* ) */
6864 fatal_error (input_location, "no arguments for spec function");
6865 func = save_string (p, endp - p);
6866 p = ++endp;
6867
6868 /* Get the arguments. */
6869 for (count = 0; *endp != '\0'; endp++)
6870 {
6871 /* ( */
6872 if (*endp == ')')
6873 {
6874 if (count == 0)
6875 break;
6876 count--;
6877 }
6878 else if (*endp == '(') /* ) */
6879 count++;
6880 }
6881 /* ( */
6882 if (*endp != ')')
6883 fatal_error (input_location, "malformed spec function arguments");
6884 args = save_string (p, endp - p);
6885 p = ++endp;
6886
6887 /* p now points to just past the end of the spec function expression. */
6888
6889 funcval = eval_spec_function (func, args, soft_matched_part);
6890 if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0)
6891 p = NULL;
6892 if (retval_nonnull)
6893 *retval_nonnull = funcval != NULL;
6894
6895 free (func);
6896 free (args);
6897
6898 processing_spec_function--;
6899
6900 return p;
6901 }
6902
6903 /* Inline subroutine of handle_braces. Returns true if the current
6904 input suffix matches the atom bracketed by ATOM and END_ATOM. */
6905 static inline bool
input_suffix_matches(const char * atom,const char * end_atom)6906 input_suffix_matches (const char *atom, const char *end_atom)
6907 {
6908 return (input_suffix
6909 && !strncmp (input_suffix, atom, end_atom - atom)
6910 && input_suffix[end_atom - atom] == '\0');
6911 }
6912
6913 /* Subroutine of handle_braces. Returns true if the current
6914 input file's spec name matches the atom bracketed by ATOM and END_ATOM. */
6915 static bool
input_spec_matches(const char * atom,const char * end_atom)6916 input_spec_matches (const char *atom, const char *end_atom)
6917 {
6918 return (input_file_compiler
6919 && input_file_compiler->suffix
6920 && input_file_compiler->suffix[0] != '\0'
6921 && !strncmp (input_file_compiler->suffix + 1, atom,
6922 end_atom - atom)
6923 && input_file_compiler->suffix[end_atom - atom + 1] == '\0');
6924 }
6925
6926 /* Subroutine of handle_braces. Returns true if a switch
6927 matching the atom bracketed by ATOM and END_ATOM appeared on the
6928 command line. */
6929 static bool
switch_matches(const char * atom,const char * end_atom,int starred)6930 switch_matches (const char *atom, const char *end_atom, int starred)
6931 {
6932 int i;
6933 int len = end_atom - atom;
6934 int plen = starred ? len : -1;
6935
6936 for (i = 0; i < n_switches; i++)
6937 if (!strncmp (switches[i].part1, atom, len)
6938 && (starred || switches[i].part1[len] == '\0')
6939 && check_live_switch (i, plen))
6940 return true;
6941
6942 /* Check if a switch with separated form matching the atom.
6943 We check -D and -U switches. */
6944 else if (switches[i].args != 0)
6945 {
6946 if ((*switches[i].part1 == 'D' || *switches[i].part1 == 'U')
6947 && *switches[i].part1 == atom[0])
6948 {
6949 if (!strncmp (switches[i].args[0], &atom[1], len - 1)
6950 && (starred || (switches[i].part1[1] == '\0'
6951 && switches[i].args[0][len - 1] == '\0'))
6952 && check_live_switch (i, (starred ? 1 : -1)))
6953 return true;
6954 }
6955 }
6956
6957 return false;
6958 }
6959
6960 /* Inline subroutine of handle_braces. Mark all of the switches which
6961 match ATOM (extends to END_ATOM; STARRED indicates whether there
6962 was a star after the atom) for later processing. */
6963 static inline void
mark_matching_switches(const char * atom,const char * end_atom,int starred)6964 mark_matching_switches (const char *atom, const char *end_atom, int starred)
6965 {
6966 int i;
6967 int len = end_atom - atom;
6968 int plen = starred ? len : -1;
6969
6970 for (i = 0; i < n_switches; i++)
6971 if (!strncmp (switches[i].part1, atom, len)
6972 && (starred || switches[i].part1[len] == '\0')
6973 && check_live_switch (i, plen))
6974 switches[i].ordering = 1;
6975 }
6976
6977 /* Inline subroutine of handle_braces. Process all the currently
6978 marked switches through give_switch, and clear the marks. */
6979 static inline void
process_marked_switches(void)6980 process_marked_switches (void)
6981 {
6982 int i;
6983
6984 for (i = 0; i < n_switches; i++)
6985 if (switches[i].ordering == 1)
6986 {
6987 switches[i].ordering = 0;
6988 give_switch (i, 0);
6989 }
6990 }
6991
6992 /* Handle a %{ ... } construct. P points just inside the leading {.
6993 Returns a pointer one past the end of the brace block, or 0
6994 if we call do_spec_1 and that returns -1. */
6995
6996 static const char *
handle_braces(const char * p)6997 handle_braces (const char *p)
6998 {
6999 const char *atom, *end_atom;
7000 const char *d_atom = NULL, *d_end_atom = NULL;
7001 char *esc_buf = NULL, *d_esc_buf = NULL;
7002 int esc;
7003 const char *orig = p;
7004
7005 bool a_is_suffix;
7006 bool a_is_spectype;
7007 bool a_is_starred;
7008 bool a_is_negated;
7009 bool a_matched;
7010
7011 bool a_must_be_last = false;
7012 bool ordered_set = false;
7013 bool disjunct_set = false;
7014 bool disj_matched = false;
7015 bool disj_starred = true;
7016 bool n_way_choice = false;
7017 bool n_way_matched = false;
7018
7019 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7020
7021 do
7022 {
7023 if (a_must_be_last)
7024 goto invalid;
7025
7026 /* Scan one "atom" (S in the description above of %{}, possibly
7027 with '!', '.', '@', ',', or '*' modifiers). */
7028 a_matched = false;
7029 a_is_suffix = false;
7030 a_is_starred = false;
7031 a_is_negated = false;
7032 a_is_spectype = false;
7033
7034 SKIP_WHITE ();
7035 if (*p == '!')
7036 p++, a_is_negated = true;
7037
7038 SKIP_WHITE ();
7039 if (*p == '%' && p[1] == ':')
7040 {
7041 atom = NULL;
7042 end_atom = NULL;
7043 p = handle_spec_function (p + 2, &a_matched, NULL);
7044 }
7045 else
7046 {
7047 if (*p == '.')
7048 p++, a_is_suffix = true;
7049 else if (*p == ',')
7050 p++, a_is_spectype = true;
7051
7052 atom = p;
7053 esc = 0;
7054 while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
7055 || *p == ',' || *p == '.' || *p == '@' || *p == '\\')
7056 {
7057 if (*p == '\\')
7058 {
7059 p++;
7060 if (!*p)
7061 fatal_error (input_location,
7062 "braced spec %qs ends in escape", orig);
7063 esc++;
7064 }
7065 p++;
7066 }
7067 end_atom = p;
7068
7069 if (esc)
7070 {
7071 const char *ap;
7072 char *ep;
7073
7074 if (esc_buf && esc_buf != d_esc_buf)
7075 free (esc_buf);
7076 esc_buf = NULL;
7077 ep = esc_buf = (char *) xmalloc (end_atom - atom - esc + 1);
7078 for (ap = atom; ap != end_atom; ap++, ep++)
7079 {
7080 if (*ap == '\\')
7081 ap++;
7082 *ep = *ap;
7083 }
7084 *ep = '\0';
7085 atom = esc_buf;
7086 end_atom = ep;
7087 }
7088
7089 if (*p == '*')
7090 p++, a_is_starred = 1;
7091 }
7092
7093 SKIP_WHITE ();
7094 switch (*p)
7095 {
7096 case '&': case '}':
7097 /* Substitute the switch(es) indicated by the current atom. */
7098 ordered_set = true;
7099 if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix
7100 || a_is_spectype || atom == end_atom)
7101 goto invalid;
7102
7103 mark_matching_switches (atom, end_atom, a_is_starred);
7104
7105 if (*p == '}')
7106 process_marked_switches ();
7107 break;
7108
7109 case '|': case ':':
7110 /* Substitute some text if the current atom appears as a switch
7111 or suffix. */
7112 disjunct_set = true;
7113 if (ordered_set)
7114 goto invalid;
7115
7116 if (atom && atom == end_atom)
7117 {
7118 if (!n_way_choice || disj_matched || *p == '|'
7119 || a_is_negated || a_is_suffix || a_is_spectype
7120 || a_is_starred)
7121 goto invalid;
7122
7123 /* An empty term may appear as the last choice of an
7124 N-way choice set; it means "otherwise". */
7125 a_must_be_last = true;
7126 disj_matched = !n_way_matched;
7127 disj_starred = false;
7128 }
7129 else
7130 {
7131 if ((a_is_suffix || a_is_spectype) && a_is_starred)
7132 goto invalid;
7133
7134 if (!a_is_starred)
7135 disj_starred = false;
7136
7137 /* Don't bother testing this atom if we already have a
7138 match. */
7139 if (!disj_matched && !n_way_matched)
7140 {
7141 if (atom == NULL)
7142 /* a_matched is already set by handle_spec_function. */;
7143 else if (a_is_suffix)
7144 a_matched = input_suffix_matches (atom, end_atom);
7145 else if (a_is_spectype)
7146 a_matched = input_spec_matches (atom, end_atom);
7147 else
7148 a_matched = switch_matches (atom, end_atom, a_is_starred);
7149
7150 if (a_matched != a_is_negated)
7151 {
7152 disj_matched = true;
7153 d_atom = atom;
7154 d_end_atom = end_atom;
7155 d_esc_buf = esc_buf;
7156 }
7157 }
7158 }
7159
7160 if (*p == ':')
7161 {
7162 /* Found the body, that is, the text to substitute if the
7163 current disjunction matches. */
7164 p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred,
7165 disj_matched && !n_way_matched);
7166 if (p == 0)
7167 goto done;
7168
7169 /* If we have an N-way choice, reset state for the next
7170 disjunction. */
7171 if (*p == ';')
7172 {
7173 n_way_choice = true;
7174 n_way_matched |= disj_matched;
7175 disj_matched = false;
7176 disj_starred = true;
7177 d_atom = d_end_atom = NULL;
7178 }
7179 }
7180 break;
7181
7182 default:
7183 goto invalid;
7184 }
7185 }
7186 while (*p++ != '}');
7187
7188 done:
7189 if (d_esc_buf && d_esc_buf != esc_buf)
7190 free (d_esc_buf);
7191 if (esc_buf)
7192 free (esc_buf);
7193
7194 return p;
7195
7196 invalid:
7197 fatal_error (input_location, "braced spec %qs is invalid at %qc", orig, *p);
7198
7199 #undef SKIP_WHITE
7200 }
7201
7202 /* Subroutine of handle_braces. Scan and process a brace substitution body
7203 (X in the description of %{} syntax). P points one past the colon;
7204 ATOM and END_ATOM bracket the first atom which was found to be true
7205 (present) in the current disjunction; STARRED indicates whether all
7206 the atoms in the current disjunction were starred (for syntax validation);
7207 MATCHED indicates whether the disjunction matched or not, and therefore
7208 whether or not the body is to be processed through do_spec_1 or just
7209 skipped. Returns a pointer to the closing } or ;, or 0 if do_spec_1
7210 returns -1. */
7211
7212 static const char *
process_brace_body(const char * p,const char * atom,const char * end_atom,int starred,int matched)7213 process_brace_body (const char *p, const char *atom, const char *end_atom,
7214 int starred, int matched)
7215 {
7216 const char *body, *end_body;
7217 unsigned int nesting_level;
7218 bool have_subst = false;
7219
7220 /* Locate the closing } or ;, honoring nested braces.
7221 Trim trailing whitespace. */
7222 body = p;
7223 nesting_level = 1;
7224 for (;;)
7225 {
7226 if (*p == '{')
7227 nesting_level++;
7228 else if (*p == '}')
7229 {
7230 if (!--nesting_level)
7231 break;
7232 }
7233 else if (*p == ';' && nesting_level == 1)
7234 break;
7235 else if (*p == '%' && p[1] == '*' && nesting_level == 1)
7236 have_subst = true;
7237 else if (*p == '\0')
7238 goto invalid;
7239 p++;
7240 }
7241
7242 end_body = p;
7243 while (end_body[-1] == ' ' || end_body[-1] == '\t')
7244 end_body--;
7245
7246 if (have_subst && !starred)
7247 goto invalid;
7248
7249 if (matched)
7250 {
7251 /* Copy the substitution body to permanent storage and execute it.
7252 If have_subst is false, this is a simple matter of running the
7253 body through do_spec_1... */
7254 char *string = save_string (body, end_body - body);
7255 if (!have_subst)
7256 {
7257 if (do_spec_1 (string, 0, NULL) < 0)
7258 {
7259 free (string);
7260 return 0;
7261 }
7262 }
7263 else
7264 {
7265 /* ... but if have_subst is true, we have to process the
7266 body once for each matching switch, with %* set to the
7267 variant part of the switch. */
7268 unsigned int hard_match_len = end_atom - atom;
7269 int i;
7270
7271 for (i = 0; i < n_switches; i++)
7272 if (!strncmp (switches[i].part1, atom, hard_match_len)
7273 && check_live_switch (i, hard_match_len))
7274 {
7275 if (do_spec_1 (string, 0,
7276 &switches[i].part1[hard_match_len]) < 0)
7277 {
7278 free (string);
7279 return 0;
7280 }
7281 /* Pass any arguments this switch has. */
7282 give_switch (i, 1);
7283 suffix_subst = NULL;
7284 }
7285 }
7286 free (string);
7287 }
7288
7289 return p;
7290
7291 invalid:
7292 fatal_error (input_location, "braced spec body %qs is invalid", body);
7293 }
7294
7295 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
7296 on the command line. PREFIX_LENGTH is the length of XXX in an {XXX*}
7297 spec, or -1 if either exact match or %* is used.
7298
7299 A -O switch is obsoleted by a later -O switch. A -f, -g, -m, or -W switch
7300 whose value does not begin with "no-" is obsoleted by the same value
7301 with the "no-", similarly for a switch with the "no-" prefix. */
7302
7303 static int
check_live_switch(int switchnum,int prefix_length)7304 check_live_switch (int switchnum, int prefix_length)
7305 {
7306 const char *name = switches[switchnum].part1;
7307 int i;
7308
7309 /* If we already processed this switch and determined if it was
7310 live or not, return our past determination. */
7311 if (switches[switchnum].live_cond != 0)
7312 return ((switches[switchnum].live_cond & SWITCH_LIVE) != 0
7313 && (switches[switchnum].live_cond & SWITCH_FALSE) == 0
7314 && (switches[switchnum].live_cond & SWITCH_IGNORE_PERMANENTLY)
7315 == 0);
7316
7317 /* In the common case of {<at-most-one-letter>*}, a negating
7318 switch would always match, so ignore that case. We will just
7319 send the conflicting switches to the compiler phase. */
7320 if (prefix_length >= 0 && prefix_length <= 1)
7321 return 1;
7322
7323 /* Now search for duplicate in a manner that depends on the name. */
7324 switch (*name)
7325 {
7326 case 'O':
7327 for (i = switchnum + 1; i < n_switches; i++)
7328 if (switches[i].part1[0] == 'O')
7329 {
7330 switches[switchnum].validated = true;
7331 switches[switchnum].live_cond = SWITCH_FALSE;
7332 return 0;
7333 }
7334 break;
7335
7336 case 'W': case 'f': case 'm': case 'g':
7337 if (! strncmp (name + 1, "no-", 3))
7338 {
7339 /* We have Xno-YYY, search for XYYY. */
7340 for (i = switchnum + 1; i < n_switches; i++)
7341 if (switches[i].part1[0] == name[0]
7342 && ! strcmp (&switches[i].part1[1], &name[4]))
7343 {
7344 /* --specs are validated with the validate_switches mechanism. */
7345 if (switches[switchnum].known)
7346 switches[switchnum].validated = true;
7347 switches[switchnum].live_cond = SWITCH_FALSE;
7348 return 0;
7349 }
7350 }
7351 else
7352 {
7353 /* We have XYYY, search for Xno-YYY. */
7354 for (i = switchnum + 1; i < n_switches; i++)
7355 if (switches[i].part1[0] == name[0]
7356 && switches[i].part1[1] == 'n'
7357 && switches[i].part1[2] == 'o'
7358 && switches[i].part1[3] == '-'
7359 && !strcmp (&switches[i].part1[4], &name[1]))
7360 {
7361 /* --specs are validated with the validate_switches mechanism. */
7362 if (switches[switchnum].known)
7363 switches[switchnum].validated = true;
7364 switches[switchnum].live_cond = SWITCH_FALSE;
7365 return 0;
7366 }
7367 }
7368 break;
7369 }
7370
7371 /* Otherwise the switch is live. */
7372 switches[switchnum].live_cond |= SWITCH_LIVE;
7373 return 1;
7374 }
7375
7376 /* Pass a switch to the current accumulating command
7377 in the same form that we received it.
7378 SWITCHNUM identifies the switch; it is an index into
7379 the vector of switches gcc received, which is `switches'.
7380 This cannot fail since it never finishes a command line.
7381
7382 If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
7383
7384 static void
give_switch(int switchnum,int omit_first_word)7385 give_switch (int switchnum, int omit_first_word)
7386 {
7387 if ((switches[switchnum].live_cond & SWITCH_IGNORE) != 0)
7388 return;
7389
7390 if (!omit_first_word)
7391 {
7392 do_spec_1 ("-", 0, NULL);
7393 do_spec_1 (switches[switchnum].part1, 1, NULL);
7394 }
7395
7396 if (switches[switchnum].args != 0)
7397 {
7398 const char **p;
7399 for (p = switches[switchnum].args; *p; p++)
7400 {
7401 const char *arg = *p;
7402
7403 do_spec_1 (" ", 0, NULL);
7404 if (suffix_subst)
7405 {
7406 unsigned length = strlen (arg);
7407 int dot = 0;
7408
7409 while (length-- && !IS_DIR_SEPARATOR (arg[length]))
7410 if (arg[length] == '.')
7411 {
7412 (CONST_CAST (char *, arg))[length] = 0;
7413 dot = 1;
7414 break;
7415 }
7416 do_spec_1 (arg, 1, NULL);
7417 if (dot)
7418 (CONST_CAST (char *, arg))[length] = '.';
7419 do_spec_1 (suffix_subst, 1, NULL);
7420 }
7421 else
7422 do_spec_1 (arg, 1, NULL);
7423 }
7424 }
7425
7426 do_spec_1 (" ", 0, NULL);
7427 switches[switchnum].validated = true;
7428 }
7429
7430 /* Print GCC configuration (e.g. version, thread model, target,
7431 configuration_arguments) to a given FILE. */
7432
7433 static void
print_configuration(FILE * file)7434 print_configuration (FILE *file)
7435 {
7436 int n;
7437 const char *thrmod;
7438
7439 fnotice (file, "Target: %s\n", spec_machine);
7440 fnotice (file, "Configured with: %s\n", configuration_arguments);
7441
7442 #ifdef THREAD_MODEL_SPEC
7443 /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
7444 but there's no point in doing all this processing just to get
7445 thread_model back. */
7446 obstack_init (&obstack);
7447 do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model);
7448 obstack_1grow (&obstack, '\0');
7449 thrmod = XOBFINISH (&obstack, const char *);
7450 #else
7451 thrmod = thread_model;
7452 #endif
7453
7454 fnotice (file, "Thread model: %s\n", thrmod);
7455 fnotice (file, "Supported LTO compression algorithms: zlib");
7456 #ifdef HAVE_ZSTD_H
7457 fnotice (file, " zstd");
7458 #endif
7459 fnotice (file, "\n");
7460
7461 /* compiler_version is truncated at the first space when initialized
7462 from version string, so truncate version_string at the first space
7463 before comparing. */
7464 for (n = 0; version_string[n]; n++)
7465 if (version_string[n] == ' ')
7466 break;
7467
7468 if (! strncmp (version_string, compiler_version, n)
7469 && compiler_version[n] == 0)
7470 fnotice (file, "gcc version %s %s\n", version_string,
7471 pkgversion_string);
7472 else
7473 fnotice (file, "gcc driver version %s %sexecuting gcc version %s\n",
7474 version_string, pkgversion_string, compiler_version);
7475
7476 }
7477
7478 #define RETRY_ICE_ATTEMPTS 3
7479
7480 /* Returns true if FILE1 and FILE2 contain equivalent data, 0 otherwise. */
7481
7482 static bool
files_equal_p(char * file1,char * file2)7483 files_equal_p (char *file1, char *file2)
7484 {
7485 struct stat st1, st2;
7486 off_t n, len;
7487 int fd1, fd2;
7488 const int bufsize = 8192;
7489 char *buf = XNEWVEC (char, bufsize);
7490
7491 fd1 = open (file1, O_RDONLY);
7492 fd2 = open (file2, O_RDONLY);
7493
7494 if (fd1 < 0 || fd2 < 0)
7495 goto error;
7496
7497 if (fstat (fd1, &st1) < 0 || fstat (fd2, &st2) < 0)
7498 goto error;
7499
7500 if (st1.st_size != st2.st_size)
7501 goto error;
7502
7503 for (n = st1.st_size; n; n -= len)
7504 {
7505 len = n;
7506 if ((int) len > bufsize / 2)
7507 len = bufsize / 2;
7508
7509 if (read (fd1, buf, len) != (int) len
7510 || read (fd2, buf + bufsize / 2, len) != (int) len)
7511 {
7512 goto error;
7513 }
7514
7515 if (memcmp (buf, buf + bufsize / 2, len) != 0)
7516 goto error;
7517 }
7518
7519 free (buf);
7520 close (fd1);
7521 close (fd2);
7522
7523 return 1;
7524
7525 error:
7526 free (buf);
7527 close (fd1);
7528 close (fd2);
7529 return 0;
7530 }
7531
7532 /* Check that compiler's output doesn't differ across runs.
7533 TEMP_STDOUT_FILES and TEMP_STDERR_FILES are arrays of files, containing
7534 stdout and stderr for each compiler run. Return true if all of
7535 TEMP_STDOUT_FILES and TEMP_STDERR_FILES are equivalent. */
7536
7537 static bool
check_repro(char ** temp_stdout_files,char ** temp_stderr_files)7538 check_repro (char **temp_stdout_files, char **temp_stderr_files)
7539 {
7540 int i;
7541 for (i = 0; i < RETRY_ICE_ATTEMPTS - 2; ++i)
7542 {
7543 if (!files_equal_p (temp_stdout_files[i], temp_stdout_files[i + 1])
7544 || !files_equal_p (temp_stderr_files[i], temp_stderr_files[i + 1]))
7545 {
7546 fnotice (stderr, "The bug is not reproducible, so it is"
7547 " likely a hardware or OS problem.\n");
7548 break;
7549 }
7550 }
7551 return i == RETRY_ICE_ATTEMPTS - 2;
7552 }
7553
7554 enum attempt_status {
7555 ATTEMPT_STATUS_FAIL_TO_RUN,
7556 ATTEMPT_STATUS_SUCCESS,
7557 ATTEMPT_STATUS_ICE
7558 };
7559
7560
7561 /* Run compiler with arguments NEW_ARGV to reproduce the ICE, storing stdout
7562 to OUT_TEMP and stderr to ERR_TEMP. If APPEND is TRUE, append to OUT_TEMP
7563 and ERR_TEMP instead of truncating. If EMIT_SYSTEM_INFO is TRUE, also write
7564 GCC configuration into to ERR_TEMP. Return ATTEMPT_STATUS_FAIL_TO_RUN if
7565 compiler failed to run, ATTEMPT_STATUS_ICE if compiled ICE-ed and
7566 ATTEMPT_STATUS_SUCCESS otherwise. */
7567
7568 static enum attempt_status
run_attempt(const char ** new_argv,const char * out_temp,const char * err_temp,int emit_system_info,int append)7569 run_attempt (const char **new_argv, const char *out_temp,
7570 const char *err_temp, int emit_system_info, int append)
7571 {
7572
7573 if (emit_system_info)
7574 {
7575 FILE *file_out = fopen (err_temp, "a");
7576 print_configuration (file_out);
7577 fputs ("\n", file_out);
7578 fclose (file_out);
7579 }
7580
7581 int exit_status;
7582 const char *errmsg;
7583 struct pex_obj *pex;
7584 int err;
7585 int pex_flags = PEX_USE_PIPES | PEX_LAST;
7586 enum attempt_status status = ATTEMPT_STATUS_FAIL_TO_RUN;
7587
7588 if (append)
7589 pex_flags |= PEX_STDOUT_APPEND | PEX_STDERR_APPEND;
7590
7591 pex = pex_init (PEX_USE_PIPES, new_argv[0], NULL);
7592 if (!pex)
7593 fatal_error (input_location, "%<pex_init%> failed: %m");
7594
7595 errmsg = pex_run (pex, pex_flags, new_argv[0],
7596 CONST_CAST2 (char *const *, const char **, &new_argv[1]),
7597 out_temp, err_temp, &err);
7598 if (errmsg != NULL)
7599 {
7600 errno = err;
7601 fatal_error (input_location,
7602 err ? G_ ("cannot execute %qs: %s: %m")
7603 : G_ ("cannot execute %qs: %s"),
7604 new_argv[0], errmsg);
7605 }
7606
7607 if (!pex_get_status (pex, 1, &exit_status))
7608 goto out;
7609
7610 switch (WEXITSTATUS (exit_status))
7611 {
7612 case ICE_EXIT_CODE:
7613 status = ATTEMPT_STATUS_ICE;
7614 break;
7615
7616 case SUCCESS_EXIT_CODE:
7617 status = ATTEMPT_STATUS_SUCCESS;
7618 break;
7619
7620 default:
7621 ;
7622 }
7623
7624 out:
7625 pex_free (pex);
7626 return status;
7627 }
7628
7629 /* This routine reads lines from IN file, adds C++ style comments
7630 at the begining of each line and writes result into OUT. */
7631
7632 static void
insert_comments(const char * file_in,const char * file_out)7633 insert_comments (const char *file_in, const char *file_out)
7634 {
7635 FILE *in = fopen (file_in, "rb");
7636 FILE *out = fopen (file_out, "wb");
7637 char line[256];
7638
7639 bool add_comment = true;
7640 while (fgets (line, sizeof (line), in))
7641 {
7642 if (add_comment)
7643 fputs ("// ", out);
7644 fputs (line, out);
7645 add_comment = strchr (line, '\n') != NULL;
7646 }
7647
7648 fclose (in);
7649 fclose (out);
7650 }
7651
7652 /* This routine adds preprocessed source code into the given ERR_FILE.
7653 To do this, it adds "-E" to NEW_ARGV and execute RUN_ATTEMPT routine to
7654 add information in report file. RUN_ATTEMPT should return
7655 ATTEMPT_STATUS_SUCCESS, in other case we cannot generate the report. */
7656
7657 static void
do_report_bug(const char ** new_argv,const int nargs,char ** out_file,char ** err_file)7658 do_report_bug (const char **new_argv, const int nargs,
7659 char **out_file, char **err_file)
7660 {
7661 int i, status;
7662 int fd = open (*out_file, O_RDWR | O_APPEND);
7663 if (fd < 0)
7664 return;
7665 write (fd, "\n//", 3);
7666 for (i = 0; i < nargs; i++)
7667 {
7668 write (fd, " ", 1);
7669 write (fd, new_argv[i], strlen (new_argv[i]));
7670 }
7671 write (fd, "\n\n", 2);
7672 close (fd);
7673 new_argv[nargs] = "-E";
7674 new_argv[nargs + 1] = NULL;
7675
7676 status = run_attempt (new_argv, *out_file, *err_file, 0, 1);
7677
7678 if (status == ATTEMPT_STATUS_SUCCESS)
7679 {
7680 fnotice (stderr, "Preprocessed source stored into %s file,"
7681 " please attach this to your bugreport.\n", *out_file);
7682 /* Make sure it is not deleted. */
7683 free (*out_file);
7684 *out_file = NULL;
7685 }
7686 }
7687
7688 /* Try to reproduce ICE. If bug is reproducible, generate report .err file
7689 containing GCC configuration, backtrace, compiler's command line options
7690 and preprocessed source code. */
7691
7692 static void
try_generate_repro(const char ** argv)7693 try_generate_repro (const char **argv)
7694 {
7695 int i, nargs, out_arg = -1, quiet = 0, attempt;
7696 const char **new_argv;
7697 char *temp_files[RETRY_ICE_ATTEMPTS * 2];
7698 char **temp_stdout_files = &temp_files[0];
7699 char **temp_stderr_files = &temp_files[RETRY_ICE_ATTEMPTS];
7700
7701 if (gcc_input_filename == NULL || ! strcmp (gcc_input_filename, "-"))
7702 return;
7703
7704 for (nargs = 0; argv[nargs] != NULL; ++nargs)
7705 /* Only retry compiler ICEs, not preprocessor ones. */
7706 if (! strcmp (argv[nargs], "-E"))
7707 return;
7708 else if (argv[nargs][0] == '-' && argv[nargs][1] == 'o')
7709 {
7710 if (out_arg == -1)
7711 out_arg = nargs;
7712 else
7713 return;
7714 }
7715 /* If the compiler is going to output any time information,
7716 it might varry between invocations. */
7717 else if (! strcmp (argv[nargs], "-quiet"))
7718 quiet = 1;
7719 else if (! strcmp (argv[nargs], "-ftime-report"))
7720 return;
7721
7722 if (out_arg == -1 || !quiet)
7723 return;
7724
7725 memset (temp_files, '\0', sizeof (temp_files));
7726 new_argv = XALLOCAVEC (const char *, nargs + 4);
7727 memcpy (new_argv, argv, (nargs + 1) * sizeof (const char *));
7728 new_argv[nargs++] = "-frandom-seed=0";
7729 new_argv[nargs++] = "-fdump-noaddr";
7730 new_argv[nargs] = NULL;
7731 if (new_argv[out_arg][2] == '\0')
7732 new_argv[out_arg + 1] = "-";
7733 else
7734 new_argv[out_arg] = "-o-";
7735
7736 int status;
7737 for (attempt = 0; attempt < RETRY_ICE_ATTEMPTS; ++attempt)
7738 {
7739 int emit_system_info = 0;
7740 int append = 0;
7741 temp_stdout_files[attempt] = make_temp_file (".out");
7742 temp_stderr_files[attempt] = make_temp_file (".err");
7743
7744 if (attempt == RETRY_ICE_ATTEMPTS - 1)
7745 {
7746 append = 1;
7747 emit_system_info = 1;
7748 }
7749
7750 status = run_attempt (new_argv, temp_stdout_files[attempt],
7751 temp_stderr_files[attempt], emit_system_info,
7752 append);
7753
7754 if (status != ATTEMPT_STATUS_ICE)
7755 {
7756 fnotice (stderr, "The bug is not reproducible, so it is"
7757 " likely a hardware or OS problem.\n");
7758 goto out;
7759 }
7760 }
7761
7762 if (!check_repro (temp_stdout_files, temp_stderr_files))
7763 goto out;
7764
7765 {
7766 /* Insert commented out backtrace into report file. */
7767 char **stderr_commented = &temp_stdout_files[RETRY_ICE_ATTEMPTS - 1];
7768 insert_comments (temp_stderr_files[RETRY_ICE_ATTEMPTS - 1],
7769 *stderr_commented);
7770
7771 /* In final attempt we append compiler options and preprocesssed code to last
7772 generated .out file with configuration and backtrace. */
7773 char **err = &temp_stderr_files[RETRY_ICE_ATTEMPTS - 1];
7774 do_report_bug (new_argv, nargs, stderr_commented, err);
7775 }
7776
7777 out:
7778 for (i = 0; i < RETRY_ICE_ATTEMPTS * 2; i++)
7779 if (temp_files[i])
7780 {
7781 unlink (temp_stdout_files[i]);
7782 free (temp_stdout_files[i]);
7783 }
7784 }
7785
7786 /* Search for a file named NAME trying various prefixes including the
7787 user's -B prefix and some standard ones.
7788 Return the absolute file name found. If nothing is found, return NAME. */
7789
7790 static const char *
find_file(const char * name)7791 find_file (const char *name)
7792 {
7793 char *newname = find_a_file (&startfile_prefixes, name, R_OK, true);
7794 return newname ? newname : name;
7795 }
7796
7797 /* Determine whether a directory exists. If LINKER, return 0 for
7798 certain fixed names not needed by the linker. */
7799
7800 static int
is_directory(const char * path1,bool linker)7801 is_directory (const char *path1, bool linker)
7802 {
7803 int len1;
7804 char *path;
7805 char *cp;
7806 struct stat st;
7807
7808 /* Ensure the string ends with "/.". The resulting path will be a
7809 directory even if the given path is a symbolic link. */
7810 len1 = strlen (path1);
7811 path = (char *) alloca (3 + len1);
7812 memcpy (path, path1, len1);
7813 cp = path + len1;
7814 if (!IS_DIR_SEPARATOR (cp[-1]))
7815 *cp++ = DIR_SEPARATOR;
7816 *cp++ = '.';
7817 *cp = '\0';
7818
7819 /* Exclude directories that the linker is known to search. */
7820 if (linker
7821 && IS_DIR_SEPARATOR (path[0])
7822 && ((cp - path == 6
7823 && filename_ncmp (path + 1, "lib", 3) == 0)
7824 || (cp - path == 10
7825 && filename_ncmp (path + 1, "usr", 3) == 0
7826 && IS_DIR_SEPARATOR (path[4])
7827 && filename_ncmp (path + 5, "lib", 3) == 0)))
7828 return 0;
7829
7830 return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
7831 }
7832
7833 /* Set up the various global variables to indicate that we're processing
7834 the input file named FILENAME. */
7835
7836 void
set_input(const char * filename)7837 set_input (const char *filename)
7838 {
7839 const char *p;
7840
7841 gcc_input_filename = filename;
7842 input_filename_length = strlen (gcc_input_filename);
7843 input_basename = lbasename (gcc_input_filename);
7844
7845 /* Find a suffix starting with the last period,
7846 and set basename_length to exclude that suffix. */
7847 basename_length = strlen (input_basename);
7848 suffixed_basename_length = basename_length;
7849 p = input_basename + basename_length;
7850 while (p != input_basename && *p != '.')
7851 --p;
7852 if (*p == '.' && p != input_basename)
7853 {
7854 basename_length = p - input_basename;
7855 input_suffix = p + 1;
7856 }
7857 else
7858 input_suffix = "";
7859
7860 /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
7861 we will need to do a stat on the gcc_input_filename. The
7862 INPUT_STAT_SET signals that the stat is needed. */
7863 input_stat_set = 0;
7864 }
7865
7866 /* On fatal signals, delete all the temporary files. */
7867
7868 static void
fatal_signal(int signum)7869 fatal_signal (int signum)
7870 {
7871 signal (signum, SIG_DFL);
7872 delete_failure_queue ();
7873 delete_temp_files ();
7874 /* Get the same signal again, this time not handled,
7875 so its normal effect occurs. */
7876 kill (getpid (), signum);
7877 }
7878
7879 /* Compare the contents of the two files named CMPFILE[0] and
7880 CMPFILE[1]. Return zero if they're identical, nonzero
7881 otherwise. */
7882
7883 static int
compare_files(char * cmpfile[])7884 compare_files (char *cmpfile[])
7885 {
7886 int ret = 0;
7887 FILE *temp[2] = { NULL, NULL };
7888 int i;
7889
7890 #if HAVE_MMAP_FILE
7891 {
7892 size_t length[2];
7893 void *map[2] = { NULL, NULL };
7894
7895 for (i = 0; i < 2; i++)
7896 {
7897 struct stat st;
7898
7899 if (stat (cmpfile[i], &st) < 0 || !S_ISREG (st.st_mode))
7900 {
7901 error ("%s: could not determine length of compare-debug file %s",
7902 gcc_input_filename, cmpfile[i]);
7903 ret = 1;
7904 break;
7905 }
7906
7907 length[i] = st.st_size;
7908 }
7909
7910 if (!ret && length[0] != length[1])
7911 {
7912 error ("%s: %<-fcompare-debug%> failure (length)", gcc_input_filename);
7913 ret = 1;
7914 }
7915
7916 if (!ret)
7917 for (i = 0; i < 2; i++)
7918 {
7919 int fd = open (cmpfile[i], O_RDONLY);
7920 if (fd < 0)
7921 {
7922 error ("%s: could not open compare-debug file %s",
7923 gcc_input_filename, cmpfile[i]);
7924 ret = 1;
7925 break;
7926 }
7927
7928 map[i] = mmap (NULL, length[i], PROT_READ, MAP_PRIVATE, fd, 0);
7929 close (fd);
7930
7931 if (map[i] == (void *) MAP_FAILED)
7932 {
7933 ret = -1;
7934 break;
7935 }
7936 }
7937
7938 if (!ret)
7939 {
7940 if (memcmp (map[0], map[1], length[0]) != 0)
7941 {
7942 error ("%s: %<-fcompare-debug%> failure", gcc_input_filename);
7943 ret = 1;
7944 }
7945 }
7946
7947 for (i = 0; i < 2; i++)
7948 if (map[i])
7949 munmap ((caddr_t) map[i], length[i]);
7950
7951 if (ret >= 0)
7952 return ret;
7953
7954 ret = 0;
7955 }
7956 #endif
7957
7958 for (i = 0; i < 2; i++)
7959 {
7960 temp[i] = fopen (cmpfile[i], "r");
7961 if (!temp[i])
7962 {
7963 error ("%s: could not open compare-debug file %s",
7964 gcc_input_filename, cmpfile[i]);
7965 ret = 1;
7966 break;
7967 }
7968 }
7969
7970 if (!ret && temp[0] && temp[1])
7971 for (;;)
7972 {
7973 int c0, c1;
7974 c0 = fgetc (temp[0]);
7975 c1 = fgetc (temp[1]);
7976
7977 if (c0 != c1)
7978 {
7979 error ("%s: %<-fcompare-debug%> failure",
7980 gcc_input_filename);
7981 ret = 1;
7982 break;
7983 }
7984
7985 if (c0 == EOF)
7986 break;
7987 }
7988
7989 for (i = 1; i >= 0; i--)
7990 {
7991 if (temp[i])
7992 fclose (temp[i]);
7993 }
7994
7995 return ret;
7996 }
7997
driver(bool can_finalize,bool debug)7998 driver::driver (bool can_finalize, bool debug) :
7999 explicit_link_files (NULL),
8000 decoded_options (NULL)
8001 {
8002 env.init (can_finalize, debug);
8003 }
8004
~driver()8005 driver::~driver ()
8006 {
8007 XDELETEVEC (explicit_link_files);
8008 XDELETEVEC (decoded_options);
8009 }
8010
8011 /* driver::main is implemented as a series of driver:: method calls. */
8012
8013 int
main(int argc,char ** argv)8014 driver::main (int argc, char **argv)
8015 {
8016 bool early_exit;
8017
8018 set_progname (argv[0]);
8019 expand_at_files (&argc, &argv);
8020 decode_argv (argc, const_cast <const char **> (argv));
8021 global_initializations ();
8022 build_multilib_strings ();
8023 set_up_specs ();
8024 putenv_COLLECT_AS_OPTIONS (assembler_options);
8025 putenv_COLLECT_GCC (argv[0]);
8026 maybe_putenv_COLLECT_LTO_WRAPPER ();
8027 maybe_putenv_OFFLOAD_TARGETS ();
8028 handle_unrecognized_options ();
8029
8030 if (completion)
8031 {
8032 m_option_proposer.suggest_completion (completion);
8033 return 0;
8034 }
8035
8036 if (!maybe_print_and_exit ())
8037 return 0;
8038
8039 early_exit = prepare_infiles ();
8040 if (early_exit)
8041 return get_exit_code ();
8042
8043 do_spec_on_infiles ();
8044 maybe_run_linker (argv[0]);
8045 final_actions ();
8046 return get_exit_code ();
8047 }
8048
8049 /* Locate the final component of argv[0] after any leading path, and set
8050 the program name accordingly. */
8051
8052 void
set_progname(const char * argv0)8053 driver::set_progname (const char *argv0) const
8054 {
8055 const char *p = argv0 + strlen (argv0);
8056 while (p != argv0 && !IS_DIR_SEPARATOR (p[-1]))
8057 --p;
8058 progname = p;
8059
8060 xmalloc_set_program_name (progname);
8061 }
8062
8063 /* Expand any @ files within the command-line args,
8064 setting at_file_supplied if any were expanded. */
8065
8066 void
expand_at_files(int * argc,char *** argv)8067 driver::expand_at_files (int *argc, char ***argv) const
8068 {
8069 char **old_argv = *argv;
8070
8071 expandargv (argc, argv);
8072
8073 /* Determine if any expansions were made. */
8074 if (*argv != old_argv)
8075 at_file_supplied = true;
8076 }
8077
8078 /* Decode the command-line arguments from argc/argv into the
8079 decoded_options array. */
8080
8081 void
decode_argv(int argc,const char ** argv)8082 driver::decode_argv (int argc, const char **argv)
8083 {
8084 init_opts_obstack ();
8085 init_options_struct (&global_options, &global_options_set);
8086
8087 decode_cmdline_options_to_array (argc, argv,
8088 CL_DRIVER,
8089 &decoded_options, &decoded_options_count);
8090 }
8091
8092 /* Perform various initializations and setup. */
8093
8094 void
global_initializations()8095 driver::global_initializations ()
8096 {
8097 /* Unlock the stdio streams. */
8098 unlock_std_streams ();
8099
8100 gcc_init_libintl ();
8101
8102 diagnostic_initialize (global_dc, 0);
8103 diagnostic_color_init (global_dc);
8104 diagnostic_urls_init (global_dc);
8105
8106 #ifdef GCC_DRIVER_HOST_INITIALIZATION
8107 /* Perform host dependent initialization when needed. */
8108 GCC_DRIVER_HOST_INITIALIZATION;
8109 #endif
8110
8111 if (atexit (delete_temp_files) != 0)
8112 fatal_error (input_location, "atexit failed");
8113
8114 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
8115 signal (SIGINT, fatal_signal);
8116 #ifdef SIGHUP
8117 if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
8118 signal (SIGHUP, fatal_signal);
8119 #endif
8120 if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
8121 signal (SIGTERM, fatal_signal);
8122 #ifdef SIGPIPE
8123 if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
8124 signal (SIGPIPE, fatal_signal);
8125 #endif
8126 #ifdef SIGCHLD
8127 /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
8128 receive the signal. A different setting is inheritable */
8129 signal (SIGCHLD, SIG_DFL);
8130 #endif
8131
8132 /* Parsing and gimplification sometimes need quite large stack.
8133 Increase stack size limits if possible. */
8134 stack_limit_increase (64 * 1024 * 1024);
8135
8136 /* Allocate the argument vector. */
8137 alloc_args ();
8138
8139 obstack_init (&obstack);
8140 }
8141
8142 /* Build multilib_select, et. al from the separate lines that make up each
8143 multilib selection. */
8144
8145 void
build_multilib_strings()8146 driver::build_multilib_strings () const
8147 {
8148 {
8149 const char *p;
8150 const char *const *q = multilib_raw;
8151 int need_space;
8152
8153 obstack_init (&multilib_obstack);
8154 while ((p = *q++) != (char *) 0)
8155 obstack_grow (&multilib_obstack, p, strlen (p));
8156
8157 obstack_1grow (&multilib_obstack, 0);
8158 multilib_select = XOBFINISH (&multilib_obstack, const char *);
8159
8160 q = multilib_matches_raw;
8161 while ((p = *q++) != (char *) 0)
8162 obstack_grow (&multilib_obstack, p, strlen (p));
8163
8164 obstack_1grow (&multilib_obstack, 0);
8165 multilib_matches = XOBFINISH (&multilib_obstack, const char *);
8166
8167 q = multilib_exclusions_raw;
8168 while ((p = *q++) != (char *) 0)
8169 obstack_grow (&multilib_obstack, p, strlen (p));
8170
8171 obstack_1grow (&multilib_obstack, 0);
8172 multilib_exclusions = XOBFINISH (&multilib_obstack, const char *);
8173
8174 q = multilib_reuse_raw;
8175 while ((p = *q++) != (char *) 0)
8176 obstack_grow (&multilib_obstack, p, strlen (p));
8177
8178 obstack_1grow (&multilib_obstack, 0);
8179 multilib_reuse = XOBFINISH (&multilib_obstack, const char *);
8180
8181 need_space = FALSE;
8182 for (size_t i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++)
8183 {
8184 if (need_space)
8185 obstack_1grow (&multilib_obstack, ' ');
8186 obstack_grow (&multilib_obstack,
8187 multilib_defaults_raw[i],
8188 strlen (multilib_defaults_raw[i]));
8189 need_space = TRUE;
8190 }
8191
8192 obstack_1grow (&multilib_obstack, 0);
8193 multilib_defaults = XOBFINISH (&multilib_obstack, const char *);
8194 }
8195 }
8196
8197 /* Set up the spec-handling machinery. */
8198
8199 void
set_up_specs()8200 driver::set_up_specs () const
8201 {
8202 const char *spec_machine_suffix;
8203 char *specs_file;
8204 size_t i;
8205
8206 #ifdef INIT_ENVIRONMENT
8207 /* Set up any other necessary machine specific environment variables. */
8208 xputenv (INIT_ENVIRONMENT);
8209 #endif
8210
8211 /* Make a table of what switches there are (switches, n_switches).
8212 Make a table of specified input files (infiles, n_infiles).
8213 Decode switches that are handled locally. */
8214
8215 process_command (decoded_options_count, decoded_options);
8216
8217 /* Initialize the vector of specs to just the default.
8218 This means one element containing 0s, as a terminator. */
8219
8220 compilers = XNEWVAR (struct compiler, sizeof default_compilers);
8221 memcpy (compilers, default_compilers, sizeof default_compilers);
8222 n_compilers = n_default_compilers;
8223
8224 /* Read specs from a file if there is one. */
8225
8226 machine_suffix = concat (spec_host_machine, dir_separator_str, spec_version,
8227 accel_dir_suffix, dir_separator_str, NULL);
8228 just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
8229
8230 specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, true);
8231 /* Read the specs file unless it is a default one. */
8232 if (specs_file != 0 && strcmp (specs_file, "specs"))
8233 read_specs (specs_file, true, false);
8234 else
8235 init_spec ();
8236
8237 #ifdef ACCEL_COMPILER
8238 spec_machine_suffix = machine_suffix;
8239 #else
8240 spec_machine_suffix = just_machine_suffix;
8241 #endif
8242
8243 /* We need to check standard_exec_prefix/spec_machine_suffix/specs
8244 for any override of as, ld and libraries. */
8245 specs_file = (char *) alloca (strlen (standard_exec_prefix)
8246 + strlen (spec_machine_suffix) + sizeof ("specs"));
8247 strcpy (specs_file, standard_exec_prefix);
8248 strcat (specs_file, spec_machine_suffix);
8249 strcat (specs_file, "specs");
8250 if (access (specs_file, R_OK) == 0)
8251 read_specs (specs_file, true, false);
8252
8253 /* Process any configure-time defaults specified for the command line
8254 options, via OPTION_DEFAULT_SPECS. */
8255 for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
8256 do_option_spec (option_default_specs[i].name,
8257 option_default_specs[i].spec);
8258
8259 /* Process DRIVER_SELF_SPECS, adding any new options to the end
8260 of the command line. */
8261
8262 for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++)
8263 do_self_spec (driver_self_specs[i]);
8264
8265 /* If not cross-compiling, look for executables in the standard
8266 places. */
8267 if (*cross_compile == '0')
8268 {
8269 if (*md_exec_prefix)
8270 {
8271 add_prefix (&exec_prefixes, md_exec_prefix, "GCC",
8272 PREFIX_PRIORITY_LAST, 0, 0);
8273 }
8274 }
8275
8276 /* Process sysroot_suffix_spec. */
8277 if (*sysroot_suffix_spec != 0
8278 && !no_sysroot_suffix
8279 && do_spec_2 (sysroot_suffix_spec, NULL) == 0)
8280 {
8281 if (argbuf.length () > 1)
8282 error ("spec failure: more than one argument to "
8283 "%<SYSROOT_SUFFIX_SPEC%>");
8284 else if (argbuf.length () == 1)
8285 target_sysroot_suffix = xstrdup (argbuf.last ());
8286 }
8287
8288 #ifdef HAVE_LD_SYSROOT
8289 /* Pass the --sysroot option to the linker, if it supports that. If
8290 there is a sysroot_suffix_spec, it has already been processed by
8291 this point, so target_system_root really is the system root we
8292 should be using. */
8293 if (target_system_root)
8294 {
8295 obstack_grow (&obstack, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
8296 obstack_grow0 (&obstack, link_spec, strlen (link_spec));
8297 set_spec ("link", XOBFINISH (&obstack, const char *), false);
8298 }
8299 #endif
8300
8301 /* Process sysroot_hdrs_suffix_spec. */
8302 if (*sysroot_hdrs_suffix_spec != 0
8303 && !no_sysroot_suffix
8304 && do_spec_2 (sysroot_hdrs_suffix_spec, NULL) == 0)
8305 {
8306 if (argbuf.length () > 1)
8307 error ("spec failure: more than one argument "
8308 "to %<SYSROOT_HEADERS_SUFFIX_SPEC%>");
8309 else if (argbuf.length () == 1)
8310 target_sysroot_hdrs_suffix = xstrdup (argbuf.last ());
8311 }
8312
8313 /* Look for startfiles in the standard places. */
8314 if (*startfile_prefix_spec != 0
8315 && do_spec_2 (startfile_prefix_spec, NULL) == 0
8316 && do_spec_1 (" ", 0, NULL) == 0)
8317 {
8318 const char *arg;
8319 int ndx;
8320 FOR_EACH_VEC_ELT (argbuf, ndx, arg)
8321 add_sysrooted_prefix (&startfile_prefixes, arg, "BINUTILS",
8322 PREFIX_PRIORITY_LAST, 0, 1);
8323 }
8324 /* We should eventually get rid of all these and stick to
8325 startfile_prefix_spec exclusively. */
8326 else if (*cross_compile == '0' || target_system_root)
8327 {
8328 if (*md_startfile_prefix)
8329 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix,
8330 "GCC", PREFIX_PRIORITY_LAST, 0, 1);
8331
8332 if (*md_startfile_prefix_1)
8333 add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix_1,
8334 "GCC", PREFIX_PRIORITY_LAST, 0, 1);
8335
8336 /* If standard_startfile_prefix is relative, base it on
8337 standard_exec_prefix. This lets us move the installed tree
8338 as a unit. If GCC_EXEC_PREFIX is defined, base
8339 standard_startfile_prefix on that as well.
8340
8341 If the prefix is relative, only search it for native compilers;
8342 otherwise we will search a directory containing host libraries. */
8343 if (IS_ABSOLUTE_PATH (standard_startfile_prefix))
8344 add_sysrooted_prefix (&startfile_prefixes,
8345 standard_startfile_prefix, "BINUTILS",
8346 PREFIX_PRIORITY_LAST, 0, 1);
8347 else if (*cross_compile == '0')
8348 {
8349 add_prefix (&startfile_prefixes,
8350 concat (gcc_exec_prefix
8351 ? gcc_exec_prefix : standard_exec_prefix,
8352 machine_suffix,
8353 standard_startfile_prefix, NULL),
8354 NULL, PREFIX_PRIORITY_LAST, 0, 1);
8355 }
8356
8357 /* Sysrooted prefixes are relocated because target_system_root is
8358 also relocated by gcc_exec_prefix. */
8359 if (*standard_startfile_prefix_1)
8360 add_sysrooted_prefix (&startfile_prefixes,
8361 standard_startfile_prefix_1, "BINUTILS",
8362 PREFIX_PRIORITY_LAST, 0, 1);
8363 if (*standard_startfile_prefix_2)
8364 add_sysrooted_prefix (&startfile_prefixes,
8365 standard_startfile_prefix_2, "BINUTILS",
8366 PREFIX_PRIORITY_LAST, 0, 1);
8367 }
8368
8369 /* Process any user specified specs in the order given on the command
8370 line. */
8371 for (struct user_specs *uptr = user_specs_head; uptr; uptr = uptr->next)
8372 {
8373 char *filename = find_a_file (&startfile_prefixes, uptr->filename,
8374 R_OK, true);
8375 read_specs (filename ? filename : uptr->filename, false, true);
8376 }
8377
8378 /* Process any user self specs. */
8379 {
8380 struct spec_list *sl;
8381 for (sl = specs; sl; sl = sl->next)
8382 if (sl->name_len == sizeof "self_spec" - 1
8383 && !strcmp (sl->name, "self_spec"))
8384 do_self_spec (*sl->ptr_spec);
8385 }
8386
8387 if (compare_debug)
8388 {
8389 enum save_temps save;
8390
8391 if (!compare_debug_second)
8392 {
8393 n_switches_debug_check[1] = n_switches;
8394 n_switches_alloc_debug_check[1] = n_switches_alloc;
8395 switches_debug_check[1] = XDUPVEC (struct switchstr, switches,
8396 n_switches_alloc);
8397
8398 do_self_spec ("%:compare-debug-self-opt()");
8399 n_switches_debug_check[0] = n_switches;
8400 n_switches_alloc_debug_check[0] = n_switches_alloc;
8401 switches_debug_check[0] = switches;
8402
8403 n_switches = n_switches_debug_check[1];
8404 n_switches_alloc = n_switches_alloc_debug_check[1];
8405 switches = switches_debug_check[1];
8406 }
8407
8408 /* Avoid crash when computing %j in this early. */
8409 save = save_temps_flag;
8410 save_temps_flag = SAVE_TEMPS_NONE;
8411
8412 compare_debug = -compare_debug;
8413 do_self_spec ("%:compare-debug-self-opt()");
8414
8415 save_temps_flag = save;
8416
8417 if (!compare_debug_second)
8418 {
8419 n_switches_debug_check[1] = n_switches;
8420 n_switches_alloc_debug_check[1] = n_switches_alloc;
8421 switches_debug_check[1] = switches;
8422 compare_debug = -compare_debug;
8423 n_switches = n_switches_debug_check[0];
8424 n_switches_alloc = n_switches_debug_check[0];
8425 switches = switches_debug_check[0];
8426 }
8427 }
8428
8429
8430 /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake. */
8431 if (gcc_exec_prefix)
8432 gcc_exec_prefix = concat (gcc_exec_prefix, spec_host_machine,
8433 dir_separator_str, spec_version,
8434 accel_dir_suffix, dir_separator_str, NULL);
8435
8436 /* Now we have the specs.
8437 Set the `valid' bits for switches that match anything in any spec. */
8438
8439 validate_all_switches ();
8440
8441 /* Now that we have the switches and the specs, set
8442 the subdirectory based on the options. */
8443 set_multilib_dir ();
8444 }
8445
8446 /* Set up to remember the pathname of gcc and any options
8447 needed for collect. We use argv[0] instead of progname because
8448 we need the complete pathname. */
8449
8450 void
putenv_COLLECT_GCC(const char * argv0)8451 driver::putenv_COLLECT_GCC (const char *argv0) const
8452 {
8453 obstack_init (&collect_obstack);
8454 obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
8455 obstack_grow (&collect_obstack, argv0, strlen (argv0) + 1);
8456 xputenv (XOBFINISH (&collect_obstack, char *));
8457 }
8458
8459 /* Set up to remember the pathname of the lto wrapper. */
8460
8461 void
maybe_putenv_COLLECT_LTO_WRAPPER()8462 driver::maybe_putenv_COLLECT_LTO_WRAPPER () const
8463 {
8464 char *lto_wrapper_file;
8465
8466 if (have_c)
8467 lto_wrapper_file = NULL;
8468 else
8469 lto_wrapper_file = find_a_file (&exec_prefixes, "lto-wrapper",
8470 X_OK, false);
8471 if (lto_wrapper_file)
8472 {
8473 lto_wrapper_file = convert_white_space (lto_wrapper_file);
8474 set_static_spec_owned (<o_wrapper_spec, lto_wrapper_file);
8475 obstack_init (&collect_obstack);
8476 obstack_grow (&collect_obstack, "COLLECT_LTO_WRAPPER=",
8477 sizeof ("COLLECT_LTO_WRAPPER=") - 1);
8478 obstack_grow (&collect_obstack, lto_wrapper_spec,
8479 strlen (lto_wrapper_spec) + 1);
8480 xputenv (XOBFINISH (&collect_obstack, char *));
8481 }
8482
8483 }
8484
8485 /* Set up to remember the names of offload targets. */
8486
8487 void
maybe_putenv_OFFLOAD_TARGETS()8488 driver::maybe_putenv_OFFLOAD_TARGETS () const
8489 {
8490 if (offload_targets && offload_targets[0] != '\0')
8491 {
8492 obstack_grow (&collect_obstack, "OFFLOAD_TARGET_NAMES=",
8493 sizeof ("OFFLOAD_TARGET_NAMES=") - 1);
8494 obstack_grow (&collect_obstack, offload_targets,
8495 strlen (offload_targets) + 1);
8496 xputenv (XOBFINISH (&collect_obstack, char *));
8497 }
8498
8499 free (offload_targets);
8500 offload_targets = NULL;
8501 }
8502
8503 /* Reject switches that no pass was interested in. */
8504
8505 void
handle_unrecognized_options()8506 driver::handle_unrecognized_options ()
8507 {
8508 for (size_t i = 0; (int) i < n_switches; i++)
8509 if (! switches[i].validated)
8510 {
8511 const char *hint = m_option_proposer.suggest_option (switches[i].part1);
8512 if (hint)
8513 error ("unrecognized command-line option %<-%s%>;"
8514 " did you mean %<-%s%>?",
8515 switches[i].part1, hint);
8516 else
8517 error ("unrecognized command-line option %<-%s%>",
8518 switches[i].part1);
8519 }
8520 }
8521
8522 /* Handle the various -print-* options, returning 0 if the driver
8523 should exit, or nonzero if the driver should continue. */
8524
8525 int
maybe_print_and_exit()8526 driver::maybe_print_and_exit () const
8527 {
8528 if (print_search_dirs)
8529 {
8530 printf (_("install: %s%s\n"),
8531 gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
8532 gcc_exec_prefix ? "" : machine_suffix);
8533 printf (_("programs: %s\n"),
8534 build_search_list (&exec_prefixes, "", false, false));
8535 printf (_("libraries: %s\n"),
8536 build_search_list (&startfile_prefixes, "", false, true));
8537 return (0);
8538 }
8539
8540 if (print_file_name)
8541 {
8542 printf ("%s\n", find_file (print_file_name));
8543 return (0);
8544 }
8545
8546 if (print_prog_name)
8547 {
8548 if (use_ld != NULL && ! strcmp (print_prog_name, "ld"))
8549 {
8550 /* Append USE_LD to the default linker. */
8551 #ifdef DEFAULT_LINKER
8552 char *ld;
8553 # ifdef HAVE_HOST_EXECUTABLE_SUFFIX
8554 int len = (sizeof (DEFAULT_LINKER)
8555 - sizeof (HOST_EXECUTABLE_SUFFIX));
8556 ld = NULL;
8557 if (len > 0)
8558 {
8559 char *default_linker = xstrdup (DEFAULT_LINKER);
8560 /* Strip HOST_EXECUTABLE_SUFFIX if DEFAULT_LINKER contains
8561 HOST_EXECUTABLE_SUFFIX. */
8562 if (! strcmp (&default_linker[len], HOST_EXECUTABLE_SUFFIX))
8563 {
8564 default_linker[len] = '\0';
8565 ld = concat (default_linker, use_ld,
8566 HOST_EXECUTABLE_SUFFIX, NULL);
8567 }
8568 }
8569 if (ld == NULL)
8570 # endif
8571 ld = concat (DEFAULT_LINKER, use_ld, NULL);
8572 if (access (ld, X_OK) == 0)
8573 {
8574 printf ("%s\n", ld);
8575 return (0);
8576 }
8577 #endif
8578 print_prog_name = concat (print_prog_name, use_ld, NULL);
8579 }
8580 char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK, 0);
8581 printf ("%s\n", (newname ? newname : print_prog_name));
8582 return (0);
8583 }
8584
8585 if (print_multi_lib)
8586 {
8587 print_multilib_info ();
8588 return (0);
8589 }
8590
8591 if (print_multi_directory)
8592 {
8593 if (multilib_dir == NULL)
8594 printf (".\n");
8595 else
8596 printf ("%s\n", multilib_dir);
8597 return (0);
8598 }
8599
8600 if (print_multiarch)
8601 {
8602 if (multiarch_dir == NULL)
8603 printf ("\n");
8604 else
8605 printf ("%s\n", multiarch_dir);
8606 return (0);
8607 }
8608
8609 if (print_sysroot)
8610 {
8611 if (target_system_root)
8612 {
8613 if (target_sysroot_suffix)
8614 printf ("%s%s\n", target_system_root, target_sysroot_suffix);
8615 else
8616 printf ("%s\n", target_system_root);
8617 }
8618 return (0);
8619 }
8620
8621 if (print_multi_os_directory)
8622 {
8623 if (multilib_os_dir == NULL)
8624 printf (".\n");
8625 else
8626 printf ("%s\n", multilib_os_dir);
8627 return (0);
8628 }
8629
8630 if (print_sysroot_headers_suffix)
8631 {
8632 if (*sysroot_hdrs_suffix_spec)
8633 {
8634 printf("%s\n", (target_sysroot_hdrs_suffix
8635 ? target_sysroot_hdrs_suffix
8636 : ""));
8637 return (0);
8638 }
8639 else
8640 /* The error status indicates that only one set of fixed
8641 headers should be built. */
8642 fatal_error (input_location,
8643 "not configured with sysroot headers suffix");
8644 }
8645
8646 if (print_help_list)
8647 {
8648 display_help ();
8649
8650 if (! verbose_flag)
8651 {
8652 printf (_("\nFor bug reporting instructions, please see:\n"));
8653 printf ("%s.\n", bug_report_url);
8654
8655 return (0);
8656 }
8657
8658 /* We do not exit here. Instead we have created a fake input file
8659 called 'help-dummy' which needs to be compiled, and we pass this
8660 on the various sub-processes, along with the --help switch.
8661 Ensure their output appears after ours. */
8662 fputc ('\n', stdout);
8663 fflush (stdout);
8664 }
8665
8666 if (print_version)
8667 {
8668 printf (_("%s %s%s\n"), progname, pkgversion_string,
8669 version_string);
8670 printf ("Copyright %s 2021 Free Software Foundation, Inc.\n",
8671 _("(C)"));
8672 fputs (_("This is free software; see the source for copying conditions. There is NO\n\
8673 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
8674 stdout);
8675 if (! verbose_flag)
8676 return 0;
8677
8678 /* We do not exit here. We use the same mechanism of --help to print
8679 the version of the sub-processes. */
8680 fputc ('\n', stdout);
8681 fflush (stdout);
8682 }
8683
8684 if (verbose_flag)
8685 {
8686 print_configuration (stderr);
8687 if (n_infiles == 0)
8688 return (0);
8689 }
8690
8691 return 1;
8692 }
8693
8694 /* Figure out what to do with each input file.
8695 Return true if we need to exit early from "main", false otherwise. */
8696
8697 bool
prepare_infiles()8698 driver::prepare_infiles ()
8699 {
8700 size_t i;
8701 int lang_n_infiles = 0;
8702
8703 if (n_infiles == added_libraries)
8704 fatal_error (input_location, "no input files");
8705
8706 if (seen_error ())
8707 /* Early exit needed from main. */
8708 return true;
8709
8710 /* Make a place to record the compiler output file names
8711 that correspond to the input files. */
8712
8713 i = n_infiles;
8714 i += lang_specific_extra_outfiles;
8715 outfiles = XCNEWVEC (const char *, i);
8716
8717 /* Record which files were specified explicitly as link input. */
8718
8719 explicit_link_files = XCNEWVEC (char, n_infiles);
8720
8721 combine_inputs = have_o || flag_wpa;
8722
8723 for (i = 0; (int) i < n_infiles; i++)
8724 {
8725 const char *name = infiles[i].name;
8726 struct compiler *compiler = lookup_compiler (name,
8727 strlen (name),
8728 infiles[i].language);
8729
8730 if (compiler && !(compiler->combinable))
8731 combine_inputs = false;
8732
8733 if (lang_n_infiles > 0 && compiler != input_file_compiler
8734 && infiles[i].language && infiles[i].language[0] != '*')
8735 infiles[i].incompiler = compiler;
8736 else if (compiler)
8737 {
8738 lang_n_infiles++;
8739 input_file_compiler = compiler;
8740 infiles[i].incompiler = compiler;
8741 }
8742 else
8743 {
8744 /* Since there is no compiler for this input file, assume it is a
8745 linker file. */
8746 explicit_link_files[i] = 1;
8747 infiles[i].incompiler = NULL;
8748 }
8749 infiles[i].compiled = false;
8750 infiles[i].preprocessed = false;
8751 }
8752
8753 if (!combine_inputs && have_c && have_o && lang_n_infiles > 1)
8754 fatal_error (input_location,
8755 "cannot specify %<-o%> with %<-c%>, %<-S%> or %<-E%> "
8756 "with multiple files");
8757
8758 /* No early exit needed from main; we can continue. */
8759 return false;
8760 }
8761
8762 /* Run the spec machinery on each input file. */
8763
8764 void
do_spec_on_infiles()8765 driver::do_spec_on_infiles () const
8766 {
8767 size_t i;
8768
8769 for (i = 0; (int) i < n_infiles; i++)
8770 {
8771 int this_file_error = 0;
8772
8773 /* Tell do_spec what to substitute for %i. */
8774
8775 input_file_number = i;
8776 set_input (infiles[i].name);
8777
8778 if (infiles[i].compiled)
8779 continue;
8780
8781 /* Use the same thing in %o, unless cp->spec says otherwise. */
8782
8783 outfiles[i] = gcc_input_filename;
8784
8785 /* Figure out which compiler from the file's suffix. */
8786
8787 input_file_compiler
8788 = lookup_compiler (infiles[i].name, input_filename_length,
8789 infiles[i].language);
8790
8791 if (input_file_compiler)
8792 {
8793 /* Ok, we found an applicable compiler. Run its spec. */
8794
8795 if (input_file_compiler->spec[0] == '#')
8796 {
8797 error ("%s: %s compiler not installed on this system",
8798 gcc_input_filename, &input_file_compiler->spec[1]);
8799 this_file_error = 1;
8800 }
8801 else
8802 {
8803 int value;
8804
8805 if (compare_debug)
8806 {
8807 free (debug_check_temp_file[0]);
8808 debug_check_temp_file[0] = NULL;
8809
8810 free (debug_check_temp_file[1]);
8811 debug_check_temp_file[1] = NULL;
8812 }
8813
8814 value = do_spec (input_file_compiler->spec);
8815 infiles[i].compiled = true;
8816 if (value < 0)
8817 this_file_error = 1;
8818 else if (compare_debug && debug_check_temp_file[0])
8819 {
8820 if (verbose_flag)
8821 inform (UNKNOWN_LOCATION,
8822 "recompiling with %<-fcompare-debug%>");
8823
8824 compare_debug = -compare_debug;
8825 n_switches = n_switches_debug_check[1];
8826 n_switches_alloc = n_switches_alloc_debug_check[1];
8827 switches = switches_debug_check[1];
8828
8829 value = do_spec (input_file_compiler->spec);
8830
8831 compare_debug = -compare_debug;
8832 n_switches = n_switches_debug_check[0];
8833 n_switches_alloc = n_switches_alloc_debug_check[0];
8834 switches = switches_debug_check[0];
8835
8836 if (value < 0)
8837 {
8838 error ("during %<-fcompare-debug%> recompilation");
8839 this_file_error = 1;
8840 }
8841
8842 gcc_assert (debug_check_temp_file[1]
8843 && filename_cmp (debug_check_temp_file[0],
8844 debug_check_temp_file[1]));
8845
8846 if (verbose_flag)
8847 inform (UNKNOWN_LOCATION, "comparing final insns dumps");
8848
8849 if (compare_files (debug_check_temp_file))
8850 this_file_error = 1;
8851 }
8852
8853 if (compare_debug)
8854 {
8855 free (debug_check_temp_file[0]);
8856 debug_check_temp_file[0] = NULL;
8857
8858 free (debug_check_temp_file[1]);
8859 debug_check_temp_file[1] = NULL;
8860 }
8861 }
8862 }
8863
8864 /* If this file's name does not contain a recognized suffix,
8865 record it as explicit linker input. */
8866
8867 else
8868 explicit_link_files[i] = 1;
8869
8870 /* Clear the delete-on-failure queue, deleting the files in it
8871 if this compilation failed. */
8872
8873 if (this_file_error)
8874 {
8875 delete_failure_queue ();
8876 errorcount++;
8877 }
8878 /* If this compilation succeeded, don't delete those files later. */
8879 clear_failure_queue ();
8880 }
8881
8882 /* Reset the input file name to the first compile/object file name, for use
8883 with %b in LINK_SPEC. We use the first input file that we can find
8884 a compiler to compile it instead of using infiles.language since for
8885 languages other than C we use aliases that we then lookup later. */
8886 if (n_infiles > 0)
8887 {
8888 int i;
8889
8890 for (i = 0; i < n_infiles ; i++)
8891 if (infiles[i].incompiler
8892 || (infiles[i].language && infiles[i].language[0] != '*'))
8893 {
8894 set_input (infiles[i].name);
8895 break;
8896 }
8897 }
8898
8899 if (!seen_error ())
8900 {
8901 /* Make sure INPUT_FILE_NUMBER points to first available open
8902 slot. */
8903 input_file_number = n_infiles;
8904 if (lang_specific_pre_link ())
8905 errorcount++;
8906 }
8907 }
8908
8909 /* If we have to run the linker, do it now. */
8910
8911 void
maybe_run_linker(const char * argv0)8912 driver::maybe_run_linker (const char *argv0) const
8913 {
8914 size_t i;
8915 int linker_was_run = 0;
8916 int num_linker_inputs;
8917
8918 /* Determine if there are any linker input files. */
8919 num_linker_inputs = 0;
8920 for (i = 0; (int) i < n_infiles; i++)
8921 if (explicit_link_files[i] || outfiles[i] != NULL)
8922 num_linker_inputs++;
8923
8924 /* Arrange for temporary file names created during linking to take
8925 on names related with the linker output rather than with the
8926 inputs when appropriate. */
8927 if (outbase && *outbase)
8928 {
8929 if (dumpdir)
8930 {
8931 char *tofree = dumpdir;
8932 gcc_checking_assert (strlen (dumpdir) == dumpdir_length);
8933 dumpdir = concat (dumpdir, outbase, ".", NULL);
8934 free (tofree);
8935 }
8936 else
8937 dumpdir = concat (outbase, ".", NULL);
8938 dumpdir_length += strlen (outbase) + 1;
8939 dumpdir_trailing_dash_added = true;
8940 }
8941 else if (dumpdir_trailing_dash_added)
8942 {
8943 gcc_assert (dumpdir[dumpdir_length - 1] == '-');
8944 dumpdir[dumpdir_length - 1] = '.';
8945 }
8946
8947 if (dumpdir_trailing_dash_added)
8948 {
8949 gcc_assert (dumpdir_length > 0);
8950 gcc_assert (dumpdir[dumpdir_length - 1] == '.');
8951 dumpdir_length--;
8952 }
8953
8954 free (outbase);
8955 input_basename = outbase = NULL;
8956 outbase_length = suffixed_basename_length = basename_length = 0;
8957
8958 /* Run ld to link all the compiler output files. */
8959
8960 if (num_linker_inputs > 0 && !seen_error () && print_subprocess_help < 2)
8961 {
8962 int tmp = execution_count;
8963
8964 detect_jobserver ();
8965
8966 if (! have_c)
8967 {
8968 #if HAVE_LTO_PLUGIN > 0
8969 #if HAVE_LTO_PLUGIN == 2
8970 const char *fno_use_linker_plugin = "fno-use-linker-plugin";
8971 #else
8972 const char *fuse_linker_plugin = "fuse-linker-plugin";
8973 #endif
8974 #endif
8975
8976 /* We'll use ld if we can't find collect2. */
8977 if (! strcmp (linker_name_spec, "collect2"))
8978 {
8979 char *s = find_a_file (&exec_prefixes, "collect2", X_OK, false);
8980 if (s == NULL)
8981 set_static_spec_shared (&linker_name_spec, "ld");
8982 }
8983
8984 #if HAVE_LTO_PLUGIN > 0
8985 #if HAVE_LTO_PLUGIN == 2
8986 if (!switch_matches (fno_use_linker_plugin,
8987 fno_use_linker_plugin
8988 + strlen (fno_use_linker_plugin), 0))
8989 #else
8990 if (switch_matches (fuse_linker_plugin,
8991 fuse_linker_plugin
8992 + strlen (fuse_linker_plugin), 0))
8993 #endif
8994 {
8995 char *temp_spec = find_a_file (&exec_prefixes,
8996 LTOPLUGINSONAME, R_OK,
8997 false);
8998 if (!temp_spec)
8999 fatal_error (input_location,
9000 "%<-fuse-linker-plugin%>, but %s not found",
9001 LTOPLUGINSONAME);
9002 linker_plugin_file_spec = convert_white_space (temp_spec);
9003 }
9004 #endif
9005 set_static_spec_shared (<o_gcc_spec, argv0);
9006 }
9007
9008 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
9009 for collect. */
9010 putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH", false);
9011 putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV, true);
9012
9013 if (print_subprocess_help == 1)
9014 {
9015 printf (_("\nLinker options\n==============\n\n"));
9016 printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
9017 " to the linker.\n\n"));
9018 fflush (stdout);
9019 }
9020 int value = do_spec (link_command_spec);
9021 if (value < 0)
9022 errorcount = 1;
9023 linker_was_run = (tmp != execution_count);
9024 }
9025
9026 /* If options said don't run linker,
9027 complain about input files to be given to the linker. */
9028
9029 if (! linker_was_run && !seen_error ())
9030 for (i = 0; (int) i < n_infiles; i++)
9031 if (explicit_link_files[i]
9032 && !(infiles[i].language && infiles[i].language[0] == '*'))
9033 {
9034 warning (0, "%s: linker input file unused because linking not done",
9035 outfiles[i]);
9036 if (access (outfiles[i], F_OK) < 0)
9037 /* This is can be an indication the user specifed an errorneous
9038 separated option value, (or used the wrong prefix for an
9039 option). */
9040 error ("%s: linker input file not found: %m", outfiles[i]);
9041 }
9042 }
9043
9044 /* The end of "main". */
9045
9046 void
final_actions()9047 driver::final_actions () const
9048 {
9049 /* Delete some or all of the temporary files we made. */
9050
9051 if (seen_error ())
9052 delete_failure_queue ();
9053 delete_temp_files ();
9054
9055 if (print_help_list)
9056 {
9057 printf (("\nFor bug reporting instructions, please see:\n"));
9058 printf ("%s\n", bug_report_url);
9059 }
9060 }
9061
9062 /* Detect whether jobserver is active and working. If not drop
9063 --jobserver-auth from MAKEFLAGS. */
9064
9065 void
detect_jobserver()9066 driver::detect_jobserver () const
9067 {
9068 /* Detect jobserver and drop it if it's not working. */
9069 const char *makeflags = env.get ("MAKEFLAGS");
9070 if (makeflags != NULL)
9071 {
9072 const char *needle = "--jobserver-auth=";
9073 const char *n = strstr (makeflags, needle);
9074 if (n != NULL)
9075 {
9076 int rfd = -1;
9077 int wfd = -1;
9078
9079 bool jobserver
9080 = (sscanf (n + strlen (needle), "%d,%d", &rfd, &wfd) == 2
9081 && rfd > 0
9082 && wfd > 0
9083 && is_valid_fd (rfd)
9084 && is_valid_fd (wfd));
9085
9086 /* Drop the jobserver if it's not working now. */
9087 if (!jobserver)
9088 {
9089 unsigned offset = n - makeflags;
9090 char *dup = xstrdup (makeflags);
9091 dup[offset] = '\0';
9092
9093 const char *space = strchr (makeflags + offset, ' ');
9094 if (space != NULL)
9095 strcpy (dup + offset, space);
9096 xputenv (concat ("MAKEFLAGS=", dup, NULL));
9097 }
9098 }
9099 }
9100 }
9101
9102 /* Determine what the exit code of the driver should be. */
9103
9104 int
get_exit_code()9105 driver::get_exit_code () const
9106 {
9107 return (signal_count != 0 ? 2
9108 : seen_error () ? (pass_exit_codes ? greatest_status : 1)
9109 : 0);
9110 }
9111
9112 /* Find the proper compilation spec for the file name NAME,
9113 whose length is LENGTH. LANGUAGE is the specified language,
9114 or 0 if this file is to be passed to the linker. */
9115
9116 static struct compiler *
lookup_compiler(const char * name,size_t length,const char * language)9117 lookup_compiler (const char *name, size_t length, const char *language)
9118 {
9119 struct compiler *cp;
9120
9121 /* If this was specified by the user to be a linker input, indicate that. */
9122 if (language != 0 && language[0] == '*')
9123 return 0;
9124
9125 /* Otherwise, look for the language, if one is spec'd. */
9126 if (language != 0)
9127 {
9128 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
9129 if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
9130 {
9131 if (name != NULL && strcmp (name, "-") == 0
9132 && (strcmp (cp->suffix, "@c-header") == 0
9133 || strcmp (cp->suffix, "@c++-header") == 0)
9134 && !have_E)
9135 fatal_error (input_location,
9136 "cannot use %<-%> as input filename for a "
9137 "precompiled header");
9138
9139 return cp;
9140 }
9141
9142 error ("language %s not recognized", language);
9143 return 0;
9144 }
9145
9146 /* Look for a suffix. */
9147 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
9148 {
9149 if (/* The suffix `-' matches only the file name `-'. */
9150 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
9151 || (strlen (cp->suffix) < length
9152 /* See if the suffix matches the end of NAME. */
9153 && !strcmp (cp->suffix,
9154 name + length - strlen (cp->suffix))
9155 ))
9156 break;
9157 }
9158
9159 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
9160 /* Look again, but case-insensitively this time. */
9161 if (cp < compilers)
9162 for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
9163 {
9164 if (/* The suffix `-' matches only the file name `-'. */
9165 (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
9166 || (strlen (cp->suffix) < length
9167 /* See if the suffix matches the end of NAME. */
9168 && ((!strcmp (cp->suffix,
9169 name + length - strlen (cp->suffix))
9170 || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
9171 && !strcasecmp (cp->suffix,
9172 name + length - strlen (cp->suffix)))
9173 ))
9174 break;
9175 }
9176 #endif
9177
9178 if (cp >= compilers)
9179 {
9180 if (cp->spec[0] != '@')
9181 /* A non-alias entry: return it. */
9182 return cp;
9183
9184 /* An alias entry maps a suffix to a language.
9185 Search for the language; pass 0 for NAME and LENGTH
9186 to avoid infinite recursion if language not found. */
9187 return lookup_compiler (NULL, 0, cp->spec + 1);
9188 }
9189 return 0;
9190 }
9191
9192 static char *
save_string(const char * s,int len)9193 save_string (const char *s, int len)
9194 {
9195 char *result = XNEWVEC (char, len + 1);
9196
9197 gcc_checking_assert (strlen (s) >= (unsigned int) len);
9198 memcpy (result, s, len);
9199 result[len] = 0;
9200 return result;
9201 }
9202
9203
9204 static inline void
validate_switches_from_spec(const char * spec,bool user)9205 validate_switches_from_spec (const char *spec, bool user)
9206 {
9207 const char *p = spec;
9208 char c;
9209 while ((c = *p++))
9210 if (c == '%'
9211 && (*p == '{'
9212 || *p == '<'
9213 || (*p == 'W' && *++p == '{')
9214 || (*p == '@' && *++p == '{')))
9215 /* We have a switch spec. */
9216 p = validate_switches (p + 1, user, *p == '{');
9217 }
9218
9219 static void
validate_all_switches(void)9220 validate_all_switches (void)
9221 {
9222 struct compiler *comp;
9223 struct spec_list *spec;
9224
9225 for (comp = compilers; comp->spec; comp++)
9226 validate_switches_from_spec (comp->spec, false);
9227
9228 /* Look through the linked list of specs read from the specs file. */
9229 for (spec = specs; spec; spec = spec->next)
9230 validate_switches_from_spec (*spec->ptr_spec, spec->user_p);
9231
9232 validate_switches_from_spec (link_command_spec, false);
9233 }
9234
9235 /* Look at the switch-name that comes after START and mark as valid
9236 all supplied switches that match it. If BRACED, handle other
9237 switches after '|' and '&', and specs after ':' until ';' or '}',
9238 going back for more switches after ';'. Without BRACED, handle
9239 only one atom. Return a pointer to whatever follows the handled
9240 items, after the closing brace if BRACED. */
9241
9242 static const char *
validate_switches(const char * start,bool user_spec,bool braced)9243 validate_switches (const char *start, bool user_spec, bool braced)
9244 {
9245 const char *p = start;
9246 const char *atom;
9247 size_t len;
9248 int i;
9249 bool suffix = false;
9250 bool starred = false;
9251
9252 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
9253
9254 next_member:
9255 SKIP_WHITE ();
9256
9257 if (*p == '!')
9258 p++;
9259
9260 SKIP_WHITE ();
9261 if (*p == '.' || *p == ',')
9262 suffix = true, p++;
9263
9264 atom = p;
9265 while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
9266 || *p == ',' || *p == '.' || *p == '@')
9267 p++;
9268 len = p - atom;
9269
9270 if (*p == '*')
9271 starred = true, p++;
9272
9273 SKIP_WHITE ();
9274
9275 if (!suffix)
9276 {
9277 /* Mark all matching switches as valid. */
9278 for (i = 0; i < n_switches; i++)
9279 if (!strncmp (switches[i].part1, atom, len)
9280 && (starred || switches[i].part1[len] == '\0')
9281 && (switches[i].known || user_spec))
9282 switches[i].validated = true;
9283 }
9284
9285 if (!braced)
9286 return p;
9287
9288 if (*p) p++;
9289 if (*p && (p[-1] == '|' || p[-1] == '&'))
9290 goto next_member;
9291
9292 if (*p && p[-1] == ':')
9293 {
9294 while (*p && *p != ';' && *p != '}')
9295 {
9296 if (*p == '%')
9297 {
9298 p++;
9299 if (*p == '{' || *p == '<')
9300 p = validate_switches (p+1, user_spec, *p == '{');
9301 else if (p[0] == 'W' && p[1] == '{')
9302 p = validate_switches (p+2, user_spec, true);
9303 else if (p[0] == '@' && p[1] == '{')
9304 p = validate_switches (p+2, user_spec, true);
9305 }
9306 else
9307 p++;
9308 }
9309
9310 if (*p) p++;
9311 if (*p && p[-1] == ';')
9312 goto next_member;
9313 }
9314
9315 return p;
9316 #undef SKIP_WHITE
9317 }
9318
9319 struct mdswitchstr
9320 {
9321 const char *str;
9322 int len;
9323 };
9324
9325 static struct mdswitchstr *mdswitches;
9326 static int n_mdswitches;
9327
9328 /* Check whether a particular argument was used. The first time we
9329 canonicalize the switches to keep only the ones we care about. */
9330
9331 struct used_arg_t
9332 {
9333 public:
9334 int operator () (const char *p, int len);
9335 void finalize ();
9336
9337 private:
9338 struct mswitchstr
9339 {
9340 const char *str;
9341 const char *replace;
9342 int len;
9343 int rep_len;
9344 };
9345
9346 mswitchstr *mswitches;
9347 int n_mswitches;
9348
9349 };
9350
9351 used_arg_t used_arg;
9352
9353 int
operator()9354 used_arg_t::operator () (const char *p, int len)
9355 {
9356 int i, j;
9357
9358 if (!mswitches)
9359 {
9360 struct mswitchstr *matches;
9361 const char *q;
9362 int cnt = 0;
9363
9364 /* Break multilib_matches into the component strings of string
9365 and replacement string. */
9366 for (q = multilib_matches; *q != '\0'; q++)
9367 if (*q == ';')
9368 cnt++;
9369
9370 matches
9371 = (struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt);
9372 i = 0;
9373 q = multilib_matches;
9374 while (*q != '\0')
9375 {
9376 matches[i].str = q;
9377 while (*q != ' ')
9378 {
9379 if (*q == '\0')
9380 {
9381 invalid_matches:
9382 fatal_error (input_location, "multilib spec %qs is invalid",
9383 multilib_matches);
9384 }
9385 q++;
9386 }
9387 matches[i].len = q - matches[i].str;
9388
9389 matches[i].replace = ++q;
9390 while (*q != ';' && *q != '\0')
9391 {
9392 if (*q == ' ')
9393 goto invalid_matches;
9394 q++;
9395 }
9396 matches[i].rep_len = q - matches[i].replace;
9397 i++;
9398 if (*q == ';')
9399 q++;
9400 }
9401
9402 /* Now build a list of the replacement string for switches that we care
9403 about. Make sure we allocate at least one entry. This prevents
9404 xmalloc from calling fatal, and prevents us from re-executing this
9405 block of code. */
9406 mswitches
9407 = XNEWVEC (struct mswitchstr, n_mdswitches + (n_switches ? n_switches : 1));
9408 for (i = 0; i < n_switches; i++)
9409 if ((switches[i].live_cond & SWITCH_IGNORE) == 0)
9410 {
9411 int xlen = strlen (switches[i].part1);
9412 for (j = 0; j < cnt; j++)
9413 if (xlen == matches[j].len
9414 && ! strncmp (switches[i].part1, matches[j].str, xlen))
9415 {
9416 mswitches[n_mswitches].str = matches[j].replace;
9417 mswitches[n_mswitches].len = matches[j].rep_len;
9418 mswitches[n_mswitches].replace = (char *) 0;
9419 mswitches[n_mswitches].rep_len = 0;
9420 n_mswitches++;
9421 break;
9422 }
9423 }
9424
9425 /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
9426 on the command line nor any options mutually incompatible with
9427 them. */
9428 for (i = 0; i < n_mdswitches; i++)
9429 {
9430 const char *r;
9431
9432 for (q = multilib_options; *q != '\0'; *q && q++)
9433 {
9434 while (*q == ' ')
9435 q++;
9436
9437 r = q;
9438 while (strncmp (q, mdswitches[i].str, mdswitches[i].len) != 0
9439 || strchr (" /", q[mdswitches[i].len]) == NULL)
9440 {
9441 while (*q != ' ' && *q != '/' && *q != '\0')
9442 q++;
9443 if (*q != '/')
9444 break;
9445 q++;
9446 }
9447
9448 if (*q != ' ' && *q != '\0')
9449 {
9450 while (*r != ' ' && *r != '\0')
9451 {
9452 q = r;
9453 while (*q != ' ' && *q != '/' && *q != '\0')
9454 q++;
9455
9456 if (used_arg (r, q - r))
9457 break;
9458
9459 if (*q != '/')
9460 {
9461 mswitches[n_mswitches].str = mdswitches[i].str;
9462 mswitches[n_mswitches].len = mdswitches[i].len;
9463 mswitches[n_mswitches].replace = (char *) 0;
9464 mswitches[n_mswitches].rep_len = 0;
9465 n_mswitches++;
9466 break;
9467 }
9468
9469 r = q + 1;
9470 }
9471 break;
9472 }
9473 }
9474 }
9475 }
9476
9477 for (i = 0; i < n_mswitches; i++)
9478 if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
9479 return 1;
9480
9481 return 0;
9482 }
9483
finalize()9484 void used_arg_t::finalize ()
9485 {
9486 XDELETEVEC (mswitches);
9487 mswitches = NULL;
9488 n_mswitches = 0;
9489 }
9490
9491
9492 static int
default_arg(const char * p,int len)9493 default_arg (const char *p, int len)
9494 {
9495 int i;
9496
9497 for (i = 0; i < n_mdswitches; i++)
9498 if (len == mdswitches[i].len && ! strncmp (p, mdswitches[i].str, len))
9499 return 1;
9500
9501 return 0;
9502 }
9503
9504 /* Work out the subdirectory to use based on the options. The format of
9505 multilib_select is a list of elements. Each element is a subdirectory
9506 name followed by a list of options followed by a semicolon. The format
9507 of multilib_exclusions is the same, but without the preceding
9508 directory. First gcc will check the exclusions, if none of the options
9509 beginning with an exclamation point are present, and all of the other
9510 options are present, then we will ignore this completely. Passing
9511 that, gcc will consider each multilib_select in turn using the same
9512 rules for matching the options. If a match is found, that subdirectory
9513 will be used.
9514 A subdirectory name is optionally followed by a colon and the corresponding
9515 multiarch name. */
9516
9517 static void
set_multilib_dir(void)9518 set_multilib_dir (void)
9519 {
9520 const char *p;
9521 unsigned int this_path_len;
9522 const char *this_path, *this_arg;
9523 const char *start, *end;
9524 int not_arg;
9525 int ok, ndfltok, first;
9526
9527 n_mdswitches = 0;
9528 start = multilib_defaults;
9529 while (*start == ' ' || *start == '\t')
9530 start++;
9531 while (*start != '\0')
9532 {
9533 n_mdswitches++;
9534 while (*start != ' ' && *start != '\t' && *start != '\0')
9535 start++;
9536 while (*start == ' ' || *start == '\t')
9537 start++;
9538 }
9539
9540 if (n_mdswitches)
9541 {
9542 int i = 0;
9543
9544 mdswitches = XNEWVEC (struct mdswitchstr, n_mdswitches);
9545 for (start = multilib_defaults; *start != '\0'; start = end + 1)
9546 {
9547 while (*start == ' ' || *start == '\t')
9548 start++;
9549
9550 if (*start == '\0')
9551 break;
9552
9553 for (end = start + 1;
9554 *end != ' ' && *end != '\t' && *end != '\0'; end++)
9555 ;
9556
9557 obstack_grow (&multilib_obstack, start, end - start);
9558 obstack_1grow (&multilib_obstack, 0);
9559 mdswitches[i].str = XOBFINISH (&multilib_obstack, const char *);
9560 mdswitches[i++].len = end - start;
9561
9562 if (*end == '\0')
9563 break;
9564 }
9565 }
9566
9567 p = multilib_exclusions;
9568 while (*p != '\0')
9569 {
9570 /* Ignore newlines. */
9571 if (*p == '\n')
9572 {
9573 ++p;
9574 continue;
9575 }
9576
9577 /* Check the arguments. */
9578 ok = 1;
9579 while (*p != ';')
9580 {
9581 if (*p == '\0')
9582 {
9583 invalid_exclusions:
9584 fatal_error (input_location, "multilib exclusions %qs is invalid",
9585 multilib_exclusions);
9586 }
9587
9588 if (! ok)
9589 {
9590 ++p;
9591 continue;
9592 }
9593
9594 this_arg = p;
9595 while (*p != ' ' && *p != ';')
9596 {
9597 if (*p == '\0')
9598 goto invalid_exclusions;
9599 ++p;
9600 }
9601
9602 if (*this_arg != '!')
9603 not_arg = 0;
9604 else
9605 {
9606 not_arg = 1;
9607 ++this_arg;
9608 }
9609
9610 ok = used_arg (this_arg, p - this_arg);
9611 if (not_arg)
9612 ok = ! ok;
9613
9614 if (*p == ' ')
9615 ++p;
9616 }
9617
9618 if (ok)
9619 return;
9620
9621 ++p;
9622 }
9623
9624 first = 1;
9625 p = multilib_select;
9626
9627 /* Append multilib reuse rules if any. With those rules, we can reuse
9628 one multilib for certain different options sets. */
9629 if (strlen (multilib_reuse) > 0)
9630 p = concat (p, multilib_reuse, NULL);
9631
9632 while (*p != '\0')
9633 {
9634 /* Ignore newlines. */
9635 if (*p == '\n')
9636 {
9637 ++p;
9638 continue;
9639 }
9640
9641 /* Get the initial path. */
9642 this_path = p;
9643 while (*p != ' ')
9644 {
9645 if (*p == '\0')
9646 {
9647 invalid_select:
9648 fatal_error (input_location, "multilib select %qs %qs is invalid",
9649 multilib_select, multilib_reuse);
9650 }
9651 ++p;
9652 }
9653 this_path_len = p - this_path;
9654
9655 /* Check the arguments. */
9656 ok = 1;
9657 ndfltok = 1;
9658 ++p;
9659 while (*p != ';')
9660 {
9661 if (*p == '\0')
9662 goto invalid_select;
9663
9664 if (! ok)
9665 {
9666 ++p;
9667 continue;
9668 }
9669
9670 this_arg = p;
9671 while (*p != ' ' && *p != ';')
9672 {
9673 if (*p == '\0')
9674 goto invalid_select;
9675 ++p;
9676 }
9677
9678 if (*this_arg != '!')
9679 not_arg = 0;
9680 else
9681 {
9682 not_arg = 1;
9683 ++this_arg;
9684 }
9685
9686 /* If this is a default argument, we can just ignore it.
9687 This is true even if this_arg begins with '!'. Beginning
9688 with '!' does not mean that this argument is necessarily
9689 inappropriate for this library: it merely means that
9690 there is a more specific library which uses this
9691 argument. If this argument is a default, we need not
9692 consider that more specific library. */
9693 ok = used_arg (this_arg, p - this_arg);
9694 if (not_arg)
9695 ok = ! ok;
9696
9697 if (! ok)
9698 ndfltok = 0;
9699
9700 if (default_arg (this_arg, p - this_arg))
9701 ok = 1;
9702
9703 if (*p == ' ')
9704 ++p;
9705 }
9706
9707 if (ok && first)
9708 {
9709 if (this_path_len != 1
9710 || this_path[0] != '.')
9711 {
9712 char *new_multilib_dir = XNEWVEC (char, this_path_len + 1);
9713 char *q;
9714
9715 strncpy (new_multilib_dir, this_path, this_path_len);
9716 new_multilib_dir[this_path_len] = '\0';
9717 q = strchr (new_multilib_dir, ':');
9718 if (q != NULL)
9719 *q = '\0';
9720 multilib_dir = new_multilib_dir;
9721 }
9722 first = 0;
9723 }
9724
9725 if (ndfltok)
9726 {
9727 const char *q = this_path, *end = this_path + this_path_len;
9728
9729 while (q < end && *q != ':')
9730 q++;
9731 if (q < end)
9732 {
9733 const char *q2 = q + 1, *ml_end = end;
9734 char *new_multilib_os_dir;
9735
9736 while (q2 < end && *q2 != ':')
9737 q2++;
9738 if (*q2 == ':')
9739 ml_end = q2;
9740 if (ml_end - q == 1)
9741 multilib_os_dir = xstrdup (".");
9742 else
9743 {
9744 new_multilib_os_dir = XNEWVEC (char, ml_end - q);
9745 memcpy (new_multilib_os_dir, q + 1, ml_end - q - 1);
9746 new_multilib_os_dir[ml_end - q - 1] = '\0';
9747 multilib_os_dir = new_multilib_os_dir;
9748 }
9749
9750 if (q2 < end && *q2 == ':')
9751 {
9752 char *new_multiarch_dir = XNEWVEC (char, end - q2);
9753 memcpy (new_multiarch_dir, q2 + 1, end - q2 - 1);
9754 new_multiarch_dir[end - q2 - 1] = '\0';
9755 multiarch_dir = new_multiarch_dir;
9756 }
9757 break;
9758 }
9759 }
9760
9761 ++p;
9762 }
9763
9764 if (multilib_dir == NULL && multilib_os_dir != NULL
9765 && strcmp (multilib_os_dir, ".") == 0)
9766 {
9767 free (CONST_CAST (char *, multilib_os_dir));
9768 multilib_os_dir = NULL;
9769 }
9770 else if (multilib_dir != NULL && multilib_os_dir == NULL)
9771 multilib_os_dir = multilib_dir;
9772 }
9773
9774 /* Print out the multiple library subdirectory selection
9775 information. This prints out a series of lines. Each line looks
9776 like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
9777 required. Only the desired options are printed out, the negative
9778 matches. The options are print without a leading dash. There are
9779 no spaces to make it easy to use the information in the shell.
9780 Each subdirectory is printed only once. This assumes the ordering
9781 generated by the genmultilib script. Also, we leave out ones that match
9782 the exclusions. */
9783
9784 static void
print_multilib_info(void)9785 print_multilib_info (void)
9786 {
9787 const char *p = multilib_select;
9788 const char *last_path = 0, *this_path;
9789 int skip;
9790 int not_arg;
9791 unsigned int last_path_len = 0;
9792
9793 while (*p != '\0')
9794 {
9795 skip = 0;
9796 /* Ignore newlines. */
9797 if (*p == '\n')
9798 {
9799 ++p;
9800 continue;
9801 }
9802
9803 /* Get the initial path. */
9804 this_path = p;
9805 while (*p != ' ')
9806 {
9807 if (*p == '\0')
9808 {
9809 invalid_select:
9810 fatal_error (input_location,
9811 "multilib select %qs is invalid", multilib_select);
9812 }
9813
9814 ++p;
9815 }
9816
9817 /* When --disable-multilib was used but target defines
9818 MULTILIB_OSDIRNAMES, entries starting with .: (and not starting
9819 with .:: for multiarch configurations) are there just to find
9820 multilib_os_dir, so skip them from output. */
9821 if (this_path[0] == '.' && this_path[1] == ':' && this_path[2] != ':')
9822 skip = 1;
9823
9824 /* Check for matches with the multilib_exclusions. We don't bother
9825 with the '!' in either list. If any of the exclusion rules match
9826 all of its options with the select rule, we skip it. */
9827 {
9828 const char *e = multilib_exclusions;
9829 const char *this_arg;
9830
9831 while (*e != '\0')
9832 {
9833 int m = 1;
9834 /* Ignore newlines. */
9835 if (*e == '\n')
9836 {
9837 ++e;
9838 continue;
9839 }
9840
9841 /* Check the arguments. */
9842 while (*e != ';')
9843 {
9844 const char *q;
9845 int mp = 0;
9846
9847 if (*e == '\0')
9848 {
9849 invalid_exclusion:
9850 fatal_error (input_location,
9851 "multilib exclusion %qs is invalid",
9852 multilib_exclusions);
9853 }
9854
9855 if (! m)
9856 {
9857 ++e;
9858 continue;
9859 }
9860
9861 this_arg = e;
9862
9863 while (*e != ' ' && *e != ';')
9864 {
9865 if (*e == '\0')
9866 goto invalid_exclusion;
9867 ++e;
9868 }
9869
9870 q = p + 1;
9871 while (*q != ';')
9872 {
9873 const char *arg;
9874 int len = e - this_arg;
9875
9876 if (*q == '\0')
9877 goto invalid_select;
9878
9879 arg = q;
9880
9881 while (*q != ' ' && *q != ';')
9882 {
9883 if (*q == '\0')
9884 goto invalid_select;
9885 ++q;
9886 }
9887
9888 if (! strncmp (arg, this_arg,
9889 (len < q - arg) ? q - arg : len)
9890 || default_arg (this_arg, e - this_arg))
9891 {
9892 mp = 1;
9893 break;
9894 }
9895
9896 if (*q == ' ')
9897 ++q;
9898 }
9899
9900 if (! mp)
9901 m = 0;
9902
9903 if (*e == ' ')
9904 ++e;
9905 }
9906
9907 if (m)
9908 {
9909 skip = 1;
9910 break;
9911 }
9912
9913 if (*e != '\0')
9914 ++e;
9915 }
9916 }
9917
9918 if (! skip)
9919 {
9920 /* If this is a duplicate, skip it. */
9921 skip = (last_path != 0
9922 && (unsigned int) (p - this_path) == last_path_len
9923 && ! filename_ncmp (last_path, this_path, last_path_len));
9924
9925 last_path = this_path;
9926 last_path_len = p - this_path;
9927 }
9928
9929 /* If all required arguments are default arguments, and no default
9930 arguments appear in the ! argument list, then we can skip it.
9931 We will already have printed a directory identical to this one
9932 which does not require that default argument. */
9933 if (! skip)
9934 {
9935 const char *q;
9936 bool default_arg_ok = false;
9937
9938 q = p + 1;
9939 while (*q != ';')
9940 {
9941 const char *arg;
9942
9943 if (*q == '\0')
9944 goto invalid_select;
9945
9946 if (*q == '!')
9947 {
9948 not_arg = 1;
9949 q++;
9950 }
9951 else
9952 not_arg = 0;
9953 arg = q;
9954
9955 while (*q != ' ' && *q != ';')
9956 {
9957 if (*q == '\0')
9958 goto invalid_select;
9959 ++q;
9960 }
9961
9962 if (default_arg (arg, q - arg))
9963 {
9964 /* Stop checking if any default arguments appeared in not
9965 list. */
9966 if (not_arg)
9967 {
9968 default_arg_ok = false;
9969 break;
9970 }
9971
9972 default_arg_ok = true;
9973 }
9974 else if (!not_arg)
9975 {
9976 /* Stop checking if any required argument is not provided by
9977 default arguments. */
9978 default_arg_ok = false;
9979 break;
9980 }
9981
9982 if (*q == ' ')
9983 ++q;
9984 }
9985
9986 /* Make sure all default argument is OK for this multi-lib set. */
9987 if (default_arg_ok)
9988 skip = 1;
9989 else
9990 skip = 0;
9991 }
9992
9993 if (! skip)
9994 {
9995 const char *p1;
9996
9997 for (p1 = last_path; p1 < p && *p1 != ':'; p1++)
9998 putchar (*p1);
9999 putchar (';');
10000 }
10001
10002 ++p;
10003 while (*p != ';')
10004 {
10005 int use_arg;
10006
10007 if (*p == '\0')
10008 goto invalid_select;
10009
10010 if (skip)
10011 {
10012 ++p;
10013 continue;
10014 }
10015
10016 use_arg = *p != '!';
10017
10018 if (use_arg)
10019 putchar ('@');
10020
10021 while (*p != ' ' && *p != ';')
10022 {
10023 if (*p == '\0')
10024 goto invalid_select;
10025 if (use_arg)
10026 putchar (*p);
10027 ++p;
10028 }
10029
10030 if (*p == ' ')
10031 ++p;
10032 }
10033
10034 if (! skip)
10035 {
10036 /* If there are extra options, print them now. */
10037 if (multilib_extra && *multilib_extra)
10038 {
10039 int print_at = TRUE;
10040 const char *q;
10041
10042 for (q = multilib_extra; *q != '\0'; q++)
10043 {
10044 if (*q == ' ')
10045 print_at = TRUE;
10046 else
10047 {
10048 if (print_at)
10049 putchar ('@');
10050 putchar (*q);
10051 print_at = FALSE;
10052 }
10053 }
10054 }
10055
10056 putchar ('\n');
10057 }
10058
10059 ++p;
10060 }
10061 }
10062
10063 /* getenv built-in spec function.
10064
10065 Returns the value of the environment variable given by its first argument,
10066 concatenated with the second argument. If the variable is not defined, a
10067 fatal error is issued unless such undefs are internally allowed, in which
10068 case the variable name prefixed by a '/' is used as the variable value.
10069
10070 The leading '/' allows using the result at a spot where a full path would
10071 normally be expected and when the actual value doesn't really matter since
10072 undef vars are allowed. */
10073
10074 static const char *
getenv_spec_function(int argc,const char ** argv)10075 getenv_spec_function (int argc, const char **argv)
10076 {
10077 const char *value;
10078 const char *varname;
10079
10080 char *result;
10081 char *ptr;
10082 size_t len;
10083
10084 if (argc != 2)
10085 return NULL;
10086
10087 varname = argv[0];
10088 value = env.get (varname);
10089
10090 /* If the variable isn't defined and this is allowed, craft our expected
10091 return value. Assume variable names used in specs strings don't contain
10092 any active spec character so don't need escaping. */
10093 if (!value && spec_undefvar_allowed)
10094 {
10095 result = XNEWVAR (char, strlen(varname) + 2);
10096 sprintf (result, "/%s", varname);
10097 return result;
10098 }
10099
10100 if (!value)
10101 fatal_error (input_location,
10102 "environment variable %qs not defined", varname);
10103
10104 /* We have to escape every character of the environment variable so
10105 they are not interpreted as active spec characters. A
10106 particularly painful case is when we are reading a variable
10107 holding a windows path complete with \ separators. */
10108 len = strlen (value) * 2 + strlen (argv[1]) + 1;
10109 result = XNEWVAR (char, len);
10110 for (ptr = result; *value; ptr += 2)
10111 {
10112 ptr[0] = '\\';
10113 ptr[1] = *value++;
10114 }
10115
10116 strcpy (ptr, argv[1]);
10117
10118 return result;
10119 }
10120
10121 /* if-exists built-in spec function.
10122
10123 Checks to see if the file specified by the absolute pathname in
10124 ARGS exists. Returns that pathname if found.
10125
10126 The usual use for this function is to check for a library file
10127 (whose name has been expanded with %s). */
10128
10129 static const char *
if_exists_spec_function(int argc,const char ** argv)10130 if_exists_spec_function (int argc, const char **argv)
10131 {
10132 /* Must have only one argument. */
10133 if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
10134 return argv[0];
10135
10136 return NULL;
10137 }
10138
10139 /* if-exists-else built-in spec function.
10140
10141 This is like if-exists, but takes an additional argument which
10142 is returned if the first argument does not exist. */
10143
10144 static const char *
if_exists_else_spec_function(int argc,const char ** argv)10145 if_exists_else_spec_function (int argc, const char **argv)
10146 {
10147 /* Must have exactly two arguments. */
10148 if (argc != 2)
10149 return NULL;
10150
10151 if (IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
10152 return argv[0];
10153
10154 return argv[1];
10155 }
10156
10157 /* if-exists-then-else built-in spec function.
10158
10159 Checks to see if the file specified by the absolute pathname in
10160 the first arg exists. Returns the second arg if so, otherwise returns
10161 the third arg if it is present. */
10162
10163 static const char *
if_exists_then_else_spec_function(int argc,const char ** argv)10164 if_exists_then_else_spec_function (int argc, const char **argv)
10165 {
10166
10167 /* Must have two or three arguments. */
10168 if (argc != 2 && argc != 3)
10169 return NULL;
10170
10171 if (IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
10172 return argv[1];
10173
10174 if (argc == 3)
10175 return argv[2];
10176
10177 return NULL;
10178 }
10179
10180 /* sanitize built-in spec function.
10181
10182 This returns non-NULL, if sanitizing address, thread or
10183 any of the undefined behavior sanitizers. */
10184
10185 static const char *
sanitize_spec_function(int argc,const char ** argv)10186 sanitize_spec_function (int argc, const char **argv)
10187 {
10188 if (argc != 1)
10189 return NULL;
10190
10191 if (strcmp (argv[0], "address") == 0)
10192 return (flag_sanitize & SANITIZE_USER_ADDRESS) ? "" : NULL;
10193 if (strcmp (argv[0], "hwaddress") == 0)
10194 return (flag_sanitize & SANITIZE_USER_HWADDRESS) ? "" : NULL;
10195 if (strcmp (argv[0], "kernel-address") == 0)
10196 return (flag_sanitize & SANITIZE_KERNEL_ADDRESS) ? "" : NULL;
10197 if (strcmp (argv[0], "kernel-hwaddress") == 0)
10198 return (flag_sanitize & SANITIZE_KERNEL_HWADDRESS) ? "" : NULL;
10199 if (strcmp (argv[0], "thread") == 0)
10200 return (flag_sanitize & SANITIZE_THREAD) ? "" : NULL;
10201 if (strcmp (argv[0], "undefined") == 0)
10202 return ((flag_sanitize
10203 & (SANITIZE_UNDEFINED | SANITIZE_UNDEFINED_NONDEFAULT))
10204 && !flag_sanitize_undefined_trap_on_error) ? "" : NULL;
10205 if (strcmp (argv[0], "leak") == 0)
10206 return ((flag_sanitize
10207 & (SANITIZE_ADDRESS | SANITIZE_LEAK | SANITIZE_THREAD))
10208 == SANITIZE_LEAK) ? "" : NULL;
10209 return NULL;
10210 }
10211
10212 /* replace-outfile built-in spec function.
10213
10214 This looks for the first argument in the outfiles array's name and
10215 replaces it with the second argument. */
10216
10217 static const char *
replace_outfile_spec_function(int argc,const char ** argv)10218 replace_outfile_spec_function (int argc, const char **argv)
10219 {
10220 int i;
10221 /* Must have exactly two arguments. */
10222 if (argc != 2)
10223 abort ();
10224
10225 for (i = 0; i < n_infiles; i++)
10226 {
10227 if (outfiles[i] && !filename_cmp (outfiles[i], argv[0]))
10228 outfiles[i] = xstrdup (argv[1]);
10229 }
10230 return NULL;
10231 }
10232
10233 /* remove-outfile built-in spec function.
10234 *
10235 * This looks for the first argument in the outfiles array's name and
10236 * removes it. */
10237
10238 static const char *
remove_outfile_spec_function(int argc,const char ** argv)10239 remove_outfile_spec_function (int argc, const char **argv)
10240 {
10241 int i;
10242 /* Must have exactly one argument. */
10243 if (argc != 1)
10244 abort ();
10245
10246 for (i = 0; i < n_infiles; i++)
10247 {
10248 if (outfiles[i] && !filename_cmp (outfiles[i], argv[0]))
10249 outfiles[i] = NULL;
10250 }
10251 return NULL;
10252 }
10253
10254 /* Given two version numbers, compares the two numbers.
10255 A version number must match the regular expression
10256 ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
10257 */
10258 static int
compare_version_strings(const char * v1,const char * v2)10259 compare_version_strings (const char *v1, const char *v2)
10260 {
10261 int rresult;
10262 regex_t r;
10263
10264 if (regcomp (&r, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
10265 REG_EXTENDED | REG_NOSUB) != 0)
10266 abort ();
10267 rresult = regexec (&r, v1, 0, NULL, 0);
10268 if (rresult == REG_NOMATCH)
10269 fatal_error (input_location, "invalid version number %qs", v1);
10270 else if (rresult != 0)
10271 abort ();
10272 rresult = regexec (&r, v2, 0, NULL, 0);
10273 if (rresult == REG_NOMATCH)
10274 fatal_error (input_location, "invalid version number %qs", v2);
10275 else if (rresult != 0)
10276 abort ();
10277
10278 return strverscmp (v1, v2);
10279 }
10280
10281
10282 /* version_compare built-in spec function.
10283
10284 This takes an argument of the following form:
10285
10286 <comparison-op> <arg1> [<arg2>] <switch> <result>
10287
10288 and produces "result" if the comparison evaluates to true,
10289 and nothing if it doesn't.
10290
10291 The supported <comparison-op> values are:
10292
10293 >= true if switch is a later (or same) version than arg1
10294 !> opposite of >=
10295 < true if switch is an earlier version than arg1
10296 !< opposite of <
10297 >< true if switch is arg1 or later, and earlier than arg2
10298 <> true if switch is earlier than arg1 or is arg2 or later
10299
10300 If the switch is not present, the condition is false unless
10301 the first character of the <comparison-op> is '!'.
10302
10303 For example,
10304 %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
10305 adds -lmx if -mmacosx-version-min=10.3.9 was passed. */
10306
10307 static const char *
version_compare_spec_function(int argc,const char ** argv)10308 version_compare_spec_function (int argc, const char **argv)
10309 {
10310 int comp1, comp2;
10311 size_t switch_len;
10312 const char *switch_value = NULL;
10313 int nargs = 1, i;
10314 bool result;
10315
10316 if (argc < 3)
10317 fatal_error (input_location, "too few arguments to %%:version-compare");
10318 if (argv[0][0] == '\0')
10319 abort ();
10320 if ((argv[0][1] == '<' || argv[0][1] == '>') && argv[0][0] != '!')
10321 nargs = 2;
10322 if (argc != nargs + 3)
10323 fatal_error (input_location, "too many arguments to %%:version-compare");
10324
10325 switch_len = strlen (argv[nargs + 1]);
10326 for (i = 0; i < n_switches; i++)
10327 if (!strncmp (switches[i].part1, argv[nargs + 1], switch_len)
10328 && check_live_switch (i, switch_len))
10329 switch_value = switches[i].part1 + switch_len;
10330
10331 if (switch_value == NULL)
10332 comp1 = comp2 = -1;
10333 else
10334 {
10335 comp1 = compare_version_strings (switch_value, argv[1]);
10336 if (nargs == 2)
10337 comp2 = compare_version_strings (switch_value, argv[2]);
10338 else
10339 comp2 = -1; /* This value unused. */
10340 }
10341
10342 switch (argv[0][0] << 8 | argv[0][1])
10343 {
10344 case '>' << 8 | '=':
10345 result = comp1 >= 0;
10346 break;
10347 case '!' << 8 | '<':
10348 result = comp1 >= 0 || switch_value == NULL;
10349 break;
10350 case '<' << 8:
10351 result = comp1 < 0;
10352 break;
10353 case '!' << 8 | '>':
10354 result = comp1 < 0 || switch_value == NULL;
10355 break;
10356 case '>' << 8 | '<':
10357 result = comp1 >= 0 && comp2 < 0;
10358 break;
10359 case '<' << 8 | '>':
10360 result = comp1 < 0 || comp2 >= 0;
10361 break;
10362
10363 default:
10364 fatal_error (input_location,
10365 "unknown operator %qs in %%:version-compare", argv[0]);
10366 }
10367 if (! result)
10368 return NULL;
10369
10370 return argv[nargs + 2];
10371 }
10372
10373 /* %:include builtin spec function. This differs from %include in that it
10374 can be nested inside a spec, and thus be conditionalized. It takes
10375 one argument, the filename, and looks for it in the startfile path.
10376 The result is always NULL, i.e. an empty expansion. */
10377
10378 static const char *
include_spec_function(int argc,const char ** argv)10379 include_spec_function (int argc, const char **argv)
10380 {
10381 char *file;
10382
10383 if (argc != 1)
10384 abort ();
10385
10386 file = find_a_file (&startfile_prefixes, argv[0], R_OK, true);
10387 read_specs (file ? file : argv[0], false, false);
10388
10389 return NULL;
10390 }
10391
10392 /* %:find-file spec function. This function replaces its argument by
10393 the file found through find_file, that is the -print-file-name gcc
10394 program option. */
10395 static const char *
find_file_spec_function(int argc,const char ** argv)10396 find_file_spec_function (int argc, const char **argv)
10397 {
10398 const char *file;
10399
10400 if (argc != 1)
10401 abort ();
10402
10403 file = find_file (argv[0]);
10404 return file;
10405 }
10406
10407
10408 /* %:find-plugindir spec function. This function replaces its argument
10409 by the -iplugindir=<dir> option. `dir' is found through find_file, that
10410 is the -print-file-name gcc program option. */
10411 static const char *
find_plugindir_spec_function(int argc,const char ** argv ATTRIBUTE_UNUSED)10412 find_plugindir_spec_function (int argc, const char **argv ATTRIBUTE_UNUSED)
10413 {
10414 const char *option;
10415
10416 if (argc != 0)
10417 abort ();
10418
10419 option = concat ("-iplugindir=", find_file ("plugin"), NULL);
10420 return option;
10421 }
10422
10423
10424 /* %:print-asm-header spec function. Print a banner to say that the
10425 following output is from the assembler. */
10426
10427 static const char *
print_asm_header_spec_function(int arg ATTRIBUTE_UNUSED,const char ** argv ATTRIBUTE_UNUSED)10428 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED,
10429 const char **argv ATTRIBUTE_UNUSED)
10430 {
10431 printf (_("Assembler options\n=================\n\n"));
10432 printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
10433 fflush (stdout);
10434 return NULL;
10435 }
10436
10437 /* Get a random number for -frandom-seed */
10438
10439 static unsigned HOST_WIDE_INT
get_random_number(void)10440 get_random_number (void)
10441 {
10442 unsigned HOST_WIDE_INT ret = 0;
10443 int fd;
10444
10445 fd = open ("/dev/urandom", O_RDONLY);
10446 if (fd >= 0)
10447 {
10448 read (fd, &ret, sizeof (HOST_WIDE_INT));
10449 close (fd);
10450 if (ret)
10451 return ret;
10452 }
10453
10454 /* Get some more or less random data. */
10455 #ifdef HAVE_GETTIMEOFDAY
10456 {
10457 struct timeval tv;
10458
10459 gettimeofday (&tv, NULL);
10460 ret = tv.tv_sec * 1000 + tv.tv_usec / 1000;
10461 }
10462 #else
10463 {
10464 time_t now = time (NULL);
10465
10466 if (now != (time_t)-1)
10467 ret = (unsigned) now;
10468 }
10469 #endif
10470
10471 return ret ^ getpid ();
10472 }
10473
10474 /* %:compare-debug-dump-opt spec function. Save the last argument,
10475 expected to be the last -fdump-final-insns option, or generate a
10476 temporary. */
10477
10478 static const char *
compare_debug_dump_opt_spec_function(int arg,const char ** argv ATTRIBUTE_UNUSED)10479 compare_debug_dump_opt_spec_function (int arg,
10480 const char **argv ATTRIBUTE_UNUSED)
10481 {
10482 char *ret;
10483 char *name;
10484 int which;
10485 static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];
10486
10487 if (arg != 0)
10488 fatal_error (input_location,
10489 "too many arguments to %%:compare-debug-dump-opt");
10490
10491 do_spec_2 ("%{fdump-final-insns=*:%*}", NULL);
10492 do_spec_1 (" ", 0, NULL);
10493
10494 if (argbuf.length () > 0
10495 && strcmp (argv[argbuf.length () - 1], ".") != 0)
10496 {
10497 if (!compare_debug)
10498 return NULL;
10499
10500 name = xstrdup (argv[argbuf.length () - 1]);
10501 ret = NULL;
10502 }
10503 else
10504 {
10505 if (argbuf.length () > 0)
10506 do_spec_2 ("%B.gkd", NULL);
10507 else if (!compare_debug)
10508 return NULL;
10509 else
10510 do_spec_2 ("%{!save-temps*:%g.gkd}%{save-temps*:%B.gkd}", NULL);
10511
10512 do_spec_1 (" ", 0, NULL);
10513
10514 gcc_assert (argbuf.length () > 0);
10515
10516 name = xstrdup (argbuf.last ());
10517
10518 char *arg = quote_spec (xstrdup (name));
10519 ret = concat ("-fdump-final-insns=", arg, NULL);
10520 free (arg);
10521 }
10522
10523 which = compare_debug < 0;
10524 debug_check_temp_file[which] = name;
10525
10526 if (!which)
10527 {
10528 unsigned HOST_WIDE_INT value = get_random_number ();
10529
10530 sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value);
10531 }
10532
10533 if (*random_seed)
10534 {
10535 char *tmp = ret;
10536 ret = concat ("%{!frandom-seed=*:-frandom-seed=", random_seed, "} ",
10537 ret, NULL);
10538 free (tmp);
10539 }
10540
10541 if (which)
10542 *random_seed = 0;
10543
10544 return ret;
10545 }
10546
10547 /* %:compare-debug-self-opt spec function. Expands to the options
10548 that are to be passed in the second compilation of
10549 compare-debug. */
10550
10551 static const char *
compare_debug_self_opt_spec_function(int arg,const char ** argv ATTRIBUTE_UNUSED)10552 compare_debug_self_opt_spec_function (int arg,
10553 const char **argv ATTRIBUTE_UNUSED)
10554 {
10555 if (arg != 0)
10556 fatal_error (input_location,
10557 "too many arguments to %%:compare-debug-self-opt");
10558
10559 if (compare_debug >= 0)
10560 return NULL;
10561
10562 return concat ("\
10563 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
10564 %<fdump-final-insns=* -w -S -o %j \
10565 %{!fcompare-debug-second:-fcompare-debug-second} \
10566 ", compare_debug_opt, NULL);
10567 }
10568
10569 /* %:pass-through-libs spec function. Finds all -l options and input
10570 file names in the lib spec passed to it, and makes a list of them
10571 prepended with the plugin option to cause them to be passed through
10572 to the final link after all the new object files have been added. */
10573
10574 const char *
pass_through_libs_spec_func(int argc,const char ** argv)10575 pass_through_libs_spec_func (int argc, const char **argv)
10576 {
10577 char *prepended = xstrdup (" ");
10578 int n;
10579 /* Shlemiel the painter's algorithm. Innately horrible, but at least
10580 we know that there will never be more than a handful of strings to
10581 concat, and it's only once per run, so it's not worth optimising. */
10582 for (n = 0; n < argc; n++)
10583 {
10584 char *old = prepended;
10585 /* Anything that isn't an option is a full path to an output
10586 file; pass it through if it ends in '.a'. Among options,
10587 pass only -l. */
10588 if (argv[n][0] == '-' && argv[n][1] == 'l')
10589 {
10590 const char *lopt = argv[n] + 2;
10591 /* Handle both joined and non-joined -l options. If for any
10592 reason there's a trailing -l with no joined or following
10593 arg just discard it. */
10594 if (!*lopt && ++n >= argc)
10595 break;
10596 else if (!*lopt)
10597 lopt = argv[n];
10598 prepended = concat (prepended, "-plugin-opt=-pass-through=-l",
10599 lopt, " ", NULL);
10600 }
10601 else if (!strcmp (".a", argv[n] + strlen (argv[n]) - 2))
10602 {
10603 prepended = concat (prepended, "-plugin-opt=-pass-through=",
10604 argv[n], " ", NULL);
10605 }
10606 if (prepended != old)
10607 free (old);
10608 }
10609 return prepended;
10610 }
10611
10612 static bool
not_actual_file_p(const char * name)10613 not_actual_file_p (const char *name)
10614 {
10615 return (strcmp (name, "-") == 0
10616 || strcmp (name, HOST_BIT_BUCKET) == 0);
10617 }
10618
10619 /* %:dumps spec function. Take an optional argument that overrides
10620 the default extension for -dumpbase and -dumpbase-ext.
10621 Return -dumpdir, -dumpbase and -dumpbase-ext, if needed. */
10622 const char *
dumps_spec_func(int argc,const char ** argv ATTRIBUTE_UNUSED)10623 dumps_spec_func (int argc, const char **argv ATTRIBUTE_UNUSED)
10624 {
10625 const char *ext = dumpbase_ext;
10626 char *p;
10627
10628 char *args[3] = { NULL, NULL, NULL };
10629 int nargs = 0;
10630
10631 /* Do not compute a default for -dumpbase-ext when -dumpbase was
10632 given explicitly. */
10633 if (dumpbase && *dumpbase && !ext)
10634 ext = "";
10635
10636 if (argc == 1)
10637 {
10638 /* Do not override the explicitly-specified -dumpbase-ext with
10639 the specs-provided overrider. */
10640 if (!ext)
10641 ext = argv[0];
10642 }
10643 else if (argc != 0)
10644 fatal_error (input_location, "too many arguments for %%:dumps");
10645
10646 if (dumpdir)
10647 {
10648 p = quote_spec_arg (xstrdup (dumpdir));
10649 args[nargs++] = concat (" -dumpdir ", p, NULL);
10650 free (p);
10651 }
10652
10653 if (!ext)
10654 ext = input_basename + basename_length;
10655
10656 /* Use the precomputed outbase, or compute dumpbase from
10657 input_basename, just like %b would. */
10658 char *base;
10659
10660 if (dumpbase && *dumpbase)
10661 {
10662 base = xstrdup (dumpbase);
10663 p = base + outbase_length;
10664 gcc_checking_assert (strncmp (base, outbase, outbase_length) == 0);
10665 gcc_checking_assert (strcmp (p, ext) == 0);
10666 }
10667 else if (outbase_length)
10668 {
10669 base = xstrndup (outbase, outbase_length);
10670 p = NULL;
10671 }
10672 else
10673 {
10674 base = xstrndup (input_basename, suffixed_basename_length);
10675 p = base + basename_length;
10676 }
10677
10678 if (compare_debug < 0 || !p || strcmp (p, ext) != 0)
10679 {
10680 if (p)
10681 *p = '\0';
10682
10683 const char *gk;
10684 if (compare_debug < 0)
10685 gk = ".gk";
10686 else
10687 gk = "";
10688
10689 p = concat (base, gk, ext, NULL);
10690
10691 free (base);
10692 base = p;
10693 }
10694
10695 base = quote_spec_arg (base);
10696 args[nargs++] = concat (" -dumpbase ", base, NULL);
10697 free (base);
10698
10699 if (*ext)
10700 {
10701 p = quote_spec_arg (xstrdup (ext));
10702 args[nargs++] = concat (" -dumpbase-ext ", p, NULL);
10703 free (p);
10704 }
10705
10706 const char *ret = concat (args[0], args[1], args[2], NULL);
10707 while (nargs > 0)
10708 free (args[--nargs]);
10709
10710 return ret;
10711 }
10712
10713 /* Returns "" if ARGV[ARGC - 2] is greater than ARGV[ARGC-1].
10714 Otherwise, return NULL. */
10715
10716 static const char *
greater_than_spec_func(int argc,const char ** argv)10717 greater_than_spec_func (int argc, const char **argv)
10718 {
10719 char *converted;
10720
10721 if (argc == 1)
10722 return NULL;
10723
10724 gcc_assert (argc >= 2);
10725
10726 long arg = strtol (argv[argc - 2], &converted, 10);
10727 gcc_assert (converted != argv[argc - 2]);
10728
10729 long lim = strtol (argv[argc - 1], &converted, 10);
10730 gcc_assert (converted != argv[argc - 1]);
10731
10732 if (arg > lim)
10733 return "";
10734
10735 return NULL;
10736 }
10737
10738 /* Returns "" if debug_info_level is greater than ARGV[ARGC-1].
10739 Otherwise, return NULL. */
10740
10741 static const char *
debug_level_greater_than_spec_func(int argc,const char ** argv)10742 debug_level_greater_than_spec_func (int argc, const char **argv)
10743 {
10744 char *converted;
10745
10746 if (argc != 1)
10747 fatal_error (input_location,
10748 "wrong number of arguments to %%:debug-level-gt");
10749
10750 long arg = strtol (argv[0], &converted, 10);
10751 gcc_assert (converted != argv[0]);
10752
10753 if (debug_info_level > arg)
10754 return "";
10755
10756 return NULL;
10757 }
10758
10759 /* Returns "" if dwarf_version is greater than ARGV[ARGC-1].
10760 Otherwise, return NULL. */
10761
10762 static const char *
dwarf_version_greater_than_spec_func(int argc,const char ** argv)10763 dwarf_version_greater_than_spec_func (int argc, const char **argv)
10764 {
10765 char *converted;
10766
10767 if (argc != 1)
10768 fatal_error (input_location,
10769 "wrong number of arguments to %%:dwarf-version-gt");
10770
10771 long arg = strtol (argv[0], &converted, 10);
10772 gcc_assert (converted != argv[0]);
10773
10774 if (dwarf_version > arg)
10775 return "";
10776
10777 return NULL;
10778 }
10779
10780 static void
path_prefix_reset(path_prefix * prefix)10781 path_prefix_reset (path_prefix *prefix)
10782 {
10783 struct prefix_list *iter, *next;
10784 iter = prefix->plist;
10785 while (iter)
10786 {
10787 next = iter->next;
10788 free (const_cast <char *> (iter->prefix));
10789 XDELETE (iter);
10790 iter = next;
10791 }
10792 prefix->plist = 0;
10793 prefix->max_len = 0;
10794 }
10795
10796 /* The function takes 3 arguments: OPTION name, file name and location
10797 where we search for Fortran modules.
10798 When the FILE is found by find_file, return OPTION=path_to_file. */
10799
10800 static const char *
find_fortran_preinclude_file(int argc,const char ** argv)10801 find_fortran_preinclude_file (int argc, const char **argv)
10802 {
10803 char *result = NULL;
10804 if (argc != 3)
10805 return NULL;
10806
10807 struct path_prefix prefixes = { 0, 0, "preinclude" };
10808
10809 /* Search first for 'finclude' folder location for a header file
10810 installed by the compiler (similar to omp_lib.h). */
10811 add_prefix (&prefixes, argv[2], NULL, 0, 0, 0);
10812 #ifdef TOOL_INCLUDE_DIR
10813 /* Then search: <prefix>/<target>/<include>/finclude */
10814 add_prefix (&prefixes, TOOL_INCLUDE_DIR "/finclude/",
10815 NULL, 0, 0, 0);
10816 #endif
10817 #ifdef NATIVE_SYSTEM_HEADER_DIR
10818 /* Then search: <sysroot>/usr/include/finclude/<multilib> */
10819 add_sysrooted_hdrs_prefix (&prefixes, NATIVE_SYSTEM_HEADER_DIR "/finclude/",
10820 NULL, 0, 0, 0);
10821 #endif
10822
10823 const char *path = find_a_file (&include_prefixes, argv[1], R_OK, false);
10824 if (path != NULL)
10825 result = concat (argv[0], path, NULL);
10826 else
10827 {
10828 path = find_a_file (&prefixes, argv[1], R_OK, false);
10829 if (path != NULL)
10830 result = concat (argv[0], path, NULL);
10831 }
10832
10833 path_prefix_reset (&prefixes);
10834 return result;
10835 }
10836
10837 /* If any character in ORIG fits QUOTE_P (_, P), reallocate the string
10838 so as to precede every one of them with a backslash. Return the
10839 original string or the reallocated one. */
10840
10841 static inline char *
quote_string(char * orig,bool (* quote_p)(char,void *),void * p)10842 quote_string (char *orig, bool (*quote_p)(char, void *), void *p)
10843 {
10844 int len, number_of_space = 0;
10845
10846 for (len = 0; orig[len]; len++)
10847 if (quote_p (orig[len], p))
10848 number_of_space++;
10849
10850 if (number_of_space)
10851 {
10852 char *new_spec = (char *) xmalloc (len + number_of_space + 1);
10853 int j, k;
10854 for (j = 0, k = 0; j <= len; j++, k++)
10855 {
10856 if (quote_p (orig[j], p))
10857 new_spec[k++] = '\\';
10858 new_spec[k] = orig[j];
10859 }
10860 free (orig);
10861 return new_spec;
10862 }
10863 else
10864 return orig;
10865 }
10866
10867 /* Return true iff C is any of the characters convert_white_space
10868 should quote. */
10869
10870 static inline bool
whitespace_to_convert_p(char c,void *)10871 whitespace_to_convert_p (char c, void *)
10872 {
10873 return (c == ' ' || c == '\t');
10874 }
10875
10876 /* Insert backslash before spaces in ORIG (usually a file path), to
10877 avoid being broken by spec parser.
10878
10879 This function is needed as do_spec_1 treats white space (' ' and '\t')
10880 as the end of an argument. But in case of -plugin /usr/gcc install/xxx.so,
10881 the file name should be treated as a single argument rather than being
10882 broken into multiple. Solution is to insert '\\' before the space in a
10883 file name.
10884
10885 This function converts and only converts all occurrence of ' '
10886 to '\\' + ' ' and '\t' to '\\' + '\t'. For example:
10887 "a b" -> "a\\ b"
10888 "a b" -> "a\\ \\ b"
10889 "a\tb" -> "a\\\tb"
10890 "a\\ b" -> "a\\\\ b"
10891
10892 orig: input null-terminating string that was allocated by xalloc. The
10893 memory it points to might be freed in this function. Behavior undefined
10894 if ORIG wasn't xalloced or was freed already at entry.
10895
10896 Return: ORIG if no conversion needed. Otherwise a newly allocated string
10897 that was converted from ORIG. */
10898
10899 static char *
convert_white_space(char * orig)10900 convert_white_space (char *orig)
10901 {
10902 return quote_string (orig, whitespace_to_convert_p, NULL);
10903 }
10904
10905 /* Return true iff C matches any of the spec active characters. */
10906 static inline bool
quote_spec_char_p(char c,void *)10907 quote_spec_char_p (char c, void *)
10908 {
10909 switch (c)
10910 {
10911 case ' ':
10912 case '\t':
10913 case '\n':
10914 case '|':
10915 case '%':
10916 case '\\':
10917 return true;
10918
10919 default:
10920 return false;
10921 }
10922 }
10923
10924 /* Like convert_white_space, but deactivate all active spec chars by
10925 quoting them. */
10926
10927 static inline char *
quote_spec(char * orig)10928 quote_spec (char *orig)
10929 {
10930 return quote_string (orig, quote_spec_char_p, NULL);
10931 }
10932
10933 /* Like quote_spec, but also turn an empty string into the spec for an
10934 empty argument. */
10935
10936 static inline char *
quote_spec_arg(char * orig)10937 quote_spec_arg (char *orig)
10938 {
10939 if (!*orig)
10940 {
10941 free (orig);
10942 return xstrdup ("%\"");
10943 }
10944
10945 return quote_spec (orig);
10946 }
10947
10948 /* Restore all state within gcc.c to the initial state, so that the driver
10949 code can be safely re-run in-process.
10950
10951 Many const char * variables are referenced by static specs (see
10952 INIT_STATIC_SPEC above). These variables are restored to their default
10953 values by a simple loop over the static specs.
10954
10955 For other variables, we directly restore them all to their initial
10956 values (often implicitly 0).
10957
10958 Free the various obstacks in this file, along with "opts_obstack"
10959 from opts.c.
10960
10961 This function also restores any environment variables that were changed. */
10962
10963 void
finalize()10964 driver::finalize ()
10965 {
10966 env.restore ();
10967 diagnostic_finish (global_dc);
10968
10969 is_cpp_driver = 0;
10970 at_file_supplied = 0;
10971 print_help_list = 0;
10972 print_version = 0;
10973 verbose_only_flag = 0;
10974 print_subprocess_help = 0;
10975 use_ld = NULL;
10976 report_times_to_file = NULL;
10977 target_system_root = DEFAULT_TARGET_SYSTEM_ROOT;
10978 target_system_root_changed = 0;
10979 target_sysroot_suffix = 0;
10980 target_sysroot_hdrs_suffix = 0;
10981 save_temps_flag = SAVE_TEMPS_NONE;
10982 save_temps_overrides_dumpdir = false;
10983 dumpdir_trailing_dash_added = false;
10984 free (dumpdir);
10985 free (dumpbase);
10986 free (dumpbase_ext);
10987 free (outbase);
10988 dumpdir = dumpbase = dumpbase_ext = outbase = NULL;
10989 dumpdir_length = outbase_length = 0;
10990 spec_machine = DEFAULT_TARGET_MACHINE;
10991 greatest_status = 1;
10992
10993 obstack_free (&obstack, NULL);
10994 obstack_free (&opts_obstack, NULL); /* in opts.c */
10995 obstack_free (&collect_obstack, NULL);
10996
10997 link_command_spec = LINK_COMMAND_SPEC;
10998
10999 obstack_free (&multilib_obstack, NULL);
11000
11001 user_specs_head = NULL;
11002 user_specs_tail = NULL;
11003
11004 /* Within the "compilers" vec, the fields "suffix" and "spec" were
11005 statically allocated for the default compilers, but dynamically
11006 allocated for additional compilers. Delete them for the latter. */
11007 for (int i = n_default_compilers; i < n_compilers; i++)
11008 {
11009 free (const_cast <char *> (compilers[i].suffix));
11010 free (const_cast <char *> (compilers[i].spec));
11011 }
11012 XDELETEVEC (compilers);
11013 compilers = NULL;
11014 n_compilers = 0;
11015
11016 linker_options.truncate (0);
11017 assembler_options.truncate (0);
11018 preprocessor_options.truncate (0);
11019
11020 path_prefix_reset (&exec_prefixes);
11021 path_prefix_reset (&startfile_prefixes);
11022 path_prefix_reset (&include_prefixes);
11023
11024 machine_suffix = 0;
11025 just_machine_suffix = 0;
11026 gcc_exec_prefix = 0;
11027 gcc_libexec_prefix = 0;
11028 set_static_spec_shared (&md_exec_prefix, MD_EXEC_PREFIX);
11029 set_static_spec_shared (&md_startfile_prefix, MD_STARTFILE_PREFIX);
11030 set_static_spec_shared (&md_startfile_prefix_1, MD_STARTFILE_PREFIX_1);
11031 multilib_dir = 0;
11032 multilib_os_dir = 0;
11033 multiarch_dir = 0;
11034
11035 /* Free any specs dynamically-allocated by set_spec.
11036 These will be at the head of the list, before the
11037 statically-allocated ones. */
11038 if (specs)
11039 {
11040 while (specs != static_specs)
11041 {
11042 spec_list *next = specs->next;
11043 free (const_cast <char *> (specs->name));
11044 XDELETE (specs);
11045 specs = next;
11046 }
11047 specs = 0;
11048 }
11049 for (unsigned i = 0; i < ARRAY_SIZE (static_specs); i++)
11050 {
11051 spec_list *sl = &static_specs[i];
11052 if (sl->alloc_p)
11053 {
11054 free (const_cast <char *> (*(sl->ptr_spec)));
11055 sl->alloc_p = false;
11056 }
11057 *(sl->ptr_spec) = sl->default_ptr;
11058 }
11059 #ifdef EXTRA_SPECS
11060 extra_specs = NULL;
11061 #endif
11062
11063 processing_spec_function = 0;
11064
11065 clear_args ();
11066
11067 have_c = 0;
11068 have_o = 0;
11069
11070 temp_names = NULL;
11071 execution_count = 0;
11072 signal_count = 0;
11073
11074 temp_filename = NULL;
11075 temp_filename_length = 0;
11076 always_delete_queue = NULL;
11077 failure_delete_queue = NULL;
11078
11079 XDELETEVEC (switches);
11080 switches = NULL;
11081 n_switches = 0;
11082 n_switches_alloc = 0;
11083
11084 compare_debug = 0;
11085 compare_debug_second = 0;
11086 compare_debug_opt = NULL;
11087 for (int i = 0; i < 2; i++)
11088 {
11089 switches_debug_check[i] = NULL;
11090 n_switches_debug_check[i] = 0;
11091 n_switches_alloc_debug_check[i] = 0;
11092 debug_check_temp_file[i] = NULL;
11093 }
11094
11095 XDELETEVEC (infiles);
11096 infiles = NULL;
11097 n_infiles = 0;
11098 n_infiles_alloc = 0;
11099
11100 combine_inputs = false;
11101 added_libraries = 0;
11102 XDELETEVEC (outfiles);
11103 outfiles = NULL;
11104 spec_lang = 0;
11105 last_language_n_infiles = 0;
11106 gcc_input_filename = NULL;
11107 input_file_number = 0;
11108 input_filename_length = 0;
11109 basename_length = 0;
11110 suffixed_basename_length = 0;
11111 input_basename = NULL;
11112 input_suffix = NULL;
11113 /* We don't need to purge "input_stat", just to unset "input_stat_set". */
11114 input_stat_set = 0;
11115 input_file_compiler = NULL;
11116 arg_going = 0;
11117 delete_this_arg = 0;
11118 this_is_output_file = 0;
11119 this_is_library_file = 0;
11120 this_is_linker_script = 0;
11121 input_from_pipe = 0;
11122 suffix_subst = NULL;
11123
11124 mdswitches = NULL;
11125 n_mdswitches = 0;
11126
11127 used_arg.finalize ();
11128 }
11129
11130 /* PR jit/64810.
11131 Targets can provide configure-time default options in
11132 OPTION_DEFAULT_SPECS. The jit needs to access these, but
11133 they are expressed in the spec language.
11134
11135 Run just enough of the driver to be able to expand these
11136 specs, and then call the callback CB on each
11137 such option. The options strings are *without* a leading
11138 '-' character e.g. ("march=x86-64"). Finally, clean up. */
11139
11140 void
driver_get_configure_time_options(void (* cb)(const char * option,void * user_data),void * user_data)11141 driver_get_configure_time_options (void (*cb) (const char *option,
11142 void *user_data),
11143 void *user_data)
11144 {
11145 size_t i;
11146
11147 obstack_init (&obstack);
11148 init_opts_obstack ();
11149 n_switches = 0;
11150
11151 for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
11152 do_option_spec (option_default_specs[i].name,
11153 option_default_specs[i].spec);
11154
11155 for (i = 0; (int) i < n_switches; i++)
11156 {
11157 gcc_assert (switches[i].part1);
11158 (*cb) (switches[i].part1, user_data);
11159 }
11160
11161 obstack_free (&opts_obstack, NULL);
11162 obstack_free (&obstack, NULL);
11163 n_switches = 0;
11164 }
11165