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