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