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