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