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                   else
2542                     fprintf (stderr, " %s", *j);
2543                 }
2544             }
2545           else
2546             for (j = commands[i].argv; *j; j++)
2547               fprintf (stderr, " %s", *j);
2548
2549           /* Print a pipe symbol after all but the last command.  */
2550           if (i + 1 != n_commands)
2551             fprintf (stderr, " |");
2552           fprintf (stderr, "\n");
2553         }
2554       fflush (stderr);
2555       if (verbose_only_flag != 0)
2556         {
2557           /* verbose_only_flag should act as if the spec was
2558              executed, so increment execution_count before
2559              returning.  This prevents spurious warnings about
2560              unused linker input files, etc.  */
2561           execution_count++;
2562           return 0;
2563         }
2564 #ifdef DEBUG
2565       fnotice (stderr, "\nGo ahead? (y or n) ");
2566       fflush (stderr);
2567       i = getchar ();
2568       if (i != '\n')
2569         while (getchar () != '\n')
2570           ;
2571
2572       if (i != 'y' && i != 'Y')
2573         return 0;
2574 #endif /* DEBUG */
2575     }
2576
2577 #ifdef ENABLE_VALGRIND_CHECKING
2578   /* Run the each command through valgrind.  To simplify prepending the
2579      path to valgrind and the option "-q" (for quiet operation unless
2580      something triggers), we allocate a separate argv array.  */
2581
2582   for (i = 0; i < n_commands; i++)
2583     {
2584       const char **argv;
2585       int argc;
2586       int j;
2587
2588       for (argc = 0; commands[i].argv[argc] != NULL; argc++)
2589         ;
2590
2591       argv = XALLOCAVEC (const char *, argc + 3);
2592
2593       argv[0] = VALGRIND_PATH;
2594       argv[1] = "-q";
2595       for (j = 2; j < argc + 2; j++)
2596         argv[j] = commands[i].argv[j - 2];
2597       argv[j] = NULL;
2598
2599       commands[i].argv = argv;
2600       commands[i].prog = argv[0];
2601     }
2602 #endif
2603
2604   /* Run each piped subprocess.  */
2605
2606   pex = pex_init (PEX_USE_PIPES | ((report_times || report_times_to_file)
2607                                    ? PEX_RECORD_TIMES : 0),
2608                   progname, temp_filename);
2609   if (pex == NULL)
2610     fatal_error ("pex_init failed: %m");
2611
2612   for (i = 0; i < n_commands; i++)
2613     {
2614       const char *errmsg;
2615       int err;
2616       const char *string = commands[i].argv[0];
2617
2618       errmsg = pex_run (pex,
2619                         ((i + 1 == n_commands ? PEX_LAST : 0)
2620                          | (string == commands[i].prog ? PEX_SEARCH : 0)),
2621                         string, CONST_CAST (char **, commands[i].argv),
2622                         NULL, NULL, &err);
2623       if (errmsg != NULL)
2624         {
2625           if (err == 0)
2626             fatal_error (errmsg);
2627           else
2628             {
2629               errno = err;
2630               pfatal_with_name (errmsg);
2631             }
2632         }
2633
2634       if (string != commands[i].prog)
2635         free (CONST_CAST (char *, string));
2636     }
2637
2638   execution_count++;
2639
2640   /* Wait for all the subprocesses to finish.  */
2641
2642   {
2643     int *statuses;
2644     struct pex_time *times = NULL;
2645     int ret_code = 0;
2646
2647     statuses = (int *) alloca (n_commands * sizeof (int));
2648     if (!pex_get_status (pex, n_commands, statuses))
2649       fatal_error ("failed to get exit status: %m");
2650
2651     if (report_times || report_times_to_file)
2652       {
2653         times = (struct pex_time *) alloca (n_commands * sizeof (struct pex_time));
2654         if (!pex_get_times (pex, n_commands, times))
2655           fatal_error ("failed to get process times: %m");
2656       }
2657
2658     pex_free (pex);
2659
2660     for (i = 0; i < n_commands; ++i)
2661       {
2662         int status = statuses[i];
2663
2664         if (WIFSIGNALED (status))
2665           {
2666 #ifdef SIGPIPE
2667             /* SIGPIPE is a special case.  It happens in -pipe mode
2668                when the compiler dies before the preprocessor is done,
2669                or the assembler dies before the compiler is done.
2670                There's generally been an error already, and this is
2671                just fallout.  So don't generate another error unless
2672                we would otherwise have succeeded.  */
2673             if (WTERMSIG (status) == SIGPIPE
2674                 && (signal_count || greatest_status >= MIN_FATAL_STATUS))
2675               {
2676                 signal_count++;
2677                 ret_code = -1;
2678               }
2679             else
2680 #endif
2681               internal_error ("%s (program %s)",
2682                               strsignal (WTERMSIG (status)), commands[i].prog);
2683           }
2684         else if (WIFEXITED (status)
2685                  && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
2686           {
2687             if (WEXITSTATUS (status) > greatest_status)
2688               greatest_status = WEXITSTATUS (status);
2689             ret_code = -1;
2690           }
2691
2692         if (report_times || report_times_to_file)
2693           {
2694             struct pex_time *pt = &times[i];
2695             double ut, st;
2696
2697             ut = ((double) pt->user_seconds
2698                   + (double) pt->user_microseconds / 1.0e6);
2699             st = ((double) pt->system_seconds
2700                   + (double) pt->system_microseconds / 1.0e6);
2701
2702             if (ut + st != 0)
2703               {
2704                 if (report_times)
2705                   fnotice (stderr, "# %s %.2f %.2f\n",
2706                            commands[i].prog, ut, st);
2707
2708                 if (report_times_to_file)
2709                   {
2710                     int c = 0;
2711                     const char *const *j;
2712
2713                     fprintf (report_times_to_file, "%g %g", ut, st);
2714
2715                     for (j = &commands[i].prog; *j; j = &commands[i].argv[++c])
2716                       {
2717                         const char *p;
2718                         for (p = *j; *p; ++p)
2719                           if (*p == '"' || *p == '\\' || *p == '$'
2720                               || ISSPACE (*p))
2721                             break;
2722
2723                         if (*p)
2724                           {
2725                             fprintf (report_times_to_file, " \"");
2726                             for (p = *j; *p; ++p)
2727                               {
2728                                 if (*p == '"' || *p == '\\' || *p == '$')
2729                                   fputc ('\\', report_times_to_file);
2730                                 fputc (*p, report_times_to_file);
2731                               }
2732                             fputc ('"', report_times_to_file);
2733                           }
2734                         else
2735                           fprintf (report_times_to_file, " %s", *j);
2736                       }
2737
2738                     fputc ('\n', report_times_to_file);
2739                   }
2740               }
2741           }
2742       }
2743
2744     return ret_code;
2745   }
2746 }
2747 \f
2748 /* Find all the switches given to us
2749    and make a vector describing them.
2750    The elements of the vector are strings, one per switch given.
2751    If a switch uses following arguments, then the `part1' field
2752    is the switch itself and the `args' field
2753    is a null-terminated vector containing the following arguments.
2754    Bits in the `live_cond' field are:
2755    SWITCH_LIVE to indicate this switch is true in a conditional spec.
2756    SWITCH_FALSE to indicate this switch is overridden by a later switch.
2757    SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
2758    SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored
2759    in all do_spec calls afterwards.  Used for %<S from self specs.
2760    The `validated' field is nonzero if any spec has looked at this switch;
2761    if it remains zero at the end of the run, it must be meaningless.  */
2762
2763 #define SWITCH_LIVE                     (1 << 0)
2764 #define SWITCH_FALSE                    (1 << 1)
2765 #define SWITCH_IGNORE                   (1 << 2)
2766 #define SWITCH_IGNORE_PERMANENTLY       (1 << 3)
2767 #define SWITCH_KEEP_FOR_GCC             (1 << 4)
2768
2769 struct switchstr
2770 {
2771   const char *part1;
2772   const char **args;
2773   unsigned int live_cond;
2774   unsigned char validated;
2775   unsigned char ordering;
2776 };
2777
2778 static struct switchstr *switches;
2779
2780 static int n_switches;
2781
2782 static int n_switches_alloc;
2783
2784 /* Set to zero if -fcompare-debug is disabled, positive if it's
2785    enabled and we're running the first compilation, negative if it's
2786    enabled and we're running the second compilation.  For most of the
2787    time, it's in the range -1..1, but it can be temporarily set to 2
2788    or 3 to indicate that the -fcompare-debug flags didn't come from
2789    the command-line, but rather from the GCC_COMPARE_DEBUG environment
2790    variable, until a synthesized -fcompare-debug flag is added to the
2791    command line.  */
2792 int compare_debug;
2793
2794 /* Set to nonzero if we've seen the -fcompare-debug-second flag.  */
2795 int compare_debug_second;
2796
2797 /* Set to the flags that should be passed to the second compilation in
2798    a -fcompare-debug compilation.  */
2799 const char *compare_debug_opt;
2800
2801 static struct switchstr *switches_debug_check[2];
2802
2803 static int n_switches_debug_check[2];
2804
2805 static int n_switches_alloc_debug_check[2];
2806
2807 static char *debug_check_temp_file[2];
2808
2809 /* Language is one of three things:
2810
2811    1) The name of a real programming language.
2812    2) NULL, indicating that no one has figured out
2813    what it is yet.
2814    3) '*', indicating that the file should be passed
2815    to the linker.  */
2816 struct infile
2817 {
2818   const char *name;
2819   const char *language;
2820   struct compiler *incompiler;
2821   bool compiled;
2822   bool preprocessed;
2823 };
2824
2825 /* Also a vector of input files specified.  */
2826
2827 static struct infile *infiles;
2828
2829 int n_infiles;
2830
2831 static int n_infiles_alloc;
2832
2833 /* True if multiple input files are being compiled to a single
2834    assembly file.  */
2835
2836 static bool combine_inputs;
2837
2838 /* This counts the number of libraries added by lang_specific_driver, so that
2839    we can tell if there were any user supplied any files or libraries.  */
2840
2841 static int added_libraries;
2842
2843 /* And a vector of corresponding output files is made up later.  */
2844
2845 const char **outfiles;
2846 \f
2847 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2848
2849 /* Convert NAME to a new name if it is the standard suffix.  DO_EXE
2850    is true if we should look for an executable suffix.  DO_OBJ
2851    is true if we should look for an object suffix.  */
2852
2853 static const char *
2854 convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
2855                   int do_obj ATTRIBUTE_UNUSED)
2856 {
2857 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2858   int i;
2859 #endif
2860   int len;
2861
2862   if (name == NULL)
2863     return NULL;
2864
2865   len = strlen (name);
2866
2867 #ifdef HAVE_TARGET_OBJECT_SUFFIX
2868   /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj".  */
2869   if (do_obj && len > 2
2870       && name[len - 2] == '.'
2871       && name[len - 1] == 'o')
2872     {
2873       obstack_grow (&obstack, name, len - 2);
2874       obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
2875       name = XOBFINISH (&obstack, const char *);
2876     }
2877 #endif
2878
2879 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2880   /* If there is no filetype, make it the executable suffix (which includes
2881      the ".").  But don't get confused if we have just "-o".  */
2882   if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
2883     return name;
2884
2885   for (i = len - 1; i >= 0; i--)
2886     if (IS_DIR_SEPARATOR (name[i]))
2887       break;
2888
2889   for (i++; i < len; i++)
2890     if (name[i] == '.')
2891       return name;
2892
2893   obstack_grow (&obstack, name, len);
2894   obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
2895                  strlen (TARGET_EXECUTABLE_SUFFIX));
2896   name = XOBFINISH (&obstack, const char *);
2897 #endif
2898
2899   return name;
2900 }
2901 #endif
2902 \f
2903 /* Display the command line switches accepted by gcc.  */
2904 static void
2905 display_help (void)
2906 {
2907   printf (_("Usage: %s [options] file...\n"), progname);
2908   fputs (_("Options:\n"), stdout);
2909
2910   fputs (_("  -pass-exit-codes         Exit with highest error code from a phase\n"), stdout);
2911   fputs (_("  --help                   Display this information\n"), stdout);
2912   fputs (_("  --target-help            Display target specific command line options\n"), stdout);
2913   fputs (_("  --help={target|optimizers|warnings|params|[^]{joined|separate|undocumented}}[,...]\n"), stdout);
2914   fputs (_("                           Display specific types of command line options\n"), stdout);
2915   if (! verbose_flag)
2916     fputs (_("  (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
2917   fputs (_("  --version                Display compiler version information\n"), stdout);
2918   fputs (_("  -dumpspecs               Display all of the built in spec strings\n"), stdout);
2919   fputs (_("  -dumpversion             Display the version of the compiler\n"), stdout);
2920   fputs (_("  -dumpmachine             Display the compiler's target processor\n"), stdout);
2921   fputs (_("  -print-search-dirs       Display the directories in the compiler's search path\n"), stdout);
2922   fputs (_("  -print-libgcc-file-name  Display the name of the compiler's companion library\n"), stdout);
2923   fputs (_("  -print-file-name=<lib>   Display the full path to library <lib>\n"), stdout);
2924   fputs (_("  -print-prog-name=<prog>  Display the full path to compiler component <prog>\n"), stdout);
2925   fputs (_("  -print-multi-directory   Display the root directory for versions of libgcc\n"), stdout);
2926   fputs (_("\
2927   -print-multi-lib         Display the mapping between command line options and\n\
2928                            multiple library search directories\n"), stdout);
2929   fputs (_("  -print-multi-os-directory Display the relative path to OS libraries\n"), stdout);
2930   fputs (_("  -print-sysroot           Display the target libraries directory\n"), stdout);
2931   fputs (_("  -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n"), stdout);
2932   fputs (_("  -Wa,<options>            Pass comma-separated <options> on to the assembler\n"), stdout);
2933   fputs (_("  -Wp,<options>            Pass comma-separated <options> on to the preprocessor\n"), stdout);
2934   fputs (_("  -Wl,<options>            Pass comma-separated <options> on to the linker\n"), stdout);
2935   fputs (_("  -Xassembler <arg>        Pass <arg> on to the assembler\n"), stdout);
2936   fputs (_("  -Xpreprocessor <arg>     Pass <arg> on to the preprocessor\n"), stdout);
2937   fputs (_("  -Xlinker <arg>           Pass <arg> on to the linker\n"), stdout);
2938   fputs (_("  -save-temps              Do not delete intermediate files\n"), stdout);
2939   fputs (_("  -save-temps=<arg>        Do not delete intermediate files\n"), stdout);
2940   fputs (_("\
2941   -no-canonical-prefixes   Do not canonicalize paths when building relative\n\
2942                            prefixes to other gcc components\n"), stdout);
2943   fputs (_("  -pipe                    Use pipes rather than intermediate files\n"), stdout);
2944   fputs (_("  -time                    Time the execution of each subprocess\n"), stdout);
2945   fputs (_("  -specs=<file>            Override built-in specs with the contents of <file>\n"), stdout);
2946   fputs (_("  -std=<standard>          Assume that the input sources are for <standard>\n"), stdout);
2947   fputs (_("\
2948   --sysroot=<directory>    Use <directory> as the root directory for headers\n\
2949                            and libraries\n"), stdout);
2950   fputs (_("  -B <directory>           Add <directory> to the compiler's search paths\n"), stdout);
2951   fputs (_("  -v                       Display the programs invoked by the compiler\n"), stdout);
2952   fputs (_("  -###                     Like -v but options quoted and commands not executed\n"), stdout);
2953   fputs (_("  -E                       Preprocess only; do not compile, assemble or link\n"), stdout);
2954   fputs (_("  -S                       Compile only; do not assemble or link\n"), stdout);
2955   fputs (_("  -c                       Compile and assemble, but do not link\n"), stdout);
2956   fputs (_("  -o <file>                Place the output into <file>\n"), stdout);
2957   fputs (_("\
2958   -x <language>            Specify the language of the following input files\n\
2959                            Permissible languages include: c c++ assembler none\n\
2960                            'none' means revert to the default behavior of\n\
2961                            guessing the language based on the file's extension\n\
2962 "), stdout);
2963
2964   printf (_("\
2965 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
2966  passed on to the various sub-processes invoked by %s.  In order to pass\n\
2967  other options on to these processes the -W<letter> options must be used.\n\
2968 "), progname);
2969
2970   /* The rest of the options are displayed by invocations of the various
2971      sub-processes.  */
2972 }
2973
2974 static void
2975 add_preprocessor_option (const char *option, int len)
2976 {
2977   VEC_safe_push (char_p, heap, preprocessor_options,
2978                  save_string (option, len));
2979 }
2980
2981 static void
2982 add_assembler_option (const char *option, int len)
2983 {
2984   VEC_safe_push (char_p, heap, assembler_options, save_string (option, len));
2985 }
2986
2987 static void
2988 add_linker_option (const char *option, int len)
2989 {
2990   VEC_safe_push (char_p, heap, linker_options, save_string (option, len));
2991 }
2992 \f
2993 /* Allocate space for an input file in infiles.  */
2994
2995 static void
2996 alloc_infile (void)
2997 {
2998   if (n_infiles_alloc == 0)
2999     {
3000       n_infiles_alloc = 16;
3001       infiles = XNEWVEC (struct infile, n_infiles_alloc);
3002     }
3003   else if (n_infiles_alloc == n_infiles)
3004     {
3005       n_infiles_alloc *= 2;
3006       infiles = XRESIZEVEC (struct infile, infiles, n_infiles_alloc);
3007     }
3008 }
3009
3010 /* Store an input file with the given NAME and LANGUAGE in
3011    infiles.  */
3012
3013 static void
3014 add_infile (const char *name, const char *language)
3015 {
3016   alloc_infile ();
3017   infiles[n_infiles].name = name;
3018   infiles[n_infiles++].language = language;
3019 }
3020
3021 /* Allocate space for a switch in switches.  */
3022
3023 static void
3024 alloc_switch (void)
3025 {
3026   if (n_switches_alloc == 0)
3027     {
3028       n_switches_alloc = 16;
3029       switches = XNEWVEC (struct switchstr, n_switches_alloc);
3030     }
3031   else if (n_switches_alloc == n_switches)
3032     {
3033       n_switches_alloc *= 2;
3034       switches = XRESIZEVEC (struct switchstr, switches, n_switches_alloc);
3035     }
3036 }
3037
3038 /* Save an option OPT with N_ARGS arguments in array ARGS, marking it
3039    as validated if VALIDATED.  */
3040
3041 static void
3042 save_switch (const char *opt, size_t n_args, const char *const *args,
3043              bool validated)
3044 {
3045   alloc_switch ();
3046   switches[n_switches].part1 = opt + 1;
3047   if (n_args == 0)
3048     switches[n_switches].args = 0;
3049   else
3050     {
3051       switches[n_switches].args = XNEWVEC (const char *, n_args + 1);
3052       memcpy (switches[n_switches].args, args, n_args * sizeof (const char *));
3053       switches[n_switches].args[n_args] = NULL;
3054     }
3055
3056   switches[n_switches].live_cond = 0;
3057   switches[n_switches].validated = validated;
3058   switches[n_switches].ordering = 0;
3059   n_switches++;
3060 }
3061
3062 /* Handle an option DECODED that is unknown to the option-processing
3063    machinery, but may be known to specs.  */
3064
3065 static bool
3066 driver_unknown_option_callback (const struct cl_decoded_option *decoded)
3067 {
3068   save_switch (decoded->canonical_option[0],
3069                decoded->canonical_option_num_elements - 1,
3070                &decoded->canonical_option[1], false);
3071
3072   return false;
3073 }
3074
3075 /* Handle an option DECODED that is not marked as CL_DRIVER.
3076    LANG_MASK will always be CL_DRIVER.  */
3077
3078 static void
3079 driver_wrong_lang_callback (const struct cl_decoded_option *decoded,
3080                             unsigned int lang_mask ATTRIBUTE_UNUSED)
3081 {
3082   /* At this point, non-driver options are accepted (and expected to
3083      be passed down by specs) unless marked to be rejected by the
3084      driver.  Options to be rejected by the driver but accepted by the
3085      compilers proper are treated just like completely unknown
3086      options.  */
3087   const struct cl_option *option = &cl_options[decoded->opt_index];
3088
3089   if (option->flags & CL_REJECT_DRIVER)
3090     error ("unrecognized command line option %qs",
3091            decoded->orig_option_with_args_text);
3092   else
3093     driver_unknown_option_callback (decoded);
3094 }
3095
3096 /* Note that an option (index OPT_INDEX, argument ARG, value VALUE)
3097    has been successfully handled with a handler for mask MASK.  */
3098
3099 static void
3100 driver_post_handling_callback (const struct cl_decoded_option *decoded ATTRIBUTE_UNUSED,
3101                                unsigned int mask ATTRIBUTE_UNUSED)
3102 {
3103   /* Nothing to do here.  */
3104 }
3105
3106 static const char *spec_lang = 0;
3107 static int last_language_n_infiles;
3108
3109 /* Handle a driver option; arguments and return value as for
3110    handle_option.  */
3111
3112 static bool
3113 driver_handle_option (struct gcc_options *opts,
3114                       struct gcc_options *opts_set,
3115                       const struct cl_decoded_option *decoded,
3116                       unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
3117                       location_t loc,
3118                       const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED,
3119                       diagnostic_context *dc)
3120 {
3121   size_t opt_index = decoded->opt_index;
3122   const char *arg = decoded->arg;
3123   const char *compare_debug_replacement_opt;
3124   int value = decoded->value;
3125   bool validated = false;
3126   bool do_save = true;
3127
3128   gcc_assert (opts == &global_options);
3129   gcc_assert (opts_set == &global_options_set);
3130   gcc_assert (kind == DK_UNSPECIFIED);
3131   gcc_assert (loc == UNKNOWN_LOCATION);
3132   gcc_assert (dc == global_dc);
3133
3134   switch (opt_index)
3135     {
3136     case OPT_dumpspecs:
3137       {
3138         struct spec_list *sl;
3139         init_spec ();
3140         for (sl = specs; sl; sl = sl->next)
3141           printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3142         if (link_command_spec)
3143           printf ("*link_command:\n%s\n\n", link_command_spec);
3144         exit (0);
3145       }
3146
3147     case OPT_dumpversion:
3148       printf ("%s\n", spec_version);
3149       exit (0);
3150
3151     case OPT_dumpmachine:
3152       printf ("%s\n", spec_machine);
3153       exit (0);
3154
3155     case OPT__version:
3156       print_version = 1;
3157
3158       /* CPP driver cannot obtain switch from cc1_options.  */
3159       if (is_cpp_driver)
3160         add_preprocessor_option ("--version", strlen ("--version"));
3161       add_assembler_option ("--version", strlen ("--version"));
3162       add_linker_option ("--version", strlen ("--version"));
3163       break;
3164
3165     case OPT__help:
3166       print_help_list = 1;
3167
3168       /* CPP driver cannot obtain switch from cc1_options.  */
3169       if (is_cpp_driver)
3170         add_preprocessor_option ("--help", 6);
3171       add_assembler_option ("--help", 6);
3172       add_linker_option ("--help", 6);
3173       break;
3174
3175     case OPT__help_:
3176       print_subprocess_help = 2;
3177       break;
3178
3179     case OPT__target_help:
3180       print_subprocess_help = 1;
3181
3182       /* CPP driver cannot obtain switch from cc1_options.  */
3183       if (is_cpp_driver)
3184         add_preprocessor_option ("--target-help", 13);
3185       add_assembler_option ("--target-help", 13);
3186       add_linker_option ("--target-help", 13);
3187       break;
3188
3189     case OPT_pass_exit_codes:
3190     case OPT_print_search_dirs:
3191     case OPT_print_file_name_:
3192     case OPT_print_prog_name_:
3193     case OPT_print_multi_lib:
3194     case OPT_print_multi_directory:
3195     case OPT_print_sysroot:
3196     case OPT_print_multi_os_directory:
3197     case OPT_print_sysroot_headers_suffix:
3198     case OPT_time:
3199     case OPT_wrapper:
3200       /* These options set the variables specified in common.opt
3201          automatically, and do not need to be saved for spec
3202          processing.  */
3203       do_save = false;
3204       break;
3205
3206     case OPT_print_libgcc_file_name:
3207       print_file_name = "libgcc.a";
3208       do_save = false;
3209       break;
3210
3211     case OPT_fcompare_debug_second:
3212       compare_debug_second = 1;
3213       break;
3214
3215     case OPT_fcompare_debug:
3216       switch (value)
3217         {
3218         case 0:
3219           compare_debug_replacement_opt = "-fcompare-debug=";
3220           arg = "";
3221           goto compare_debug_with_arg;
3222
3223         case 1:
3224           compare_debug_replacement_opt = "-fcompare-debug=-gtoggle";
3225           arg = "-gtoggle";
3226           goto compare_debug_with_arg;
3227
3228         default:
3229           gcc_unreachable ();
3230         }
3231       break;
3232
3233     case OPT_fcompare_debug_:
3234       compare_debug_replacement_opt = decoded->canonical_option[0];
3235     compare_debug_with_arg:
3236       gcc_assert (decoded->canonical_option_num_elements == 1);
3237       gcc_assert (arg != NULL);
3238       if (arg)
3239         compare_debug = 1;
3240       else
3241         compare_debug = -1;
3242       if (compare_debug < 0)
3243         compare_debug_opt = NULL;
3244       else
3245         compare_debug_opt = arg;
3246       save_switch (compare_debug_replacement_opt, 0, NULL, validated);
3247       return true;
3248
3249     case OPT_Wa_:
3250       {
3251         int prev, j;
3252         /* Pass the rest of this option to the assembler.  */
3253
3254         /* Split the argument at commas.  */
3255         prev = 0;
3256         for (j = 0; arg[j]; j++)
3257           if (arg[j] == ',')
3258             {
3259               add_assembler_option (arg + prev, j - prev);
3260               prev = j + 1;
3261             }
3262
3263         /* Record the part after the last comma.  */
3264         add_assembler_option (arg + prev, j - prev);
3265       }
3266       do_save = false;
3267       break;
3268
3269     case OPT_Wp_:
3270       {
3271         int prev, j;
3272         /* Pass the rest of this option to the preprocessor.  */
3273
3274         /* Split the argument at commas.  */
3275         prev = 0;
3276         for (j = 0; arg[j]; j++)
3277           if (arg[j] == ',')
3278             {
3279               add_preprocessor_option (arg + prev, j - prev);
3280               prev = j + 1;
3281             }
3282
3283         /* Record the part after the last comma.  */
3284         add_preprocessor_option (arg + prev, j - prev);
3285       }
3286       do_save = false;
3287       break;
3288
3289     case OPT_Wl_:
3290       {
3291         int prev, j;
3292         /* Split the argument at commas.  */
3293         prev = 0;
3294         for (j = 0; arg[j]; j++)
3295           if (arg[j] == ',')
3296             {
3297               add_infile (save_string (arg + prev, j - prev), "*");
3298               prev = j + 1;
3299             }
3300         /* Record the part after the last comma.  */
3301         add_infile (arg + prev, "*");
3302       }
3303       do_save = false;
3304       break;
3305
3306     case OPT_Xlinker:
3307       add_infile (arg, "*");
3308       do_save = false;
3309       break;
3310
3311     case OPT_Xpreprocessor:
3312       add_preprocessor_option (arg, strlen (arg));
3313       do_save = false;
3314       break;
3315
3316     case OPT_Xassembler:
3317       add_assembler_option (arg, strlen (arg));
3318       do_save = false;
3319       break;
3320
3321     case OPT_l:
3322       /* POSIX allows separation of -l and the lib arg; canonicalize
3323          by concatenating -l with its arg */
3324       add_infile (concat ("-l", arg, NULL), "*");
3325       do_save = false;
3326       break;
3327
3328     case OPT_L:
3329       /* Similarly, canonicalize -L for linkers that may not accept
3330          separate arguments.  */
3331       save_switch (concat ("-L", arg, NULL), 0, NULL, validated);
3332       return true;
3333
3334     case OPT_F:
3335       /* Likewise -F.  */
3336       save_switch (concat ("-F", arg, NULL), 0, NULL, validated);
3337       return true;
3338
3339     case OPT_save_temps:
3340       save_temps_flag = SAVE_TEMPS_CWD;
3341       validated = true;
3342       break;
3343
3344     case OPT_save_temps_:
3345       if (strcmp (arg, "cwd") == 0)
3346         save_temps_flag = SAVE_TEMPS_CWD;
3347       else if (strcmp (arg, "obj") == 0
3348                || strcmp (arg, "object") == 0)
3349         save_temps_flag = SAVE_TEMPS_OBJ;
3350       else
3351         fatal_error ("%qs is an unknown -save-temps option",
3352                      decoded->orig_option_with_args_text);
3353       break;
3354
3355     case OPT_no_canonical_prefixes:
3356       /* Already handled as a special case, so ignored here.  */
3357       do_save = false;
3358       break;
3359
3360     case OPT_pipe:
3361       validated = true;
3362       /* These options set the variables specified in common.opt
3363          automatically, but do need to be saved for spec
3364          processing.  */
3365       break;
3366
3367     case OPT_specs_:
3368       {
3369         struct user_specs *user = XNEW (struct user_specs);
3370
3371         user->next = (struct user_specs *) 0;
3372         user->filename = arg;
3373         if (user_specs_tail)
3374           user_specs_tail->next = user;
3375         else
3376           user_specs_head = user;
3377         user_specs_tail = user;
3378       }
3379       do_save = false;
3380       break;
3381
3382     case OPT__sysroot_:
3383       target_system_root = arg;
3384       target_system_root_changed = 1;
3385       do_save = false;
3386       break;
3387
3388     case OPT_time_:
3389       if (report_times_to_file)
3390         fclose (report_times_to_file);
3391       report_times_to_file = fopen (arg, "a");
3392       do_save = false;
3393       break;
3394
3395     case OPT____:
3396       /* "-###"
3397          This is similar to -v except that there is no execution
3398          of the commands and the echoed arguments are quoted.  It
3399          is intended for use in shell scripts to capture the
3400          driver-generated command line.  */
3401       verbose_only_flag++;
3402       verbose_flag = 1;
3403       do_save = false;
3404       break;
3405
3406     case OPT_B:
3407       {
3408         size_t len = strlen (arg);
3409
3410         /* Catch the case where the user has forgotten to append a
3411            directory separator to the path.  Note, they may be using
3412            -B to add an executable name prefix, eg "i386-elf-", in
3413            order to distinguish between multiple installations of
3414            GCC in the same directory.  Hence we must check to see
3415            if appending a directory separator actually makes a
3416            valid directory name.  */
3417         if (!IS_DIR_SEPARATOR (arg[len - 1])
3418             && is_directory (arg, false))
3419           {
3420             char *tmp = XNEWVEC (char, len + 2);
3421             strcpy (tmp, arg);
3422             tmp[len] = DIR_SEPARATOR;
3423             tmp[++len] = 0;
3424             arg = tmp;
3425           }
3426
3427         add_prefix (&exec_prefixes, arg, NULL,
3428                     PREFIX_PRIORITY_B_OPT, 0, 0);
3429         add_prefix (&startfile_prefixes, arg, NULL,
3430                     PREFIX_PRIORITY_B_OPT, 0, 0);
3431         add_prefix (&include_prefixes, arg, NULL,
3432                     PREFIX_PRIORITY_B_OPT, 0, 0);
3433       }
3434       validated = true;
3435       break;
3436
3437     case OPT_x:
3438       spec_lang = arg;
3439       if (!strcmp (spec_lang, "none"))
3440         /* Suppress the warning if -xnone comes after the last input
3441            file, because alternate command interfaces like g++ might
3442            find it useful to place -xnone after each input file.  */
3443         spec_lang = 0;
3444       else
3445         last_language_n_infiles = n_infiles;
3446       do_save = false;
3447       break;
3448
3449     case OPT_o:
3450       have_o = 1;
3451 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3452       arg = convert_filename (arg, ! have_c, 0);
3453 #endif
3454       /* Save the output name in case -save-temps=obj was used.  */
3455       save_temps_prefix = xstrdup (arg);
3456       /* On some systems, ld cannot handle "-o" without a space.  So
3457          split the option from its argument.  */
3458       save_switch ("-o", 1, &arg, validated);
3459       return true;
3460
3461     case OPT_static_libgcc:
3462     case OPT_shared_libgcc:
3463     case OPT_static_libgfortran:
3464     case OPT_static_libstdc__:
3465       /* These are always valid, since gcc.c itself understands the
3466          first two, gfortranspec.c understands -static-libgfortran and
3467          g++spec.c understands -static-libstdc++ */
3468       validated = true;
3469       break;
3470
3471     default:
3472       /* Various driver options need no special processing at this
3473          point, having been handled in a prescan above or being
3474          handled by specs.  */
3475       break;
3476     }
3477
3478   if (do_save)
3479     save_switch (decoded->canonical_option[0],
3480                  decoded->canonical_option_num_elements - 1,
3481                  &decoded->canonical_option[1], validated);
3482   return true;
3483 }
3484
3485 /* Put the driver's standard set of option handlers in *HANDLERS.  */
3486
3487 static void
3488 set_option_handlers (struct cl_option_handlers *handlers)
3489 {
3490   handlers->unknown_option_callback = driver_unknown_option_callback;
3491   handlers->wrong_lang_callback = driver_wrong_lang_callback;
3492   handlers->post_handling_callback = driver_post_handling_callback;
3493   handlers->num_handlers = 1;
3494   handlers->handlers[0].handler = driver_handle_option;
3495   handlers->handlers[0].mask = CL_DRIVER;
3496 }
3497
3498 /* Create the vector `switches' and its contents.
3499    Store its length in `n_switches'.  */
3500
3501 static void
3502 process_command (unsigned int decoded_options_count,
3503                  struct cl_decoded_option *decoded_options)
3504 {
3505   const char *temp;
3506   char *temp1;
3507   const char *tooldir_prefix;
3508   char *(*get_relative_prefix) (const char *, const char *,
3509                                 const char *) = NULL;
3510   struct cl_option_handlers handlers;
3511   unsigned int j;
3512
3513   gcc_exec_prefix = getenv ("GCC_EXEC_PREFIX");
3514
3515   n_switches = 0;
3516   n_infiles = 0;
3517   added_libraries = 0;
3518
3519   /* Figure compiler version from version string.  */
3520
3521   compiler_version = temp1 = xstrdup (version_string);
3522
3523   for (; *temp1; ++temp1)
3524     {
3525       if (*temp1 == ' ')
3526         {
3527           *temp1 = '\0';
3528           break;
3529         }
3530     }
3531
3532   /* Handle any -no-canonical-prefixes flag early, to assign the function
3533      that builds relative prefixes.  This function creates default search
3534      paths that are needed later in normal option handling.  */
3535
3536   for (j = 1; j < decoded_options_count; j++)
3537     {
3538       if (decoded_options[j].opt_index == OPT_no_canonical_prefixes)
3539         {
3540           get_relative_prefix = make_relative_prefix_ignore_links;
3541           break;
3542         }
3543     }
3544   if (! get_relative_prefix)
3545     get_relative_prefix = make_relative_prefix;
3546
3547   /* Set up the default search paths.  If there is no GCC_EXEC_PREFIX,
3548      see if we can create it from the pathname specified in
3549      decoded_options[0].arg.  */
3550
3551   gcc_libexec_prefix = standard_libexec_prefix;
3552 #ifndef VMS
3553   /* FIXME: make_relative_prefix doesn't yet work for VMS.  */
3554   if (!gcc_exec_prefix)
3555     {
3556       gcc_exec_prefix = get_relative_prefix (decoded_options[0].arg,
3557                                              standard_bindir_prefix,
3558                                              standard_exec_prefix);
3559       gcc_libexec_prefix = get_relative_prefix (decoded_options[0].arg,
3560                                              standard_bindir_prefix,
3561                                              standard_libexec_prefix);
3562       if (gcc_exec_prefix)
3563         xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
3564     }
3565   else
3566     {
3567       /* make_relative_prefix requires a program name, but
3568          GCC_EXEC_PREFIX is typically a directory name with a trailing
3569          / (which is ignored by make_relative_prefix), so append a
3570          program name.  */
3571       char *tmp_prefix = concat (gcc_exec_prefix, "gcc", NULL);
3572       gcc_libexec_prefix = get_relative_prefix (tmp_prefix,
3573                                                 standard_exec_prefix,
3574                                                 standard_libexec_prefix);
3575
3576       /* The path is unrelocated, so fallback to the original setting.  */
3577       if (!gcc_libexec_prefix)
3578         gcc_libexec_prefix = standard_libexec_prefix;
3579
3580       free (tmp_prefix);
3581     }
3582 #else
3583 #endif
3584   /* From this point onward, gcc_exec_prefix is non-null if the toolchain
3585      is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
3586      or an automatically created GCC_EXEC_PREFIX from
3587      decoded_options[0].arg.  */
3588
3589   /* Do language-specific adjustment/addition of flags.  */
3590   lang_specific_driver (&decoded_options, &decoded_options_count,
3591                         &added_libraries);
3592
3593   if (gcc_exec_prefix)
3594     {
3595       int len = strlen (gcc_exec_prefix);
3596
3597       if (len > (int) sizeof ("/lib/gcc/") - 1
3598           && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
3599         {
3600           temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1;
3601           if (IS_DIR_SEPARATOR (*temp)
3602               && strncmp (temp + 1, "lib", 3) == 0
3603               && IS_DIR_SEPARATOR (temp[4])
3604               && strncmp (temp + 5, "gcc", 3) == 0)
3605             len -= sizeof ("/lib/gcc/") - 1;
3606         }
3607
3608       set_std_prefix (gcc_exec_prefix, len);
3609       add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC",
3610                   PREFIX_PRIORITY_LAST, 0, 0);
3611       add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
3612                   PREFIX_PRIORITY_LAST, 0, 0);
3613     }
3614
3615   /* COMPILER_PATH and LIBRARY_PATH have values
3616      that are lists of directory names with colons.  */
3617
3618   temp = getenv ("COMPILER_PATH");
3619   if (temp)
3620     {
3621       const char *startp, *endp;
3622       char *nstore = (char *) alloca (strlen (temp) + 3);
3623
3624       startp = endp = temp;
3625       while (1)
3626         {
3627           if (*endp == PATH_SEPARATOR || *endp == 0)
3628             {
3629               strncpy (nstore, startp, endp - startp);
3630               if (endp == startp)
3631                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3632               else if (!IS_DIR_SEPARATOR (endp[-1]))
3633                 {
3634                   nstore[endp - startp] = DIR_SEPARATOR;
3635                   nstore[endp - startp + 1] = 0;
3636                 }
3637               else
3638                 nstore[endp - startp] = 0;
3639               add_prefix (&exec_prefixes, nstore, 0,
3640                           PREFIX_PRIORITY_LAST, 0, 0);
3641               add_prefix (&include_prefixes, nstore, 0,
3642                           PREFIX_PRIORITY_LAST, 0, 0);
3643               if (*endp == 0)
3644                 break;
3645               endp = startp = endp + 1;
3646             }
3647           else
3648             endp++;
3649         }
3650     }
3651
3652   temp = getenv (LIBRARY_PATH_ENV);
3653   if (temp && *cross_compile == '0')
3654     {
3655       const char *startp, *endp;
3656       char *nstore = (char *) alloca (strlen (temp) + 3);
3657
3658       startp = endp = temp;
3659       while (1)
3660         {
3661           if (*endp == PATH_SEPARATOR || *endp == 0)
3662             {
3663               strncpy (nstore, startp, endp - startp);
3664               if (endp == startp)
3665                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3666               else if (!IS_DIR_SEPARATOR (endp[-1]))
3667                 {
3668                   nstore[endp - startp] = DIR_SEPARATOR;
3669                   nstore[endp - startp + 1] = 0;
3670                 }
3671               else
3672                 nstore[endp - startp] = 0;
3673               add_prefix (&startfile_prefixes, nstore, NULL,
3674                           PREFIX_PRIORITY_LAST, 0, 1);
3675               if (*endp == 0)
3676                 break;
3677               endp = startp = endp + 1;
3678             }
3679           else
3680             endp++;
3681         }
3682     }
3683
3684   /* Use LPATH like LIBRARY_PATH (for the CMU build program).  */
3685   temp = getenv ("LPATH");
3686   if (temp && *cross_compile == '0')
3687     {
3688       const char *startp, *endp;
3689       char *nstore = (char *) alloca (strlen (temp) + 3);
3690
3691       startp = endp = temp;
3692       while (1)
3693         {
3694           if (*endp == PATH_SEPARATOR || *endp == 0)
3695             {
3696               strncpy (nstore, startp, endp - startp);
3697               if (endp == startp)
3698                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3699               else if (!IS_DIR_SEPARATOR (endp[-1]))
3700                 {
3701                   nstore[endp - startp] = DIR_SEPARATOR;
3702                   nstore[endp - startp + 1] = 0;
3703                 }
3704               else
3705                 nstore[endp - startp] = 0;
3706               add_prefix (&startfile_prefixes, nstore, NULL,
3707                           PREFIX_PRIORITY_LAST, 0, 1);
3708               if (*endp == 0)
3709                 break;
3710               endp = startp = endp + 1;
3711             }
3712           else
3713             endp++;
3714         }
3715     }
3716
3717   /* Process the options and store input files and switches in their
3718      vectors.  */
3719
3720   last_language_n_infiles = -1;
3721
3722   set_option_handlers (&handlers);
3723
3724   for (j = 1; j < decoded_options_count; j++)
3725     {
3726       switch (decoded_options[j].opt_index)
3727         {
3728         case OPT_S:
3729         case OPT_c:
3730         case OPT_E:
3731           have_c = 1;
3732           break;
3733         }
3734       if (have_c)
3735         break;
3736     }
3737
3738   for (j = 1; j < decoded_options_count; j++)
3739     {
3740       if (decoded_options[j].opt_index == OPT_SPECIAL_input_file)
3741         {
3742           const char *arg = decoded_options[j].arg;
3743           const char *p = strrchr (arg, '@');
3744           char *fname;
3745           long offset;
3746           int consumed;
3747 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3748           arg = convert_filename (arg, 0, access (arg, F_OK));
3749 #endif
3750           /* For LTO static archive support we handle input file
3751              specifications that are composed of a filename and
3752              an offset like FNAME@OFFSET.  */
3753           if (p
3754               && p != arg
3755               && sscanf (p, "@%li%n", &offset, &consumed) >= 1
3756               && strlen (p) == (unsigned int)consumed)
3757             {
3758               fname = (char *)xmalloc (p - arg + 1);
3759               memcpy (fname, arg, p - arg);
3760               fname[p - arg] = '\0';
3761               /* Only accept non-stdin and existing FNAME parts, otherwise
3762                  try with the full name.  */
3763               if (strcmp (fname, "-") == 0 || access (fname, F_OK) < 0)
3764                 {
3765                   free (fname);
3766                   fname = xstrdup (arg);
3767                 }
3768             }
3769           else
3770             fname = xstrdup (arg);
3771
3772           if (strcmp (fname, "-") != 0 && access (fname, F_OK) < 0)
3773             perror_with_name (fname);
3774           else
3775             add_infile (arg, spec_lang);
3776
3777           free (fname);
3778           continue;
3779         }
3780
3781       read_cmdline_option (&global_options, &global_options_set,
3782                            decoded_options + j, UNKNOWN_LOCATION,
3783                            CL_DRIVER, &handlers, global_dc);
3784     }
3785
3786   /* If -save-temps=obj and -o name, create the prefix to use for %b.
3787      Otherwise just make -save-temps=obj the same as -save-temps=cwd.  */
3788   if (save_temps_flag == SAVE_TEMPS_OBJ && save_temps_prefix != NULL)
3789     {
3790       save_temps_length = strlen (save_temps_prefix);
3791       temp = strrchr (lbasename (save_temps_prefix), '.');
3792       if (temp)
3793         {
3794           save_temps_length -= strlen (temp);
3795           save_temps_prefix[save_temps_length] = '\0';
3796         }
3797
3798     }
3799   else if (save_temps_prefix != NULL)
3800     {
3801       free (save_temps_prefix);
3802       save_temps_prefix = NULL;
3803     }
3804
3805   if (save_temps_flag && use_pipes)
3806     {
3807       /* -save-temps overrides -pipe, so that temp files are produced */
3808       if (save_temps_flag)
3809         warning (0, "-pipe ignored because -save-temps specified");
3810       use_pipes = 0;
3811     }
3812
3813   if (!compare_debug)
3814     {
3815       const char *gcd = getenv ("GCC_COMPARE_DEBUG");
3816
3817       if (gcd && gcd[0] == '-')
3818         {
3819           compare_debug = 2;
3820           compare_debug_opt = gcd;
3821         }
3822       else if (gcd && *gcd && strcmp (gcd, "0"))
3823         {
3824           compare_debug = 3;
3825           compare_debug_opt = "-gtoggle";
3826         }
3827     }
3828   else if (compare_debug < 0)
3829     {
3830       compare_debug = 0;
3831       gcc_assert (!compare_debug_opt);
3832     }
3833
3834   /* Set up the search paths.  We add directories that we expect to
3835      contain GNU Toolchain components before directories specified by
3836      the machine description so that we will find GNU components (like
3837      the GNU assembler) before those of the host system.  */
3838
3839   /* If we don't know where the toolchain has been installed, use the
3840      configured-in locations.  */
3841   if (!gcc_exec_prefix)
3842     {
3843 #ifndef OS2
3844       add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC",
3845                   PREFIX_PRIORITY_LAST, 1, 0);
3846       add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS",
3847                   PREFIX_PRIORITY_LAST, 2, 0);
3848       add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
3849                   PREFIX_PRIORITY_LAST, 2, 0);
3850 #endif
3851       add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
3852                   PREFIX_PRIORITY_LAST, 1, 0);
3853     }
3854
3855   gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix));
3856   tooldir_prefix = concat (tooldir_base_prefix, spec_machine,
3857                            dir_separator_str, NULL);
3858
3859   /* Look for tools relative to the location from which the driver is
3860      running, or, if that is not available, the configured prefix.  */
3861   tooldir_prefix
3862     = concat (gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
3863               spec_machine, dir_separator_str,
3864               spec_version, dir_separator_str, tooldir_prefix, NULL);
3865
3866   add_prefix (&exec_prefixes,
3867               concat (tooldir_prefix, "bin", dir_separator_str, NULL),
3868               "BINUTILS", PREFIX_PRIORITY_LAST, 0, 0);
3869   add_prefix (&startfile_prefixes,
3870               concat (tooldir_prefix, "lib", dir_separator_str, NULL),
3871               "BINUTILS", PREFIX_PRIORITY_LAST, 0, 1);
3872
3873 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
3874   /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
3875      then consider it to relocate with the rest of the GCC installation
3876      if GCC_EXEC_PREFIX is set.
3877      ``make_relative_prefix'' is not compiled for VMS, so don't call it.  */
3878   if (target_system_root && !target_system_root_changed && gcc_exec_prefix)
3879     {
3880       char *tmp_prefix = get_relative_prefix (decoded_options[0].arg,
3881                                               standard_bindir_prefix,
3882                                               target_system_root);
3883       if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0)
3884         {
3885           target_system_root = tmp_prefix;
3886           target_system_root_changed = 1;
3887         }
3888     }
3889 #endif
3890
3891   /* More prefixes are enabled in main, after we read the specs file
3892      and determine whether this is cross-compilation or not.  */
3893
3894   if (n_infiles == last_language_n_infiles && spec_lang != 0)
3895     warning (0, "%<-x %s%> after last input file has no effect", spec_lang);
3896
3897   if (compare_debug == 2 || compare_debug == 3)
3898     {
3899       alloc_switch ();
3900       switches[n_switches].part1 = concat ("fcompare-debug=",
3901                                            compare_debug_opt,
3902                                            NULL);
3903       switches[n_switches].args = 0;
3904       switches[n_switches].live_cond = 0;
3905       switches[n_switches].validated = 0;
3906       switches[n_switches].ordering = 0;
3907       n_switches++;
3908       compare_debug = 1;
3909     }
3910
3911   /* Ensure we only invoke each subprocess once.  */
3912   if (print_subprocess_help || print_help_list || print_version)
3913     {
3914       n_infiles = 0;
3915
3916       /* Create a dummy input file, so that we can pass
3917          the help option on to the various sub-processes.  */
3918       add_infile ("help-dummy", "c");
3919     }
3920
3921   alloc_switch ();
3922   switches[n_switches].part1 = 0;
3923   alloc_infile ();
3924   infiles[n_infiles].name = 0;
3925 }
3926
3927 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
3928    and place that in the environment.  */
3929
3930 static void
3931 set_collect_gcc_options (void)
3932 {
3933   int i;
3934   int first_time;
3935
3936   /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
3937      the compiler.  */
3938   obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
3939                 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
3940
3941   first_time = TRUE;
3942   for (i = 0; (int) i < n_switches; i++)
3943     {
3944       const char *const *args;
3945       const char *p, *q;
3946       if (!first_time)
3947         obstack_grow (&collect_obstack, " ", 1);
3948
3949       first_time = FALSE;
3950
3951       /* Ignore elided switches.  */
3952       if ((switches[i].live_cond
3953            & (SWITCH_IGNORE | SWITCH_KEEP_FOR_GCC))
3954           == SWITCH_IGNORE)
3955         continue;
3956
3957       obstack_grow (&collect_obstack, "'-", 2);
3958       q = switches[i].part1;
3959       while ((p = strchr (q, '\'')))
3960         {
3961           obstack_grow (&collect_obstack, q, p - q);
3962           obstack_grow (&collect_obstack, "'\\''", 4);
3963           q = ++p;
3964         }
3965       obstack_grow (&collect_obstack, q, strlen (q));
3966       obstack_grow (&collect_obstack, "'", 1);
3967
3968       for (args = switches[i].args; args && *args; args++)
3969         {
3970           obstack_grow (&collect_obstack, " '", 2);
3971           q = *args;
3972           while ((p = strchr (q, '\'')))
3973             {
3974               obstack_grow (&collect_obstack, q, p - q);
3975               obstack_grow (&collect_obstack, "'\\''", 4);
3976               q = ++p;
3977             }
3978           obstack_grow (&collect_obstack, q, strlen (q));
3979           obstack_grow (&collect_obstack, "'", 1);
3980         }
3981     }
3982   obstack_grow (&collect_obstack, "\0", 1);
3983   xputenv (XOBFINISH (&collect_obstack, char *));
3984 }
3985 \f
3986 /* Process a spec string, accumulating and running commands.  */
3987
3988 /* These variables describe the input file name.
3989    input_file_number is the index on outfiles of this file,
3990    so that the output file name can be stored for later use by %o.
3991    input_basename is the start of the part of the input file
3992    sans all directory names, and basename_length is the number
3993    of characters starting there excluding the suffix .c or whatever.  */
3994
3995 static const char *gcc_input_filename;
3996 static int input_file_number;
3997 size_t input_filename_length;
3998 static int basename_length;
3999 static int suffixed_basename_length;
4000 static const char *input_basename;
4001 static const char *input_suffix;
4002 #ifndef HOST_LACKS_INODE_NUMBERS
4003 static struct stat input_stat;
4004 #endif
4005 static int input_stat_set;
4006
4007 /* The compiler used to process the current input file.  */
4008 static struct compiler *input_file_compiler;
4009
4010 /* These are variables used within do_spec and do_spec_1.  */
4011
4012 /* Nonzero if an arg has been started and not yet terminated
4013    (with space, tab or newline).  */
4014 static int arg_going;
4015
4016 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4017    is a temporary file name.  */
4018 static int delete_this_arg;
4019
4020 /* Nonzero means %w has been seen; the next arg to be terminated
4021    is the output file name of this compilation.  */
4022 static int this_is_output_file;
4023
4024 /* Nonzero means %s has been seen; the next arg to be terminated
4025    is the name of a library file and we should try the standard
4026    search dirs for it.  */
4027 static int this_is_library_file;
4028
4029 /* Nonzero means %T has been seen; the next arg to be terminated
4030    is the name of a linker script and we should try all of the
4031    standard search dirs for it.  If it is found insert a --script
4032    command line switch and then substitute the full path in place,
4033    otherwise generate an error message.  */
4034 static int this_is_linker_script;
4035
4036 /* Nonzero means that the input of this command is coming from a pipe.  */
4037 static int input_from_pipe;
4038
4039 /* Nonnull means substitute this for any suffix when outputting a switches
4040    arguments.  */
4041 static const char *suffix_subst;
4042
4043 /* If there is an argument being accumulated, terminate it and store it.  */
4044
4045 static void
4046 end_going_arg (void)
4047 {
4048   if (arg_going)
4049     {
4050       const char *string;
4051
4052       obstack_1grow (&obstack, 0);
4053       string = XOBFINISH (&obstack, const char *);
4054       if (this_is_library_file)
4055         string = find_file (string);
4056       if (this_is_linker_script)
4057         {
4058           char * full_script_path = find_a_file (&startfile_prefixes, string, R_OK, true);
4059
4060           if (full_script_path == NULL)
4061             {
4062               error ("unable to locate default linker script %qs in the library search paths", string);
4063               /* Script was not found on search path.  */
4064               return;
4065             }
4066           store_arg ("--script", false, false);
4067           string = full_script_path;
4068         }
4069       store_arg (string, delete_this_arg, this_is_output_file);
4070       if (this_is_output_file)
4071         outfiles[input_file_number] = string;
4072       arg_going = 0;
4073     }
4074 }
4075
4076
4077 /* Parse the WRAPPER string which is a comma separated list of the command line
4078    and insert them into the beginning of argbuf.  */
4079
4080 static void
4081 insert_wrapper (const char *wrapper)
4082 {
4083   int n = 0;
4084   int i;
4085   char *buf = xstrdup (wrapper);
4086   char *p = buf;
4087   unsigned int old_length = VEC_length (const_char_p, argbuf);
4088
4089   do
4090     {
4091       n++;
4092       while (*p == ',')
4093         p++;
4094     }
4095   while ((p = strchr (p, ',')) != NULL);
4096
4097   VEC_safe_grow (const_char_p, heap, argbuf, old_length + n);
4098   memmove (VEC_address (const_char_p, argbuf) + n,
4099            VEC_address (const_char_p, argbuf),
4100            old_length * sizeof (const_char_p));
4101
4102   i = 0;
4103   p = buf;
4104   do
4105     {
4106       while (*p == ',')
4107         {
4108           *p = 0;
4109           p++;
4110         }
4111       VEC_replace (const_char_p, argbuf, i, p);
4112       i++;
4113     }
4114   while ((p = strchr (p, ',')) != NULL);
4115   gcc_assert (i == n);
4116 }
4117
4118 /* Process the spec SPEC and run the commands specified therein.
4119    Returns 0 if the spec is successfully processed; -1 if failed.  */
4120
4121 int
4122 do_spec (const char *spec)
4123 {
4124   int value;
4125
4126   value = do_spec_2 (spec);
4127
4128   /* Force out any unfinished command.
4129      If -pipe, this forces out the last command if it ended in `|'.  */
4130   if (value == 0)
4131     {
4132       if (VEC_length (const_char_p, argbuf) > 0
4133           && !strcmp (VEC_last (const_char_p, argbuf), "|"))
4134         VEC_pop (const_char_p, argbuf);
4135
4136       set_collect_gcc_options ();
4137
4138       if (VEC_length (const_char_p, argbuf) > 0)
4139         value = execute ();
4140     }
4141
4142   return value;
4143 }
4144
4145 static int
4146 do_spec_2 (const char *spec)
4147 {
4148   int result;
4149
4150   clear_args ();
4151   arg_going = 0;
4152   delete_this_arg = 0;
4153   this_is_output_file = 0;
4154   this_is_library_file = 0;
4155   this_is_linker_script = 0;
4156   input_from_pipe = 0;
4157   suffix_subst = NULL;
4158
4159   result = do_spec_1 (spec, 0, NULL);
4160
4161   end_going_arg ();
4162
4163   return result;
4164 }
4165
4166
4167 /* Process the given spec string and add any new options to the end
4168    of the switches/n_switches array.  */
4169
4170 static void
4171 do_option_spec (const char *name, const char *spec)
4172 {
4173   unsigned int i, value_count, value_len;
4174   const char *p, *q, *value;
4175   char *tmp_spec, *tmp_spec_p;
4176
4177   if (configure_default_options[0].name == NULL)
4178     return;
4179
4180   for (i = 0; i < ARRAY_SIZE (configure_default_options); i++)
4181     if (strcmp (configure_default_options[i].name, name) == 0)
4182       break;
4183   if (i == ARRAY_SIZE (configure_default_options))
4184     return;
4185
4186   value = configure_default_options[i].value;
4187   value_len = strlen (value);
4188
4189   /* Compute the size of the final spec.  */
4190   value_count = 0;
4191   p = spec;
4192   while ((p = strstr (p, "%(VALUE)")) != NULL)
4193     {
4194       p ++;
4195       value_count ++;
4196     }
4197
4198   /* Replace each %(VALUE) by the specified value.  */
4199   tmp_spec = (char *) alloca (strlen (spec) + 1
4200                      + value_count * (value_len - strlen ("%(VALUE)")));
4201   tmp_spec_p = tmp_spec;
4202   q = spec;
4203   while ((p = strstr (q, "%(VALUE)")) != NULL)
4204     {
4205       memcpy (tmp_spec_p, q, p - q);
4206       tmp_spec_p = tmp_spec_p + (p - q);
4207       memcpy (tmp_spec_p, value, value_len);
4208       tmp_spec_p += value_len;
4209       q = p + strlen ("%(VALUE)");
4210     }
4211   strcpy (tmp_spec_p, q);
4212
4213   do_self_spec (tmp_spec);
4214 }
4215
4216 /* Process the given spec string and add any new options to the end
4217    of the switches/n_switches array.  */
4218
4219 static void
4220 do_self_spec (const char *spec)
4221 {
4222   int i;
4223
4224   do_spec_2 (spec);
4225   do_spec_1 (" ", 0, NULL);
4226
4227   /* Mark %<S switches processed by do_self_spec to be ignored permanently.
4228      do_self_specs adds the replacements to switches array, so it shouldn't
4229      be processed afterwards.  */
4230   for (i = 0; i < n_switches; i++)
4231     if ((switches[i].live_cond & SWITCH_IGNORE))
4232       switches[i].live_cond |= SWITCH_IGNORE_PERMANENTLY;
4233
4234   if (VEC_length (const_char_p, argbuf) > 0)
4235     {
4236       const char **argbuf_copy;
4237       struct cl_decoded_option *decoded_options;
4238       struct cl_option_handlers handlers;
4239       unsigned int decoded_options_count;
4240       unsigned int j;
4241
4242       /* Create a copy of argbuf with a dummy argv[0] entry for
4243          decode_cmdline_options_to_array.  */
4244       argbuf_copy = XNEWVEC (const char *,
4245                              VEC_length (const_char_p, argbuf) + 1);
4246       argbuf_copy[0] = "";
4247       memcpy (argbuf_copy + 1, VEC_address (const_char_p, argbuf),
4248               VEC_length (const_char_p, argbuf) * sizeof (const char *));
4249
4250       decode_cmdline_options_to_array (VEC_length (const_char_p, argbuf) + 1,
4251                                        argbuf_copy,
4252                                        CL_DRIVER, &decoded_options,
4253                                        &decoded_options_count);
4254
4255       set_option_handlers (&handlers);
4256
4257       for (j = 1; j < decoded_options_count; j++)
4258         {
4259           switch (decoded_options[j].opt_index)
4260             {
4261             case OPT_SPECIAL_input_file:
4262               /* Specs should only generate options, not input
4263                  files.  */
4264               if (strcmp (decoded_options[j].arg, "-") != 0)
4265                 fatal_error ("switch %qs does not start with %<-%>",
4266                              decoded_options[j].arg);
4267               else
4268                 fatal_error ("spec-generated switch is just %<-%>");
4269               break;
4270
4271             case OPT_fcompare_debug_second:
4272             case OPT_fcompare_debug:
4273             case OPT_fcompare_debug_:
4274             case OPT_o:
4275               /* Avoid duplicate processing of some options from
4276                  compare-debug specs; just save them here.  */
4277               save_switch (decoded_options[j].canonical_option[0],
4278                            (decoded_options[j].canonical_option_num_elements
4279                             - 1),
4280                            &decoded_options[j].canonical_option[1], false);
4281               break;
4282
4283             default:
4284               read_cmdline_option (&global_options, &global_options_set,
4285                                    decoded_options + j, UNKNOWN_LOCATION,
4286                                    CL_DRIVER, &handlers, global_dc);
4287               break;
4288             }
4289         }
4290
4291       alloc_switch ();
4292       switches[n_switches].part1 = 0;
4293     }
4294 }
4295
4296 /* Callback for processing %D and %I specs.  */
4297
4298 struct spec_path_info {
4299   const char *option;
4300   const char *append;
4301   size_t append_len;
4302   bool omit_relative;
4303   bool separate_options;
4304 };
4305
4306 static void *
4307 spec_path (char *path, void *data)
4308 {
4309   struct spec_path_info *info = (struct spec_path_info *) data;
4310   size_t len = 0;
4311   char save = 0;
4312
4313   if (info->omit_relative && !IS_ABSOLUTE_PATH (path))
4314     return NULL;
4315
4316   if (info->append_len != 0)
4317     {
4318       len = strlen (path);
4319       memcpy (path + len, info->append, info->append_len + 1);
4320     }
4321
4322   if (!is_directory (path, true))
4323     return NULL;
4324
4325   do_spec_1 (info->option, 1, NULL);
4326   if (info->separate_options)
4327     do_spec_1 (" ", 0, NULL);
4328
4329   if (info->append_len == 0)
4330     {
4331       len = strlen (path);
4332       save = path[len - 1];
4333       if (IS_DIR_SEPARATOR (path[len - 1]))
4334         path[len - 1] = '\0';
4335     }
4336
4337   do_spec_1 (path, 1, NULL);
4338   do_spec_1 (" ", 0, NULL);
4339
4340   /* Must not damage the original path.  */
4341   if (info->append_len == 0)
4342     path[len - 1] = save;
4343
4344   return NULL;
4345 }
4346
4347 /* Create a temporary FILE with the contents of ARGV. Add @FILE to the
4348    argument list. */
4349
4350 static void
4351 create_at_file (char **argv)
4352 {
4353   char *temp_file = make_temp_file ("");
4354   char *at_argument = concat ("@", temp_file, NULL);
4355   FILE *f = fopen (temp_file, "w");
4356   int status;
4357
4358   if (f == NULL)
4359     fatal_error ("could not open temporary response file %s",
4360                  temp_file);
4361
4362   status = writeargv (argv, f);
4363
4364   if (status)
4365     fatal_error ("could not write to temporary response file %s",
4366                  temp_file);
4367
4368   status = fclose (f);
4369
4370   if (EOF == status)
4371     fatal_error ("could not close temporary response file %s",
4372                  temp_file);
4373
4374   store_arg (at_argument, 0, 0);
4375
4376   record_temp_file (temp_file, !save_temps_flag, !save_temps_flag);
4377 }
4378
4379 /* True if we should compile INFILE. */
4380
4381 static bool
4382 compile_input_file_p (struct infile *infile)
4383 {
4384   if ((!infile->language) || (infile->language[0] != '*'))
4385     if (infile->incompiler == input_file_compiler)
4386       return true;
4387   return false;
4388 }
4389
4390 /* Process each member of VEC as a spec.  */
4391
4392 static void
4393 do_specs_vec (VEC(char_p,heap) *vec)
4394 {
4395   unsigned ix;
4396   char *opt;
4397
4398   FOR_EACH_VEC_ELT (char_p, vec, ix, opt)
4399     {
4400       do_spec_1 (opt, 1, NULL);
4401       /* Make each accumulated option a separate argument.  */
4402       do_spec_1 (" ", 0, NULL);
4403     }
4404 }
4405
4406 /* Process the sub-spec SPEC as a portion of a larger spec.
4407    This is like processing a whole spec except that we do
4408    not initialize at the beginning and we do not supply a
4409    newline by default at the end.
4410    INSWITCH nonzero means don't process %-sequences in SPEC;
4411    in this case, % is treated as an ordinary character.
4412    This is used while substituting switches.
4413    INSWITCH nonzero also causes SPC not to terminate an argument.
4414
4415    Value is zero unless a line was finished
4416    and the command on that line reported an error.  */
4417
4418 static int
4419 do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
4420 {
4421   const char *p = spec;
4422   int c;
4423   int i;
4424   int value;
4425
4426   while ((c = *p++))
4427     /* If substituting a switch, treat all chars like letters.
4428        Otherwise, NL, SPC, TAB and % are special.  */
4429     switch (inswitch ? 'a' : c)
4430       {
4431       case '\n':
4432         end_going_arg ();
4433
4434         if (VEC_length (const_char_p, argbuf) > 0
4435             && !strcmp (VEC_last (const_char_p, argbuf), "|"))
4436           {
4437             /* A `|' before the newline means use a pipe here,
4438                but only if -pipe was specified.
4439                Otherwise, execute now and don't pass the `|' as an arg.  */
4440             if (use_pipes)
4441               {
4442                 input_from_pipe = 1;
4443                 break;
4444               }
4445             else
4446               VEC_pop (const_char_p, argbuf);
4447           }
4448
4449         set_collect_gcc_options ();
4450
4451         if (VEC_length (const_char_p, argbuf) > 0)
4452           {
4453             value = execute ();
4454             if (value)
4455               return value;
4456           }
4457         /* Reinitialize for a new command, and for a new argument.  */
4458         clear_args ();
4459         arg_going = 0;
4460         delete_this_arg = 0;
4461         this_is_output_file = 0;
4462         this_is_library_file = 0;
4463         this_is_linker_script = 0;
4464         input_from_pipe = 0;
4465         break;
4466
4467       case '|':
4468         end_going_arg ();
4469
4470         /* Use pipe */
4471         obstack_1grow (&obstack, c);
4472         arg_going = 1;
4473         break;
4474
4475       case '\t':
4476       case ' ':
4477         end_going_arg ();
4478
4479         /* Reinitialize for a new argument.  */
4480         delete_this_arg = 0;
4481         this_is_output_file = 0;
4482         this_is_library_file = 0;
4483         this_is_linker_script = 0;
4484         break;
4485
4486       case '%':
4487         switch (c = *p++)
4488           {
4489           case 0:
4490             fatal_error ("spec %qs invalid", spec);
4491
4492           case 'b':
4493             if (save_temps_length)
4494               obstack_grow (&obstack, save_temps_prefix, save_temps_length);
4495             else
4496               obstack_grow (&obstack, input_basename, basename_length);
4497             if (compare_debug < 0)
4498               obstack_grow (&obstack, ".gk", 3);
4499             arg_going = 1;
4500             break;
4501
4502           case 'B':
4503             if (save_temps_length)
4504               obstack_grow (&obstack, save_temps_prefix, save_temps_length);
4505             else
4506               obstack_grow (&obstack, input_basename, suffixed_basename_length);
4507             if (compare_debug < 0)
4508               obstack_grow (&obstack, ".gk", 3);
4509             arg_going = 1;
4510             break;
4511
4512           case 'd':
4513             delete_this_arg = 2;
4514             break;
4515
4516           /* Dump out the directories specified with LIBRARY_PATH,
4517              followed by the absolute directories
4518              that we search for startfiles.  */
4519           case 'D':
4520             {
4521               struct spec_path_info info;
4522
4523               info.option = "-L";
4524               info.append_len = 0;
4525 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
4526               /* Used on systems which record the specified -L dirs
4527                  and use them to search for dynamic linking.
4528                  Relative directories always come from -B,
4529                  and it is better not to use them for searching
4530                  at run time.  In particular, stage1 loses.  */
4531               info.omit_relative = true;
4532 #else
4533               info.omit_relative = false;
4534 #endif
4535               info.separate_options = false;
4536
4537               for_each_path (&startfile_prefixes, true, 0, spec_path, &info);
4538             }
4539             break;
4540
4541           case 'e':
4542             /* %efoo means report an error with `foo' as error message
4543                and don't execute any more commands for this file.  */
4544             {
4545               const char *q = p;
4546               char *buf;
4547               while (*p != 0 && *p != '\n')
4548                 p++;
4549               buf = (char *) alloca (p - q + 1);
4550               strncpy (buf, q, p - q);
4551               buf[p - q] = 0;
4552               error ("%s", _(buf));
4553               return -1;
4554             }
4555             break;
4556           case 'n':
4557             /* %nfoo means report a notice with `foo' on stderr.  */
4558             {
4559               const char *q = p;
4560               char *buf;
4561               while (*p != 0 && *p != '\n')
4562                 p++;
4563               buf = (char *) alloca (p - q + 1);
4564               strncpy (buf, q, p - q);
4565               buf[p - q] = 0;
4566               inform (0, "%s", _(buf));
4567               if (*p)
4568                 p++;
4569             }
4570             break;
4571
4572           case 'j':
4573             {
4574               struct stat st;
4575
4576               /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
4577                  defined, and it is not a directory, and it is
4578                  writable, use it.  Otherwise, treat this like any
4579                  other temporary file.  */
4580
4581               if ((!save_temps_flag)
4582                   && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode))
4583                   && (access (HOST_BIT_BUCKET, W_OK) == 0))
4584                 {
4585                   obstack_grow (&obstack, HOST_BIT_BUCKET,
4586                                 strlen (HOST_BIT_BUCKET));
4587                   delete_this_arg = 0;
4588                   arg_going = 1;
4589                   break;
4590                 }
4591             }
4592             goto create_temp_file;
4593           case '|':
4594             if (use_pipes)
4595               {
4596                 obstack_1grow (&obstack, '-');
4597                 delete_this_arg = 0;
4598                 arg_going = 1;
4599
4600                 /* consume suffix */
4601                 while (*p == '.' || ISALNUM ((unsigned char) *p))
4602                   p++;
4603                 if (p[0] == '%' && p[1] == 'O')
4604                   p += 2;
4605
4606                 break;
4607               }
4608             goto create_temp_file;
4609           case 'm':
4610             if (use_pipes)
4611               {
4612                 /* consume suffix */
4613                 while (*p == '.' || ISALNUM ((unsigned char) *p))
4614                   p++;
4615                 if (p[0] == '%' && p[1] == 'O')
4616                   p += 2;
4617
4618                 break;
4619               }
4620             goto create_temp_file;
4621           case 'g':
4622           case 'u':
4623           case 'U':
4624           create_temp_file:
4625               {
4626                 struct temp_name *t;
4627                 int suffix_length;
4628                 const char *suffix = p;
4629                 char *saved_suffix = NULL;
4630
4631                 while (*p == '.' || ISALNUM ((unsigned char) *p))
4632                   p++;
4633                 suffix_length = p - suffix;
4634                 if (p[0] == '%' && p[1] == 'O')
4635                   {
4636                     p += 2;
4637                     /* We don't support extra suffix characters after %O.  */
4638                     if (*p == '.' || ISALNUM ((unsigned char) *p))
4639                       fatal_error ("spec %qs has invalid %<%%0%c%>", spec, *p);
4640                     if (suffix_length == 0)
4641                       suffix = TARGET_OBJECT_SUFFIX;
4642                     else
4643                       {
4644                         saved_suffix
4645                           = XNEWVEC (char, suffix_length
4646                                      + strlen (TARGET_OBJECT_SUFFIX));
4647                         strncpy (saved_suffix, suffix, suffix_length);
4648                         strcpy (saved_suffix + suffix_length,
4649                                 TARGET_OBJECT_SUFFIX);
4650                       }
4651                     suffix_length += strlen (TARGET_OBJECT_SUFFIX);
4652                   }
4653
4654                 if (compare_debug < 0)
4655                   {
4656                     suffix = concat (".gk", suffix, NULL);
4657                     suffix_length += 3;
4658                   }
4659
4660                 /* If -save-temps=obj and -o were specified, use that for the
4661                    temp file.  */
4662                 if (save_temps_length)
4663                   {
4664                     char *tmp;
4665                     temp_filename_length
4666                       = save_temps_length + suffix_length + 1;
4667                     tmp = (char *) alloca (temp_filename_length);
4668                     memcpy (tmp, save_temps_prefix, save_temps_length);
4669                     memcpy (tmp + save_temps_length, suffix, suffix_length);
4670                     tmp[save_temps_length + suffix_length] = '\0';
4671                     temp_filename = save_string (tmp,
4672                                                  temp_filename_length + 1);
4673                     obstack_grow (&obstack, temp_filename,
4674                                   temp_filename_length);
4675                     arg_going = 1;
4676                     delete_this_arg = 0;
4677                     break;
4678                   }
4679
4680                 /* If the gcc_input_filename has the same suffix specified
4681                    for the %g, %u, or %U, and -save-temps is specified,
4682                    we could end up using that file as an intermediate
4683                    thus clobbering the user's source file (.e.g.,
4684                    gcc -save-temps foo.s would clobber foo.s with the
4685                    output of cpp0).  So check for this condition and
4686                    generate a temp file as the intermediate.  */
4687
4688                 if (save_temps_flag)
4689                   {
4690                     char *tmp;
4691                     temp_filename_length = basename_length + suffix_length + 1;
4692                     tmp = (char *) alloca (temp_filename_length);
4693                     memcpy (tmp, input_basename, basename_length);
4694                     memcpy (tmp + basename_length, suffix, suffix_length);
4695                     tmp[basename_length + suffix_length] = '\0';
4696                     temp_filename = tmp;
4697
4698                     if (strcmp (temp_filename, gcc_input_filename) != 0)
4699                       {
4700 #ifndef HOST_LACKS_INODE_NUMBERS
4701                         struct stat st_temp;
4702
4703                         /* Note, set_input() resets input_stat_set to 0.  */
4704                         if (input_stat_set == 0)
4705                           {
4706                             input_stat_set = stat (gcc_input_filename,
4707                                                    &input_stat);
4708                             if (input_stat_set >= 0)
4709                               input_stat_set = 1;
4710                           }
4711
4712                         /* If we have the stat for the gcc_input_filename
4713                            and we can do the stat for the temp_filename
4714                            then the they could still refer to the same
4715                            file if st_dev/st_ino's are the same.  */
4716                         if (input_stat_set != 1
4717                             || stat (temp_filename, &st_temp) < 0
4718                             || input_stat.st_dev != st_temp.st_dev
4719                             || input_stat.st_ino != st_temp.st_ino)
4720 #else
4721                         /* Just compare canonical pathnames.  */
4722                         char* input_realname = lrealpath (gcc_input_filename);
4723                         char* temp_realname = lrealpath (temp_filename);
4724                         bool files_differ = strcmp (input_realname, temp_realname);
4725                         free (input_realname);
4726                         free (temp_realname);
4727                         if (files_differ)
4728 #endif
4729                           {
4730                             temp_filename = save_string (temp_filename,
4731                                                          temp_filename_length + 1);
4732                             obstack_grow (&obstack, temp_filename,
4733                                                     temp_filename_length);
4734                             arg_going = 1;
4735                             delete_this_arg = 0;
4736                             break;
4737                           }
4738                       }
4739                   }
4740
4741                 /* See if we already have an association of %g/%u/%U and
4742                    suffix.  */
4743                 for (t = temp_names; t; t = t->next)
4744                   if (t->length == suffix_length
4745                       && strncmp (t->suffix, suffix, suffix_length) == 0
4746                       && t->unique == (c == 'u' || c == 'U' || c == 'j'))
4747                     break;
4748
4749                 /* Make a new association if needed.  %u and %j
4750                    require one.  */
4751                 if (t == 0 || c == 'u' || c == 'j')
4752                   {
4753                     if (t == 0)
4754                       {
4755                         t = XNEW (struct temp_name);
4756                         t->next = temp_names;
4757                         temp_names = t;
4758                       }
4759                     t->length = suffix_length;
4760                     if (saved_suffix)
4761                       {
4762                         t->suffix = saved_suffix;
4763                         saved_suffix = NULL;
4764                       }
4765                     else
4766                       t->suffix = save_string (suffix, suffix_length);
4767                     t->unique = (c == 'u' || c == 'U' || c == 'j');
4768                     temp_filename = make_temp_file (t->suffix);
4769                     temp_filename_length = strlen (temp_filename);
4770                     t->filename = temp_filename;
4771                     t->filename_length = temp_filename_length;
4772                   }
4773
4774                 if (saved_suffix)
4775                   free (saved_suffix);
4776
4777                 obstack_grow (&obstack, t->filename, t->filename_length);
4778                 delete_this_arg = 1;
4779               }
4780             arg_going = 1;
4781             break;
4782
4783           case 'i':
4784             if (combine_inputs)
4785               {
4786                 if (at_file_supplied)
4787                   {
4788                     /* We are going to expand `%i' to `@FILE', where FILE
4789                        is a newly-created temporary filename.  The filenames
4790                        that would usually be expanded in place of %o will be
4791                        written to the temporary file.  */
4792                     char **argv;
4793                     int n_files = 0;
4794                     int j;
4795
4796                     for (i = 0; i < n_infiles; i++)
4797                       if (compile_input_file_p (&infiles[i]))
4798                         n_files++;
4799
4800                     argv = (char **) alloca (sizeof (char *) * (n_files + 1));
4801
4802                     /* Copy the strings over.  */
4803                     for (i = 0, j = 0; i < n_infiles; i++)
4804                       if (compile_input_file_p (&infiles[i]))
4805                         {
4806                           argv[j] = CONST_CAST (char *, infiles[i].name);
4807                           infiles[i].compiled = true;
4808                           j++;
4809                         }
4810                     argv[j] = NULL;
4811
4812                     create_at_file (argv);
4813                   }
4814                 else
4815                   for (i = 0; (int) i < n_infiles; i++)
4816                     if (compile_input_file_p (&infiles[i]))
4817                       {
4818                         store_arg (infiles[i].name, 0, 0);
4819                         infiles[i].compiled = true;
4820                       }
4821               }
4822             else
4823               {
4824                 obstack_grow (&obstack, gcc_input_filename,
4825                               input_filename_length);
4826                 arg_going = 1;
4827               }
4828             break;
4829
4830           case 'I':
4831             {
4832               struct spec_path_info info;
4833
4834               if (multilib_dir)
4835                 {
4836                   do_spec_1 ("-imultilib", 1, NULL);
4837                   /* Make this a separate argument.  */
4838                   do_spec_1 (" ", 0, NULL);
4839                   do_spec_1 (multilib_dir, 1, NULL);
4840                   do_spec_1 (" ", 0, NULL);
4841                 }
4842
4843               if (gcc_exec_prefix)
4844                 {
4845                   do_spec_1 ("-iprefix", 1, NULL);
4846                   /* Make this a separate argument.  */
4847                   do_spec_1 (" ", 0, NULL);
4848                   do_spec_1 (gcc_exec_prefix, 1, NULL);
4849                   do_spec_1 (" ", 0, NULL);
4850                 }
4851
4852               if (target_system_root_changed ||
4853                   (target_system_root && target_sysroot_hdrs_suffix))
4854                 {
4855                   do_spec_1 ("-isysroot", 1, NULL);
4856                   /* Make this a separate argument.  */
4857                   do_spec_1 (" ", 0, NULL);
4858                   do_spec_1 (target_system_root, 1, NULL);
4859                   if (target_sysroot_hdrs_suffix)
4860                     do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL);
4861                   do_spec_1 (" ", 0, NULL);
4862                 }
4863
4864               info.option = "-isystem";
4865               info.append = "include";
4866               info.append_len = strlen (info.append);
4867               info.omit_relative = false;
4868               info.separate_options = true;
4869
4870               for_each_path (&include_prefixes, false, info.append_len,
4871                              spec_path, &info);
4872
4873               info.append = "include-fixed";
4874               if (*sysroot_hdrs_suffix_spec)
4875                 info.append = concat (info.append, dir_separator_str,
4876                                       multilib_dir, NULL);
4877               info.append_len = strlen (info.append);
4878               for_each_path (&include_prefixes, false, info.append_len,
4879                              spec_path, &info);
4880             }
4881             break;
4882
4883           case 'o':
4884             {
4885               int max = n_infiles;
4886               max += lang_specific_extra_outfiles;
4887
4888               if (HAVE_GNU_LD && at_file_supplied)
4889                 {
4890                   /* We are going to expand `%o' to `@FILE', where FILE
4891                      is a newly-created temporary filename.  The filenames
4892                      that would usually be expanded in place of %o will be
4893                      written to the temporary file.  */
4894
4895                   char **argv;
4896                   int n_files, j;
4897
4898                   /* Convert OUTFILES into a form suitable for writeargv.  */
4899
4900                   /* Determine how many are non-NULL.  */
4901                   for (n_files = 0, i = 0; i < max; i++)
4902                     n_files += outfiles[i] != NULL;
4903
4904                   argv = (char **) alloca (sizeof (char *) * (n_files + 1));
4905
4906                   /* Copy the strings over.  */
4907                   for (i = 0, j = 0; i < max; i++)
4908                     if (outfiles[i])
4909                       {
4910                         argv[j] = CONST_CAST (char *, outfiles[i]);
4911                         j++;
4912                       }
4913                   argv[j] = NULL;
4914
4915                   create_at_file (argv);
4916                 }
4917               else
4918                 for (i = 0; i < max; i++)
4919                   if (outfiles[i])
4920                     store_arg (outfiles[i], 0, 0);
4921               break;
4922             }
4923
4924           case 'O':
4925             obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
4926             arg_going = 1;
4927             break;
4928
4929           case 's':
4930             this_is_library_file = 1;
4931             break;
4932
4933           case 'T':
4934             this_is_linker_script = 1;
4935             break;
4936
4937           case 'V':
4938             outfiles[input_file_number] = NULL;
4939             break;
4940
4941           case 'w':
4942             this_is_output_file = 1;
4943             break;
4944
4945           case 'W':
4946             {
4947               unsigned int cur_index = VEC_length (const_char_p, argbuf);
4948               /* Handle the {...} following the %W.  */
4949               if (*p != '{')
4950                 fatal_error ("spec %qs has invalid %<%%W%c%>", spec, *p);
4951               p = handle_braces (p + 1);
4952               if (p == 0)
4953                 return -1;
4954               end_going_arg ();
4955               /* If any args were output, mark the last one for deletion
4956                  on failure.  */
4957               if (VEC_length (const_char_p, argbuf) != cur_index)
4958                 record_temp_file (VEC_last (const_char_p, argbuf), 0, 1);
4959               break;
4960             }
4961
4962           /* %x{OPTION} records OPTION for %X to output.  */
4963           case 'x':
4964             {
4965               const char *p1 = p;
4966               char *string;
4967               char *opt;
4968               unsigned ix;
4969
4970               /* Skip past the option value and make a copy.  */
4971               if (*p != '{')
4972                 fatal_error ("spec %qs has invalid %<%%x%c%>", spec, *p);
4973               while (*p++ != '}')
4974                 ;
4975               string = save_string (p1 + 1, p - p1 - 2);
4976
4977               /* See if we already recorded this option.  */
4978               FOR_EACH_VEC_ELT (char_p, linker_options, ix, opt)
4979                 if (! strcmp (string, opt))
4980                   {
4981                     free (string);
4982                     return 0;
4983                   }
4984
4985               /* This option is new; add it.  */
4986               add_linker_option (string, strlen (string));
4987             }
4988             break;
4989
4990           /* Dump out the options accumulated previously using %x.  */
4991           case 'X':
4992             do_specs_vec (linker_options);
4993             break;
4994
4995           /* Dump out the options accumulated previously using -Wa,.  */
4996           case 'Y':
4997             do_specs_vec (assembler_options);
4998             break;
4999
5000           /* Dump out the options accumulated previously using -Wp,.  */
5001           case 'Z':
5002             do_specs_vec (preprocessor_options);
5003             break;
5004
5005             /* Here are digits and numbers that just process
5006                a certain constant string as a spec.  */
5007
5008           case '1':
5009             value = do_spec_1 (cc1_spec, 0, NULL);
5010             if (value != 0)
5011               return value;
5012             break;
5013
5014           case '2':
5015             value = do_spec_1 (cc1plus_spec, 0, NULL);
5016             if (value != 0)
5017               return value;
5018             break;
5019
5020           case 'a':
5021             value = do_spec_1 (asm_spec, 0, NULL);
5022             if (value != 0)
5023               return value;
5024             break;
5025
5026           case 'A':
5027             value = do_spec_1 (asm_final_spec, 0, NULL);
5028             if (value != 0)
5029               return value;
5030             break;
5031
5032           case 'C':
5033             {
5034               const char *const spec
5035                 = (input_file_compiler->cpp_spec
5036                    ? input_file_compiler->cpp_spec
5037                    : cpp_spec);
5038               value = do_spec_1 (spec, 0, NULL);
5039               if (value != 0)
5040                 return value;
5041             }
5042             break;
5043
5044           case 'E':
5045             value = do_spec_1 (endfile_spec, 0, NULL);
5046             if (value != 0)
5047               return value;
5048             break;
5049
5050           case 'l':
5051             value = do_spec_1 (link_spec, 0, NULL);
5052             if (value != 0)
5053               return value;
5054             break;
5055
5056           case 'L':
5057             value = do_spec_1 (lib_spec, 0, NULL);
5058             if (value != 0)
5059               return value;
5060             break;
5061
5062           case 'G':
5063             value = do_spec_1 (libgcc_spec, 0, NULL);
5064             if (value != 0)
5065               return value;
5066             break;
5067
5068           case 'R':
5069             /* We assume there is a directory
5070                separator at the end of this string.  */
5071             if (target_system_root)
5072               {
5073                 obstack_grow (&obstack, target_system_root,
5074                               strlen (target_system_root));
5075                 if (target_sysroot_suffix)
5076                   obstack_grow (&obstack, target_sysroot_suffix,
5077                                 strlen (target_sysroot_suffix));
5078               }
5079             break;
5080
5081           case 'S':
5082             value = do_spec_1 (startfile_spec, 0, NULL);
5083             if (value != 0)
5084               return value;
5085             break;
5086
5087             /* Here we define characters other than letters and digits.  */
5088
5089           case '{':
5090             p = handle_braces (p);
5091             if (p == 0)
5092               return -1;
5093             break;
5094
5095           case ':':
5096             p = handle_spec_function (p);
5097             if (p == 0)
5098               return -1;
5099             break;
5100
5101           case '%':
5102             obstack_1grow (&obstack, '%');
5103             break;
5104
5105           case '.':
5106             {
5107               unsigned len = 0;
5108
5109               while (p[len] && p[len] != ' ' && p[len] != '%')
5110                 len++;
5111               suffix_subst = save_string (p - 1, len + 1);
5112               p += len;
5113             }
5114            break;
5115
5116            /* Henceforth ignore the option(s) matching the pattern
5117               after the %<.  */
5118           case '<':
5119           case '>':
5120             {
5121               unsigned len = 0;
5122               int have_wildcard = 0;
5123               int i;
5124               int switch_option;
5125
5126               if (c == '>')
5127                 switch_option = SWITCH_IGNORE | SWITCH_KEEP_FOR_GCC;
5128               else
5129                 switch_option = SWITCH_IGNORE;
5130
5131               while (p[len] && p[len] != ' ' && p[len] != '\t')
5132                 len++;
5133
5134               if (p[len-1] == '*')
5135                 have_wildcard = 1;
5136
5137               for (i = 0; i < n_switches; i++)
5138                 if (!strncmp (switches[i].part1, p, len - have_wildcard)
5139                     && (have_wildcard || switches[i].part1[len] == '\0'))
5140                   {
5141                     switches[i].live_cond |= switch_option;
5142                     switches[i].validated = 1;
5143                   }
5144
5145               p += len;
5146             }
5147             break;
5148
5149           case '*':
5150             if (soft_matched_part)
5151               {
5152                 do_spec_1 (soft_matched_part, 1, NULL);
5153                 do_spec_1 (" ", 0, NULL);
5154               }
5155             else
5156               /* Catch the case where a spec string contains something like
5157                  '%{foo:%*}'.  i.e. there is no * in the pattern on the left
5158                  hand side of the :.  */
5159               error ("spec failure: %<%%*%> has not been initialized by pattern match");
5160             break;
5161
5162             /* Process a string found as the value of a spec given by name.
5163                This feature allows individual machine descriptions
5164                to add and use their own specs.
5165                %[...] modifies -D options the way %P does;
5166                %(...) uses the spec unmodified.  */
5167           case '[':
5168             warning (0, "use of obsolete %%[ operator in specs");
5169           case '(':
5170             {
5171               const char *name = p;
5172               struct spec_list *sl;
5173               int len;
5174
5175               /* The string after the S/P is the name of a spec that is to be
5176                  processed.  */
5177               while (*p && *p != ')' && *p != ']')
5178                 p++;
5179
5180               /* See if it's in the list.  */
5181               for (len = p - name, sl = specs; sl; sl = sl->next)
5182                 if (sl->name_len == len && !strncmp (sl->name, name, len))
5183                   {
5184                     name = *(sl->ptr_spec);
5185 #ifdef DEBUG_SPECS
5186                     fnotice (stderr, "Processing spec %c%s%c, which is '%s'\n",
5187                             c, sl->name, (c == '(') ? ')' : ']', name);
5188 #endif
5189                     break;
5190                   }
5191
5192               if (sl)
5193                 {
5194                   if (c == '(')
5195                     {
5196                       value = do_spec_1 (name, 0, NULL);
5197                       if (value != 0)
5198                         return value;
5199                     }
5200                   else
5201                     {
5202                       char *x = (char *) alloca (strlen (name) * 2 + 1);
5203                       char *buf = x;
5204                       const char *y = name;
5205                       int flag = 0;
5206
5207                       /* Copy all of NAME into BUF, but put __ after
5208                          every -D and at the end of each arg.  */
5209                       while (1)
5210                         {
5211                           if (! strncmp (y, "-D", 2))
5212                             {
5213                               *x++ = '-';
5214                               *x++ = 'D';
5215                               *x++ = '_';
5216                               *x++ = '_';
5217                               y += 2;
5218                               flag = 1;
5219                               continue;
5220                             }
5221                           else if (flag
5222                                    && (*y == ' ' || *y == '\t' || *y == '='
5223                                        || *y == '}' || *y == 0))
5224                             {
5225                               *x++ = '_';
5226                               *x++ = '_';
5227                               flag = 0;
5228                             }
5229                           if (*y == 0)
5230                             break;
5231                           else
5232                             *x++ = *y++;
5233                         }
5234                       *x = 0;
5235
5236                       value = do_spec_1 (buf, 0, NULL);
5237                       if (value != 0)
5238                         return value;
5239                     }
5240                 }
5241
5242               /* Discard the closing paren or bracket.  */
5243               if (*p)
5244                 p++;
5245             }
5246             break;
5247
5248           default:
5249             error ("spec failure: unrecognized spec option %qc", c);
5250             break;
5251           }
5252         break;
5253
5254       case '\\':
5255         /* Backslash: treat next character as ordinary.  */
5256         c = *p++;
5257
5258         /* Fall through.  */
5259       default:
5260         /* Ordinary character: put it into the current argument.  */
5261         obstack_1grow (&obstack, c);
5262         arg_going = 1;
5263       }
5264
5265   /* End of string.  If we are processing a spec function, we need to
5266      end any pending argument.  */
5267   if (processing_spec_function)
5268     end_going_arg ();
5269
5270   return 0;
5271 }
5272
5273 /* Look up a spec function.  */
5274
5275 static const struct spec_function *
5276 lookup_spec_function (const char *name)
5277 {
5278   const struct spec_function *sf;
5279
5280   for (sf = static_spec_functions; sf->name != NULL; sf++)
5281     if (strcmp (sf->name, name) == 0)
5282       return sf;
5283
5284   return NULL;
5285 }
5286
5287 /* Evaluate a spec function.  */
5288
5289 static const char *
5290 eval_spec_function (const char *func, const char *args)
5291 {
5292   const struct spec_function *sf;
5293   const char *funcval;
5294
5295   /* Saved spec processing context.  */
5296   VEC(const_char_p,heap) *save_argbuf;
5297
5298   int save_arg_going;
5299   int save_delete_this_arg;
5300   int save_this_is_output_file;
5301   int save_this_is_library_file;
5302   int save_input_from_pipe;
5303   int save_this_is_linker_script;
5304   const char *save_suffix_subst;
5305
5306
5307   sf = lookup_spec_function (func);
5308   if (sf == NULL)
5309     fatal_error ("unknown spec function %qs", func);
5310
5311   /* Push the spec processing context.  */
5312   save_argbuf = argbuf;
5313
5314   save_arg_going = arg_going;
5315   save_delete_this_arg = delete_this_arg;
5316   save_this_is_output_file = this_is_output_file;
5317   save_this_is_library_file = this_is_library_file;
5318   save_this_is_linker_script = this_is_linker_script;
5319   save_input_from_pipe = input_from_pipe;
5320   save_suffix_subst = suffix_subst;
5321
5322   /* Create a new spec processing context, and build the function
5323      arguments.  */
5324
5325   alloc_args ();
5326   if (do_spec_2 (args) < 0)
5327     fatal_error ("error in args to spec function %qs", func);
5328
5329   /* argbuf_index is an index for the next argument to be inserted, and
5330      so contains the count of the args already inserted.  */
5331
5332   funcval = (*sf->func) (VEC_length (const_char_p, argbuf),
5333                          VEC_address (const_char_p, argbuf));
5334
5335   /* Pop the spec processing context.  */
5336   VEC_free (const_char_p, heap, argbuf);
5337   argbuf = save_argbuf;
5338
5339   arg_going = save_arg_going;
5340   delete_this_arg = save_delete_this_arg;
5341   this_is_output_file = save_this_is_output_file;
5342   this_is_library_file = save_this_is_library_file;
5343   this_is_linker_script = save_this_is_linker_script;
5344   input_from_pipe = save_input_from_pipe;
5345   suffix_subst = save_suffix_subst;
5346
5347   return funcval;
5348 }
5349
5350 /* Handle a spec function call of the form:
5351
5352    %:function(args)
5353
5354    ARGS is processed as a spec in a separate context and split into an
5355    argument vector in the normal fashion.  The function returns a string
5356    containing a spec which we then process in the caller's context, or
5357    NULL if no processing is required.  */
5358
5359 static const char *
5360 handle_spec_function (const char *p)
5361 {
5362   char *func, *args;
5363   const char *endp, *funcval;
5364   int count;
5365
5366   processing_spec_function++;
5367
5368   /* Get the function name.  */
5369   for (endp = p; *endp != '\0'; endp++)
5370     {
5371       if (*endp == '(')         /* ) */
5372         break;
5373       /* Only allow [A-Za-z0-9], -, and _ in function names.  */
5374       if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_'))
5375         fatal_error ("malformed spec function name");
5376     }
5377   if (*endp != '(')             /* ) */
5378     fatal_error ("no arguments for spec function");
5379   func = save_string (p, endp - p);
5380   p = ++endp;
5381
5382   /* Get the arguments.  */
5383   for (count = 0; *endp != '\0'; endp++)
5384     {
5385       /* ( */
5386       if (*endp == ')')
5387         {
5388           if (count == 0)
5389             break;
5390           count--;
5391         }
5392       else if (*endp == '(')    /* ) */
5393         count++;
5394     }
5395   /* ( */
5396   if (*endp != ')')
5397     fatal_error ("malformed spec function arguments");
5398   args = save_string (p, endp - p);
5399   p = ++endp;
5400
5401   /* p now points to just past the end of the spec function expression.  */
5402
5403   funcval = eval_spec_function (func, args);
5404   if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0)
5405     p = NULL;
5406
5407   free (func);
5408   free (args);
5409
5410   processing_spec_function--;
5411
5412   return p;
5413 }
5414
5415 /* Inline subroutine of handle_braces.  Returns true if the current
5416    input suffix matches the atom bracketed by ATOM and END_ATOM.  */
5417 static inline bool
5418 input_suffix_matches (const char *atom, const char *end_atom)
5419 {
5420   return (input_suffix
5421           && !strncmp (input_suffix, atom, end_atom - atom)
5422           && input_suffix[end_atom - atom] == '\0');
5423 }
5424
5425 /* Subroutine of handle_braces.  Returns true if the current
5426    input file's spec name matches the atom bracketed by ATOM and END_ATOM.  */
5427 static bool
5428 input_spec_matches (const char *atom, const char *end_atom)
5429 {
5430   return (input_file_compiler
5431           && input_file_compiler->suffix
5432           && input_file_compiler->suffix[0] != '\0'
5433           && !strncmp (input_file_compiler->suffix + 1, atom,
5434                        end_atom - atom)
5435           && input_file_compiler->suffix[end_atom - atom + 1] == '\0');
5436 }
5437
5438 /* Subroutine of handle_braces.  Returns true if a switch
5439    matching the atom bracketed by ATOM and END_ATOM appeared on the
5440    command line.  */
5441 static bool
5442 switch_matches (const char *atom, const char *end_atom, int starred)
5443 {
5444   int i;
5445   int len = end_atom - atom;
5446   int plen = starred ? len : -1;
5447
5448   for (i = 0; i < n_switches; i++)
5449     if (!strncmp (switches[i].part1, atom, len)
5450         && (starred || switches[i].part1[len] == '\0')
5451         && check_live_switch (i, plen))
5452       return true;
5453
5454   return false;
5455 }
5456
5457 /* Inline subroutine of handle_braces.  Mark all of the switches which
5458    match ATOM (extends to END_ATOM; STARRED indicates whether there
5459    was a star after the atom) for later processing.  */
5460 static inline void
5461 mark_matching_switches (const char *atom, const char *end_atom, int starred)
5462 {
5463   int i;
5464   int len = end_atom - atom;
5465   int plen = starred ? len : -1;
5466
5467   for (i = 0; i < n_switches; i++)
5468     if (!strncmp (switches[i].part1, atom, len)
5469         && (starred || switches[i].part1[len] == '\0')
5470         && check_live_switch (i, plen))
5471       switches[i].ordering = 1;
5472 }
5473
5474 /* Inline subroutine of handle_braces.  Process all the currently
5475    marked switches through give_switch, and clear the marks.  */
5476 static inline void
5477 process_marked_switches (void)
5478 {
5479   int i;
5480
5481   for (i = 0; i < n_switches; i++)
5482     if (switches[i].ordering == 1)
5483       {
5484         switches[i].ordering = 0;
5485         give_switch (i, 0);
5486       }
5487 }
5488
5489 /* Handle a %{ ... } construct.  P points just inside the leading {.
5490    Returns a pointer one past the end of the brace block, or 0
5491    if we call do_spec_1 and that returns -1.  */
5492
5493 static const char *
5494 handle_braces (const char *p)
5495 {
5496   const char *atom, *end_atom;
5497   const char *d_atom = NULL, *d_end_atom = NULL;
5498   const char *orig = p;
5499
5500   bool a_is_suffix;
5501   bool a_is_spectype;
5502   bool a_is_starred;
5503   bool a_is_negated;
5504   bool a_matched;
5505
5506   bool a_must_be_last = false;
5507   bool ordered_set    = false;
5508   bool disjunct_set   = false;
5509   bool disj_matched   = false;
5510   bool disj_starred   = true;
5511   bool n_way_choice   = false;
5512   bool n_way_matched  = false;
5513
5514 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
5515
5516   do
5517     {
5518       if (a_must_be_last)
5519         goto invalid;
5520
5521       /* Scan one "atom" (S in the description above of %{}, possibly
5522          with '!', '.', '@', ',', or '*' modifiers).  */
5523       a_matched = false;
5524       a_is_suffix = false;
5525       a_is_starred = false;
5526       a_is_negated = false;
5527       a_is_spectype = false;
5528
5529       SKIP_WHITE();
5530       if (*p == '!')
5531         p++, a_is_negated = true;
5532
5533       SKIP_WHITE();
5534       if (*p == '.')
5535         p++, a_is_suffix = true;
5536       else if (*p == ',')
5537         p++, a_is_spectype = true;
5538
5539       atom = p;
5540       while (ISIDNUM(*p) || *p == '-' || *p == '+' || *p == '='
5541              || *p == ',' || *p == '.' || *p == '@')
5542         p++;
5543       end_atom = p;
5544
5545       if (*p == '*')
5546         p++, a_is_starred = 1;
5547
5548       SKIP_WHITE();
5549       switch (*p)
5550         {
5551         case '&': case '}':
5552           /* Substitute the switch(es) indicated by the current atom.  */
5553           ordered_set = true;
5554           if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix
5555               || a_is_spectype || atom == end_atom)
5556             goto invalid;
5557
5558           mark_matching_switches (atom, end_atom, a_is_starred);
5559
5560           if (*p == '}')
5561             process_marked_switches ();
5562           break;
5563
5564         case '|': case ':':
5565           /* Substitute some text if the current atom appears as a switch
5566              or suffix.  */
5567           disjunct_set = true;
5568           if (ordered_set)
5569             goto invalid;
5570
5571           if (atom == end_atom)
5572             {
5573               if (!n_way_choice || disj_matched || *p == '|'
5574                   || a_is_negated || a_is_suffix || a_is_spectype
5575                   || a_is_starred)
5576                 goto invalid;
5577
5578               /* An empty term may appear as the last choice of an
5579                  N-way choice set; it means "otherwise".  */
5580               a_must_be_last = true;
5581               disj_matched = !n_way_matched;
5582               disj_starred = false;
5583             }
5584           else
5585             {
5586               if ((a_is_suffix || a_is_spectype) && a_is_starred)
5587                 goto invalid;
5588
5589               if (!a_is_starred)
5590                 disj_starred = false;
5591
5592               /* Don't bother testing this atom if we already have a
5593                  match.  */
5594               if (!disj_matched && !n_way_matched)
5595                 {
5596                   if (a_is_suffix)
5597                     a_matched = input_suffix_matches (atom, end_atom);
5598                   else if (a_is_spectype)
5599                     a_matched = input_spec_matches (atom, end_atom);
5600                   else
5601                     a_matched = switch_matches (atom, end_atom, a_is_starred);
5602
5603                   if (a_matched != a_is_negated)
5604                     {
5605                       disj_matched = true;
5606                       d_atom = atom;
5607                       d_end_atom = end_atom;
5608                     }
5609                 }
5610             }
5611
5612           if (*p == ':')
5613             {
5614               /* Found the body, that is, the text to substitute if the
5615                  current disjunction matches.  */
5616               p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred,
5617                                       disj_matched && !n_way_matched);
5618               if (p == 0)
5619                 return 0;
5620
5621               /* If we have an N-way choice, reset state for the next
5622                  disjunction.  */
5623               if (*p == ';')
5624                 {
5625                   n_way_choice = true;
5626                   n_way_matched |= disj_matched;
5627                   disj_matched = false;
5628                   disj_starred = true;
5629                   d_atom = d_end_atom = NULL;
5630                 }
5631             }
5632           break;
5633
5634         default:
5635           goto invalid;
5636         }
5637     }
5638   while (*p++ != '}');
5639
5640   return p;
5641
5642  invalid:
5643   fatal_error ("braced spec %qs is invalid at %qc", orig, *p);
5644
5645 #undef SKIP_WHITE
5646 }
5647
5648 /* Subroutine of handle_braces.  Scan and process a brace substitution body
5649    (X in the description of %{} syntax).  P points one past the colon;
5650    ATOM and END_ATOM bracket the first atom which was found to be true
5651    (present) in the current disjunction; STARRED indicates whether all
5652    the atoms in the current disjunction were starred (for syntax validation);
5653    MATCHED indicates whether the disjunction matched or not, and therefore
5654    whether or not the body is to be processed through do_spec_1 or just
5655    skipped.  Returns a pointer to the closing } or ;, or 0 if do_spec_1
5656    returns -1.  */
5657
5658 static const char *
5659 process_brace_body (const char *p, const char *atom, const char *end_atom,
5660                     int starred, int matched)
5661 {
5662   const char *body, *end_body;
5663   unsigned int nesting_level;
5664   bool have_subst     = false;
5665
5666   /* Locate the closing } or ;, honoring nested braces.
5667      Trim trailing whitespace.  */
5668   body = p;
5669   nesting_level = 1;
5670   for (;;)
5671     {
5672       if (*p == '{')
5673         nesting_level++;
5674       else if (*p == '}')
5675         {
5676           if (!--nesting_level)
5677             break;
5678         }
5679       else if (*p == ';' && nesting_level == 1)
5680         break;
5681       else if (*p == '%' && p[1] == '*' && nesting_level == 1)
5682         have_subst = true;
5683       else if (*p == '\0')
5684         goto invalid;
5685       p++;
5686     }
5687
5688   end_body = p;
5689   while (end_body[-1] == ' ' || end_body[-1] == '\t')
5690     end_body--;
5691
5692   if (have_subst && !starred)
5693     goto invalid;
5694
5695   if (matched)
5696     {
5697       /* Copy the substitution body to permanent storage and execute it.
5698          If have_subst is false, this is a simple matter of running the
5699          body through do_spec_1...  */
5700       char *string = save_string (body, end_body - body);
5701       if (!have_subst)
5702         {
5703           if (do_spec_1 (string, 0, NULL) < 0)
5704             return 0;
5705         }
5706       else
5707         {
5708           /* ... but if have_subst is true, we have to process the
5709              body once for each matching switch, with %* set to the
5710              variant part of the switch.  */
5711           unsigned int hard_match_len = end_atom - atom;
5712           int i;
5713
5714           for (i = 0; i < n_switches; i++)
5715             if (!strncmp (switches[i].part1, atom, hard_match_len)
5716                 && check_live_switch (i, hard_match_len))
5717               {
5718                 if (do_spec_1 (string, 0,
5719                                &switches[i].part1[hard_match_len]) < 0)
5720                   return 0;
5721                 /* Pass any arguments this switch has.  */
5722                 give_switch (i, 1);
5723                 suffix_subst = NULL;
5724               }
5725         }
5726     }
5727
5728   return p;
5729
5730  invalid:
5731   fatal_error ("braced spec body %qs is invalid", body);
5732 }
5733 \f
5734 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
5735    on the command line.  PREFIX_LENGTH is the length of XXX in an {XXX*}
5736    spec, or -1 if either exact match or %* is used.
5737
5738    A -O switch is obsoleted by a later -O switch.  A -f, -m, or -W switch
5739    whose value does not begin with "no-" is obsoleted by the same value
5740    with the "no-", similarly for a switch with the "no-" prefix.  */
5741
5742 static int
5743 check_live_switch (int switchnum, int prefix_length)
5744 {
5745   const char *name = switches[switchnum].part1;
5746   int i;
5747
5748   /* If we already processed this switch and determined if it was
5749      live or not, return our past determination.  */
5750   if (switches[switchnum].live_cond != 0)
5751     return ((switches[switchnum].live_cond & SWITCH_LIVE) != 0
5752             && (switches[switchnum].live_cond & SWITCH_FALSE) == 0
5753             && (switches[switchnum].live_cond & SWITCH_IGNORE_PERMANENTLY)
5754                == 0);
5755
5756   /* In the common case of {<at-most-one-letter>*}, a negating
5757      switch would always match, so ignore that case.  We will just
5758      send the conflicting switches to the compiler phase.  */
5759   if (prefix_length >= 0 && prefix_length <= 1)
5760     return 1;
5761
5762   /* Now search for duplicate in a manner that depends on the name.  */
5763   switch (*name)
5764     {
5765     case 'O':
5766       for (i = switchnum + 1; i < n_switches; i++)
5767         if (switches[i].part1[0] == 'O')
5768           {
5769             switches[switchnum].validated = 1;
5770             switches[switchnum].live_cond = SWITCH_FALSE;
5771             return 0;
5772           }
5773       break;
5774
5775     case 'W':  case 'f':  case 'm':
5776       if (! strncmp (name + 1, "no-", 3))
5777         {
5778           /* We have Xno-YYY, search for XYYY.  */
5779           for (i = switchnum + 1; i < n_switches; i++)
5780             if (switches[i].part1[0] == name[0]
5781                 && ! strcmp (&switches[i].part1[1], &name[4]))
5782               {
5783                 switches[switchnum].validated = 1;
5784                 switches[switchnum].live_cond = SWITCH_FALSE;
5785                 return 0;
5786               }
5787         }
5788       else
5789         {
5790           /* We have XYYY, search for Xno-YYY.  */
5791           for (i = switchnum + 1; i < n_switches; i++)
5792             if (switches[i].part1[0] == name[0]
5793                 && switches[i].part1[1] == 'n'
5794                 && switches[i].part1[2] == 'o'
5795                 && switches[i].part1[3] == '-'
5796                 && !strcmp (&switches[i].part1[4], &name[1]))
5797               {
5798                 switches[switchnum].validated = 1;
5799                 switches[switchnum].live_cond = SWITCH_FALSE;
5800                 return 0;
5801               }
5802         }
5803       break;
5804     }
5805
5806   /* Otherwise the switch is live.  */
5807   switches[switchnum].live_cond |= SWITCH_LIVE;
5808   return 1;
5809 }
5810 \f
5811 /* Pass a switch to the current accumulating command
5812    in the same form that we received it.
5813    SWITCHNUM identifies the switch; it is an index into
5814    the vector of switches gcc received, which is `switches'.
5815    This cannot fail since it never finishes a command line.
5816
5817    If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument.  */
5818
5819 static void
5820 give_switch (int switchnum, int omit_first_word)
5821 {
5822   if ((switches[switchnum].live_cond & SWITCH_IGNORE) != 0)
5823     return;
5824
5825   if (!omit_first_word)
5826     {
5827       do_spec_1 ("-", 0, NULL);
5828       do_spec_1 (switches[switchnum].part1, 1, NULL);
5829     }
5830
5831   if (switches[switchnum].args != 0)
5832     {
5833       const char **p;
5834       for (p = switches[switchnum].args; *p; p++)
5835         {
5836           const char *arg = *p;
5837
5838           do_spec_1 (" ", 0, NULL);
5839           if (suffix_subst)
5840             {
5841               unsigned length = strlen (arg);
5842               int dot = 0;
5843
5844               while (length-- && !IS_DIR_SEPARATOR (arg[length]))
5845                 if (arg[length] == '.')
5846                   {
5847                     (CONST_CAST(char *, arg))[length] = 0;
5848                     dot = 1;
5849                     break;
5850                   }
5851               do_spec_1 (arg, 1, NULL);
5852               if (dot)
5853                 (CONST_CAST(char *, arg))[length] = '.';
5854               do_spec_1 (suffix_subst, 1, NULL);
5855             }
5856           else
5857             do_spec_1 (arg, 1, NULL);
5858         }
5859     }
5860
5861   do_spec_1 (" ", 0, NULL);
5862   switches[switchnum].validated = 1;
5863 }
5864 \f
5865 /* Search for a file named NAME trying various prefixes including the
5866    user's -B prefix and some standard ones.
5867    Return the absolute file name found.  If nothing is found, return NAME.  */
5868
5869 static const char *
5870 find_file (const char *name)
5871 {
5872   char *newname = find_a_file (&startfile_prefixes, name, R_OK, true);
5873   return newname ? newname : name;
5874 }
5875
5876 /* Determine whether a directory exists.  If LINKER, return 0 for
5877    certain fixed names not needed by the linker.  */
5878
5879 static int
5880 is_directory (const char *path1, bool linker)
5881 {
5882   int len1;
5883   char *path;
5884   char *cp;
5885   struct stat st;
5886
5887   /* Ensure the string ends with "/.".  The resulting path will be a
5888      directory even if the given path is a symbolic link.  */
5889   len1 = strlen (path1);
5890   path = (char *) alloca (3 + len1);
5891   memcpy (path, path1, len1);
5892   cp = path + len1;
5893   if (!IS_DIR_SEPARATOR (cp[-1]))
5894     *cp++ = DIR_SEPARATOR;
5895   *cp++ = '.';
5896   *cp = '\0';
5897
5898   /* Exclude directories that the linker is known to search.  */
5899   if (linker
5900       && IS_DIR_SEPARATOR (path[0])
5901       && ((cp - path == 6
5902            && strncmp (path + 1, "lib", 3) == 0)
5903           || (cp - path == 10
5904               && strncmp (path + 1, "usr", 3) == 0
5905               && IS_DIR_SEPARATOR (path[4])
5906               && strncmp (path + 5, "lib", 3) == 0)))
5907     return 0;
5908
5909   return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
5910 }
5911
5912 /* Set up the various global variables to indicate that we're processing
5913    the input file named FILENAME.  */
5914
5915 void
5916 set_input (const char *filename)
5917 {
5918   const char *p;
5919
5920   gcc_input_filename = filename;
5921   input_filename_length = strlen (gcc_input_filename);
5922   input_basename = lbasename (gcc_input_filename);
5923
5924   /* Find a suffix starting with the last period,
5925      and set basename_length to exclude that suffix.  */
5926   basename_length = strlen (input_basename);
5927   suffixed_basename_length = basename_length;
5928   p = input_basename + basename_length;
5929   while (p != input_basename && *p != '.')
5930     --p;
5931   if (*p == '.' && p != input_basename)
5932     {
5933       basename_length = p - input_basename;
5934       input_suffix = p + 1;
5935     }
5936   else
5937     input_suffix = "";
5938
5939   /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
5940      we will need to do a stat on the gcc_input_filename.  The
5941      INPUT_STAT_SET signals that the stat is needed.  */
5942   input_stat_set = 0;
5943 }
5944 \f
5945 /* On fatal signals, delete all the temporary files.  */
5946
5947 static void
5948 fatal_signal (int signum)
5949 {
5950   signal (signum, SIG_DFL);
5951   delete_failure_queue ();
5952   delete_temp_files ();
5953   /* Get the same signal again, this time not handled,
5954      so its normal effect occurs.  */
5955   kill (getpid (), signum);
5956 }
5957
5958 /* Compare the contents of the two files named CMPFILE[0] and
5959    CMPFILE[1].  Return zero if they're identical, nonzero
5960    otherwise.  */
5961
5962 static int
5963 compare_files (char *cmpfile[])
5964 {
5965   int ret = 0;
5966   FILE *temp[2] = { NULL, NULL };
5967   int i;
5968
5969 #if HAVE_MMAP_FILE
5970   {
5971     size_t length[2];
5972     void *map[2] = { NULL, NULL };
5973
5974     for (i = 0; i < 2; i++)
5975       {
5976         struct stat st;
5977
5978         if (stat (cmpfile[i], &st) < 0 || !S_ISREG (st.st_mode))
5979           {
5980             error ("%s: could not determine length of compare-debug file %s",
5981                    gcc_input_filename, cmpfile[i]);
5982             ret = 1;
5983             break;
5984           }
5985
5986         length[i] = st.st_size;
5987       }
5988
5989     if (!ret && length[0] != length[1])
5990       {
5991         error ("%s: -fcompare-debug failure (length)", gcc_input_filename);
5992         ret = 1;
5993       }
5994
5995     if (!ret)
5996       for (i = 0; i < 2; i++)
5997         {
5998           int fd = open (cmpfile[i], O_RDONLY);
5999           if (fd < 0)
6000             {
6001               error ("%s: could not open compare-debug file %s",
6002                      gcc_input_filename, cmpfile[i]);
6003               ret = 1;
6004               break;
6005             }
6006
6007           map[i] = mmap (NULL, length[i], PROT_READ, MAP_PRIVATE, fd, 0);
6008           close (fd);
6009
6010           if (map[i] == (void *) MAP_FAILED)
6011             {
6012               ret = -1;
6013               break;
6014             }
6015         }
6016
6017     if (!ret)
6018       {
6019         if (memcmp (map[0], map[1], length[0]) != 0)
6020           {
6021             error ("%s: -fcompare-debug failure", gcc_input_filename);
6022             ret = 1;
6023           }
6024       }
6025
6026     for (i = 0; i < 2; i++)
6027       if (map[i])
6028         munmap ((caddr_t) map[i], length[i]);
6029
6030     if (ret >= 0)
6031       return ret;
6032
6033     ret = 0;
6034   }
6035 #endif
6036
6037   for (i = 0; i < 2; i++)
6038     {
6039       temp[i] = fopen (cmpfile[i], "r");
6040       if (!temp[i])
6041         {
6042           error ("%s: could not open compare-debug file %s",
6043                  gcc_input_filename, cmpfile[i]);
6044           ret = 1;
6045           break;
6046         }
6047     }
6048
6049   if (!ret && temp[0] && temp[1])
6050     for (;;)
6051       {
6052         int c0, c1;
6053         c0 = fgetc (temp[0]);
6054         c1 = fgetc (temp[1]);
6055
6056         if (c0 != c1)
6057           {
6058             error ("%s: -fcompare-debug failure",
6059                    gcc_input_filename);
6060             ret = 1;
6061             break;
6062           }
6063
6064         if (c0 == EOF)
6065           break;
6066       }
6067
6068   for (i = 1; i >= 0; i--)
6069     {
6070       if (temp[i])
6071         fclose (temp[i]);
6072     }
6073
6074   return ret;
6075 }
6076
6077 extern int main (int, char **);
6078
6079 int
6080 main (int argc, char **argv)
6081 {
6082   size_t i;
6083   int value;
6084   int linker_was_run = 0;
6085   int lang_n_infiles = 0;
6086   int num_linker_inputs = 0;
6087   char *explicit_link_files;
6088   char *specs_file;
6089   char *lto_wrapper_file;
6090   const char *p;
6091   struct user_specs *uptr;
6092   char **old_argv = argv;
6093   struct cl_decoded_option *decoded_options;
6094   unsigned int decoded_options_count;
6095
6096   /* Initialize here, not in definition.  The IRIX 6 O32 cc sometimes chokes
6097      on ?: in file-scope variable initializations.  */
6098   asm_debug = ASM_DEBUG_SPEC;
6099
6100   p = argv[0] + strlen (argv[0]);
6101   while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
6102     --p;
6103   progname = p;
6104
6105   xmalloc_set_program_name (progname);
6106
6107   expandargv (&argc, &argv);
6108
6109   /* Determine if any expansions were made.  */
6110   if (argv != old_argv)
6111     at_file_supplied = true;
6112
6113   global_options = global_options_init;
6114
6115   decode_cmdline_options_to_array (argc, CONST_CAST2 (const char **, char **,
6116                                                       argv),
6117                                    CL_DRIVER,
6118                                    &decoded_options, &decoded_options_count);
6119
6120 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6121   /* Perform host dependent initialization when needed.  */
6122   GCC_DRIVER_HOST_INITIALIZATION;
6123 #endif
6124
6125   /* Unlock the stdio streams.  */
6126   unlock_std_streams ();
6127
6128   gcc_init_libintl ();
6129
6130   diagnostic_initialize (global_dc, 0);
6131   if (atexit (delete_temp_files) != 0)
6132     fatal_error ("atexit failed");
6133
6134   if (signal (SIGINT, SIG_IGN) != SIG_IGN)
6135     signal (SIGINT, fatal_signal);
6136 #ifdef SIGHUP
6137   if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
6138     signal (SIGHUP, fatal_signal);
6139 #endif
6140   if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
6141     signal (SIGTERM, fatal_signal);
6142 #ifdef SIGPIPE
6143   if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
6144     signal (SIGPIPE, fatal_signal);
6145 #endif
6146 #ifdef SIGCHLD
6147   /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6148      receive the signal.  A different setting is inheritable */
6149   signal (SIGCHLD, SIG_DFL);
6150 #endif
6151
6152   /* Allocate the argument vector.  */
6153   alloc_args ();
6154
6155   obstack_init (&obstack);
6156
6157   /* Build multilib_select, et. al from the separate lines that make up each
6158      multilib selection.  */
6159   {
6160     const char *const *q = multilib_raw;
6161     int need_space;
6162
6163     obstack_init (&multilib_obstack);
6164     while ((p = *q++) != (char *) 0)
6165       obstack_grow (&multilib_obstack, p, strlen (p));
6166
6167     obstack_1grow (&multilib_obstack, 0);
6168     multilib_select = XOBFINISH (&multilib_obstack, const char *);
6169
6170     q = multilib_matches_raw;
6171     while ((p = *q++) != (char *) 0)
6172       obstack_grow (&multilib_obstack, p, strlen (p));
6173
6174     obstack_1grow (&multilib_obstack, 0);
6175     multilib_matches = XOBFINISH (&multilib_obstack, const char *);
6176
6177     q = multilib_exclusions_raw;
6178     while ((p = *q++) != (char *) 0)
6179       obstack_grow (&multilib_obstack, p, strlen (p));
6180
6181     obstack_1grow (&multilib_obstack, 0);
6182     multilib_exclusions = XOBFINISH (&multilib_obstack, const char *);
6183
6184     need_space = FALSE;
6185     for (i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++)
6186       {
6187         if (need_space)
6188           obstack_1grow (&multilib_obstack, ' ');
6189         obstack_grow (&multilib_obstack,
6190                       multilib_defaults_raw[i],
6191                       strlen (multilib_defaults_raw[i]));
6192         need_space = TRUE;
6193       }
6194
6195     obstack_1grow (&multilib_obstack, 0);
6196     multilib_defaults = XOBFINISH (&multilib_obstack, const char *);
6197   }
6198
6199 #ifdef INIT_ENVIRONMENT
6200   /* Set up any other necessary machine specific environment variables.  */
6201   xputenv (INIT_ENVIRONMENT);
6202 #endif
6203
6204   /* Make a table of what switches there are (switches, n_switches).
6205      Make a table of specified input files (infiles, n_infiles).
6206      Decode switches that are handled locally.  */
6207
6208   process_command (decoded_options_count, decoded_options);
6209
6210   /* Initialize the vector of specs to just the default.
6211      This means one element containing 0s, as a terminator.  */
6212
6213   compilers = XNEWVAR (struct compiler, sizeof default_compilers);
6214   memcpy (compilers, default_compilers, sizeof default_compilers);
6215   n_compilers = n_default_compilers;
6216
6217   /* Read specs from a file if there is one.  */
6218
6219   machine_suffix = concat (spec_machine, dir_separator_str,
6220                            spec_version, dir_separator_str, NULL);
6221   just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
6222
6223   specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, true);
6224   /* Read the specs file unless it is a default one.  */
6225   if (specs_file != 0 && strcmp (specs_file, "specs"))
6226     read_specs (specs_file, TRUE);
6227   else
6228     init_spec ();
6229
6230   /* We need to check standard_exec_prefix/just_machine_suffix/specs
6231      for any override of as, ld and libraries.  */
6232   specs_file = (char *) alloca (strlen (standard_exec_prefix)
6233                        + strlen (just_machine_suffix) + sizeof ("specs"));
6234
6235   strcpy (specs_file, standard_exec_prefix);
6236   strcat (specs_file, just_machine_suffix);
6237   strcat (specs_file, "specs");
6238   if (access (specs_file, R_OK) == 0)
6239     read_specs (specs_file, TRUE);
6240
6241   /* Process any configure-time defaults specified for the command line
6242      options, via OPTION_DEFAULT_SPECS.  */
6243   for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
6244     do_option_spec (option_default_specs[i].name,
6245                     option_default_specs[i].spec);
6246
6247   /* Process DRIVER_SELF_SPECS, adding any new options to the end
6248      of the command line.  */
6249
6250   for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++)
6251     do_self_spec (driver_self_specs[i]);
6252
6253   if (compare_debug)
6254     {
6255       enum save_temps save;
6256
6257       if (!compare_debug_second)
6258         {
6259           n_switches_debug_check[1] = n_switches;
6260           n_switches_alloc_debug_check[1] = n_switches_alloc;
6261           switches_debug_check[1] = XDUPVEC (struct switchstr, switches,
6262                                              n_switches_alloc);
6263
6264           do_self_spec ("%:compare-debug-self-opt()");
6265           n_switches_debug_check[0] = n_switches;
6266           n_switches_alloc_debug_check[0] = n_switches_alloc;
6267           switches_debug_check[0] = switches;
6268
6269           n_switches = n_switches_debug_check[1];
6270           n_switches_alloc = n_switches_alloc_debug_check[1];
6271           switches = switches_debug_check[1];
6272         }
6273
6274       /* Avoid crash when computing %j in this early.  */
6275       save = save_temps_flag;
6276       save_temps_flag = SAVE_TEMPS_NONE;
6277
6278       compare_debug = -compare_debug;
6279       do_self_spec ("%:compare-debug-self-opt()");
6280
6281       save_temps_flag = save;
6282
6283       if (!compare_debug_second)
6284         {
6285           n_switches_debug_check[1] = n_switches;
6286           n_switches_alloc_debug_check[1] = n_switches_alloc;
6287           switches_debug_check[1] = switches;
6288           compare_debug = -compare_debug;
6289           n_switches = n_switches_debug_check[0];
6290           n_switches_alloc = n_switches_debug_check[0];
6291           switches = switches_debug_check[0];
6292         }
6293     }
6294
6295   /* If not cross-compiling, look for executables in the standard
6296      places.  */
6297   if (*cross_compile == '0')
6298     {
6299       if (*md_exec_prefix)
6300         {
6301           add_prefix (&exec_prefixes, md_exec_prefix, "GCC",
6302                       PREFIX_PRIORITY_LAST, 0, 0);
6303         }
6304     }
6305
6306   /* Process sysroot_suffix_spec.  */
6307   if (*sysroot_suffix_spec != 0
6308       && do_spec_2 (sysroot_suffix_spec) == 0)
6309     {
6310       if (VEC_length (const_char_p, argbuf) > 1)
6311         error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
6312       else if (VEC_length (const_char_p, argbuf) == 1)
6313         target_sysroot_suffix = xstrdup (VEC_last (const_char_p, argbuf));
6314     }
6315
6316 #ifdef HAVE_LD_SYSROOT
6317   /* Pass the --sysroot option to the linker, if it supports that.  If
6318      there is a sysroot_suffix_spec, it has already been processed by
6319      this point, so target_system_root really is the system root we
6320      should be using.  */
6321   if (target_system_root)
6322     {
6323       obstack_grow (&obstack, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
6324       obstack_grow0 (&obstack, link_spec, strlen (link_spec));
6325       set_spec ("link", XOBFINISH (&obstack, const char *));
6326     }
6327 #endif
6328
6329   /* Process sysroot_hdrs_suffix_spec.  */
6330   if (*sysroot_hdrs_suffix_spec != 0
6331       && do_spec_2 (sysroot_hdrs_suffix_spec) == 0)
6332     {
6333       if (VEC_length (const_char_p, argbuf) > 1)
6334         error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
6335       else if (VEC_length (const_char_p, argbuf) == 1)
6336         target_sysroot_hdrs_suffix = xstrdup (VEC_last (const_char_p, argbuf));
6337     }
6338
6339   /* Look for startfiles in the standard places.  */
6340   if (*startfile_prefix_spec != 0
6341       && do_spec_2 (startfile_prefix_spec) == 0
6342       && do_spec_1 (" ", 0, NULL) == 0)
6343     {
6344       const char *arg;
6345       int ndx;
6346       FOR_EACH_VEC_ELT (const_char_p, argbuf, ndx, arg)
6347         add_sysrooted_prefix (&startfile_prefixes, arg, "BINUTILS",
6348                               PREFIX_PRIORITY_LAST, 0, 1);
6349     }
6350   /* We should eventually get rid of all these and stick to
6351      startfile_prefix_spec exclusively.  */
6352   else if (*cross_compile == '0' || target_system_root)
6353     {
6354       if (*md_startfile_prefix)
6355         add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix,
6356                               "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6357
6358       if (*md_startfile_prefix_1)
6359         add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix_1,
6360                               "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6361
6362       /* If standard_startfile_prefix is relative, base it on
6363          standard_exec_prefix.  This lets us move the installed tree
6364          as a unit.  If GCC_EXEC_PREFIX is defined, base
6365          standard_startfile_prefix on that as well.
6366
6367          If the prefix is relative, only search it for native compilers;
6368          otherwise we will search a directory containing host libraries.  */
6369       if (IS_ABSOLUTE_PATH (standard_startfile_prefix))
6370         add_sysrooted_prefix (&startfile_prefixes,
6371                               standard_startfile_prefix, "BINUTILS",
6372                               PREFIX_PRIORITY_LAST, 0, 1);
6373       else if (*cross_compile == '0')
6374         {
6375           add_prefix (&startfile_prefixes,
6376                       concat (gcc_exec_prefix
6377                               ? gcc_exec_prefix : standard_exec_prefix,
6378                               machine_suffix,
6379                               standard_startfile_prefix, NULL),
6380                       NULL, PREFIX_PRIORITY_LAST, 0, 1);
6381         }
6382
6383       /* Sysrooted prefixes are relocated because target_system_root is
6384          also relocated by gcc_exec_prefix.  */
6385       if (*standard_startfile_prefix_1)
6386         add_sysrooted_prefix (&startfile_prefixes,
6387                               standard_startfile_prefix_1, "BINUTILS",
6388                               PREFIX_PRIORITY_LAST, 0, 1);
6389       if (*standard_startfile_prefix_2)
6390         add_sysrooted_prefix (&startfile_prefixes,
6391                               standard_startfile_prefix_2, "BINUTILS",
6392                               PREFIX_PRIORITY_LAST, 0, 1);
6393     }
6394
6395   /* Process any user specified specs in the order given on the command
6396      line.  */
6397   for (uptr = user_specs_head; uptr; uptr = uptr->next)
6398     {
6399       char *filename = find_a_file (&startfile_prefixes, uptr->filename,
6400                                     R_OK, true);
6401       read_specs (filename ? filename : uptr->filename, FALSE);
6402     }
6403
6404   /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake.  */
6405   if (gcc_exec_prefix)
6406     gcc_exec_prefix = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
6407                               spec_version, dir_separator_str, NULL);
6408
6409   /* Now we have the specs.
6410      Set the `valid' bits for switches that match anything in any spec.  */
6411
6412   validate_all_switches ();
6413
6414   /* Now that we have the switches and the specs, set
6415      the subdirectory based on the options.  */
6416   set_multilib_dir ();
6417
6418   /* Set up to remember the pathname of gcc and any options
6419      needed for collect.  We use argv[0] instead of progname because
6420      we need the complete pathname.  */
6421   obstack_init (&collect_obstack);
6422   obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
6423   obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1);
6424   xputenv (XOBFINISH (&collect_obstack, char *));
6425
6426   /* Set up to remember the pathname of the lto wrapper. */
6427
6428   lto_wrapper_file = find_a_file (&exec_prefixes, "lto-wrapper", X_OK, false);
6429   if (lto_wrapper_file)
6430     {
6431       lto_wrapper_spec = lto_wrapper_file;
6432       obstack_init (&collect_obstack);
6433       obstack_grow (&collect_obstack, "COLLECT_LTO_WRAPPER=",
6434                     sizeof ("COLLECT_LTO_WRAPPER=") - 1);
6435       obstack_grow (&collect_obstack, lto_wrapper_spec,
6436                     strlen (lto_wrapper_spec) + 1);
6437       xputenv (XOBFINISH (&collect_obstack, char *));
6438     }
6439
6440   /* Warn about any switches that no pass was interested in.  */
6441
6442   for (i = 0; (int) i < n_switches; i++)
6443     if (! switches[i].validated)
6444       error ("unrecognized option %<-%s%>", switches[i].part1);
6445
6446   /* Obey some of the options.  */
6447
6448   if (print_search_dirs)
6449     {
6450       printf (_("install: %s%s\n"),
6451               gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
6452               gcc_exec_prefix ? "" : machine_suffix);
6453       printf (_("programs: %s\n"),
6454               build_search_list (&exec_prefixes, "", false, false));
6455       printf (_("libraries: %s\n"),
6456               build_search_list (&startfile_prefixes, "", false, true));
6457       return (0);
6458     }
6459
6460   if (print_file_name)
6461     {
6462       printf ("%s\n", find_file (print_file_name));
6463       return (0);
6464     }
6465
6466   if (print_prog_name)
6467     {
6468       char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK, 0);
6469       printf ("%s\n", (newname ? newname : print_prog_name));
6470       return (0);
6471     }
6472
6473   if (print_multi_lib)
6474     {
6475       print_multilib_info ();
6476       return (0);
6477     }
6478
6479   if (print_multi_directory)
6480     {
6481       if (multilib_dir == NULL)
6482         printf (".\n");
6483       else
6484         printf ("%s\n", multilib_dir);
6485       return (0);
6486     }
6487
6488   if (print_sysroot)
6489     {
6490       if (target_system_root)
6491         {
6492           if (target_sysroot_suffix)
6493             printf ("%s%s\n", target_system_root, target_sysroot_suffix);
6494           else
6495             printf ("%s\n", target_system_root);
6496         }
6497       return (0);
6498     }
6499
6500   if (print_multi_os_directory)
6501     {
6502       if (multilib_os_dir == NULL)
6503         printf (".\n");
6504       else
6505         printf ("%s\n", multilib_os_dir);
6506       return (0);
6507     }
6508
6509   if (print_sysroot_headers_suffix)
6510     {
6511       if (*sysroot_hdrs_suffix_spec)
6512         {
6513           printf("%s\n", (target_sysroot_hdrs_suffix
6514                           ? target_sysroot_hdrs_suffix
6515                           : ""));
6516           return (0);
6517         }
6518       else
6519         /* The error status indicates that only one set of fixed
6520            headers should be built.  */
6521         fatal_error ("not configured with sysroot headers suffix");
6522     }
6523
6524   if (print_help_list)
6525     {
6526       display_help ();
6527
6528       if (! verbose_flag)
6529         {
6530           printf (_("\nFor bug reporting instructions, please see:\n"));
6531           printf ("%s.\n", bug_report_url);
6532
6533           return (0);
6534         }
6535
6536       /* We do not exit here.  Instead we have created a fake input file
6537          called 'help-dummy' which needs to be compiled, and we pass this
6538          on the various sub-processes, along with the --help switch.
6539          Ensure their output appears after ours.  */
6540       fputc ('\n', stdout);
6541       fflush (stdout);
6542     }
6543
6544   if (print_version)
6545     {
6546       printf (_("%s %s%s\n"), progname, pkgversion_string,
6547               version_string);
6548       printf ("Copyright %s 2011 Free Software Foundation, Inc.\n",
6549               _("(C)"));
6550       fputs (_("This is free software; see the source for copying conditions.  There is NO\n\
6551 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
6552              stdout);
6553       if (! verbose_flag)
6554         return 0;
6555
6556       /* We do not exit here. We use the same mechanism of --help to print
6557          the version of the sub-processes. */
6558       fputc ('\n', stdout);
6559       fflush (stdout);
6560     }
6561
6562   if (verbose_flag)
6563     {
6564       int n;
6565       const char *thrmod;
6566
6567       fnotice (stderr, "Target: %s\n", spec_machine);
6568       fnotice (stderr, "Configured with: %s\n", configuration_arguments);
6569
6570 #ifdef THREAD_MODEL_SPEC
6571       /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
6572          but there's no point in doing all this processing just to get
6573          thread_model back.  */
6574       obstack_init (&obstack);
6575       do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model);
6576       obstack_1grow (&obstack, '\0');
6577       thrmod = XOBFINISH (&obstack, const char *);
6578 #else
6579       thrmod = thread_model;
6580 #endif
6581
6582       fnotice (stderr, "Thread model: %s\n", thrmod);
6583
6584       /* compiler_version is truncated at the first space when initialized
6585          from version string, so truncate version_string at the first space
6586          before comparing.  */
6587       for (n = 0; version_string[n]; n++)
6588         if (version_string[n] == ' ')
6589           break;
6590
6591       if (! strncmp (version_string, compiler_version, n)
6592           && compiler_version[n] == 0)
6593         fnotice (stderr, "gcc version %s %s\n", version_string,
6594                  pkgversion_string);
6595       else
6596         fnotice (stderr, "gcc driver version %s %sexecuting gcc version %s\n",
6597                  version_string, pkgversion_string, compiler_version);
6598
6599       if (n_infiles == 0)
6600         return (0);
6601     }
6602
6603   if (n_infiles == added_libraries)
6604     fatal_error ("no input files");
6605
6606   if (seen_error ())
6607     goto out;
6608
6609   /* Make a place to record the compiler output file names
6610      that correspond to the input files.  */
6611
6612   i = n_infiles;
6613   i += lang_specific_extra_outfiles;
6614   outfiles = XCNEWVEC (const char *, i);
6615
6616   /* Record which files were specified explicitly as link input.  */
6617
6618   explicit_link_files = XCNEWVEC (char, n_infiles);
6619
6620   combine_inputs = have_o || flag_wpa;
6621
6622   for (i = 0; (int) i < n_infiles; i++)
6623     {
6624       const char *name = infiles[i].name;
6625       struct compiler *compiler = lookup_compiler (name,
6626                                                    strlen (name),
6627                                                    infiles[i].language);
6628
6629       if (compiler && !(compiler->combinable))
6630         combine_inputs = false;
6631
6632       if (lang_n_infiles > 0 && compiler != input_file_compiler
6633           && infiles[i].language && infiles[i].language[0] != '*')
6634         infiles[i].incompiler = compiler;
6635       else if (compiler)
6636         {
6637           lang_n_infiles++;
6638           input_file_compiler = compiler;
6639           infiles[i].incompiler = compiler;
6640         }
6641       else
6642         {
6643           /* Since there is no compiler for this input file, assume it is a
6644              linker file.  */
6645           explicit_link_files[i] = 1;
6646           infiles[i].incompiler = NULL;
6647         }
6648       infiles[i].compiled = false;
6649       infiles[i].preprocessed = false;
6650     }
6651
6652   if (!combine_inputs && have_c && have_o && lang_n_infiles > 1)
6653     fatal_error ("cannot specify -o with -c, -S or -E with multiple files");
6654
6655   for (i = 0; (int) i < n_infiles; i++)
6656     {
6657       int this_file_error = 0;
6658
6659       /* Tell do_spec what to substitute for %i.  */
6660
6661       input_file_number = i;
6662       set_input (infiles[i].name);
6663
6664       if (infiles[i].compiled)
6665         continue;
6666
6667       /* Use the same thing in %o, unless cp->spec says otherwise.  */
6668
6669       outfiles[i] = gcc_input_filename;
6670
6671       /* Figure out which compiler from the file's suffix.  */
6672
6673       input_file_compiler
6674         = lookup_compiler (infiles[i].name, input_filename_length,
6675                            infiles[i].language);
6676
6677       if (input_file_compiler)
6678         {
6679           /* Ok, we found an applicable compiler.  Run its spec.  */
6680
6681           if (input_file_compiler->spec[0] == '#')
6682             {
6683               error ("%s: %s compiler not installed on this system",
6684                      gcc_input_filename, &input_file_compiler->spec[1]);
6685               this_file_error = 1;
6686             }
6687           else
6688             {
6689               if (compare_debug)
6690                 {
6691                   if (debug_check_temp_file[0])
6692                     free (debug_check_temp_file[0]);
6693                   debug_check_temp_file[0] = NULL;
6694
6695                   if (debug_check_temp_file[1])
6696                     free (debug_check_temp_file[1]);
6697                   debug_check_temp_file[1] = NULL;
6698                 }
6699
6700               value = do_spec (input_file_compiler->spec);
6701               infiles[i].compiled = true;
6702               if (value < 0)
6703                 this_file_error = 1;
6704               else if (compare_debug && debug_check_temp_file[0])
6705                 {
6706                   if (verbose_flag)
6707                     inform (0, "recompiling with -fcompare-debug");
6708
6709                   compare_debug = -compare_debug;
6710                   n_switches = n_switches_debug_check[1];
6711                   n_switches_alloc = n_switches_alloc_debug_check[1];
6712                   switches = switches_debug_check[1];
6713
6714                   value = do_spec (input_file_compiler->spec);
6715
6716                   compare_debug = -compare_debug;
6717                   n_switches = n_switches_debug_check[0];
6718                   n_switches_alloc = n_switches_alloc_debug_check[0];
6719                   switches = switches_debug_check[0];
6720
6721                   if (value < 0)
6722                     {
6723                       error ("during -fcompare-debug recompilation");
6724                       this_file_error = 1;
6725                     }
6726
6727                   gcc_assert (debug_check_temp_file[1]
6728                               && strcmp (debug_check_temp_file[0],
6729                                          debug_check_temp_file[1]));
6730
6731                   if (verbose_flag)
6732                     inform (0, "comparing final insns dumps");
6733
6734                   if (compare_files (debug_check_temp_file))
6735                     this_file_error = 1;
6736                 }
6737
6738               if (compare_debug)
6739                 {
6740                   if (debug_check_temp_file[0])
6741                     free (debug_check_temp_file[0]);
6742                   debug_check_temp_file[0] = NULL;
6743
6744                   if (debug_check_temp_file[1])
6745                     free (debug_check_temp_file[1]);
6746                   debug_check_temp_file[1] = NULL;
6747                 }
6748             }
6749         }
6750
6751       /* If this file's name does not contain a recognized suffix,
6752          record it as explicit linker input.  */
6753
6754       else
6755         explicit_link_files[i] = 1;
6756
6757       /* Clear the delete-on-failure queue, deleting the files in it
6758          if this compilation failed.  */
6759
6760       if (this_file_error)
6761         {
6762           delete_failure_queue ();
6763           errorcount++;
6764         }
6765       /* If this compilation succeeded, don't delete those files later.  */
6766       clear_failure_queue ();
6767     }
6768
6769   /* Reset the input file name to the first compile/object file name, for use
6770      with %b in LINK_SPEC. We use the first input file that we can find
6771      a compiler to compile it instead of using infiles.language since for
6772      languages other than C we use aliases that we then lookup later.  */
6773   if (n_infiles > 0)
6774     {
6775       int i;
6776
6777       for (i = 0; i < n_infiles ; i++)
6778         if (infiles[i].incompiler
6779             || (infiles[i].language && infiles[i].language[0] != '*'))
6780           {
6781             set_input (infiles[i].name);
6782             break;
6783           }
6784     }
6785
6786   if (!seen_error ())
6787     {
6788       /* Make sure INPUT_FILE_NUMBER points to first available open
6789          slot.  */
6790       input_file_number = n_infiles;
6791       if (lang_specific_pre_link ())
6792         errorcount++;
6793     }
6794
6795   /* Determine if there are any linker input files.  */
6796   num_linker_inputs = 0;
6797   for (i = 0; (int) i < n_infiles; i++)
6798     if (explicit_link_files[i] || outfiles[i] != NULL)
6799       num_linker_inputs++;
6800
6801   /* Run ld to link all the compiler output files.  */
6802
6803   if (num_linker_inputs > 0 && !seen_error () && print_subprocess_help < 2)
6804     {
6805       int tmp = execution_count;
6806 #ifdef HAVE_LTO_PLUGIN
6807       const char *fno_use_linker_plugin = "fno-use-linker-plugin";
6808 #else
6809       const char *fuse_linker_plugin = "fuse-linker-plugin";
6810 #endif
6811
6812       /* We'll use ld if we can't find collect2.  */
6813       if (! strcmp (linker_name_spec, "collect2"))
6814         {
6815           char *s = find_a_file (&exec_prefixes, "collect2", X_OK, false);
6816           if (s == NULL)
6817             linker_name_spec = "ld";
6818         }
6819
6820 #ifdef HAVE_LTO_PLUGIN
6821       if (!switch_matches (fno_use_linker_plugin,
6822                            fno_use_linker_plugin + strlen (fno_use_linker_plugin), 0))
6823 #else
6824       if (switch_matches (fuse_linker_plugin,
6825                           fuse_linker_plugin + strlen (fuse_linker_plugin), 0))
6826 #endif
6827         {
6828           linker_plugin_file_spec = find_a_file (&exec_prefixes,
6829                                                  LTOPLUGINSONAME, R_OK,
6830                                                  false);
6831           if (!linker_plugin_file_spec)
6832             fatal_error ("-fuse-linker-plugin, but " LTOPLUGINSONAME " not found");
6833         }
6834       lto_gcc_spec = argv[0];
6835
6836       /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
6837          for collect.  */
6838       putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH", false);
6839       putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV, true);
6840
6841       if (print_subprocess_help == 1)
6842         {
6843           printf (_("\nLinker options\n==============\n\n"));
6844           printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
6845                     " to the linker.\n\n"));
6846           fflush (stdout);
6847         }
6848       value = do_spec (link_command_spec);
6849       if (value < 0)
6850         errorcount = 1;
6851       linker_was_run = (tmp != execution_count);
6852     }
6853
6854   /* If options said don't run linker,
6855      complain about input files to be given to the linker.  */
6856
6857   if (! linker_was_run && !seen_error ())
6858     for (i = 0; (int) i < n_infiles; i++)
6859       if (explicit_link_files[i]
6860           && !(infiles[i].language && infiles[i].language[0] == '*'))
6861         warning (0, "%s: linker input file unused because linking not done",
6862                  outfiles[i]);
6863
6864   /* Delete some or all of the temporary files we made.  */
6865
6866   if (seen_error ())
6867     delete_failure_queue ();
6868   delete_temp_files ();
6869
6870   if (print_help_list)
6871     {
6872       printf (("\nFor bug reporting instructions, please see:\n"));
6873       printf ("%s\n", bug_report_url);
6874     }
6875
6876  out:
6877   return (signal_count != 0 ? 2
6878           : seen_error () ? (pass_exit_codes ? greatest_status : 1)
6879           : 0);
6880 }
6881
6882 /* Find the proper compilation spec for the file name NAME,
6883    whose length is LENGTH.  LANGUAGE is the specified language,
6884    or 0 if this file is to be passed to the linker.  */
6885
6886 static struct compiler *
6887 lookup_compiler (const char *name, size_t length, const char *language)
6888 {
6889   struct compiler *cp;
6890
6891   /* If this was specified by the user to be a linker input, indicate that.  */
6892   if (language != 0 && language[0] == '*')
6893     return 0;
6894
6895   /* Otherwise, look for the language, if one is spec'd.  */
6896   if (language != 0)
6897     {
6898       for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
6899         if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
6900           return cp;
6901
6902       error ("language %s not recognized", language);
6903       return 0;
6904     }
6905
6906   /* Look for a suffix.  */
6907   for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
6908     {
6909       if (/* The suffix `-' matches only the file name `-'.  */
6910           (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
6911           || (strlen (cp->suffix) < length
6912               /* See if the suffix matches the end of NAME.  */
6913               && !strcmp (cp->suffix,
6914                           name + length - strlen (cp->suffix))
6915          ))
6916         break;
6917     }
6918
6919 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
6920   /* Look again, but case-insensitively this time.  */
6921   if (cp < compilers)
6922     for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
6923       {
6924         if (/* The suffix `-' matches only the file name `-'.  */
6925             (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
6926             || (strlen (cp->suffix) < length
6927                 /* See if the suffix matches the end of NAME.  */
6928                 && ((!strcmp (cp->suffix,
6929                              name + length - strlen (cp->suffix))
6930                      || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
6931                     && !strcasecmp (cp->suffix,
6932                                     name + length - strlen (cp->suffix)))
6933            ))
6934           break;
6935       }
6936 #endif
6937
6938   if (cp >= compilers)
6939     {
6940       if (cp->spec[0] != '@')
6941         /* A non-alias entry: return it.  */
6942         return cp;
6943
6944       /* An alias entry maps a suffix to a language.
6945          Search for the language; pass 0 for NAME and LENGTH
6946          to avoid infinite recursion if language not found.  */
6947       return lookup_compiler (NULL, 0, cp->spec + 1);
6948     }
6949   return 0;
6950 }
6951 \f
6952 static char *
6953 save_string (const char *s, int len)
6954 {
6955   char *result = XNEWVEC (char, len + 1);
6956
6957   memcpy (result, s, len);
6958   result[len] = 0;
6959   return result;
6960 }
6961
6962 void
6963 pfatal_with_name (const char *name)
6964 {
6965   perror_with_name (name);
6966   delete_temp_files ();
6967   exit (1);
6968 }
6969
6970 static void
6971 perror_with_name (const char *name)
6972 {
6973   error ("%s: %m", name);
6974 }
6975 \f
6976 static inline void
6977 validate_switches_from_spec (const char *spec)
6978 {
6979   const char *p = spec;
6980   char c;
6981   while ((c = *p++))
6982     if (c == '%' && (*p == '{' || *p == '<' || (*p == 'W' && *++p == '{')))
6983       /* We have a switch spec.  */
6984       p = validate_switches (p + 1);
6985 }
6986
6987 static void
6988 validate_all_switches (void)
6989 {
6990   struct compiler *comp;
6991   struct spec_list *spec;
6992
6993   for (comp = compilers; comp->spec; comp++)
6994     validate_switches_from_spec (comp->spec);
6995
6996   /* Look through the linked list of specs read from the specs file.  */
6997   for (spec = specs; spec; spec = spec->next)
6998     validate_switches_from_spec (*spec->ptr_spec);
6999
7000   validate_switches_from_spec (link_command_spec);
7001 }
7002
7003 /* Look at the switch-name that comes after START
7004    and mark as valid all supplied switches that match it.  */
7005
7006 static const char *
7007 validate_switches (const char *start)
7008 {
7009   const char *p = start;
7010   const char *atom;
7011   size_t len;
7012   int i;
7013   bool suffix = false;
7014   bool starred = false;
7015
7016 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7017
7018 next_member:
7019   SKIP_WHITE ();
7020
7021   if (*p == '!')
7022     p++;
7023
7024   SKIP_WHITE ();
7025   if (*p == '.' || *p == ',')
7026     suffix = true, p++;
7027
7028   atom = p;
7029   while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
7030          || *p == ',' || *p == '.' || *p == '@')
7031     p++;
7032   len = p - atom;
7033
7034   if (*p == '*')
7035     starred = true, p++;
7036
7037   SKIP_WHITE ();
7038
7039   if (!suffix)
7040     {
7041       /* Mark all matching switches as valid.  */
7042       for (i = 0; i < n_switches; i++)
7043         if (!strncmp (switches[i].part1, atom, len)
7044             && (starred || switches[i].part1[len] == 0))
7045           switches[i].validated = 1;
7046     }
7047
7048   if (*p) p++;
7049   if (*p && (p[-1] == '|' || p[-1] == '&'))
7050     goto next_member;
7051
7052   if (*p && p[-1] == ':')
7053     {
7054       while (*p && *p != ';' && *p != '}')
7055         {
7056           if (*p == '%')
7057             {
7058               p++;
7059               if (*p == '{' || *p == '<')
7060                 p = validate_switches (p+1);
7061               else if (p[0] == 'W' && p[1] == '{')
7062                 p = validate_switches (p+2);
7063             }
7064           else
7065             p++;
7066         }
7067
7068       if (*p) p++;
7069       if (*p && p[-1] == ';')
7070         goto next_member;
7071     }
7072
7073   return p;
7074 #undef SKIP_WHITE
7075 }
7076 \f
7077 struct mdswitchstr
7078 {
7079   const char *str;
7080   int len;
7081 };
7082
7083 static struct mdswitchstr *mdswitches;
7084 static int n_mdswitches;
7085
7086 /* Check whether a particular argument was used.  The first time we
7087    canonicalize the switches to keep only the ones we care about.  */
7088
7089 static int
7090 used_arg (const char *p, int len)
7091 {
7092   struct mswitchstr
7093   {
7094     const char *str;
7095     const char *replace;
7096     int len;
7097     int rep_len;
7098   };
7099
7100   static struct mswitchstr *mswitches;
7101   static int n_mswitches;
7102   int i, j;
7103
7104   if (!mswitches)
7105     {
7106       struct mswitchstr *matches;
7107       const char *q;
7108       int cnt = 0;
7109
7110       /* Break multilib_matches into the component strings of string
7111          and replacement string.  */
7112       for (q = multilib_matches; *q != '\0'; q++)
7113         if (*q == ';')
7114           cnt++;
7115
7116       matches
7117         = (struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt);
7118       i = 0;
7119       q = multilib_matches;
7120       while (*q != '\0')
7121         {
7122           matches[i].str = q;
7123           while (*q != ' ')
7124             {
7125               if (*q == '\0')
7126                 {
7127                 invalid_matches:
7128                   fatal_error ("multilib spec %qs is invalid",
7129                                multilib_matches);
7130                 }
7131               q++;
7132             }
7133           matches[i].len = q - matches[i].str;
7134
7135           matches[i].replace = ++q;
7136           while (*q != ';' && *q != '\0')
7137             {
7138               if (*q == ' ')
7139                 goto invalid_matches;
7140               q++;
7141             }
7142           matches[i].rep_len = q - matches[i].replace;
7143           i++;
7144           if (*q == ';')
7145             q++;
7146         }
7147
7148       /* Now build a list of the replacement string for switches that we care
7149          about.  Make sure we allocate at least one entry.  This prevents
7150          xmalloc from calling fatal, and prevents us from re-executing this
7151          block of code.  */
7152       mswitches
7153         = XNEWVEC (struct mswitchstr, n_mdswitches + (n_switches ? n_switches : 1));
7154       for (i = 0; i < n_switches; i++)
7155         if ((switches[i].live_cond & SWITCH_IGNORE) == 0)
7156           {
7157             int xlen = strlen (switches[i].part1);
7158             for (j = 0; j < cnt; j++)
7159               if (xlen == matches[j].len
7160                   && ! strncmp (switches[i].part1, matches[j].str, xlen))
7161                 {
7162                   mswitches[n_mswitches].str = matches[j].replace;
7163                   mswitches[n_mswitches].len = matches[j].rep_len;
7164                   mswitches[n_mswitches].replace = (char *) 0;
7165                   mswitches[n_mswitches].rep_len = 0;
7166                   n_mswitches++;
7167                   break;
7168                 }
7169           }
7170
7171       /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
7172          on the command line nor any options mutually incompatible with
7173          them.  */
7174       for (i = 0; i < n_mdswitches; i++)
7175         {
7176           const char *r;
7177
7178           for (q = multilib_options; *q != '\0'; q++)
7179             {
7180               while (*q == ' ')
7181                 q++;
7182
7183               r = q;
7184               while (strncmp (q, mdswitches[i].str, mdswitches[i].len) != 0
7185                      || strchr (" /", q[mdswitches[i].len]) == NULL)
7186                 {
7187                   while (*q != ' ' && *q != '/' && *q != '\0')
7188                     q++;
7189                   if (*q != '/')
7190                     break;
7191                   q++;
7192                 }
7193
7194               if (*q != ' ' && *q != '\0')
7195                 {
7196                   while (*r != ' ' && *r != '\0')
7197                     {
7198                       q = r;
7199                       while (*q != ' ' && *q != '/' && *q != '\0')
7200                         q++;
7201
7202                       if (used_arg (r, q - r))
7203                         break;
7204
7205                       if (*q != '/')
7206                         {
7207                           mswitches[n_mswitches].str = mdswitches[i].str;
7208                           mswitches[n_mswitches].len = mdswitches[i].len;
7209                           mswitches[n_mswitches].replace = (char *) 0;
7210                           mswitches[n_mswitches].rep_len = 0;
7211                           n_mswitches++;
7212                           break;
7213                         }
7214
7215                       r = q + 1;
7216                     }
7217                   break;
7218                 }
7219             }
7220         }
7221     }
7222
7223   for (i = 0; i < n_mswitches; i++)
7224     if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
7225       return 1;
7226
7227   return 0;
7228 }
7229
7230 static int
7231 default_arg (const char *p, int len)
7232 {
7233   int i;
7234
7235   for (i = 0; i < n_mdswitches; i++)
7236     if (len == mdswitches[i].len && ! strncmp (p, mdswitches[i].str, len))
7237       return 1;
7238
7239   return 0;
7240 }
7241
7242 /* Work out the subdirectory to use based on the options. The format of
7243    multilib_select is a list of elements. Each element is a subdirectory
7244    name followed by a list of options followed by a semicolon. The format
7245    of multilib_exclusions is the same, but without the preceding
7246    directory. First gcc will check the exclusions, if none of the options
7247    beginning with an exclamation point are present, and all of the other
7248    options are present, then we will ignore this completely. Passing
7249    that, gcc will consider each multilib_select in turn using the same
7250    rules for matching the options. If a match is found, that subdirectory
7251    will be used.  */
7252
7253 static void
7254 set_multilib_dir (void)
7255 {
7256   const char *p;
7257   unsigned int this_path_len;
7258   const char *this_path, *this_arg;
7259   const char *start, *end;
7260   int not_arg;
7261   int ok, ndfltok, first;
7262
7263   n_mdswitches = 0;
7264   start = multilib_defaults;
7265   while (*start == ' ' || *start == '\t')
7266     start++;
7267   while (*start != '\0')
7268     {
7269       n_mdswitches++;
7270       while (*start != ' ' && *start != '\t' && *start != '\0')
7271         start++;
7272       while (*start == ' ' || *start == '\t')
7273         start++;
7274     }
7275
7276   if (n_mdswitches)
7277     {
7278       int i = 0;
7279
7280       mdswitches = XNEWVEC (struct mdswitchstr, n_mdswitches);
7281       for (start = multilib_defaults; *start != '\0'; start = end + 1)
7282         {
7283           while (*start == ' ' || *start == '\t')
7284             start++;
7285
7286           if (*start == '\0')
7287             break;
7288
7289           for (end = start + 1;
7290                *end != ' ' && *end != '\t' && *end != '\0'; end++)
7291             ;
7292
7293           obstack_grow (&multilib_obstack, start, end - start);
7294           obstack_1grow (&multilib_obstack, 0);
7295           mdswitches[i].str = XOBFINISH (&multilib_obstack, const char *);
7296           mdswitches[i++].len = end - start;
7297
7298           if (*end == '\0')
7299             break;
7300         }
7301     }
7302
7303   p = multilib_exclusions;
7304   while (*p != '\0')
7305     {
7306       /* Ignore newlines.  */
7307       if (*p == '\n')
7308         {
7309           ++p;
7310           continue;
7311         }
7312
7313       /* Check the arguments.  */
7314       ok = 1;
7315       while (*p != ';')
7316         {
7317           if (*p == '\0')
7318             {
7319             invalid_exclusions:
7320               fatal_error ("multilib exclusions %qs is invalid",
7321                            multilib_exclusions);
7322             }
7323
7324           if (! ok)
7325             {
7326               ++p;
7327               continue;
7328             }
7329
7330           this_arg = p;
7331           while (*p != ' ' && *p != ';')
7332             {
7333               if (*p == '\0')
7334                 goto invalid_exclusions;
7335               ++p;
7336             }
7337
7338           if (*this_arg != '!')
7339             not_arg = 0;
7340           else
7341             {
7342               not_arg = 1;
7343               ++this_arg;
7344             }
7345
7346           ok = used_arg (this_arg, p - this_arg);
7347           if (not_arg)
7348             ok = ! ok;
7349
7350           if (*p == ' ')
7351             ++p;
7352         }
7353
7354       if (ok)
7355         return;
7356
7357       ++p;
7358     }
7359
7360   first = 1;
7361   p = multilib_select;
7362   while (*p != '\0')
7363     {
7364       /* Ignore newlines.  */
7365       if (*p == '\n')
7366         {
7367           ++p;
7368           continue;
7369         }
7370
7371       /* Get the initial path.  */
7372       this_path = p;
7373       while (*p != ' ')
7374         {
7375           if (*p == '\0')
7376             {
7377             invalid_select:
7378               fatal_error ("multilib select %qs is invalid",
7379                            multilib_select);
7380             }
7381           ++p;
7382         }
7383       this_path_len = p - this_path;
7384
7385       /* Check the arguments.  */
7386       ok = 1;
7387       ndfltok = 1;
7388       ++p;
7389       while (*p != ';')
7390         {
7391           if (*p == '\0')
7392             goto invalid_select;
7393
7394           if (! ok)
7395             {
7396               ++p;
7397               continue;
7398             }
7399
7400           this_arg = p;
7401           while (*p != ' ' && *p != ';')
7402             {
7403               if (*p == '\0')
7404                 goto invalid_select;
7405               ++p;
7406             }
7407
7408           if (*this_arg != '!')
7409             not_arg = 0;
7410           else
7411             {
7412               not_arg = 1;
7413               ++this_arg;
7414             }
7415
7416           /* If this is a default argument, we can just ignore it.
7417              This is true even if this_arg begins with '!'.  Beginning
7418              with '!' does not mean that this argument is necessarily
7419              inappropriate for this library: it merely means that
7420              there is a more specific library which uses this
7421              argument.  If this argument is a default, we need not
7422              consider that more specific library.  */
7423           ok = used_arg (this_arg, p - this_arg);
7424           if (not_arg)
7425             ok = ! ok;
7426
7427           if (! ok)
7428             ndfltok = 0;
7429
7430           if (default_arg (this_arg, p - this_arg))
7431             ok = 1;
7432
7433           if (*p == ' ')
7434             ++p;
7435         }
7436
7437       if (ok && first)
7438         {
7439           if (this_path_len != 1
7440               || this_path[0] != '.')
7441             {
7442               char *new_multilib_dir = XNEWVEC (char, this_path_len + 1);
7443               char *q;
7444
7445               strncpy (new_multilib_dir, this_path, this_path_len);
7446               new_multilib_dir[this_path_len] = '\0';
7447               q = strchr (new_multilib_dir, ':');
7448               if (q != NULL)
7449                 *q = '\0';
7450               multilib_dir = new_multilib_dir;
7451             }
7452           first = 0;
7453         }
7454
7455       if (ndfltok)
7456         {
7457           const char *q = this_path, *end = this_path + this_path_len;
7458
7459           while (q < end && *q != ':')
7460             q++;
7461           if (q < end)
7462             {
7463               char *new_multilib_os_dir = XNEWVEC (char, end - q);
7464               memcpy (new_multilib_os_dir, q + 1, end - q - 1);
7465               new_multilib_os_dir[end - q - 1] = '\0';
7466               multilib_os_dir = new_multilib_os_dir;
7467               break;
7468             }
7469         }
7470
7471       ++p;
7472     }
7473
7474   if (multilib_dir == NULL && multilib_os_dir != NULL
7475       && strcmp (multilib_os_dir, ".") == 0)
7476     {
7477       free (CONST_CAST (char *, multilib_os_dir));
7478       multilib_os_dir = NULL;
7479     }
7480   else if (multilib_dir != NULL && multilib_os_dir == NULL)
7481     multilib_os_dir = multilib_dir;
7482 }
7483
7484 /* Print out the multiple library subdirectory selection
7485    information.  This prints out a series of lines.  Each line looks
7486    like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
7487    required.  Only the desired options are printed out, the negative
7488    matches.  The options are print without a leading dash.  There are
7489    no spaces to make it easy to use the information in the shell.
7490    Each subdirectory is printed only once.  This assumes the ordering
7491    generated by the genmultilib script. Also, we leave out ones that match
7492    the exclusions.  */
7493
7494 static void
7495 print_multilib_info (void)
7496 {
7497   const char *p = multilib_select;
7498   const char *last_path = 0, *this_path;
7499   int skip;
7500   unsigned int last_path_len = 0;
7501
7502   while (*p != '\0')
7503     {
7504       skip = 0;
7505       /* Ignore newlines.  */
7506       if (*p == '\n')
7507         {
7508           ++p;
7509           continue;
7510         }
7511
7512       /* Get the initial path.  */
7513       this_path = p;
7514       while (*p != ' ')
7515         {
7516           if (*p == '\0')
7517             {
7518             invalid_select:
7519               fatal_error ("multilib select %qs is invalid", multilib_select);
7520             }
7521
7522           ++p;
7523         }
7524
7525       /* When --disable-multilib was used but target defines
7526          MULTILIB_OSDIRNAMES, entries starting with .: are there just
7527          to find multilib_os_dir, so skip them from output.  */
7528       if (this_path[0] == '.' && this_path[1] == ':')
7529         skip = 1;
7530
7531       /* Check for matches with the multilib_exclusions. We don't bother
7532          with the '!' in either list. If any of the exclusion rules match
7533          all of its options with the select rule, we skip it.  */
7534       {
7535         const char *e = multilib_exclusions;
7536         const char *this_arg;
7537
7538         while (*e != '\0')
7539           {
7540             int m = 1;
7541             /* Ignore newlines.  */
7542             if (*e == '\n')
7543               {
7544                 ++e;
7545                 continue;
7546               }
7547
7548             /* Check the arguments.  */
7549             while (*e != ';')
7550               {
7551                 const char *q;
7552                 int mp = 0;
7553
7554                 if (*e == '\0')
7555                   {
7556                   invalid_exclusion:
7557                     fatal_error ("multilib exclusion %qs is invalid",
7558                                  multilib_exclusions);
7559                   }
7560
7561                 if (! m)
7562                   {
7563                     ++e;
7564                     continue;
7565                   }
7566
7567                 this_arg = e;
7568
7569                 while (*e != ' ' && *e != ';')
7570                   {
7571                     if (*e == '\0')
7572                       goto invalid_exclusion;
7573                     ++e;
7574                   }
7575
7576                 q = p + 1;
7577                 while (*q != ';')
7578                   {
7579                     const char *arg;
7580                     int len = e - this_arg;
7581
7582                     if (*q == '\0')
7583                       goto invalid_select;
7584
7585                     arg = q;
7586
7587                     while (*q != ' ' && *q != ';')
7588                       {
7589                         if (*q == '\0')
7590                           goto invalid_select;
7591                         ++q;
7592                       }
7593
7594                     if (! strncmp (arg, this_arg,
7595                                    (len < q - arg) ? q - arg : len)
7596                         || default_arg (this_arg, e - this_arg))
7597                       {
7598                         mp = 1;
7599                         break;
7600                       }
7601
7602                     if (*q == ' ')
7603                       ++q;
7604                   }
7605
7606                 if (! mp)
7607                   m = 0;
7608
7609                 if (*e == ' ')
7610                   ++e;
7611               }
7612
7613             if (m)
7614               {
7615                 skip = 1;
7616                 break;
7617               }
7618
7619             if (*e != '\0')
7620               ++e;
7621           }
7622       }
7623
7624       if (! skip)
7625         {
7626           /* If this is a duplicate, skip it.  */
7627           skip = (last_path != 0
7628                   && (unsigned int) (p - this_path) == last_path_len
7629                   && ! strncmp (last_path, this_path, last_path_len));
7630
7631           last_path = this_path;
7632           last_path_len = p - this_path;
7633         }
7634
7635       /* If this directory requires any default arguments, we can skip
7636          it.  We will already have printed a directory identical to
7637          this one which does not require that default argument.  */
7638       if (! skip)
7639         {
7640           const char *q;
7641
7642           q = p + 1;
7643           while (*q != ';')
7644             {
7645               const char *arg;
7646
7647               if (*q == '\0')
7648                 goto invalid_select;
7649
7650               if (*q == '!')
7651                 arg = NULL;
7652               else
7653                 arg = q;
7654
7655               while (*q != ' ' && *q != ';')
7656                 {
7657                   if (*q == '\0')
7658                     goto invalid_select;
7659                   ++q;
7660                 }
7661
7662               if (arg != NULL
7663                   && default_arg (arg, q - arg))
7664                 {
7665                   skip = 1;
7666                   break;
7667                 }
7668
7669               if (*q == ' ')
7670                 ++q;
7671             }
7672         }
7673
7674       if (! skip)
7675         {
7676           const char *p1;
7677
7678           for (p1 = last_path; p1 < p && *p1 != ':'; p1++)
7679             putchar (*p1);
7680           putchar (';');
7681         }
7682
7683       ++p;
7684       while (*p != ';')
7685         {
7686           int use_arg;
7687
7688           if (*p == '\0')
7689             goto invalid_select;
7690
7691           if (skip)
7692             {
7693               ++p;
7694               continue;
7695             }
7696
7697           use_arg = *p != '!';
7698
7699           if (use_arg)
7700             putchar ('@');
7701
7702           while (*p != ' ' && *p != ';')
7703             {
7704               if (*p == '\0')
7705                 goto invalid_select;
7706               if (use_arg)
7707                 putchar (*p);
7708               ++p;
7709             }
7710
7711           if (*p == ' ')
7712             ++p;
7713         }
7714
7715       if (! skip)
7716         {
7717           /* If there are extra options, print them now.  */
7718           if (multilib_extra && *multilib_extra)
7719             {
7720               int print_at = TRUE;
7721               const char *q;
7722
7723               for (q = multilib_extra; *q != '\0'; q++)
7724                 {
7725                   if (*q == ' ')
7726                     print_at = TRUE;
7727                   else
7728                     {
7729                       if (print_at)
7730                         putchar ('@');
7731                       putchar (*q);
7732                       print_at = FALSE;
7733                     }
7734                 }
7735             }
7736
7737           putchar ('\n');
7738         }
7739
7740       ++p;
7741     }
7742 }
7743 \f
7744 /* getenv built-in spec function.
7745
7746    Returns the value of the environment variable given by its first
7747    argument, concatenated with the second argument.  If the
7748    environment variable is not defined, a fatal error is issued.  */
7749
7750 static const char *
7751 getenv_spec_function (int argc, const char **argv)
7752 {
7753   char *value;
7754   char *result;
7755   char *ptr;
7756   size_t len;
7757
7758   if (argc != 2)
7759     return NULL;
7760
7761   value = getenv (argv[0]);
7762   if (!value)
7763     fatal_error ("environment variable %qs not defined", argv[0]);
7764
7765   /* We have to escape every character of the environment variable so
7766      they are not interpreted as active spec characters.  A
7767      particularly painful case is when we are reading a variable
7768      holding a windows path complete with \ separators.  */
7769   len = strlen (value) * 2 + strlen (argv[1]) + 1;
7770   result = XNEWVAR (char, len);
7771   for (ptr = result; *value; ptr += 2)
7772     {
7773       ptr[0] = '\\';
7774       ptr[1] = *value++;
7775     }
7776
7777   strcpy (ptr, argv[1]);
7778
7779   return result;
7780 }
7781
7782 /* if-exists built-in spec function.
7783
7784    Checks to see if the file specified by the absolute pathname in
7785    ARGS exists.  Returns that pathname if found.
7786
7787    The usual use for this function is to check for a library file
7788    (whose name has been expanded with %s).  */
7789
7790 static const char *
7791 if_exists_spec_function (int argc, const char **argv)
7792 {
7793   /* Must have only one argument.  */
7794   if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
7795     return argv[0];
7796
7797   return NULL;
7798 }
7799
7800 /* if-exists-else built-in spec function.
7801
7802    This is like if-exists, but takes an additional argument which
7803    is returned if the first argument does not exist.  */
7804
7805 static const char *
7806 if_exists_else_spec_function (int argc, const char **argv)
7807 {
7808   /* Must have exactly two arguments.  */
7809   if (argc != 2)
7810     return NULL;
7811
7812   if (IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
7813     return argv[0];
7814
7815   return argv[1];
7816 }
7817
7818 /* replace-outfile built-in spec function.
7819
7820    This looks for the first argument in the outfiles array's name and
7821    replaces it with the second argument.  */
7822
7823 static const char *
7824 replace_outfile_spec_function (int argc, const char **argv)
7825 {
7826   int i;
7827   /* Must have exactly two arguments.  */
7828   if (argc != 2)
7829     abort ();
7830
7831   for (i = 0; i < n_infiles; i++)
7832     {
7833       if (outfiles[i] && !strcmp (outfiles[i], argv[0]))
7834         outfiles[i] = xstrdup (argv[1]);
7835     }
7836   return NULL;
7837 }
7838
7839 /* remove-outfile built-in spec function.
7840  *
7841  *    This looks for the first argument in the outfiles array's name and
7842  *       removes it.  */
7843
7844 static const char *
7845 remove_outfile_spec_function (int argc, const char **argv)
7846 {
7847   int i;
7848   /* Must have exactly one argument.  */
7849   if (argc != 1)
7850     abort ();
7851
7852   for (i = 0; i < n_infiles; i++)
7853     {
7854       if (outfiles[i] && !strcmp (outfiles[i], argv[0]))
7855         outfiles[i] = NULL;
7856     }
7857   return NULL;
7858 }
7859
7860 /* Given two version numbers, compares the two numbers.
7861    A version number must match the regular expression
7862    ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
7863 */
7864 static int
7865 compare_version_strings (const char *v1, const char *v2)
7866 {
7867   int rresult;
7868   regex_t r;
7869
7870   if (regcomp (&r, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
7871                REG_EXTENDED | REG_NOSUB) != 0)
7872     abort ();
7873   rresult = regexec (&r, v1, 0, NULL, 0);
7874   if (rresult == REG_NOMATCH)
7875     fatal_error ("invalid version number %qs", v1);
7876   else if (rresult != 0)
7877     abort ();
7878   rresult = regexec (&r, v2, 0, NULL, 0);
7879   if (rresult == REG_NOMATCH)
7880     fatal_error ("invalid version number %qs", v2);
7881   else if (rresult != 0)
7882     abort ();
7883
7884   return strverscmp (v1, v2);
7885 }
7886
7887
7888 /* version_compare built-in spec function.
7889
7890    This takes an argument of the following form:
7891
7892    <comparison-op> <arg1> [<arg2>] <switch> <result>
7893
7894    and produces "result" if the comparison evaluates to true,
7895    and nothing if it doesn't.
7896
7897    The supported <comparison-op> values are:
7898
7899    >=  true if switch is a later (or same) version than arg1
7900    !>  opposite of >=
7901    <   true if switch is an earlier version than arg1
7902    !<  opposite of <
7903    ><  true if switch is arg1 or later, and earlier than arg2
7904    <>  true if switch is earlier than arg1 or is arg2 or later
7905
7906    If the switch is not present, the condition is false unless
7907    the first character of the <comparison-op> is '!'.
7908
7909    For example,
7910    %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
7911    adds -lmx if -mmacosx-version-min=10.3.9 was passed.  */
7912
7913 static const char *
7914 version_compare_spec_function (int argc, const char **argv)
7915 {
7916   int comp1, comp2;
7917   size_t switch_len;
7918   const char *switch_value = NULL;
7919   int nargs = 1, i;
7920   bool result;
7921
7922   if (argc < 3)
7923     fatal_error ("too few arguments to %%:version-compare");
7924   if (argv[0][0] == '\0')
7925     abort ();
7926   if ((argv[0][1] == '<' || argv[0][1] == '>') && argv[0][0] != '!')
7927     nargs = 2;
7928   if (argc != nargs + 3)
7929     fatal_error ("too many arguments to %%:version-compare");
7930
7931   switch_len = strlen (argv[nargs + 1]);
7932   for (i = 0; i < n_switches; i++)
7933     if (!strncmp (switches[i].part1, argv[nargs + 1], switch_len)
7934         && check_live_switch (i, switch_len))
7935       switch_value = switches[i].part1 + switch_len;
7936
7937   if (switch_value == NULL)
7938     comp1 = comp2 = -1;
7939   else
7940     {
7941       comp1 = compare_version_strings (switch_value, argv[1]);
7942       if (nargs == 2)
7943         comp2 = compare_version_strings (switch_value, argv[2]);
7944       else
7945         comp2 = -1;  /* This value unused.  */
7946     }
7947
7948   switch (argv[0][0] << 8 | argv[0][1])
7949     {
7950     case '>' << 8 | '=':
7951       result = comp1 >= 0;
7952       break;
7953     case '!' << 8 | '<':
7954       result = comp1 >= 0 || switch_value == NULL;
7955       break;
7956     case '<' << 8:
7957       result = comp1 < 0;
7958       break;
7959     case '!' << 8 | '>':
7960       result = comp1 < 0 || switch_value == NULL;
7961       break;
7962     case '>' << 8 | '<':
7963       result = comp1 >= 0 && comp2 < 0;
7964       break;
7965     case '<' << 8 | '>':
7966       result = comp1 < 0 || comp2 >= 0;
7967       break;
7968
7969     default:
7970       fatal_error ("unknown operator %qs in %%:version-compare", argv[0]);
7971     }
7972   if (! result)
7973     return NULL;
7974
7975   return argv[nargs + 2];
7976 }
7977
7978 /* %:include builtin spec function.  This differs from %include in that it
7979    can be nested inside a spec, and thus be conditionalized.  It takes
7980    one argument, the filename, and looks for it in the startfile path.
7981    The result is always NULL, i.e. an empty expansion.  */
7982
7983 static const char *
7984 include_spec_function (int argc, const char **argv)
7985 {
7986   char *file;
7987
7988   if (argc != 1)
7989     abort ();
7990
7991   file = find_a_file (&startfile_prefixes, argv[0], R_OK, true);
7992   read_specs (file ? file : argv[0], FALSE);
7993
7994   return NULL;
7995 }
7996
7997 /* %:find-file spec function.  This function replaces its argument by
7998     the file found thru find_file, that is the -print-file-name gcc
7999     program option. */
8000 static const char *
8001 find_file_spec_function (int argc, const char **argv)
8002 {
8003   const char *file;
8004
8005   if (argc != 1)
8006     abort ();
8007
8008   file = find_file (argv[0]);
8009   return file;
8010 }
8011
8012
8013 /* %:find-plugindir spec function.  This function replaces its argument
8014     by the -iplugindir=<dir> option.  `dir' is found thru find_file, that
8015     is the -print-file-name gcc program option. */
8016 static const char *
8017 find_plugindir_spec_function (int argc, const char **argv ATTRIBUTE_UNUSED)
8018 {
8019   const char *option;
8020
8021   if (argc != 0)
8022     abort ();
8023
8024   option = concat ("-iplugindir=", find_file ("plugin"), NULL);
8025   return option;
8026 }
8027
8028
8029 /* %:print-asm-header spec function.  Print a banner to say that the
8030    following output is from the assembler.  */
8031
8032 static const char *
8033 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED,
8034                                 const char **argv ATTRIBUTE_UNUSED)
8035 {
8036   printf (_("Assembler options\n=================\n\n"));
8037   printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
8038   fflush (stdout);
8039   return NULL;
8040 }
8041
8042 /* Compute a timestamp to initialize flag_random_seed.  */
8043
8044 static unsigned
8045 get_local_tick (void)
8046 {
8047   unsigned ret = 0;
8048
8049   /* Get some more or less random data.  */
8050 #ifdef HAVE_GETTIMEOFDAY
8051   {
8052     struct timeval tv;
8053
8054     gettimeofday (&tv, NULL);
8055     ret = tv.tv_sec * 1000 + tv.tv_usec / 1000;
8056   }
8057 #else
8058   {
8059     time_t now = time (NULL);
8060
8061     if (now != (time_t)-1)
8062       ret = (unsigned) now;
8063   }
8064 #endif
8065
8066   return ret;
8067 }
8068
8069 /* %:compare-debug-dump-opt spec function.  Save the last argument,
8070    expected to be the last -fdump-final-insns option, or generate a
8071    temporary.  */
8072
8073 static const char *
8074 compare_debug_dump_opt_spec_function (int arg,
8075                                       const char **argv ATTRIBUTE_UNUSED)
8076 {
8077   const char *ret;
8078   char *name;
8079   int which;
8080   static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];
8081
8082   if (arg != 0)
8083     fatal_error ("too many arguments to %%:compare-debug-dump-opt");
8084
8085   do_spec_2 ("%{fdump-final-insns=*:%*}");
8086   do_spec_1 (" ", 0, NULL);
8087
8088   if (VEC_length (const_char_p, argbuf) > 0
8089       && strcmp (argv[VEC_length (const_char_p, argbuf) - 1], "."))
8090     {
8091       if (!compare_debug)
8092         return NULL;
8093
8094       name = xstrdup (argv[VEC_length (const_char_p, argbuf) - 1]);
8095       ret = NULL;
8096     }
8097   else
8098     {
8099       const char *ext = NULL;
8100
8101       if (VEC_length (const_char_p, argbuf) > 0)
8102         {
8103           do_spec_2 ("%{o*:%*}%{!o:%{!S:%b%O}%{S:%b.s}}");
8104           ext = ".gkd";
8105         }
8106       else if (!compare_debug)
8107         return NULL;
8108       else
8109         do_spec_2 ("%g.gkd");
8110
8111       do_spec_1 (" ", 0, NULL);
8112
8113       gcc_assert (VEC_length (const_char_p, argbuf) > 0);
8114
8115       name = concat (VEC_last (const_char_p, argbuf), ext, NULL);
8116
8117       ret = concat ("-fdump-final-insns=", name, NULL);
8118     }
8119
8120   which = compare_debug < 0;
8121   debug_check_temp_file[which] = name;
8122
8123   if (!which)
8124     {
8125       unsigned HOST_WIDE_INT value = get_local_tick () ^ getpid ();
8126
8127       sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value);
8128     }
8129
8130   if (*random_seed)
8131     ret = concat ("%{!frandom-seed=*:-frandom-seed=", random_seed, "} ",
8132                   ret, NULL);
8133
8134   if (which)
8135     *random_seed = 0;
8136
8137   return ret;
8138 }
8139
8140 static const char *debug_auxbase_opt;
8141
8142 /* %:compare-debug-self-opt spec function.  Expands to the options
8143     that are to be passed in the second compilation of
8144     compare-debug.  */
8145
8146 static const char *
8147 compare_debug_self_opt_spec_function (int arg,
8148                                       const char **argv ATTRIBUTE_UNUSED)
8149 {
8150   if (arg != 0)
8151     fatal_error ("too many arguments to %%:compare-debug-self-opt");
8152
8153   if (compare_debug >= 0)
8154     return NULL;
8155
8156   do_spec_2 ("%{c|S:%{o*:%*}}");
8157   do_spec_1 (" ", 0, NULL);
8158
8159   if (VEC_length (const_char_p, argbuf) > 0)
8160     debug_auxbase_opt = concat ("-auxbase-strip ",
8161                                 VEC_last (const_char_p, argbuf),
8162                                 NULL);
8163   else
8164     debug_auxbase_opt = NULL;
8165
8166   return concat ("\
8167 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
8168 %<fdump-final-insns=* -w -S -o %j \
8169 %{!fcompare-debug-second:-fcompare-debug-second} \
8170 ", compare_debug_opt, NULL);
8171 }
8172
8173 /* %:compare-debug-auxbase-opt spec function.  Expands to the auxbase
8174     options that are to be passed in the second compilation of
8175     compare-debug.  It expects, as an argument, the basename of the
8176     current input file name, with the .gk suffix appended to it.  */
8177
8178 static const char *
8179 compare_debug_auxbase_opt_spec_function (int arg,
8180                                          const char **argv)
8181 {
8182   char *name;
8183   int len;
8184
8185   if (arg == 0)
8186     fatal_error ("too few arguments to %%:compare-debug-auxbase-opt");
8187
8188   if (arg != 1)
8189     fatal_error ("too many arguments to %%:compare-debug-auxbase-opt");
8190
8191   if (compare_debug >= 0)
8192     return NULL;
8193
8194   len = strlen (argv[0]);
8195   if (len < 3 || strcmp (argv[0] + len - 3, ".gk") != 0)
8196     fatal_error ("argument to %%:compare-debug-auxbase-opt "
8197                  "does not end in .gk");
8198
8199   if (debug_auxbase_opt)
8200     return debug_auxbase_opt;
8201
8202 #define OPT "-auxbase "
8203
8204   len -= 3;
8205   name = (char*) xmalloc (sizeof (OPT) + len);
8206   memcpy (name, OPT, sizeof (OPT) - 1);
8207   memcpy (name + sizeof (OPT) - 1, argv[0], len);
8208   name[sizeof (OPT) - 1 + len] = '\0';
8209
8210 #undef OPT
8211
8212   return name;
8213 }
8214
8215 /* %:pass-through-libs spec function.  Finds all -l options and input
8216    file names in the lib spec passed to it, and makes a list of them
8217    prepended with the plugin option to cause them to be passed through
8218    to the final link after all the new object files have been added.  */
8219
8220 const char *
8221 pass_through_libs_spec_func (int argc, const char **argv)
8222 {
8223   char *prepended = xstrdup (" ");
8224   int n;
8225   /* Shlemiel the painter's algorithm.  Innately horrible, but at least
8226      we know that there will never be more than a handful of strings to
8227      concat, and it's only once per run, so it's not worth optimising.  */
8228   for (n = 0; n < argc; n++)
8229     {
8230       char *old = prepended;
8231       /* Anything that isn't an option is a full path to an output
8232          file; pass it through if it ends in '.a'.  Among options,
8233          pass only -l.  */
8234       if (argv[n][0] == '-' && argv[n][1] == 'l')
8235         {
8236           const char *lopt = argv[n] + 2;
8237           /* Handle both joined and non-joined -l options.  If for any
8238              reason there's a trailing -l with no joined or following
8239              arg just discard it.  */
8240           if (!*lopt && ++n >= argc)
8241             break;
8242           else if (!*lopt)
8243             lopt = argv[n];
8244           prepended = concat (prepended, "-plugin-opt=-pass-through=-l",
8245                 lopt, " ", NULL);
8246         }
8247       else if (!strcmp (".a", argv[n] + strlen (argv[n]) - 2))
8248         {
8249           prepended = concat (prepended, "-plugin-opt=-pass-through=",
8250                 argv[n], " ", NULL);
8251         }
8252       if (prepended != old)
8253         free (old);
8254     }
8255   return prepended;
8256 }