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