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