gcc/gcc.c

   1 /* Compiler driver program that can handle many languages.
   2    Copyright (C) 1987-2013 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 /* Whether we should report subprocess execution times to a file.  */
 109
 110 FILE *report_times_to_file = NULL;
 111
 112 /* Nonzero means place this string before uses of /, so that include
 113    and library files can be found in an alternate location.  */
 114
 115 #ifdef TARGET_SYSTEM_ROOT
 116 static const char *target_system_root = TARGET_SYSTEM_ROOT;
 117 #else
 118 static const char *target_system_root = 0;
 119 #endif
 120
 121 /* Nonzero means pass the updated target_system_root to the compiler.  */
 122
 123 static int target_system_root_changed;
 124
 125 /* Nonzero means append this string to target_system_root.  */
 126
 127 static const char *target_sysroot_suffix = 0;
 128
 129 /* Nonzero means append this string to target_system_root for headers.  */
 130
 131 static const char *target_sysroot_hdrs_suffix = 0;
 132
 133 /* Nonzero means write "temp" files in source directory
 134    and use the source file's name in them, and don't delete them.  */
 135
 136 static enum save_temps {
 137   SAVE_TEMPS_NONE,              /* no -save-temps */
 138   SAVE_TEMPS_CWD,               /* -save-temps in current directory */
 139   SAVE_TEMPS_OBJ                /* -save-temps in object directory */
 140 } save_temps_flag;
 141
 142 /* Output file to use to get the object directory for -save-temps=obj  */
 143 static char *save_temps_prefix = 0;
 144 static size_t save_temps_length = 0;
 145
 146 /* The compiler version.  */
 147
 148 static const char *compiler_version;
 149
 150 /* The target version.  */
 151
 152 static const char *const spec_version = DEFAULT_TARGET_VERSION;
 153
 154 /* The target machine.  */
 155
 156 static const char *spec_machine = DEFAULT_TARGET_MACHINE;
 157
 158 /* Nonzero if cross-compiling.
 159    When -b is used, the value comes from the `specs' file.  */
 160
 161 #ifdef CROSS_DIRECTORY_STRUCTURE
 162 static const char *cross_compile = "1";
 163 #else
 164 static const char *cross_compile = "0";
 165 #endif
 166
 167 /* Greatest exit code of sub-processes that has been encountered up to
 168    now.  */
 169 static int greatest_status = 1;
 170
 171 /* This is the obstack which we use to allocate many strings.  */
 172
 173 static struct obstack obstack;
 174
 175 /* This is the obstack to build an environment variable to pass to
 176    collect2 that describes all of the relevant switches of what to
 177    pass the compiler in building the list of pointers to constructors
 178    and destructors.  */
 179
 180 static struct obstack collect_obstack;
 181
 182 /* Forward declaration for prototypes.  */
 183 struct path_prefix;
 184 struct prefix_list;
 185
 186 static void init_spec (void);
 187 static void store_arg (const char *, int, int);
 188 static void insert_wrapper (const char *);
 189 static char *load_specs (const char *);
 190 static void read_specs (const char *, bool, bool);
 191 static void set_spec (const char *, const char *, bool);
 192 static struct compiler *lookup_compiler (const char *, size_t, const char *);
 193 static char *build_search_list (const struct path_prefix *, const char *,
 194                                 bool, bool);
 195 static void xputenv (const char *);
 196 static void putenv_from_prefixes (const struct path_prefix *, const char *,
 197                                   bool);
 198 static int access_check (const char *, int);
 199 static char *find_a_file (const struct path_prefix *, const char *, int, bool);
 200 static void add_prefix (struct path_prefix *, const char *, const char *,
 201                         int, int, int);
 202 static void add_sysrooted_prefix (struct path_prefix *, const char *,
 203                                   const char *, int, int, int);
 204 static char *skip_whitespace (char *);
 205 static void delete_if_ordinary (const char *);
 206 static void delete_temp_files (void);
 207 static void delete_failure_queue (void);
 208 static void clear_failure_queue (void);
 209 static int check_live_switch (int, int);
 210 static const char *handle_braces (const char *);
 211 static inline bool input_suffix_matches (const char *, const char *);
 212 static inline bool switch_matches (const char *, const char *, int);
 213 static inline void mark_matching_switches (const char *, const char *, int);
 214 static inline void process_marked_switches (void);
 215 static const char *process_brace_body (const char *, const char *, const char *, int, int);
 216 static const struct spec_function *lookup_spec_function (const char *);
 217 static const char *eval_spec_function (const char *, const char *);
 218 static const char *handle_spec_function (const char *, bool *);
 219 static char *save_string (const char *, int);
 220 static void set_collect_gcc_options (void);
 221 static int do_spec_1 (const char *, int, const char *);
 222 static int do_spec_2 (const char *);
 223 static void do_option_spec (const char *, const char *);
 224 static void do_self_spec (const char *);
 225 static const char *find_file (const char *);
 226 static int is_directory (const char *, bool);
 227 static const char *validate_switches (const char *, bool);
 228 static void validate_all_switches (void);
 229 static inline void validate_switches_from_spec (const char *, bool);
 230 static void give_switch (int, int);
 231 static int used_arg (const char *, int);
 232 static int default_arg (const char *, int);
 233 static void set_multilib_dir (void);
 234 static void print_multilib_info (void);
 235 static void perror_with_name (const char *);
 236 static void display_help (void);
 237 static void add_preprocessor_option (const char *, int);
 238 static void add_assembler_option (const char *, int);
 239 static void add_linker_option (const char *, int);
 240 static void process_command (unsigned int, struct cl_decoded_option *);
 241 static int execute (void);
 242 static void alloc_args (void);
 243 static void clear_args (void);
 244 static void fatal_signal (int);
 245 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
 246 static void init_gcc_specs (struct obstack *, const char *, const char *,
 247                             const char *);
 248 #endif
 249 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
 250 static const char *convert_filename (const char *, int, int);
 251 #endif
 252
 253 static const char *getenv_spec_function (int, const char **);
 254 static const char *if_exists_spec_function (int, const char **);
 255 static const char *if_exists_else_spec_function (int, const char **);
 256 static const char *sanitize_spec_function (int, const char **);
 257 static const char *replace_outfile_spec_function (int, const char **);
 258 static const char *remove_outfile_spec_function (int, const char **);
 259 static const char *version_compare_spec_function (int, const char **);
 260 static const char *include_spec_function (int, const char **);
 261 static const char *find_file_spec_function (int, const char **);
 262 static const char *find_plugindir_spec_function (int, const char **);
 263 static const char *print_asm_header_spec_function (int, const char **);
 264 static const char *compare_debug_dump_opt_spec_function (int, const char **);
 265 static const char *compare_debug_self_opt_spec_function (int, const char **);
 266 static const char *compare_debug_auxbase_opt_spec_function (int, const char **);
 267 static const char *pass_through_libs_spec_func (int, const char **);
 268 static const char *replace_extension_spec_func (int, const char **);
 269 static char *convert_white_space (char *);
 270 \f
 271 /* The Specs Language
 272
 273 Specs are strings containing lines, each of which (if not blank)
 274 is made up of a program name, and arguments separated by spaces.
 275 The program name must be exact and start from root, since no path
 276 is searched and it is unreliable to depend on the current working directory.
 277 Redirection of input or output is not supported; the subprograms must
 278 accept filenames saying what files to read and write.
 279
 280 In addition, the specs can contain %-sequences to substitute variable text
 281 or for conditional text.  Here is a table of all defined %-sequences.
 282 Note that spaces are not generated automatically around the results of
 283 expanding these sequences; therefore, you can concatenate them together
 284 or with constant text in a single argument.
 285
 286  %%     substitute one % into the program name or argument.
 287  %i     substitute the name of the input file being processed.
 288  %b     substitute the basename of the input file being processed.
 289         This is the substring up to (and not including) the last period
 290         and not including the directory unless -save-temps was specified
 291         to put temporaries in a different location.
 292  %B     same as %b, but include the file suffix (text after the last period).
 293  %gSUFFIX
 294         substitute a file name that has suffix SUFFIX and is chosen
 295         once per compilation, and mark the argument a la %d.  To reduce
 296         exposure to denial-of-service attacks, the file name is now
 297         chosen in a way that is hard to predict even when previously
 298         chosen file names are known.  For example, `%g.s ... %g.o ... %g.s'
 299         might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'.  SUFFIX matches
 300         the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
 301         had been pre-processed.  Previously, %g was simply substituted
 302         with a file name chosen once per compilation, without regard
 303         to any appended suffix (which was therefore treated just like
 304         ordinary text), making such attacks more likely to succeed.
 305  %|SUFFIX
 306         like %g, but if -pipe is in effect, expands simply to "-".
 307  %mSUFFIX
 308         like %g, but if -pipe is in effect, expands to nothing.  (We have both
 309         %| and %m to accommodate differences between system assemblers; see
 310         the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
 311  %uSUFFIX
 312         like %g, but generates a new temporary file name even if %uSUFFIX
 313         was already seen.
 314  %USUFFIX
 315         substitutes the last file name generated with %uSUFFIX, generating a
 316         new one if there is no such last file name.  In the absence of any
 317         %uSUFFIX, this is just like %gSUFFIX, except they don't share
 318         the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
 319         would involve the generation of two distinct file names, one
 320         for each `%g.s' and another for each `%U.s'.  Previously, %U was
 321         simply substituted with a file name chosen for the previous %u,
 322         without regard to any appended suffix.
 323  %jSUFFIX
 324         substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
 325         writable, and if save-temps is off; otherwise, substitute the name
 326         of a temporary file, just like %u.  This temporary file is not
 327         meant for communication between processes, but rather as a junk
 328         disposal mechanism.
 329  %.SUFFIX
 330         substitutes .SUFFIX for the suffixes of a matched switch's args when
 331         it is subsequently output with %*. SUFFIX is terminated by the next
 332         space or %.
 333  %d     marks the argument containing or following the %d as a
 334         temporary file name, so that that file will be deleted if GCC exits
 335         successfully.  Unlike %g, this contributes no text to the argument.
 336  %w     marks the argument containing or following the %w as the
 337         "output file" of this compilation.  This puts the argument
 338         into the sequence of arguments that %o will substitute later.
 339  %V     indicates that this compilation produces no "output file".
 340  %W{...}
 341         like %{...} but mark last argument supplied within
 342         as a file to be deleted on failure.
 343  %o     substitutes the names of all the output files, with spaces
 344         automatically placed around them.  You should write spaces
 345         around the %o as well or the results are undefined.
 346         %o is for use in the specs for running the linker.
 347         Input files whose names have no recognized suffix are not compiled
 348         at all, but they are included among the output files, so they will
 349         be linked.
 350  %O     substitutes the suffix for object files.  Note that this is
 351         handled specially when it immediately follows %g, %u, or %U
 352         (with or without a suffix argument) because of the need for
 353         those to form complete file names.  The handling is such that
 354         %O is treated exactly as if it had already been substituted,
 355         except that %g, %u, and %U do not currently support additional
 356         SUFFIX characters following %O as they would following, for
 357         example, `.o'.
 358  %I     Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
 359         (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
 360         and -B options) and -imultilib as necessary.
 361  %s     current argument is the name of a library or startup file of some sort.
 362         Search for that file in a standard list of directories
 363         and substitute the full name found.
 364  %eSTR  Print STR as an error message.  STR is terminated by a newline.
 365         Use this when inconsistent options are detected.
 366  %nSTR  Print STR as a notice.  STR is terminated by a newline.
 367  %x{OPTION}     Accumulate an option for %X.
 368  %X     Output the accumulated linker options specified by compilations.
 369  %Y     Output the accumulated assembler options specified by compilations.
 370  %Z     Output the accumulated preprocessor options specified by compilations.
 371  %a     process ASM_SPEC as a spec.
 372         This allows config.h to specify part of the spec for running as.
 373  %A     process ASM_FINAL_SPEC as a spec.  A capital A is actually
 374         used here.  This can be used to run a post-processor after the
 375         assembler has done its job.
 376  %D     Dump out a -L option for each directory in startfile_prefixes.
 377         If multilib_dir is set, extra entries are generated with it affixed.
 378  %l     process LINK_SPEC as a spec.
 379  %L     process LIB_SPEC as a spec.
 380  %M     Output multilib_os_dir.
 381  %G     process LIBGCC_SPEC as a spec.
 382  %R     Output the concatenation of target_system_root and
 383         target_sysroot_suffix.
 384  %S     process STARTFILE_SPEC as a spec.  A capital S is actually used here.
 385  %E     process ENDFILE_SPEC as a spec.  A capital E is actually used here.
 386  %C     process CPP_SPEC as a spec.
 387  %1     process CC1_SPEC as a spec.
 388  %2     process CC1PLUS_SPEC as a spec.
 389  %*     substitute the variable part of a matched option.  (See below.)
 390         Note that each comma in the substituted string is replaced by
 391         a single space.
 392  %<S    remove all occurrences of -S from the command line.
 393         Note - this command is position dependent.  % commands in the
 394         spec string before this one will see -S, % commands in the
 395         spec string after this one will not.
 396  %>S    Similar to "%<S", but keep it in the GCC command line.
 397  %<S*   remove all occurrences of all switches beginning with -S from the
 398         command line.
 399  %:function(args)
 400         Call the named function FUNCTION, passing it ARGS.  ARGS is
 401         first processed as a nested spec string, then split into an
 402         argument vector in the usual fashion.  The function returns
 403         a string which is processed as if it had appeared literally
 404         as part of the current spec.
 405  %{S}   substitutes the -S switch, if that switch was given to GCC.
 406         If that switch was not specified, this substitutes nothing.
 407         Here S is a metasyntactic variable.
 408  %{S*}  substitutes all the switches specified to GCC whose names start
 409         with -S.  This is used for -o, -I, etc; switches that take
 410         arguments.  GCC considers `-o foo' as being one switch whose
 411         name starts with `o'.  %{o*} would substitute this text,
 412         including the space; thus, two arguments would be generated.
 413  %{S*&T*} likewise, but preserve order of S and T options (the order
 414         of S and T in the spec is not significant).  Can be any number
 415         of ampersand-separated variables; for each the wild card is
 416         optional.  Useful for CPP as %{D*&U*&A*}.
 417
 418  %{S:X}   substitutes X, if the -S switch was given to GCC.
 419  %{!S:X}  substitutes X, if the -S switch was NOT given to GCC.
 420  %{S*:X}  substitutes X if one or more switches whose names start
 421           with -S was given to GCC.  Normally X is substituted only
 422           once, no matter how many such switches appeared.  However,
 423           if %* appears somewhere in X, then X will be substituted
 424           once for each matching switch, with the %* replaced by the
 425           part of that switch that matched the '*'.
 426  %{.S:X}  substitutes X, if processing a file with suffix S.
 427  %{!.S:X} substitutes X, if NOT processing a file with suffix S.
 428  %{,S:X}  substitutes X, if processing a file which will use spec S.
 429  %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
 430
 431  %{S|T:X} substitutes X if either -S or -T was given to GCC.  This may be
 432           combined with '!', '.', ',', and '*' as above binding stronger
 433           than the OR.
 434           If %* appears in X, all of the alternatives must be starred, and
 435           only the first matching alternative is substituted.
 436  %{%:function(args):X}
 437           Call function named FUNCTION with args ARGS.  If the function
 438           returns non-NULL, then X is substituted, if it returns
 439           NULL, it isn't substituted.
 440  %{S:X;   if S was given to GCC, substitutes X;
 441    T:Y;   else if T was given to GCC, substitutes Y;
 442     :D}   else substitutes D.  There can be as many clauses as you need.
 443           This may be combined with '.', '!', ',', '|', and '*' as above.
 444
 445  %(Spec) processes a specification defined in a specs file as *Spec:
 446
 447 The conditional text X in a %{S:X} or similar construct may contain
 448 other nested % constructs or spaces, or even newlines.  They are
 449 processed as usual, as described above.  Trailing white space in X is
 450 ignored.  White space may also appear anywhere on the left side of the
 451 colon in these constructs, except between . or * and the corresponding
 452 word.
 453
 454 The -O, -f, -g, -m, and -W switches are handled specifically in these
 455 constructs.  If another value of -O or the negated form of a -f, -m, or
 456 -W switch is found later in the command line, the earlier switch
 457 value is ignored, except with {S*} where S is just one letter; this
 458 passes all matching options.
 459
 460 The character | at the beginning of the predicate text is used to indicate
 461 that a command should be piped to the following command, but only if -pipe
 462 is specified.
 463
 464 Note that it is built into GCC which switches take arguments and which
 465 do not.  You might think it would be useful to generalize this to
 466 allow each compiler's spec to say which switches take arguments.  But
 467 this cannot be done in a consistent fashion.  GCC cannot even decide
 468 which input files have been specified without knowing which switches
 469 take arguments, and it must know which input files to compile in order
 470 to tell which compilers to run.
 471
 472 GCC also knows implicitly that arguments starting in `-l' are to be
 473 treated as compiler output files, and passed to the linker in their
 474 proper position among the other output files.  */
 475 \f
 476 /* Define the macros used for specs %a, %l, %L, %S, %C, %1.  */
 477
 478 /* config.h can define ASM_SPEC to provide extra args to the assembler
 479    or extra switch-translations.  */
 480 #ifndef ASM_SPEC
 481 #define ASM_SPEC ""
 482 #endif
 483
 484 /* config.h can define ASM_FINAL_SPEC to run a post processor after
 485    the assembler has run.  */
 486 #ifndef ASM_FINAL_SPEC
 487 #define ASM_FINAL_SPEC \
 488   "%{gsplit-dwarf: \n\
 489        objcopy --extract-dwo \
 490          %{c:%{o*:%*}%{!o*:%b%O}}%{!c:%U%O} \
 491          %{c:%{o*:%:replace-extension(%{o*:%*} .dwo)}%{!o*:%b.dwo}}%{!c:%b.dwo} \n\
 492        objcopy --strip-dwo \
 493          %{c:%{o*:%*}%{!o*:%b%O}}%{!c:%U%O} \
 494     }"
 495 #endif
 496
 497 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
 498    or extra switch-translations.  */
 499 #ifndef CPP_SPEC
 500 #define CPP_SPEC ""
 501 #endif
 502
 503 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
 504    or extra switch-translations.  */
 505 #ifndef CC1_SPEC
 506 #define CC1_SPEC ""
 507 #endif
 508
 509 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
 510    or extra switch-translations.  */
 511 #ifndef CC1PLUS_SPEC
 512 #define CC1PLUS_SPEC ""
 513 #endif
 514
 515 /* config.h can define LINK_SPEC to provide extra args to the linker
 516    or extra switch-translations.  */
 517 #ifndef LINK_SPEC
 518 #define LINK_SPEC ""
 519 #endif
 520
 521 /* config.h can define LIB_SPEC to override the default libraries.  */
 522 #ifndef LIB_SPEC
 523 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
 524 #endif
 525
 526 /* When using -fsplit-stack we need to wrap pthread_create, in order
 527    to initialize the stack guard.  We always use wrapping, rather than
 528    shared library ordering, and we keep the wrapper function in
 529    libgcc.  This is not yet a real spec, though it could become one;
 530    it is currently just stuffed into LINK_SPEC.  FIXME: This wrapping
 531    only works with GNU ld and gold.  */
 532 #define STACK_SPLIT_SPEC " %{fsplit-stack: --wrap=pthread_create}"
 533
 534 #ifndef LIBASAN_SPEC
 535 #ifdef STATIC_LIBASAN_LIBS
 536 #define ADD_STATIC_LIBASAN_LIBS \
 537   " %{static-libasan:" STATIC_LIBASAN_LIBS "}"
 538 #else
 539 #define ADD_STATIC_LIBASAN_LIBS
 540 #endif
 541 #ifdef LIBASAN_EARLY_SPEC
 542 #define LIBASAN_SPEC ADD_STATIC_LIBASAN_LIBS
 543 #elif defined(HAVE_LD_STATIC_DYNAMIC)
 544 #define LIBASAN_SPEC "%{static-libasan:" LD_STATIC_OPTION \
 545                      "} -lasan %{static-libasan:" LD_DYNAMIC_OPTION "}" \
 546                      ADD_STATIC_LIBASAN_LIBS
 547 #else
 548 #define LIBASAN_SPEC "-lasan" ADD_STATIC_LIBASAN_LIBS
 549 #endif
 550 #endif
 551
 552 #ifndef LIBASAN_EARLY_SPEC
 553 #define LIBASAN_EARLY_SPEC ""
 554 #endif
 555
 556 #ifndef LIBTSAN_SPEC
 557 #ifdef STATIC_LIBTSAN_LIBS
 558 #define ADD_STATIC_LIBTSAN_LIBS \
 559   " %{static-libtsan:" STATIC_LIBTSAN_LIBS "}"
 560 #else
 561 #define ADD_STATIC_LIBTSAN_LIBS
 562 #endif
 563 #ifdef LIBTSAN_EARLY_SPEC
 564 #define LIBTSAN_SPEC ADD_STATIC_LIBTSAN_LIBS
 565 #elif defined(HAVE_LD_STATIC_DYNAMIC)
 566 #define LIBTSAN_SPEC "%{static-libtsan:" LD_STATIC_OPTION \
 567                      "} -ltsan %{static-libtsan:" LD_DYNAMIC_OPTION "}" \
 568                      ADD_STATIC_LIBTSAN_LIBS
 569 #else
 570 #define LIBTSAN_SPEC "-ltsan" ADD_STATIC_LIBTSAN_LIBS
 571 #endif
 572 #endif
 573
 574 #ifndef LIBTSAN_EARLY_SPEC
 575 #define LIBTSAN_EARLY_SPEC ""
 576 #endif
 577
 578 #ifndef LIBUBSAN_SPEC
 579 #ifdef STATIC_LIBUBSAN_LIBS
 580 #define ADD_STATIC_LIBUBSAN_LIBS \
 581   " %{static-libubsan:" STATIC_LIBUBSAN_LIBS "}"
 582 #else
 583 #define ADD_STATIC_LIBUBSAN_LIBS
 584 #endif
 585 #ifdef LIBUBSAN_EARLY_SPEC
 586 #define LIBUBSAN_SPEC ADD_STATIC_LIBUBSAN_LIBS
 587 #elif defined(HAVE_LD_STATIC_DYNAMIC)
 588 #define LIBUBSAN_SPEC "%{static-libubsan:" LD_STATIC_OPTION \
 589                      "} -lubsan %{static-libubsan:" LD_DYNAMIC_OPTION "}" \
 590                      ADD_STATIC_LIBUBSAN_LIBS
 591 #else
 592 #define LIBUBSAN_SPEC "-lubsan" ADD_STATIC_LIBUBSAN_LIBS
 593 #endif
 594 #endif
 595
 596 #ifndef LIBUBSAN_EARLY_SPEC
 597 #define LIBUBSAN_EARLY_SPEC ""
 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     %{%:sanitize(undefined):" LIBUBSAN_EARLY_SPEC "}}}"
 725 #endif
 726
 727 /* Linker command line options for -fsanitize= late on the command line.  */
 728 #ifndef SANITIZER_SPEC
 729 #define SANITIZER_SPEC "\
 730 %{!nostdlib:%{!nodefaultlibs:%{%:sanitize(address):" LIBASAN_SPEC "\
 731     %{static:%ecannot specify -static with -fsanitize=address}\
 732     %{%:sanitize(thread):%e-fsanitize=address is incompatible with -fsanitize=thread}}\
 733     %{%:sanitize(thread):" LIBTSAN_SPEC "\
 734     %{!pie:%{!shared:%e-fsanitize=thread linking must be done with -pie or -shared}}}\
 735     %{%:sanitize(undefined):" LIBUBSAN_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 /* Adding -fopenmp should imply 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_fcompare_debug_second:
3387       compare_debug_second = 1;
3388       break;
3389
3390     case OPT_fcompare_debug:
3391       switch (value)
3392         {
3393         case 0:
3394           compare_debug_replacement_opt = "-fcompare-debug=";
3395           arg = "";
3396           goto compare_debug_with_arg;
3397
3398         case 1:
3399           compare_debug_replacement_opt = "-fcompare-debug=-gtoggle";
3400           arg = "-gtoggle";
3401           goto compare_debug_with_arg;
3402
3403         default:
3404           gcc_unreachable ();
3405         }
3406       break;
3407
3408     case OPT_fcompare_debug_:
3409       compare_debug_replacement_opt = decoded->canonical_option[0];
3410     compare_debug_with_arg:
3411       gcc_assert (decoded->canonical_option_num_elements == 1);
3412       gcc_assert (arg != NULL);
3413       if (*arg)
3414         compare_debug = 1;
3415       else
3416         compare_debug = -1;
3417       if (compare_debug < 0)
3418         compare_debug_opt = NULL;
3419       else
3420         compare_debug_opt = arg;
3421       save_switch (compare_debug_replacement_opt, 0, NULL, validated, true);
3422       return true;
3423
3424     case OPT_Wa_:
3425       {
3426         int prev, j;
3427         /* Pass the rest of this option to the assembler.  */
3428
3429         /* Split the argument at commas.  */
3430         prev = 0;
3431         for (j = 0; arg[j]; j++)
3432           if (arg[j] == ',')
3433             {
3434               add_assembler_option (arg + prev, j - prev);
3435               prev = j + 1;
3436             }
3437
3438         /* Record the part after the last comma.  */
3439         add_assembler_option (arg + prev, j - prev);
3440       }
3441       do_save = false;
3442       break;
3443
3444     case OPT_Wp_:
3445       {
3446         int prev, j;
3447         /* Pass the rest of this option to the preprocessor.  */
3448
3449         /* Split the argument at commas.  */
3450         prev = 0;
3451         for (j = 0; arg[j]; j++)
3452           if (arg[j] == ',')
3453             {
3454               add_preprocessor_option (arg + prev, j - prev);
3455               prev = j + 1;
3456             }
3457
3458         /* Record the part after the last comma.  */
3459         add_preprocessor_option (arg + prev, j - prev);
3460       }
3461       do_save = false;
3462       break;
3463
3464     case OPT_Wl_:
3465       {
3466         int prev, j;
3467         /* Split the argument at commas.  */
3468         prev = 0;
3469         for (j = 0; arg[j]; j++)
3470           if (arg[j] == ',')
3471             {
3472               add_infile (save_string (arg + prev, j - prev), "*");
3473               prev = j + 1;
3474             }
3475         /* Record the part after the last comma.  */
3476         add_infile (arg + prev, "*");
3477       }
3478       do_save = false;
3479       break;
3480
3481     case OPT_Xlinker:
3482       add_infile (arg, "*");
3483       do_save = false;
3484       break;
3485
3486     case OPT_Xpreprocessor:
3487       add_preprocessor_option (arg, strlen (arg));
3488       do_save = false;
3489       break;
3490
3491     case OPT_Xassembler:
3492       add_assembler_option (arg, strlen (arg));
3493       do_save = false;
3494       break;
3495
3496     case OPT_l:
3497       /* POSIX allows separation of -l and the lib arg; canonicalize
3498          by concatenating -l with its arg */
3499       add_infile (concat ("-l", arg, NULL), "*");
3500       do_save = false;
3501       break;
3502
3503     case OPT_L:
3504       /* Similarly, canonicalize -L for linkers that may not accept
3505          separate arguments.  */
3506       save_switch (concat ("-L", arg, NULL), 0, NULL, validated, true);
3507       return true;
3508
3509     case OPT_F:
3510       /* Likewise -F.  */
3511       save_switch (concat ("-F", arg, NULL), 0, NULL, validated, true);
3512       return true;
3513
3514     case OPT_save_temps:
3515       save_temps_flag = SAVE_TEMPS_CWD;
3516       validated = true;
3517       break;
3518
3519     case OPT_save_temps_:
3520       if (strcmp (arg, "cwd") == 0)
3521         save_temps_flag = SAVE_TEMPS_CWD;
3522       else if (strcmp (arg, "obj") == 0
3523                || strcmp (arg, "object") == 0)
3524         save_temps_flag = SAVE_TEMPS_OBJ;
3525       else
3526         fatal_error ("%qs is an unknown -save-temps option",
3527                      decoded->orig_option_with_args_text);
3528       break;
3529
3530     case OPT_no_canonical_prefixes:
3531       /* Already handled as a special case, so ignored here.  */
3532       do_save = false;
3533       break;
3534
3535     case OPT_pipe:
3536       validated = true;
3537       /* These options set the variables specified in common.opt
3538          automatically, but do need to be saved for spec
3539          processing.  */
3540       break;
3541
3542     case OPT_specs_:
3543       {
3544         struct user_specs *user = XNEW (struct user_specs);
3545
3546         user->next = (struct user_specs *) 0;
3547         user->filename = arg;
3548         if (user_specs_tail)
3549           user_specs_tail->next = user;
3550         else
3551           user_specs_head = user;
3552         user_specs_tail = user;
3553       }
3554       validated = true;
3555       break;
3556
3557     case OPT__sysroot_:
3558       target_system_root = arg;
3559       target_system_root_changed = 1;
3560       do_save = false;
3561       break;
3562
3563     case OPT_time_:
3564       if (report_times_to_file)
3565         fclose (report_times_to_file);
3566       report_times_to_file = fopen (arg, "a");
3567       do_save = false;
3568       break;
3569
3570     case OPT____:
3571       /* "-###"
3572          This is similar to -v except that there is no execution
3573          of the commands and the echoed arguments are quoted.  It
3574          is intended for use in shell scripts to capture the
3575          driver-generated command line.  */
3576       verbose_only_flag++;
3577       verbose_flag = 1;
3578       do_save = false;
3579       break;
3580
3581     case OPT_B:
3582       {
3583         size_t len = strlen (arg);
3584
3585         /* Catch the case where the user has forgotten to append a
3586            directory separator to the path.  Note, they may be using
3587            -B to add an executable name prefix, eg "i386-elf-", in
3588            order to distinguish between multiple installations of
3589            GCC in the same directory.  Hence we must check to see
3590            if appending a directory separator actually makes a
3591            valid directory name.  */
3592         if (!IS_DIR_SEPARATOR (arg[len - 1])
3593             && is_directory (arg, false))
3594           {
3595             char *tmp = XNEWVEC (char, len + 2);
3596             strcpy (tmp, arg);
3597             tmp[len] = DIR_SEPARATOR;
3598             tmp[++len] = 0;
3599             arg = tmp;
3600           }
3601
3602         add_prefix (&exec_prefixes, arg, NULL,
3603                     PREFIX_PRIORITY_B_OPT, 0, 0);
3604         add_prefix (&startfile_prefixes, arg, NULL,
3605                     PREFIX_PRIORITY_B_OPT, 0, 0);
3606         add_prefix (&include_prefixes, arg, NULL,
3607                     PREFIX_PRIORITY_B_OPT, 0, 0);
3608       }
3609       validated = true;
3610       break;
3611
3612     case OPT_x:
3613       spec_lang = arg;
3614       if (!strcmp (spec_lang, "none"))
3615         /* Suppress the warning if -xnone comes after the last input
3616            file, because alternate command interfaces like g++ might
3617            find it useful to place -xnone after each input file.  */
3618         spec_lang = 0;
3619       else
3620         last_language_n_infiles = n_infiles;
3621       do_save = false;
3622       break;
3623
3624     case OPT_o:
3625       have_o = 1;
3626 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3627       arg = convert_filename (arg, ! have_c, 0);
3628 #endif
3629       /* Save the output name in case -save-temps=obj was used.  */
3630       save_temps_prefix = xstrdup (arg);
3631       /* On some systems, ld cannot handle "-o" without a space.  So
3632          split the option from its argument.  */
3633       save_switch ("-o", 1, &arg, validated, true);
3634       return true;
3635
3636     case OPT_static_libgcc:
3637     case OPT_shared_libgcc:
3638     case OPT_static_libgfortran:
3639     case OPT_static_libstdc__:
3640       /* These are always valid, since gcc.c itself understands the
3641          first two, gfortranspec.c understands -static-libgfortran and
3642          g++spec.c understands -static-libstdc++ */
3643       validated = true;
3644       break;
3645
3646     default:
3647       /* Various driver options need no special processing at this
3648          point, having been handled in a prescan above or being
3649          handled by specs.  */
3650       break;
3651     }
3652
3653   if (do_save)
3654     save_switch (decoded->canonical_option[0],
3655                  decoded->canonical_option_num_elements - 1,
3656                  &decoded->canonical_option[1], validated, true);
3657   return true;
3658 }
3659
3660 /* Put the driver's standard set of option handlers in *HANDLERS.  */
3661
3662 static void
3663 set_option_handlers (struct cl_option_handlers *handlers)
3664 {
3665   handlers->unknown_option_callback = driver_unknown_option_callback;
3666   handlers->wrong_lang_callback = driver_wrong_lang_callback;
3667   handlers->num_handlers = 3;
3668   handlers->handlers[0].handler = driver_handle_option;
3669   handlers->handlers[0].mask = CL_DRIVER;
3670   handlers->handlers[1].handler = common_handle_option;
3671   handlers->handlers[1].mask = CL_COMMON;
3672   handlers->handlers[2].handler = target_handle_option;
3673   handlers->handlers[2].mask = CL_TARGET;
3674 }
3675
3676 /* Create the vector `switches' and its contents.
3677    Store its length in `n_switches'.  */
3678
3679 static void
3680 process_command (unsigned int decoded_options_count,
3681                  struct cl_decoded_option *decoded_options)
3682 {
3683   const char *temp;
3684   char *temp1;
3685   char *tooldir_prefix, *tooldir_prefix2;
3686   char *(*get_relative_prefix) (const char *, const char *,
3687                                 const char *) = NULL;
3688   struct cl_option_handlers handlers;
3689   unsigned int j;
3690
3691   gcc_exec_prefix = getenv ("GCC_EXEC_PREFIX");
3692
3693   n_switches = 0;
3694   n_infiles = 0;
3695   added_libraries = 0;
3696
3697   /* Figure compiler version from version string.  */
3698
3699   compiler_version = temp1 = xstrdup (version_string);
3700
3701   for (; *temp1; ++temp1)
3702     {
3703       if (*temp1 == ' ')
3704         {
3705           *temp1 = '\0';
3706           break;
3707         }
3708     }
3709
3710   /* Handle any -no-canonical-prefixes flag early, to assign the function
3711      that builds relative prefixes.  This function creates default search
3712      paths that are needed later in normal option handling.  */
3713
3714   for (j = 1; j < decoded_options_count; j++)
3715     {
3716       if (decoded_options[j].opt_index == OPT_no_canonical_prefixes)
3717         {
3718           get_relative_prefix = make_relative_prefix_ignore_links;
3719           break;
3720         }
3721     }
3722   if (! get_relative_prefix)
3723     get_relative_prefix = make_relative_prefix;
3724
3725   /* Set up the default search paths.  If there is no GCC_EXEC_PREFIX,
3726      see if we can create it from the pathname specified in
3727      decoded_options[0].arg.  */
3728
3729   gcc_libexec_prefix = standard_libexec_prefix;
3730 #ifndef VMS
3731   /* FIXME: make_relative_prefix doesn't yet work for VMS.  */
3732   if (!gcc_exec_prefix)
3733     {
3734       gcc_exec_prefix = get_relative_prefix (decoded_options[0].arg,
3735                                              standard_bindir_prefix,
3736                                              standard_exec_prefix);
3737       gcc_libexec_prefix = get_relative_prefix (decoded_options[0].arg,
3738                                              standard_bindir_prefix,
3739                                              standard_libexec_prefix);
3740       if (gcc_exec_prefix)
3741         xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
3742     }
3743   else
3744     {
3745       /* make_relative_prefix requires a program name, but
3746          GCC_EXEC_PREFIX is typically a directory name with a trailing
3747          / (which is ignored by make_relative_prefix), so append a
3748          program name.  */
3749       char *tmp_prefix = concat (gcc_exec_prefix, "gcc", NULL);
3750       gcc_libexec_prefix = get_relative_prefix (tmp_prefix,
3751                                                 standard_exec_prefix,
3752                                                 standard_libexec_prefix);
3753
3754       /* The path is unrelocated, so fallback to the original setting.  */
3755       if (!gcc_libexec_prefix)
3756         gcc_libexec_prefix = standard_libexec_prefix;
3757
3758       free (tmp_prefix);
3759     }
3760 #else
3761 #endif
3762   /* From this point onward, gcc_exec_prefix is non-null if the toolchain
3763      is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
3764      or an automatically created GCC_EXEC_PREFIX from
3765      decoded_options[0].arg.  */
3766
3767   /* Do language-specific adjustment/addition of flags.  */
3768   lang_specific_driver (&decoded_options, &decoded_options_count,
3769                         &added_libraries);
3770
3771   if (gcc_exec_prefix)
3772     {
3773       int len = strlen (gcc_exec_prefix);
3774
3775       if (len > (int) sizeof ("/lib/gcc/") - 1
3776           && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
3777         {
3778           temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1;
3779           if (IS_DIR_SEPARATOR (*temp)
3780               && filename_ncmp (temp + 1, "lib", 3) == 0
3781               && IS_DIR_SEPARATOR (temp[4])
3782               && filename_ncmp (temp + 5, "gcc", 3) == 0)
3783             len -= sizeof ("/lib/gcc/") - 1;
3784         }
3785
3786       set_std_prefix (gcc_exec_prefix, len);
3787       add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC",
3788                   PREFIX_PRIORITY_LAST, 0, 0);
3789       add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
3790                   PREFIX_PRIORITY_LAST, 0, 0);
3791     }
3792
3793   /* COMPILER_PATH and LIBRARY_PATH have values
3794      that are lists of directory names with colons.  */
3795
3796   temp = getenv ("COMPILER_PATH");
3797   if (temp)
3798     {
3799       const char *startp, *endp;
3800       char *nstore = (char *) alloca (strlen (temp) + 3);
3801
3802       startp = endp = temp;
3803       while (1)
3804         {
3805           if (*endp == PATH_SEPARATOR || *endp == 0)
3806             {
3807               strncpy (nstore, startp, endp - startp);
3808               if (endp == startp)
3809                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3810               else if (!IS_DIR_SEPARATOR (endp[-1]))
3811                 {
3812                   nstore[endp - startp] = DIR_SEPARATOR;
3813                   nstore[endp - startp + 1] = 0;
3814                 }
3815               else
3816                 nstore[endp - startp] = 0;
3817               add_prefix (&exec_prefixes, nstore, 0,
3818                           PREFIX_PRIORITY_LAST, 0, 0);
3819               add_prefix (&include_prefixes, nstore, 0,
3820                           PREFIX_PRIORITY_LAST, 0, 0);
3821               if (*endp == 0)
3822                 break;
3823               endp = startp = endp + 1;
3824             }
3825           else
3826             endp++;
3827         }
3828     }
3829
3830   temp = getenv (LIBRARY_PATH_ENV);
3831   if (temp && *cross_compile == '0')
3832     {
3833       const char *startp, *endp;
3834       char *nstore = (char *) alloca (strlen (temp) + 3);
3835
3836       startp = endp = temp;
3837       while (1)
3838         {
3839           if (*endp == PATH_SEPARATOR || *endp == 0)
3840             {
3841               strncpy (nstore, startp, endp - startp);
3842               if (endp == startp)
3843                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3844               else if (!IS_DIR_SEPARATOR (endp[-1]))
3845                 {
3846                   nstore[endp - startp] = DIR_SEPARATOR;
3847                   nstore[endp - startp + 1] = 0;
3848                 }
3849               else
3850                 nstore[endp - startp] = 0;
3851               add_prefix (&startfile_prefixes, nstore, NULL,
3852                           PREFIX_PRIORITY_LAST, 0, 1);
3853               if (*endp == 0)
3854                 break;
3855               endp = startp = endp + 1;
3856             }
3857           else
3858             endp++;
3859         }
3860     }
3861
3862   /* Use LPATH like LIBRARY_PATH (for the CMU build program).  */
3863   temp = getenv ("LPATH");
3864   if (temp && *cross_compile == '0')
3865     {
3866       const char *startp, *endp;
3867       char *nstore = (char *) alloca (strlen (temp) + 3);
3868
3869       startp = endp = temp;
3870       while (1)
3871         {
3872           if (*endp == PATH_SEPARATOR || *endp == 0)
3873             {
3874               strncpy (nstore, startp, endp - startp);
3875               if (endp == startp)
3876                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3877               else if (!IS_DIR_SEPARATOR (endp[-1]))
3878                 {
3879                   nstore[endp - startp] = DIR_SEPARATOR;
3880                   nstore[endp - startp + 1] = 0;
3881                 }
3882               else
3883                 nstore[endp - startp] = 0;
3884               add_prefix (&startfile_prefixes, nstore, NULL,
3885                           PREFIX_PRIORITY_LAST, 0, 1);
3886               if (*endp == 0)
3887                 break;
3888               endp = startp = endp + 1;
3889             }
3890           else
3891             endp++;
3892         }
3893     }
3894
3895   /* Process the options and store input files and switches in their
3896      vectors.  */
3897
3898   last_language_n_infiles = -1;
3899
3900   set_option_handlers (&handlers);
3901
3902   for (j = 1; j < decoded_options_count; j++)
3903     {
3904       switch (decoded_options[j].opt_index)
3905         {
3906         case OPT_S:
3907         case OPT_c:
3908         case OPT_E:
3909           have_c = 1;
3910           break;
3911         }
3912       if (have_c)
3913         break;
3914     }
3915
3916   for (j = 1; j < decoded_options_count; j++)
3917     {
3918       if (decoded_options[j].opt_index == OPT_SPECIAL_input_file)
3919         {
3920           const char *arg = decoded_options[j].arg;
3921           const char *p = strrchr (arg, '@');
3922           char *fname;
3923           long offset;
3924           int consumed;
3925 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3926           arg = convert_filename (arg, 0, access (arg, F_OK));
3927 #endif
3928           /* For LTO static archive support we handle input file
3929              specifications that are composed of a filename and
3930              an offset like FNAME@OFFSET.  */
3931           if (p
3932               && p != arg
3933               && sscanf (p, "@%li%n", &offset, &consumed) >= 1
3934               && strlen (p) == (unsigned int)consumed)
3935             {
3936               fname = (char *)xmalloc (p - arg + 1);
3937               memcpy (fname, arg, p - arg);
3938               fname[p - arg] = '\0';
3939               /* Only accept non-stdin and existing FNAME parts, otherwise
3940                  try with the full name.  */
3941               if (strcmp (fname, "-") == 0 || access (fname, F_OK) < 0)
3942                 {
3943                   free (fname);
3944                   fname = xstrdup (arg);
3945                 }
3946             }
3947           else
3948             fname = xstrdup (arg);
3949
3950           if (strcmp (fname, "-") != 0 && access (fname, F_OK) < 0)
3951             perror_with_name (fname);
3952           else
3953             add_infile (arg, spec_lang);
3954
3955           free (fname);
3956           continue;
3957         }
3958
3959       read_cmdline_option (&global_options, &global_options_set,
3960                            decoded_options + j, UNKNOWN_LOCATION,
3961                            CL_DRIVER, &handlers, global_dc);
3962     }
3963
3964   /* If -save-temps=obj and -o name, create the prefix to use for %b.
3965      Otherwise just make -save-temps=obj the same as -save-temps=cwd.  */
3966   if (save_temps_flag == SAVE_TEMPS_OBJ && save_temps_prefix != NULL)
3967     {
3968       save_temps_length = strlen (save_temps_prefix);
3969       temp = strrchr (lbasename (save_temps_prefix), '.');
3970       if (temp)
3971         {
3972           save_temps_length -= strlen (temp);
3973           save_temps_prefix[save_temps_length] = '\0';
3974         }
3975
3976     }
3977   else if (save_temps_prefix != NULL)
3978     {
3979       free (save_temps_prefix);
3980       save_temps_prefix = NULL;
3981     }
3982
3983   if (save_temps_flag && use_pipes)
3984     {
3985       /* -save-temps overrides -pipe, so that temp files are produced */
3986       if (save_temps_flag)
3987         warning (0, "-pipe ignored because -save-temps specified");
3988       use_pipes = 0;
3989     }
3990
3991   if (!compare_debug)
3992     {
3993       const char *gcd = getenv ("GCC_COMPARE_DEBUG");
3994
3995       if (gcd && gcd[0] == '-')
3996         {
3997           compare_debug = 2;
3998           compare_debug_opt = gcd;
3999         }
4000       else if (gcd && *gcd && strcmp (gcd, "0"))
4001         {
4002           compare_debug = 3;
4003           compare_debug_opt = "-gtoggle";
4004         }
4005     }
4006   else if (compare_debug < 0)
4007     {
4008       compare_debug = 0;
4009       gcc_assert (!compare_debug_opt);
4010     }
4011
4012   /* Set up the search paths.  We add directories that we expect to
4013      contain GNU Toolchain components before directories specified by
4014      the machine description so that we will find GNU components (like
4015      the GNU assembler) before those of the host system.  */
4016
4017   /* If we don't know where the toolchain has been installed, use the
4018      configured-in locations.  */
4019   if (!gcc_exec_prefix)
4020     {
4021 #ifndef OS2
4022       add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC",
4023                   PREFIX_PRIORITY_LAST, 1, 0);
4024       add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS",
4025                   PREFIX_PRIORITY_LAST, 2, 0);
4026       add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
4027                   PREFIX_PRIORITY_LAST, 2, 0);
4028 #endif
4029       add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
4030                   PREFIX_PRIORITY_LAST, 1, 0);
4031     }
4032
4033   gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix));
4034   tooldir_prefix2 = concat (tooldir_base_prefix, spec_machine,
4035                             dir_separator_str, NULL);
4036
4037   /* Look for tools relative to the location from which the driver is
4038      running, or, if that is not available, the configured prefix.  */
4039   tooldir_prefix
4040     = concat (gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
4041               spec_machine, dir_separator_str,
4042               spec_version, dir_separator_str, tooldir_prefix2, NULL);
4043   free (tooldir_prefix2);
4044
4045   add_prefix (&exec_prefixes,
4046               concat (tooldir_prefix, "bin", dir_separator_str, NULL),
4047               "BINUTILS", PREFIX_PRIORITY_LAST, 0, 0);
4048   add_prefix (&startfile_prefixes,
4049               concat (tooldir_prefix, "lib", dir_separator_str, NULL),
4050               "BINUTILS", PREFIX_PRIORITY_LAST, 0, 1);
4051   free (tooldir_prefix);
4052
4053 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
4054   /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
4055      then consider it to relocate with the rest of the GCC installation
4056      if GCC_EXEC_PREFIX is set.
4057      ``make_relative_prefix'' is not compiled for VMS, so don't call it.  */
4058   if (target_system_root && !target_system_root_changed && gcc_exec_prefix)
4059     {
4060       char *tmp_prefix = get_relative_prefix (decoded_options[0].arg,
4061                                               standard_bindir_prefix,
4062                                               target_system_root);
4063       if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0)
4064         {
4065           target_system_root = tmp_prefix;
4066           target_system_root_changed = 1;
4067         }
4068     }
4069 #endif
4070
4071   /* More prefixes are enabled in main, after we read the specs file
4072      and determine whether this is cross-compilation or not.  */
4073
4074   if (n_infiles == last_language_n_infiles && spec_lang != 0)
4075     warning (0, "%<-x %s%> after last input file has no effect", spec_lang);
4076
4077   /* Synthesize -fcompare-debug flag from the GCC_COMPARE_DEBUG
4078      environment variable.  */
4079   if (compare_debug == 2 || compare_debug == 3)
4080     {
4081       const char *opt = concat ("-fcompare-debug=", compare_debug_opt, NULL);
4082       save_switch (opt, 0, NULL, false, true);
4083       compare_debug = 1;
4084     }
4085
4086   /* Ensure we only invoke each subprocess once.  */
4087   if (print_subprocess_help || print_help_list || print_version)
4088     {
4089       n_infiles = 0;
4090
4091       /* Create a dummy input file, so that we can pass
4092          the help option on to the various sub-processes.  */
4093       add_infile ("help-dummy", "c");
4094     }
4095
4096   alloc_switch ();
4097   switches[n_switches].part1 = 0;
4098   alloc_infile ();
4099   infiles[n_infiles].name = 0;
4100 }
4101
4102 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4103    and place that in the environment.  */
4104
4105 static void
4106 set_collect_gcc_options (void)
4107 {
4108   int i;
4109   int first_time;
4110
4111   /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4112      the compiler.  */
4113   obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
4114                 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4115
4116   first_time = TRUE;
4117   for (i = 0; (int) i < n_switches; i++)
4118     {
4119       const char *const *args;
4120       const char *p, *q;
4121       if (!first_time)
4122         obstack_grow (&collect_obstack, " ", 1);
4123
4124       first_time = FALSE;
4125
4126       /* Ignore elided switches.  */
4127       if ((switches[i].live_cond
4128            & (SWITCH_IGNORE | SWITCH_KEEP_FOR_GCC))
4129           == SWITCH_IGNORE)
4130         continue;
4131
4132       obstack_grow (&collect_obstack, "'-", 2);
4133       q = switches[i].part1;
4134       while ((p = strchr (q, '\'')))
4135         {
4136           obstack_grow (&collect_obstack, q, p - q);
4137           obstack_grow (&collect_obstack, "'\\''", 4);
4138           q = ++p;
4139         }
4140       obstack_grow (&collect_obstack, q, strlen (q));
4141       obstack_grow (&collect_obstack, "'", 1);
4142
4143       for (args = switches[i].args; args && *args; args++)
4144         {
4145           obstack_grow (&collect_obstack, " '", 2);
4146           q = *args;
4147           while ((p = strchr (q, '\'')))
4148             {
4149               obstack_grow (&collect_obstack, q, p - q);
4150               obstack_grow (&collect_obstack, "'\\''", 4);
4151               q = ++p;
4152             }
4153           obstack_grow (&collect_obstack, q, strlen (q));
4154           obstack_grow (&collect_obstack, "'", 1);
4155         }
4156     }
4157   obstack_grow (&collect_obstack, "\0", 1);
4158   xputenv (XOBFINISH (&collect_obstack, char *));
4159 }
4160 \f
4161 /* Process a spec string, accumulating and running commands.  */
4162
4163 /* These variables describe the input file name.
4164    input_file_number is the index on outfiles of this file,
4165    so that the output file name can be stored for later use by %o.
4166    input_basename is the start of the part of the input file
4167    sans all directory names, and basename_length is the number
4168    of characters starting there excluding the suffix .c or whatever.  */
4169
4170 static const char *gcc_input_filename;
4171 static int input_file_number;
4172 size_t input_filename_length;
4173 static int basename_length;
4174 static int suffixed_basename_length;
4175 static const char *input_basename;
4176 static const char *input_suffix;
4177 #ifndef HOST_LACKS_INODE_NUMBERS
4178 static struct stat input_stat;
4179 #endif
4180 static int input_stat_set;
4181
4182 /* The compiler used to process the current input file.  */
4183 static struct compiler *input_file_compiler;
4184
4185 /* These are variables used within do_spec and do_spec_1.  */
4186
4187 /* Nonzero if an arg has been started and not yet terminated
4188    (with space, tab or newline).  */
4189 static int arg_going;
4190
4191 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4192    is a temporary file name.  */
4193 static int delete_this_arg;
4194
4195 /* Nonzero means %w has been seen; the next arg to be terminated
4196    is the output file name of this compilation.  */
4197 static int this_is_output_file;
4198
4199 /* Nonzero means %s has been seen; the next arg to be terminated
4200    is the name of a library file and we should try the standard
4201    search dirs for it.  */
4202 static int this_is_library_file;
4203
4204 /* Nonzero means %T has been seen; the next arg to be terminated
4205    is the name of a linker script and we should try all of the
4206    standard search dirs for it.  If it is found insert a --script
4207    command line switch and then substitute the full path in place,
4208    otherwise generate an error message.  */
4209 static int this_is_linker_script;
4210
4211 /* Nonzero means that the input of this command is coming from a pipe.  */
4212 static int input_from_pipe;
4213
4214 /* Nonnull means substitute this for any suffix when outputting a switches
4215    arguments.  */
4216 static const char *suffix_subst;
4217
4218 /* If there is an argument being accumulated, terminate it and store it.  */
4219
4220 static void
4221 end_going_arg (void)
4222 {
4223   if (arg_going)
4224     {
4225       const char *string;
4226
4227       obstack_1grow (&obstack, 0);
4228       string = XOBFINISH (&obstack, const char *);
4229       if (this_is_library_file)
4230         string = find_file (string);
4231       if (this_is_linker_script)
4232         {
4233           char * full_script_path = find_a_file (&startfile_prefixes, string, R_OK, true);
4234
4235           if (full_script_path == NULL)
4236             {
4237               error ("unable to locate default linker script %qs in the library search paths", string);
4238               /* Script was not found on search path.  */
4239               return;
4240             }
4241           store_arg ("--script", false, false);
4242           string = full_script_path;
4243         }
4244       store_arg (string, delete_this_arg, this_is_output_file);
4245       if (this_is_output_file)
4246         outfiles[input_file_number] = string;
4247       arg_going = 0;
4248     }
4249 }
4250
4251
4252 /* Parse the WRAPPER string which is a comma separated list of the command line
4253    and insert them into the beginning of argbuf.  */
4254
4255 static void
4256 insert_wrapper (const char *wrapper)
4257 {
4258   int n = 0;
4259   int i;
4260   char *buf = xstrdup (wrapper);
4261   char *p = buf;
4262   unsigned int old_length = argbuf.length ();
4263
4264   do
4265     {
4266       n++;
4267       while (*p == ',')
4268         p++;
4269     }
4270   while ((p = strchr (p, ',')) != NULL);
4271
4272   argbuf.safe_grow (old_length + n);
4273   memmove (argbuf.address () + n,
4274            argbuf.address (),
4275            old_length * sizeof (const_char_p));
4276
4277   i = 0;
4278   p = buf;
4279   do
4280     {
4281       while (*p == ',')
4282         {
4283           *p = 0;
4284           p++;
4285         }
4286       argbuf[i] = p;
4287       i++;
4288     }
4289   while ((p = strchr (p, ',')) != NULL);
4290   gcc_assert (i == n);
4291 }
4292
4293 /* Process the spec SPEC and run the commands specified therein.
4294    Returns 0 if the spec is successfully processed; -1 if failed.  */
4295
4296 int
4297 do_spec (const char *spec)
4298 {
4299   int value;
4300
4301   value = do_spec_2 (spec);
4302
4303   /* Force out any unfinished command.
4304      If -pipe, this forces out the last command if it ended in `|'.  */
4305   if (value == 0)
4306     {
4307       if (argbuf.length () > 0
4308           && !strcmp (argbuf.last (), "|"))
4309         argbuf.pop ();
4310
4311       set_collect_gcc_options ();
4312
4313       if (argbuf.length () > 0)
4314         value = execute ();
4315     }
4316
4317   return value;
4318 }
4319
4320 static int
4321 do_spec_2 (const char *spec)
4322 {
4323   int result;
4324
4325   clear_args ();
4326   arg_going = 0;
4327   delete_this_arg = 0;
4328   this_is_output_file = 0;
4329   this_is_library_file = 0;
4330   this_is_linker_script = 0;
4331   input_from_pipe = 0;
4332   suffix_subst = NULL;
4333
4334   result = do_spec_1 (spec, 0, NULL);
4335
4336   end_going_arg ();
4337
4338   return result;
4339 }
4340
4341
4342 /* Process the given spec string and add any new options to the end
4343    of the switches/n_switches array.  */
4344
4345 static void
4346 do_option_spec (const char *name, const char *spec)
4347 {
4348   unsigned int i, value_count, value_len;
4349   const char *p, *q, *value;
4350   char *tmp_spec, *tmp_spec_p;
4351
4352   if (configure_default_options[0].name == NULL)
4353     return;
4354
4355   for (i = 0; i < ARRAY_SIZE (configure_default_options); i++)
4356     if (strcmp (configure_default_options[i].name, name) == 0)
4357       break;
4358   if (i == ARRAY_SIZE (configure_default_options))
4359     return;
4360
4361   value = configure_default_options[i].value;
4362   value_len = strlen (value);
4363
4364   /* Compute the size of the final spec.  */
4365   value_count = 0;
4366   p = spec;
4367   while ((p = strstr (p, "%(VALUE)")) != NULL)
4368     {
4369       p ++;
4370       value_count ++;
4371     }
4372
4373   /* Replace each %(VALUE) by the specified value.  */
4374   tmp_spec = (char *) alloca (strlen (spec) + 1
4375                      + value_count * (value_len - strlen ("%(VALUE)")));
4376   tmp_spec_p = tmp_spec;
4377   q = spec;
4378   while ((p = strstr (q, "%(VALUE)")) != NULL)
4379     {
4380       memcpy (tmp_spec_p, q, p - q);
4381       tmp_spec_p = tmp_spec_p + (p - q);
4382       memcpy (tmp_spec_p, value, value_len);
4383       tmp_spec_p += value_len;
4384       q = p + strlen ("%(VALUE)");
4385     }
4386   strcpy (tmp_spec_p, q);
4387
4388   do_self_spec (tmp_spec);
4389 }
4390
4391 /* Process the given spec string and add any new options to the end
4392    of the switches/n_switches array.  */
4393
4394 static void
4395 do_self_spec (const char *spec)
4396 {
4397   int i;
4398
4399   do_spec_2 (spec);
4400   do_spec_1 (" ", 0, NULL);
4401
4402   /* Mark %<S switches processed by do_self_spec to be ignored permanently.
4403      do_self_specs adds the replacements to switches array, so it shouldn't
4404      be processed afterwards.  */
4405   for (i = 0; i < n_switches; i++)
4406     if ((switches[i].live_cond & SWITCH_IGNORE))
4407       switches[i].live_cond |= SWITCH_IGNORE_PERMANENTLY;
4408
4409   if (argbuf.length () > 0)
4410     {
4411       const char **argbuf_copy;
4412       struct cl_decoded_option *decoded_options;
4413       struct cl_option_handlers handlers;
4414       unsigned int decoded_options_count;
4415       unsigned int j;
4416
4417       /* Create a copy of argbuf with a dummy argv[0] entry for
4418          decode_cmdline_options_to_array.  */
4419       argbuf_copy = XNEWVEC (const char *,
4420                              argbuf.length () + 1);
4421       argbuf_copy[0] = "";
4422       memcpy (argbuf_copy + 1, argbuf.address (),
4423               argbuf.length () * sizeof (const char *));
4424
4425       decode_cmdline_options_to_array (argbuf.length () + 1,
4426                                        argbuf_copy,
4427                                        CL_DRIVER, &decoded_options,
4428                                        &decoded_options_count);
4429       free (argbuf_copy);
4430
4431       set_option_handlers (&handlers);
4432
4433       for (j = 1; j < decoded_options_count; j++)
4434         {
4435           switch (decoded_options[j].opt_index)
4436             {
4437             case OPT_SPECIAL_input_file:
4438               /* Specs should only generate options, not input
4439                  files.  */
4440               if (strcmp (decoded_options[j].arg, "-") != 0)
4441                 fatal_error ("switch %qs does not start with %<-%>",
4442                              decoded_options[j].arg);
4443               else
4444                 fatal_error ("spec-generated switch is just %<-%>");
4445               break;
4446
4447             case OPT_fcompare_debug_second:
4448             case OPT_fcompare_debug:
4449             case OPT_fcompare_debug_:
4450             case OPT_o:
4451               /* Avoid duplicate processing of some options from
4452                  compare-debug specs; just save them here.  */
4453               save_switch (decoded_options[j].canonical_option[0],
4454                            (decoded_options[j].canonical_option_num_elements
4455                             - 1),
4456                            &decoded_options[j].canonical_option[1], false, true);
4457               break;
4458
4459             default:
4460               read_cmdline_option (&global_options, &global_options_set,
4461                                    decoded_options + j, UNKNOWN_LOCATION,
4462                                    CL_DRIVER, &handlers, global_dc);
4463               break;
4464             }
4465         }
4466
4467       alloc_switch ();
4468       switches[n_switches].part1 = 0;
4469     }
4470 }
4471
4472 /* Callback for processing %D and %I specs.  */
4473
4474 struct spec_path_info {
4475   const char *option;
4476   const char *append;
4477   size_t append_len;
4478   bool omit_relative;
4479   bool separate_options;
4480 };
4481
4482 static void *
4483 spec_path (char *path, void *data)
4484 {
4485   struct spec_path_info *info = (struct spec_path_info *) data;
4486   size_t len = 0;
4487   char save = 0;
4488
4489   if (info->omit_relative && !IS_ABSOLUTE_PATH (path))
4490     return NULL;
4491
4492   if (info->append_len != 0)
4493     {
4494       len = strlen (path);
4495       memcpy (path + len, info->append, info->append_len + 1);
4496     }
4497
4498   if (!is_directory (path, true))
4499     return NULL;
4500
4501   do_spec_1 (info->option, 1, NULL);
4502   if (info->separate_options)
4503     do_spec_1 (" ", 0, NULL);
4504
4505   if (info->append_len == 0)
4506     {
4507       len = strlen (path);
4508       save = path[len - 1];
4509       if (IS_DIR_SEPARATOR (path[len - 1]))
4510         path[len - 1] = '\0';
4511     }
4512
4513   do_spec_1 (path, 1, NULL);
4514   do_spec_1 (" ", 0, NULL);
4515
4516   /* Must not damage the original path.  */
4517   if (info->append_len == 0)
4518     path[len - 1] = save;
4519
4520   return NULL;
4521 }
4522
4523 /* Create a temporary FILE with the contents of ARGV. Add @FILE to the
4524    argument list. */
4525
4526 static void
4527 create_at_file (char **argv)
4528 {
4529   char *temp_file = make_temp_file ("");
4530   char *at_argument = concat ("@", temp_file, NULL);
4531   FILE *f = fopen (temp_file, "w");
4532   int status;
4533
4534   if (f == NULL)
4535     fatal_error ("could not open temporary response file %s",
4536                  temp_file);
4537
4538   status = writeargv (argv, f);
4539
4540   if (status)
4541     fatal_error ("could not write to temporary response file %s",
4542                  temp_file);
4543
4544   status = fclose (f);
4545
4546   if (EOF == status)
4547     fatal_error ("could not close temporary response file %s",
4548                  temp_file);
4549
4550   store_arg (at_argument, 0, 0);
4551
4552   record_temp_file (temp_file, !save_temps_flag, !save_temps_flag);
4553 }
4554
4555 /* True if we should compile INFILE. */
4556
4557 static bool
4558 compile_input_file_p (struct infile *infile)
4559 {
4560   if ((!infile->language) || (infile->language[0] != '*'))
4561     if (infile->incompiler == input_file_compiler)
4562       return true;
4563   return false;
4564 }
4565
4566 /* Process each member of VEC as a spec.  */
4567
4568 static void
4569 do_specs_vec (vec<char_p> vec)
4570 {
4571   unsigned ix;
4572   char *opt;
4573
4574   FOR_EACH_VEC_ELT (vec, ix, opt)
4575     {
4576       do_spec_1 (opt, 1, NULL);
4577       /* Make each accumulated option a separate argument.  */
4578       do_spec_1 (" ", 0, NULL);
4579     }
4580 }
4581
4582 /* Process the sub-spec SPEC as a portion of a larger spec.
4583    This is like processing a whole spec except that we do
4584    not initialize at the beginning and we do not supply a
4585    newline by default at the end.
4586    INSWITCH nonzero means don't process %-sequences in SPEC;
4587    in this case, % is treated as an ordinary character.
4588    This is used while substituting switches.
4589    INSWITCH nonzero also causes SPC not to terminate an argument.
4590
4591    Value is zero unless a line was finished
4592    and the command on that line reported an error.  */
4593
4594 static int
4595 do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
4596 {
4597   const char *p = spec;
4598   int c;
4599   int i;
4600   int value;
4601
4602   /* If it's an empty string argument to a switch, keep it as is.  */
4603   if (inswitch && !*p)
4604     arg_going = 1;
4605
4606   while ((c = *p++))
4607     /* If substituting a switch, treat all chars like letters.
4608        Otherwise, NL, SPC, TAB and % are special.  */
4609     switch (inswitch ? 'a' : c)
4610       {
4611       case '\n':
4612         end_going_arg ();
4613
4614         if (argbuf.length () > 0
4615             && !strcmp (argbuf.last (), "|"))
4616           {
4617             /* A `|' before the newline means use a pipe here,
4618                but only if -pipe was specified.
4619                Otherwise, execute now and don't pass the `|' as an arg.  */
4620             if (use_pipes)
4621               {
4622                 input_from_pipe = 1;
4623                 break;
4624               }
4625             else
4626               argbuf.pop ();
4627           }
4628
4629         set_collect_gcc_options ();
4630
4631         if (argbuf.length () > 0)
4632           {
4633             value = execute ();
4634             if (value)
4635               return value;
4636           }
4637         /* Reinitialize for a new command, and for a new argument.  */
4638         clear_args ();
4639         arg_going = 0;
4640         delete_this_arg = 0;
4641         this_is_output_file = 0;
4642         this_is_library_file = 0;
4643         this_is_linker_script = 0;
4644         input_from_pipe = 0;
4645         break;
4646
4647       case '|':
4648         end_going_arg ();
4649
4650         /* Use pipe */
4651         obstack_1grow (&obstack, c);
4652         arg_going = 1;
4653         break;
4654
4655       case '\t':
4656       case ' ':
4657         end_going_arg ();
4658
4659         /* Reinitialize for a new argument.  */
4660         delete_this_arg = 0;
4661         this_is_output_file = 0;
4662         this_is_library_file = 0;
4663         this_is_linker_script = 0;
4664         break;
4665
4666       case '%':
4667         switch (c = *p++)
4668           {
4669           case 0:
4670             fatal_error ("spec %qs invalid", spec);
4671
4672           case 'b':
4673             if (save_temps_length)
4674               obstack_grow (&obstack, save_temps_prefix, save_temps_length);
4675             else
4676               obstack_grow (&obstack, input_basename, basename_length);
4677             if (compare_debug < 0)
4678               obstack_grow (&obstack, ".gk", 3);
4679             arg_going = 1;
4680             break;
4681
4682           case 'B':
4683             if (save_temps_length)
4684               obstack_grow (&obstack, save_temps_prefix, save_temps_length);
4685             else
4686               obstack_grow (&obstack, input_basename, suffixed_basename_length);
4687             if (compare_debug < 0)
4688               obstack_grow (&obstack, ".gk", 3);
4689             arg_going = 1;
4690             break;
4691
4692           case 'd':
4693             delete_this_arg = 2;
4694             break;
4695
4696           /* Dump out the directories specified with LIBRARY_PATH,
4697              followed by the absolute directories
4698              that we search for startfiles.  */
4699           case 'D':
4700             {
4701               struct spec_path_info info;
4702
4703               info.option = "-L";
4704               info.append_len = 0;
4705 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
4706               /* Used on systems which record the specified -L dirs
4707                  and use them to search for dynamic linking.
4708                  Relative directories always come from -B,
4709                  and it is better not to use them for searching
4710                  at run time.  In particular, stage1 loses.  */
4711               info.omit_relative = true;
4712 #else
4713               info.omit_relative = false;
4714 #endif
4715               info.separate_options = false;
4716
4717               for_each_path (&startfile_prefixes, true, 0, spec_path, &info);
4718             }
4719             break;
4720
4721           case 'e':
4722             /* %efoo means report an error with `foo' as error message
4723                and don't execute any more commands for this file.  */
4724             {
4725               const char *q = p;
4726               char *buf;
4727               while (*p != 0 && *p != '\n')
4728                 p++;
4729               buf = (char *) alloca (p - q + 1);
4730               strncpy (buf, q, p - q);
4731               buf[p - q] = 0;
4732               error ("%s", _(buf));
4733               return -1;
4734             }
4735             break;
4736           case 'n':
4737             /* %nfoo means report a notice with `foo' on stderr.  */
4738             {
4739               const char *q = p;
4740               char *buf;
4741               while (*p != 0 && *p != '\n')
4742                 p++;
4743               buf = (char *) alloca (p - q + 1);
4744               strncpy (buf, q, p - q);
4745               buf[p - q] = 0;
4746               inform (0, "%s", _(buf));
4747               if (*p)
4748                 p++;
4749             }
4750             break;
4751
4752           case 'j':
4753             {
4754               struct stat st;
4755
4756               /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
4757                  defined, and it is not a directory, and it is
4758                  writable, use it.  Otherwise, treat this like any
4759                  other temporary file.  */
4760
4761               if ((!save_temps_flag)
4762                   && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode))
4763                   && (access (HOST_BIT_BUCKET, W_OK) == 0))
4764                 {
4765                   obstack_grow (&obstack, HOST_BIT_BUCKET,
4766                                 strlen (HOST_BIT_BUCKET));
4767                   delete_this_arg = 0;
4768                   arg_going = 1;
4769                   break;
4770                 }
4771             }
4772             goto create_temp_file;
4773           case '|':
4774             if (use_pipes)
4775               {
4776                 obstack_1grow (&obstack, '-');
4777                 delete_this_arg = 0;
4778                 arg_going = 1;
4779
4780                 /* consume suffix */
4781                 while (*p == '.' || ISALNUM ((unsigned char) *p))
4782                   p++;
4783                 if (p[0] == '%' && p[1] == 'O')
4784                   p += 2;
4785
4786                 break;
4787               }
4788             goto create_temp_file;
4789           case 'm':
4790             if (use_pipes)
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 'g':
4802           case 'u':
4803           case 'U':
4804           create_temp_file:
4805               {
4806                 struct temp_name *t;
4807                 int suffix_length;
4808                 const char *suffix = p;
4809                 char *saved_suffix = NULL;
4810
4811                 while (*p == '.' || ISALNUM ((unsigned char) *p))
4812                   p++;
4813                 suffix_length = p - suffix;
4814                 if (p[0] == '%' && p[1] == 'O')
4815                   {
4816                     p += 2;
4817                     /* We don't support extra suffix characters after %O.  */
4818                     if (*p == '.' || ISALNUM ((unsigned char) *p))
4819                       fatal_error ("spec %qs has invalid %<%%0%c%>", spec, *p);
4820                     if (suffix_length == 0)
4821                       suffix = TARGET_OBJECT_SUFFIX;
4822                     else
4823                       {
4824                         saved_suffix
4825                           = XNEWVEC (char, suffix_length
4826                                      + strlen (TARGET_OBJECT_SUFFIX));
4827                         strncpy (saved_suffix, suffix, suffix_length);
4828                         strcpy (saved_suffix + suffix_length,
4829                                 TARGET_OBJECT_SUFFIX);
4830                       }
4831                     suffix_length += strlen (TARGET_OBJECT_SUFFIX);
4832                   }
4833
4834                 if (compare_debug < 0)
4835                   {
4836                     suffix = concat (".gk", suffix, NULL);
4837                     suffix_length += 3;
4838                   }
4839
4840                 /* If -save-temps=obj and -o were specified, use that for the
4841                    temp file.  */
4842                 if (save_temps_length)
4843                   {
4844                     char *tmp;
4845                     temp_filename_length
4846                       = save_temps_length + suffix_length + 1;
4847                     tmp = (char *) alloca (temp_filename_length);
4848                     memcpy (tmp, save_temps_prefix, save_temps_length);
4849                     memcpy (tmp + save_temps_length, suffix, suffix_length);
4850                     tmp[save_temps_length + suffix_length] = '\0';
4851                     temp_filename = save_string (tmp, save_temps_length
4852                                                       + suffix_length);
4853                     obstack_grow (&obstack, temp_filename,
4854                                   temp_filename_length);
4855                     arg_going = 1;
4856                     delete_this_arg = 0;
4857                     break;
4858                   }
4859
4860                 /* If the gcc_input_filename has the same suffix specified
4861                    for the %g, %u, or %U, and -save-temps is specified,
4862                    we could end up using that file as an intermediate
4863                    thus clobbering the user's source file (.e.g.,
4864                    gcc -save-temps foo.s would clobber foo.s with the
4865                    output of cpp0).  So check for this condition and
4866                    generate a temp file as the intermediate.  */
4867
4868                 if (save_temps_flag)
4869                   {
4870                     char *tmp;
4871                     temp_filename_length = basename_length + suffix_length + 1;
4872                     tmp = (char *) alloca (temp_filename_length);
4873                     memcpy (tmp, input_basename, basename_length);
4874                     memcpy (tmp + basename_length, suffix, suffix_length);
4875                     tmp[basename_length + suffix_length] = '\0';
4876                     temp_filename = tmp;
4877
4878                     if (filename_cmp (temp_filename, gcc_input_filename) != 0)
4879                       {
4880 #ifndef HOST_LACKS_INODE_NUMBERS
4881                         struct stat st_temp;
4882
4883                         /* Note, set_input() resets input_stat_set to 0.  */
4884                         if (input_stat_set == 0)
4885                           {
4886                             input_stat_set = stat (gcc_input_filename,
4887                                                    &input_stat);
4888                             if (input_stat_set >= 0)
4889                               input_stat_set = 1;
4890                           }
4891
4892                         /* If we have the stat for the gcc_input_filename
4893                            and we can do the stat for the temp_filename
4894                            then the they could still refer to the same
4895                            file if st_dev/st_ino's are the same.  */
4896                         if (input_stat_set != 1
4897                             || stat (temp_filename, &st_temp) < 0
4898                             || input_stat.st_dev != st_temp.st_dev
4899                             || input_stat.st_ino != st_temp.st_ino)
4900 #else
4901                         /* Just compare canonical pathnames.  */
4902                         char* input_realname = lrealpath (gcc_input_filename);
4903                         char* temp_realname = lrealpath (temp_filename);
4904                         bool files_differ = filename_cmp (input_realname, temp_realname);
4905                         free (input_realname);
4906                         free (temp_realname);
4907                         if (files_differ)
4908 #endif
4909                           {
4910                             temp_filename = save_string (temp_filename,
4911                                                          temp_filename_length + 1);
4912                             obstack_grow (&obstack, temp_filename,
4913                                                     temp_filename_length);
4914                             arg_going = 1;
4915                             delete_this_arg = 0;
4916                             break;
4917                           }
4918                       }
4919                   }
4920
4921                 /* See if we already have an association of %g/%u/%U and
4922                    suffix.  */
4923                 for (t = temp_names; t; t = t->next)
4924                   if (t->length == suffix_length
4925                       && strncmp (t->suffix, suffix, suffix_length) == 0
4926                       && t->unique == (c == 'u' || c == 'U' || c == 'j'))
4927                     break;
4928
4929                 /* Make a new association if needed.  %u and %j
4930                    require one.  */
4931                 if (t == 0 || c == 'u' || c == 'j')
4932                   {
4933                     if (t == 0)
4934                       {
4935                         t = XNEW (struct temp_name);
4936                         t->next = temp_names;
4937                         temp_names = t;
4938                       }
4939                     t->length = suffix_length;
4940                     if (saved_suffix)
4941                       {
4942                         t->suffix = saved_suffix;
4943                         saved_suffix = NULL;
4944                       }
4945                     else
4946                       t->suffix = save_string (suffix, suffix_length);
4947                     t->unique = (c == 'u' || c == 'U' || c == 'j');
4948                     temp_filename = make_temp_file (t->suffix);
4949                     temp_filename_length = strlen (temp_filename);
4950                     t->filename = temp_filename;
4951                     t->filename_length = temp_filename_length;
4952                   }
4953
4954                 free (saved_suffix);
4955
4956                 obstack_grow (&obstack, t->filename, t->filename_length);
4957                 delete_this_arg = 1;
4958               }
4959             arg_going = 1;
4960             break;
4961
4962           case 'i':
4963             if (combine_inputs)
4964               {
4965                 if (at_file_supplied)
4966                   {
4967                     /* We are going to expand `%i' to `@FILE', where FILE
4968                        is a newly-created temporary filename.  The filenames
4969                        that would usually be expanded in place of %o will be
4970                        written to the temporary file.  */
4971                     char **argv;
4972                     int n_files = 0;
4973                     int j;
4974
4975                     for (i = 0; i < n_infiles; i++)
4976                       if (compile_input_file_p (&infiles[i]))
4977                         n_files++;
4978
4979                     argv = (char **) alloca (sizeof (char *) * (n_files + 1));
4980
4981                     /* Copy the strings over.  */
4982                     for (i = 0, j = 0; i < n_infiles; i++)
4983                       if (compile_input_file_p (&infiles[i]))
4984                         {
4985                           argv[j] = CONST_CAST (char *, infiles[i].name);
4986                           infiles[i].compiled = true;
4987                           j++;
4988                         }
4989                     argv[j] = NULL;
4990
4991                     create_at_file (argv);
4992                   }
4993                 else
4994                   for (i = 0; (int) i < n_infiles; i++)
4995                     if (compile_input_file_p (&infiles[i]))
4996                       {
4997                         store_arg (infiles[i].name, 0, 0);
4998                         infiles[i].compiled = true;
4999                       }
5000               }
5001             else
5002               {
5003                 obstack_grow (&obstack, gcc_input_filename,
5004                               input_filename_length);
5005                 arg_going = 1;
5006               }
5007             break;
5008
5009           case 'I':
5010             {
5011               struct spec_path_info info;
5012
5013               if (multilib_dir)
5014                 {
5015                   do_spec_1 ("-imultilib", 1, NULL);
5016                   /* Make this a separate argument.  */
5017                   do_spec_1 (" ", 0, NULL);
5018                   do_spec_1 (multilib_dir, 1, NULL);
5019                   do_spec_1 (" ", 0, NULL);
5020                 }
5021
5022               if (multiarch_dir)
5023                 {
5024                   do_spec_1 ("-imultiarch", 1, NULL);
5025                   /* Make this a separate argument.  */
5026                   do_spec_1 (" ", 0, NULL);
5027                   do_spec_1 (multiarch_dir, 1, NULL);
5028                   do_spec_1 (" ", 0, NULL);
5029                 }
5030
5031               if (gcc_exec_prefix)
5032                 {
5033                   do_spec_1 ("-iprefix", 1, NULL);
5034                   /* Make this a separate argument.  */
5035                   do_spec_1 (" ", 0, NULL);
5036                   do_spec_1 (gcc_exec_prefix, 1, NULL);
5037                   do_spec_1 (" ", 0, NULL);
5038                 }
5039
5040               if (target_system_root_changed ||
5041                   (target_system_root && target_sysroot_hdrs_suffix))
5042                 {
5043                   do_spec_1 ("-isysroot", 1, NULL);
5044                   /* Make this a separate argument.  */
5045                   do_spec_1 (" ", 0, NULL);
5046                   do_spec_1 (target_system_root, 1, NULL);
5047                   if (target_sysroot_hdrs_suffix)
5048                     do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL);
5049                   do_spec_1 (" ", 0, NULL);
5050                 }
5051
5052               info.option = "-isystem";
5053               info.append = "include";
5054               info.append_len = strlen (info.append);
5055               info.omit_relative = false;
5056               info.separate_options = true;
5057
5058               for_each_path (&include_prefixes, false, info.append_len,
5059                              spec_path, &info);
5060
5061               info.append = "include-fixed";
5062               if (*sysroot_hdrs_suffix_spec)
5063                 info.append = concat (info.append, dir_separator_str,
5064                                       multilib_dir, NULL);
5065               info.append_len = strlen (info.append);
5066               for_each_path (&include_prefixes, false, info.append_len,
5067                              spec_path, &info);
5068             }
5069             break;
5070
5071           case 'o':
5072             {
5073               int max = n_infiles;
5074               max += lang_specific_extra_outfiles;
5075
5076               if (HAVE_GNU_LD && at_file_supplied)
5077                 {
5078                   /* We are going to expand `%o' to `@FILE', where FILE
5079                      is a newly-created temporary filename.  The filenames
5080                      that would usually be expanded in place of %o will be
5081                      written to the temporary file.  */
5082
5083                   char **argv;
5084                   int n_files, j;
5085
5086                   /* Convert OUTFILES into a form suitable for writeargv.  */
5087
5088                   /* Determine how many are non-NULL.  */
5089                   for (n_files = 0, i = 0; i < max; i++)
5090                     n_files += outfiles[i] != NULL;
5091
5092                   argv = (char **) alloca (sizeof (char *) * (n_files + 1));
5093
5094                   /* Copy the strings over.  */
5095                   for (i = 0, j = 0; i < max; i++)
5096                     if (outfiles[i])
5097                       {
5098                         argv[j] = CONST_CAST (char *, outfiles[i]);
5099                         j++;
5100                       }
5101                   argv[j] = NULL;
5102
5103                   create_at_file (argv);
5104                 }
5105               else
5106                 for (i = 0; i < max; i++)
5107                   if (outfiles[i])
5108                     store_arg (outfiles[i], 0, 0);
5109               break;
5110             }
5111
5112           case 'O':
5113             obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
5114             arg_going = 1;
5115             break;
5116
5117           case 's':
5118             this_is_library_file = 1;
5119             break;
5120
5121           case 'T':
5122             this_is_linker_script = 1;
5123             break;
5124
5125           case 'V':
5126             outfiles[input_file_number] = NULL;
5127             break;
5128
5129           case 'w':
5130             this_is_output_file = 1;
5131             break;
5132
5133           case 'W':
5134             {
5135               unsigned int cur_index = argbuf.length ();
5136               /* Handle the {...} following the %W.  */
5137               if (*p != '{')
5138                 fatal_error ("spec %qs has invalid %<%%W%c%>", spec, *p);
5139               p = handle_braces (p + 1);
5140               if (p == 0)
5141                 return -1;
5142               end_going_arg ();
5143               /* If any args were output, mark the last one for deletion
5144                  on failure.  */
5145               if (argbuf.length () != cur_index)
5146                 record_temp_file (argbuf.last (), 0, 1);
5147               break;
5148             }
5149
5150           /* %x{OPTION} records OPTION for %X to output.  */
5151           case 'x':
5152             {
5153               const char *p1 = p;
5154               char *string;
5155               char *opt;
5156               unsigned ix;
5157
5158               /* Skip past the option value and make a copy.  */
5159               if (*p != '{')
5160                 fatal_error ("spec %qs has invalid %<%%x%c%>", spec, *p);
5161               while (*p++ != '}')
5162                 ;
5163               string = save_string (p1 + 1, p - p1 - 2);
5164
5165               /* See if we already recorded this option.  */
5166               FOR_EACH_VEC_ELT (linker_options, ix, opt)
5167                 if (! strcmp (string, opt))
5168                   {
5169                     free (string);
5170                     return 0;
5171                   }
5172
5173               /* This option is new; add it.  */
5174               add_linker_option (string, strlen (string));
5175               free (string);
5176             }
5177             break;
5178
5179           /* Dump out the options accumulated previously using %x.  */
5180           case 'X':
5181             do_specs_vec (linker_options);
5182             break;
5183
5184           /* Dump out the options accumulated previously using -Wa,.  */
5185           case 'Y':
5186             do_specs_vec (assembler_options);
5187             break;
5188
5189           /* Dump out the options accumulated previously using -Wp,.  */
5190           case 'Z':
5191             do_specs_vec (preprocessor_options);
5192             break;
5193
5194             /* Here are digits and numbers that just process
5195                a certain constant string as a spec.  */
5196
5197           case '1':
5198             value = do_spec_1 (cc1_spec, 0, NULL);
5199             if (value != 0)
5200               return value;
5201             break;
5202
5203           case '2':
5204             value = do_spec_1 (cc1plus_spec, 0, NULL);
5205             if (value != 0)
5206               return value;
5207             break;
5208
5209           case 'a':
5210             value = do_spec_1 (asm_spec, 0, NULL);
5211             if (value != 0)
5212               return value;
5213             break;
5214
5215           case 'A':
5216             value = do_spec_1 (asm_final_spec, 0, NULL);
5217             if (value != 0)
5218               return value;
5219             break;
5220
5221           case 'C':
5222             {
5223               const char *const spec
5224                 = (input_file_compiler->cpp_spec
5225                    ? input_file_compiler->cpp_spec
5226                    : cpp_spec);
5227               value = do_spec_1 (spec, 0, NULL);
5228               if (value != 0)
5229                 return value;
5230             }
5231             break;
5232
5233           case 'E':
5234             value = do_spec_1 (endfile_spec, 0, NULL);
5235             if (value != 0)
5236               return value;
5237             break;
5238
5239           case 'l':
5240             value = do_spec_1 (link_spec, 0, NULL);
5241             if (value != 0)
5242               return value;
5243             break;
5244
5245           case 'L':
5246             value = do_spec_1 (lib_spec, 0, NULL);
5247             if (value != 0)
5248               return value;
5249             break;
5250
5251           case 'M':
5252             if (multilib_os_dir == NULL)
5253               obstack_1grow (&obstack, '.');
5254             else
5255               obstack_grow (&obstack, multilib_os_dir,
5256                             strlen (multilib_os_dir));
5257             break;
5258
5259           case 'G':
5260             value = do_spec_1 (libgcc_spec, 0, NULL);
5261             if (value != 0)
5262               return value;
5263             break;
5264
5265           case 'R':
5266             /* We assume there is a directory
5267                separator at the end of this string.  */
5268             if (target_system_root)
5269               {
5270                 obstack_grow (&obstack, target_system_root,
5271                               strlen (target_system_root));
5272                 if (target_sysroot_suffix)
5273                   obstack_grow (&obstack, target_sysroot_suffix,
5274                                 strlen (target_sysroot_suffix));
5275               }
5276             break;
5277
5278           case 'S':
5279             value = do_spec_1 (startfile_spec, 0, NULL);
5280             if (value != 0)
5281               return value;
5282             break;
5283
5284             /* Here we define characters other than letters and digits.  */
5285
5286           case '{':
5287             p = handle_braces (p);
5288             if (p == 0)
5289               return -1;
5290             break;
5291
5292           case ':':
5293             p = handle_spec_function (p, NULL);
5294             if (p == 0)
5295               return -1;
5296             break;
5297
5298           case '%':
5299             obstack_1grow (&obstack, '%');
5300             break;
5301
5302           case '.':
5303             {
5304               unsigned len = 0;
5305
5306               while (p[len] && p[len] != ' ' && p[len] != '%')
5307                 len++;
5308               suffix_subst = save_string (p - 1, len + 1);
5309               p += len;
5310             }
5311            break;
5312
5313            /* Henceforth ignore the option(s) matching the pattern
5314               after the %<.  */
5315           case '<':
5316           case '>':
5317             {
5318               unsigned len = 0;
5319               int have_wildcard = 0;
5320               int i;
5321               int switch_option;
5322
5323               if (c == '>')
5324                 switch_option = SWITCH_IGNORE | SWITCH_KEEP_FOR_GCC;
5325               else
5326                 switch_option = SWITCH_IGNORE;
5327
5328               while (p[len] && p[len] != ' ' && p[len] != '\t')
5329                 len++;
5330
5331               if (p[len-1] == '*')
5332                 have_wildcard = 1;
5333
5334               for (i = 0; i < n_switches; i++)
5335                 if (!strncmp (switches[i].part1, p, len - have_wildcard)
5336                     && (have_wildcard || switches[i].part1[len] == '\0'))
5337                   {
5338                     switches[i].live_cond |= switch_option;
5339                     /* User switch be validated from validate_all_switches.
5340                        when the definition is seen from the spec file.
5341                        If not defined anywhere, will be rejected.  */
5342                     if (switches[i].known)
5343                       switches[i].validated = true;
5344                   }
5345
5346               p += len;
5347             }
5348             break;
5349
5350           case '*':
5351             if (soft_matched_part)
5352               {
5353                 if (soft_matched_part[0])
5354                   do_spec_1 (soft_matched_part, 1, NULL);
5355                 do_spec_1 (" ", 0, NULL);
5356               }
5357             else
5358               /* Catch the case where a spec string contains something like
5359                  '%{foo:%*}'.  i.e. there is no * in the pattern on the left
5360                  hand side of the :.  */
5361               error ("spec failure: %<%%*%> has not been initialized by pattern match");
5362             break;
5363
5364             /* Process a string found as the value of a spec given by name.
5365                This feature allows individual machine descriptions
5366                to add and use their own specs.  */
5367           case '(':
5368             {
5369               const char *name = p;
5370               struct spec_list *sl;
5371               int len;
5372
5373               /* The string after the S/P is the name of a spec that is to be
5374                  processed.  */
5375               while (*p && *p != ')')
5376                 p++;
5377
5378               /* See if it's in the list.  */
5379               for (len = p - name, sl = specs; sl; sl = sl->next)
5380                 if (sl->name_len == len && !strncmp (sl->name, name, len))
5381                   {
5382                     name = *(sl->ptr_spec);
5383 #ifdef DEBUG_SPECS
5384                     fnotice (stderr, "Processing spec (%s), which is '%s'\n",
5385                              sl->name, name);
5386 #endif
5387                     break;
5388                   }
5389
5390               if (sl)
5391                 {
5392                   value = do_spec_1 (name, 0, NULL);
5393                   if (value != 0)
5394                     return value;
5395                 }
5396
5397               /* Discard the closing paren.  */
5398               if (*p)
5399                 p++;
5400             }
5401             break;
5402
5403           default:
5404             error ("spec failure: unrecognized spec option %qc", c);
5405             break;
5406           }
5407         break;
5408
5409       case '\\':
5410         /* Backslash: treat next character as ordinary.  */
5411         c = *p++;
5412
5413         /* Fall through.  */
5414       default:
5415         /* Ordinary character: put it into the current argument.  */
5416         obstack_1grow (&obstack, c);
5417         arg_going = 1;
5418       }
5419
5420   /* End of string.  If we are processing a spec function, we need to
5421      end any pending argument.  */
5422   if (processing_spec_function)
5423     end_going_arg ();
5424
5425   return 0;
5426 }
5427
5428 /* Look up a spec function.  */
5429
5430 static const struct spec_function *
5431 lookup_spec_function (const char *name)
5432 {
5433   const struct spec_function *sf;
5434
5435   for (sf = static_spec_functions; sf->name != NULL; sf++)
5436     if (strcmp (sf->name, name) == 0)
5437       return sf;
5438
5439   return NULL;
5440 }
5441
5442 /* Evaluate a spec function.  */
5443
5444 static const char *
5445 eval_spec_function (const char *func, const char *args)
5446 {
5447   const struct spec_function *sf;
5448   const char *funcval;
5449
5450   /* Saved spec processing context.  */
5451   vec<const_char_p> save_argbuf;
5452
5453   int save_arg_going;
5454   int save_delete_this_arg;
5455   int save_this_is_output_file;
5456   int save_this_is_library_file;
5457   int save_input_from_pipe;
5458   int save_this_is_linker_script;
5459   const char *save_suffix_subst;
5460
5461   int save_growing_size;
5462   void *save_growing_value;
5463
5464   sf = lookup_spec_function (func);
5465   if (sf == NULL)
5466     fatal_error ("unknown spec function %qs", func);
5467
5468   /* Push the spec processing context.  */
5469   save_argbuf = argbuf;
5470
5471   save_arg_going = arg_going;
5472   save_delete_this_arg = delete_this_arg;
5473   save_this_is_output_file = this_is_output_file;
5474   save_this_is_library_file = this_is_library_file;
5475   save_this_is_linker_script = this_is_linker_script;
5476   save_input_from_pipe = input_from_pipe;
5477   save_suffix_subst = suffix_subst;
5478
5479   /* If we have some object growing now, finalize it so the args and function
5480      eval proceed from a cleared context.  This is needed to prevent the first
5481      constructed arg from mistakenly including the growing value.  We'll push
5482      this value back on the obstack once the function evaluation is done, to
5483      restore a consistent processing context for our caller.  This is fine as
5484      the address of growing objects isn't guaranteed to remain stable until
5485      they are finalized, and we expect this situation to be rare enough for
5486      the extra copy not to be an issue.  */
5487   save_growing_size = obstack_object_size (&obstack);
5488   if (save_growing_size > 0)
5489     save_growing_value = obstack_finish (&obstack);
5490
5491   /* Create a new spec processing context, and build the function
5492      arguments.  */
5493
5494   alloc_args ();
5495   if (do_spec_2 (args) < 0)
5496     fatal_error ("error in args to spec function %qs", func);
5497
5498   /* argbuf_index is an index for the next argument to be inserted, and
5499      so contains the count of the args already inserted.  */
5500
5501   funcval = (*sf->func) (argbuf.length (),
5502                          argbuf.address ());
5503
5504   /* Pop the spec processing context.  */
5505   argbuf.release ();
5506   argbuf = save_argbuf;
5507
5508   arg_going = save_arg_going;
5509   delete_this_arg = save_delete_this_arg;
5510   this_is_output_file = save_this_is_output_file;
5511   this_is_library_file = save_this_is_library_file;
5512   this_is_linker_script = save_this_is_linker_script;
5513   input_from_pipe = save_input_from_pipe;
5514   suffix_subst = save_suffix_subst;
5515
5516   if (save_growing_size > 0)
5517     obstack_grow (&obstack, save_growing_value, save_growing_size);
5518
5519   return funcval;
5520 }
5521
5522 /* Handle a spec function call of the form:
5523
5524    %:function(args)
5525
5526    ARGS is processed as a spec in a separate context and split into an
5527    argument vector in the normal fashion.  The function returns a string
5528    containing a spec which we then process in the caller's context, or
5529    NULL if no processing is required.
5530
5531    If RETVAL_NONNULL is not NULL, then store a bool whether function
5532    returned non-NULL.  */
5533
5534 static const char *
5535 handle_spec_function (const char *p, bool *retval_nonnull)
5536 {
5537   char *func, *args;
5538   const char *endp, *funcval;
5539   int count;
5540
5541   processing_spec_function++;
5542
5543   /* Get the function name.  */
5544   for (endp = p; *endp != '\0'; endp++)
5545     {
5546       if (*endp == '(')         /* ) */
5547         break;
5548       /* Only allow [A-Za-z0-9], -, and _ in function names.  */
5549       if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_'))
5550         fatal_error ("malformed spec function name");
5551     }
5552   if (*endp != '(')             /* ) */
5553     fatal_error ("no arguments for spec function");
5554   func = save_string (p, endp - p);
5555   p = ++endp;
5556
5557   /* Get the arguments.  */
5558   for (count = 0; *endp != '\0'; endp++)
5559     {
5560       /* ( */
5561       if (*endp == ')')
5562         {
5563           if (count == 0)
5564             break;
5565           count--;
5566         }
5567       else if (*endp == '(')    /* ) */
5568         count++;
5569     }
5570   /* ( */
5571   if (*endp != ')')
5572     fatal_error ("malformed spec function arguments");
5573   args = save_string (p, endp - p);
5574   p = ++endp;
5575
5576   /* p now points to just past the end of the spec function expression.  */
5577
5578   funcval = eval_spec_function (func, args);
5579   if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0)
5580     p = NULL;
5581   if (retval_nonnull)
5582     *retval_nonnull = funcval != NULL;
5583
5584   free (func);
5585   free (args);
5586
5587   processing_spec_function--;
5588
5589   return p;
5590 }
5591
5592 /* Inline subroutine of handle_braces.  Returns true if the current
5593    input suffix matches the atom bracketed by ATOM and END_ATOM.  */
5594 static inline bool
5595 input_suffix_matches (const char *atom, const char *end_atom)
5596 {
5597   return (input_suffix
5598           && !strncmp (input_suffix, atom, end_atom - atom)
5599           && input_suffix[end_atom - atom] == '\0');
5600 }
5601
5602 /* Subroutine of handle_braces.  Returns true if the current
5603    input file's spec name matches the atom bracketed by ATOM and END_ATOM.  */
5604 static bool
5605 input_spec_matches (const char *atom, const char *end_atom)
5606 {
5607   return (input_file_compiler
5608           && input_file_compiler->suffix
5609           && input_file_compiler->suffix[0] != '\0'
5610           && !strncmp (input_file_compiler->suffix + 1, atom,
5611                        end_atom - atom)
5612           && input_file_compiler->suffix[end_atom - atom + 1] == '\0');
5613 }
5614
5615 /* Subroutine of handle_braces.  Returns true if a switch
5616    matching the atom bracketed by ATOM and END_ATOM appeared on the
5617    command line.  */
5618 static bool
5619 switch_matches (const char *atom, const char *end_atom, int starred)
5620 {
5621   int i;
5622   int len = end_atom - atom;
5623   int plen = starred ? len : -1;
5624
5625   for (i = 0; i < n_switches; i++)
5626     if (!strncmp (switches[i].part1, atom, len)
5627         && (starred || switches[i].part1[len] == '\0')
5628         && check_live_switch (i, plen))
5629       return true;
5630
5631     /* Check if a switch with separated form matching the atom.
5632        We check -D and -U switches. */
5633     else if (switches[i].args != 0)
5634       {
5635         if ((*switches[i].part1 == 'D' || *switches[i].part1 == 'U')
5636             && *switches[i].part1 == atom[0])
5637           {
5638             if (!strncmp (switches[i].args[0], &atom[1], len - 1)
5639                 && (starred || (switches[i].part1[1] == '\0'
5640                                 && switches[i].args[0][len - 1] == '\0'))
5641                 && check_live_switch (i, (starred ? 1 : -1)))
5642               return true;
5643           }
5644       }
5645
5646   return false;
5647 }
5648
5649 /* Inline subroutine of handle_braces.  Mark all of the switches which
5650    match ATOM (extends to END_ATOM; STARRED indicates whether there
5651    was a star after the atom) for later processing.  */
5652 static inline void
5653 mark_matching_switches (const char *atom, const char *end_atom, int starred)
5654 {
5655   int i;
5656   int len = end_atom - atom;
5657   int plen = starred ? len : -1;
5658
5659   for (i = 0; i < n_switches; i++)
5660     if (!strncmp (switches[i].part1, atom, len)
5661         && (starred || switches[i].part1[len] == '\0')
5662         && check_live_switch (i, plen))
5663       switches[i].ordering = 1;
5664 }
5665
5666 /* Inline subroutine of handle_braces.  Process all the currently
5667    marked switches through give_switch, and clear the marks.  */
5668 static inline void
5669 process_marked_switches (void)
5670 {
5671   int i;
5672
5673   for (i = 0; i < n_switches; i++)
5674     if (switches[i].ordering == 1)
5675       {
5676         switches[i].ordering = 0;
5677         give_switch (i, 0);
5678       }
5679 }
5680
5681 /* Handle a %{ ... } construct.  P points just inside the leading {.
5682    Returns a pointer one past the end of the brace block, or 0
5683    if we call do_spec_1 and that returns -1.  */
5684
5685 static const char *
5686 handle_braces (const char *p)
5687 {
5688   const char *atom, *end_atom;
5689   const char *d_atom = NULL, *d_end_atom = NULL;
5690   const char *orig = p;
5691
5692   bool a_is_suffix;
5693   bool a_is_spectype;
5694   bool a_is_starred;
5695   bool a_is_negated;
5696   bool a_matched;
5697
5698   bool a_must_be_last = false;
5699   bool ordered_set    = false;
5700   bool disjunct_set   = false;
5701   bool disj_matched   = false;
5702   bool disj_starred   = true;
5703   bool n_way_choice   = false;
5704   bool n_way_matched  = false;
5705
5706 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
5707
5708   do
5709     {
5710       if (a_must_be_last)
5711         goto invalid;
5712
5713       /* Scan one "atom" (S in the description above of %{}, possibly
5714          with '!', '.', '@', ',', or '*' modifiers).  */
5715       a_matched = false;
5716       a_is_suffix = false;
5717       a_is_starred = false;
5718       a_is_negated = false;
5719       a_is_spectype = false;
5720
5721       SKIP_WHITE ();
5722       if (*p == '!')
5723         p++, a_is_negated = true;
5724
5725       SKIP_WHITE ();
5726       if (*p == '%' && p[1] == ':')
5727         {
5728           atom = NULL;
5729           end_atom = NULL;
5730           p = handle_spec_function (p + 2, &a_matched);
5731         }
5732       else
5733         {
5734           if (*p == '.')
5735             p++, a_is_suffix = true;
5736           else if (*p == ',')
5737             p++, a_is_spectype = true;
5738
5739           atom = p;
5740           while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
5741                  || *p == ',' || *p == '.' || *p == '@')
5742             p++;
5743           end_atom = p;
5744
5745           if (*p == '*')
5746             p++, a_is_starred = 1;
5747         }
5748
5749       SKIP_WHITE ();
5750       switch (*p)
5751         {
5752         case '&': case '}':
5753           /* Substitute the switch(es) indicated by the current atom.  */
5754           ordered_set = true;
5755           if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix
5756               || a_is_spectype || atom == end_atom)
5757             goto invalid;
5758
5759           mark_matching_switches (atom, end_atom, a_is_starred);
5760
5761           if (*p == '}')
5762             process_marked_switches ();
5763           break;
5764
5765         case '|': case ':':
5766           /* Substitute some text if the current atom appears as a switch
5767              or suffix.  */
5768           disjunct_set = true;
5769           if (ordered_set)
5770             goto invalid;
5771
5772           if (atom && atom == end_atom)
5773             {
5774               if (!n_way_choice || disj_matched || *p == '|'
5775                   || a_is_negated || a_is_suffix || a_is_spectype
5776                   || a_is_starred)
5777                 goto invalid;
5778
5779               /* An empty term may appear as the last choice of an
5780                  N-way choice set; it means "otherwise".  */
5781               a_must_be_last = true;
5782               disj_matched = !n_way_matched;
5783               disj_starred = false;
5784             }
5785           else
5786             {
5787               if ((a_is_suffix || a_is_spectype) && a_is_starred)
5788                 goto invalid;
5789
5790               if (!a_is_starred)
5791                 disj_starred = false;
5792
5793               /* Don't bother testing this atom if we already have a
5794                  match.  */
5795               if (!disj_matched && !n_way_matched)
5796                 {
5797                   if (atom == NULL)
5798                     /* a_matched is already set by handle_spec_function.  */;
5799                   else if (a_is_suffix)
5800                     a_matched = input_suffix_matches (atom, end_atom);
5801                   else if (a_is_spectype)
5802                     a_matched = input_spec_matches (atom, end_atom);
5803                   else
5804                     a_matched = switch_matches (atom, end_atom, a_is_starred);
5805
5806                   if (a_matched != a_is_negated)
5807                     {
5808                       disj_matched = true;
5809                       d_atom = atom;
5810                       d_end_atom = end_atom;
5811                     }
5812                 }
5813             }
5814
5815           if (*p == ':')
5816             {
5817               /* Found the body, that is, the text to substitute if the
5818                  current disjunction matches.  */
5819               p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred,
5820                                       disj_matched && !n_way_matched);
5821               if (p == 0)
5822                 return 0;
5823
5824               /* If we have an N-way choice, reset state for the next
5825                  disjunction.  */
5826               if (*p == ';')
5827                 {
5828                   n_way_choice = true;
5829                   n_way_matched |= disj_matched;
5830                   disj_matched = false;
5831                   disj_starred = true;
5832                   d_atom = d_end_atom = NULL;
5833                 }
5834             }
5835           break;
5836
5837         default:
5838           goto invalid;
5839         }
5840     }
5841   while (*p++ != '}');
5842
5843   return p;
5844
5845  invalid:
5846   fatal_error ("braced spec %qs is invalid at %qc", orig, *p);
5847
5848 #undef SKIP_WHITE
5849 }
5850
5851 /* Subroutine of handle_braces.  Scan and process a brace substitution body
5852    (X in the description of %{} syntax).  P points one past the colon;
5853    ATOM and END_ATOM bracket the first atom which was found to be true
5854    (present) in the current disjunction; STARRED indicates whether all
5855    the atoms in the current disjunction were starred (for syntax validation);
5856    MATCHED indicates whether the disjunction matched or not, and therefore
5857    whether or not the body is to be processed through do_spec_1 or just
5858    skipped.  Returns a pointer to the closing } or ;, or 0 if do_spec_1
5859    returns -1.  */
5860
5861 static const char *
5862 process_brace_body (const char *p, const char *atom, const char *end_atom,
5863                     int starred, int matched)
5864 {
5865   const char *body, *end_body;
5866   unsigned int nesting_level;
5867   bool have_subst     = false;
5868
5869   /* Locate the closing } or ;, honoring nested braces.
5870      Trim trailing whitespace.  */
5871   body = p;
5872   nesting_level = 1;
5873   for (;;)
5874     {
5875       if (*p == '{')
5876         nesting_level++;
5877       else if (*p == '}')
5878         {
5879           if (!--nesting_level)
5880             break;
5881         }
5882       else if (*p == ';' && nesting_level == 1)
5883         break;
5884       else if (*p == '%' && p[1] == '*' && nesting_level == 1)
5885         have_subst = true;
5886       else if (*p == '\0')
5887         goto invalid;
5888       p++;
5889     }
5890
5891   end_body = p;
5892   while (end_body[-1] == ' ' || end_body[-1] == '\t')
5893     end_body--;
5894
5895   if (have_subst && !starred)
5896     goto invalid;
5897
5898   if (matched)
5899     {
5900       /* Copy the substitution body to permanent storage and execute it.
5901          If have_subst is false, this is a simple matter of running the
5902          body through do_spec_1...  */
5903       char *string = save_string (body, end_body - body);
5904       if (!have_subst)
5905         {
5906           if (do_spec_1 (string, 0, NULL) < 0)
5907             return 0;
5908         }
5909       else
5910         {
5911           /* ... but if have_subst is true, we have to process the
5912              body once for each matching switch, with %* set to the
5913              variant part of the switch.  */
5914           unsigned int hard_match_len = end_atom - atom;
5915           int i;
5916
5917           for (i = 0; i < n_switches; i++)
5918             if (!strncmp (switches[i].part1, atom, hard_match_len)
5919                 && check_live_switch (i, hard_match_len))
5920               {
5921                 if (do_spec_1 (string, 0,
5922                                &switches[i].part1[hard_match_len]) < 0)
5923                   return 0;
5924                 /* Pass any arguments this switch has.  */
5925                 give_switch (i, 1);
5926                 suffix_subst = NULL;
5927               }
5928         }
5929     }
5930
5931   return p;
5932
5933  invalid:
5934   fatal_error ("braced spec body %qs is invalid", body);
5935 }
5936 \f
5937 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
5938    on the command line.  PREFIX_LENGTH is the length of XXX in an {XXX*}
5939    spec, or -1 if either exact match or %* is used.
5940
5941    A -O switch is obsoleted by a later -O switch.  A -f, -g, -m, or -W switch
5942    whose value does not begin with "no-" is obsoleted by the same value
5943    with the "no-", similarly for a switch with the "no-" prefix.  */
5944
5945 static int
5946 check_live_switch (int switchnum, int prefix_length)
5947 {
5948   const char *name = switches[switchnum].part1;
5949   int i;
5950
5951   /* If we already processed this switch and determined if it was
5952      live or not, return our past determination.  */
5953   if (switches[switchnum].live_cond != 0)
5954     return ((switches[switchnum].live_cond & SWITCH_LIVE) != 0
5955             && (switches[switchnum].live_cond & SWITCH_FALSE) == 0
5956             && (switches[switchnum].live_cond & SWITCH_IGNORE_PERMANENTLY)
5957                == 0);
5958
5959   /* In the common case of {<at-most-one-letter>*}, a negating
5960      switch would always match, so ignore that case.  We will just
5961      send the conflicting switches to the compiler phase.  */
5962   if (prefix_length >= 0 && prefix_length <= 1)
5963     return 1;
5964
5965   /* Now search for duplicate in a manner that depends on the name.  */
5966   switch (*name)
5967     {
5968     case 'O':
5969       for (i = switchnum + 1; i < n_switches; i++)
5970         if (switches[i].part1[0] == 'O')
5971           {
5972             switches[switchnum].validated = true;
5973             switches[switchnum].live_cond = SWITCH_FALSE;
5974             return 0;
5975           }
5976       break;
5977
5978     case 'W':  case 'f':  case 'm': case 'g':
5979       if (! strncmp (name + 1, "no-", 3))
5980         {
5981           /* We have Xno-YYY, search for XYYY.  */
5982           for (i = switchnum + 1; i < n_switches; i++)
5983             if (switches[i].part1[0] == name[0]
5984                 && ! strcmp (&switches[i].part1[1], &name[4]))
5985               {
5986                 /* --specs are validated with the validate_switches mechanism.  */
5987                 if (switches[switchnum].known)
5988                   switches[switchnum].validated = true;
5989                 switches[switchnum].live_cond = SWITCH_FALSE;
5990                 return 0;
5991               }
5992         }
5993       else
5994         {
5995           /* We have XYYY, search for Xno-YYY.  */
5996           for (i = switchnum + 1; i < n_switches; i++)
5997             if (switches[i].part1[0] == name[0]
5998                 && switches[i].part1[1] == 'n'
5999                 && switches[i].part1[2] == 'o'
6000                 && switches[i].part1[3] == '-'
6001                 && !strcmp (&switches[i].part1[4], &name[1]))
6002               {
6003                 /* --specs are validated with the validate_switches mechanism.  */
6004                 if (switches[switchnum].known)
6005                   switches[switchnum].validated = true;
6006                 switches[switchnum].live_cond = SWITCH_FALSE;
6007                 return 0;
6008               }
6009         }
6010       break;
6011     }
6012
6013   /* Otherwise the switch is live.  */
6014   switches[switchnum].live_cond |= SWITCH_LIVE;
6015   return 1;
6016 }
6017 \f
6018 /* Pass a switch to the current accumulating command
6019    in the same form that we received it.
6020    SWITCHNUM identifies the switch; it is an index into
6021    the vector of switches gcc received, which is `switches'.
6022    This cannot fail since it never finishes a command line.
6023
6024    If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument.  */
6025
6026 static void
6027 give_switch (int switchnum, int omit_first_word)
6028 {
6029   if ((switches[switchnum].live_cond & SWITCH_IGNORE) != 0)
6030     return;
6031
6032   if (!omit_first_word)
6033     {
6034       do_spec_1 ("-", 0, NULL);
6035       do_spec_1 (switches[switchnum].part1, 1, NULL);
6036     }
6037
6038   if (switches[switchnum].args != 0)
6039     {
6040       const char **p;
6041       for (p = switches[switchnum].args; *p; p++)
6042         {
6043           const char *arg = *p;
6044
6045           do_spec_1 (" ", 0, NULL);
6046           if (suffix_subst)
6047             {
6048               unsigned length = strlen (arg);
6049               int dot = 0;
6050
6051               while (length-- && !IS_DIR_SEPARATOR (arg[length]))
6052                 if (arg[length] == '.')
6053                   {
6054                     (CONST_CAST (char *, arg))[length] = 0;
6055                     dot = 1;
6056                     break;
6057                   }
6058               do_spec_1 (arg, 1, NULL);
6059               if (dot)
6060                 (CONST_CAST (char *, arg))[length] = '.';
6061               do_spec_1 (suffix_subst, 1, NULL);
6062             }
6063           else
6064             do_spec_1 (arg, 1, NULL);
6065         }
6066     }
6067
6068   do_spec_1 (" ", 0, NULL);
6069   switches[switchnum].validated = true;
6070 }
6071 \f
6072 /* Search for a file named NAME trying various prefixes including the
6073    user's -B prefix and some standard ones.
6074    Return the absolute file name found.  If nothing is found, return NAME.  */
6075
6076 static const char *
6077 find_file (const char *name)
6078 {
6079   char *newname = find_a_file (&startfile_prefixes, name, R_OK, true);
6080   return newname ? newname : name;
6081 }
6082
6083 /* Determine whether a directory exists.  If LINKER, return 0 for
6084    certain fixed names not needed by the linker.  */
6085
6086 static int
6087 is_directory (const char *path1, bool linker)
6088 {
6089   int len1;
6090   char *path;
6091   char *cp;
6092   struct stat st;
6093
6094   /* Ensure the string ends with "/.".  The resulting path will be a
6095      directory even if the given path is a symbolic link.  */
6096   len1 = strlen (path1);
6097   path = (char *) alloca (3 + len1);
6098   memcpy (path, path1, len1);
6099   cp = path + len1;
6100   if (!IS_DIR_SEPARATOR (cp[-1]))
6101     *cp++ = DIR_SEPARATOR;
6102   *cp++ = '.';
6103   *cp = '\0';
6104
6105   /* Exclude directories that the linker is known to search.  */
6106   if (linker
6107       && IS_DIR_SEPARATOR (path[0])
6108       && ((cp - path == 6
6109            && filename_ncmp (path + 1, "lib", 3) == 0)
6110           || (cp - path == 10
6111               && filename_ncmp (path + 1, "usr", 3) == 0
6112               && IS_DIR_SEPARATOR (path[4])
6113               && filename_ncmp (path + 5, "lib", 3) == 0)))
6114     return 0;
6115
6116   return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
6117 }
6118
6119 /* Set up the various global variables to indicate that we're processing
6120    the input file named FILENAME.  */
6121
6122 void
6123 set_input (const char *filename)
6124 {
6125   const char *p;
6126
6127   gcc_input_filename = filename;
6128   input_filename_length = strlen (gcc_input_filename);
6129   input_basename = lbasename (gcc_input_filename);
6130
6131   /* Find a suffix starting with the last period,
6132      and set basename_length to exclude that suffix.  */
6133   basename_length = strlen (input_basename);
6134   suffixed_basename_length = basename_length;
6135   p = input_basename + basename_length;
6136   while (p != input_basename && *p != '.')
6137     --p;
6138   if (*p == '.' && p != input_basename)
6139     {
6140       basename_length = p - input_basename;
6141       input_suffix = p + 1;
6142     }
6143   else
6144     input_suffix = "";
6145
6146   /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
6147      we will need to do a stat on the gcc_input_filename.  The
6148      INPUT_STAT_SET signals that the stat is needed.  */
6149   input_stat_set = 0;
6150 }
6151 \f
6152 /* On fatal signals, delete all the temporary files.  */
6153
6154 static void
6155 fatal_signal (int signum)
6156 {
6157   signal (signum, SIG_DFL);
6158   delete_failure_queue ();
6159   delete_temp_files ();
6160   /* Get the same signal again, this time not handled,
6161      so its normal effect occurs.  */
6162   kill (getpid (), signum);
6163 }
6164
6165 /* Compare the contents of the two files named CMPFILE[0] and
6166    CMPFILE[1].  Return zero if they're identical, nonzero
6167    otherwise.  */
6168
6169 static int
6170 compare_files (char *cmpfile[])
6171 {
6172   int ret = 0;
6173   FILE *temp[2] = { NULL, NULL };
6174   int i;
6175
6176 #if HAVE_MMAP_FILE
6177   {
6178     size_t length[2];
6179     void *map[2] = { NULL, NULL };
6180
6181     for (i = 0; i < 2; i++)
6182       {
6183         struct stat st;
6184
6185         if (stat (cmpfile[i], &st) < 0 || !S_ISREG (st.st_mode))
6186           {
6187             error ("%s: could not determine length of compare-debug file %s",
6188                    gcc_input_filename, cmpfile[i]);
6189             ret = 1;
6190             break;
6191           }
6192
6193         length[i] = st.st_size;
6194       }
6195
6196     if (!ret && length[0] != length[1])
6197       {
6198         error ("%s: -fcompare-debug failure (length)", gcc_input_filename);
6199         ret = 1;
6200       }
6201
6202     if (!ret)
6203       for (i = 0; i < 2; i++)
6204         {
6205           int fd = open (cmpfile[i], O_RDONLY);
6206           if (fd < 0)
6207             {
6208               error ("%s: could not open compare-debug file %s",
6209                      gcc_input_filename, cmpfile[i]);
6210               ret = 1;
6211               break;
6212             }
6213
6214           map[i] = mmap (NULL, length[i], PROT_READ, MAP_PRIVATE, fd, 0);
6215           close (fd);
6216
6217           if (map[i] == (void *) MAP_FAILED)
6218             {
6219               ret = -1;
6220               break;
6221             }
6222         }
6223
6224     if (!ret)
6225       {
6226         if (memcmp (map[0], map[1], length[0]) != 0)
6227           {
6228             error ("%s: -fcompare-debug failure", gcc_input_filename);
6229             ret = 1;
6230           }
6231       }
6232
6233     for (i = 0; i < 2; i++)
6234       if (map[i])
6235         munmap ((caddr_t) map[i], length[i]);
6236
6237     if (ret >= 0)
6238       return ret;
6239
6240     ret = 0;
6241   }
6242 #endif
6243
6244   for (i = 0; i < 2; i++)
6245     {
6246       temp[i] = fopen (cmpfile[i], "r");
6247       if (!temp[i])
6248         {
6249           error ("%s: could not open compare-debug file %s",
6250                  gcc_input_filename, cmpfile[i]);
6251           ret = 1;
6252           break;
6253         }
6254     }
6255
6256   if (!ret && temp[0] && temp[1])
6257     for (;;)
6258       {
6259         int c0, c1;
6260         c0 = fgetc (temp[0]);
6261         c1 = fgetc (temp[1]);
6262
6263         if (c0 != c1)
6264           {
6265             error ("%s: -fcompare-debug failure",
6266                    gcc_input_filename);
6267             ret = 1;
6268             break;
6269           }
6270
6271         if (c0 == EOF)
6272           break;
6273       }
6274
6275   for (i = 1; i >= 0; i--)
6276     {
6277       if (temp[i])
6278         fclose (temp[i]);
6279     }
6280
6281   return ret;
6282 }
6283
6284 extern int main (int, char **);
6285
6286 int
6287 main (int argc, char **argv)
6288 {
6289   size_t i;
6290   int value;
6291   int linker_was_run = 0;
6292   int lang_n_infiles = 0;
6293   int num_linker_inputs = 0;
6294   char *explicit_link_files;
6295   char *specs_file;
6296   char *lto_wrapper_file;
6297   const char *p;
6298   struct user_specs *uptr;
6299   char **old_argv = argv;
6300   struct cl_decoded_option *decoded_options;
6301   unsigned int decoded_options_count;
6302
6303   p = argv[0] + strlen (argv[0]);
6304   while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
6305     --p;
6306   progname = p;
6307
6308   xmalloc_set_program_name (progname);
6309
6310   expandargv (&argc, &argv);
6311
6312   /* Determine if any expansions were made.  */
6313   if (argv != old_argv)
6314     at_file_supplied = true;
6315
6316   /* Register the language-independent parameters.  */
6317   global_init_params ();
6318   finish_params ();
6319
6320   init_options_struct (&global_options, &global_options_set);
6321
6322   decode_cmdline_options_to_array (argc, CONST_CAST2 (const char **, char **,
6323                                                       argv),
6324                                    CL_DRIVER,
6325                                    &decoded_options, &decoded_options_count);
6326
6327   /* Unlock the stdio streams.  */
6328   unlock_std_streams ();
6329
6330   gcc_init_libintl ();
6331
6332   diagnostic_initialize (global_dc, 0);
6333
6334 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6335   /* Perform host dependent initialization when needed.  */
6336   GCC_DRIVER_HOST_INITIALIZATION;
6337 #endif
6338
6339   if (atexit (delete_temp_files) != 0)
6340     fatal_error ("atexit failed");
6341
6342   if (signal (SIGINT, SIG_IGN) != SIG_IGN)
6343     signal (SIGINT, fatal_signal);
6344 #ifdef SIGHUP
6345   if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
6346     signal (SIGHUP, fatal_signal);
6347 #endif
6348   if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
6349     signal (SIGTERM, fatal_signal);
6350 #ifdef SIGPIPE
6351   if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
6352     signal (SIGPIPE, fatal_signal);
6353 #endif
6354 #ifdef SIGCHLD
6355   /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6356      receive the signal.  A different setting is inheritable */
6357   signal (SIGCHLD, SIG_DFL);
6358 #endif
6359
6360   /* Parsing and gimplification sometimes need quite large stack.
6361      Increase stack size limits if possible.  */
6362   stack_limit_increase (64 * 1024 * 1024);
6363
6364   /* Allocate the argument vector.  */
6365   alloc_args ();
6366
6367   obstack_init (&obstack);
6368
6369   /* Build multilib_select, et. al from the separate lines that make up each
6370      multilib selection.  */
6371   {
6372     const char *const *q = multilib_raw;
6373     int need_space;
6374
6375     obstack_init (&multilib_obstack);
6376     while ((p = *q++) != (char *) 0)
6377       obstack_grow (&multilib_obstack, p, strlen (p));
6378
6379     obstack_1grow (&multilib_obstack, 0);
6380     multilib_select = XOBFINISH (&multilib_obstack, const char *);
6381
6382     q = multilib_matches_raw;
6383     while ((p = *q++) != (char *) 0)
6384       obstack_grow (&multilib_obstack, p, strlen (p));
6385
6386     obstack_1grow (&multilib_obstack, 0);
6387     multilib_matches = XOBFINISH (&multilib_obstack, const char *);
6388
6389     q = multilib_exclusions_raw;
6390     while ((p = *q++) != (char *) 0)
6391       obstack_grow (&multilib_obstack, p, strlen (p));
6392
6393     obstack_1grow (&multilib_obstack, 0);
6394     multilib_exclusions = XOBFINISH (&multilib_obstack, const char *);
6395
6396     q = multilib_reuse_raw;
6397     while ((p = *q++) != (char *) 0)
6398       obstack_grow (&multilib_obstack, p, strlen (p));
6399
6400     obstack_1grow (&multilib_obstack, 0);
6401     multilib_reuse = XOBFINISH (&multilib_obstack, const char *);
6402
6403     need_space = FALSE;
6404     for (i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++)
6405       {
6406         if (need_space)
6407           obstack_1grow (&multilib_obstack, ' ');
6408         obstack_grow (&multilib_obstack,
6409                       multilib_defaults_raw[i],
6410                       strlen (multilib_defaults_raw[i]));
6411         need_space = TRUE;
6412       }
6413
6414     obstack_1grow (&multilib_obstack, 0);
6415     multilib_defaults = XOBFINISH (&multilib_obstack, const char *);
6416   }
6417
6418 #ifdef INIT_ENVIRONMENT
6419   /* Set up any other necessary machine specific environment variables.  */
6420   xputenv (INIT_ENVIRONMENT);
6421 #endif
6422
6423   /* Make a table of what switches there are (switches, n_switches).
6424      Make a table of specified input files (infiles, n_infiles).
6425      Decode switches that are handled locally.  */
6426
6427   process_command (decoded_options_count, decoded_options);
6428
6429   /* Initialize the vector of specs to just the default.
6430      This means one element containing 0s, as a terminator.  */
6431
6432   compilers = XNEWVAR (struct compiler, sizeof default_compilers);
6433   memcpy (compilers, default_compilers, sizeof default_compilers);
6434   n_compilers = n_default_compilers;
6435
6436   /* Read specs from a file if there is one.  */
6437
6438   machine_suffix = concat (spec_machine, dir_separator_str,
6439                            spec_version, dir_separator_str, NULL);
6440   just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
6441
6442   specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, true);
6443   /* Read the specs file unless it is a default one.  */
6444   if (specs_file != 0 && strcmp (specs_file, "specs"))
6445     read_specs (specs_file, true, false);
6446   else
6447     init_spec ();
6448
6449   /* We need to check standard_exec_prefix/just_machine_suffix/specs
6450      for any override of as, ld and libraries.  */
6451   specs_file = (char *) alloca (strlen (standard_exec_prefix)
6452                        + strlen (just_machine_suffix) + sizeof ("specs"));
6453
6454   strcpy (specs_file, standard_exec_prefix);
6455   strcat (specs_file, just_machine_suffix);
6456   strcat (specs_file, "specs");
6457   if (access (specs_file, R_OK) == 0)
6458     read_specs (specs_file, true, false);
6459
6460   /* Process any configure-time defaults specified for the command line
6461      options, via OPTION_DEFAULT_SPECS.  */
6462   for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
6463     do_option_spec (option_default_specs[i].name,
6464                     option_default_specs[i].spec);
6465
6466   /* Process DRIVER_SELF_SPECS, adding any new options to the end
6467      of the command line.  */
6468
6469   for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++)
6470     do_self_spec (driver_self_specs[i]);
6471
6472   /* If not cross-compiling, look for executables in the standard
6473      places.  */
6474   if (*cross_compile == '0')
6475     {
6476       if (*md_exec_prefix)
6477         {
6478           add_prefix (&exec_prefixes, md_exec_prefix, "GCC",
6479                       PREFIX_PRIORITY_LAST, 0, 0);
6480         }
6481     }
6482
6483   /* Process sysroot_suffix_spec.  */
6484   if (*sysroot_suffix_spec != 0
6485       && !no_sysroot_suffix
6486       && do_spec_2 (sysroot_suffix_spec) == 0)
6487     {
6488       if (argbuf.length () > 1)
6489         error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
6490       else if (argbuf.length () == 1)
6491         target_sysroot_suffix = xstrdup (argbuf.last ());
6492     }
6493
6494 #ifdef HAVE_LD_SYSROOT
6495   /* Pass the --sysroot option to the linker, if it supports that.  If
6496      there is a sysroot_suffix_spec, it has already been processed by
6497      this point, so target_system_root really is the system root we
6498      should be using.  */
6499   if (target_system_root)
6500     {
6501       obstack_grow (&obstack, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
6502       obstack_grow0 (&obstack, link_spec, strlen (link_spec));
6503       set_spec ("link", XOBFINISH (&obstack, const char *), false);
6504     }
6505 #endif
6506
6507   /* Process sysroot_hdrs_suffix_spec.  */
6508   if (*sysroot_hdrs_suffix_spec != 0
6509       && !no_sysroot_suffix
6510       && do_spec_2 (sysroot_hdrs_suffix_spec) == 0)
6511     {
6512       if (argbuf.length () > 1)
6513         error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
6514       else if (argbuf.length () == 1)
6515         target_sysroot_hdrs_suffix = xstrdup (argbuf.last ());
6516     }
6517
6518   /* Look for startfiles in the standard places.  */
6519   if (*startfile_prefix_spec != 0
6520       && do_spec_2 (startfile_prefix_spec) == 0
6521       && do_spec_1 (" ", 0, NULL) == 0)
6522     {
6523       const char *arg;
6524       int ndx;
6525       FOR_EACH_VEC_ELT (argbuf, ndx, arg)
6526         add_sysrooted_prefix (&startfile_prefixes, arg, "BINUTILS",
6527                               PREFIX_PRIORITY_LAST, 0, 1);
6528     }
6529   /* We should eventually get rid of all these and stick to
6530      startfile_prefix_spec exclusively.  */
6531   else if (*cross_compile == '0' || target_system_root)
6532     {
6533       if (*md_startfile_prefix)
6534         add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix,
6535                               "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6536
6537       if (*md_startfile_prefix_1)
6538         add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix_1,
6539                               "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6540
6541       /* If standard_startfile_prefix is relative, base it on
6542          standard_exec_prefix.  This lets us move the installed tree
6543          as a unit.  If GCC_EXEC_PREFIX is defined, base
6544          standard_startfile_prefix on that as well.
6545
6546          If the prefix is relative, only search it for native compilers;
6547          otherwise we will search a directory containing host libraries.  */
6548       if (IS_ABSOLUTE_PATH (standard_startfile_prefix))
6549         add_sysrooted_prefix (&startfile_prefixes,
6550                               standard_startfile_prefix, "BINUTILS",
6551                               PREFIX_PRIORITY_LAST, 0, 1);
6552       else if (*cross_compile == '0')
6553         {
6554           add_prefix (&startfile_prefixes,
6555                       concat (gcc_exec_prefix
6556                               ? gcc_exec_prefix : standard_exec_prefix,
6557                               machine_suffix,
6558                               standard_startfile_prefix, NULL),
6559                       NULL, PREFIX_PRIORITY_LAST, 0, 1);
6560         }
6561
6562       /* Sysrooted prefixes are relocated because target_system_root is
6563          also relocated by gcc_exec_prefix.  */
6564       if (*standard_startfile_prefix_1)
6565         add_sysrooted_prefix (&startfile_prefixes,
6566                               standard_startfile_prefix_1, "BINUTILS",
6567                               PREFIX_PRIORITY_LAST, 0, 1);
6568       if (*standard_startfile_prefix_2)
6569         add_sysrooted_prefix (&startfile_prefixes,
6570                               standard_startfile_prefix_2, "BINUTILS",
6571                               PREFIX_PRIORITY_LAST, 0, 1);
6572     }
6573
6574   /* Process any user specified specs in the order given on the command
6575      line.  */
6576   for (uptr = user_specs_head; uptr; uptr = uptr->next)
6577     {
6578       char *filename = find_a_file (&startfile_prefixes, uptr->filename,
6579                                     R_OK, true);
6580       read_specs (filename ? filename : uptr->filename, false, true);
6581     }
6582
6583   /* Process any user self specs.  */
6584   {
6585     struct spec_list *sl;
6586     for (sl = specs; sl; sl = sl->next)
6587       if (sl->name_len == sizeof "self_spec" - 1
6588           && !strcmp (sl->name, "self_spec"))
6589         do_self_spec (*sl->ptr_spec);
6590   }
6591
6592   if (compare_debug)
6593     {
6594       enum save_temps save;
6595
6596       if (!compare_debug_second)
6597         {
6598           n_switches_debug_check[1] = n_switches;
6599           n_switches_alloc_debug_check[1] = n_switches_alloc;
6600           switches_debug_check[1] = XDUPVEC (struct switchstr, switches,
6601                                              n_switches_alloc);
6602
6603           do_self_spec ("%:compare-debug-self-opt()");
6604           n_switches_debug_check[0] = n_switches;
6605           n_switches_alloc_debug_check[0] = n_switches_alloc;
6606           switches_debug_check[0] = switches;
6607
6608           n_switches = n_switches_debug_check[1];
6609           n_switches_alloc = n_switches_alloc_debug_check[1];
6610           switches = switches_debug_check[1];
6611         }
6612
6613       /* Avoid crash when computing %j in this early.  */
6614       save = save_temps_flag;
6615       save_temps_flag = SAVE_TEMPS_NONE;
6616
6617       compare_debug = -compare_debug;
6618       do_self_spec ("%:compare-debug-self-opt()");
6619
6620       save_temps_flag = save;
6621
6622       if (!compare_debug_second)
6623         {
6624           n_switches_debug_check[1] = n_switches;
6625           n_switches_alloc_debug_check[1] = n_switches_alloc;
6626           switches_debug_check[1] = switches;
6627           compare_debug = -compare_debug;
6628           n_switches = n_switches_debug_check[0];
6629           n_switches_alloc = n_switches_debug_check[0];
6630           switches = switches_debug_check[0];
6631         }
6632     }
6633
6634
6635   /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake.  */
6636   if (gcc_exec_prefix)
6637     gcc_exec_prefix = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
6638                               spec_version, dir_separator_str, NULL);
6639
6640   /* Now we have the specs.
6641      Set the `valid' bits for switches that match anything in any spec.  */
6642
6643   validate_all_switches ();
6644
6645   /* Now that we have the switches and the specs, set
6646      the subdirectory based on the options.  */
6647   set_multilib_dir ();
6648
6649   /* Set up to remember the pathname of gcc and any options
6650      needed for collect.  We use argv[0] instead of progname because
6651      we need the complete pathname.  */
6652   obstack_init (&collect_obstack);
6653   obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
6654   obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1);
6655   xputenv (XOBFINISH (&collect_obstack, char *));
6656
6657   /* Set up to remember the pathname of the lto wrapper. */
6658
6659   if (have_c)
6660     lto_wrapper_file = NULL;
6661   else
6662     lto_wrapper_file = find_a_file (&exec_prefixes, "lto-wrapper",
6663                                     X_OK, false);
6664   if (lto_wrapper_file)
6665     {
6666       lto_wrapper_file = convert_white_space (lto_wrapper_file);
6667       lto_wrapper_spec = lto_wrapper_file;
6668       obstack_init (&collect_obstack);
6669       obstack_grow (&collect_obstack, "COLLECT_LTO_WRAPPER=",
6670                     sizeof ("COLLECT_LTO_WRAPPER=") - 1);
6671       obstack_grow (&collect_obstack, lto_wrapper_spec,
6672                     strlen (lto_wrapper_spec) + 1);
6673       xputenv (XOBFINISH (&collect_obstack, char *));
6674     }
6675
6676   /* Reject switches that no pass was interested in.  */
6677
6678   for (i = 0; (int) i < n_switches; i++)
6679     if (! switches[i].validated)
6680       error ("unrecognized command line option %<-%s%>", switches[i].part1);
6681
6682   /* Obey some of the options.  */
6683
6684   if (print_search_dirs)
6685     {
6686       printf (_("install: %s%s\n"),
6687               gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
6688               gcc_exec_prefix ? "" : machine_suffix);
6689       printf (_("programs: %s\n"),
6690               build_search_list (&exec_prefixes, "", false, false));
6691       printf (_("libraries: %s\n"),
6692               build_search_list (&startfile_prefixes, "", false, true));
6693       return (0);
6694     }
6695
6696   if (print_file_name)
6697     {
6698       printf ("%s\n", find_file (print_file_name));
6699       return (0);
6700     }
6701
6702   if (print_prog_name)
6703     {
6704       char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK, 0);
6705       printf ("%s\n", (newname ? newname : print_prog_name));
6706       return (0);
6707     }
6708
6709   if (print_multi_lib)
6710     {
6711       print_multilib_info ();
6712       return (0);
6713     }
6714
6715   if (print_multi_directory)
6716     {
6717       if (multilib_dir == NULL)
6718         printf (".\n");
6719       else
6720         printf ("%s\n", multilib_dir);
6721       return (0);
6722     }
6723
6724   if (print_multiarch)
6725     {
6726       if (multiarch_dir == NULL)
6727         printf ("\n");
6728       else
6729         printf ("%s\n", multiarch_dir);
6730       return (0);
6731     }
6732
6733   if (print_sysroot)
6734     {
6735       if (target_system_root)
6736         {
6737           if (target_sysroot_suffix)
6738             printf ("%s%s\n", target_system_root, target_sysroot_suffix);
6739           else
6740             printf ("%s\n", target_system_root);
6741         }
6742       return (0);
6743     }
6744
6745   if (print_multi_os_directory)
6746     {
6747       if (multilib_os_dir == NULL)
6748         printf (".\n");
6749       else
6750         printf ("%s\n", multilib_os_dir);
6751       return (0);
6752     }
6753
6754   if (print_sysroot_headers_suffix)
6755     {
6756       if (*sysroot_hdrs_suffix_spec)
6757         {
6758           printf("%s\n", (target_sysroot_hdrs_suffix
6759                           ? target_sysroot_hdrs_suffix
6760                           : ""));
6761           return (0);
6762         }
6763       else
6764         /* The error status indicates that only one set of fixed
6765            headers should be built.  */
6766         fatal_error ("not configured with sysroot headers suffix");
6767     }
6768
6769   if (print_help_list)
6770     {
6771       display_help ();
6772
6773       if (! verbose_flag)
6774         {
6775           printf (_("\nFor bug reporting instructions, please see:\n"));
6776           printf ("%s.\n", bug_report_url);
6777
6778           return (0);
6779         }
6780
6781       /* We do not exit here.  Instead we have created a fake input file
6782          called 'help-dummy' which needs to be compiled, and we pass this
6783          on the various sub-processes, along with the --help switch.
6784          Ensure their output appears after ours.  */
6785       fputc ('\n', stdout);
6786       fflush (stdout);
6787     }
6788
6789   if (print_version)
6790     {
6791       printf (_("%s %s%s\n"), progname, pkgversion_string,
6792               version_string);
6793       printf ("Copyright %s 2013 Free Software Foundation, Inc.\n",
6794               _("(C)"));
6795       fputs (_("This is free software; see the source for copying conditions.  There is NO\n\
6796 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
6797              stdout);
6798       if (! verbose_flag)
6799         return 0;
6800
6801       /* We do not exit here. We use the same mechanism of --help to print
6802          the version of the sub-processes. */
6803       fputc ('\n', stdout);
6804       fflush (stdout);
6805     }
6806
6807   if (verbose_flag)
6808     {
6809       int n;
6810       const char *thrmod;
6811
6812       fnotice (stderr, "Target: %s\n", spec_machine);
6813       fnotice (stderr, "Configured with: %s\n", configuration_arguments);
6814
6815 #ifdef THREAD_MODEL_SPEC
6816       /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
6817          but there's no point in doing all this processing just to get
6818          thread_model back.  */
6819       obstack_init (&obstack);
6820       do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model);
6821       obstack_1grow (&obstack, '\0');
6822       thrmod = XOBFINISH (&obstack, const char *);
6823 #else
6824       thrmod = thread_model;
6825 #endif
6826
6827       fnotice (stderr, "Thread model: %s\n", thrmod);
6828
6829       /* compiler_version is truncated at the first space when initialized
6830          from version string, so truncate version_string at the first space
6831          before comparing.  */
6832       for (n = 0; version_string[n]; n++)
6833         if (version_string[n] == ' ')
6834           break;
6835
6836       if (! strncmp (version_string, compiler_version, n)
6837           && compiler_version[n] == 0)
6838         fnotice (stderr, "gcc version %s %s\n", version_string,
6839                  pkgversion_string);
6840       else
6841         fnotice (stderr, "gcc driver version %s %sexecuting gcc version %s\n",
6842                  version_string, pkgversion_string, compiler_version);
6843
6844       if (n_infiles == 0)
6845         return (0);
6846     }
6847
6848   if (n_infiles == added_libraries)
6849     fatal_error ("no input files");
6850
6851   if (seen_error ())
6852     goto out;
6853
6854   /* Make a place to record the compiler output file names
6855      that correspond to the input files.  */
6856
6857   i = n_infiles;
6858   i += lang_specific_extra_outfiles;
6859   outfiles = XCNEWVEC (const char *, i);
6860
6861   /* Record which files were specified explicitly as link input.  */
6862
6863   explicit_link_files = XCNEWVEC (char, n_infiles);
6864
6865   combine_inputs = have_o || flag_wpa;
6866
6867   for (i = 0; (int) i < n_infiles; i++)
6868     {
6869       const char *name = infiles[i].name;
6870       struct compiler *compiler = lookup_compiler (name,
6871                                                    strlen (name),
6872                                                    infiles[i].language);
6873
6874       if (compiler && !(compiler->combinable))
6875         combine_inputs = false;
6876
6877       if (lang_n_infiles > 0 && compiler != input_file_compiler
6878           && infiles[i].language && infiles[i].language[0] != '*')
6879         infiles[i].incompiler = compiler;
6880       else if (compiler)
6881         {
6882           lang_n_infiles++;
6883           input_file_compiler = compiler;
6884           infiles[i].incompiler = compiler;
6885         }
6886       else
6887         {
6888           /* Since there is no compiler for this input file, assume it is a
6889              linker file.  */
6890           explicit_link_files[i] = 1;
6891           infiles[i].incompiler = NULL;
6892         }
6893       infiles[i].compiled = false;
6894       infiles[i].preprocessed = false;
6895     }
6896
6897   if (!combine_inputs && have_c && have_o && lang_n_infiles > 1)
6898     fatal_error ("cannot specify -o with -c, -S or -E with multiple files");
6899
6900   for (i = 0; (int) i < n_infiles; i++)
6901     {
6902       int this_file_error = 0;
6903
6904       /* Tell do_spec what to substitute for %i.  */
6905
6906       input_file_number = i;
6907       set_input (infiles[i].name);
6908
6909       if (infiles[i].compiled)
6910         continue;
6911
6912       /* Use the same thing in %o, unless cp->spec says otherwise.  */
6913
6914       outfiles[i] = gcc_input_filename;
6915
6916       /* Figure out which compiler from the file's suffix.  */
6917
6918       input_file_compiler
6919         = lookup_compiler (infiles[i].name, input_filename_length,
6920                            infiles[i].language);
6921
6922       if (input_file_compiler)
6923         {
6924           /* Ok, we found an applicable compiler.  Run its spec.  */
6925
6926           if (input_file_compiler->spec[0] == '#')
6927             {
6928               error ("%s: %s compiler not installed on this system",
6929                      gcc_input_filename, &input_file_compiler->spec[1]);
6930               this_file_error = 1;
6931             }
6932           else
6933             {
6934               if (compare_debug)
6935                 {
6936                   free (debug_check_temp_file[0]);
6937                   debug_check_temp_file[0] = NULL;
6938
6939                   free (debug_check_temp_file[1]);
6940                   debug_check_temp_file[1] = NULL;
6941                 }
6942
6943               value = do_spec (input_file_compiler->spec);
6944               infiles[i].compiled = true;
6945               if (value < 0)
6946                 this_file_error = 1;
6947               else if (compare_debug && debug_check_temp_file[0])
6948                 {
6949                   if (verbose_flag)
6950                     inform (0, "recompiling with -fcompare-debug");
6951
6952                   compare_debug = -compare_debug;
6953                   n_switches = n_switches_debug_check[1];
6954                   n_switches_alloc = n_switches_alloc_debug_check[1];
6955                   switches = switches_debug_check[1];
6956
6957                   value = do_spec (input_file_compiler->spec);
6958
6959                   compare_debug = -compare_debug;
6960                   n_switches = n_switches_debug_check[0];
6961                   n_switches_alloc = n_switches_alloc_debug_check[0];
6962                   switches = switches_debug_check[0];
6963
6964                   if (value < 0)
6965                     {
6966                       error ("during -fcompare-debug recompilation");
6967                       this_file_error = 1;
6968                     }
6969
6970                   gcc_assert (debug_check_temp_file[1]
6971                               && filename_cmp (debug_check_temp_file[0],
6972                                                debug_check_temp_file[1]));
6973
6974                   if (verbose_flag)
6975                     inform (0, "comparing final insns dumps");
6976
6977                   if (compare_files (debug_check_temp_file))
6978                     this_file_error = 1;
6979                 }
6980
6981               if (compare_debug)
6982                 {
6983                   free (debug_check_temp_file[0]);
6984                   debug_check_temp_file[0] = NULL;
6985
6986                   free (debug_check_temp_file[1]);
6987                   debug_check_temp_file[1] = NULL;
6988                 }
6989             }
6990         }
6991
6992       /* If this file's name does not contain a recognized suffix,
6993          record it as explicit linker input.  */
6994
6995       else
6996         explicit_link_files[i] = 1;
6997
6998       /* Clear the delete-on-failure queue, deleting the files in it
6999          if this compilation failed.  */
7000
7001       if (this_file_error)
7002         {
7003           delete_failure_queue ();
7004           errorcount++;
7005         }
7006       /* If this compilation succeeded, don't delete those files later.  */
7007       clear_failure_queue ();
7008     }
7009
7010   /* Reset the input file name to the first compile/object file name, for use
7011      with %b in LINK_SPEC. We use the first input file that we can find
7012      a compiler to compile it instead of using infiles.language since for
7013      languages other than C we use aliases that we then lookup later.  */
7014   if (n_infiles > 0)
7015     {
7016       int i;
7017
7018       for (i = 0; i < n_infiles ; i++)
7019         if (infiles[i].incompiler
7020             || (infiles[i].language && infiles[i].language[0] != '*'))
7021           {
7022             set_input (infiles[i].name);
7023             break;
7024           }
7025     }
7026
7027   if (!seen_error ())
7028     {
7029       /* Make sure INPUT_FILE_NUMBER points to first available open
7030          slot.  */
7031       input_file_number = n_infiles;
7032       if (lang_specific_pre_link ())
7033         errorcount++;
7034     }
7035
7036   /* Determine if there are any linker input files.  */
7037   num_linker_inputs = 0;
7038   for (i = 0; (int) i < n_infiles; i++)
7039     if (explicit_link_files[i] || outfiles[i] != NULL)
7040       num_linker_inputs++;
7041
7042   /* Run ld to link all the compiler output files.  */
7043
7044   if (num_linker_inputs > 0 && !seen_error () && print_subprocess_help < 2)
7045     {
7046       int tmp = execution_count;
7047
7048       if (! have_c)
7049         {
7050 #if HAVE_LTO_PLUGIN > 0
7051 #if HAVE_LTO_PLUGIN == 2
7052           const char *fno_use_linker_plugin = "fno-use-linker-plugin";
7053 #else
7054           const char *fuse_linker_plugin = "fuse-linker-plugin";
7055 #endif
7056 #endif
7057
7058           /* We'll use ld if we can't find collect2.  */
7059           if (! strcmp (linker_name_spec, "collect2"))
7060             {
7061               char *s = find_a_file (&exec_prefixes, "collect2", X_OK, false);
7062               if (s == NULL)
7063                 linker_name_spec = "ld";
7064             }
7065
7066 #if HAVE_LTO_PLUGIN > 0
7067 #if HAVE_LTO_PLUGIN == 2
7068           if (!switch_matches (fno_use_linker_plugin,
7069                                fno_use_linker_plugin
7070                                + strlen (fno_use_linker_plugin), 0))
7071 #else
7072           if (switch_matches (fuse_linker_plugin,
7073                               fuse_linker_plugin
7074                               + strlen (fuse_linker_plugin), 0))
7075 #endif
7076             {
7077               char *temp_spec = find_a_file (&exec_prefixes,
7078                                              LTOPLUGINSONAME, R_OK,
7079                                              false);
7080               if (!temp_spec)
7081                 fatal_error ("-fuse-linker-plugin, but %s not found",
7082                              LTOPLUGINSONAME);
7083               linker_plugin_file_spec = convert_white_space (temp_spec);
7084             }
7085 #endif
7086           lto_gcc_spec = argv[0];
7087         }
7088
7089       /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
7090          for collect.  */
7091       putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH", false);
7092       putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV, true);
7093
7094       if (print_subprocess_help == 1)
7095         {
7096           printf (_("\nLinker options\n==============\n\n"));
7097           printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
7098                     " to the linker.\n\n"));
7099           fflush (stdout);
7100         }
7101       value = do_spec (link_command_spec);
7102       if (value < 0)
7103         errorcount = 1;
7104       linker_was_run = (tmp != execution_count);
7105     }
7106
7107   /* If options said don't run linker,
7108      complain about input files to be given to the linker.  */
7109
7110   if (! linker_was_run && !seen_error ())
7111     for (i = 0; (int) i < n_infiles; i++)
7112       if (explicit_link_files[i]
7113           && !(infiles[i].language && infiles[i].language[0] == '*'))
7114         warning (0, "%s: linker input file unused because linking not done",
7115                  outfiles[i]);
7116
7117   /* Delete some or all of the temporary files we made.  */
7118
7119   if (seen_error ())
7120     delete_failure_queue ();
7121   delete_temp_files ();
7122
7123   if (print_help_list)
7124     {
7125       printf (("\nFor bug reporting instructions, please see:\n"));
7126       printf ("%s\n", bug_report_url);
7127     }
7128
7129  out:
7130   return (signal_count != 0 ? 2
7131           : seen_error () ? (pass_exit_codes ? greatest_status : 1)
7132           : 0);
7133 }
7134
7135 /* Find the proper compilation spec for the file name NAME,
7136    whose length is LENGTH.  LANGUAGE is the specified language,
7137    or 0 if this file is to be passed to the linker.  */
7138
7139 static struct compiler *
7140 lookup_compiler (const char *name, size_t length, const char *language)
7141 {
7142   struct compiler *cp;
7143
7144   /* If this was specified by the user to be a linker input, indicate that.  */
7145   if (language != 0 && language[0] == '*')
7146     return 0;
7147
7148   /* Otherwise, look for the language, if one is spec'd.  */
7149   if (language != 0)
7150     {
7151       for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7152         if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
7153           return cp;
7154
7155       error ("language %s not recognized", language);
7156       return 0;
7157     }
7158
7159   /* Look for a suffix.  */
7160   for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7161     {
7162       if (/* The suffix `-' matches only the file name `-'.  */
7163           (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
7164           || (strlen (cp->suffix) < length
7165               /* See if the suffix matches the end of NAME.  */
7166               && !strcmp (cp->suffix,
7167                           name + length - strlen (cp->suffix))
7168          ))
7169         break;
7170     }
7171
7172 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
7173   /* Look again, but case-insensitively this time.  */
7174   if (cp < compilers)
7175     for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7176       {
7177         if (/* The suffix `-' matches only the file name `-'.  */
7178             (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
7179             || (strlen (cp->suffix) < length
7180                 /* See if the suffix matches the end of NAME.  */
7181                 && ((!strcmp (cp->suffix,
7182                              name + length - strlen (cp->suffix))
7183                      || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
7184                     && !strcasecmp (cp->suffix,
7185                                     name + length - strlen (cp->suffix)))
7186            ))
7187           break;
7188       }
7189 #endif
7190
7191   if (cp >= compilers)
7192     {
7193       if (cp->spec[0] != '@')
7194         /* A non-alias entry: return it.  */
7195         return cp;
7196
7197       /* An alias entry maps a suffix to a language.
7198          Search for the language; pass 0 for NAME and LENGTH
7199          to avoid infinite recursion if language not found.  */
7200       return lookup_compiler (NULL, 0, cp->spec + 1);
7201     }
7202   return 0;
7203 }
7204 \f
7205 static char *
7206 save_string (const char *s, int len)
7207 {
7208   char *result = XNEWVEC (char, len + 1);
7209
7210   memcpy (result, s, len);
7211   result[len] = 0;
7212   return result;
7213 }
7214
7215 void
7216 pfatal_with_name (const char *name)
7217 {
7218   perror_with_name (name);
7219   delete_temp_files ();
7220   exit (1);
7221 }
7222
7223 static void
7224 perror_with_name (const char *name)
7225 {
7226   error ("%s: %m", name);
7227 }
7228 \f
7229 static inline void
7230 validate_switches_from_spec (const char *spec, bool user)
7231 {
7232   const char *p = spec;
7233   char c;
7234   while ((c = *p++))
7235     if (c == '%' && (*p == '{' || *p == '<' || (*p == 'W' && *++p == '{')))
7236       /* We have a switch spec.  */
7237       p = validate_switches (p + 1, user);
7238 }
7239
7240 static void
7241 validate_all_switches (void)
7242 {
7243   struct compiler *comp;
7244   struct spec_list *spec;
7245
7246   for (comp = compilers; comp->spec; comp++)
7247     validate_switches_from_spec (comp->spec, false);
7248
7249   /* Look through the linked list of specs read from the specs file.  */
7250   for (spec = specs; spec; spec = spec->next)
7251     validate_switches_from_spec (*spec->ptr_spec, spec->user_p);
7252
7253   validate_switches_from_spec (link_command_spec, false);
7254 }
7255
7256 /* Look at the switch-name that comes after START
7257    and mark as valid all supplied switches that match it.  */
7258
7259 static const char *
7260 validate_switches (const char *start, bool user_spec)
7261 {
7262   const char *p = start;
7263   const char *atom;
7264   size_t len;
7265   int i;
7266   bool suffix = false;
7267   bool starred = false;
7268
7269 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7270
7271 next_member:
7272   SKIP_WHITE ();
7273
7274   if (*p == '!')
7275     p++;
7276
7277   SKIP_WHITE ();
7278   if (*p == '.' || *p == ',')
7279     suffix = true, p++;
7280
7281   atom = p;
7282   while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
7283          || *p == ',' || *p == '.' || *p == '@')
7284     p++;
7285   len = p - atom;
7286
7287   if (*p == '*')
7288     starred = true, p++;
7289
7290   SKIP_WHITE ();
7291
7292   if (!suffix)
7293     {
7294       /* Mark all matching switches as valid.  */
7295       for (i = 0; i < n_switches; i++)
7296         if (!strncmp (switches[i].part1, atom, len)
7297             && (starred || switches[i].part1[len] == '\0')
7298             && (switches[i].known || user_spec))
7299               switches[i].validated = true;
7300     }
7301
7302   if (*p) p++;
7303   if (*p && (p[-1] == '|' || p[-1] == '&'))
7304     goto next_member;
7305
7306   if (*p && p[-1] == ':')
7307     {
7308       while (*p && *p != ';' && *p != '}')
7309         {
7310           if (*p == '%')
7311             {
7312               p++;
7313               if (*p == '{' || *p == '<')
7314                 p = validate_switches (p+1, user_spec);
7315               else if (p[0] == 'W' && p[1] == '{')
7316                 p = validate_switches (p+2, user_spec);
7317             }
7318           else
7319             p++;
7320         }
7321
7322       if (*p) p++;
7323       if (*p && p[-1] == ';')
7324         goto next_member;
7325     }
7326
7327   return p;
7328 #undef SKIP_WHITE
7329 }
7330 \f
7331 struct mdswitchstr
7332 {
7333   const char *str;
7334   int len;
7335 };
7336
7337 static struct mdswitchstr *mdswitches;
7338 static int n_mdswitches;
7339
7340 /* Check whether a particular argument was used.  The first time we
7341    canonicalize the switches to keep only the ones we care about.  */
7342
7343 static int
7344 used_arg (const char *p, int len)
7345 {
7346   struct mswitchstr
7347   {
7348     const char *str;
7349     const char *replace;
7350     int len;
7351     int rep_len;
7352   };
7353
7354   static struct mswitchstr *mswitches;
7355   static int n_mswitches;
7356   int i, j;
7357
7358   if (!mswitches)
7359     {
7360       struct mswitchstr *matches;
7361       const char *q;
7362       int cnt = 0;
7363
7364       /* Break multilib_matches into the component strings of string
7365          and replacement string.  */
7366       for (q = multilib_matches; *q != '\0'; q++)
7367         if (*q == ';')
7368           cnt++;
7369
7370       matches
7371         = (struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt);
7372       i = 0;
7373       q = multilib_matches;
7374       while (*q != '\0')
7375         {
7376           matches[i].str = q;
7377           while (*q != ' ')
7378             {
7379               if (*q == '\0')
7380                 {
7381                 invalid_matches:
7382                   fatal_error ("multilib spec %qs is invalid",
7383                                multilib_matches);
7384                 }
7385               q++;
7386             }
7387           matches[i].len = q - matches[i].str;
7388
7389           matches[i].replace = ++q;
7390           while (*q != ';' && *q != '\0')
7391             {
7392               if (*q == ' ')
7393                 goto invalid_matches;
7394               q++;
7395             }
7396           matches[i].rep_len = q - matches[i].replace;
7397           i++;
7398           if (*q == ';')
7399             q++;
7400         }
7401
7402       /* Now build a list of the replacement string for switches that we care
7403          about.  Make sure we allocate at least one entry.  This prevents
7404          xmalloc from calling fatal, and prevents us from re-executing this
7405          block of code.  */
7406       mswitches
7407         = XNEWVEC (struct mswitchstr, n_mdswitches + (n_switches ? n_switches : 1));
7408       for (i = 0; i < n_switches; i++)
7409         if ((switches[i].live_cond & SWITCH_IGNORE) == 0)
7410           {
7411             int xlen = strlen (switches[i].part1);
7412             for (j = 0; j < cnt; j++)
7413               if (xlen == matches[j].len
7414                   && ! strncmp (switches[i].part1, matches[j].str, xlen))
7415                 {
7416                   mswitches[n_mswitches].str = matches[j].replace;
7417                   mswitches[n_mswitches].len = matches[j].rep_len;
7418                   mswitches[n_mswitches].replace = (char *) 0;
7419                   mswitches[n_mswitches].rep_len = 0;
7420                   n_mswitches++;
7421                   break;
7422                 }
7423           }
7424
7425       /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
7426          on the command line nor any options mutually incompatible with
7427          them.  */
7428       for (i = 0; i < n_mdswitches; i++)
7429         {
7430           const char *r;
7431
7432           for (q = multilib_options; *q != '\0'; q++)
7433             {
7434               while (*q == ' ')
7435                 q++;
7436
7437               r = q;
7438               while (strncmp (q, mdswitches[i].str, mdswitches[i].len) != 0
7439                      || strchr (" /", q[mdswitches[i].len]) == NULL)
7440                 {
7441                   while (*q != ' ' && *q != '/' && *q != '\0')
7442                     q++;
7443                   if (*q != '/')
7444                     break;
7445                   q++;
7446                 }
7447
7448               if (*q != ' ' && *q != '\0')
7449                 {
7450                   while (*r != ' ' && *r != '\0')
7451                     {
7452                       q = r;
7453                       while (*q != ' ' && *q != '/' && *q != '\0')
7454                         q++;
7455
7456                       if (used_arg (r, q - r))
7457                         break;
7458
7459                       if (*q != '/')
7460                         {
7461                           mswitches[n_mswitches].str = mdswitches[i].str;
7462                           mswitches[n_mswitches].len = mdswitches[i].len;
7463                           mswitches[n_mswitches].replace = (char *) 0;
7464                           mswitches[n_mswitches].rep_len = 0;
7465                           n_mswitches++;
7466                           break;
7467                         }
7468
7469                       r = q + 1;
7470                     }
7471                   break;
7472                 }
7473             }
7474         }
7475     }
7476
7477   for (i = 0; i < n_mswitches; i++)
7478     if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
7479       return 1;
7480
7481   return 0;
7482 }
7483
7484 static int
7485 default_arg (const char *p, int len)
7486 {
7487   int i;
7488
7489   for (i = 0; i < n_mdswitches; i++)
7490     if (len == mdswitches[i].len && ! strncmp (p, mdswitches[i].str, len))
7491       return 1;
7492
7493   return 0;
7494 }
7495
7496 /* Work out the subdirectory to use based on the options. The format of
7497    multilib_select is a list of elements. Each element is a subdirectory
7498    name followed by a list of options followed by a semicolon. The format
7499    of multilib_exclusions is the same, but without the preceding
7500    directory. First gcc will check the exclusions, if none of the options
7501    beginning with an exclamation point are present, and all of the other
7502    options are present, then we will ignore this completely. Passing
7503    that, gcc will consider each multilib_select in turn using the same
7504    rules for matching the options. If a match is found, that subdirectory
7505    will be used.
7506    A subdirectory name is optionally followed by a colon and the corresponding
7507    multiarch name.  */
7508
7509 static void
7510 set_multilib_dir (void)
7511 {
7512   const char *p;
7513   unsigned int this_path_len;
7514   const char *this_path, *this_arg;
7515   const char *start, *end;
7516   int not_arg;
7517   int ok, ndfltok, first;
7518
7519   n_mdswitches = 0;
7520   start = multilib_defaults;
7521   while (*start == ' ' || *start == '\t')
7522     start++;
7523   while (*start != '\0')
7524     {
7525       n_mdswitches++;
7526       while (*start != ' ' && *start != '\t' && *start != '\0')
7527         start++;
7528       while (*start == ' ' || *start == '\t')
7529         start++;
7530     }
7531
7532   if (n_mdswitches)
7533     {
7534       int i = 0;
7535
7536       mdswitches = XNEWVEC (struct mdswitchstr, n_mdswitches);
7537       for (start = multilib_defaults; *start != '\0'; start = end + 1)
7538         {
7539           while (*start == ' ' || *start == '\t')
7540             start++;
7541
7542           if (*start == '\0')
7543             break;
7544
7545           for (end = start + 1;
7546                *end != ' ' && *end != '\t' && *end != '\0'; end++)
7547             ;
7548
7549           obstack_grow (&multilib_obstack, start, end - start);
7550           obstack_1grow (&multilib_obstack, 0);
7551           mdswitches[i].str = XOBFINISH (&multilib_obstack, const char *);
7552           mdswitches[i++].len = end - start;
7553
7554           if (*end == '\0')
7555             break;
7556         }
7557     }
7558
7559   p = multilib_exclusions;
7560   while (*p != '\0')
7561     {
7562       /* Ignore newlines.  */
7563       if (*p == '\n')
7564         {
7565           ++p;
7566           continue;
7567         }
7568
7569       /* Check the arguments.  */
7570       ok = 1;
7571       while (*p != ';')
7572         {
7573           if (*p == '\0')
7574             {
7575             invalid_exclusions:
7576               fatal_error ("multilib exclusions %qs is invalid",
7577                            multilib_exclusions);
7578             }
7579
7580           if (! ok)
7581             {
7582               ++p;
7583               continue;
7584             }
7585
7586           this_arg = p;
7587           while (*p != ' ' && *p != ';')
7588             {
7589               if (*p == '\0')
7590                 goto invalid_exclusions;
7591               ++p;
7592             }
7593
7594           if (*this_arg != '!')
7595             not_arg = 0;
7596           else
7597             {
7598               not_arg = 1;
7599               ++this_arg;
7600             }
7601
7602           ok = used_arg (this_arg, p - this_arg);
7603           if (not_arg)
7604             ok = ! ok;
7605
7606           if (*p == ' ')
7607             ++p;
7608         }
7609
7610       if (ok)
7611         return;
7612
7613       ++p;
7614     }
7615
7616   first = 1;
7617   p = multilib_select;
7618
7619   /* Append multilib reuse rules if any.  With those rules, we can reuse
7620      one multilib for certain different options sets.  */
7621   if (strlen (multilib_reuse) > 0)
7622     p = concat (p, multilib_reuse, NULL);
7623
7624   while (*p != '\0')
7625     {
7626       /* Ignore newlines.  */
7627       if (*p == '\n')
7628         {
7629           ++p;
7630           continue;
7631         }
7632
7633       /* Get the initial path.  */
7634       this_path = p;
7635       while (*p != ' ')
7636         {
7637           if (*p == '\0')
7638             {
7639             invalid_select:
7640               fatal_error ("multilib select %qs %qs is invalid",
7641                            multilib_select, multilib_reuse);
7642             }
7643           ++p;
7644         }
7645       this_path_len = p - this_path;
7646
7647       /* Check the arguments.  */
7648       ok = 1;
7649       ndfltok = 1;
7650       ++p;
7651       while (*p != ';')
7652         {
7653           if (*p == '\0')
7654             goto invalid_select;
7655
7656           if (! ok)
7657             {
7658               ++p;
7659               continue;
7660             }
7661
7662           this_arg = p;
7663           while (*p != ' ' && *p != ';')
7664             {
7665               if (*p == '\0')
7666                 goto invalid_select;
7667               ++p;
7668             }
7669
7670           if (*this_arg != '!')
7671             not_arg = 0;
7672           else
7673             {
7674               not_arg = 1;
7675               ++this_arg;
7676             }
7677
7678           /* If this is a default argument, we can just ignore it.
7679              This is true even if this_arg begins with '!'.  Beginning
7680              with '!' does not mean that this argument is necessarily
7681              inappropriate for this library: it merely means that
7682              there is a more specific library which uses this
7683              argument.  If this argument is a default, we need not
7684              consider that more specific library.  */
7685           ok = used_arg (this_arg, p - this_arg);
7686           if (not_arg)
7687             ok = ! ok;
7688
7689           if (! ok)
7690             ndfltok = 0;
7691
7692           if (default_arg (this_arg, p - this_arg))
7693             ok = 1;
7694
7695           if (*p == ' ')
7696             ++p;
7697         }
7698
7699       if (ok && first)
7700         {
7701           if (this_path_len != 1
7702               || this_path[0] != '.')
7703             {
7704               char *new_multilib_dir = XNEWVEC (char, this_path_len + 1);
7705               char *q;
7706
7707               strncpy (new_multilib_dir, this_path, this_path_len);
7708               new_multilib_dir[this_path_len] = '\0';
7709               q = strchr (new_multilib_dir, ':');
7710               if (q != NULL)
7711                 *q = '\0';
7712               multilib_dir = new_multilib_dir;
7713             }
7714           first = 0;
7715         }
7716
7717       if (ndfltok)
7718         {
7719           const char *q = this_path, *end = this_path + this_path_len;
7720
7721           while (q < end && *q != ':')
7722             q++;
7723           if (q < end)
7724             {
7725               const char *q2 = q + 1, *ml_end = end;
7726               char *new_multilib_os_dir;
7727
7728               while (q2 < end && *q2 != ':')
7729                 q2++;
7730               if (*q2 == ':')
7731                 ml_end = q2;
7732               new_multilib_os_dir = XNEWVEC (char, ml_end - q);
7733               memcpy (new_multilib_os_dir, q + 1, ml_end - q - 1);
7734               new_multilib_os_dir[ml_end - q - 1] = '\0';
7735               multilib_os_dir = *new_multilib_os_dir ? new_multilib_os_dir : ".";
7736
7737               if (q2 < end && *q2 == ':')
7738                 {
7739                   char *new_multiarch_dir = XNEWVEC (char, end - q2);
7740                   memcpy (new_multiarch_dir, q2 + 1, end - q2 - 1);
7741                   new_multiarch_dir[end - q2 - 1] = '\0';
7742                   multiarch_dir = new_multiarch_dir;
7743                 }
7744               break;
7745             }
7746         }
7747
7748       ++p;
7749     }
7750
7751   if (multilib_dir == NULL && multilib_os_dir != NULL
7752       && strcmp (multilib_os_dir, ".") == 0)
7753     {
7754       free (CONST_CAST (char *, multilib_os_dir));
7755       multilib_os_dir = NULL;
7756     }
7757   else if (multilib_dir != NULL && multilib_os_dir == NULL)
7758     multilib_os_dir = multilib_dir;
7759 }
7760
7761 /* Print out the multiple library subdirectory selection
7762    information.  This prints out a series of lines.  Each line looks
7763    like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
7764    required.  Only the desired options are printed out, the negative
7765    matches.  The options are print without a leading dash.  There are
7766    no spaces to make it easy to use the information in the shell.
7767    Each subdirectory is printed only once.  This assumes the ordering
7768    generated by the genmultilib script. Also, we leave out ones that match
7769    the exclusions.  */
7770
7771 static void
7772 print_multilib_info (void)
7773 {
7774   const char *p = multilib_select;
7775   const char *last_path = 0, *this_path;
7776   int skip;
7777   unsigned int last_path_len = 0;
7778
7779   while (*p != '\0')
7780     {
7781       skip = 0;
7782       /* Ignore newlines.  */
7783       if (*p == '\n')
7784         {
7785           ++p;
7786           continue;
7787         }
7788
7789       /* Get the initial path.  */
7790       this_path = p;
7791       while (*p != ' ')
7792         {
7793           if (*p == '\0')
7794             {
7795             invalid_select:
7796               fatal_error ("multilib select %qs is invalid", multilib_select);
7797             }
7798
7799           ++p;
7800         }
7801
7802       /* When --disable-multilib was used but target defines
7803          MULTILIB_OSDIRNAMES, entries starting with .: (and not starting
7804          with .:: for multiarch configurations) are there just to find
7805          multilib_os_dir, so skip them from output.  */
7806       if (this_path[0] == '.' && this_path[1] == ':' && this_path[2] != ':')
7807         skip = 1;
7808
7809       /* Check for matches with the multilib_exclusions. We don't bother
7810          with the '!' in either list. If any of the exclusion rules match
7811          all of its options with the select rule, we skip it.  */
7812       {
7813         const char *e = multilib_exclusions;
7814         const char *this_arg;
7815
7816         while (*e != '\0')
7817           {
7818             int m = 1;
7819             /* Ignore newlines.  */
7820             if (*e == '\n')
7821               {
7822                 ++e;
7823                 continue;
7824               }
7825
7826             /* Check the arguments.  */
7827             while (*e != ';')
7828               {
7829                 const char *q;
7830                 int mp = 0;
7831
7832                 if (*e == '\0')
7833                   {
7834                   invalid_exclusion:
7835                     fatal_error ("multilib exclusion %qs is invalid",
7836                                  multilib_exclusions);
7837                   }
7838
7839                 if (! m)
7840                   {
7841                     ++e;
7842                     continue;
7843                   }
7844
7845                 this_arg = e;
7846
7847                 while (*e != ' ' && *e != ';')
7848                   {
7849                     if (*e == '\0')
7850                       goto invalid_exclusion;
7851                     ++e;
7852                   }
7853
7854                 q = p + 1;
7855                 while (*q != ';')
7856                   {
7857                     const char *arg;
7858                     int len = e - this_arg;
7859
7860                     if (*q == '\0')
7861                       goto invalid_select;
7862
7863                     arg = q;
7864
7865                     while (*q != ' ' && *q != ';')
7866                       {
7867                         if (*q == '\0')
7868                           goto invalid_select;
7869                         ++q;
7870                       }
7871
7872                     if (! strncmp (arg, this_arg,
7873                                    (len < q - arg) ? q - arg : len)
7874                         || default_arg (this_arg, e - this_arg))
7875                       {
7876                         mp = 1;
7877                         break;
7878                       }
7879
7880                     if (*q == ' ')
7881                       ++q;
7882                   }
7883
7884                 if (! mp)
7885                   m = 0;
7886
7887                 if (*e == ' ')
7888                   ++e;
7889               }
7890
7891             if (m)
7892               {
7893                 skip = 1;
7894                 break;
7895               }
7896
7897             if (*e != '\0')
7898               ++e;
7899           }
7900       }
7901
7902       if (! skip)
7903         {
7904           /* If this is a duplicate, skip it.  */
7905           skip = (last_path != 0
7906                   && (unsigned int) (p - this_path) == last_path_len
7907                   && ! filename_ncmp (last_path, this_path, last_path_len));
7908
7909           last_path = this_path;
7910           last_path_len = p - this_path;
7911         }
7912
7913       /* If this directory requires any default arguments, we can skip
7914          it.  We will already have printed a directory identical to
7915          this one which does not require that default argument.  */
7916       if (! skip)
7917         {
7918           const char *q;
7919
7920           q = p + 1;
7921           while (*q != ';')
7922             {
7923               const char *arg;
7924
7925               if (*q == '\0')
7926                 goto invalid_select;
7927
7928               if (*q == '!')
7929                 arg = NULL;
7930               else
7931                 arg = q;
7932
7933               while (*q != ' ' && *q != ';')
7934                 {
7935                   if (*q == '\0')
7936                     goto invalid_select;
7937                   ++q;
7938                 }
7939
7940               if (arg != NULL
7941                   && default_arg (arg, q - arg))
7942                 {
7943                   skip = 1;
7944                   break;
7945                 }
7946
7947               if (*q == ' ')
7948                 ++q;
7949             }
7950         }
7951
7952       if (! skip)
7953         {
7954           const char *p1;
7955
7956           for (p1 = last_path; p1 < p && *p1 != ':'; p1++)
7957             putchar (*p1);
7958           putchar (';');
7959         }
7960
7961       ++p;
7962       while (*p != ';')
7963         {
7964           int use_arg;
7965
7966           if (*p == '\0')
7967             goto invalid_select;
7968
7969           if (skip)
7970             {
7971               ++p;
7972               continue;
7973             }
7974
7975           use_arg = *p != '!';
7976
7977           if (use_arg)
7978             putchar ('@');
7979
7980           while (*p != ' ' && *p != ';')
7981             {
7982               if (*p == '\0')
7983                 goto invalid_select;
7984               if (use_arg)
7985                 putchar (*p);
7986               ++p;
7987             }
7988
7989           if (*p == ' ')
7990             ++p;
7991         }
7992
7993       if (! skip)
7994         {
7995           /* If there are extra options, print them now.  */
7996           if (multilib_extra && *multilib_extra)
7997             {
7998               int print_at = TRUE;
7999               const char *q;
8000
8001               for (q = multilib_extra; *q != '\0'; q++)
8002                 {
8003                   if (*q == ' ')
8004                     print_at = TRUE;
8005                   else
8006                     {
8007                       if (print_at)
8008                         putchar ('@');
8009                       putchar (*q);
8010                       print_at = FALSE;
8011                     }
8012                 }
8013             }
8014
8015           putchar ('\n');
8016         }
8017
8018       ++p;
8019     }
8020 }
8021 \f
8022 /* getenv built-in spec function.
8023
8024    Returns the value of the environment variable given by its first
8025    argument, concatenated with the second argument.  If the
8026    environment variable is not defined, a fatal error is issued.  */
8027
8028 static const char *
8029 getenv_spec_function (int argc, const char **argv)
8030 {
8031   char *value;
8032   char *result;
8033   char *ptr;
8034   size_t len;
8035
8036   if (argc != 2)
8037     return NULL;
8038
8039   value = getenv (argv[0]);
8040   if (!value)
8041     fatal_error ("environment variable %qs not defined", argv[0]);
8042
8043   /* We have to escape every character of the environment variable so
8044      they are not interpreted as active spec characters.  A
8045      particularly painful case is when we are reading a variable
8046      holding a windows path complete with \ separators.  */
8047   len = strlen (value) * 2 + strlen (argv[1]) + 1;
8048   result = XNEWVAR (char, len);
8049   for (ptr = result; *value; ptr += 2)
8050     {
8051       ptr[0] = '\\';
8052       ptr[1] = *value++;
8053     }
8054
8055   strcpy (ptr, argv[1]);
8056
8057   return result;
8058 }
8059
8060 /* if-exists built-in spec function.
8061
8062    Checks to see if the file specified by the absolute pathname in
8063    ARGS exists.  Returns that pathname if found.
8064
8065    The usual use for this function is to check for a library file
8066    (whose name has been expanded with %s).  */
8067
8068 static const char *
8069 if_exists_spec_function (int argc, const char **argv)
8070 {
8071   /* Must have only one argument.  */
8072   if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
8073     return argv[0];
8074
8075   return NULL;
8076 }
8077
8078 /* if-exists-else built-in spec function.
8079
8080    This is like if-exists, but takes an additional argument which
8081    is returned if the first argument does not exist.  */
8082
8083 static const char *
8084 if_exists_else_spec_function (int argc, const char **argv)
8085 {
8086   /* Must have exactly two arguments.  */
8087   if (argc != 2)
8088     return NULL;
8089
8090   if (IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
8091     return argv[0];
8092
8093   return argv[1];
8094 }
8095
8096 /* sanitize built-in spec function.
8097
8098    This returns non-NULL, if sanitizing address, thread or
8099    any of the undefined behavior sanitizers.  */
8100
8101 static const char *
8102 sanitize_spec_function (int argc, const char **argv)
8103 {
8104   if (argc != 1)
8105     return NULL;
8106
8107   if (strcmp (argv[0], "address") == 0)
8108     return (flag_sanitize & SANITIZE_ADDRESS) ? "" : NULL;
8109   if (strcmp (argv[0], "thread") == 0)
8110     return (flag_sanitize & SANITIZE_THREAD) ? "" : NULL;
8111   if (strcmp (argv[0], "undefined") == 0)
8112     return (flag_sanitize & SANITIZE_UNDEFINED) ? "" : NULL;
8113
8114   return NULL;
8115 }
8116
8117 /* replace-outfile built-in spec function.
8118
8119    This looks for the first argument in the outfiles array's name and
8120    replaces it with the second argument.  */
8121
8122 static const char *
8123 replace_outfile_spec_function (int argc, const char **argv)
8124 {
8125   int i;
8126   /* Must have exactly two arguments.  */
8127   if (argc != 2)
8128     abort ();
8129
8130   for (i = 0; i < n_infiles; i++)
8131     {
8132       if (outfiles[i] && !filename_cmp (outfiles[i], argv[0]))
8133         outfiles[i] = xstrdup (argv[1]);
8134     }
8135   return NULL;
8136 }
8137
8138 /* remove-outfile built-in spec function.
8139  *
8140  *    This looks for the first argument in the outfiles array's name and
8141  *       removes it.  */
8142
8143 static const char *
8144 remove_outfile_spec_function (int argc, const char **argv)
8145 {
8146   int i;
8147   /* Must have exactly one argument.  */
8148   if (argc != 1)
8149     abort ();
8150
8151   for (i = 0; i < n_infiles; i++)
8152     {
8153       if (outfiles[i] && !filename_cmp (outfiles[i], argv[0]))
8154         outfiles[i] = NULL;
8155     }
8156   return NULL;
8157 }
8158
8159 /* Given two version numbers, compares the two numbers.
8160    A version number must match the regular expression
8161    ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
8162 */
8163 static int
8164 compare_version_strings (const char *v1, const char *v2)
8165 {
8166   int rresult;
8167   regex_t r;
8168
8169   if (regcomp (&r, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
8170                REG_EXTENDED | REG_NOSUB) != 0)
8171     abort ();
8172   rresult = regexec (&r, v1, 0, NULL, 0);
8173   if (rresult == REG_NOMATCH)
8174     fatal_error ("invalid version number %qs", v1);
8175   else if (rresult != 0)
8176     abort ();
8177   rresult = regexec (&r, v2, 0, NULL, 0);
8178   if (rresult == REG_NOMATCH)
8179     fatal_error ("invalid version number %qs", v2);
8180   else if (rresult != 0)
8181     abort ();
8182
8183   return strverscmp (v1, v2);
8184 }
8185
8186
8187 /* version_compare built-in spec function.
8188
8189    This takes an argument of the following form:
8190
8191    <comparison-op> <arg1> [<arg2>] <switch> <result>
8192
8193    and produces "result" if the comparison evaluates to true,
8194    and nothing if it doesn't.
8195
8196    The supported <comparison-op> values are:
8197
8198    >=  true if switch is a later (or same) version than arg1
8199    !>  opposite of >=
8200    <   true if switch is an earlier version than arg1
8201    !<  opposite of <
8202    ><  true if switch is arg1 or later, and earlier than arg2
8203    <>  true if switch is earlier than arg1 or is arg2 or later
8204
8205    If the switch is not present, the condition is false unless
8206    the first character of the <comparison-op> is '!'.
8207
8208    For example,
8209    %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
8210    adds -lmx if -mmacosx-version-min=10.3.9 was passed.  */
8211
8212 static const char *
8213 version_compare_spec_function (int argc, const char **argv)
8214 {
8215   int comp1, comp2;
8216   size_t switch_len;
8217   const char *switch_value = NULL;
8218   int nargs = 1, i;
8219   bool result;
8220
8221   if (argc < 3)
8222     fatal_error ("too few arguments to %%:version-compare");
8223   if (argv[0][0] == '\0')
8224     abort ();
8225   if ((argv[0][1] == '<' || argv[0][1] == '>') && argv[0][0] != '!')
8226     nargs = 2;
8227   if (argc != nargs + 3)
8228     fatal_error ("too many arguments to %%:version-compare");
8229
8230   switch_len = strlen (argv[nargs + 1]);
8231   for (i = 0; i < n_switches; i++)
8232     if (!strncmp (switches[i].part1, argv[nargs + 1], switch_len)
8233         && check_live_switch (i, switch_len))
8234       switch_value = switches[i].part1 + switch_len;
8235
8236   if (switch_value == NULL)
8237     comp1 = comp2 = -1;
8238   else
8239     {
8240       comp1 = compare_version_strings (switch_value, argv[1]);
8241       if (nargs == 2)
8242         comp2 = compare_version_strings (switch_value, argv[2]);
8243       else
8244         comp2 = -1;  /* This value unused.  */
8245     }
8246
8247   switch (argv[0][0] << 8 | argv[0][1])
8248     {
8249     case '>' << 8 | '=':
8250       result = comp1 >= 0;
8251       break;
8252     case '!' << 8 | '<':
8253       result = comp1 >= 0 || switch_value == NULL;
8254       break;
8255     case '<' << 8:
8256       result = comp1 < 0;
8257       break;
8258     case '!' << 8 | '>':
8259       result = comp1 < 0 || switch_value == NULL;
8260       break;
8261     case '>' << 8 | '<':
8262       result = comp1 >= 0 && comp2 < 0;
8263       break;
8264     case '<' << 8 | '>':
8265       result = comp1 < 0 || comp2 >= 0;
8266       break;
8267
8268     default:
8269       fatal_error ("unknown operator %qs in %%:version-compare", argv[0]);
8270     }
8271   if (! result)
8272     return NULL;
8273
8274   return argv[nargs + 2];
8275 }
8276
8277 /* %:include builtin spec function.  This differs from %include in that it
8278    can be nested inside a spec, and thus be conditionalized.  It takes
8279    one argument, the filename, and looks for it in the startfile path.
8280    The result is always NULL, i.e. an empty expansion.  */
8281
8282 static const char *
8283 include_spec_function (int argc, const char **argv)
8284 {
8285   char *file;
8286
8287   if (argc != 1)
8288     abort ();
8289
8290   file = find_a_file (&startfile_prefixes, argv[0], R_OK, true);
8291   read_specs (file ? file : argv[0], false, false);
8292
8293   return NULL;
8294 }
8295
8296 /* %:find-file spec function.  This function replaces its argument by
8297     the file found through find_file, that is the -print-file-name gcc
8298     program option. */
8299 static const char *
8300 find_file_spec_function (int argc, const char **argv)
8301 {
8302   const char *file;
8303
8304   if (argc != 1)
8305     abort ();
8306
8307   file = find_file (argv[0]);
8308   return file;
8309 }
8310
8311
8312 /* %:find-plugindir spec function.  This function replaces its argument
8313     by the -iplugindir=<dir> option.  `dir' is found through find_file, that
8314     is the -print-file-name gcc program option. */
8315 static const char *
8316 find_plugindir_spec_function (int argc, const char **argv ATTRIBUTE_UNUSED)
8317 {
8318   const char *option;
8319
8320   if (argc != 0)
8321     abort ();
8322
8323   option = concat ("-iplugindir=", find_file ("plugin"), NULL);
8324   return option;
8325 }
8326
8327
8328 /* %:print-asm-header spec function.  Print a banner to say that the
8329    following output is from the assembler.  */
8330
8331 static const char *
8332 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED,
8333                                 const char **argv ATTRIBUTE_UNUSED)
8334 {
8335   printf (_("Assembler options\n=================\n\n"));
8336   printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
8337   fflush (stdout);
8338   return NULL;
8339 }
8340
8341 /* Get a random number for -frandom-seed */
8342
8343 static unsigned HOST_WIDE_INT
8344 get_random_number (void)
8345 {
8346   unsigned HOST_WIDE_INT ret = 0;
8347   int fd;
8348
8349   fd = open ("/dev/urandom", O_RDONLY);
8350   if (fd >= 0)
8351     {
8352       read (fd, &ret, sizeof (HOST_WIDE_INT));
8353       close (fd);
8354       if (ret)
8355         return ret;
8356     }
8357
8358   /* Get some more or less random data.  */
8359 #ifdef HAVE_GETTIMEOFDAY
8360   {
8361     struct timeval tv;
8362
8363     gettimeofday (&tv, NULL);
8364     ret = tv.tv_sec * 1000 + tv.tv_usec / 1000;
8365   }
8366 #else
8367   {
8368     time_t now = time (NULL);
8369
8370     if (now != (time_t)-1)
8371       ret = (unsigned) now;
8372   }
8373 #endif
8374
8375   return ret ^ getpid ();
8376 }
8377
8378 /* %:compare-debug-dump-opt spec function.  Save the last argument,
8379    expected to be the last -fdump-final-insns option, or generate a
8380    temporary.  */
8381
8382 static const char *
8383 compare_debug_dump_opt_spec_function (int arg,
8384                                       const char **argv ATTRIBUTE_UNUSED)
8385 {
8386   char *ret;
8387   char *name;
8388   int which;
8389   static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];
8390
8391   if (arg != 0)
8392     fatal_error ("too many arguments to %%:compare-debug-dump-opt");
8393
8394   do_spec_2 ("%{fdump-final-insns=*:%*}");
8395   do_spec_1 (" ", 0, NULL);
8396
8397   if (argbuf.length () > 0
8398       && strcmp (argv[argbuf.length () - 1], "."))
8399     {
8400       if (!compare_debug)
8401         return NULL;
8402
8403       name = xstrdup (argv[argbuf.length () - 1]);
8404       ret = NULL;
8405     }
8406   else
8407     {
8408       const char *ext = NULL;
8409
8410       if (argbuf.length () > 0)
8411         {
8412           do_spec_2 ("%{o*:%*}%{!o:%{!S:%b%O}%{S:%b.s}}");
8413           ext = ".gkd";
8414         }
8415       else if (!compare_debug)
8416         return NULL;
8417       else
8418         do_spec_2 ("%g.gkd");
8419
8420       do_spec_1 (" ", 0, NULL);
8421
8422       gcc_assert (argbuf.length () > 0);
8423
8424       name = concat (argbuf.last (), ext, NULL);
8425
8426       ret = concat ("-fdump-final-insns=", name, NULL);
8427     }
8428
8429   which = compare_debug < 0;
8430   debug_check_temp_file[which] = name;
8431
8432   if (!which)
8433     {
8434       unsigned HOST_WIDE_INT value = get_random_number ();
8435
8436       sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value);
8437     }
8438
8439   if (*random_seed)
8440     {
8441       char *tmp = ret;
8442       ret = concat ("%{!frandom-seed=*:-frandom-seed=", random_seed, "} ",
8443                     ret, NULL);
8444       free (tmp);
8445     }
8446
8447   if (which)
8448     *random_seed = 0;
8449
8450   return ret;
8451 }
8452
8453 static const char *debug_auxbase_opt;
8454
8455 /* %:compare-debug-self-opt spec function.  Expands to the options
8456     that are to be passed in the second compilation of
8457     compare-debug.  */
8458
8459 static const char *
8460 compare_debug_self_opt_spec_function (int arg,
8461                                       const char **argv ATTRIBUTE_UNUSED)
8462 {
8463   if (arg != 0)
8464     fatal_error ("too many arguments to %%:compare-debug-self-opt");
8465
8466   if (compare_debug >= 0)
8467     return NULL;
8468
8469   do_spec_2 ("%{c|S:%{o*:%*}}");
8470   do_spec_1 (" ", 0, NULL);
8471
8472   if (argbuf.length () > 0)
8473     debug_auxbase_opt = concat ("-auxbase-strip ",
8474                                 argbuf.last (),
8475                                 NULL);
8476   else
8477     debug_auxbase_opt = NULL;
8478
8479   return concat ("\
8480 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
8481 %<fdump-final-insns=* -w -S -o %j \
8482 %{!fcompare-debug-second:-fcompare-debug-second} \
8483 ", compare_debug_opt, NULL);
8484 }
8485
8486 /* %:compare-debug-auxbase-opt spec function.  Expands to the auxbase
8487     options that are to be passed in the second compilation of
8488     compare-debug.  It expects, as an argument, the basename of the
8489     current input file name, with the .gk suffix appended to it.  */
8490
8491 static const char *
8492 compare_debug_auxbase_opt_spec_function (int arg,
8493                                          const char **argv)
8494 {
8495   char *name;
8496   int len;
8497
8498   if (arg == 0)
8499     fatal_error ("too few arguments to %%:compare-debug-auxbase-opt");
8500
8501   if (arg != 1)
8502     fatal_error ("too many arguments to %%:compare-debug-auxbase-opt");
8503
8504   if (compare_debug >= 0)
8505     return NULL;
8506
8507   len = strlen (argv[0]);
8508   if (len < 3 || strcmp (argv[0] + len - 3, ".gk") != 0)
8509     fatal_error ("argument to %%:compare-debug-auxbase-opt "
8510                  "does not end in .gk");
8511
8512   if (debug_auxbase_opt)
8513     return debug_auxbase_opt;
8514
8515 #define OPT "-auxbase "
8516
8517   len -= 3;
8518   name = (char*) xmalloc (sizeof (OPT) + len);
8519   memcpy (name, OPT, sizeof (OPT) - 1);
8520   memcpy (name + sizeof (OPT) - 1, argv[0], len);
8521   name[sizeof (OPT) - 1 + len] = '\0';
8522
8523 #undef OPT
8524
8525   return name;
8526 }
8527
8528 /* %:pass-through-libs spec function.  Finds all -l options and input
8529    file names in the lib spec passed to it, and makes a list of them
8530    prepended with the plugin option to cause them to be passed through
8531    to the final link after all the new object files have been added.  */
8532
8533 const char *
8534 pass_through_libs_spec_func (int argc, const char **argv)
8535 {
8536   char *prepended = xstrdup (" ");
8537   int n;
8538   /* Shlemiel the painter's algorithm.  Innately horrible, but at least
8539      we know that there will never be more than a handful of strings to
8540      concat, and it's only once per run, so it's not worth optimising.  */
8541   for (n = 0; n < argc; n++)
8542     {
8543       char *old = prepended;
8544       /* Anything that isn't an option is a full path to an output
8545          file; pass it through if it ends in '.a'.  Among options,
8546          pass only -l.  */
8547       if (argv[n][0] == '-' && argv[n][1] == 'l')
8548         {
8549           const char *lopt = argv[n] + 2;
8550           /* Handle both joined and non-joined -l options.  If for any
8551              reason there's a trailing -l with no joined or following
8552              arg just discard it.  */
8553           if (!*lopt && ++n >= argc)
8554             break;
8555           else if (!*lopt)
8556             lopt = argv[n];
8557           prepended = concat (prepended, "-plugin-opt=-pass-through=-l",
8558                 lopt, " ", NULL);
8559         }
8560       else if (!strcmp (".a", argv[n] + strlen (argv[n]) - 2))
8561         {
8562           prepended = concat (prepended, "-plugin-opt=-pass-through=",
8563                 argv[n], " ", NULL);
8564         }
8565       if (prepended != old)
8566         free (old);
8567     }
8568   return prepended;
8569 }
8570
8571 /* %:replace-extension spec function.  Replaces the extension of the
8572    first argument with the second argument.  */
8573
8574 const char *
8575 replace_extension_spec_func (int argc, const char **argv)
8576 {
8577   char *name;
8578   char *p;
8579   char *result;
8580   int i;
8581
8582   if (argc != 2)
8583     fatal_error ("too few arguments to %%:replace-extension");
8584
8585   name = xstrdup (argv[0]);
8586
8587   for (i = strlen (name) - 1; i >= 0; i--)
8588     if (IS_DIR_SEPARATOR (name[i]))
8589       break;
8590
8591   p = strrchr (name + i + 1, '.');
8592   if (p != NULL)
8593       *p = '\0';
8594
8595   result = concat (name, argv[1], NULL);
8596
8597   free (name);
8598   return result;
8599 }
8600
8601 /* Insert backslash before spaces in ORIG (usually a file path), to
8602    avoid being broken by spec parser.
8603
8604    This function is needed as do_spec_1 treats white space (' ' and '\t')
8605    as the end of an argument. But in case of -plugin /usr/gcc install/xxx.so,
8606    the file name should be treated as a single argument rather than being
8607    broken into multiple. Solution is to insert '\\' before the space in a
8608    file name.
8609
8610    This function converts and only converts all occurrence of ' '
8611    to '\\' + ' ' and '\t' to '\\' + '\t'.  For example:
8612    "a b"  -> "a\\ b"
8613    "a  b" -> "a\\ \\ b"
8614    "a\tb" -> "a\\\tb"
8615    "a\\ b" -> "a\\\\ b"
8616
8617    orig: input null-terminating string that was allocated by xalloc. The
8618    memory it points to might be freed in this function. Behavior undefined
8619    if ORIG wasn't xalloced or was freed already at entry.
8620
8621    Return: ORIG if no conversion needed. Otherwise a newly allocated string
8622    that was converted from ORIG.  */
8623
8624 static char *
8625 convert_white_space (char *orig)
8626 {
8627   int len, number_of_space = 0;
8628
8629   for (len = 0; orig[len]; len++)
8630     if (orig[len] == ' ' || orig[len] == '\t') number_of_space++;
8631
8632   if (number_of_space)
8633     {
8634       char *new_spec = (char *) xmalloc (len + number_of_space + 1);
8635       int j, k;
8636       for (j = 0, k = 0; j <= len; j++, k++)
8637         {
8638           if (orig[j] == ' ' || orig[j] == '\t')
8639             new_spec[k++] = '\\';
8640           new_spec[k] = orig[j];
8641         }
8642       free (orig);
8643       return new_spec;
8644   }
8645   else
8646     return orig;
8647 }