gcc/gcc.c

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