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