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