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