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