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 that the input of this command is coming from a pipe.  */
4689 static int input_from_pipe;
4690
4691 /* Nonnull means substitute this for any suffix when outputting a switches
4692    arguments.  */
4693 static const char *suffix_subst;
4694
4695 /* If there is an argument being accumulated, terminate it and store it.  */
4696
4697 static void
4698 end_going_arg (void)
4699 {
4700   if (arg_going)
4701     {
4702       const char *string;
4703
4704       obstack_1grow (&obstack, 0);
4705       string = XOBFINISH (&obstack, const char *);
4706       if (this_is_library_file)
4707         string = find_file (string);
4708       store_arg (string, delete_this_arg, this_is_output_file);
4709       if (this_is_output_file)
4710         outfiles[input_file_number] = string;
4711       arg_going = 0;
4712     }
4713 }
4714
4715
4716 /* Parse the WRAPPER string which is a comma separated list of the command line
4717    and insert them into the beginning of argbuf.  */
4718
4719 static void
4720 insert_wrapper (const char *wrapper)
4721 {
4722   int n = 0;
4723   int i;
4724   char *buf = xstrdup (wrapper);
4725   char *p = buf;
4726
4727   do
4728     {
4729       n++;
4730       while (*p == ',')
4731         p++;
4732     }
4733   while ((p = strchr (p, ',')) != NULL);
4734
4735   if (argbuf_index + n >= argbuf_length)
4736     {
4737       argbuf_length = argbuf_length * 2;
4738       while (argbuf_length < argbuf_index + n)
4739         argbuf_length *= 2;
4740       argbuf = XRESIZEVEC (const char *, argbuf, argbuf_length);
4741     }
4742   for (i = argbuf_index - 1; i >= 0; i--)
4743     argbuf[i + n] = argbuf[i];
4744
4745   i = 0;
4746   p = buf;
4747   do
4748     {
4749       while (*p == ',')
4750         {
4751           *p = 0;
4752           p++;
4753         }
4754       argbuf[i++] = p;
4755     }
4756   while ((p = strchr (p, ',')) != NULL);
4757   gcc_assert (i == n);
4758   argbuf_index += n;
4759 }
4760
4761 /* Process the spec SPEC and run the commands specified therein.
4762    Returns 0 if the spec is successfully processed; -1 if failed.  */
4763
4764 int
4765 do_spec (const char *spec)
4766 {
4767   int value;
4768
4769   value = do_spec_2 (spec);
4770
4771   /* Force out any unfinished command.
4772      If -pipe, this forces out the last command if it ended in `|'.  */
4773   if (value == 0)
4774     {
4775       if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
4776         argbuf_index--;
4777
4778       set_collect_gcc_options ();
4779
4780       if (argbuf_index > 0)
4781         value = execute ();
4782     }
4783
4784   return value;
4785 }
4786
4787 static int
4788 do_spec_2 (const char *spec)
4789 {
4790   int result;
4791
4792   clear_args ();
4793   arg_going = 0;
4794   delete_this_arg = 0;
4795   this_is_output_file = 0;
4796   this_is_library_file = 0;
4797   input_from_pipe = 0;
4798   suffix_subst = NULL;
4799
4800   result = do_spec_1 (spec, 0, NULL);
4801
4802   end_going_arg ();
4803
4804   return result;
4805 }
4806
4807
4808 /* Process the given spec string and add any new options to the end
4809    of the switches/n_switches array.  */
4810
4811 static void
4812 do_option_spec (const char *name, const char *spec)
4813 {
4814   unsigned int i, value_count, value_len;
4815   const char *p, *q, *value;
4816   char *tmp_spec, *tmp_spec_p;
4817
4818   if (configure_default_options[0].name == NULL)
4819     return;
4820
4821   for (i = 0; i < ARRAY_SIZE (configure_default_options); i++)
4822     if (strcmp (configure_default_options[i].name, name) == 0)
4823       break;
4824   if (i == ARRAY_SIZE (configure_default_options))
4825     return;
4826
4827   value = configure_default_options[i].value;
4828   value_len = strlen (value);
4829
4830   /* Compute the size of the final spec.  */
4831   value_count = 0;
4832   p = spec;
4833   while ((p = strstr (p, "%(VALUE)")) != NULL)
4834     {
4835       p ++;
4836       value_count ++;
4837     }
4838
4839   /* Replace each %(VALUE) by the specified value.  */
4840   tmp_spec = (char *) alloca (strlen (spec) + 1
4841                      + value_count * (value_len - strlen ("%(VALUE)")));
4842   tmp_spec_p = tmp_spec;
4843   q = spec;
4844   while ((p = strstr (q, "%(VALUE)")) != NULL)
4845     {
4846       memcpy (tmp_spec_p, q, p - q);
4847       tmp_spec_p = tmp_spec_p + (p - q);
4848       memcpy (tmp_spec_p, value, value_len);
4849       tmp_spec_p += value_len;
4850       q = p + strlen ("%(VALUE)");
4851     }
4852   strcpy (tmp_spec_p, q);
4853
4854   do_self_spec (tmp_spec);
4855 }
4856
4857 /* Process the given spec string and add any new options to the end
4858    of the switches/n_switches array.  */
4859
4860 static void
4861 do_self_spec (const char *spec)
4862 {
4863   do_spec_2 (spec);
4864   do_spec_1 (" ", 0, NULL);
4865
4866   if (argbuf_index > 0)
4867     {
4868       int i;
4869
4870       switches = XRESIZEVEC (struct switchstr, switches,
4871                              n_switches + argbuf_index + 1);
4872
4873       for (i = 0; i < argbuf_index; i++)
4874         {
4875           struct switchstr *sw;
4876           const char *p = argbuf[i];
4877           int c = *p;
4878
4879           /* Each switch should start with '-'.  */
4880           if (c != '-')
4881             fatal ("switch '%s' does not start with '-'", argbuf[i]);
4882
4883           p++;
4884           c = *p;
4885
4886           sw = &switches[n_switches++];
4887           sw->part1 = p;
4888           sw->live_cond = 0;
4889           sw->validated = 0;
4890           sw->ordering = 0;
4891
4892           /* Deal with option arguments in separate argv elements.  */
4893           if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
4894               || WORD_SWITCH_TAKES_ARG (p))
4895             {
4896               int j = 0;
4897               int n_args = WORD_SWITCH_TAKES_ARG (p);
4898
4899               if (n_args == 0)
4900                 {
4901                   /* Count only the option arguments in separate argv elements.  */
4902                   n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
4903                 }
4904               if (i + n_args >= argbuf_index)
4905                 fatal ("argument to '-%s' is missing", p);
4906               sw->args
4907                 = XNEWVEC (const char *, n_args + 1);
4908               while (j < n_args)
4909                 sw->args[j++] = argbuf[++i];
4910               /* Null-terminate the vector.  */
4911               sw->args[j] = 0;
4912             }
4913           else if (strchr (switches_need_spaces, c))
4914             {
4915               /* On some systems, ld cannot handle some options without
4916                  a space.  So split the option from its argument.  */
4917               char *part1 = XNEWVEC (char, 2);
4918               part1[0] = c;
4919               part1[1] = '\0';
4920
4921               sw->part1 = part1;
4922               sw->args = XNEWVEC (const char *, 2);
4923               sw->args[0] = xstrdup (p+1);
4924               sw->args[1] = 0;
4925             }
4926           else
4927             sw->args = 0;
4928         }
4929
4930       switches[n_switches].part1 = 0;
4931     }
4932 }
4933
4934 /* Callback for processing %D and %I specs.  */
4935
4936 struct spec_path_info {
4937   const char *option;
4938   const char *append;
4939   size_t append_len;
4940   bool omit_relative;
4941   bool separate_options;
4942 };
4943
4944 static void *
4945 spec_path (char *path, void *data)
4946 {
4947   struct spec_path_info *info = (struct spec_path_info *) data;
4948   size_t len = 0;
4949   char save = 0;
4950
4951   if (info->omit_relative && !IS_ABSOLUTE_PATH (path))
4952     return NULL;
4953
4954   if (info->append_len != 0)
4955     {
4956       len = strlen (path);
4957       memcpy (path + len, info->append, info->append_len + 1);
4958     }
4959
4960   if (!is_directory (path, true))
4961     return NULL;
4962
4963   do_spec_1 (info->option, 1, NULL);
4964   if (info->separate_options)
4965     do_spec_1 (" ", 0, NULL);
4966
4967   if (info->append_len == 0)
4968     {
4969       len = strlen (path);
4970       save = path[len - 1];
4971       if (IS_DIR_SEPARATOR (path[len - 1]))
4972         path[len - 1] = '\0';
4973     }
4974
4975   do_spec_1 (path, 1, NULL);
4976   do_spec_1 (" ", 0, NULL);
4977
4978   /* Must not damage the original path.  */
4979   if (info->append_len == 0)
4980     path[len - 1] = save;
4981
4982   return NULL;
4983 }
4984
4985 /* Create a temporary FILE with the contents of ARGV. Add @FILE to the
4986    argument list. */
4987
4988 static void
4989 create_at_file (char **argv)
4990 {
4991   char *temp_file = make_temp_file ("");
4992   char *at_argument = concat ("@", temp_file, NULL);
4993   FILE *f = fopen (temp_file, "w");
4994   int status;
4995
4996   if (f == NULL)
4997     fatal ("could not open temporary response file %s",
4998            temp_file);
4999
5000   status = writeargv (argv, f);
5001
5002   if (status)
5003     fatal ("could not write to temporary response file %s",
5004            temp_file);
5005
5006   status = fclose (f);
5007
5008   if (EOF == status)
5009     fatal ("could not close temporary response file %s",
5010            temp_file);
5011
5012   store_arg (at_argument, 0, 0);
5013
5014   record_temp_file (temp_file, !save_temps_flag, !save_temps_flag);
5015 }
5016
5017 /* True if we should compile INFILE. */
5018
5019 static bool
5020 compile_input_file_p (struct infile *infile)
5021 {
5022   if ((!infile->language) || (infile->language[0] != '*'))
5023     if (infile->incompiler == input_file_compiler)
5024       return true;
5025   return false;
5026 }
5027
5028 /* Process the sub-spec SPEC as a portion of a larger spec.
5029    This is like processing a whole spec except that we do
5030    not initialize at the beginning and we do not supply a
5031    newline by default at the end.
5032    INSWITCH nonzero means don't process %-sequences in SPEC;
5033    in this case, % is treated as an ordinary character.
5034    This is used while substituting switches.
5035    INSWITCH nonzero also causes SPC not to terminate an argument.
5036
5037    Value is zero unless a line was finished
5038    and the command on that line reported an error.  */
5039
5040 static int
5041 do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
5042 {
5043   const char *p = spec;
5044   int c;
5045   int i;
5046   int value;
5047
5048   while ((c = *p++))
5049     /* If substituting a switch, treat all chars like letters.
5050        Otherwise, NL, SPC, TAB and % are special.  */
5051     switch (inswitch ? 'a' : c)
5052       {
5053       case '\n':
5054         end_going_arg ();
5055
5056         if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
5057           {
5058             /* A `|' before the newline means use a pipe here,
5059                but only if -pipe was specified.
5060                Otherwise, execute now and don't pass the `|' as an arg.  */
5061             if (use_pipes)
5062               {
5063                 input_from_pipe = 1;
5064                 break;
5065               }
5066             else
5067               argbuf_index--;
5068           }
5069
5070         set_collect_gcc_options ();
5071
5072         if (argbuf_index > 0)
5073           {
5074             value = execute ();
5075             if (value)
5076               return value;
5077           }
5078         /* Reinitialize for a new command, and for a new argument.  */
5079         clear_args ();
5080         arg_going = 0;
5081         delete_this_arg = 0;
5082         this_is_output_file = 0;
5083         this_is_library_file = 0;
5084         input_from_pipe = 0;
5085         break;
5086
5087       case '|':
5088         end_going_arg ();
5089
5090         /* Use pipe */
5091         obstack_1grow (&obstack, c);
5092         arg_going = 1;
5093         break;
5094
5095       case '\t':
5096       case ' ':
5097         end_going_arg ();
5098
5099         /* Reinitialize for a new argument.  */
5100         delete_this_arg = 0;
5101         this_is_output_file = 0;
5102         this_is_library_file = 0;
5103         break;
5104
5105       case '%':
5106         switch (c = *p++)
5107           {
5108           case 0:
5109             fatal ("spec '%s' invalid", spec);
5110
5111           case 'b':
5112             if (save_temps_length)
5113               obstack_grow (&obstack, save_temps_prefix, save_temps_length);
5114             else
5115               obstack_grow (&obstack, input_basename, basename_length);
5116             if (compare_debug < 0)
5117               obstack_grow (&obstack, ".gk", 3);
5118             arg_going = 1;
5119             break;
5120
5121           case 'B':
5122             if (save_temps_length)
5123               obstack_grow (&obstack, save_temps_prefix, save_temps_length);
5124             else
5125               obstack_grow (&obstack, input_basename, suffixed_basename_length);
5126             if (compare_debug < 0)
5127               obstack_grow (&obstack, ".gk", 3);
5128             arg_going = 1;
5129             break;
5130
5131           case 'd':
5132             delete_this_arg = 2;
5133             break;
5134
5135           /* Dump out the directories specified with LIBRARY_PATH,
5136              followed by the absolute directories
5137              that we search for startfiles.  */
5138           case 'D':
5139             {
5140               struct spec_path_info info;
5141
5142               info.option = "-L";
5143               info.append_len = 0;
5144 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
5145               /* Used on systems which record the specified -L dirs
5146                  and use them to search for dynamic linking.
5147                  Relative directories always come from -B,
5148                  and it is better not to use them for searching
5149                  at run time.  In particular, stage1 loses.  */
5150               info.omit_relative = true;
5151 #else
5152               info.omit_relative = false;
5153 #endif
5154               info.separate_options = false;
5155
5156               for_each_path (&startfile_prefixes, true, 0, spec_path, &info);
5157             }
5158             break;
5159
5160           case 'e':
5161             /* %efoo means report an error with `foo' as error message
5162                and don't execute any more commands for this file.  */
5163             {
5164               const char *q = p;
5165               char *buf;
5166               while (*p != 0 && *p != '\n')
5167                 p++;
5168               buf = (char *) alloca (p - q + 1);
5169               strncpy (buf, q, p - q);
5170               buf[p - q] = 0;
5171               error ("%s", buf);
5172               return -1;
5173             }
5174             break;
5175           case 'n':
5176             /* %nfoo means report a notice with `foo' on stderr.  */
5177             {
5178               const char *q = p;
5179               char *buf;
5180               while (*p != 0 && *p != '\n')
5181                 p++;
5182               buf = (char *) alloca (p - q + 1);
5183               strncpy (buf, q, p - q);
5184               buf[p - q] = 0;
5185               notice ("%s\n", buf);
5186               if (*p)
5187                 p++;
5188             }
5189             break;
5190
5191           case 'j':
5192             {
5193               struct stat st;
5194
5195               /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
5196                  defined, and it is not a directory, and it is
5197                  writable, use it.  Otherwise, treat this like any
5198                  other temporary file.  */
5199
5200               if ((!save_temps_flag)
5201                   && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode))
5202                   && (access (HOST_BIT_BUCKET, W_OK) == 0))
5203                 {
5204                   obstack_grow (&obstack, HOST_BIT_BUCKET,
5205                                 strlen (HOST_BIT_BUCKET));
5206                   delete_this_arg = 0;
5207                   arg_going = 1;
5208                   break;
5209                 }
5210             }
5211             goto create_temp_file;
5212           case '|':
5213             if (use_pipes)
5214               {
5215                 obstack_1grow (&obstack, '-');
5216                 delete_this_arg = 0;
5217                 arg_going = 1;
5218
5219                 /* consume suffix */
5220                 while (*p == '.' || ISALNUM ((unsigned char) *p))
5221                   p++;
5222                 if (p[0] == '%' && p[1] == 'O')
5223                   p += 2;
5224
5225                 break;
5226               }
5227             goto create_temp_file;
5228           case 'm':
5229             if (use_pipes)
5230               {
5231                 /* consume suffix */
5232                 while (*p == '.' || ISALNUM ((unsigned char) *p))
5233                   p++;
5234                 if (p[0] == '%' && p[1] == 'O')
5235                   p += 2;
5236
5237                 break;
5238               }
5239             goto create_temp_file;
5240           case 'g':
5241           case 'u':
5242           case 'U':
5243           create_temp_file:
5244               {
5245                 struct temp_name *t;
5246                 int suffix_length;
5247                 const char *suffix = p;
5248                 char *saved_suffix = NULL;
5249
5250                 while (*p == '.' || ISALNUM ((unsigned char) *p))
5251                   p++;
5252                 suffix_length = p - suffix;
5253                 if (p[0] == '%' && p[1] == 'O')
5254                   {
5255                     p += 2;
5256                     /* We don't support extra suffix characters after %O.  */
5257                     if (*p == '.' || ISALNUM ((unsigned char) *p))
5258                       fatal ("spec '%s' has invalid '%%0%c'", spec, *p);
5259                     if (suffix_length == 0)
5260                       suffix = TARGET_OBJECT_SUFFIX;
5261                     else
5262                       {
5263                         saved_suffix
5264                           = XNEWVEC (char, suffix_length
5265                                      + strlen (TARGET_OBJECT_SUFFIX));
5266                         strncpy (saved_suffix, suffix, suffix_length);
5267                         strcpy (saved_suffix + suffix_length,
5268                                 TARGET_OBJECT_SUFFIX);
5269                       }
5270                     suffix_length += strlen (TARGET_OBJECT_SUFFIX);
5271                   }
5272
5273                 if (compare_debug < 0)
5274                   {
5275                     suffix = concat (".gk", suffix, NULL);
5276                     suffix_length += 3;
5277                   }
5278
5279                 /* If -save-temps=obj and -o were specified, use that for the
5280                    temp file.  */
5281                 if (save_temps_length)
5282                   {
5283                     char *tmp;
5284                     temp_filename_length
5285                       = save_temps_length + suffix_length + 1;
5286                     tmp = (char *) alloca (temp_filename_length);
5287                     memcpy (tmp, save_temps_prefix, save_temps_length);
5288                     memcpy (tmp + save_temps_length, suffix, suffix_length);
5289                     tmp[save_temps_length + suffix_length] = '\0';
5290                     temp_filename = save_string (tmp,
5291                                                  temp_filename_length + 1);
5292                     obstack_grow (&obstack, temp_filename,
5293                                   temp_filename_length);
5294                     arg_going = 1;
5295                     delete_this_arg = 0;
5296                     break;
5297                   }
5298
5299                 /* If the input_filename has the same suffix specified
5300                    for the %g, %u, or %U, and -save-temps is specified,
5301                    we could end up using that file as an intermediate
5302                    thus clobbering the user's source file (.e.g.,
5303                    gcc -save-temps foo.s would clobber foo.s with the
5304                    output of cpp0).  So check for this condition and
5305                    generate a temp file as the intermediate.  */
5306
5307                 if (save_temps_flag)
5308                   {
5309                     char *tmp;
5310                     temp_filename_length = basename_length + suffix_length + 1;
5311                     tmp = (char *) alloca (temp_filename_length);
5312                     memcpy (tmp, input_basename, basename_length);
5313                     memcpy (tmp + basename_length, suffix, suffix_length);
5314                     tmp[basename_length + suffix_length] = '\0';
5315                     temp_filename = tmp;
5316
5317                     if (strcmp (temp_filename, input_filename) != 0)
5318                       {
5319 #ifndef HOST_LACKS_INODE_NUMBERS
5320                         struct stat st_temp;
5321
5322                         /* Note, set_input() resets input_stat_set to 0.  */
5323                         if (input_stat_set == 0)
5324                           {
5325                             input_stat_set = stat (input_filename, &input_stat);
5326                             if (input_stat_set >= 0)
5327                               input_stat_set = 1;
5328                           }
5329
5330                         /* If we have the stat for the input_filename
5331                            and we can do the stat for the temp_filename
5332                            then the they could still refer to the same
5333                            file if st_dev/st_ino's are the same.  */
5334                         if (input_stat_set != 1
5335                             || stat (temp_filename, &st_temp) < 0
5336                             || input_stat.st_dev != st_temp.st_dev
5337                             || input_stat.st_ino != st_temp.st_ino)
5338 #else
5339                         /* Just compare canonical pathnames.  */
5340                         char* input_realname = lrealpath (input_filename);
5341                         char* temp_realname = lrealpath (temp_filename);
5342                         bool files_differ = strcmp (input_realname, temp_realname);
5343                         free (input_realname);
5344                         free (temp_realname);
5345                         if (files_differ)
5346 #endif
5347                           {
5348                             temp_filename = save_string (temp_filename,
5349                                                          temp_filename_length + 1);
5350                             obstack_grow (&obstack, temp_filename,
5351                                                     temp_filename_length);
5352                             arg_going = 1;
5353                             delete_this_arg = 0;
5354                             break;
5355                           }
5356                       }
5357                   }
5358
5359                 /* See if we already have an association of %g/%u/%U and
5360                    suffix.  */
5361                 for (t = temp_names; t; t = t->next)
5362                   if (t->length == suffix_length
5363                       && strncmp (t->suffix, suffix, suffix_length) == 0
5364                       && t->unique == (c == 'u' || c == 'U' || c == 'j'))
5365                     break;
5366
5367                 /* Make a new association if needed.  %u and %j
5368                    require one.  */
5369                 if (t == 0 || c == 'u' || c == 'j')
5370                   {
5371                     if (t == 0)
5372                       {
5373                         t = XNEW (struct temp_name);
5374                         t->next = temp_names;
5375                         temp_names = t;
5376                       }
5377                     t->length = suffix_length;
5378                     if (saved_suffix)
5379                       {
5380                         t->suffix = saved_suffix;
5381                         saved_suffix = NULL;
5382                       }
5383                     else
5384                       t->suffix = save_string (suffix, suffix_length);
5385                     t->unique = (c == 'u' || c == 'U' || c == 'j');
5386                     temp_filename = make_temp_file (t->suffix);
5387                     temp_filename_length = strlen (temp_filename);
5388                     t->filename = temp_filename;
5389                     t->filename_length = temp_filename_length;
5390                   }
5391
5392                 if (saved_suffix)
5393                   free (saved_suffix);
5394
5395                 obstack_grow (&obstack, t->filename, t->filename_length);
5396                 delete_this_arg = 1;
5397               }
5398             arg_going = 1;
5399             break;
5400
5401           case 'i':
5402             if (combine_inputs)
5403               {
5404                 if (at_file_supplied)
5405                   {
5406                     /* We are going to expand `%i' to `@FILE', where FILE
5407                        is a newly-created temporary filename.  The filenames
5408                        that would usually be expanded in place of %o will be
5409                        written to the temporary file.  */
5410                     char **argv;
5411                     int n_files = 0;
5412                     int j;
5413
5414                     for (i = 0; i < n_infiles; i++)
5415                       if (compile_input_file_p (&infiles[i]))
5416                         n_files++;
5417
5418                     argv = (char **) alloca (sizeof (char *) * (n_files + 1));
5419
5420                     /* Copy the strings over.  */
5421                     for (i = 0, j = 0; i < n_infiles; i++)
5422                       if (compile_input_file_p (&infiles[i]))
5423                         {
5424                           argv[j] = CONST_CAST (char *, infiles[i].name);
5425                           infiles[i].compiled = true;
5426                           j++;
5427                         }
5428                     argv[j] = NULL;
5429
5430                     create_at_file (argv);
5431                   }
5432                 else
5433                   for (i = 0; (int) i < n_infiles; i++)
5434                     if (compile_input_file_p (&infiles[i]))
5435                       {
5436                         store_arg (infiles[i].name, 0, 0);
5437                         infiles[i].compiled = true;
5438                       }
5439               }
5440             else
5441               {
5442                 obstack_grow (&obstack, input_filename, input_filename_length);
5443                 arg_going = 1;
5444               }
5445             break;
5446
5447           case 'I':
5448             {
5449               struct spec_path_info info;
5450
5451               if (multilib_dir)
5452                 {
5453                   do_spec_1 ("-imultilib", 1, NULL);
5454                   /* Make this a separate argument.  */
5455                   do_spec_1 (" ", 0, NULL);
5456                   do_spec_1 (multilib_dir, 1, NULL);
5457                   do_spec_1 (" ", 0, NULL);
5458                 }
5459
5460               if (gcc_exec_prefix)
5461                 {
5462                   do_spec_1 ("-iprefix", 1, NULL);
5463                   /* Make this a separate argument.  */
5464                   do_spec_1 (" ", 0, NULL);
5465                   do_spec_1 (gcc_exec_prefix, 1, NULL);
5466                   do_spec_1 (" ", 0, NULL);
5467                 }
5468
5469               if (target_system_root_changed ||
5470                   (target_system_root && target_sysroot_hdrs_suffix))
5471                 {
5472                   do_spec_1 ("-isysroot", 1, NULL);
5473                   /* Make this a separate argument.  */
5474                   do_spec_1 (" ", 0, NULL);
5475                   do_spec_1 (target_system_root, 1, NULL);
5476                   if (target_sysroot_hdrs_suffix)
5477                     do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL);
5478                   do_spec_1 (" ", 0, NULL);
5479                 }
5480
5481               info.option = "-isystem";
5482               info.append = "include";
5483               info.append_len = strlen (info.append);
5484               info.omit_relative = false;
5485               info.separate_options = true;
5486
5487               for_each_path (&include_prefixes, false, info.append_len,
5488                              spec_path, &info);
5489
5490               info.append = "include-fixed";
5491               if (*sysroot_hdrs_suffix_spec)
5492                 info.append = concat (info.append, dir_separator_str,
5493                                       multilib_dir, NULL);
5494               info.append_len = strlen (info.append);
5495               for_each_path (&include_prefixes, false, info.append_len,
5496                              spec_path, &info);
5497             }
5498             break;
5499
5500           case 'o':
5501             {
5502               int max = n_infiles;
5503               max += lang_specific_extra_outfiles;
5504
5505               if (HAVE_GNU_LD && at_file_supplied)
5506                 {
5507                   /* We are going to expand `%o' to `@FILE', where FILE
5508                      is a newly-created temporary filename.  The filenames
5509                      that would usually be expanded in place of %o will be
5510                      written to the temporary file.  */
5511
5512                   char **argv;
5513                   int n_files, j;
5514
5515                   /* Convert OUTFILES into a form suitable for writeargv.  */
5516
5517                   /* Determine how many are non-NULL.  */
5518                   for (n_files = 0, i = 0; i < max; i++)
5519                     n_files += outfiles[i] != NULL;
5520
5521                   argv = (char **) alloca (sizeof (char *) * (n_files + 1));
5522
5523                   /* Copy the strings over.  */
5524                   for (i = 0, j = 0; i < max; i++)
5525                     if (outfiles[i])
5526                       {
5527                         argv[j] = CONST_CAST (char *, outfiles[i]);
5528                         j++;
5529                       }
5530                   argv[j] = NULL;
5531
5532                   create_at_file (argv);
5533                 }
5534               else
5535                 for (i = 0; i < max; i++)
5536                   if (outfiles[i])
5537                     store_arg (outfiles[i], 0, 0);
5538               break;
5539             }
5540
5541           case 'O':
5542             obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
5543             arg_going = 1;
5544             break;
5545
5546           case 's':
5547             this_is_library_file = 1;
5548             break;
5549
5550           case 'V':
5551             outfiles[input_file_number] = NULL;
5552             break;
5553
5554           case 'w':
5555             this_is_output_file = 1;
5556             break;
5557
5558           case 'W':
5559             {
5560               int cur_index = argbuf_index;
5561               /* Handle the {...} following the %W.  */
5562               if (*p != '{')
5563                 fatal ("spec '%s' has invalid '%%W%c", spec, *p);
5564               p = handle_braces (p + 1);
5565               if (p == 0)
5566                 return -1;
5567               end_going_arg ();
5568               /* If any args were output, mark the last one for deletion
5569                  on failure.  */
5570               if (argbuf_index != cur_index)
5571                 record_temp_file (argbuf[argbuf_index - 1], 0, 1);
5572               break;
5573             }
5574
5575           /* %x{OPTION} records OPTION for %X to output.  */
5576           case 'x':
5577             {
5578               const char *p1 = p;
5579               char *string;
5580
5581               /* Skip past the option value and make a copy.  */
5582               if (*p != '{')
5583                 fatal ("spec '%s' has invalid '%%x%c'", spec, *p);
5584               while (*p++ != '}')
5585                 ;
5586               string = save_string (p1 + 1, p - p1 - 2);
5587
5588               /* See if we already recorded this option.  */
5589               for (i = 0; i < n_linker_options; i++)
5590                 if (! strcmp (string, linker_options[i]))
5591                   {
5592                     free (string);
5593                     return 0;
5594                   }
5595
5596               /* This option is new; add it.  */
5597               add_linker_option (string, strlen (string));
5598             }
5599             break;
5600
5601           /* Dump out the options accumulated previously using %x.  */
5602           case 'X':
5603             for (i = 0; i < n_linker_options; i++)
5604               {
5605                 do_spec_1 (linker_options[i], 1, NULL);
5606                 /* Make each accumulated option a separate argument.  */
5607                 do_spec_1 (" ", 0, NULL);
5608               }
5609             break;
5610
5611           /* Dump out the options accumulated previously using -Wa,.  */
5612           case 'Y':
5613             for (i = 0; i < n_assembler_options; i++)
5614               {
5615                 do_spec_1 (assembler_options[i], 1, NULL);
5616                 /* Make each accumulated option a separate argument.  */
5617                 do_spec_1 (" ", 0, NULL);
5618               }
5619             break;
5620
5621           /* Dump out the options accumulated previously using -Wp,.  */
5622           case 'Z':
5623             for (i = 0; i < n_preprocessor_options; i++)
5624               {
5625                 do_spec_1 (preprocessor_options[i], 1, NULL);
5626                 /* Make each accumulated option a separate argument.  */
5627                 do_spec_1 (" ", 0, NULL);
5628               }
5629             break;
5630
5631             /* Here are digits and numbers that just process
5632                a certain constant string as a spec.  */
5633
5634           case '1':
5635             value = do_spec_1 (cc1_spec, 0, NULL);
5636             if (value != 0)
5637               return value;
5638             break;
5639
5640           case '2':
5641             value = do_spec_1 (cc1plus_spec, 0, NULL);
5642             if (value != 0)
5643               return value;
5644             break;
5645
5646           case 'a':
5647             value = do_spec_1 (asm_spec, 0, NULL);
5648             if (value != 0)
5649               return value;
5650             break;
5651
5652           case 'A':
5653             value = do_spec_1 (asm_final_spec, 0, NULL);
5654             if (value != 0)
5655               return value;
5656             break;
5657
5658           case 'C':
5659             {
5660               const char *const spec
5661                 = (input_file_compiler->cpp_spec
5662                    ? input_file_compiler->cpp_spec
5663                    : cpp_spec);
5664               value = do_spec_1 (spec, 0, NULL);
5665               if (value != 0)
5666                 return value;
5667             }
5668             break;
5669
5670           case 'E':
5671             value = do_spec_1 (endfile_spec, 0, NULL);
5672             if (value != 0)
5673               return value;
5674             break;
5675
5676           case 'l':
5677             value = do_spec_1 (link_spec, 0, NULL);
5678             if (value != 0)
5679               return value;
5680             break;
5681
5682           case 'L':
5683             value = do_spec_1 (lib_spec, 0, NULL);
5684             if (value != 0)
5685               return value;
5686             break;
5687
5688           case 'G':
5689             value = do_spec_1 (libgcc_spec, 0, NULL);
5690             if (value != 0)
5691               return value;
5692             break;
5693
5694           case 'R':
5695             /* We assume there is a directory
5696                separator at the end of this string.  */
5697             if (target_system_root)
5698               {
5699                 obstack_grow (&obstack, target_system_root,
5700                               strlen (target_system_root));
5701                 if (target_sysroot_suffix)
5702                   obstack_grow (&obstack, target_sysroot_suffix,
5703                                 strlen (target_sysroot_suffix));
5704               }
5705             break;
5706
5707           case 'S':
5708             value = do_spec_1 (startfile_spec, 0, NULL);
5709             if (value != 0)
5710               return value;
5711             break;
5712
5713             /* Here we define characters other than letters and digits.  */
5714
5715           case '{':
5716             p = handle_braces (p);
5717             if (p == 0)
5718               return -1;
5719             break;
5720
5721           case ':':
5722             p = handle_spec_function (p);
5723             if (p == 0)
5724               return -1;
5725             break;
5726
5727           case '%':
5728             obstack_1grow (&obstack, '%');
5729             break;
5730
5731           case '.':
5732             {
5733               unsigned len = 0;
5734
5735               while (p[len] && p[len] != ' ' && p[len] != '%')
5736                 len++;
5737               suffix_subst = save_string (p - 1, len + 1);
5738               p += len;
5739             }
5740            break;
5741
5742            /* Henceforth ignore the option(s) matching the pattern
5743               after the %<.  */
5744           case '<':
5745             {
5746               unsigned len = 0;
5747               int have_wildcard = 0;
5748               int i;
5749
5750               while (p[len] && p[len] != ' ' && p[len] != '\t')
5751                 len++;
5752
5753               if (p[len-1] == '*')
5754                 have_wildcard = 1;
5755
5756               for (i = 0; i < n_switches; i++)
5757                 if (!strncmp (switches[i].part1, p, len - have_wildcard)
5758                     && (have_wildcard || switches[i].part1[len] == '\0'))
5759                   {
5760                     switches[i].live_cond |= SWITCH_IGNORE;
5761                     switches[i].validated = 1;
5762                   }
5763
5764               p += len;
5765             }
5766             break;
5767
5768           case '*':
5769             if (soft_matched_part)
5770               {
5771                 do_spec_1 (soft_matched_part, 1, NULL);
5772                 do_spec_1 (" ", 0, NULL);
5773               }
5774             else
5775               /* Catch the case where a spec string contains something like
5776                  '%{foo:%*}'.  i.e. there is no * in the pattern on the left
5777                  hand side of the :.  */
5778               error ("spec failure: '%%*' has not been initialized by pattern match");
5779             break;
5780
5781             /* Process a string found as the value of a spec given by name.
5782                This feature allows individual machine descriptions
5783                to add and use their own specs.
5784                %[...] modifies -D options the way %P does;
5785                %(...) uses the spec unmodified.  */
5786           case '[':
5787             error ("warning: use of obsolete %%[ operator in specs");
5788           case '(':
5789             {
5790               const char *name = p;
5791               struct spec_list *sl;
5792               int len;
5793
5794               /* The string after the S/P is the name of a spec that is to be
5795                  processed.  */
5796               while (*p && *p != ')' && *p != ']')
5797                 p++;
5798
5799               /* See if it's in the list.  */
5800               for (len = p - name, sl = specs; sl; sl = sl->next)
5801                 if (sl->name_len == len && !strncmp (sl->name, name, len))
5802                   {
5803                     name = *(sl->ptr_spec);
5804 #ifdef DEBUG_SPECS
5805                     notice ("Processing spec %c%s%c, which is '%s'\n",
5806                             c, sl->name, (c == '(') ? ')' : ']', name);
5807 #endif
5808                     break;
5809                   }
5810
5811               if (sl)
5812                 {
5813                   if (c == '(')
5814                     {
5815                       value = do_spec_1 (name, 0, NULL);
5816                       if (value != 0)
5817                         return value;
5818                     }
5819                   else
5820                     {
5821                       char *x = (char *) alloca (strlen (name) * 2 + 1);
5822                       char *buf = x;
5823                       const char *y = name;
5824                       int flag = 0;
5825
5826                       /* Copy all of NAME into BUF, but put __ after
5827                          every -D and at the end of each arg.  */
5828                       while (1)
5829                         {
5830                           if (! strncmp (y, "-D", 2))
5831                             {
5832                               *x++ = '-';
5833                               *x++ = 'D';
5834                               *x++ = '_';
5835                               *x++ = '_';
5836                               y += 2;
5837                               flag = 1;
5838                               continue;
5839                             }
5840                           else if (flag
5841                                    && (*y == ' ' || *y == '\t' || *y == '='
5842                                        || *y == '}' || *y == 0))
5843                             {
5844                               *x++ = '_';
5845                               *x++ = '_';
5846                               flag = 0;
5847                             }
5848                           if (*y == 0)
5849                             break;
5850                           else
5851                             *x++ = *y++;
5852                         }
5853                       *x = 0;
5854
5855                       value = do_spec_1 (buf, 0, NULL);
5856                       if (value != 0)
5857                         return value;
5858                     }
5859                 }
5860
5861               /* Discard the closing paren or bracket.  */
5862               if (*p)
5863                 p++;
5864             }
5865             break;
5866
5867           default:
5868             error ("spec failure: unrecognized spec option '%c'", c);
5869             break;
5870           }
5871         break;
5872
5873       case '\\':
5874         /* Backslash: treat next character as ordinary.  */
5875         c = *p++;
5876
5877         /* Fall through.  */
5878       default:
5879         /* Ordinary character: put it into the current argument.  */
5880         obstack_1grow (&obstack, c);
5881         arg_going = 1;
5882       }
5883
5884   /* End of string.  If we are processing a spec function, we need to
5885      end any pending argument.  */
5886   if (processing_spec_function)
5887     end_going_arg ();
5888
5889   return 0;
5890 }
5891
5892 /* Look up a spec function.  */
5893
5894 static const struct spec_function *
5895 lookup_spec_function (const char *name)
5896 {
5897   const struct spec_function *sf;
5898
5899   for (sf = static_spec_functions; sf->name != NULL; sf++)
5900     if (strcmp (sf->name, name) == 0)
5901       return sf;
5902
5903   return NULL;
5904 }
5905
5906 /* Evaluate a spec function.  */
5907
5908 static const char *
5909 eval_spec_function (const char *func, const char *args)
5910 {
5911   const struct spec_function *sf;
5912   const char *funcval;
5913
5914   /* Saved spec processing context.  */
5915   int save_argbuf_index;
5916   int save_argbuf_length;
5917   const char **save_argbuf;
5918
5919   int save_arg_going;
5920   int save_delete_this_arg;
5921   int save_this_is_output_file;
5922   int save_this_is_library_file;
5923   int save_input_from_pipe;
5924   const char *save_suffix_subst;
5925
5926
5927   sf = lookup_spec_function (func);
5928   if (sf == NULL)
5929     fatal ("unknown spec function '%s'", func);
5930
5931   /* Push the spec processing context.  */
5932   save_argbuf_index = argbuf_index;
5933   save_argbuf_length = argbuf_length;
5934   save_argbuf = argbuf;
5935
5936   save_arg_going = arg_going;
5937   save_delete_this_arg = delete_this_arg;
5938   save_this_is_output_file = this_is_output_file;
5939   save_this_is_library_file = this_is_library_file;
5940   save_input_from_pipe = input_from_pipe;
5941   save_suffix_subst = suffix_subst;
5942
5943   /* Create a new spec processing context, and build the function
5944      arguments.  */
5945
5946   alloc_args ();
5947   if (do_spec_2 (args) < 0)
5948     fatal ("error in args to spec function '%s'", func);
5949
5950   /* argbuf_index is an index for the next argument to be inserted, and
5951      so contains the count of the args already inserted.  */
5952
5953   funcval = (*sf->func) (argbuf_index, argbuf);
5954
5955   /* Pop the spec processing context.  */
5956   argbuf_index = save_argbuf_index;
5957   argbuf_length = save_argbuf_length;
5958   free (argbuf);
5959   argbuf = save_argbuf;
5960
5961   arg_going = save_arg_going;
5962   delete_this_arg = save_delete_this_arg;
5963   this_is_output_file = save_this_is_output_file;
5964   this_is_library_file = save_this_is_library_file;
5965   input_from_pipe = save_input_from_pipe;
5966   suffix_subst = save_suffix_subst;
5967
5968   return funcval;
5969 }
5970
5971 /* Handle a spec function call of the form:
5972
5973    %:function(args)
5974
5975    ARGS is processed as a spec in a separate context and split into an
5976    argument vector in the normal fashion.  The function returns a string
5977    containing a spec which we then process in the caller's context, or
5978    NULL if no processing is required.  */
5979
5980 static const char *
5981 handle_spec_function (const char *p)
5982 {
5983   char *func, *args;
5984   const char *endp, *funcval;
5985   int count;
5986
5987   processing_spec_function++;
5988
5989   /* Get the function name.  */
5990   for (endp = p; *endp != '\0'; endp++)
5991     {
5992       if (*endp == '(')         /* ) */
5993         break;
5994       /* Only allow [A-Za-z0-9], -, and _ in function names.  */
5995       if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_'))
5996         fatal ("malformed spec function name");
5997     }
5998   if (*endp != '(')             /* ) */
5999     fatal ("no arguments for spec function");
6000   func = save_string (p, endp - p);
6001   p = ++endp;
6002
6003   /* Get the arguments.  */
6004   for (count = 0; *endp != '\0'; endp++)
6005     {
6006       /* ( */
6007       if (*endp == ')')
6008         {
6009           if (count == 0)
6010             break;
6011           count--;
6012         }
6013       else if (*endp == '(')    /* ) */
6014         count++;
6015     }
6016   /* ( */
6017   if (*endp != ')')
6018     fatal ("malformed spec function arguments");
6019   args = save_string (p, endp - p);
6020   p = ++endp;
6021
6022   /* p now points to just past the end of the spec function expression.  */
6023
6024   funcval = eval_spec_function (func, args);
6025   if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0)
6026     p = NULL;
6027
6028   free (func);
6029   free (args);
6030
6031   processing_spec_function--;
6032
6033   return p;
6034 }
6035
6036 /* Inline subroutine of handle_braces.  Returns true if the current
6037    input suffix matches the atom bracketed by ATOM and END_ATOM.  */
6038 static inline bool
6039 input_suffix_matches (const char *atom, const char *end_atom)
6040 {
6041   return (input_suffix
6042           && !strncmp (input_suffix, atom, end_atom - atom)
6043           && input_suffix[end_atom - atom] == '\0');
6044 }
6045
6046 /* Subroutine of handle_braces.  Returns true if the current
6047    input file's spec name matches the atom bracketed by ATOM and END_ATOM.  */
6048 static bool
6049 input_spec_matches (const char *atom, const char *end_atom)
6050 {
6051   return (input_file_compiler
6052           && input_file_compiler->suffix
6053           && input_file_compiler->suffix[0] != '\0'
6054           && !strncmp (input_file_compiler->suffix + 1, atom,
6055                        end_atom - atom)
6056           && input_file_compiler->suffix[end_atom - atom + 1] == '\0');
6057 }
6058
6059 /* Subroutine of handle_braces.  Returns true if a switch
6060    matching the atom bracketed by ATOM and END_ATOM appeared on the
6061    command line.  */
6062 static bool
6063 switch_matches (const char *atom, const char *end_atom, int starred)
6064 {
6065   int i;
6066   int len = end_atom - atom;
6067   int plen = starred ? len : -1;
6068
6069   for (i = 0; i < n_switches; i++)
6070     if (!strncmp (switches[i].part1, atom, len)
6071         && (starred || switches[i].part1[len] == '\0')
6072         && check_live_switch (i, plen))
6073       return true;
6074
6075   return false;
6076 }
6077
6078 /* Inline subroutine of handle_braces.  Mark all of the switches which
6079    match ATOM (extends to END_ATOM; STARRED indicates whether there
6080    was a star after the atom) for later processing.  */
6081 static inline void
6082 mark_matching_switches (const char *atom, const char *end_atom, int starred)
6083 {
6084   int i;
6085   int len = end_atom - atom;
6086   int plen = starred ? len : -1;
6087
6088   for (i = 0; i < n_switches; i++)
6089     if (!strncmp (switches[i].part1, atom, len)
6090         && (starred || switches[i].part1[len] == '\0')
6091         && check_live_switch (i, plen))
6092       switches[i].ordering = 1;
6093 }
6094
6095 /* Inline subroutine of handle_braces.  Process all the currently
6096    marked switches through give_switch, and clear the marks.  */
6097 static inline void
6098 process_marked_switches (void)
6099 {
6100   int i;
6101
6102   for (i = 0; i < n_switches; i++)
6103     if (switches[i].ordering == 1)
6104       {
6105         switches[i].ordering = 0;
6106         give_switch (i, 0);
6107       }
6108 }
6109
6110 /* Handle a %{ ... } construct.  P points just inside the leading {.
6111    Returns a pointer one past the end of the brace block, or 0
6112    if we call do_spec_1 and that returns -1.  */
6113
6114 static const char *
6115 handle_braces (const char *p)
6116 {
6117   const char *atom, *end_atom;
6118   const char *d_atom = NULL, *d_end_atom = NULL;
6119   const char *orig = p;
6120
6121   bool a_is_suffix;
6122   bool a_is_spectype;
6123   bool a_is_starred;
6124   bool a_is_negated;
6125   bool a_matched;
6126
6127   bool a_must_be_last = false;
6128   bool ordered_set    = false;
6129   bool disjunct_set   = false;
6130   bool disj_matched   = false;
6131   bool disj_starred   = true;
6132   bool n_way_choice   = false;
6133   bool n_way_matched  = false;
6134
6135 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
6136
6137   do
6138     {
6139       if (a_must_be_last)
6140         goto invalid;
6141
6142       /* Scan one "atom" (S in the description above of %{}, possibly
6143          with '!', '.', '@', ',', or '*' modifiers).  */
6144       a_matched = false;
6145       a_is_suffix = false;
6146       a_is_starred = false;
6147       a_is_negated = false;
6148       a_is_spectype = false;
6149
6150       SKIP_WHITE();
6151       if (*p == '!')
6152         p++, a_is_negated = true;
6153
6154       SKIP_WHITE();
6155       if (*p == '.')
6156         p++, a_is_suffix = true;
6157       else if (*p == ',')
6158         p++, a_is_spectype = true;
6159
6160       atom = p;
6161       while (ISIDNUM(*p) || *p == '-' || *p == '+' || *p == '='
6162              || *p == ',' || *p == '.' || *p == '@')
6163         p++;
6164       end_atom = p;
6165
6166       if (*p == '*')
6167         p++, a_is_starred = 1;
6168
6169       SKIP_WHITE();
6170       switch (*p)
6171         {
6172         case '&': case '}':
6173           /* Substitute the switch(es) indicated by the current atom.  */
6174           ordered_set = true;
6175           if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix
6176               || a_is_spectype || atom == end_atom)
6177             goto invalid;
6178
6179           mark_matching_switches (atom, end_atom, a_is_starred);
6180
6181           if (*p == '}')
6182             process_marked_switches ();
6183           break;
6184
6185         case '|': case ':':
6186           /* Substitute some text if the current atom appears as a switch
6187              or suffix.  */
6188           disjunct_set = true;
6189           if (ordered_set)
6190             goto invalid;
6191
6192           if (atom == end_atom)
6193             {
6194               if (!n_way_choice || disj_matched || *p == '|'
6195                   || a_is_negated || a_is_suffix || a_is_spectype
6196                   || a_is_starred)
6197                 goto invalid;
6198
6199               /* An empty term may appear as the last choice of an
6200                  N-way choice set; it means "otherwise".  */
6201               a_must_be_last = true;
6202               disj_matched = !n_way_matched;
6203               disj_starred = false;
6204             }
6205           else
6206             {
6207               if ((a_is_suffix || a_is_spectype) && a_is_starred)
6208                 goto invalid;
6209
6210               if (!a_is_starred)
6211                 disj_starred = false;
6212
6213               /* Don't bother testing this atom if we already have a
6214                  match.  */
6215               if (!disj_matched && !n_way_matched)
6216                 {
6217                   if (a_is_suffix)
6218                     a_matched = input_suffix_matches (atom, end_atom);
6219                   else if (a_is_spectype)
6220                     a_matched = input_spec_matches (atom, end_atom);
6221                   else
6222                     a_matched = switch_matches (atom, end_atom, a_is_starred);
6223
6224                   if (a_matched != a_is_negated)
6225                     {
6226                       disj_matched = true;
6227                       d_atom = atom;
6228                       d_end_atom = end_atom;
6229                     }
6230                 }
6231             }
6232
6233           if (*p == ':')
6234             {
6235               /* Found the body, that is, the text to substitute if the
6236                  current disjunction matches.  */
6237               p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred,
6238                                       disj_matched && !n_way_matched);
6239               if (p == 0)
6240                 return 0;
6241
6242               /* If we have an N-way choice, reset state for the next
6243                  disjunction.  */
6244               if (*p == ';')
6245                 {
6246                   n_way_choice = true;
6247                   n_way_matched |= disj_matched;
6248                   disj_matched = false;
6249                   disj_starred = true;
6250                   d_atom = d_end_atom = NULL;
6251                 }
6252             }
6253           break;
6254
6255         default:
6256           goto invalid;
6257         }
6258     }
6259   while (*p++ != '}');
6260
6261   return p;
6262
6263  invalid:
6264   fatal ("braced spec '%s' is invalid at '%c'", orig, *p);
6265
6266 #undef SKIP_WHITE
6267 }
6268
6269 /* Subroutine of handle_braces.  Scan and process a brace substitution body
6270    (X in the description of %{} syntax).  P points one past the colon;
6271    ATOM and END_ATOM bracket the first atom which was found to be true
6272    (present) in the current disjunction; STARRED indicates whether all
6273    the atoms in the current disjunction were starred (for syntax validation);
6274    MATCHED indicates whether the disjunction matched or not, and therefore
6275    whether or not the body is to be processed through do_spec_1 or just
6276    skipped.  Returns a pointer to the closing } or ;, or 0 if do_spec_1
6277    returns -1.  */
6278
6279 static const char *
6280 process_brace_body (const char *p, const char *atom, const char *end_atom,
6281                     int starred, int matched)
6282 {
6283   const char *body, *end_body;
6284   unsigned int nesting_level;
6285   bool have_subst     = false;
6286
6287   /* Locate the closing } or ;, honoring nested braces.
6288      Trim trailing whitespace.  */
6289   body = p;
6290   nesting_level = 1;
6291   for (;;)
6292     {
6293       if (*p == '{')
6294         nesting_level++;
6295       else if (*p == '}')
6296         {
6297           if (!--nesting_level)
6298             break;
6299         }
6300       else if (*p == ';' && nesting_level == 1)
6301         break;
6302       else if (*p == '%' && p[1] == '*' && nesting_level == 1)
6303         have_subst = true;
6304       else if (*p == '\0')
6305         goto invalid;
6306       p++;
6307     }
6308
6309   end_body = p;
6310   while (end_body[-1] == ' ' || end_body[-1] == '\t')
6311     end_body--;
6312
6313   if (have_subst && !starred)
6314     goto invalid;
6315
6316   if (matched)
6317     {
6318       /* Copy the substitution body to permanent storage and execute it.
6319          If have_subst is false, this is a simple matter of running the
6320          body through do_spec_1...  */
6321       char *string = save_string (body, end_body - body);
6322       if (!have_subst)
6323         {
6324           if (do_spec_1 (string, 0, NULL) < 0)
6325             return 0;
6326         }
6327       else
6328         {
6329           /* ... but if have_subst is true, we have to process the
6330              body once for each matching switch, with %* set to the
6331              variant part of the switch.  */
6332           unsigned int hard_match_len = end_atom - atom;
6333           int i;
6334
6335           for (i = 0; i < n_switches; i++)
6336             if (!strncmp (switches[i].part1, atom, hard_match_len)
6337                 && check_live_switch (i, hard_match_len))
6338               {
6339                 if (do_spec_1 (string, 0,
6340                                &switches[i].part1[hard_match_len]) < 0)
6341                   return 0;
6342                 /* Pass any arguments this switch has.  */
6343                 give_switch (i, 1);
6344                 suffix_subst = NULL;
6345               }
6346         }
6347     }
6348
6349   return p;
6350
6351  invalid:
6352   fatal ("braced spec body '%s' is invalid", body);
6353 }
6354 \f
6355 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
6356    on the command line.  PREFIX_LENGTH is the length of XXX in an {XXX*}
6357    spec, or -1 if either exact match or %* is used.
6358
6359    A -O switch is obsoleted by a later -O switch.  A -f, -m, or -W switch
6360    whose value does not begin with "no-" is obsoleted by the same value
6361    with the "no-", similarly for a switch with the "no-" prefix.  */
6362
6363 static int
6364 check_live_switch (int switchnum, int prefix_length)
6365 {
6366   const char *name = switches[switchnum].part1;
6367   int i;
6368
6369   /* If we already processed this switch and determined if it was
6370      live or not, return our past determination.  */
6371   if (switches[switchnum].live_cond != 0)
6372     return ((switches[switchnum].live_cond & SWITCH_LIVE) != 0
6373             && (switches[switchnum].live_cond & SWITCH_FALSE) == 0
6374             && (switches[switchnum].live_cond & SWITCH_IGNORE) == 0);
6375
6376   /* In the common case of {<at-most-one-letter>*}, a negating
6377      switch would always match, so ignore that case.  We will just
6378      send the conflicting switches to the compiler phase.  */
6379   if (prefix_length >= 0 && prefix_length <= 1)
6380     return 1;
6381
6382   /* Now search for duplicate in a manner that depends on the name.  */
6383   switch (*name)
6384     {
6385     case 'O':
6386       for (i = switchnum + 1; i < n_switches; i++)
6387         if (switches[i].part1[0] == 'O')
6388           {
6389             switches[switchnum].validated = 1;
6390             switches[switchnum].live_cond = SWITCH_FALSE;
6391             return 0;
6392           }
6393       break;
6394
6395     case 'W':  case 'f':  case 'm':
6396       if (! strncmp (name + 1, "no-", 3))
6397         {
6398           /* We have Xno-YYY, search for XYYY.  */
6399           for (i = switchnum + 1; i < n_switches; i++)
6400             if (switches[i].part1[0] == name[0]
6401                 && ! strcmp (&switches[i].part1[1], &name[4]))
6402               {
6403                 switches[switchnum].validated = 1;
6404                 switches[switchnum].live_cond = SWITCH_FALSE;
6405                 return 0;
6406               }
6407         }
6408       else
6409         {
6410           /* We have XYYY, search for Xno-YYY.  */
6411           for (i = switchnum + 1; i < n_switches; i++)
6412             if (switches[i].part1[0] == name[0]
6413                 && switches[i].part1[1] == 'n'
6414                 && switches[i].part1[2] == 'o'
6415                 && switches[i].part1[3] == '-'
6416                 && !strcmp (&switches[i].part1[4], &name[1]))
6417               {
6418                 switches[switchnum].validated = 1;
6419                 switches[switchnum].live_cond = SWITCH_FALSE;
6420                 return 0;
6421               }
6422         }
6423       break;
6424     }
6425
6426   /* Otherwise the switch is live.  */
6427   switches[switchnum].live_cond |= SWITCH_LIVE;
6428   return 1;
6429 }
6430 \f
6431 /* Pass a switch to the current accumulating command
6432    in the same form that we received it.
6433    SWITCHNUM identifies the switch; it is an index into
6434    the vector of switches gcc received, which is `switches'.
6435    This cannot fail since it never finishes a command line.
6436
6437    If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument.  */
6438
6439 static void
6440 give_switch (int switchnum, int omit_first_word)
6441 {
6442   if ((switches[switchnum].live_cond & SWITCH_IGNORE) != 0)
6443     return;
6444
6445   if (!omit_first_word)
6446     {
6447       do_spec_1 ("-", 0, NULL);
6448       do_spec_1 (switches[switchnum].part1, 1, NULL);
6449     }
6450
6451   if (switches[switchnum].args != 0)
6452     {
6453       const char **p;
6454       for (p = switches[switchnum].args; *p; p++)
6455         {
6456           const char *arg = *p;
6457
6458           do_spec_1 (" ", 0, NULL);
6459           if (suffix_subst)
6460             {
6461               unsigned length = strlen (arg);
6462               int dot = 0;
6463
6464               while (length-- && !IS_DIR_SEPARATOR (arg[length]))
6465                 if (arg[length] == '.')
6466                   {
6467                     (CONST_CAST(char *, arg))[length] = 0;
6468                     dot = 1;
6469                     break;
6470                   }
6471               do_spec_1 (arg, 1, NULL);
6472               if (dot)
6473                 (CONST_CAST(char *, arg))[length] = '.';
6474               do_spec_1 (suffix_subst, 1, NULL);
6475             }
6476           else
6477             do_spec_1 (arg, 1, NULL);
6478         }
6479     }
6480
6481   do_spec_1 (" ", 0, NULL);
6482   switches[switchnum].validated = 1;
6483 }
6484 \f
6485 /* Search for a file named NAME trying various prefixes including the
6486    user's -B prefix and some standard ones.
6487    Return the absolute file name found.  If nothing is found, return NAME.  */
6488
6489 static const char *
6490 find_file (const char *name)
6491 {
6492   char *newname = find_a_file (&startfile_prefixes, name, R_OK, true);
6493   return newname ? newname : name;
6494 }
6495
6496 /* Determine whether a directory exists.  If LINKER, return 0 for
6497    certain fixed names not needed by the linker.  */
6498
6499 static int
6500 is_directory (const char *path1, bool linker)
6501 {
6502   int len1;
6503   char *path;
6504   char *cp;
6505   struct stat st;
6506
6507   /* Ensure the string ends with "/.".  The resulting path will be a
6508      directory even if the given path is a symbolic link.  */
6509   len1 = strlen (path1);
6510   path = (char *) alloca (3 + len1);
6511   memcpy (path, path1, len1);
6512   cp = path + len1;
6513   if (!IS_DIR_SEPARATOR (cp[-1]))
6514     *cp++ = DIR_SEPARATOR;
6515   *cp++ = '.';
6516   *cp = '\0';
6517
6518   /* Exclude directories that the linker is known to search.  */
6519   if (linker
6520       && IS_DIR_SEPARATOR (path[0])
6521       && ((cp - path == 6
6522            && strncmp (path + 1, "lib", 3) == 0)
6523           || (cp - path == 10
6524               && strncmp (path + 1, "usr", 3) == 0
6525               && IS_DIR_SEPARATOR (path[4])
6526               && strncmp (path + 5, "lib", 3) == 0)))
6527     return 0;
6528
6529   return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
6530 }
6531
6532 /* Set up the various global variables to indicate that we're processing
6533    the input file named FILENAME.  */
6534
6535 void
6536 set_input (const char *filename)
6537 {
6538   const char *p;
6539
6540   input_filename = filename;
6541   input_filename_length = strlen (input_filename);
6542   input_basename = lbasename (input_filename);
6543
6544   /* Find a suffix starting with the last period,
6545      and set basename_length to exclude that suffix.  */
6546   basename_length = strlen (input_basename);
6547   suffixed_basename_length = basename_length;
6548   p = input_basename + basename_length;
6549   while (p != input_basename && *p != '.')
6550     --p;
6551   if (*p == '.' && p != input_basename)
6552     {
6553       basename_length = p - input_basename;
6554       input_suffix = p + 1;
6555     }
6556   else
6557     input_suffix = "";
6558
6559   /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
6560      we will need to do a stat on the input_filename.  The
6561      INPUT_STAT_SET signals that the stat is needed.  */
6562   input_stat_set = 0;
6563 }
6564 \f
6565 /* On fatal signals, delete all the temporary files.  */
6566
6567 static void
6568 fatal_error (int signum)
6569 {
6570   signal (signum, SIG_DFL);
6571   delete_failure_queue ();
6572   delete_temp_files ();
6573   /* Get the same signal again, this time not handled,
6574      so its normal effect occurs.  */
6575   kill (getpid (), signum);
6576 }
6577
6578 /* Compare the contents of the two files named CMPFILE[0] and
6579    CMPFILE[1].  Return zero if they're identical, nonzero
6580    otherwise.  */
6581
6582 static int
6583 compare_files (char *cmpfile[])
6584 {
6585   int ret = 0;
6586   FILE *temp[2] = { NULL, NULL };
6587   int i;
6588
6589 #if HAVE_MMAP_FILE
6590   {
6591     size_t length[2];
6592     void *map[2] = { NULL, NULL };
6593
6594     for (i = 0; i < 2; i++)
6595       {
6596         struct stat st;
6597
6598         if (stat (cmpfile[i], &st) < 0 || !S_ISREG (st.st_mode))
6599           {
6600             error ("%s: could not determine length of compare-debug file %s",
6601                    input_filename, cmpfile[i]);
6602             ret = 1;
6603             break;
6604           }
6605
6606         length[i] = st.st_size;
6607       }
6608
6609     if (!ret && length[0] != length[1])
6610       {
6611         error ("%s: -fcompare-debug failure (length)", input_filename);
6612         ret = 1;
6613       }
6614
6615     if (!ret)
6616       for (i = 0; i < 2; i++)
6617         {
6618           int fd = open (cmpfile[i], O_RDONLY);
6619           if (fd < 0)
6620             {
6621               error ("%s: could not open compare-debug file %s",
6622                      input_filename, cmpfile[i]);
6623               ret = 1;
6624               break;
6625             }
6626
6627           map[i] = mmap (NULL, length[i], PROT_READ, MAP_PRIVATE, fd, 0);
6628           close (fd);
6629
6630           if (map[i] == (void *) MAP_FAILED)
6631             {
6632               ret = -1;
6633               break;
6634             }
6635         }
6636
6637     if (!ret)
6638       {
6639         if (memcmp (map[0], map[1], length[0]) != 0)
6640           {
6641             error ("%s: -fcompare-debug failure", input_filename);
6642             ret = 1;
6643           }
6644       }
6645
6646     for (i = 0; i < 2; i++)
6647       if (map[i])
6648         munmap ((caddr_t) map[i], length[i]);
6649
6650     if (ret >= 0)
6651       return ret;
6652
6653     ret = 0;
6654   }
6655 #endif
6656
6657   for (i = 0; i < 2; i++)
6658     {
6659       temp[i] = fopen (cmpfile[i], "r");
6660       if (!temp[i])
6661         {
6662           error ("%s: could not open compare-debug file %s",
6663                  input_filename, cmpfile[i]);
6664           ret = 1;
6665           break;
6666         }
6667     }
6668
6669   if (!ret && temp[0] && temp[1])
6670     for (;;)
6671       {
6672         int c0, c1;
6673         c0 = fgetc (temp[0]);
6674         c1 = fgetc (temp[1]);
6675
6676         if (c0 != c1)
6677           {
6678             error ("%s: -fcompare-debug failure",
6679                    input_filename);
6680             ret = 1;
6681             break;
6682           }
6683
6684         if (c0 == EOF)
6685           break;
6686       }
6687
6688   for (i = 1; i >= 0; i--)
6689     {
6690       if (temp[i])
6691         fclose (temp[i]);
6692     }
6693
6694   return ret;
6695 }
6696
6697 extern int main (int, char **);
6698
6699 int
6700 main (int argc, char **argv)
6701 {
6702   size_t i;
6703   int value;
6704   int linker_was_run = 0;
6705   int lang_n_infiles = 0;
6706   int num_linker_inputs = 0;
6707   char *explicit_link_files;
6708   char *specs_file;
6709   const char *p;
6710   struct user_specs *uptr;
6711   char **old_argv = argv;
6712
6713   /* Initialize here, not in definition.  The IRIX 6 O32 cc sometimes chokes
6714      on ?: in file-scope variable initializations.  */
6715   asm_debug = ASM_DEBUG_SPEC;
6716
6717   p = argv[0] + strlen (argv[0]);
6718   while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
6719     --p;
6720   programname = p;
6721
6722   xmalloc_set_program_name (programname);
6723
6724   expandargv (&argc, &argv);
6725
6726   /* Determine if any expansions were made.  */
6727   if (argv != old_argv)
6728     at_file_supplied = true;
6729
6730   prune_options (&argc, &argv);
6731
6732 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6733   /* Perform host dependent initialization when needed.  */
6734   GCC_DRIVER_HOST_INITIALIZATION;
6735 #endif
6736
6737   /* Unlock the stdio streams.  */
6738   unlock_std_streams ();
6739
6740   gcc_init_libintl ();
6741
6742   if (signal (SIGINT, SIG_IGN) != SIG_IGN)
6743     signal (SIGINT, fatal_error);
6744 #ifdef SIGHUP
6745   if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
6746     signal (SIGHUP, fatal_error);
6747 #endif
6748   if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
6749     signal (SIGTERM, fatal_error);
6750 #ifdef SIGPIPE
6751   if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
6752     signal (SIGPIPE, fatal_error);
6753 #endif
6754 #ifdef SIGCHLD
6755   /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6756      receive the signal.  A different setting is inheritable */
6757   signal (SIGCHLD, SIG_DFL);
6758 #endif
6759
6760   /* Allocate the argument vector.  */
6761   alloc_args ();
6762
6763   obstack_init (&obstack);
6764
6765   /* Build multilib_select, et. al from the separate lines that make up each
6766      multilib selection.  */
6767   {
6768     const char *const *q = multilib_raw;
6769     int need_space;
6770
6771     obstack_init (&multilib_obstack);
6772     while ((p = *q++) != (char *) 0)
6773       obstack_grow (&multilib_obstack, p, strlen (p));
6774
6775     obstack_1grow (&multilib_obstack, 0);
6776     multilib_select = XOBFINISH (&multilib_obstack, const char *);
6777
6778     q = multilib_matches_raw;
6779     while ((p = *q++) != (char *) 0)
6780       obstack_grow (&multilib_obstack, p, strlen (p));
6781
6782     obstack_1grow (&multilib_obstack, 0);
6783     multilib_matches = XOBFINISH (&multilib_obstack, const char *);
6784
6785     q = multilib_exclusions_raw;
6786     while ((p = *q++) != (char *) 0)
6787       obstack_grow (&multilib_obstack, p, strlen (p));
6788
6789     obstack_1grow (&multilib_obstack, 0);
6790     multilib_exclusions = XOBFINISH (&multilib_obstack, const char *);
6791
6792     need_space = FALSE;
6793     for (i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++)
6794       {
6795         if (need_space)
6796           obstack_1grow (&multilib_obstack, ' ');
6797         obstack_grow (&multilib_obstack,
6798                       multilib_defaults_raw[i],
6799                       strlen (multilib_defaults_raw[i]));
6800         need_space = TRUE;
6801       }
6802
6803     obstack_1grow (&multilib_obstack, 0);
6804     multilib_defaults = XOBFINISH (&multilib_obstack, const char *);
6805   }
6806
6807   /* Set up to remember the pathname of gcc and any options
6808      needed for collect.  We use argv[0] instead of programname because
6809      we need the complete pathname.  */
6810   obstack_init (&collect_obstack);
6811   obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
6812   obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1);
6813   xputenv (XOBFINISH (&collect_obstack, char *));
6814
6815 #ifdef INIT_ENVIRONMENT
6816   /* Set up any other necessary machine specific environment variables.  */
6817   xputenv (INIT_ENVIRONMENT);
6818 #endif
6819
6820   /* Make a table of what switches there are (switches, n_switches).
6821      Make a table of specified input files (infiles, n_infiles).
6822      Decode switches that are handled locally.  */
6823
6824   process_command (argc, CONST_CAST2 (const char **, char **, argv));
6825
6826   /* Initialize the vector of specs to just the default.
6827      This means one element containing 0s, as a terminator.  */
6828
6829   compilers = XNEWVAR (struct compiler, sizeof default_compilers);
6830   memcpy (compilers, default_compilers, sizeof default_compilers);
6831   n_compilers = n_default_compilers;
6832
6833   /* Read specs from a file if there is one.  */
6834
6835   machine_suffix = concat (spec_machine, dir_separator_str,
6836                            spec_version, dir_separator_str, NULL);
6837   just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
6838
6839   specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, true);
6840   /* Read the specs file unless it is a default one.  */
6841   if (specs_file != 0 && strcmp (specs_file, "specs"))
6842     read_specs (specs_file, TRUE);
6843   else
6844     init_spec ();
6845
6846   /* We need to check standard_exec_prefix/just_machine_suffix/specs
6847      for any override of as, ld and libraries.  */
6848   specs_file = (char *) alloca (strlen (standard_exec_prefix)
6849                        + strlen (just_machine_suffix) + sizeof ("specs"));
6850
6851   strcpy (specs_file, standard_exec_prefix);
6852   strcat (specs_file, just_machine_suffix);
6853   strcat (specs_file, "specs");
6854   if (access (specs_file, R_OK) == 0)
6855     read_specs (specs_file, TRUE);
6856
6857   /* Process any configure-time defaults specified for the command line
6858      options, via OPTION_DEFAULT_SPECS.  */
6859   for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
6860     do_option_spec (option_default_specs[i].name,
6861                     option_default_specs[i].spec);
6862
6863   /* Process DRIVER_SELF_SPECS, adding any new options to the end
6864      of the command line.  */
6865
6866   for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++)
6867     do_self_spec (driver_self_specs[i]);
6868
6869   if (compare_debug)
6870     {
6871       enum save_temps save;
6872
6873       if (!compare_debug_second)
6874         {
6875           n_switches_debug_check[1] = n_switches;
6876           switches_debug_check[1] = XDUPVEC (struct switchstr, switches,
6877                                              n_switches + 1);
6878
6879           do_self_spec ("%:compare-debug-self-opt()");
6880           n_switches_debug_check[0] = n_switches;
6881           switches_debug_check[0] = switches;
6882
6883           n_switches = n_switches_debug_check[1];
6884           switches = switches_debug_check[1];
6885         }
6886
6887       /* Avoid crash when computing %j in this early.  */
6888       save = save_temps_flag;
6889       save_temps_flag = SAVE_TEMPS_NONE;
6890
6891       compare_debug = -compare_debug;
6892       do_self_spec ("%:compare-debug-self-opt()");
6893
6894       save_temps_flag = save;
6895
6896       if (!compare_debug_second)
6897         {
6898           n_switches_debug_check[1] = n_switches;
6899           switches_debug_check[1] = switches;
6900           compare_debug = -compare_debug;
6901           n_switches = n_switches_debug_check[0];
6902           switches = switches_debug_check[0];
6903         }
6904     }
6905
6906   /* If not cross-compiling, look for executables in the standard
6907      places.  */
6908   if (*cross_compile == '0')
6909     {
6910       if (*md_exec_prefix)
6911         {
6912           add_prefix (&exec_prefixes, md_exec_prefix, "GCC",
6913                       PREFIX_PRIORITY_LAST, 0, 0);
6914         }
6915     }
6916
6917   /* Process sysroot_suffix_spec.  */
6918   if (*sysroot_suffix_spec != 0
6919       && do_spec_2 (sysroot_suffix_spec) == 0)
6920     {
6921       if (argbuf_index > 1)
6922         error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
6923       else if (argbuf_index == 1)
6924         target_sysroot_suffix = xstrdup (argbuf[argbuf_index -1]);
6925     }
6926
6927 #ifdef HAVE_LD_SYSROOT
6928   /* Pass the --sysroot option to the linker, if it supports that.  If
6929      there is a sysroot_suffix_spec, it has already been processed by
6930      this point, so target_system_root really is the system root we
6931      should be using.  */
6932   if (target_system_root)
6933     {
6934       obstack_grow (&obstack, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
6935       obstack_grow0 (&obstack, link_spec, strlen (link_spec));
6936       set_spec ("link", XOBFINISH (&obstack, const char *));
6937     }
6938 #endif
6939
6940   /* Process sysroot_hdrs_suffix_spec.  */
6941   if (*sysroot_hdrs_suffix_spec != 0
6942       && do_spec_2 (sysroot_hdrs_suffix_spec) == 0)
6943     {
6944       if (argbuf_index > 1)
6945         error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
6946       else if (argbuf_index == 1)
6947         target_sysroot_hdrs_suffix = xstrdup (argbuf[argbuf_index -1]);
6948     }
6949
6950   /* Look for startfiles in the standard places.  */
6951   if (*startfile_prefix_spec != 0
6952       && do_spec_2 (startfile_prefix_spec) == 0
6953       && do_spec_1 (" ", 0, NULL) == 0)
6954     {
6955       int ndx;
6956       for (ndx = 0; ndx < argbuf_index; ndx++)
6957         add_sysrooted_prefix (&startfile_prefixes, argbuf[ndx], "BINUTILS",
6958                               PREFIX_PRIORITY_LAST, 0, 1);
6959     }
6960   /* We should eventually get rid of all these and stick to
6961      startfile_prefix_spec exclusively.  */
6962   else if (*cross_compile == '0' || target_system_root)
6963     {
6964       if (*md_startfile_prefix)
6965         add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix,
6966                               "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6967
6968       if (*md_startfile_prefix_1)
6969         add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix_1,
6970                               "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6971
6972       /* If standard_startfile_prefix is relative, base it on
6973          standard_exec_prefix.  This lets us move the installed tree
6974          as a unit.  If GCC_EXEC_PREFIX is defined, base
6975          standard_startfile_prefix on that as well.
6976
6977          If the prefix is relative, only search it for native compilers;
6978          otherwise we will search a directory containing host libraries.  */
6979       if (IS_ABSOLUTE_PATH (standard_startfile_prefix))
6980         add_sysrooted_prefix (&startfile_prefixes,
6981                               standard_startfile_prefix, "BINUTILS",
6982                               PREFIX_PRIORITY_LAST, 0, 1);
6983       else if (*cross_compile == '0')
6984         {
6985           add_prefix (&startfile_prefixes,
6986                       concat (gcc_exec_prefix
6987                               ? gcc_exec_prefix : standard_exec_prefix,
6988                               machine_suffix,
6989                               standard_startfile_prefix, NULL),
6990                       NULL, PREFIX_PRIORITY_LAST, 0, 1);
6991         }
6992
6993       /* Sysrooted prefixes are relocated because target_system_root is
6994          also relocated by gcc_exec_prefix.  */
6995       if (*standard_startfile_prefix_1)
6996         add_sysrooted_prefix (&startfile_prefixes,
6997                               standard_startfile_prefix_1, "BINUTILS",
6998                               PREFIX_PRIORITY_LAST, 0, 1);
6999       if (*standard_startfile_prefix_2)
7000         add_sysrooted_prefix (&startfile_prefixes,
7001                               standard_startfile_prefix_2, "BINUTILS",
7002                               PREFIX_PRIORITY_LAST, 0, 1);
7003     }
7004
7005   /* Process any user specified specs in the order given on the command
7006      line.  */
7007   for (uptr = user_specs_head; uptr; uptr = uptr->next)
7008     {
7009       char *filename = find_a_file (&startfile_prefixes, uptr->filename,
7010                                     R_OK, true);
7011       read_specs (filename ? filename : uptr->filename, FALSE);
7012     }
7013
7014   /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake.  */
7015   if (gcc_exec_prefix)
7016     gcc_exec_prefix = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
7017                               spec_version, dir_separator_str, NULL);
7018
7019   /* Now we have the specs.
7020      Set the `valid' bits for switches that match anything in any spec.  */
7021
7022   validate_all_switches ();
7023
7024   /* Now that we have the switches and the specs, set
7025      the subdirectory based on the options.  */
7026   set_multilib_dir ();
7027
7028   /* Warn about any switches that no pass was interested in.  */
7029
7030   for (i = 0; (int) i < n_switches; i++)
7031     if (! switches[i].validated)
7032       error ("unrecognized option '-%s'", switches[i].part1);
7033
7034   /* Obey some of the options.  */
7035
7036   if (print_search_dirs)
7037     {
7038       printf (_("install: %s%s\n"),
7039               gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
7040               gcc_exec_prefix ? "" : machine_suffix);
7041       printf (_("programs: %s\n"),
7042               build_search_list (&exec_prefixes, "", false, false));
7043       printf (_("libraries: %s\n"),
7044               build_search_list (&startfile_prefixes, "", false, true));
7045       return (0);
7046     }
7047
7048   if (print_file_name)
7049     {
7050       printf ("%s\n", find_file (print_file_name));
7051       return (0);
7052     }
7053
7054   if (print_prog_name)
7055     {
7056       char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK, 0);
7057       printf ("%s\n", (newname ? newname : print_prog_name));
7058       return (0);
7059     }
7060
7061   if (print_multi_lib)
7062     {
7063       print_multilib_info ();
7064       return (0);
7065     }
7066
7067   if (print_multi_directory)
7068     {
7069       if (multilib_dir == NULL)
7070         printf (".\n");
7071       else
7072         printf ("%s\n", multilib_dir);
7073       return (0);
7074     }
7075
7076   if (print_sysroot)
7077     {
7078       if (target_system_root)
7079         {
7080           if (target_sysroot_suffix)
7081             printf ("%s%s\n", target_system_root, target_sysroot_suffix);
7082           else
7083             printf ("%s\n", target_system_root);
7084         }
7085       return (0);
7086     }
7087
7088   if (print_multi_os_directory)
7089     {
7090       if (multilib_os_dir == NULL)
7091         printf (".\n");
7092       else
7093         printf ("%s\n", multilib_os_dir);
7094       return (0);
7095     }
7096
7097   if (print_sysroot_headers_suffix)
7098     {
7099       if (*sysroot_hdrs_suffix_spec)
7100         {
7101           printf("%s\n", (target_sysroot_hdrs_suffix
7102                           ? target_sysroot_hdrs_suffix
7103                           : ""));
7104           return (0);
7105         }
7106       else
7107         /* The error status indicates that only one set of fixed
7108            headers should be built.  */
7109         fatal ("not configured with sysroot headers suffix");
7110     }
7111
7112   if (print_help_list)
7113     {
7114       display_help ();
7115
7116       if (! verbose_flag)
7117         {
7118           printf (_("\nFor bug reporting instructions, please see:\n"));
7119           printf ("%s.\n", bug_report_url);
7120
7121           return (0);
7122         }
7123
7124       /* We do not exit here.  Instead we have created a fake input file
7125          called 'help-dummy' which needs to be compiled, and we pass this
7126          on the various sub-processes, along with the --help switch.
7127          Ensure their output appears after ours.  */
7128       fputc ('\n', stdout);
7129       fflush (stdout);
7130     }
7131
7132   if (print_version)
7133     {
7134       printf (_("%s %s%s\n"), programname, pkgversion_string,
7135               version_string);
7136       printf ("Copyright %s 2009 Free Software Foundation, Inc.\n",
7137               _("(C)"));
7138       fputs (_("This is free software; see the source for copying conditions.  There is NO\n\
7139 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
7140              stdout);
7141       if (! verbose_flag)
7142         return 0;
7143
7144       /* We do not exit here. We use the same mechanism of --help to print
7145          the version of the sub-processes. */
7146       fputc ('\n', stdout);
7147       fflush (stdout);
7148     }
7149
7150   if (verbose_flag)
7151     {
7152       int n;
7153       const char *thrmod;
7154
7155       notice ("Target: %s\n", spec_machine);
7156       notice ("Configured with: %s\n", configuration_arguments);
7157
7158 #ifdef THREAD_MODEL_SPEC
7159       /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
7160          but there's no point in doing all this processing just to get
7161          thread_model back.  */
7162       obstack_init (&obstack);
7163       do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model);
7164       obstack_1grow (&obstack, '\0');
7165       thrmod = XOBFINISH (&obstack, const char *);
7166 #else
7167       thrmod = thread_model;
7168 #endif
7169
7170       notice ("Thread model: %s\n", thrmod);
7171
7172       /* compiler_version is truncated at the first space when initialized
7173          from version string, so truncate version_string at the first space
7174          before comparing.  */
7175       for (n = 0; version_string[n]; n++)
7176         if (version_string[n] == ' ')
7177           break;
7178
7179       if (! strncmp (version_string, compiler_version, n)
7180           && compiler_version[n] == 0)
7181         notice ("gcc version %s %s\n", version_string, pkgversion_string);
7182       else
7183         notice ("gcc driver version %s %sexecuting gcc version %s\n",
7184                 version_string, pkgversion_string, compiler_version);
7185
7186       if (n_infiles == 0)
7187         return (0);
7188     }
7189
7190   if (n_infiles == added_libraries)
7191     fatal ("no input files");
7192
7193   /* Make a place to record the compiler output file names
7194      that correspond to the input files.  */
7195
7196   i = n_infiles;
7197   i += lang_specific_extra_outfiles;
7198   outfiles = XCNEWVEC (const char *, i);
7199
7200   /* Record which files were specified explicitly as link input.  */
7201
7202   explicit_link_files = XCNEWVEC (char, n_infiles);
7203
7204   if (combine_flag)
7205     combine_inputs = true;
7206   else
7207     combine_inputs = false;
7208
7209   for (i = 0; (int) i < n_infiles; i++)
7210     {
7211       const char *name = infiles[i].name;
7212       struct compiler *compiler = lookup_compiler (name,
7213                                                    strlen (name),
7214                                                    infiles[i].language);
7215
7216       if (compiler && !(compiler->combinable))
7217         combine_inputs = false;
7218
7219       if (lang_n_infiles > 0 && compiler != input_file_compiler
7220           && infiles[i].language && infiles[i].language[0] != '*')
7221         infiles[i].incompiler = compiler;
7222       else if (compiler)
7223         {
7224           lang_n_infiles++;
7225           input_file_compiler = compiler;
7226           infiles[i].incompiler = compiler;
7227         }
7228       else
7229         {
7230           /* Since there is no compiler for this input file, assume it is a
7231              linker file.  */
7232           explicit_link_files[i] = 1;
7233           infiles[i].incompiler = NULL;
7234         }
7235       infiles[i].compiled = false;
7236       infiles[i].preprocessed = false;
7237     }
7238
7239   if (!combine_inputs && have_c && have_o && lang_n_infiles > 1)
7240    fatal ("cannot specify -o with -c or -S with multiple files");
7241
7242   if (combine_flag && save_temps_flag)
7243     {
7244       bool save_combine_inputs = combine_inputs;
7245       /* Must do a separate pre-processing pass for C & Objective-C files, to
7246          obtain individual .i files.  */
7247
7248       combine_inputs = false;
7249       for (i = 0; (int) i < n_infiles; i++)
7250         {
7251           int this_file_error = 0;
7252
7253           input_file_number = i;
7254           set_input (infiles[i].name);
7255           if (infiles[i].incompiler
7256               && (infiles[i].incompiler)->needs_preprocessing)
7257             input_file_compiler = infiles[i].incompiler;
7258           else
7259             continue;
7260
7261           if (input_file_compiler)
7262             {
7263               if (input_file_compiler->spec[0] == '#')
7264                 {
7265                   error ("%s: %s compiler not installed on this system",
7266                          input_filename, &input_file_compiler->spec[1]);
7267                   this_file_error = 1;
7268                 }
7269               else
7270                 {
7271                   value = do_spec (input_file_compiler->spec);
7272                   infiles[i].preprocessed = true;
7273                   if (!have_o_argbuf_index)
7274                     fatal ("spec '%s' is invalid", input_file_compiler->spec);
7275                   infiles[i].name = argbuf[have_o_argbuf_index];
7276                   infiles[i].incompiler
7277                     = lookup_compiler (infiles[i].name,
7278                                        strlen (infiles[i].name),
7279                                        infiles[i].language);
7280
7281                   if (value < 0)
7282                     this_file_error = 1;
7283                 }
7284             }
7285
7286           if (this_file_error)
7287             {
7288               delete_failure_queue ();
7289               error_count++;
7290               break;
7291             }
7292           clear_failure_queue ();
7293         }
7294       combine_inputs = save_combine_inputs;
7295     }
7296
7297   for (i = 0; (int) i < n_infiles; i++)
7298     {
7299       int this_file_error = 0;
7300
7301       /* Tell do_spec what to substitute for %i.  */
7302
7303       input_file_number = i;
7304       set_input (infiles[i].name);
7305
7306       if (infiles[i].compiled)
7307         continue;
7308
7309       /* Use the same thing in %o, unless cp->spec says otherwise.  */
7310
7311       outfiles[i] = input_filename;
7312
7313       /* Figure out which compiler from the file's suffix.  */
7314
7315       if (! combine_inputs)
7316         input_file_compiler
7317           = lookup_compiler (infiles[i].name, input_filename_length,
7318                              infiles[i].language);
7319       else
7320         input_file_compiler = infiles[i].incompiler;
7321
7322       if (input_file_compiler)
7323         {
7324           /* Ok, we found an applicable compiler.  Run its spec.  */
7325
7326           if (input_file_compiler->spec[0] == '#')
7327             {
7328               error ("%s: %s compiler not installed on this system",
7329                      input_filename, &input_file_compiler->spec[1]);
7330               this_file_error = 1;
7331             }
7332           else
7333             {
7334               if (compare_debug)
7335                 {
7336                   if (debug_check_temp_file[0])
7337                     free (debug_check_temp_file[0]);
7338                   debug_check_temp_file[0] = NULL;
7339
7340                   if (debug_check_temp_file[1])
7341                     free (debug_check_temp_file[1]);
7342                   debug_check_temp_file[1] = NULL;
7343                 }
7344
7345               value = do_spec (input_file_compiler->spec);
7346               infiles[i].compiled = true;
7347               if (value < 0)
7348                 this_file_error = 1;
7349               else if (compare_debug && debug_check_temp_file[0])
7350                 {
7351                   if (verbose_flag)
7352                     error ("Recompiling with -fcompare-debug");
7353
7354                   compare_debug = -compare_debug;
7355                   n_switches = n_switches_debug_check[1];
7356                   switches = switches_debug_check[1];
7357
7358                   value = do_spec (input_file_compiler->spec);
7359
7360                   compare_debug = -compare_debug;
7361                   n_switches = n_switches_debug_check[0];
7362                   switches = switches_debug_check[0];
7363
7364                   if (value < 0)
7365                     {
7366                       error ("during -fcompare-debug recompilation");
7367                       this_file_error = 1;
7368                     }
7369
7370                   gcc_assert (debug_check_temp_file[1]
7371                               && strcmp (debug_check_temp_file[0],
7372                                          debug_check_temp_file[1]));
7373
7374                   if (verbose_flag)
7375                     error ("Comparing final insns dumps");
7376
7377                   if (compare_files (debug_check_temp_file))
7378                     this_file_error = 1;
7379                 }
7380
7381               if (compare_debug)
7382                 {
7383                   if (debug_check_temp_file[0])
7384                     free (debug_check_temp_file[0]);
7385                   debug_check_temp_file[0] = NULL;
7386
7387                   if (debug_check_temp_file[1])
7388                     free (debug_check_temp_file[1]);
7389                   debug_check_temp_file[1] = NULL;
7390                 }
7391             }
7392         }
7393
7394       /* If this file's name does not contain a recognized suffix,
7395          record it as explicit linker input.  */
7396
7397       else
7398         explicit_link_files[i] = 1;
7399
7400       /* Clear the delete-on-failure queue, deleting the files in it
7401          if this compilation failed.  */
7402
7403       if (this_file_error)
7404         {
7405           delete_failure_queue ();
7406           error_count++;
7407         }
7408       /* If this compilation succeeded, don't delete those files later.  */
7409       clear_failure_queue ();
7410     }
7411
7412   /* Reset the input file name to the first compile/object file name, for use
7413      with %b in LINK_SPEC. We use the first input file that we can find
7414      a compiler to compile it instead of using infiles.language since for
7415      languages other than C we use aliases that we then lookup later.  */
7416   if (n_infiles > 0)
7417     {
7418       int i;
7419
7420       for (i = 0; i < n_infiles ; i++)
7421         if (infiles[i].language && infiles[i].language[0] != '*')
7422           {
7423             set_input (infiles[i].name);
7424             break;
7425           }
7426     }
7427
7428   if (error_count == 0)
7429     {
7430       /* Make sure INPUT_FILE_NUMBER points to first available open
7431          slot.  */
7432       input_file_number = n_infiles;
7433       if (lang_specific_pre_link ())
7434         error_count++;
7435     }
7436
7437   /* Determine if there are any linker input files.  */
7438   num_linker_inputs = 0;
7439   for (i = 0; (int) i < n_infiles; i++)
7440     if (explicit_link_files[i] || outfiles[i] != NULL)
7441       num_linker_inputs++;
7442
7443   /* Run ld to link all the compiler output files.  */
7444
7445   if (num_linker_inputs > 0 && error_count == 0 && print_subprocess_help < 2)
7446     {
7447       int tmp = execution_count;
7448
7449       /* We'll use ld if we can't find collect2.  */
7450       if (! strcmp (linker_name_spec, "collect2"))
7451         {
7452           char *s = find_a_file (&exec_prefixes, "collect2", X_OK, false);
7453           if (s == NULL)
7454             linker_name_spec = "ld";
7455         }
7456       /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
7457          for collect.  */
7458       putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH", false);
7459       putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV, true);
7460
7461       if (print_subprocess_help == 1)
7462         {
7463           printf (_("\nLinker options\n==============\n\n"));
7464           printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
7465                     " to the linker.\n\n"));
7466           fflush (stdout);
7467         }
7468       value = do_spec (link_command_spec);
7469       if (value < 0)
7470         error_count = 1;
7471       linker_was_run = (tmp != execution_count);
7472     }
7473
7474   /* If options said don't run linker,
7475      complain about input files to be given to the linker.  */
7476
7477   if (! linker_was_run && error_count == 0)
7478     for (i = 0; (int) i < n_infiles; i++)
7479       if (explicit_link_files[i]
7480           && !(infiles[i].language && infiles[i].language[0] == '*'))
7481         error ("%s: linker input file unused because linking not done",
7482                outfiles[i]);
7483
7484   /* Delete some or all of the temporary files we made.  */
7485
7486   if (error_count)
7487     delete_failure_queue ();
7488   delete_temp_files ();
7489
7490   if (print_help_list)
7491     {
7492       printf (("\nFor bug reporting instructions, please see:\n"));
7493       printf ("%s\n", bug_report_url);
7494     }
7495
7496   return (signal_count != 0 ? 2
7497           : error_count > 0 ? (pass_exit_codes ? greatest_status : 1)
7498           : 0);
7499 }
7500
7501 /* Find the proper compilation spec for the file name NAME,
7502    whose length is LENGTH.  LANGUAGE is the specified language,
7503    or 0 if this file is to be passed to the linker.  */
7504
7505 static struct compiler *
7506 lookup_compiler (const char *name, size_t length, const char *language)
7507 {
7508   struct compiler *cp;
7509
7510   /* If this was specified by the user to be a linker input, indicate that.  */
7511   if (language != 0 && language[0] == '*')
7512     return 0;
7513
7514   /* Otherwise, look for the language, if one is spec'd.  */
7515   if (language != 0)
7516     {
7517       for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7518         if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
7519           return cp;
7520
7521       error ("language %s not recognized", language);
7522       return 0;
7523     }
7524
7525   /* Look for a suffix.  */
7526   for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7527     {
7528       if (/* The suffix `-' matches only the file name `-'.  */
7529           (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
7530           || (strlen (cp->suffix) < length
7531               /* See if the suffix matches the end of NAME.  */
7532               && !strcmp (cp->suffix,
7533                           name + length - strlen (cp->suffix))
7534          ))
7535         break;
7536     }
7537
7538 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
7539   /* Look again, but case-insensitively this time.  */
7540   if (cp < compilers)
7541     for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7542       {
7543         if (/* The suffix `-' matches only the file name `-'.  */
7544             (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
7545             || (strlen (cp->suffix) < length
7546                 /* See if the suffix matches the end of NAME.  */
7547                 && ((!strcmp (cp->suffix,
7548                              name + length - strlen (cp->suffix))
7549                      || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
7550                     && !strcasecmp (cp->suffix,
7551                                     name + length - strlen (cp->suffix)))
7552            ))
7553           break;
7554       }
7555 #endif
7556
7557   if (cp >= compilers)
7558     {
7559       if (cp->spec[0] != '@')
7560         /* A non-alias entry: return it.  */
7561         return cp;
7562
7563       /* An alias entry maps a suffix to a language.
7564          Search for the language; pass 0 for NAME and LENGTH
7565          to avoid infinite recursion if language not found.  */
7566       return lookup_compiler (NULL, 0, cp->spec + 1);
7567     }
7568   return 0;
7569 }
7570 \f
7571 static char *
7572 save_string (const char *s, int len)
7573 {
7574   char *result = XNEWVEC (char, len + 1);
7575
7576   memcpy (result, s, len);
7577   result[len] = 0;
7578   return result;
7579 }
7580
7581 void
7582 pfatal_with_name (const char *name)
7583 {
7584   perror_with_name (name);
7585   delete_temp_files ();
7586   exit (1);
7587 }
7588
7589 static void
7590 perror_with_name (const char *name)
7591 {
7592   error ("%s: %s", name, xstrerror (errno));
7593 }
7594
7595 /* Output an error message and exit.  */
7596
7597 void
7598 fancy_abort (const char *file, int line, const char *func)
7599 {
7600   fatal_ice ("internal gcc abort in %s, at %s:%d", func, file, line);
7601 }
7602 \f
7603 /* Output an error message and exit.  */
7604
7605 void
7606 fatal_ice (const char *cmsgid, ...)
7607 {
7608   va_list ap;
7609
7610   va_start (ap, cmsgid);
7611
7612   fprintf (stderr, "%s: ", programname);
7613   vfprintf (stderr, _(cmsgid), ap);
7614   va_end (ap);
7615   fprintf (stderr, "\n");
7616   delete_temp_files ();
7617   exit (pass_exit_codes ? ICE_EXIT_CODE : 1);
7618 }
7619
7620 void
7621 fatal (const char *cmsgid, ...)
7622 {
7623   va_list ap;
7624
7625   va_start (ap, cmsgid);
7626
7627   fprintf (stderr, "%s: ", programname);
7628   vfprintf (stderr, _(cmsgid), ap);
7629   va_end (ap);
7630   fprintf (stderr, "\n");
7631   delete_temp_files ();
7632   exit (1);
7633 }
7634
7635 /* The argument is actually c-format, not gcc-internal-format,
7636    but because functions with identical names are used through
7637    the rest of the compiler with gcc-internal-format, we just
7638    need to hope all users of these functions use the common
7639    subset between c-format and gcc-internal-format.  */
7640
7641 void
7642 error (const char *gmsgid, ...)
7643 {
7644   va_list ap;
7645
7646   va_start (ap, gmsgid);
7647   fprintf (stderr, "%s: ", programname);
7648   vfprintf (stderr, _(gmsgid), ap);
7649   va_end (ap);
7650
7651   fprintf (stderr, "\n");
7652 }
7653
7654 static void
7655 notice (const char *cmsgid, ...)
7656 {
7657   va_list ap;
7658
7659   va_start (ap, cmsgid);
7660   vfprintf (stderr, _(cmsgid), ap);
7661   va_end (ap);
7662 }
7663 \f
7664 static inline void
7665 validate_switches_from_spec (const char *spec)
7666 {
7667   const char *p = spec;
7668   char c;
7669   while ((c = *p++))
7670     if (c == '%' && (*p == '{' || *p == '<' || (*p == 'W' && *++p == '{')))
7671       /* We have a switch spec.  */
7672       p = validate_switches (p + 1);
7673 }
7674
7675 static void
7676 validate_all_switches (void)
7677 {
7678   struct compiler *comp;
7679   struct spec_list *spec;
7680
7681   for (comp = compilers; comp->spec; comp++)
7682     validate_switches_from_spec (comp->spec);
7683
7684   /* Look through the linked list of specs read from the specs file.  */
7685   for (spec = specs; spec; spec = spec->next)
7686     validate_switches_from_spec (*spec->ptr_spec);
7687
7688   validate_switches_from_spec (link_command_spec);
7689 }
7690
7691 /* Look at the switch-name that comes after START
7692    and mark as valid all supplied switches that match it.  */
7693
7694 static const char *
7695 validate_switches (const char *start)
7696 {
7697   const char *p = start;
7698   const char *atom;
7699   size_t len;
7700   int i;
7701   bool suffix = false;
7702   bool starred = false;
7703
7704 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7705
7706 next_member:
7707   SKIP_WHITE ();
7708
7709   if (*p == '!')
7710     p++;
7711
7712   SKIP_WHITE ();
7713   if (*p == '.' || *p == ',')
7714     suffix = true, p++;
7715
7716   atom = p;
7717   while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
7718          || *p == ',' || *p == '.' || *p == '@')
7719     p++;
7720   len = p - atom;
7721
7722   if (*p == '*')
7723     starred = true, p++;
7724
7725   SKIP_WHITE ();
7726
7727   if (!suffix)
7728     {
7729       /* Mark all matching switches as valid.  */
7730       for (i = 0; i < n_switches; i++)
7731         if (!strncmp (switches[i].part1, atom, len)
7732             && (starred || switches[i].part1[len] == 0))
7733           switches[i].validated = 1;
7734     }
7735
7736   if (*p) p++;
7737   if (*p && (p[-1] == '|' || p[-1] == '&'))
7738     goto next_member;
7739
7740   if (*p && p[-1] == ':')
7741     {
7742       while (*p && *p != ';' && *p != '}')
7743         {
7744           if (*p == '%')
7745             {
7746               p++;
7747               if (*p == '{' || *p == '<')
7748                 p = validate_switches (p+1);
7749               else if (p[0] == 'W' && p[1] == '{')
7750                 p = validate_switches (p+2);
7751             }
7752           else
7753             p++;
7754         }
7755
7756       if (*p) p++;
7757       if (*p && p[-1] == ';')
7758         goto next_member;
7759     }
7760
7761   return p;
7762 #undef SKIP_WHITE
7763 }
7764 \f
7765 struct mdswitchstr
7766 {
7767   const char *str;
7768   int len;
7769 };
7770
7771 static struct mdswitchstr *mdswitches;
7772 static int n_mdswitches;
7773
7774 /* Check whether a particular argument was used.  The first time we
7775    canonicalize the switches to keep only the ones we care about.  */
7776
7777 static int
7778 used_arg (const char *p, int len)
7779 {
7780   struct mswitchstr
7781   {
7782     const char *str;
7783     const char *replace;
7784     int len;
7785     int rep_len;
7786   };
7787
7788   static struct mswitchstr *mswitches;
7789   static int n_mswitches;
7790   int i, j;
7791
7792   if (!mswitches)
7793     {
7794       struct mswitchstr *matches;
7795       const char *q;
7796       int cnt = 0;
7797
7798       /* Break multilib_matches into the component strings of string
7799          and replacement string.  */
7800       for (q = multilib_matches; *q != '\0'; q++)
7801         if (*q == ';')
7802           cnt++;
7803
7804       matches
7805         = (struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt);
7806       i = 0;
7807       q = multilib_matches;
7808       while (*q != '\0')
7809         {
7810           matches[i].str = q;
7811           while (*q != ' ')
7812             {
7813               if (*q == '\0')
7814                 {
7815                 invalid_matches:
7816                   fatal ("multilib spec '%s' is invalid", multilib_matches);
7817                 }
7818               q++;
7819             }
7820           matches[i].len = q - matches[i].str;
7821
7822           matches[i].replace = ++q;
7823           while (*q != ';' && *q != '\0')
7824             {
7825               if (*q == ' ')
7826                 goto invalid_matches;
7827               q++;
7828             }
7829           matches[i].rep_len = q - matches[i].replace;
7830           i++;
7831           if (*q == ';')
7832             q++;
7833         }
7834
7835       /* Now build a list of the replacement string for switches that we care
7836          about.  Make sure we allocate at least one entry.  This prevents
7837          xmalloc from calling fatal, and prevents us from re-executing this
7838          block of code.  */
7839       mswitches
7840         = XNEWVEC (struct mswitchstr, n_mdswitches + (n_switches ? n_switches : 1));
7841       for (i = 0; i < n_switches; i++)
7842         if ((switches[i].live_cond & SWITCH_IGNORE) == 0)
7843           {
7844             int xlen = strlen (switches[i].part1);
7845             for (j = 0; j < cnt; j++)
7846               if (xlen == matches[j].len
7847                   && ! strncmp (switches[i].part1, matches[j].str, xlen))
7848                 {
7849                   mswitches[n_mswitches].str = matches[j].replace;
7850                   mswitches[n_mswitches].len = matches[j].rep_len;
7851                   mswitches[n_mswitches].replace = (char *) 0;
7852                   mswitches[n_mswitches].rep_len = 0;
7853                   n_mswitches++;
7854                   break;
7855                 }
7856           }
7857
7858       /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
7859          on the command line nor any options mutually incompatible with
7860          them.  */
7861       for (i = 0; i < n_mdswitches; i++)
7862         {
7863           const char *r;
7864
7865           for (q = multilib_options; *q != '\0'; q++)
7866             {
7867               while (*q == ' ')
7868                 q++;
7869
7870               r = q;
7871               while (strncmp (q, mdswitches[i].str, mdswitches[i].len) != 0
7872                      || strchr (" /", q[mdswitches[i].len]) == NULL)
7873                 {
7874                   while (*q != ' ' && *q != '/' && *q != '\0')
7875                     q++;
7876                   if (*q != '/')
7877                     break;
7878                   q++;
7879                 }
7880
7881               if (*q != ' ' && *q != '\0')
7882                 {
7883                   while (*r != ' ' && *r != '\0')
7884                     {
7885                       q = r;
7886                       while (*q != ' ' && *q != '/' && *q != '\0')
7887                         q++;
7888
7889                       if (used_arg (r, q - r))
7890                         break;
7891
7892                       if (*q != '/')
7893                         {
7894                           mswitches[n_mswitches].str = mdswitches[i].str;
7895                           mswitches[n_mswitches].len = mdswitches[i].len;
7896                           mswitches[n_mswitches].replace = (char *) 0;
7897                           mswitches[n_mswitches].rep_len = 0;
7898                           n_mswitches++;
7899                           break;
7900                         }
7901
7902                       r = q + 1;
7903                     }
7904                   break;
7905                 }
7906             }
7907         }
7908     }
7909
7910   for (i = 0; i < n_mswitches; i++)
7911     if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
7912       return 1;
7913
7914   return 0;
7915 }
7916
7917 static int
7918 default_arg (const char *p, int len)
7919 {
7920   int i;
7921
7922   for (i = 0; i < n_mdswitches; i++)
7923     if (len == mdswitches[i].len && ! strncmp (p, mdswitches[i].str, len))
7924       return 1;
7925
7926   return 0;
7927 }
7928
7929 /* Work out the subdirectory to use based on the options. The format of
7930    multilib_select is a list of elements. Each element is a subdirectory
7931    name followed by a list of options followed by a semicolon. The format
7932    of multilib_exclusions is the same, but without the preceding
7933    directory. First gcc will check the exclusions, if none of the options
7934    beginning with an exclamation point are present, and all of the other
7935    options are present, then we will ignore this completely. Passing
7936    that, gcc will consider each multilib_select in turn using the same
7937    rules for matching the options. If a match is found, that subdirectory
7938    will be used.  */
7939
7940 static void
7941 set_multilib_dir (void)
7942 {
7943   const char *p;
7944   unsigned int this_path_len;
7945   const char *this_path, *this_arg;
7946   const char *start, *end;
7947   int not_arg;
7948   int ok, ndfltok, first;
7949
7950   n_mdswitches = 0;
7951   start = multilib_defaults;
7952   while (*start == ' ' || *start == '\t')
7953     start++;
7954   while (*start != '\0')
7955     {
7956       n_mdswitches++;
7957       while (*start != ' ' && *start != '\t' && *start != '\0')
7958         start++;
7959       while (*start == ' ' || *start == '\t')
7960         start++;
7961     }
7962
7963   if (n_mdswitches)
7964     {
7965       int i = 0;
7966
7967       mdswitches = XNEWVEC (struct mdswitchstr, n_mdswitches);
7968       for (start = multilib_defaults; *start != '\0'; start = end + 1)
7969         {
7970           while (*start == ' ' || *start == '\t')
7971             start++;
7972
7973           if (*start == '\0')
7974             break;
7975
7976           for (end = start + 1;
7977                *end != ' ' && *end != '\t' && *end != '\0'; end++)
7978             ;
7979
7980           obstack_grow (&multilib_obstack, start, end - start);
7981           obstack_1grow (&multilib_obstack, 0);
7982           mdswitches[i].str = XOBFINISH (&multilib_obstack, const char *);
7983           mdswitches[i++].len = end - start;
7984
7985           if (*end == '\0')
7986             break;
7987         }
7988     }
7989
7990   p = multilib_exclusions;
7991   while (*p != '\0')
7992     {
7993       /* Ignore newlines.  */
7994       if (*p == '\n')
7995         {
7996           ++p;
7997           continue;
7998         }
7999
8000       /* Check the arguments.  */
8001       ok = 1;
8002       while (*p != ';')
8003         {
8004           if (*p == '\0')
8005             {
8006             invalid_exclusions:
8007               fatal ("multilib exclusions '%s' is invalid",
8008                      multilib_exclusions);
8009             }
8010
8011           if (! ok)
8012             {
8013               ++p;
8014               continue;
8015             }
8016
8017           this_arg = p;
8018           while (*p != ' ' && *p != ';')
8019             {
8020               if (*p == '\0')
8021                 goto invalid_exclusions;
8022               ++p;
8023             }
8024
8025           if (*this_arg != '!')
8026             not_arg = 0;
8027           else
8028             {
8029               not_arg = 1;
8030               ++this_arg;
8031             }
8032
8033           ok = used_arg (this_arg, p - this_arg);
8034           if (not_arg)
8035             ok = ! ok;
8036
8037           if (*p == ' ')
8038             ++p;
8039         }
8040
8041       if (ok)
8042         return;
8043
8044       ++p;
8045     }
8046
8047   first = 1;
8048   p = multilib_select;
8049   while (*p != '\0')
8050     {
8051       /* Ignore newlines.  */
8052       if (*p == '\n')
8053         {
8054           ++p;
8055           continue;
8056         }
8057
8058       /* Get the initial path.  */
8059       this_path = p;
8060       while (*p != ' ')
8061         {
8062           if (*p == '\0')
8063             {
8064             invalid_select:
8065               fatal ("multilib select '%s' is invalid",
8066                      multilib_select);
8067             }
8068           ++p;
8069         }
8070       this_path_len = p - this_path;
8071
8072       /* Check the arguments.  */
8073       ok = 1;
8074       ndfltok = 1;
8075       ++p;
8076       while (*p != ';')
8077         {
8078           if (*p == '\0')
8079             goto invalid_select;
8080
8081           if (! ok)
8082             {
8083               ++p;
8084               continue;
8085             }
8086
8087           this_arg = p;
8088           while (*p != ' ' && *p != ';')
8089             {
8090               if (*p == '\0')
8091                 goto invalid_select;
8092               ++p;
8093             }
8094
8095           if (*this_arg != '!')
8096             not_arg = 0;
8097           else
8098             {
8099               not_arg = 1;
8100               ++this_arg;
8101             }
8102
8103           /* If this is a default argument, we can just ignore it.
8104              This is true even if this_arg begins with '!'.  Beginning
8105              with '!' does not mean that this argument is necessarily
8106              inappropriate for this library: it merely means that
8107              there is a more specific library which uses this
8108              argument.  If this argument is a default, we need not
8109              consider that more specific library.  */
8110           ok = used_arg (this_arg, p - this_arg);
8111           if (not_arg)
8112             ok = ! ok;
8113
8114           if (! ok)
8115             ndfltok = 0;
8116
8117           if (default_arg (this_arg, p - this_arg))
8118             ok = 1;
8119
8120           if (*p == ' ')
8121             ++p;
8122         }
8123
8124       if (ok && first)
8125         {
8126           if (this_path_len != 1
8127               || this_path[0] != '.')
8128             {
8129               char *new_multilib_dir = XNEWVEC (char, this_path_len + 1);
8130               char *q;
8131
8132               strncpy (new_multilib_dir, this_path, this_path_len);
8133               new_multilib_dir[this_path_len] = '\0';
8134               q = strchr (new_multilib_dir, ':');
8135               if (q != NULL)
8136                 *q = '\0';
8137               multilib_dir = new_multilib_dir;
8138             }
8139           first = 0;
8140         }
8141
8142       if (ndfltok)
8143         {
8144           const char *q = this_path, *end = this_path + this_path_len;
8145
8146           while (q < end && *q != ':')
8147             q++;
8148           if (q < end)
8149             {
8150               char *new_multilib_os_dir = XNEWVEC (char, end - q);
8151               memcpy (new_multilib_os_dir, q + 1, end - q - 1);
8152               new_multilib_os_dir[end - q - 1] = '\0';
8153               multilib_os_dir = new_multilib_os_dir;
8154               break;
8155             }
8156         }
8157
8158       ++p;
8159     }
8160
8161   if (multilib_dir == NULL && multilib_os_dir != NULL
8162       && strcmp (multilib_os_dir, ".") == 0)
8163     {
8164       free (CONST_CAST (char *, multilib_os_dir));
8165       multilib_os_dir = NULL;
8166     }
8167   else if (multilib_dir != NULL && multilib_os_dir == NULL)
8168     multilib_os_dir = multilib_dir;
8169 }
8170
8171 /* Print out the multiple library subdirectory selection
8172    information.  This prints out a series of lines.  Each line looks
8173    like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
8174    required.  Only the desired options are printed out, the negative
8175    matches.  The options are print without a leading dash.  There are
8176    no spaces to make it easy to use the information in the shell.
8177    Each subdirectory is printed only once.  This assumes the ordering
8178    generated by the genmultilib script. Also, we leave out ones that match
8179    the exclusions.  */
8180
8181 static void
8182 print_multilib_info (void)
8183 {
8184   const char *p = multilib_select;
8185   const char *last_path = 0, *this_path;
8186   int skip;
8187   unsigned int last_path_len = 0;
8188
8189   while (*p != '\0')
8190     {
8191       skip = 0;
8192       /* Ignore newlines.  */
8193       if (*p == '\n')
8194         {
8195           ++p;
8196           continue;
8197         }
8198
8199       /* Get the initial path.  */
8200       this_path = p;
8201       while (*p != ' ')
8202         {
8203           if (*p == '\0')
8204             {
8205             invalid_select:
8206               fatal ("multilib select '%s' is invalid", multilib_select);
8207             }
8208
8209           ++p;
8210         }
8211
8212       /* When --disable-multilib was used but target defines
8213          MULTILIB_OSDIRNAMES, entries starting with .: are there just
8214          to find multilib_os_dir, so skip them from output.  */
8215       if (this_path[0] == '.' && this_path[1] == ':')
8216         skip = 1;
8217
8218       /* Check for matches with the multilib_exclusions. We don't bother
8219          with the '!' in either list. If any of the exclusion rules match
8220          all of its options with the select rule, we skip it.  */
8221       {
8222         const char *e = multilib_exclusions;
8223         const char *this_arg;
8224
8225         while (*e != '\0')
8226           {
8227             int m = 1;
8228             /* Ignore newlines.  */
8229             if (*e == '\n')
8230               {
8231                 ++e;
8232                 continue;
8233               }
8234
8235             /* Check the arguments.  */
8236             while (*e != ';')
8237               {
8238                 const char *q;
8239                 int mp = 0;
8240
8241                 if (*e == '\0')
8242                   {
8243                   invalid_exclusion:
8244                     fatal ("multilib exclusion '%s' is invalid",
8245                            multilib_exclusions);
8246                   }
8247
8248                 if (! m)
8249                   {
8250                     ++e;
8251                     continue;
8252                   }
8253
8254                 this_arg = e;
8255
8256                 while (*e != ' ' && *e != ';')
8257                   {
8258                     if (*e == '\0')
8259                       goto invalid_exclusion;
8260                     ++e;
8261                   }
8262
8263                 q = p + 1;
8264                 while (*q != ';')
8265                   {
8266                     const char *arg;
8267                     int len = e - this_arg;
8268
8269                     if (*q == '\0')
8270                       goto invalid_select;
8271
8272                     arg = q;
8273
8274                     while (*q != ' ' && *q != ';')
8275                       {
8276                         if (*q == '\0')
8277                           goto invalid_select;
8278                         ++q;
8279                       }
8280
8281                     if (! strncmp (arg, this_arg,
8282                                    (len < q - arg) ? q - arg : len)
8283                         || default_arg (this_arg, e - this_arg))
8284                       {
8285                         mp = 1;
8286                         break;
8287                       }
8288
8289                     if (*q == ' ')
8290                       ++q;
8291                   }
8292
8293                 if (! mp)
8294                   m = 0;
8295
8296                 if (*e == ' ')
8297                   ++e;
8298               }
8299
8300             if (m)
8301               {
8302                 skip = 1;
8303                 break;
8304               }
8305
8306             if (*e != '\0')
8307               ++e;
8308           }
8309       }
8310
8311       if (! skip)
8312         {
8313           /* If this is a duplicate, skip it.  */
8314           skip = (last_path != 0
8315                   && (unsigned int) (p - this_path) == last_path_len
8316                   && ! strncmp (last_path, this_path, last_path_len));
8317
8318           last_path = this_path;
8319           last_path_len = p - this_path;
8320         }
8321
8322       /* If this directory requires any default arguments, we can skip
8323          it.  We will already have printed a directory identical to
8324          this one which does not require that default argument.  */
8325       if (! skip)
8326         {
8327           const char *q;
8328
8329           q = p + 1;
8330           while (*q != ';')
8331             {
8332               const char *arg;
8333
8334               if (*q == '\0')
8335                 goto invalid_select;
8336
8337               if (*q == '!')
8338                 arg = NULL;
8339               else
8340                 arg = q;
8341
8342               while (*q != ' ' && *q != ';')
8343                 {
8344                   if (*q == '\0')
8345                     goto invalid_select;
8346                   ++q;
8347                 }
8348
8349               if (arg != NULL
8350                   && default_arg (arg, q - arg))
8351                 {
8352                   skip = 1;
8353                   break;
8354                 }
8355
8356               if (*q == ' ')
8357                 ++q;
8358             }
8359         }
8360
8361       if (! skip)
8362         {
8363           const char *p1;
8364
8365           for (p1 = last_path; p1 < p && *p1 != ':'; p1++)
8366             putchar (*p1);
8367           putchar (';');
8368         }
8369
8370       ++p;
8371       while (*p != ';')
8372         {
8373           int use_arg;
8374
8375           if (*p == '\0')
8376             goto invalid_select;
8377
8378           if (skip)
8379             {
8380               ++p;
8381               continue;
8382             }
8383
8384           use_arg = *p != '!';
8385
8386           if (use_arg)
8387             putchar ('@');
8388
8389           while (*p != ' ' && *p != ';')
8390             {
8391               if (*p == '\0')
8392                 goto invalid_select;
8393               if (use_arg)
8394                 putchar (*p);
8395               ++p;
8396             }
8397
8398           if (*p == ' ')
8399             ++p;
8400         }
8401
8402       if (! skip)
8403         {
8404           /* If there are extra options, print them now.  */
8405           if (multilib_extra && *multilib_extra)
8406             {
8407               int print_at = TRUE;
8408               const char *q;
8409
8410               for (q = multilib_extra; *q != '\0'; q++)
8411                 {
8412                   if (*q == ' ')
8413                     print_at = TRUE;
8414                   else
8415                     {
8416                       if (print_at)
8417                         putchar ('@');
8418                       putchar (*q);
8419                       print_at = FALSE;
8420                     }
8421                 }
8422             }
8423
8424           putchar ('\n');
8425         }
8426
8427       ++p;
8428     }
8429 }
8430 \f
8431 /* getenv built-in spec function.
8432
8433    Returns the value of the environment variable given by its first
8434    argument, concatenated with the second argument.  If the
8435    environment variable is not defined, a fatal error is issued.  */
8436
8437 static const char *
8438 getenv_spec_function (int argc, const char **argv)
8439 {
8440   char *value;
8441   char *result;
8442   char *ptr;
8443   size_t len;
8444
8445   if (argc != 2)
8446     return NULL;
8447
8448   value = getenv (argv[0]);
8449   if (!value)
8450     fatal ("environment variable \"%s\" not defined", argv[0]);
8451
8452   /* We have to escape every character of the environment variable so
8453      they are not interpreted as active spec characters.  A
8454      particularly painful case is when we are reading a variable
8455      holding a windows path complete with \ separators.  */
8456   len = strlen (value) * 2 + strlen (argv[1]) + 1;
8457   result = XNEWVAR (char, len);
8458   for (ptr = result; *value; ptr += 2)
8459     {
8460       ptr[0] = '\\';
8461       ptr[1] = *value++;
8462     }
8463
8464   strcpy (ptr, argv[1]);
8465
8466   return result;
8467 }
8468
8469 /* if-exists built-in spec function.
8470
8471    Checks to see if the file specified by the absolute pathname in
8472    ARGS exists.  Returns that pathname if found.
8473
8474    The usual use for this function is to check for a library file
8475    (whose name has been expanded with %s).  */
8476
8477 static const char *
8478 if_exists_spec_function (int argc, const char **argv)
8479 {
8480   /* Must have only one argument.  */
8481   if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
8482     return argv[0];
8483
8484   return NULL;
8485 }
8486
8487 /* if-exists-else built-in spec function.
8488
8489    This is like if-exists, but takes an additional argument which
8490    is returned if the first argument does not exist.  */
8491
8492 static const char *
8493 if_exists_else_spec_function (int argc, const char **argv)
8494 {
8495   /* Must have exactly two arguments.  */
8496   if (argc != 2)
8497     return NULL;
8498
8499   if (IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
8500     return argv[0];
8501
8502   return argv[1];
8503 }
8504
8505 /* replace-outfile built-in spec function.
8506
8507    This looks for the first argument in the outfiles array's name and
8508    replaces it with the second argument.  */
8509
8510 static const char *
8511 replace_outfile_spec_function (int argc, const char **argv)
8512 {
8513   int i;
8514   /* Must have exactly two arguments.  */
8515   if (argc != 2)
8516     abort ();
8517
8518   for (i = 0; i < n_infiles; i++)
8519     {
8520       if (outfiles[i] && !strcmp (outfiles[i], argv[0]))
8521         outfiles[i] = xstrdup (argv[1]);
8522     }
8523   return NULL;
8524 }
8525
8526 /* Given two version numbers, compares the two numbers.
8527    A version number must match the regular expression
8528    ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
8529 */
8530 static int
8531 compare_version_strings (const char *v1, const char *v2)
8532 {
8533   int rresult;
8534   regex_t r;
8535
8536   if (regcomp (&r, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
8537                REG_EXTENDED | REG_NOSUB) != 0)
8538     abort ();
8539   rresult = regexec (&r, v1, 0, NULL, 0);
8540   if (rresult == REG_NOMATCH)
8541     fatal ("invalid version number `%s'", v1);
8542   else if (rresult != 0)
8543     abort ();
8544   rresult = regexec (&r, v2, 0, NULL, 0);
8545   if (rresult == REG_NOMATCH)
8546     fatal ("invalid version number `%s'", v2);
8547   else if (rresult != 0)
8548     abort ();
8549
8550   return strverscmp (v1, v2);
8551 }
8552
8553
8554 /* version_compare built-in spec function.
8555
8556    This takes an argument of the following form:
8557
8558    <comparison-op> <arg1> [<arg2>] <switch> <result>
8559
8560    and produces "result" if the comparison evaluates to true,
8561    and nothing if it doesn't.
8562
8563    The supported <comparison-op> values are:
8564
8565    >=  true if switch is a later (or same) version than arg1
8566    !>  opposite of >=
8567    <   true if switch is an earlier version than arg1
8568    !<  opposite of <
8569    ><  true if switch is arg1 or later, and earlier than arg2
8570    <>  true if switch is earlier than arg1 or is arg2 or later
8571
8572    If the switch is not present, the condition is false unless
8573    the first character of the <comparison-op> is '!'.
8574
8575    For example,
8576    %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
8577    adds -lmx if -mmacosx-version-min=10.3.9 was passed.  */
8578
8579 static const char *
8580 version_compare_spec_function (int argc, const char **argv)
8581 {
8582   int comp1, comp2;
8583   size_t switch_len;
8584   const char *switch_value = NULL;
8585   int nargs = 1, i;
8586   bool result;
8587
8588   if (argc < 3)
8589     fatal ("too few arguments to %%:version-compare");
8590   if (argv[0][0] == '\0')
8591     abort ();
8592   if ((argv[0][1] == '<' || argv[0][1] == '>') && argv[0][0] != '!')
8593     nargs = 2;
8594   if (argc != nargs + 3)
8595     fatal ("too many arguments to %%:version-compare");
8596
8597   switch_len = strlen (argv[nargs + 1]);
8598   for (i = 0; i < n_switches; i++)
8599     if (!strncmp (switches[i].part1, argv[nargs + 1], switch_len)
8600         && check_live_switch (i, switch_len))
8601       switch_value = switches[i].part1 + switch_len;
8602
8603   if (switch_value == NULL)
8604     comp1 = comp2 = -1;
8605   else
8606     {
8607       comp1 = compare_version_strings (switch_value, argv[1]);
8608       if (nargs == 2)
8609         comp2 = compare_version_strings (switch_value, argv[2]);
8610       else
8611         comp2 = -1;  /* This value unused.  */
8612     }
8613
8614   switch (argv[0][0] << 8 | argv[0][1])
8615     {
8616     case '>' << 8 | '=':
8617       result = comp1 >= 0;
8618       break;
8619     case '!' << 8 | '<':
8620       result = comp1 >= 0 || switch_value == NULL;
8621       break;
8622     case '<' << 8:
8623       result = comp1 < 0;
8624       break;
8625     case '!' << 8 | '>':
8626       result = comp1 < 0 || switch_value == NULL;
8627       break;
8628     case '>' << 8 | '<':
8629       result = comp1 >= 0 && comp2 < 0;
8630       break;
8631     case '<' << 8 | '>':
8632       result = comp1 < 0 || comp2 >= 0;
8633       break;
8634
8635     default:
8636       fatal ("unknown operator '%s' in %%:version-compare", argv[0]);
8637     }
8638   if (! result)
8639     return NULL;
8640
8641   return argv[nargs + 2];
8642 }
8643
8644 /* %:include builtin spec function.  This differs from %include in that it
8645    can be nested inside a spec, and thus be conditionalized.  It takes
8646    one argument, the filename, and looks for it in the startfile path.
8647    The result is always NULL, i.e. an empty expansion.  */
8648
8649 static const char *
8650 include_spec_function (int argc, const char **argv)
8651 {
8652   char *file;
8653
8654   if (argc != 1)
8655     abort ();
8656
8657   file = find_a_file (&startfile_prefixes, argv[0], R_OK, true);
8658   read_specs (file ? file : argv[0], FALSE);
8659
8660   return NULL;
8661 }
8662
8663 /* %:print-asm-header spec function.  Print a banner to say that the
8664    following output is from the assembler.  */
8665
8666 static const char *
8667 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED,
8668                                 const char **argv ATTRIBUTE_UNUSED)
8669 {
8670   printf (_("Assembler options\n=================\n\n"));
8671   printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
8672   fflush (stdout);
8673   return NULL;
8674 }
8675
8676 /* Compute a timestamp to initialize flag_random_seed.  */
8677
8678 static unsigned
8679 get_local_tick (void)
8680 {
8681   unsigned ret = 0;
8682
8683   /* Get some more or less random data.  */
8684 #ifdef HAVE_GETTIMEOFDAY
8685   {
8686     struct timeval tv;
8687
8688     gettimeofday (&tv, NULL);
8689     ret = tv.tv_sec * 1000 + tv.tv_usec / 1000;
8690   }
8691 #else
8692   {
8693     time_t now = time (NULL);
8694
8695     if (now != (time_t)-1)
8696       ret = (unsigned) now;
8697   }
8698 #endif
8699
8700   return ret;
8701 }
8702
8703 /* %:compare-debug-dump-opt spec function.  Save the last argument,
8704    expected to be the last -fdump-final-insns option, or generate a
8705    temporary.  */
8706
8707 static const char *
8708 compare_debug_dump_opt_spec_function (int arg,
8709                                       const char **argv ATTRIBUTE_UNUSED)
8710 {
8711   const char *ret;
8712   char *name;
8713   int which;
8714   static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];
8715
8716   if (arg != 0)
8717     fatal ("too many arguments to %%:compare-debug-dump-opt");
8718
8719   do_spec_2 ("%{fdump-final-insns=*:%*}");
8720   do_spec_1 (" ", 0, NULL);
8721
8722   if (argbuf_index > 0 && strcmp (argv[argbuf_index - 1], "."))
8723     {
8724       if (!compare_debug)
8725         return NULL;
8726
8727       name = xstrdup (argv[argbuf_index - 1]);
8728       ret = NULL;
8729     }
8730   else
8731     {
8732       const char *ext = NULL;
8733
8734       if (argbuf_index > 0)
8735         {
8736           do_spec_2 ("%{o*:%*}%{!o:%{!S:%b%O}%{S:%b.s}}");
8737           ext = ".gkd";
8738         }
8739       else if (!compare_debug)
8740         return NULL;
8741       else
8742         do_spec_2 ("%g.gkd");
8743
8744       do_spec_1 (" ", 0, NULL);
8745
8746       gcc_assert (argbuf_index > 0);
8747
8748       name = concat (argbuf[argbuf_index - 1], ext, NULL);
8749
8750       ret = concat ("-fdump-final-insns=", name, NULL);
8751     }
8752
8753   which = compare_debug < 0;
8754   debug_check_temp_file[which] = name;
8755
8756   if (!which)
8757     {
8758       unsigned HOST_WIDE_INT value = get_local_tick () ^ getpid ();
8759
8760       sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value);
8761     }
8762
8763   if (*random_seed)
8764     ret = concat ("%{!frandom-seed=*:-frandom-seed=", random_seed, "} ",
8765                   ret, NULL);
8766
8767   if (which)
8768     *random_seed = 0;
8769
8770   return ret;
8771 }
8772
8773 static const char *debug_auxbase_opt;
8774
8775 /* %:compare-debug-self-opt spec function.  Expands to the options
8776     that are to be passed in the second compilation of
8777     compare-debug.  */
8778
8779 static const char *
8780 compare_debug_self_opt_spec_function (int arg,
8781                                       const char **argv ATTRIBUTE_UNUSED)
8782 {
8783   if (arg != 0)
8784     fatal ("too many arguments to %%:compare-debug-self-opt");
8785
8786   if (compare_debug >= 0)
8787     return NULL;
8788
8789   do_spec_2 ("%{c|S:%{o*:%*}}");
8790   do_spec_1 (" ", 0, NULL);
8791
8792   if (argbuf_index > 0)
8793     debug_auxbase_opt = concat ("-auxbase-strip ",
8794                                 argbuf[argbuf_index - 1],
8795                                 NULL);
8796   else
8797     debug_auxbase_opt = NULL;
8798
8799   return concat ("\
8800 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
8801 %<fdump-final-insns=* -w -S -o %j \
8802 %{!fcompare-debug-second:-fcompare-debug-second} \
8803 ", compare_debug_opt, NULL);
8804 }
8805
8806 /* %:compare-debug-auxbase-opt spec function.  Expands to the auxbase
8807     options that are to be passed in the second compilation of
8808     compare-debug.  It expects, as an argument, the basename of the
8809     current input file name, with the .gk suffix appended to it.  */
8810
8811 static const char *
8812 compare_debug_auxbase_opt_spec_function (int arg,
8813                                          const char **argv)
8814 {
8815   char *name;
8816   int len;
8817
8818   if (arg == 0)
8819     fatal ("too few arguments to %%:compare-debug-auxbase-opt");
8820
8821   if (arg != 1)
8822     fatal ("too many arguments to %%:compare-debug-auxbase-opt");
8823
8824   if (compare_debug >= 0)
8825     return NULL;
8826
8827   len = strlen (argv[0]);
8828   if (len < 3 || strcmp (argv[0] + len - 3, ".gk") != 0)
8829     fatal ("argument to %%:compare-debug-auxbase-opt does not end in .gk");
8830
8831   if (debug_auxbase_opt)
8832     return debug_auxbase_opt;
8833
8834 #define OPT "-auxbase "
8835
8836   len -= 3;
8837   name = (char*) xmalloc (sizeof (OPT) + len);
8838   memcpy (name, OPT, sizeof (OPT) - 1);
8839   memcpy (name + sizeof (OPT) - 1, argv[0], len);
8840   name[sizeof (OPT) - 1 + len] = '\0';
8841
8842 #undef OPT
8843
8844   return name;
8845 }