gcc/gcc.c

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