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