gcc/gcc.c

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