gcc/gcc.c

   1 /* Compiler driver program that can handle many languages.
   2    Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
   4    2010
   5    Free Software Foundation, Inc.
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify it under
  10 the terms of the GNU General Public License as published by the Free
  11 Software Foundation; either version 3, or (at your option) any later
  12 version.
  13
  14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17 for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING3.  If not see
  21 <http://www.gnu.org/licenses/>.  */
  22
  23 /* This program is the user interface to the C compiler and possibly to
  24 other compilers.  It is used because compilation is a complicated procedure
  25 which involves running several programs and passing temporary files between
  26 them, forwarding the users switches to those programs selectively,
  27 and deleting the temporary files at the end.
  28
  29 CC recognizes how to compile each input file by suffixes in the file names.
  30 Once it knows which kind of compilation to perform, the procedure for
  31 compilation is specified by a string called a "spec".  */
  32
  33 #include "config.h"
  34 #include "system.h"
  35 #include "coretypes.h"
  36 #include "multilib.h" /* before tm.h */
  37 #include "tm.h"
  38 #include <signal.h>
  39 #if ! defined( SIGCHLD ) && defined( SIGCLD )
  40 #  define SIGCHLD SIGCLD
  41 #endif
  42 #include "xregex.h"
  43 #include "obstack.h"
  44 #include "intl.h"
  45 #include "prefix.h"
  46 #include "gcc.h"
  47 #include "diagnostic.h"
  48 #include "flags.h"
  49 #include "opts.h"
  50
  51 #ifdef HAVE_MMAP_FILE
  52 # include <sys/mman.h>
  53 # ifdef HAVE_MINCORE
  54 /* This is on Solaris.  */
  55 #  include <sys/types.h>
  56 # endif
  57 #endif
  58
  59 #ifndef MAP_FAILED
  60 # define MAP_FAILED ((void *)-1)
  61 #endif
  62
  63 /* By default there is no special suffix for target executables.  */
  64 /* FIXME: when autoconf is fixed, remove the host check - dj */
  65 #if defined(TARGET_EXECUTABLE_SUFFIX) && defined(HOST_EXECUTABLE_SUFFIX)
  66 #define HAVE_TARGET_EXECUTABLE_SUFFIX
  67 #endif
  68
  69 /* By default there is no special suffix for host executables.  */
  70 #ifdef HOST_EXECUTABLE_SUFFIX
  71 #define HAVE_HOST_EXECUTABLE_SUFFIX
  72 #else
  73 #define HOST_EXECUTABLE_SUFFIX ""
  74 #endif
  75
  76 /* By default, the suffix for target object files is ".o".  */
  77 #ifdef TARGET_OBJECT_SUFFIX
  78 #define HAVE_TARGET_OBJECT_SUFFIX
  79 #else
  80 #define TARGET_OBJECT_SUFFIX ".o"
  81 #endif
  82
  83 static const char dir_separator_str[] = { DIR_SEPARATOR, 0 };
  84
  85 /* Most every one is fine with LIBRARY_PATH.  For some, it conflicts.  */
  86 #ifndef LIBRARY_PATH_ENV
  87 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
  88 #endif
  89
  90 #ifndef HAVE_KILL
  91 #define kill(p,s) raise(s)
  92 #endif
  93
  94 /* If a stage of compilation returns an exit status >= 1,
  95    compilation of that file ceases.  */
  96
  97 #define MIN_FATAL_STATUS 1
  98
  99 /* Flag set by cppspec.c to 1.  */
 100 int is_cpp_driver;
 101
 102 /* Flag set to nonzero if an @file argument has been supplied to gcc.  */
 103 static bool at_file_supplied;
 104
 105 /* Definition of string containing the arguments given to configure.  */
 106 #include "configargs.h"
 107
 108 /* Flag saying to print the command line options understood by gcc and its
 109    sub-processes.  */
 110
 111 static int print_help_list;
 112
 113 /* Flag saying to print the version of gcc and its sub-processes.  */
 114
 115 static int print_version;
 116
 117 /* Flag indicating whether we should ONLY print the command and
 118    arguments (like verbose_flag) without executing the command.
 119    Displayed arguments are quoted so that the generated command
 120    line is suitable for execution.  This is intended for use in
 121    shell scripts to capture the driver-generated command line.  */
 122 static int verbose_only_flag;
 123
 124 /* Flag indicating how to print command line options of sub-processes.  */
 125
 126 static int print_subprocess_help;
 127
 128 /* Whether we should report subprocess execution times to a file.  */
 129
 130 FILE *report_times_to_file = NULL;
 131
 132 /* Nonzero means place this string before uses of /, so that include
 133    and library files can be found in an alternate location.  */
 134
 135 #ifdef TARGET_SYSTEM_ROOT
 136 static const char *target_system_root = TARGET_SYSTEM_ROOT;
 137 #else
 138 static const char *target_system_root = 0;
 139 #endif
 140
 141 /* Nonzero means pass the updated target_system_root to the compiler.  */
 142
 143 static int target_system_root_changed;
 144
 145 /* Nonzero means append this string to target_system_root.  */
 146
 147 static const char *target_sysroot_suffix = 0;
 148
 149 /* Nonzero means append this string to target_system_root for headers.  */
 150
 151 static const char *target_sysroot_hdrs_suffix = 0;
 152
 153 /* Nonzero means write "temp" files in source directory
 154    and use the source file's name in them, and don't delete them.  */
 155
 156 static enum save_temps {
 157   SAVE_TEMPS_NONE,              /* no -save-temps */
 158   SAVE_TEMPS_CWD,               /* -save-temps in current directory */
 159   SAVE_TEMPS_OBJ                /* -save-temps in object directory */
 160 } save_temps_flag;
 161
 162 /* Output file to use to get the object directory for -save-temps=obj  */
 163 static char *save_temps_prefix = 0;
 164 static size_t save_temps_length = 0;
 165
 166 /* The compiler version.  */
 167
 168 static const char *compiler_version;
 169
 170 /* The target version.  */
 171
 172 static const char *const spec_version = DEFAULT_TARGET_VERSION;
 173
 174 /* The target machine.  */
 175
 176 static const char *spec_machine = DEFAULT_TARGET_MACHINE;
 177
 178 /* Nonzero if cross-compiling.
 179    When -b is used, the value comes from the `specs' file.  */
 180
 181 #ifdef CROSS_DIRECTORY_STRUCTURE
 182 static const char *cross_compile = "1";
 183 #else
 184 static const char *cross_compile = "0";
 185 #endif
 186
 187 /* Greatest exit code of sub-processes that has been encountered up to
 188    now.  */
 189 static int greatest_status = 1;
 190
 191 /* This is the obstack which we use to allocate many strings.  */
 192
 193 static struct obstack obstack;
 194
 195 /* This is the obstack to build an environment variable to pass to
 196    collect2 that describes all of the relevant switches of what to
 197    pass the compiler in building the list of pointers to constructors
 198    and destructors.  */
 199
 200 static struct obstack collect_obstack;
 201
 202 /* Forward declaration for prototypes.  */
 203 struct path_prefix;
 204 struct prefix_list;
 205
 206 static void init_spec (void);
 207 static void store_arg (const char *, int, int);
 208 static void insert_wrapper (const char *);
 209 static char *load_specs (const char *);
 210 static void read_specs (const char *, int);
 211 static void set_spec (const char *, const char *);
 212 static struct compiler *lookup_compiler (const char *, size_t, const char *);
 213 static char *build_search_list (const struct path_prefix *, const char *,
 214                                 bool, bool);
 215 static void xputenv (const char *);
 216 static void putenv_from_prefixes (const struct path_prefix *, const char *,
 217                                   bool);
 218 static int access_check (const char *, int);
 219 static char *find_a_file (const struct path_prefix *, const char *, int, bool);
 220 static void add_prefix (struct path_prefix *, const char *, const char *,
 221                         int, int, int);
 222 static void add_sysrooted_prefix (struct path_prefix *, const char *,
 223                                   const char *, int, int, int);
 224 static char *skip_whitespace (char *);
 225 static void delete_if_ordinary (const char *);
 226 static void delete_temp_files (void);
 227 static void delete_failure_queue (void);
 228 static void clear_failure_queue (void);
 229 static int check_live_switch (int, int);
 230 static const char *handle_braces (const char *);
 231 static inline bool input_suffix_matches (const char *, const char *);
 232 static inline bool switch_matches (const char *, const char *, int);
 233 static inline void mark_matching_switches (const char *, const char *, int);
 234 static inline void process_marked_switches (void);
 235 static const char *process_brace_body (const char *, const char *, const char *, int, int);
 236 static const struct spec_function *lookup_spec_function (const char *);
 237 static const char *eval_spec_function (const char *, const char *);
 238 static const char *handle_spec_function (const char *);
 239 static char *save_string (const char *, int);
 240 static void set_collect_gcc_options (void);
 241 static int do_spec_1 (const char *, int, const char *);
 242 static int do_spec_2 (const char *);
 243 static void do_option_spec (const char *, const char *);
 244 static void do_self_spec (const char *);
 245 static const char *find_file (const char *);
 246 static int is_directory (const char *, bool);
 247 static const char *validate_switches (const char *);
 248 static void validate_all_switches (void);
 249 static inline void validate_switches_from_spec (const char *);
 250 static void give_switch (int, int);
 251 static int used_arg (const char *, int);
 252 static int default_arg (const char *, int);
 253 static void set_multilib_dir (void);
 254 static void print_multilib_info (void);
 255 static void perror_with_name (const char *);
 256 static void display_help (void);
 257 static void add_preprocessor_option (const char *, int);
 258 static void add_assembler_option (const char *, int);
 259 static void add_linker_option (const char *, int);
 260 static void process_command (unsigned int, struct cl_decoded_option *);
 261 static int execute (void);
 262 static void alloc_args (void);
 263 static void clear_args (void);
 264 static void fatal_signal (int);
 265 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
 266 static void init_gcc_specs (struct obstack *, const char *, const char *,
 267                             const char *);
 268 #endif
 269 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
 270 static const char *convert_filename (const char *, int, int);
 271 #endif
 272
 273 static const char *getenv_spec_function (int, const char **);
 274 static const char *if_exists_spec_function (int, const char **);
 275 static const char *if_exists_else_spec_function (int, const char **);
 276 static const char *replace_outfile_spec_function (int, const char **);
 277 static const char *remove_outfile_spec_function (int, const char **);
 278 static const char *version_compare_spec_function (int, const char **);
 279 static const char *include_spec_function (int, const char **);
 280 static const char *find_file_spec_function (int, const char **);
 281 static const char *find_plugindir_spec_function (int, const char **);
 282 static const char *print_asm_header_spec_function (int, const char **);
 283 static const char *compare_debug_dump_opt_spec_function (int, const char **);
 284 static const char *compare_debug_self_opt_spec_function (int, const char **);
 285 static const char *compare_debug_auxbase_opt_spec_function (int, const char **);
 286 \f
 287 /* The Specs Language
 288
 289 Specs are strings containing lines, each of which (if not blank)
 290 is made up of a program name, and arguments separated by spaces.
 291 The program name must be exact and start from root, since no path
 292 is searched and it is unreliable to depend on the current working directory.
 293 Redirection of input or output is not supported; the subprograms must
 294 accept filenames saying what files to read and write.
 295
 296 In addition, the specs can contain %-sequences to substitute variable text
 297 or for conditional text.  Here is a table of all defined %-sequences.
 298 Note that spaces are not generated automatically around the results of
 299 expanding these sequences; therefore, you can concatenate them together
 300 or with constant text in a single argument.
 301
 302  %%     substitute one % into the program name or argument.
 303  %i     substitute the name of the input file being processed.
 304  %b     substitute the basename of the input file being processed.
 305         This is the substring up to (and not including) the last period
 306         and not including the directory unless -save-temps was specified
 307         to put temporaries in a different location.
 308  %B     same as %b, but include the file suffix (text after the last period).
 309  %gSUFFIX
 310         substitute a file name that has suffix SUFFIX and is chosen
 311         once per compilation, and mark the argument a la %d.  To reduce
 312         exposure to denial-of-service attacks, the file name is now
 313         chosen in a way that is hard to predict even when previously
 314         chosen file names are known.  For example, `%g.s ... %g.o ... %g.s'
 315         might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'.  SUFFIX matches
 316         the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
 317         had been pre-processed.  Previously, %g was simply substituted
 318         with a file name chosen once per compilation, without regard
 319         to any appended suffix (which was therefore treated just like
 320         ordinary text), making such attacks more likely to succeed.
 321  %|SUFFIX
 322         like %g, but if -pipe is in effect, expands simply to "-".
 323  %mSUFFIX
 324         like %g, but if -pipe is in effect, expands to nothing.  (We have both
 325         %| and %m to accommodate differences between system assemblers; see
 326         the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
 327  %uSUFFIX
 328         like %g, but generates a new temporary file name even if %uSUFFIX
 329         was already seen.
 330  %USUFFIX
 331         substitutes the last file name generated with %uSUFFIX, generating a
 332         new one if there is no such last file name.  In the absence of any
 333         %uSUFFIX, this is just like %gSUFFIX, except they don't share
 334         the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
 335         would involve the generation of two distinct file names, one
 336         for each `%g.s' and another for each `%U.s'.  Previously, %U was
 337         simply substituted with a file name chosen for the previous %u,
 338         without regard to any appended suffix.
 339  %jSUFFIX
 340         substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
 341         writable, and if save-temps is off; otherwise, substitute the name
 342         of a temporary file, just like %u.  This temporary file is not
 343         meant for communication between processes, but rather as a junk
 344         disposal mechanism.
 345  %.SUFFIX
 346         substitutes .SUFFIX for the suffixes of a matched switch's args when
 347         it is subsequently output with %*. SUFFIX is terminated by the next
 348         space or %.
 349  %d     marks the argument containing or following the %d as a
 350         temporary file name, so that that file will be deleted if GCC exits
 351         successfully.  Unlike %g, this contributes no text to the argument.
 352  %w     marks the argument containing or following the %w as the
 353         "output file" of this compilation.  This puts the argument
 354         into the sequence of arguments that %o will substitute later.
 355  %V     indicates that this compilation produces no "output file".
 356  %W{...}
 357         like %{...} but mark last argument supplied within
 358         as a file to be deleted on failure.
 359  %o     substitutes the names of all the output files, with spaces
 360         automatically placed around them.  You should write spaces
 361         around the %o as well or the results are undefined.
 362         %o is for use in the specs for running the linker.
 363         Input files whose names have no recognized suffix are not compiled
 364         at all, but they are included among the output files, so they will
 365         be linked.
 366  %O     substitutes the suffix for object files.  Note that this is
 367         handled specially when it immediately follows %g, %u, or %U
 368         (with or without a suffix argument) because of the need for
 369         those to form complete file names.  The handling is such that
 370         %O is treated exactly as if it had already been substituted,
 371         except that %g, %u, and %U do not currently support additional
 372         SUFFIX characters following %O as they would following, for
 373         example, `.o'.
 374  %I     Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
 375         (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
 376         and -B options) and -imultilib as necessary.
 377  %s     current argument is the name of a library or startup file of some sort.
 378         Search for that file in a standard list of directories
 379         and substitute the full name found.
 380  %eSTR  Print STR as an error message.  STR is terminated by a newline.
 381         Use this when inconsistent options are detected.
 382  %nSTR  Print STR as a notice.  STR is terminated by a newline.
 383  %x{OPTION}     Accumulate an option for %X.
 384  %X     Output the accumulated linker options specified by compilations.
 385  %Y     Output the accumulated assembler options specified by compilations.
 386  %Z     Output the accumulated preprocessor options specified by compilations.
 387  %a     process ASM_SPEC as a spec.
 388         This allows config.h to specify part of the spec for running as.
 389  %A     process ASM_FINAL_SPEC as a spec.  A capital A is actually
 390         used here.  This can be used to run a post-processor after the
 391         assembler has done its job.
 392  %D     Dump out a -L option for each directory in startfile_prefixes.
 393         If multilib_dir is set, extra entries are generated with it affixed.
 394  %l     process LINK_SPEC as a spec.
 395  %L     process LIB_SPEC as a spec.
 396  %G     process LIBGCC_SPEC as a spec.
 397  %R     Output the concatenation of target_system_root and
 398         target_sysroot_suffix.
 399  %S     process STARTFILE_SPEC as a spec.  A capital S is actually used here.
 400  %E     process ENDFILE_SPEC as a spec.  A capital E is actually used here.
 401  %C     process CPP_SPEC as a spec.
 402  %1     process CC1_SPEC as a spec.
 403  %2     process CC1PLUS_SPEC as a spec.
 404  %*     substitute the variable part of a matched option.  (See below.)
 405         Note that each comma in the substituted string is replaced by
 406         a single space.
 407  %<S    remove all occurrences of -S from the command line.
 408         Note - this command is position dependent.  % commands in the
 409         spec string before this one will see -S, % commands in the
 410         spec string after this one will not.
 411  %<S*   remove all occurrences of all switches beginning with -S from the
 412         command line.
 413  %:function(args)
 414         Call the named function FUNCTION, passing it ARGS.  ARGS is
 415         first processed as a nested spec string, then split into an
 416         argument vector in the usual fashion.  The function returns
 417         a string which is processed as if it had appeared literally
 418         as part of the current spec.
 419  %{S}   substitutes the -S switch, if that switch was given to GCC.
 420         If that switch was not specified, this substitutes nothing.
 421         Here S is a metasyntactic variable.
 422  %{S*}  substitutes all the switches specified to GCC whose names start
 423         with -S.  This is used for -o, -I, etc; switches that take
 424         arguments.  GCC considers `-o foo' as being one switch whose
 425         name starts with `o'.  %{o*} would substitute this text,
 426         including the space; thus, two arguments would be generated.
 427  %{S*&T*} likewise, but preserve order of S and T options (the order
 428         of S and T in the spec is not significant).  Can be any number
 429         of ampersand-separated variables; for each the wild card is
 430         optional.  Useful for CPP as %{D*&U*&A*}.
 431
 432  %{S:X}   substitutes X, if the -S switch was given to GCC.
 433  %{!S:X}  substitutes X, if the -S switch was NOT given to GCC.
 434  %{S*:X}  substitutes X if one or more switches whose names start
 435           with -S was given to GCC.  Normally X is substituted only
 436           once, no matter how many such switches appeared.  However,
 437           if %* appears somewhere in X, then X will be substituted
 438           once for each matching switch, with the %* replaced by the
 439           part of that switch that matched the '*'.
 440  %{.S:X}  substitutes X, if processing a file with suffix S.
 441  %{!.S:X} substitutes X, if NOT processing a file with suffix S.
 442  %{,S:X}  substitutes X, if processing a file which will use spec S.
 443  %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
 444
 445  %{S|T:X} substitutes X if either -S or -T was given to GCC.  This may be
 446           combined with '!', '.', ',', and '*' as above binding stronger
 447           than the OR.
 448           If %* appears in X, all of the alternatives must be starred, and
 449           only the first matching alternative is substituted.
 450  %{S:X;   if S was given to GCC, substitutes X;
 451    T:Y;   else if T was given to GCC, substitutes Y;
 452     :D}   else substitutes D.  There can be as many clauses as you need.
 453           This may be combined with '.', '!', ',', '|', and '*' as above.
 454
 455  %(Spec) processes a specification defined in a specs file as *Spec:
 456  %[Spec] as above, but put __ around -D arguments
 457
 458 The conditional text X in a %{S:X} or similar construct may contain
 459 other nested % constructs or spaces, or even newlines.  They are
 460 processed as usual, as described above.  Trailing white space in X is
 461 ignored.  White space may also appear anywhere on the left side of the
 462 colon in these constructs, except between . or * and the corresponding
 463 word.
 464
 465 The -O, -f, -m, and -W switches are handled specifically in these
 466 constructs.  If another value of -O or the negated form of a -f, -m, or
 467 -W switch is found later in the command line, the earlier switch
 468 value is ignored, except with {S*} where S is just one letter; this
 469 passes all matching options.
 470
 471 The character | at the beginning of the predicate text is used to indicate
 472 that a command should be piped to the following command, but only if -pipe
 473 is specified.
 474
 475 Note that it is built into GCC which switches take arguments and which
 476 do not.  You might think it would be useful to generalize this to
 477 allow each compiler's spec to say which switches take arguments.  But
 478 this cannot be done in a consistent fashion.  GCC cannot even decide
 479 which input files have been specified without knowing which switches
 480 take arguments, and it must know which input files to compile in order
 481 to tell which compilers to run.
 482
 483 GCC also knows implicitly that arguments starting in `-l' are to be
 484 treated as compiler output files, and passed to the linker in their
 485 proper position among the other output files.  */
 486 \f
 487 /* Define the macros used for specs %a, %l, %L, %S, %C, %1.  */
 488
 489 /* config.h can define ASM_SPEC to provide extra args to the assembler
 490    or extra switch-translations.  */
 491 #ifndef ASM_SPEC
 492 #define ASM_SPEC ""
 493 #endif
 494
 495 /* config.h can define ASM_FINAL_SPEC to run a post processor after
 496    the assembler has run.  */
 497 #ifndef ASM_FINAL_SPEC
 498 #define ASM_FINAL_SPEC ""
 499 #endif
 500
 501 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
 502    or extra switch-translations.  */
 503 #ifndef CPP_SPEC
 504 #define CPP_SPEC ""
 505 #endif
 506
 507 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
 508    or extra switch-translations.  */
 509 #ifndef CC1_SPEC
 510 #define CC1_SPEC ""
 511 #endif
 512
 513 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
 514    or extra switch-translations.  */
 515 #ifndef CC1PLUS_SPEC
 516 #define CC1PLUS_SPEC ""
 517 #endif
 518
 519 /* config.h can define LINK_SPEC to provide extra args to the linker
 520    or extra switch-translations.  */
 521 #ifndef LINK_SPEC
 522 #define LINK_SPEC ""
 523 #endif
 524
 525 /* config.h can define LIB_SPEC to override the default libraries.  */
 526 #ifndef LIB_SPEC
 527 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
 528 #endif
 529
 530 /* mudflap specs */
 531 #ifndef MFWRAP_SPEC
 532 /* XXX: valid only for GNU ld */
 533 /* XXX: should exactly match hooks provided by libmudflap.a */
 534 #define MFWRAP_SPEC " %{static: %{fmudflap|fmudflapth: \
 535  --wrap=malloc --wrap=free --wrap=calloc --wrap=realloc\
 536  --wrap=mmap --wrap=munmap --wrap=alloca\
 537 } %{fmudflapth: --wrap=pthread_create\
 538 }} %{fmudflap|fmudflapth: --wrap=main}"
 539 #endif
 540 #ifndef MFLIB_SPEC
 541 #define MFLIB_SPEC "%{fmudflap|fmudflapth: -export-dynamic}"
 542 #endif
 543
 544 /* When using -fsplit-stack we need to wrap pthread_create, in order
 545    to initialize the stack guard.  We always use wrapping, rather than
 546    shared library ordering, and we keep the wrapper function in
 547    libgcc.  This is not yet a real spec, though it could become one;
 548    it is currently just stuffed into LINK_SPEC.  FIXME: This wrapping
 549    only works with GNU ld and gold.  FIXME: This is incompatible with
 550    -fmudflap when linking statically, which wants to do its own
 551    wrapping.  */
 552 #define STACK_SPLIT_SPEC " %{fsplit-stack: --wrap=pthread_create}"
 553
 554 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
 555    included.  */
 556 #ifndef LIBGCC_SPEC
 557 #if defined(REAL_LIBGCC_SPEC)
 558 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
 559 #elif defined(LINK_LIBGCC_SPECIAL_1)
 560 /* Have gcc do the search for libgcc.a.  */
 561 #define LIBGCC_SPEC "libgcc.a%s"
 562 #else
 563 #define LIBGCC_SPEC "-lgcc"
 564 #endif
 565 #endif
 566
 567 /* config.h can define STARTFILE_SPEC to override the default crt0 files.  */
 568 #ifndef STARTFILE_SPEC
 569 #define STARTFILE_SPEC  \
 570   "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
 571 #endif
 572
 573 /* config.h can define ENDFILE_SPEC to override the default crtn files.  */
 574 #ifndef ENDFILE_SPEC
 575 #define ENDFILE_SPEC ""
 576 #endif
 577
 578 #ifndef LINKER_NAME
 579 #define LINKER_NAME "collect2"
 580 #endif
 581
 582 #ifdef HAVE_AS_DEBUG_PREFIX_MAP
 583 #define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
 584 #else
 585 #define ASM_MAP ""
 586 #endif
 587
 588 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
 589    to the assembler.  */
 590 #ifndef ASM_DEBUG_SPEC
 591 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
 592      && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
 593 #  define ASM_DEBUG_SPEC                                                \
 594       (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG                            \
 595        ? "%{!g0:%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}}" ASM_MAP    \
 596        : "%{!g0:%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}}" ASM_MAP)
 597 # else
 598 #  if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
 599 #   define ASM_DEBUG_SPEC "%{g*:%{!g0:--gstabs}}" ASM_MAP
 600 #  endif
 601 #  if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
 602 #   define ASM_DEBUG_SPEC "%{g*:%{!g0:--gdwarf2}}" ASM_MAP
 603 #  endif
 604 # endif
 605 #endif
 606 #ifndef ASM_DEBUG_SPEC
 607 # define ASM_DEBUG_SPEC ""
 608 #endif
 609
 610 /* Here is the spec for running the linker, after compiling all files.  */
 611
 612 /* This is overridable by the target in case they need to specify the
 613    -lgcc and -lc order specially, yet not require them to override all
 614    of LINK_COMMAND_SPEC.  */
 615 #ifndef LINK_GCC_C_SEQUENCE_SPEC
 616 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
 617 #endif
 618
 619 #ifndef LINK_SSP_SPEC
 620 #ifdef TARGET_LIBC_PROVIDES_SSP
 621 #define LINK_SSP_SPEC "%{fstack-protector:}"
 622 #else
 623 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all:-lssp_nonshared -lssp}"
 624 #endif
 625 #endif
 626
 627 #ifndef LINK_PIE_SPEC
 628 #ifdef HAVE_LD_PIE
 629 #define LINK_PIE_SPEC "%{pie:-pie} "
 630 #else
 631 #define LINK_PIE_SPEC "%{pie:} "
 632 #endif
 633 #endif
 634
 635 #ifndef LINK_BUILDID_SPEC
 636 # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
 637 #  define LINK_BUILDID_SPEC "%{!r:--build-id} "
 638 # endif
 639 #endif
 640
 641
 642 /* -u* was put back because both BSD and SysV seem to support it.  */
 643 /* %{static:} simply prevents an error message if the target machine
 644    doesn't handle -static.  */
 645 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
 646    scripts which exist in user specified directories, or in standard
 647    directories.  */
 648 /* We pass any -flto flags on to the linker, which is expected
 649    to understand them.  In practice, this means it had better be collect2.  */
 650 #ifndef LINK_COMMAND_SPEC
 651 #define LINK_COMMAND_SPEC "\
 652 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
 653     %(linker) \
 654     %{fuse-linker-plugin: \
 655     -plugin %(linker_plugin_file) \
 656     -plugin-opt=%(lto_wrapper) \
 657     -plugin-opt=-fresolution=%u.res \
 658     %{static|static-libgcc:-plugin-opt=-pass-through=%(lto_libgcc)}     \
 659     %{static:-plugin-opt=-pass-through=-lc}     \
 660     } \
 661     %{flto*:%<fcompare-debug*} \
 662     %{flto*} %l " LINK_PIE_SPEC \
 663    "%X %{o*} %{A} %{d} %{e*} %{m} %{N} %{n} %{r}\
 664     %{s} %{t} %{u*} %{z} %{Z} %{!A:%{!nostdlib:%{!nostartfiles:%S}}}\
 665     %{static:} %{L*} %(mfwrap) %(link_libgcc) %o\
 666     %{fopenmp|ftree-parallelize-loops=*:%:include(libgomp.spec)%(link_gomp)}\
 667     %(mflib) " STACK_SPLIT_SPEC "\
 668     %{fprofile-arcs|fprofile-generate*|coverage:-lgcov}\
 669     %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\
 670     %{!A:%{!nostdlib:%{!nostartfiles:%E}}} %{T*} }}}}}}"
 671 #endif
 672
 673 #ifndef LINK_LIBGCC_SPEC
 674 /* Generate -L options for startfile prefix list.  */
 675 # define LINK_LIBGCC_SPEC "%D"
 676 #endif
 677
 678 #ifndef STARTFILE_PREFIX_SPEC
 679 # define STARTFILE_PREFIX_SPEC ""
 680 #endif
 681
 682 #ifndef SYSROOT_SPEC
 683 # define SYSROOT_SPEC "--sysroot=%R"
 684 #endif
 685
 686 #ifndef SYSROOT_SUFFIX_SPEC
 687 # define SYSROOT_SUFFIX_SPEC ""
 688 #endif
 689
 690 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
 691 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
 692 #endif
 693
 694 static const char *asm_debug;
 695 static const char *cpp_spec = CPP_SPEC;
 696 static const char *cc1_spec = CC1_SPEC;
 697 static const char *cc1plus_spec = CC1PLUS_SPEC;
 698 static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC;
 699 static const char *link_ssp_spec = LINK_SSP_SPEC;
 700 static const char *asm_spec = ASM_SPEC;
 701 static const char *asm_final_spec = ASM_FINAL_SPEC;
 702 static const char *link_spec = LINK_SPEC;
 703 static const char *lib_spec = LIB_SPEC;
 704 static const char *mfwrap_spec = MFWRAP_SPEC;
 705 static const char *mflib_spec = MFLIB_SPEC;
 706 static const char *link_gomp_spec = "";
 707 static const char *libgcc_spec = LIBGCC_SPEC;
 708 static const char *endfile_spec = ENDFILE_SPEC;
 709 static const char *startfile_spec = STARTFILE_SPEC;
 710 static const char *linker_name_spec = LINKER_NAME;
 711 static const char *linker_plugin_file_spec = "";
 712 static const char *lto_wrapper_spec = "";
 713 static const char *lto_gcc_spec = "";
 714 static const char *lto_libgcc_spec = "";
 715 static const char *link_command_spec = LINK_COMMAND_SPEC;
 716 static const char *link_libgcc_spec = LINK_LIBGCC_SPEC;
 717 static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC;
 718 static const char *sysroot_spec = SYSROOT_SPEC;
 719 static const char *sysroot_suffix_spec = SYSROOT_SUFFIX_SPEC;
 720 static const char *sysroot_hdrs_suffix_spec = SYSROOT_HEADERS_SUFFIX_SPEC;
 721
 722 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
 723    There should be no need to override these in target dependent files,
 724    but we need to copy them to the specs file so that newer versions
 725    of the GCC driver can correctly drive older tool chains with the
 726    appropriate -B options.  */
 727
 728 /* When cpplib handles traditional preprocessing, get rid of this, and
 729    call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
 730    that we default the front end language better.  */
 731 static const char *trad_capable_cpp =
 732 "cc1 -E %{traditional|ftraditional|traditional-cpp:-traditional-cpp}";
 733
 734 /* We don't wrap .d files in %W{} since a missing .d file, and
 735    therefore no dependency entry, confuses make into thinking a .o
 736    file that happens to exist is up-to-date.  */
 737 static const char *cpp_unique_options =
 738 "%{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\
 739  %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
 740  %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
 741  %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
 742  %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
 743  %{remap} %{g3|ggdb3|gstabs3|gcoff3|gxcoff3|gvms3:-dD}\
 744  %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
 745  %{H} %C %{D*&U*&A*} %{i*} %Z %i\
 746  %{fmudflap:-D_MUDFLAP -include mf-runtime.h}\
 747  %{fmudflapth:-D_MUDFLAP -D_MUDFLAPTH -include mf-runtime.h}\
 748  %{E|M|MM:%W{o*}}";
 749
 750 /* This contains cpp options which are common with cc1_options and are passed
 751    only when preprocessing only to avoid duplication.  We pass the cc1 spec
 752    options to the preprocessor so that it the cc1 spec may manipulate
 753    options used to set target flags.  Those special target flags settings may
 754    in turn cause preprocessor symbols to be defined specially.  */
 755 static const char *cpp_options =
 756 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
 757  %{f*} %{g*:%{!g0:%{g*} %{!fno-working-directory:-fworking-directory}}} %{O*}\
 758  %{undef} %{save-temps*:-fpch-preprocess}";
 759
 760 /* This contains cpp options which are not passed when the preprocessor
 761    output will be used by another program.  */
 762 static const char *cpp_debug_options = "%{d*}";
 763
 764 /* NB: This is shared amongst all front-ends, except for Ada.  */
 765 static const char *cc1_options =
 766 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
 767  %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
 768  %1 %{!Q:-quiet} %{!dumpbase:-dumpbase %B} %{d*} %{m*} %{aux-info*}\
 769  %{fcompare-debug-second:%:compare-debug-auxbase-opt(%b)} \
 770  %{!fcompare-debug-second:%{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}}%{!c:%{!S:-auxbase %b}} \
 771  %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
 772  %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
 773  %{Qn:-fno-ident} %{-help:--help}\
 774  %{-target-help:--target-help}\
 775  %{-version:--version}\
 776  %{-help=*:--help=%*}\
 777  %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
 778  %{fsyntax-only:-o %j} %{-param*}\
 779  %{fmudflap|fmudflapth:-fno-builtin -fno-merge-constants}\
 780  %{coverage:-fprofile-arcs -ftest-coverage}";
 781
 782 static const char *asm_options =
 783 "%{--target-help:%:print-asm-header()} "
 784 #if HAVE_GNU_AS
 785 /* If GNU AS is used, then convert -w (no warnings), -I, and -v
 786    to the assembler equivalents.  */
 787 "%{v} %{w:-W} %{I*} "
 788 #endif
 789 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
 790
 791 static const char *invoke_as =
 792 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
 793 "%{!fwpa:\
 794    %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
 795    %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
 796   }";
 797 #else
 798 "%{!fwpa:\
 799    %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
 800    %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
 801   }";
 802 #endif
 803
 804 /* Some compilers have limits on line lengths, and the multilib_select
 805    and/or multilib_matches strings can be very long, so we build them at
 806    run time.  */
 807 static struct obstack multilib_obstack;
 808 static const char *multilib_select;
 809 static const char *multilib_matches;
 810 static const char *multilib_defaults;
 811 static const char *multilib_exclusions;
 812
 813 /* Check whether a particular argument is a default argument.  */
 814
 815 #ifndef MULTILIB_DEFAULTS
 816 #define MULTILIB_DEFAULTS { "" }
 817 #endif
 818
 819 static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
 820
 821 #ifndef DRIVER_SELF_SPECS
 822 #define DRIVER_SELF_SPECS ""
 823 #endif
 824
 825 /* Adding -fopenmp should imply pthreads.  This is particularly important
 826    for targets that use different start files and suchlike.  */
 827 #ifndef GOMP_SELF_SPECS
 828 #define GOMP_SELF_SPECS "%{fopenmp|ftree-parallelize-loops=*: -pthread}"
 829 #endif
 830
 831 static const char *const driver_self_specs[] = {
 832   "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
 833   DRIVER_SELF_SPECS, CONFIGURE_SPECS, GOMP_SELF_SPECS
 834 };
 835
 836 #ifndef OPTION_DEFAULT_SPECS
 837 #define OPTION_DEFAULT_SPECS { "", "" }
 838 #endif
 839
 840 struct default_spec
 841 {
 842   const char *name;
 843   const char *spec;
 844 };
 845
 846 static const struct default_spec
 847   option_default_specs[] = { OPTION_DEFAULT_SPECS };
 848
 849 struct user_specs
 850 {
 851   struct user_specs *next;
 852   const char *filename;
 853 };
 854
 855 static struct user_specs *user_specs_head, *user_specs_tail;
 856
 857 \f
 858 /* Record the mapping from file suffixes for compilation specs.  */
 859
 860 struct compiler
 861 {
 862   const char *suffix;           /* Use this compiler for input files
 863                                    whose names end in this suffix.  */
 864
 865   const char *spec;             /* To use this compiler, run this spec.  */
 866
 867   const char *cpp_spec;         /* If non-NULL, substitute this spec
 868                                    for `%C', rather than the usual
 869                                    cpp_spec.  */
 870   const int combinable;          /* If nonzero, compiler can deal with
 871                                     multiple source files at once (IMA).  */
 872   const int needs_preprocessing; /* If nonzero, source files need to
 873                                     be run through a preprocessor.  */
 874 };
 875
 876 /* Pointer to a vector of `struct compiler' that gives the spec for
 877    compiling a file, based on its suffix.
 878    A file that does not end in any of these suffixes will be passed
 879    unchanged to the loader and nothing else will be done to it.
 880
 881    An entry containing two 0s is used to terminate the vector.
 882
 883    If multiple entries match a file, the last matching one is used.  */
 884
 885 static struct compiler *compilers;
 886
 887 /* Number of entries in `compilers', not counting the null terminator.  */
 888
 889 static int n_compilers;
 890
 891 /* The default list of file name suffixes and their compilation specs.  */
 892
 893 static const struct compiler default_compilers[] =
 894 {
 895   /* Add lists of suffixes of known languages here.  If those languages
 896      were not present when we built the driver, we will hit these copies
 897      and be given a more meaningful error than "file not used since
 898      linking is not done".  */
 899   {".m",  "#Objective-C", 0, 0, 0}, {".mi",  "#Objective-C", 0, 0, 0},
 900   {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
 901   {".mii", "#Objective-C++", 0, 0, 0},
 902   {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
 903   {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
 904   {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
 905   {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
 906   {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
 907   {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
 908   {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
 909   {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
 910   {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
 911   {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
 912   {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
 913   {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
 914   {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
 915   {".r", "#Ratfor", 0, 0, 0},
 916   {".p", "#Pascal", 0, 0, 0}, {".pas", "#Pascal", 0, 0, 0},
 917   {".java", "#Java", 0, 0, 0}, {".class", "#Java", 0, 0, 0},
 918   {".zip", "#Java", 0, 0, 0}, {".jar", "#Java", 0, 0, 0},
 919   /* Next come the entries for C.  */
 920   {".c", "@c", 0, 0, 1},
 921   {"@c",
 922    /* cc1 has an integrated ISO C preprocessor.  We should invoke the
 923       external preprocessor if -save-temps is given.  */
 924      "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
 925       %{!E:%{!M:%{!MM:\
 926           %{traditional|ftraditional:\
 927 %eGNU C no longer supports -traditional without -E}\
 928       %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
 929           %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
 930             cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
 931           %(cc1_options)}\
 932       %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
 933           cc1 %(cpp_unique_options) %(cc1_options)}}}\
 934       %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 1},
 935   {"-",
 936    "%{!E:%e-E or -x required when input is from standard input}\
 937     %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
 938   {".h", "@c-header", 0, 0, 0},
 939   {"@c-header",
 940    /* cc1 has an integrated ISO C preprocessor.  We should invoke the
 941       external preprocessor if -save-temps is given.  */
 942      "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
 943       %{!E:%{!M:%{!MM:\
 944           %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
 945                 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
 946                     cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
 947                         %(cc1_options)\
 948                         %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
 949                         %W{o*:--output-pch=%*}}%V}\
 950           %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
 951                 cc1 %(cpp_unique_options) %(cc1_options)\
 952                     %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
 953                     %W{o*:--output-pch=%*}}%V}}}}}}", 0, 0, 0},
 954   {".i", "@cpp-output", 0, 0, 0},
 955   {"@cpp-output",
 956    "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 1, 0},
 957   {".s", "@assembler", 0, 1, 0},
 958   {"@assembler",
 959    "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 1, 0},
 960   {".sx", "@assembler-with-cpp", 0, 1, 0},
 961   {".S", "@assembler-with-cpp", 0, 1, 0},
 962   {"@assembler-with-cpp",
 963 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
 964    "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
 965       %{E|M|MM:%(cpp_debug_options)}\
 966       %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
 967        as %(asm_debug) %(asm_options) %|.s %A }}}}"
 968 #else
 969    "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
 970       %{E|M|MM:%(cpp_debug_options)}\
 971       %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
 972        as %(asm_debug) %(asm_options) %m.s %A }}}}"
 973 #endif
 974    , 0, 1, 0},
 975
 976 #include "specs.h"
 977   /* Mark end of table.  */
 978   {0, 0, 0, 0, 0}
 979 };
 980
 981 /* Number of elements in default_compilers, not counting the terminator.  */
 982
 983 static const int n_default_compilers = ARRAY_SIZE (default_compilers) - 1;
 984
 985 /* A vector of options to give to the linker.
 986    These options are accumulated by %x,
 987    and substituted into the linker command with %X.  */
 988 static int n_linker_options;
 989 static char **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 int n_assembler_options;
 995 static char **assembler_options;
 996
 997 /* A vector of options to give to the preprocessor.
 998    These options are accumulated by -Wp,
 999    and substituted into the preprocessor command with %Z.  */
1000 static int n_preprocessor_options;
1001 static char **preprocessor_options;
1002 \f
1003 static char *
1004 skip_whitespace (char *p)
1005 {
1006   while (1)
1007     {
1008       /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1009          be considered whitespace.  */
1010       if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
1011         return p + 1;
1012       else if (*p == '\n' || *p == ' ' || *p == '\t')
1013         p++;
1014       else if (*p == '#')
1015         {
1016           while (*p != '\n')
1017             p++;
1018           p++;
1019         }
1020       else
1021         break;
1022     }
1023
1024   return p;
1025 }
1026 /* Structures to keep track of prefixes to try when looking for files.  */
1027
1028 struct prefix_list
1029 {
1030   const char *prefix;         /* String to prepend to the path.  */
1031   struct prefix_list *next;   /* Next in linked list.  */
1032   int require_machine_suffix; /* Don't use without machine_suffix.  */
1033   /* 2 means try both machine_suffix and just_machine_suffix.  */
1034   int priority;               /* Sort key - priority within list.  */
1035   int os_multilib;            /* 1 if OS multilib scheme should be used,
1036                                  0 for GCC multilib scheme.  */
1037 };
1038
1039 struct path_prefix
1040 {
1041   struct prefix_list *plist;  /* List of prefixes to try */
1042   int max_len;                /* Max length of a prefix in PLIST */
1043   const char *name;           /* Name of this list (used in config stuff) */
1044 };
1045
1046 /* List of prefixes to try when looking for executables.  */
1047
1048 static struct path_prefix exec_prefixes = { 0, 0, "exec" };
1049
1050 /* List of prefixes to try when looking for startup (crt0) files.  */
1051
1052 static struct path_prefix startfile_prefixes = { 0, 0, "startfile" };
1053
1054 /* List of prefixes to try when looking for include files.  */
1055
1056 static struct path_prefix include_prefixes = { 0, 0, "include" };
1057
1058 /* Suffix to attach to directories searched for commands.
1059    This looks like `MACHINE/VERSION/'.  */
1060
1061 static const char *machine_suffix = 0;
1062
1063 /* Suffix to attach to directories searched for commands.
1064    This is just `MACHINE/'.  */
1065
1066 static const char *just_machine_suffix = 0;
1067
1068 /* Adjusted value of GCC_EXEC_PREFIX envvar.  */
1069
1070 static const char *gcc_exec_prefix;
1071
1072 /* Adjusted value of standard_libexec_prefix.  */
1073
1074 static const char *gcc_libexec_prefix;
1075
1076 /* Default prefixes to attach to command names.  */
1077
1078 #ifndef STANDARD_STARTFILE_PREFIX_1
1079 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1080 #endif
1081 #ifndef STANDARD_STARTFILE_PREFIX_2
1082 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1083 #endif
1084
1085 #ifdef CROSS_DIRECTORY_STRUCTURE  /* Don't use these prefixes for a cross compiler.  */
1086 #undef MD_EXEC_PREFIX
1087 #undef MD_STARTFILE_PREFIX
1088 #undef MD_STARTFILE_PREFIX_1
1089 #endif
1090
1091 /* If no prefixes defined, use the null string, which will disable them.  */
1092 #ifndef MD_EXEC_PREFIX
1093 #define MD_EXEC_PREFIX ""
1094 #endif
1095 #ifndef MD_STARTFILE_PREFIX
1096 #define MD_STARTFILE_PREFIX ""
1097 #endif
1098 #ifndef MD_STARTFILE_PREFIX_1
1099 #define MD_STARTFILE_PREFIX_1 ""
1100 #endif
1101
1102 /* These directories are locations set at configure-time based on the
1103    --prefix option provided to configure.  Their initializers are
1104    defined in Makefile.in.  These paths are not *directly* used when
1105    gcc_exec_prefix is set because, in that case, we know where the
1106    compiler has been installed, and use paths relative to that
1107    location instead.  */
1108 static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
1109 static const char *const standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX;
1110 static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
1111 static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1112
1113 /* For native compilers, these are well-known paths containing
1114    components that may be provided by the system.  For cross
1115    compilers, these paths are not used.  */
1116 static const char *md_exec_prefix = MD_EXEC_PREFIX;
1117 static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1118 static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1119 static const char *const standard_startfile_prefix_1
1120   = STANDARD_STARTFILE_PREFIX_1;
1121 static const char *const standard_startfile_prefix_2
1122   = STANDARD_STARTFILE_PREFIX_2;
1123
1124 /* A relative path to be used in finding the location of tools
1125    relative to the driver.  */
1126 static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1127
1128 /* Subdirectory to use for locating libraries.  Set by
1129    set_multilib_dir based on the compilation options.  */
1130
1131 static const char *multilib_dir;
1132
1133 /* Subdirectory to use for locating libraries in OS conventions.  Set by
1134    set_multilib_dir based on the compilation options.  */
1135
1136 static const char *multilib_os_dir;
1137 \f
1138 /* Structure to keep track of the specs that have been defined so far.
1139    These are accessed using %(specname) or %[specname] in a compiler
1140    or link spec.  */
1141
1142 struct spec_list
1143 {
1144                                 /* The following 2 fields must be first */
1145                                 /* to allow EXTRA_SPECS to be initialized */
1146   const char *name;             /* name of the spec.  */
1147   const char *ptr;              /* available ptr if no static pointer */
1148
1149                                 /* The following fields are not initialized */
1150                                 /* by EXTRA_SPECS */
1151   const char **ptr_spec;        /* pointer to the spec itself.  */
1152   struct spec_list *next;       /* Next spec in linked list.  */
1153   int name_len;                 /* length of the name */
1154   int alloc_p;                  /* whether string was allocated */
1155 };
1156
1157 #define INIT_STATIC_SPEC(NAME,PTR) \
1158 { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, 0 }
1159
1160 /* List of statically defined specs.  */
1161 static struct spec_list static_specs[] =
1162 {
1163   INIT_STATIC_SPEC ("asm",                      &asm_spec),
1164   INIT_STATIC_SPEC ("asm_debug",                &asm_debug),
1165   INIT_STATIC_SPEC ("asm_final",                &asm_final_spec),
1166   INIT_STATIC_SPEC ("asm_options",              &asm_options),
1167   INIT_STATIC_SPEC ("invoke_as",                &invoke_as),
1168   INIT_STATIC_SPEC ("cpp",                      &cpp_spec),
1169   INIT_STATIC_SPEC ("cpp_options",              &cpp_options),
1170   INIT_STATIC_SPEC ("cpp_debug_options",        &cpp_debug_options),
1171   INIT_STATIC_SPEC ("cpp_unique_options",       &cpp_unique_options),
1172   INIT_STATIC_SPEC ("trad_capable_cpp",         &trad_capable_cpp),
1173   INIT_STATIC_SPEC ("cc1",                      &cc1_spec),
1174   INIT_STATIC_SPEC ("cc1_options",              &cc1_options),
1175   INIT_STATIC_SPEC ("cc1plus",                  &cc1plus_spec),
1176   INIT_STATIC_SPEC ("link_gcc_c_sequence",      &link_gcc_c_sequence_spec),
1177   INIT_STATIC_SPEC ("link_ssp",                 &link_ssp_spec),
1178   INIT_STATIC_SPEC ("endfile",                  &endfile_spec),
1179   INIT_STATIC_SPEC ("link",                     &link_spec),
1180   INIT_STATIC_SPEC ("lib",                      &lib_spec),
1181   INIT_STATIC_SPEC ("mfwrap",                   &mfwrap_spec),
1182   INIT_STATIC_SPEC ("mflib",                    &mflib_spec),
1183   INIT_STATIC_SPEC ("link_gomp",                &link_gomp_spec),
1184   INIT_STATIC_SPEC ("libgcc",                   &libgcc_spec),
1185   INIT_STATIC_SPEC ("startfile",                &startfile_spec),
1186   INIT_STATIC_SPEC ("cross_compile",            &cross_compile),
1187   INIT_STATIC_SPEC ("version",                  &compiler_version),
1188   INIT_STATIC_SPEC ("multilib",                 &multilib_select),
1189   INIT_STATIC_SPEC ("multilib_defaults",        &multilib_defaults),
1190   INIT_STATIC_SPEC ("multilib_extra",           &multilib_extra),
1191   INIT_STATIC_SPEC ("multilib_matches",         &multilib_matches),
1192   INIT_STATIC_SPEC ("multilib_exclusions",      &multilib_exclusions),
1193   INIT_STATIC_SPEC ("multilib_options",         &multilib_options),
1194   INIT_STATIC_SPEC ("linker",                   &linker_name_spec),
1195   INIT_STATIC_SPEC ("linker_plugin_file",       &linker_plugin_file_spec),
1196   INIT_STATIC_SPEC ("lto_wrapper",              &lto_wrapper_spec),
1197   INIT_STATIC_SPEC ("lto_gcc",                  &lto_gcc_spec),
1198   INIT_STATIC_SPEC ("lto_libgcc",               &lto_libgcc_spec),
1199   INIT_STATIC_SPEC ("link_libgcc",              &link_libgcc_spec),
1200   INIT_STATIC_SPEC ("md_exec_prefix",           &md_exec_prefix),
1201   INIT_STATIC_SPEC ("md_startfile_prefix",      &md_startfile_prefix),
1202   INIT_STATIC_SPEC ("md_startfile_prefix_1",    &md_startfile_prefix_1),
1203   INIT_STATIC_SPEC ("startfile_prefix_spec",    &startfile_prefix_spec),
1204   INIT_STATIC_SPEC ("sysroot_spec",             &sysroot_spec),
1205   INIT_STATIC_SPEC ("sysroot_suffix_spec",      &sysroot_suffix_spec),
1206   INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec),
1207 };
1208
1209 #ifdef EXTRA_SPECS              /* additional specs needed */
1210 /* Structure to keep track of just the first two args of a spec_list.
1211    That is all that the EXTRA_SPECS macro gives us.  */
1212 struct spec_list_1
1213 {
1214   const char *const name;
1215   const char *const ptr;
1216 };
1217
1218 static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1219 static struct spec_list *extra_specs = (struct spec_list *) 0;
1220 #endif
1221
1222 /* List of dynamically allocates specs that have been defined so far.  */
1223
1224 static struct spec_list *specs = (struct spec_list *) 0;
1225 \f
1226 /* List of static spec functions.  */
1227
1228 static const struct spec_function static_spec_functions[] =
1229 {
1230   { "getenv",                   getenv_spec_function },
1231   { "if-exists",                if_exists_spec_function },
1232   { "if-exists-else",           if_exists_else_spec_function },
1233   { "replace-outfile",          replace_outfile_spec_function },
1234   { "remove-outfile",           remove_outfile_spec_function },
1235   { "version-compare",          version_compare_spec_function },
1236   { "include",                  include_spec_function },
1237   { "find-file",                find_file_spec_function },
1238   { "find-plugindir",           find_plugindir_spec_function },
1239   { "print-asm-header",         print_asm_header_spec_function },
1240   { "compare-debug-dump-opt",   compare_debug_dump_opt_spec_function },
1241   { "compare-debug-self-opt",   compare_debug_self_opt_spec_function },
1242   { "compare-debug-auxbase-opt", compare_debug_auxbase_opt_spec_function },
1243 #ifdef EXTRA_SPEC_FUNCTIONS
1244   EXTRA_SPEC_FUNCTIONS
1245 #endif
1246   { 0, 0 }
1247 };
1248
1249 static int processing_spec_function;
1250 \f
1251 /* Add appropriate libgcc specs to OBSTACK, taking into account
1252    various permutations of -shared-libgcc, -shared, and such.  */
1253
1254 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1255
1256 #ifndef USE_LD_AS_NEEDED
1257 #define USE_LD_AS_NEEDED 0
1258 #endif
1259
1260 static void
1261 init_gcc_specs (struct obstack *obstack, const char *shared_name,
1262                 const char *static_name, const char *eh_name)
1263 {
1264   char *buf;
1265
1266   buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name, "}"
1267                 "%{!static:%{!static-libgcc:"
1268 #if USE_LD_AS_NEEDED
1269                 "%{!shared-libgcc:",
1270                 static_name, " --as-needed ", shared_name, " --no-as-needed"
1271                 "}"
1272                 "%{shared-libgcc:",
1273                 shared_name, "%{!shared: ", static_name, "}"
1274                 "}"
1275 #else
1276                 "%{!shared:"
1277                 "%{!shared-libgcc:", static_name, " ", eh_name, "}"
1278                 "%{shared-libgcc:", shared_name, " ", static_name, "}"
1279                 "}"
1280 #ifdef LINK_EH_SPEC
1281                 "%{shared:"
1282                 "%{shared-libgcc:", shared_name, "}"
1283                 "%{!shared-libgcc:", static_name, "}"
1284                 "}"
1285 #else
1286                 "%{shared:", shared_name, "}"
1287 #endif
1288 #endif
1289                 "}}", NULL);
1290
1291   obstack_grow (obstack, buf, strlen (buf));
1292   free (buf);
1293 }
1294 #endif /* ENABLE_SHARED_LIBGCC */
1295
1296 /* Initialize the specs lookup routines.  */
1297
1298 static void
1299 init_spec (void)
1300 {
1301   struct spec_list *next = (struct spec_list *) 0;
1302   struct spec_list *sl   = (struct spec_list *) 0;
1303   int i;
1304
1305   if (specs)
1306     return;                     /* Already initialized.  */
1307
1308   if (verbose_flag)
1309     fnotice (stderr, "Using built-in specs.\n");
1310
1311 #ifdef EXTRA_SPECS
1312   extra_specs = XCNEWVEC (struct spec_list, ARRAY_SIZE (extra_specs_1));
1313
1314   for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--)
1315     {
1316       sl = &extra_specs[i];
1317       sl->name = extra_specs_1[i].name;
1318       sl->ptr = extra_specs_1[i].ptr;
1319       sl->next = next;
1320       sl->name_len = strlen (sl->name);
1321       sl->ptr_spec = &sl->ptr;
1322       next = sl;
1323     }
1324 #endif
1325
1326   for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1327     {
1328       sl = &static_specs[i];
1329       sl->next = next;
1330       next = sl;
1331     }
1332
1333 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1334   /* ??? If neither -shared-libgcc nor --static-libgcc was
1335      seen, then we should be making an educated guess.  Some proposed
1336      heuristics for ELF include:
1337
1338         (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1339             program will be doing dynamic loading, which will likely
1340             need the shared libgcc.
1341
1342         (2) If "-ldl", then it's also a fair bet that we're doing
1343             dynamic loading.
1344
1345         (3) For each ET_DYN we're linking against (either through -lfoo
1346             or /some/path/foo.so), check to see whether it or one of
1347             its dependencies depends on a shared libgcc.
1348
1349         (4) If "-shared"
1350
1351             If the runtime is fixed to look for program headers instead
1352             of calling __register_frame_info at all, for each object,
1353             use the shared libgcc if any EH symbol referenced.
1354
1355             If crtstuff is fixed to not invoke __register_frame_info
1356             automatically, for each object, use the shared libgcc if
1357             any non-empty unwind section found.
1358
1359      Doing any of this probably requires invoking an external program to
1360      do the actual object file scanning.  */
1361   {
1362     const char *p = libgcc_spec;
1363     int in_sep = 1;
1364
1365     /* Transform the extant libgcc_spec into one that uses the shared libgcc
1366        when given the proper command line arguments.  */
1367     while (*p)
1368       {
1369         if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
1370           {
1371             init_gcc_specs (&obstack,
1372                             "-lgcc_s"
1373 #ifdef USE_LIBUNWIND_EXCEPTIONS
1374                             " -lunwind"
1375 #endif
1376                             ,
1377                             "-lgcc",
1378                             "-lgcc_eh"
1379 #ifdef USE_LIBUNWIND_EXCEPTIONS
1380 # ifdef HAVE_LD_STATIC_DYNAMIC
1381                             " %{!static:-Bstatic} -lunwind %{!static:-Bdynamic}"
1382 # else
1383                             " -lunwind"
1384 # endif
1385 #endif
1386                             );
1387
1388             p += 5;
1389             in_sep = 0;
1390           }
1391         else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0)
1392           {
1393             /* Ug.  We don't know shared library extensions.  Hope that
1394                systems that use this form don't do shared libraries.  */
1395             init_gcc_specs (&obstack,
1396                             "-lgcc_s",
1397                             "libgcc.a%s",
1398                             "libgcc_eh.a%s"
1399 #ifdef USE_LIBUNWIND_EXCEPTIONS
1400                             " -lunwind"
1401 #endif
1402                             );
1403             p += 10;
1404             in_sep = 0;
1405           }
1406         else
1407           {
1408             obstack_1grow (&obstack, *p);
1409             in_sep = (*p == ' ');
1410             p += 1;
1411           }
1412       }
1413
1414     obstack_1grow (&obstack, '\0');
1415     libgcc_spec = XOBFINISH (&obstack, const char *);
1416   }
1417 #endif
1418 #ifdef USE_AS_TRADITIONAL_FORMAT
1419   /* Prepend "--traditional-format" to whatever asm_spec we had before.  */
1420   {
1421     static const char tf[] = "--traditional-format ";
1422     obstack_grow (&obstack, tf, sizeof(tf) - 1);
1423     obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
1424     asm_spec = XOBFINISH (&obstack, const char *);
1425   }
1426 #endif
1427
1428 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC
1429 # ifdef LINK_BUILDID_SPEC
1430   /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before.  */
1431   obstack_grow (&obstack, LINK_BUILDID_SPEC, sizeof(LINK_BUILDID_SPEC) - 1);
1432 # endif
1433 # ifdef LINK_EH_SPEC
1434   /* Prepend LINK_EH_SPEC to whatever link_spec we had before.  */
1435   obstack_grow (&obstack, LINK_EH_SPEC, sizeof(LINK_EH_SPEC) - 1);
1436 # endif
1437   obstack_grow0 (&obstack, link_spec, strlen (link_spec));
1438   link_spec = XOBFINISH (&obstack, const char *);
1439 #endif
1440
1441   specs = sl;
1442 }
1443 \f
1444 /* Change the value of spec NAME to SPEC.  If SPEC is empty, then the spec is
1445    removed; If the spec starts with a + then SPEC is added to the end of the
1446    current spec.  */
1447
1448 static void
1449 set_spec (const char *name, const char *spec)
1450 {
1451   struct spec_list *sl;
1452   const char *old_spec;
1453   int name_len = strlen (name);
1454   int i;
1455
1456   /* If this is the first call, initialize the statically allocated specs.  */
1457   if (!specs)
1458     {
1459       struct spec_list *next = (struct spec_list *) 0;
1460       for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1461         {
1462           sl = &static_specs[i];
1463           sl->next = next;
1464           next = sl;
1465         }
1466       specs = sl;
1467     }
1468
1469   /* See if the spec already exists.  */
1470   for (sl = specs; sl; sl = sl->next)
1471     if (name_len == sl->name_len && !strcmp (sl->name, name))
1472       break;
1473
1474   if (!sl)
1475     {
1476       /* Not found - make it.  */
1477       sl = XNEW (struct spec_list);
1478       sl->name = xstrdup (name);
1479       sl->name_len = name_len;
1480       sl->ptr_spec = &sl->ptr;
1481       sl->alloc_p = 0;
1482       *(sl->ptr_spec) = "";
1483       sl->next = specs;
1484       specs = sl;
1485     }
1486
1487   old_spec = *(sl->ptr_spec);
1488   *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
1489                      ? concat (old_spec, spec + 1, NULL)
1490                      : xstrdup (spec));
1491
1492 #ifdef DEBUG_SPECS
1493   if (verbose_flag)
1494     fnotice (stderr, "Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
1495 #endif
1496
1497   /* Free the old spec.  */
1498   if (old_spec && sl->alloc_p)
1499     free (CONST_CAST(char *, old_spec));
1500
1501   sl->alloc_p = 1;
1502 }
1503 \f
1504 /* Accumulate a command (program name and args), and run it.  */
1505
1506 /* Vector of pointers to arguments in the current line of specifications.  */
1507
1508 static const char **argbuf;
1509
1510 /* Number of elements allocated in argbuf.  */
1511
1512 static int argbuf_length;
1513
1514 /* Number of elements in argbuf currently in use (containing args).  */
1515
1516 static int argbuf_index;
1517
1518 /* Position in the argbuf array containing the name of the output file
1519    (the value associated with the "-o" flag).  */
1520
1521 static int have_o_argbuf_index = 0;
1522
1523 /* Were the options -c, -S or -E passed.  */
1524 static int have_c = 0;
1525
1526 /* Was the option -o passed.  */
1527 static int have_o = 0;
1528
1529 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1530    temp file.  If the HOST_BIT_BUCKET is used for %j, no entry is made for
1531    it here.  */
1532
1533 static struct temp_name {
1534   const char *suffix;   /* suffix associated with the code.  */
1535   int length;           /* strlen (suffix).  */
1536   int unique;           /* Indicates whether %g or %u/%U was used.  */
1537   const char *filename; /* associated filename.  */
1538   int filename_length;  /* strlen (filename).  */
1539   struct temp_name *next;
1540 } *temp_names;
1541
1542 /* Number of commands executed so far.  */
1543
1544 static int execution_count;
1545
1546 /* Number of commands that exited with a signal.  */
1547
1548 static int signal_count;
1549 \f
1550 /* Allocate the argument vector.  */
1551
1552 static void
1553 alloc_args (void)
1554 {
1555   argbuf_length = 10;
1556   argbuf = XNEWVEC (const char *, argbuf_length);
1557 }
1558
1559 /* Clear out the vector of arguments (after a command is executed).  */
1560
1561 static void
1562 clear_args (void)
1563 {
1564   argbuf_index = 0;
1565 }
1566
1567 /* Add one argument to the vector at the end.
1568    This is done when a space is seen or at the end of the line.
1569    If DELETE_ALWAYS is nonzero, the arg is a filename
1570     and the file should be deleted eventually.
1571    If DELETE_FAILURE is nonzero, the arg is a filename
1572     and the file should be deleted if this compilation fails.  */
1573
1574 static void
1575 store_arg (const char *arg, int delete_always, int delete_failure)
1576 {
1577   if (argbuf_index + 1 == argbuf_length)
1578     argbuf = XRESIZEVEC (const char *, argbuf, (argbuf_length *= 2));
1579
1580   argbuf[argbuf_index++] = arg;
1581   argbuf[argbuf_index] = 0;
1582
1583   if (strcmp (arg, "-o") == 0)
1584     have_o_argbuf_index = argbuf_index;
1585   if (delete_always || delete_failure)
1586     {
1587       const char *p;
1588       /* If the temporary file we should delete is specified as
1589          part of a joined argument extract the filename.  */
1590       if (arg[0] == '-'
1591           && (p = strrchr (arg, '=')))
1592         arg = p + 1;
1593       record_temp_file (arg, delete_always, delete_failure);
1594     }
1595 }
1596 \f
1597 /* Load specs from a file name named FILENAME, replacing occurrences of
1598    various different types of line-endings, \r\n, \n\r and just \r, with
1599    a single \n.  */
1600
1601 static char *
1602 load_specs (const char *filename)
1603 {
1604   int desc;
1605   int readlen;
1606   struct stat statbuf;
1607   char *buffer;
1608   char *buffer_p;
1609   char *specs;
1610   char *specs_p;
1611
1612   if (verbose_flag)
1613     fnotice (stderr, "Reading specs from %s\n", filename);
1614
1615   /* Open and stat the file.  */
1616   desc = open (filename, O_RDONLY, 0);
1617   if (desc < 0)
1618     pfatal_with_name (filename);
1619   if (stat (filename, &statbuf) < 0)
1620     pfatal_with_name (filename);
1621
1622   /* Read contents of file into BUFFER.  */
1623   buffer = XNEWVEC (char, statbuf.st_size + 1);
1624   readlen = read (desc, buffer, (unsigned) statbuf.st_size);
1625   if (readlen < 0)
1626     pfatal_with_name (filename);
1627   buffer[readlen] = 0;
1628   close (desc);
1629
1630   specs = XNEWVEC (char, readlen + 1);
1631   specs_p = specs;
1632   for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
1633     {
1634       int skip = 0;
1635       char c = *buffer_p;
1636       if (c == '\r')
1637         {
1638           if (buffer_p > buffer && *(buffer_p - 1) == '\n')     /* \n\r */
1639             skip = 1;
1640           else if (*(buffer_p + 1) == '\n')                     /* \r\n */
1641             skip = 1;
1642           else                                                  /* \r */
1643             c = '\n';
1644         }
1645       if (! skip)
1646         *specs_p++ = c;
1647     }
1648   *specs_p = '\0';
1649
1650   free (buffer);
1651   return (specs);
1652 }
1653
1654 /* Read compilation specs from a file named FILENAME,
1655    replacing the default ones.
1656
1657    A suffix which starts with `*' is a definition for
1658    one of the machine-specific sub-specs.  The "suffix" should be
1659    *asm, *cc1, *cpp, *link, *startfile, etc.
1660    The corresponding spec is stored in asm_spec, etc.,
1661    rather than in the `compilers' vector.
1662
1663    Anything invalid in the file is a fatal error.  */
1664
1665 static void
1666 read_specs (const char *filename, int main_p)
1667 {
1668   char *buffer;
1669   char *p;
1670
1671   buffer = load_specs (filename);
1672
1673   /* Scan BUFFER for specs, putting them in the vector.  */
1674   p = buffer;
1675   while (1)
1676     {
1677       char *suffix;
1678       char *spec;
1679       char *in, *out, *p1, *p2, *p3;
1680
1681       /* Advance P in BUFFER to the next nonblank nocomment line.  */
1682       p = skip_whitespace (p);
1683       if (*p == 0)
1684         break;
1685
1686       /* Is this a special command that starts with '%'? */
1687       /* Don't allow this for the main specs file, since it would
1688          encourage people to overwrite it.  */
1689       if (*p == '%' && !main_p)
1690         {
1691           p1 = p;
1692           while (*p && *p != '\n')
1693             p++;
1694
1695           /* Skip '\n'.  */
1696           p++;
1697
1698           if (!strncmp (p1, "%include", sizeof ("%include") - 1)
1699               && (p1[sizeof "%include" - 1] == ' '
1700                   || p1[sizeof "%include" - 1] == '\t'))
1701             {
1702               char *new_filename;
1703
1704               p1 += sizeof ("%include");
1705               while (*p1 == ' ' || *p1 == '\t')
1706                 p1++;
1707
1708               if (*p1++ != '<' || p[-2] != '>')
1709                 fatal_error ("specs %%include syntax malformed after "
1710                              "%ld characters",
1711                              (long) (p1 - buffer + 1));
1712
1713               p[-2] = '\0';
1714               new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
1715               read_specs (new_filename ? new_filename : p1, FALSE);
1716               continue;
1717             }
1718           else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
1719                    && (p1[sizeof "%include_noerr" - 1] == ' '
1720                        || p1[sizeof "%include_noerr" - 1] == '\t'))
1721             {
1722               char *new_filename;
1723
1724               p1 += sizeof "%include_noerr";
1725               while (*p1 == ' ' || *p1 == '\t')
1726                 p1++;
1727
1728               if (*p1++ != '<' || p[-2] != '>')
1729                 fatal_error ("specs %%include syntax malformed after "
1730                              "%ld characters",
1731                              (long) (p1 - buffer + 1));
1732
1733               p[-2] = '\0';
1734               new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
1735               if (new_filename)
1736                 read_specs (new_filename, FALSE);
1737               else if (verbose_flag)
1738                 fnotice (stderr, "could not find specs file %s\n", p1);
1739               continue;
1740             }
1741           else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
1742                    && (p1[sizeof "%rename" - 1] == ' '
1743                        || p1[sizeof "%rename" - 1] == '\t'))
1744             {
1745               int name_len;
1746               struct spec_list *sl;
1747               struct spec_list *newsl;
1748
1749               /* Get original name.  */
1750               p1 += sizeof "%rename";
1751               while (*p1 == ' ' || *p1 == '\t')
1752                 p1++;
1753
1754               if (! ISALPHA ((unsigned char) *p1))
1755                 fatal_error ("specs %%rename syntax malformed after "
1756                              "%ld characters",
1757                              (long) (p1 - buffer));
1758
1759               p2 = p1;
1760               while (*p2 && !ISSPACE ((unsigned char) *p2))
1761                 p2++;
1762
1763               if (*p2 != ' ' && *p2 != '\t')
1764                 fatal_error ("specs %%rename syntax malformed after "
1765                              "%ld characters",
1766                              (long) (p2 - buffer));
1767
1768               name_len = p2 - p1;
1769               *p2++ = '\0';
1770               while (*p2 == ' ' || *p2 == '\t')
1771                 p2++;
1772
1773               if (! ISALPHA ((unsigned char) *p2))
1774                 fatal_error ("specs %%rename syntax malformed after "
1775                              "%ld characters",
1776                              (long) (p2 - buffer));
1777
1778               /* Get new spec name.  */
1779               p3 = p2;
1780               while (*p3 && !ISSPACE ((unsigned char) *p3))
1781                 p3++;
1782
1783               if (p3 != p - 1)
1784                 fatal_error ("specs %%rename syntax malformed after "
1785                              "%ld characters",
1786                              (long) (p3 - buffer));
1787               *p3 = '\0';
1788
1789               for (sl = specs; sl; sl = sl->next)
1790                 if (name_len == sl->name_len && !strcmp (sl->name, p1))
1791                   break;
1792
1793               if (!sl)
1794                 fatal_error ("specs %s spec was not found to be renamed", p1);
1795
1796               if (strcmp (p1, p2) == 0)
1797                 continue;
1798
1799               for (newsl = specs; newsl; newsl = newsl->next)
1800                 if (strcmp (newsl->name, p2) == 0)
1801                   fatal_error ("%s: attempt to rename spec %qs to "
1802                                "already defined spec %qs",
1803                     filename, p1, p2);
1804
1805               if (verbose_flag)
1806                 {
1807                   fnotice (stderr, "rename spec %s to %s\n", p1, p2);
1808 #ifdef DEBUG_SPECS
1809                   fnotice (stderr, "spec is '%s'\n\n", *(sl->ptr_spec));
1810 #endif
1811                 }
1812
1813               set_spec (p2, *(sl->ptr_spec));
1814               if (sl->alloc_p)
1815                 free (CONST_CAST (char *, *(sl->ptr_spec)));
1816
1817               *(sl->ptr_spec) = "";
1818               sl->alloc_p = 0;
1819               continue;
1820             }
1821           else
1822             fatal_error ("specs unknown %% command after %ld characters",
1823                          (long) (p1 - buffer));
1824         }
1825
1826       /* Find the colon that should end the suffix.  */
1827       p1 = p;
1828       while (*p1 && *p1 != ':' && *p1 != '\n')
1829         p1++;
1830
1831       /* The colon shouldn't be missing.  */
1832       if (*p1 != ':')
1833         fatal_error ("specs file malformed after %ld characters",
1834                      (long) (p1 - buffer));
1835
1836       /* Skip back over trailing whitespace.  */
1837       p2 = p1;
1838       while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
1839         p2--;
1840
1841       /* Copy the suffix to a string.  */
1842       suffix = save_string (p, p2 - p);
1843       /* Find the next line.  */
1844       p = skip_whitespace (p1 + 1);
1845       if (p[1] == 0)
1846         fatal_error ("specs file malformed after %ld characters",
1847                      (long) (p - buffer));
1848
1849       p1 = p;
1850       /* Find next blank line or end of string.  */
1851       while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
1852         p1++;
1853
1854       /* Specs end at the blank line and do not include the newline.  */
1855       spec = save_string (p, p1 - p);
1856       p = p1;
1857
1858       /* Delete backslash-newline sequences from the spec.  */
1859       in = spec;
1860       out = spec;
1861       while (*in != 0)
1862         {
1863           if (in[0] == '\\' && in[1] == '\n')
1864             in += 2;
1865           else if (in[0] == '#')
1866             while (*in && *in != '\n')
1867               in++;
1868
1869           else
1870             *out++ = *in++;
1871         }
1872       *out = 0;
1873
1874       if (suffix[0] == '*')
1875         {
1876           if (! strcmp (suffix, "*link_command"))
1877             link_command_spec = spec;
1878           else
1879             set_spec (suffix + 1, spec);
1880         }
1881       else
1882         {
1883           /* Add this pair to the vector.  */
1884           compilers
1885             = XRESIZEVEC (struct compiler, compilers, n_compilers + 2);
1886
1887           compilers[n_compilers].suffix = suffix;
1888           compilers[n_compilers].spec = spec;
1889           n_compilers++;
1890           memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
1891         }
1892
1893       if (*suffix == 0)
1894         link_command_spec = spec;
1895     }
1896
1897   if (link_command_spec == 0)
1898     fatal_error ("spec file has no spec for linking");
1899 }
1900 \f
1901 /* Record the names of temporary files we tell compilers to write,
1902    and delete them at the end of the run.  */
1903
1904 /* This is the common prefix we use to make temp file names.
1905    It is chosen once for each run of this program.
1906    It is substituted into a spec by %g or %j.
1907    Thus, all temp file names contain this prefix.
1908    In practice, all temp file names start with this prefix.
1909
1910    This prefix comes from the envvar TMPDIR if it is defined;
1911    otherwise, from the P_tmpdir macro if that is defined;
1912    otherwise, in /usr/tmp or /tmp;
1913    or finally the current directory if all else fails.  */
1914
1915 static const char *temp_filename;
1916
1917 /* Length of the prefix.  */
1918
1919 static int temp_filename_length;
1920
1921 /* Define the list of temporary files to delete.  */
1922
1923 struct temp_file
1924 {
1925   const char *name;
1926   struct temp_file *next;
1927 };
1928
1929 /* Queue of files to delete on success or failure of compilation.  */
1930 static struct temp_file *always_delete_queue;
1931 /* Queue of files to delete on failure of compilation.  */
1932 static struct temp_file *failure_delete_queue;
1933
1934 /* Record FILENAME as a file to be deleted automatically.
1935    ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
1936    otherwise delete it in any case.
1937    FAIL_DELETE nonzero means delete it if a compilation step fails;
1938    otherwise delete it in any case.  */
1939
1940 void
1941 record_temp_file (const char *filename, int always_delete, int fail_delete)
1942 {
1943   char *const name = xstrdup (filename);
1944
1945   if (always_delete)
1946     {
1947       struct temp_file *temp;
1948       for (temp = always_delete_queue; temp; temp = temp->next)
1949         if (! strcmp (name, temp->name))
1950           goto already1;
1951
1952       temp = XNEW (struct temp_file);
1953       temp->next = always_delete_queue;
1954       temp->name = name;
1955       always_delete_queue = temp;
1956
1957     already1:;
1958     }
1959
1960   if (fail_delete)
1961     {
1962       struct temp_file *temp;
1963       for (temp = failure_delete_queue; temp; temp = temp->next)
1964         if (! strcmp (name, temp->name))
1965           goto already2;
1966
1967       temp = XNEW (struct temp_file);
1968       temp->next = failure_delete_queue;
1969       temp->name = name;
1970       failure_delete_queue = temp;
1971
1972     already2:;
1973     }
1974 }
1975
1976 /* Delete all the temporary files whose names we previously recorded.  */
1977
1978 #ifndef DELETE_IF_ORDINARY
1979 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG)        \
1980 do                                                      \
1981   {                                                     \
1982     if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode))  \
1983       if (unlink (NAME) < 0)                            \
1984         if (VERBOSE_FLAG)                               \
1985           perror_with_name (NAME);                      \
1986   } while (0)
1987 #endif
1988
1989 static void
1990 delete_if_ordinary (const char *name)
1991 {
1992   struct stat st;
1993 #ifdef DEBUG
1994   int i, c;
1995
1996   printf ("Delete %s? (y or n) ", name);
1997   fflush (stdout);
1998   i = getchar ();
1999   if (i != '\n')
2000     while ((c = getchar ()) != '\n' && c != EOF)
2001       ;
2002
2003   if (i == 'y' || i == 'Y')
2004 #endif /* DEBUG */
2005   DELETE_IF_ORDINARY (name, st, verbose_flag);
2006 }
2007
2008 static void
2009 delete_temp_files (void)
2010 {
2011   struct temp_file *temp;
2012
2013   for (temp = always_delete_queue; temp; temp = temp->next)
2014     delete_if_ordinary (temp->name);
2015   always_delete_queue = 0;
2016 }
2017
2018 /* Delete all the files to be deleted on error.  */
2019
2020 static void
2021 delete_failure_queue (void)
2022 {
2023   struct temp_file *temp;
2024
2025   for (temp = failure_delete_queue; temp; temp = temp->next)
2026     delete_if_ordinary (temp->name);
2027 }
2028
2029 static void
2030 clear_failure_queue (void)
2031 {
2032   failure_delete_queue = 0;
2033 }
2034 \f
2035 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2036    returns non-NULL.
2037    If DO_MULTI is true iterate over the paths twice, first with multilib
2038    suffix then without, otherwise iterate over the paths once without
2039    adding a multilib suffix.  When DO_MULTI is true, some attempt is made
2040    to avoid visiting the same path twice, but we could do better.  For
2041    instance, /usr/lib/../lib is considered different from /usr/lib.
2042    At least EXTRA_SPACE chars past the end of the path passed to
2043    CALLBACK are available for use by the callback.
2044    CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2045
2046    Returns the value returned by CALLBACK.  */
2047
2048 static void *
2049 for_each_path (const struct path_prefix *paths,
2050                bool do_multi,
2051                size_t extra_space,
2052                void *(*callback) (char *, void *),
2053                void *callback_info)
2054 {
2055   struct prefix_list *pl;
2056   const char *multi_dir = NULL;
2057   const char *multi_os_dir = NULL;
2058   const char *multi_suffix;
2059   const char *just_multi_suffix;
2060   char *path = NULL;
2061   void *ret = NULL;
2062   bool skip_multi_dir = false;
2063   bool skip_multi_os_dir = false;
2064
2065   multi_suffix = machine_suffix;
2066   just_multi_suffix = just_machine_suffix;
2067   if (do_multi && multilib_dir && strcmp (multilib_dir, ".") != 0)
2068     {
2069       multi_dir = concat (multilib_dir, dir_separator_str, NULL);
2070       multi_suffix = concat (multi_suffix, multi_dir, NULL);
2071       just_multi_suffix = concat (just_multi_suffix, multi_dir, NULL);
2072     }
2073   if (do_multi && multilib_os_dir && strcmp (multilib_os_dir, ".") != 0)
2074     multi_os_dir = concat (multilib_os_dir, dir_separator_str, NULL);
2075
2076   while (1)
2077     {
2078       size_t multi_dir_len = 0;
2079       size_t multi_os_dir_len = 0;
2080       size_t suffix_len;
2081       size_t just_suffix_len;
2082       size_t len;
2083
2084       if (multi_dir)
2085         multi_dir_len = strlen (multi_dir);
2086       if (multi_os_dir)
2087         multi_os_dir_len = strlen (multi_os_dir);
2088       suffix_len = strlen (multi_suffix);
2089       just_suffix_len = strlen (just_multi_suffix);
2090
2091       if (path == NULL)
2092         {
2093           len = paths->max_len + extra_space + 1;
2094           if (suffix_len > multi_os_dir_len)
2095             len += suffix_len;
2096           else
2097             len += multi_os_dir_len;
2098           path = XNEWVEC (char, len);
2099         }
2100
2101       for (pl = paths->plist; pl != 0; pl = pl->next)
2102         {
2103           len = strlen (pl->prefix);
2104           memcpy (path, pl->prefix, len);
2105
2106           /* Look first in MACHINE/VERSION subdirectory.  */
2107           if (!skip_multi_dir)
2108             {
2109               memcpy (path + len, multi_suffix, suffix_len + 1);
2110               ret = callback (path, callback_info);
2111               if (ret)
2112                 break;
2113             }
2114
2115           /* Some paths are tried with just the machine (ie. target)
2116              subdir.  This is used for finding as, ld, etc.  */
2117           if (!skip_multi_dir
2118               && pl->require_machine_suffix == 2)
2119             {
2120               memcpy (path + len, just_multi_suffix, just_suffix_len + 1);
2121               ret = callback (path, callback_info);
2122               if (ret)
2123                 break;
2124             }
2125
2126           /* Now try the base path.  */
2127           if (!pl->require_machine_suffix
2128               && !(pl->os_multilib ? skip_multi_os_dir : skip_multi_dir))
2129             {
2130               const char *this_multi;
2131               size_t this_multi_len;
2132
2133               if (pl->os_multilib)
2134                 {
2135                   this_multi = multi_os_dir;
2136                   this_multi_len = multi_os_dir_len;
2137                 }
2138               else
2139                 {
2140                   this_multi = multi_dir;
2141                   this_multi_len = multi_dir_len;
2142                 }
2143
2144               if (this_multi_len)
2145                 memcpy (path + len, this_multi, this_multi_len + 1);
2146               else
2147                 path[len] = '\0';
2148
2149               ret = callback (path, callback_info);
2150               if (ret)
2151                 break;
2152             }
2153         }
2154       if (pl)
2155         break;
2156
2157       if (multi_dir == NULL && multi_os_dir == NULL)
2158         break;
2159
2160       /* Run through the paths again, this time without multilibs.
2161          Don't repeat any we have already seen.  */
2162       if (multi_dir)
2163         {
2164           free (CONST_CAST (char *, multi_dir));
2165           multi_dir = NULL;
2166           free (CONST_CAST (char *, multi_suffix));
2167           multi_suffix = machine_suffix;
2168           free (CONST_CAST (char *, just_multi_suffix));
2169           just_multi_suffix = just_machine_suffix;
2170         }
2171       else
2172         skip_multi_dir = true;
2173       if (multi_os_dir)
2174         {
2175           free (CONST_CAST (char *, multi_os_dir));
2176           multi_os_dir = NULL;
2177         }
2178       else
2179         skip_multi_os_dir = true;
2180     }
2181
2182   if (multi_dir)
2183     {
2184       free (CONST_CAST (char *, multi_dir));
2185       free (CONST_CAST (char *, multi_suffix));
2186       free (CONST_CAST (char *, just_multi_suffix));
2187     }
2188   if (multi_os_dir)
2189     free (CONST_CAST (char *, multi_os_dir));
2190   if (ret != path)
2191     free (path);
2192   return ret;
2193 }
2194
2195 /* Callback for build_search_list.  Adds path to obstack being built.  */
2196
2197 struct add_to_obstack_info {
2198   struct obstack *ob;
2199   bool check_dir;
2200   bool first_time;
2201 };
2202
2203 static void *
2204 add_to_obstack (char *path, void *data)
2205 {
2206   struct add_to_obstack_info *info = (struct add_to_obstack_info *) data;
2207
2208   if (info->check_dir && !is_directory (path, false))
2209     return NULL;
2210
2211   if (!info->first_time)
2212     obstack_1grow (info->ob, PATH_SEPARATOR);
2213
2214   obstack_grow (info->ob, path, strlen (path));
2215
2216   info->first_time = false;
2217   return NULL;
2218 }
2219
2220 /* Add or change the value of an environment variable, outputting the
2221    change to standard error if in verbose mode.  */
2222 static void
2223 xputenv (const char *string)
2224 {
2225   if (verbose_flag)
2226     fnotice (stderr, "%s\n", string);
2227   putenv (CONST_CAST (char *, string));
2228 }
2229
2230 /* Build a list of search directories from PATHS.
2231    PREFIX is a string to prepend to the list.
2232    If CHECK_DIR_P is true we ensure the directory exists.
2233    If DO_MULTI is true, multilib paths are output first, then
2234    non-multilib paths.
2235    This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2236    It is also used by the --print-search-dirs flag.  */
2237
2238 static char *
2239 build_search_list (const struct path_prefix *paths, const char *prefix,
2240                    bool check_dir, bool do_multi)
2241 {
2242   struct add_to_obstack_info info;
2243
2244   info.ob = &collect_obstack;
2245   info.check_dir = check_dir;
2246   info.first_time = true;
2247
2248   obstack_grow (&collect_obstack, prefix, strlen (prefix));
2249   obstack_1grow (&collect_obstack, '=');
2250
2251   for_each_path (paths, do_multi, 0, add_to_obstack, &info);
2252
2253   obstack_1grow (&collect_obstack, '\0');
2254   return XOBFINISH (&collect_obstack, char *);
2255 }
2256
2257 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2258    for collect.  */
2259
2260 static void
2261 putenv_from_prefixes (const struct path_prefix *paths, const char *env_var,
2262                       bool do_multi)
2263 {
2264   xputenv (build_search_list (paths, env_var, true, do_multi));
2265 }
2266 \f
2267 /* Check whether NAME can be accessed in MODE.  This is like access,
2268    except that it never considers directories to be executable.  */
2269
2270 static int
2271 access_check (const char *name, int mode)
2272 {
2273   if (mode == X_OK)
2274     {
2275       struct stat st;
2276
2277       if (stat (name, &st) < 0
2278           || S_ISDIR (st.st_mode))
2279         return -1;
2280     }
2281
2282   return access (name, mode);
2283 }
2284
2285 /* Callback for find_a_file.  Appends the file name to the directory
2286    path.  If the resulting file exists in the right mode, return the
2287    full pathname to the file.  */
2288
2289 struct file_at_path_info {
2290   const char *name;
2291   const char *suffix;
2292   int name_len;
2293   int suffix_len;
2294   int mode;
2295 };
2296
2297 static void *
2298 file_at_path (char *path, void *data)
2299 {
2300   struct file_at_path_info *info = (struct file_at_path_info *) data;
2301   size_t len = strlen (path);
2302
2303   memcpy (path + len, info->name, info->name_len);
2304   len += info->name_len;
2305
2306   /* Some systems have a suffix for executable files.
2307      So try appending that first.  */
2308   if (info->suffix_len)
2309     {
2310       memcpy (path + len, info->suffix, info->suffix_len + 1);
2311       if (access_check (path, info->mode) == 0)
2312         return path;
2313     }
2314
2315   path[len] = '\0';
2316   if (access_check (path, info->mode) == 0)
2317     return path;
2318
2319   return NULL;
2320 }
2321
2322 /* Search for NAME using the prefix list PREFIXES.  MODE is passed to
2323    access to check permissions.  If DO_MULTI is true, search multilib
2324    paths then non-multilib paths, otherwise do not search multilib paths.
2325    Return 0 if not found, otherwise return its name, allocated with malloc.  */
2326
2327 static char *
2328 find_a_file (const struct path_prefix *pprefix, const char *name, int mode,
2329              bool do_multi)
2330 {
2331   struct file_at_path_info info;
2332
2333 #ifdef DEFAULT_ASSEMBLER
2334   if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
2335     return xstrdup (DEFAULT_ASSEMBLER);
2336 #endif
2337
2338 #ifdef DEFAULT_LINKER
2339   if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0)
2340     return xstrdup (DEFAULT_LINKER);
2341 #endif
2342
2343   /* Determine the filename to execute (special case for absolute paths).  */
2344
2345   if (IS_ABSOLUTE_PATH (name))
2346     {
2347       if (access (name, mode) == 0)
2348         return xstrdup (name);
2349
2350       return NULL;
2351     }
2352
2353   info.name = name;
2354   info.suffix = (mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "";
2355   info.name_len = strlen (info.name);
2356   info.suffix_len = strlen (info.suffix);
2357   info.mode = mode;
2358
2359   return (char*) for_each_path (pprefix, do_multi,
2360                                 info.name_len + info.suffix_len,
2361                                 file_at_path, &info);
2362 }
2363
2364 /* Ranking of prefixes in the sort list. -B prefixes are put before
2365    all others.  */
2366
2367 enum path_prefix_priority
2368 {
2369   PREFIX_PRIORITY_B_OPT,
2370   PREFIX_PRIORITY_LAST
2371 };
2372
2373 /* Add an entry for PREFIX in PLIST.  The PLIST is kept in ascending
2374    order according to PRIORITY.  Within each PRIORITY, new entries are
2375    appended.
2376
2377    If WARN is nonzero, we will warn if no file is found
2378    through this prefix.  WARN should point to an int
2379    which will be set to 1 if this entry is used.
2380
2381    COMPONENT is the value to be passed to update_path.
2382
2383    REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2384    the complete value of machine_suffix.
2385    2 means try both machine_suffix and just_machine_suffix.  */
2386
2387 static void
2388 add_prefix (struct path_prefix *pprefix, const char *prefix,
2389             const char *component, /* enum prefix_priority */ int priority,
2390             int require_machine_suffix, int os_multilib)
2391 {
2392   struct prefix_list *pl, **prev;
2393   int len;
2394
2395   for (prev = &pprefix->plist;
2396        (*prev) != NULL && (*prev)->priority <= priority;
2397        prev = &(*prev)->next)
2398     ;
2399
2400   /* Keep track of the longest prefix.  */
2401
2402   prefix = update_path (prefix, component);
2403   len = strlen (prefix);
2404   if (len > pprefix->max_len)
2405     pprefix->max_len = len;
2406
2407   pl = XNEW (struct prefix_list);
2408   pl->prefix = prefix;
2409   pl->require_machine_suffix = require_machine_suffix;
2410   pl->priority = priority;
2411   pl->os_multilib = os_multilib;
2412
2413   /* Insert after PREV.  */
2414   pl->next = (*prev);
2415   (*prev) = pl;
2416 }
2417
2418 /* Same as add_prefix, but prepending target_system_root to prefix.  */
2419 /* The target_system_root prefix has been relocated by gcc_exec_prefix.  */
2420 static void
2421 add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
2422                       const char *component,
2423                       /* enum prefix_priority */ int priority,
2424                       int require_machine_suffix, int os_multilib)
2425 {
2426   if (!IS_ABSOLUTE_PATH (prefix))
2427     fatal_error ("system path %qs is not absolute", prefix);
2428
2429   if (target_system_root)
2430     {
2431       if (target_sysroot_suffix)
2432           prefix = concat (target_sysroot_suffix, prefix, NULL);
2433       prefix = concat (target_system_root, prefix, NULL);
2434
2435       /* We have to override this because GCC's notion of sysroot
2436          moves along with GCC.  */
2437       component = "GCC";
2438     }
2439
2440   add_prefix (pprefix, prefix, component, priority,
2441               require_machine_suffix, os_multilib);
2442 }
2443 \f
2444 /* Execute the command specified by the arguments on the current line of spec.
2445    When using pipes, this includes several piped-together commands
2446    with `|' between them.
2447
2448    Return 0 if successful, -1 if failed.  */
2449
2450 static int
2451 execute (void)
2452 {
2453   int i;
2454   int n_commands;               /* # of command.  */
2455   char *string;
2456   struct pex_obj *pex;
2457   struct command
2458   {
2459     const char *prog;           /* program name.  */
2460     const char **argv;          /* vector of args.  */
2461   };
2462
2463   struct command *commands;     /* each command buffer with above info.  */
2464
2465   gcc_assert (!processing_spec_function);
2466
2467   if (wrapper_string)
2468     {
2469       string = find_a_file (&exec_prefixes, argbuf[0], X_OK, false);
2470       argbuf[0] = (string) ? string : argbuf[0];
2471       insert_wrapper (wrapper_string);
2472     }
2473
2474   /* Count # of piped commands.  */
2475   for (n_commands = 1, i = 0; i < argbuf_index; i++)
2476     if (strcmp (argbuf[i], "|") == 0)
2477       n_commands++;
2478
2479   /* Get storage for each command.  */
2480   commands = (struct command *) alloca (n_commands * sizeof (struct command));
2481
2482   /* Split argbuf into its separate piped processes,
2483      and record info about each one.
2484      Also search for the programs that are to be run.  */
2485
2486   commands[0].prog = argbuf[0]; /* first command.  */
2487   commands[0].argv = &argbuf[0];
2488
2489   if (!wrapper_string)
2490     {
2491       string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, false);
2492       commands[0].argv[0] = (string) ? string : commands[0].argv[0];
2493     }
2494
2495   for (n_commands = 1, i = 0; i < argbuf_index; i++)
2496     if (strcmp (argbuf[i], "|") == 0)
2497       {                         /* each command.  */
2498 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2499         fatal_error ("-pipe not supported");
2500 #endif
2501         argbuf[i] = 0;  /* termination of command args.  */
2502         commands[n_commands].prog = argbuf[i + 1];
2503         commands[n_commands].argv = &argbuf[i + 1];
2504         string = find_a_file (&exec_prefixes, commands[n_commands].prog,
2505                               X_OK, false);
2506         if (string)
2507           commands[n_commands].argv[0] = string;
2508         n_commands++;
2509       }
2510
2511   argbuf[argbuf_index] = 0;
2512
2513   /* If -v, print what we are about to do, and maybe query.  */
2514
2515   if (verbose_flag)
2516     {
2517       /* For help listings, put a blank line between sub-processes.  */
2518       if (print_help_list)
2519         fputc ('\n', stderr);
2520
2521       /* Print each piped command as a separate line.  */
2522       for (i = 0; i < n_commands; i++)
2523         {
2524           const char *const *j;
2525
2526           if (verbose_only_flag)
2527             {
2528               for (j = commands[i].argv; *j; j++)
2529                 {
2530                   const char *p;
2531                   for (p = *j; *p; ++p)
2532                     if (!ISALNUM ((unsigned char) *p)
2533                         && *p != '_' && *p != '/' && *p != '-' && *p != '.')
2534                       break;
2535                   if (*p || !*j)
2536                     {
2537                       fprintf (stderr, " \"");
2538                       for (p = *j; *p; ++p)
2539                         {
2540                           if (*p == '"' || *p == '\\' || *p == '$')
2541                             fputc ('\\', stderr);
2542                           fputc (*p, stderr);
2543                         }
2544                       fputc ('"', stderr);
2545                     }
2546                   else
2547                     fprintf (stderr, " %s", *j);
2548                 }
2549             }
2550           else
2551             for (j = commands[i].argv; *j; j++)
2552               fprintf (stderr, " %s", *j);
2553
2554           /* Print a pipe symbol after all but the last command.  */
2555           if (i + 1 != n_commands)
2556             fprintf (stderr, " |");
2557           fprintf (stderr, "\n");
2558         }
2559       fflush (stderr);
2560       if (verbose_only_flag != 0)
2561         {
2562           /* verbose_only_flag should act as if the spec was
2563              executed, so increment execution_count before
2564              returning.  This prevents spurious warnings about
2565              unused linker input files, etc.  */
2566           execution_count++;
2567           return 0;
2568         }
2569 #ifdef DEBUG
2570       fnotice (stderr, "\nGo ahead? (y or n) ");
2571       fflush (stderr);
2572       i = getchar ();
2573       if (i != '\n')
2574         while (getchar () != '\n')
2575           ;
2576
2577       if (i != 'y' && i != 'Y')
2578         return 0;
2579 #endif /* DEBUG */
2580     }
2581
2582 #ifdef ENABLE_VALGRIND_CHECKING
2583   /* Run the each command through valgrind.  To simplify prepending the
2584      path to valgrind and the option "-q" (for quiet operation unless
2585      something triggers), we allocate a separate argv array.  */
2586
2587   for (i = 0; i < n_commands; i++)
2588     {
2589       const char **argv;
2590       int argc;
2591       int j;
2592
2593       for (argc = 0; commands[i].argv[argc] != NULL; argc++)
2594         ;
2595
2596       argv = XALLOCAVEC (const char *, argc + 3);
2597
2598       argv[0] = VALGRIND_PATH;
2599       argv[1] = "-q";
2600       for (j = 2; j < argc + 2; j++)
2601         argv[j] = commands[i].argv[j - 2];
2602       argv[j] = NULL;
2603
2604       commands[i].argv = argv;
2605       commands[i].prog = argv[0];
2606     }
2607 #endif
2608
2609   /* Run each piped subprocess.  */
2610
2611   pex = pex_init (PEX_USE_PIPES | ((report_times || report_times_to_file)
2612                                    ? PEX_RECORD_TIMES : 0),
2613                   progname, temp_filename);
2614   if (pex == NULL)
2615     fatal_error ("pex_init failed: %m");
2616
2617   for (i = 0; i < n_commands; i++)
2618     {
2619       const char *errmsg;
2620       int err;
2621       const char *string = commands[i].argv[0];
2622
2623       errmsg = pex_run (pex,
2624                         ((i + 1 == n_commands ? PEX_LAST : 0)
2625                          | (string == commands[i].prog ? PEX_SEARCH : 0)),
2626                         string, CONST_CAST (char **, commands[i].argv),
2627                         NULL, NULL, &err);
2628       if (errmsg != NULL)
2629         {
2630           if (err == 0)
2631             fatal_error (errmsg);
2632           else
2633             {
2634               errno = err;
2635               pfatal_with_name (errmsg);
2636             }
2637         }
2638
2639       if (string != commands[i].prog)
2640         free (CONST_CAST (char *, string));
2641     }
2642
2643   execution_count++;
2644
2645   /* Wait for all the subprocesses to finish.  */
2646
2647   {
2648     int *statuses;
2649     struct pex_time *times = NULL;
2650     int ret_code = 0;
2651
2652     statuses = (int *) alloca (n_commands * sizeof (int));
2653     if (!pex_get_status (pex, n_commands, statuses))
2654       fatal_error ("failed to get exit status: %m");
2655
2656     if (report_times || report_times_to_file)
2657       {
2658         times = (struct pex_time *) alloca (n_commands * sizeof (struct pex_time));
2659         if (!pex_get_times (pex, n_commands, times))
2660           fatal_error ("failed to get process times: %m");
2661       }
2662
2663     pex_free (pex);
2664
2665     for (i = 0; i < n_commands; ++i)
2666       {
2667         int status = statuses[i];
2668
2669         if (WIFSIGNALED (status))
2670           {
2671 #ifdef SIGPIPE
2672             /* SIGPIPE is a special case.  It happens in -pipe mode
2673                when the compiler dies before the preprocessor is done,
2674                or the assembler dies before the compiler is done.
2675                There's generally been an error already, and this is
2676                just fallout.  So don't generate another error unless
2677                we would otherwise have succeeded.  */
2678             if (WTERMSIG (status) == SIGPIPE
2679                 && (signal_count || greatest_status >= MIN_FATAL_STATUS))
2680               {
2681                 signal_count++;
2682                 ret_code = -1;
2683               }
2684             else
2685 #endif
2686               internal_error ("%s (program %s)",
2687                               strsignal (WTERMSIG (status)), commands[i].prog);
2688           }
2689         else if (WIFEXITED (status)
2690                  && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
2691           {
2692             if (WEXITSTATUS (status) > greatest_status)
2693               greatest_status = WEXITSTATUS (status);
2694             ret_code = -1;
2695           }
2696
2697         if (report_times || report_times_to_file)
2698           {
2699             struct pex_time *pt = &times[i];
2700             double ut, st;
2701
2702             ut = ((double) pt->user_seconds
2703                   + (double) pt->user_microseconds / 1.0e6);
2704             st = ((double) pt->system_seconds
2705                   + (double) pt->system_microseconds / 1.0e6);
2706
2707             if (ut + st != 0)
2708               {
2709                 if (report_times)
2710                   fnotice (stderr, "# %s %.2f %.2f\n",
2711                            commands[i].prog, ut, st);
2712
2713                 if (report_times_to_file)
2714                   {
2715                     int c = 0;
2716                     const char *const *j;
2717
2718                     fprintf (report_times_to_file, "%g %g", ut, st);
2719
2720                     for (j = &commands[i].prog; *j; j = &commands[i].argv[++c])
2721                       {
2722                         const char *p;
2723                         for (p = *j; *p; ++p)
2724                           if (*p == '"' || *p == '\\' || *p == '$'
2725                               || ISSPACE (*p))
2726                             break;
2727
2728                         if (*p)
2729                           {
2730                             fprintf (report_times_to_file, " \"");
2731                             for (p = *j; *p; ++p)
2732                               {
2733                                 if (*p == '"' || *p == '\\' || *p == '$')
2734                                   fputc ('\\', report_times_to_file);
2735                                 fputc (*p, report_times_to_file);
2736                               }
2737                             fputc ('"', report_times_to_file);
2738                           }
2739                         else
2740                           fprintf (report_times_to_file, " %s", *j);
2741                       }
2742
2743                     fputc ('\n', report_times_to_file);
2744                   }
2745               }
2746           }
2747       }
2748
2749     return ret_code;
2750   }
2751 }
2752 \f
2753 /* Find all the switches given to us
2754    and make a vector describing them.
2755    The elements of the vector are strings, one per switch given.
2756    If a switch uses following arguments, then the `part1' field
2757    is the switch itself and the `args' field
2758    is a null-terminated vector containing the following arguments.
2759    Bits in the `live_cond' field are:
2760    SWITCH_LIVE to indicate this switch is true in a conditional spec.
2761    SWITCH_FALSE to indicate this switch is overridden by a later switch.
2762    SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
2763    SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored
2764    in all do_spec calls afterwards.  Used for %<S from self specs.
2765    The `validated' field is nonzero if any spec has looked at this switch;
2766    if it remains zero at the end of the run, it must be meaningless.  */
2767
2768 #define SWITCH_LIVE                     0x1
2769 #define SWITCH_FALSE                    0x2
2770 #define SWITCH_IGNORE                   0x4
2771 #define SWITCH_IGNORE_PERMANENTLY       0x8
2772
2773 struct switchstr
2774 {
2775   const char *part1;
2776   const char **args;
2777   unsigned int live_cond;
2778   unsigned char validated;
2779   unsigned char ordering;
2780 };
2781
2782 static struct switchstr *switches;
2783
2784 static int n_switches;
2785
2786 static int n_switches_alloc;
2787
2788 /* Set to zero if -fcompare-debug is disabled, positive if it's
2789    enabled and we're running the first compilation, negative if it's
2790    enabled and we're running the second compilation.  For most of the
2791    time, it's in the range -1..1, but it can be temporarily set to 2
2792    or 3 to indicate that the -fcompare-debug flags didn't come from
2793    the command-line, but rather from the GCC_COMPARE_DEBUG environment
2794    variable, until a synthesized -fcompare-debug flag is added to the
2795    command line.  */
2796 int compare_debug;
2797
2798 /* Set to nonzero if we've seen the -fcompare-debug-second flag.  */
2799 int compare_debug_second;
2800
2801 /* Set to the flags that should be passed to the second compilation in
2802    a -fcompare-debug compilation.  */
2803 const char *compare_debug_opt;
2804
2805 static struct switchstr *switches_debug_check[2];
2806
2807 static int n_switches_debug_check[2];
2808
2809 static int n_switches_alloc_debug_check[2];
2810
2811 static char *debug_check_temp_file[2];
2812
2813 /* Language is one of three things:
2814
2815    1) The name of a real programming language.
2816    2) NULL, indicating that no one has figured out
2817    what it is yet.
2818    3) '*', indicating that the file should be passed
2819    to the linker.  */
2820 struct infile
2821 {
2822   const char *name;
2823   const char *language;
2824   struct compiler *incompiler;
2825   bool compiled;
2826   bool preprocessed;
2827 };
2828
2829 /* Also a vector of input files specified.  */
2830
2831 static struct infile *infiles;
2832
2833 int n_infiles;
2834
2835 static int n_infiles_alloc;
2836
2837 /* True if multiple input files are being compiled to a single
2838    assembly file.  */
2839
2840 static bool combine_inputs;
2841
2842 /* This counts the number of libraries added by lang_specific_driver, so that
2843    we can tell if there were any user supplied any files or libraries.  */
2844
2845 static int added_libraries;
2846
2847 /* And a vector of corresponding output files is made up later.  */
2848
2849 const char **outfiles;
2850 \f
2851 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2852
2853 /* Convert NAME to a new name if it is the standard suffix.  DO_EXE
2854    is true if we should look for an executable suffix.  DO_OBJ
2855    is true if we should look for an object suffix.  */
2856
2857 static const char *
2858 convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
2859                   int do_obj ATTRIBUTE_UNUSED)
2860 {
2861 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2862   int i;
2863 #endif
2864   int len;
2865
2866   if (name == NULL)
2867     return NULL;
2868
2869   len = strlen (name);
2870
2871 #ifdef HAVE_TARGET_OBJECT_SUFFIX
2872   /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj".  */
2873   if (do_obj && len > 2
2874       && name[len - 2] == '.'
2875       && name[len - 1] == 'o')
2876     {
2877       obstack_grow (&obstack, name, len - 2);
2878       obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
2879       name = XOBFINISH (&obstack, const char *);
2880     }
2881 #endif
2882
2883 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2884   /* If there is no filetype, make it the executable suffix (which includes
2885      the ".").  But don't get confused if we have just "-o".  */
2886   if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
2887     return name;
2888
2889   for (i = len - 1; i >= 0; i--)
2890     if (IS_DIR_SEPARATOR (name[i]))
2891       break;
2892
2893   for (i++; i < len; i++)
2894     if (name[i] == '.')
2895       return name;
2896
2897   obstack_grow (&obstack, name, len);
2898   obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
2899                  strlen (TARGET_EXECUTABLE_SUFFIX));
2900   name = XOBFINISH (&obstack, const char *);
2901 #endif
2902
2903   return name;
2904 }
2905 #endif
2906 \f
2907 /* Display the command line switches accepted by gcc.  */
2908 static void
2909 display_help (void)
2910 {
2911   printf (_("Usage: %s [options] file...\n"), progname);
2912   fputs (_("Options:\n"), stdout);
2913
2914   fputs (_("  -pass-exit-codes         Exit with highest error code from a phase\n"), stdout);
2915   fputs (_("  --help                   Display this information\n"), stdout);
2916   fputs (_("  --target-help            Display target specific command line options\n"), stdout);
2917   fputs (_("  --help={target|optimizers|warnings|params|[^]{joined|separate|undocumented}}[,...]\n"), stdout);
2918   fputs (_("                           Display specific types of command line options\n"), stdout);
2919   if (! verbose_flag)
2920     fputs (_("  (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
2921   fputs (_("  --version                Display compiler version information\n"), stdout);
2922   fputs (_("  -dumpspecs               Display all of the built in spec strings\n"), stdout);
2923   fputs (_("  -dumpversion             Display the version of the compiler\n"), stdout);
2924   fputs (_("  -dumpmachine             Display the compiler's target processor\n"), stdout);
2925   fputs (_("  -print-search-dirs       Display the directories in the compiler's search path\n"), stdout);
2926   fputs (_("  -print-libgcc-file-name  Display the name of the compiler's companion library\n"), stdout);
2927   fputs (_("  -print-file-name=<lib>   Display the full path to library <lib>\n"), stdout);
2928   fputs (_("  -print-prog-name=<prog>  Display the full path to compiler component <prog>\n"), stdout);
2929   fputs (_("  -print-multi-directory   Display the root directory for versions of libgcc\n"), stdout);
2930   fputs (_("\
2931   -print-multi-lib         Display the mapping between command line options and\n\
2932                            multiple library search directories\n"), stdout);
2933   fputs (_("  -print-multi-os-directory Display the relative path to OS libraries\n"), stdout);
2934   fputs (_("  -print-sysroot           Display the target libraries directory\n"), stdout);
2935   fputs (_("  -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n"), stdout);
2936   fputs (_("  -Wa,<options>            Pass comma-separated <options> on to the assembler\n"), stdout);
2937   fputs (_("  -Wp,<options>            Pass comma-separated <options> on to the preprocessor\n"), stdout);
2938   fputs (_("  -Wl,<options>            Pass comma-separated <options> on to the linker\n"), stdout);
2939   fputs (_("  -Xassembler <arg>        Pass <arg> on to the assembler\n"), stdout);
2940   fputs (_("  -Xpreprocessor <arg>     Pass <arg> on to the preprocessor\n"), stdout);
2941   fputs (_("  -Xlinker <arg>           Pass <arg> on to the linker\n"), stdout);
2942   fputs (_("  -save-temps              Do not delete intermediate files\n"), stdout);
2943   fputs (_("  -save-temps=<arg>        Do not delete intermediate files\n"), stdout);
2944   fputs (_("\
2945   -no-canonical-prefixes   Do not canonicalize paths when building relative\n\
2946                            prefixes to other gcc components\n"), stdout);
2947   fputs (_("  -pipe                    Use pipes rather than intermediate files\n"), stdout);
2948   fputs (_("  -time                    Time the execution of each subprocess\n"), stdout);
2949   fputs (_("  -specs=<file>            Override built-in specs with the contents of <file>\n"), stdout);
2950   fputs (_("  -std=<standard>          Assume that the input sources are for <standard>\n"), stdout);
2951   fputs (_("\
2952   --sysroot=<directory>    Use <directory> as the root directory for headers\n\
2953                            and libraries\n"), stdout);
2954   fputs (_("  -B <directory>           Add <directory> to the compiler's search paths\n"), stdout);
2955   fputs (_("  -v                       Display the programs invoked by the compiler\n"), stdout);
2956   fputs (_("  -###                     Like -v but options quoted and commands not executed\n"), stdout);
2957   fputs (_("  -E                       Preprocess only; do not compile, assemble or link\n"), stdout);
2958   fputs (_("  -S                       Compile only; do not assemble or link\n"), stdout);
2959   fputs (_("  -c                       Compile and assemble, but do not link\n"), stdout);
2960   fputs (_("  -o <file>                Place the output into <file>\n"), stdout);
2961   fputs (_("\
2962   -x <language>            Specify the language of the following input files\n\
2963                            Permissible languages include: c c++ assembler none\n\
2964                            'none' means revert to the default behavior of\n\
2965                            guessing the language based on the file's extension\n\
2966 "), stdout);
2967
2968   printf (_("\
2969 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
2970  passed on to the various sub-processes invoked by %s.  In order to pass\n\
2971  other options on to these processes the -W<letter> options must be used.\n\
2972 "), progname);
2973
2974   /* The rest of the options are displayed by invocations of the various
2975      sub-processes.  */
2976 }
2977
2978 static void
2979 add_preprocessor_option (const char *option, int len)
2980 {
2981   n_preprocessor_options++;
2982
2983   if (! preprocessor_options)
2984     preprocessor_options = XNEWVEC (char *, n_preprocessor_options);
2985   else
2986     preprocessor_options = XRESIZEVEC (char *, preprocessor_options,
2987                                        n_preprocessor_options);
2988
2989   preprocessor_options [n_preprocessor_options - 1] =
2990     save_string (option, len);
2991 }
2992
2993 static void
2994 add_assembler_option (const char *option, int len)
2995 {
2996   n_assembler_options++;
2997
2998   if (! assembler_options)
2999     assembler_options = XNEWVEC (char *, n_assembler_options);
3000   else
3001     assembler_options = XRESIZEVEC (char *, assembler_options,
3002                                     n_assembler_options);
3003
3004   assembler_options [n_assembler_options - 1] = save_string (option, len);
3005 }
3006
3007 static void
3008 add_linker_option (const char *option, int len)
3009 {
3010   n_linker_options++;
3011
3012   if (! linker_options)
3013     linker_options = XNEWVEC (char *, n_linker_options);
3014   else
3015     linker_options = XRESIZEVEC (char *, linker_options, n_linker_options);
3016
3017   linker_options [n_linker_options - 1] = save_string (option, len);
3018 }
3019 \f
3020 /* Allocate space for an input file in infiles.  */
3021
3022 static void
3023 alloc_infile (void)
3024 {
3025   if (n_infiles_alloc == 0)
3026     {
3027       n_infiles_alloc = 16;
3028       infiles = XNEWVEC (struct infile, n_infiles_alloc);
3029     }
3030   else if (n_infiles_alloc == n_infiles)
3031     {
3032       n_infiles_alloc *= 2;
3033       infiles = XRESIZEVEC (struct infile, infiles, n_infiles_alloc);
3034     }
3035 }
3036
3037 /* Store an input file with the given NAME and LANGUAGE in
3038    infiles.  */
3039
3040 static void
3041 add_infile (const char *name, const char *language)
3042 {
3043   alloc_infile ();
3044   infiles[n_infiles].name = name;
3045   infiles[n_infiles++].language = language;
3046 }
3047
3048 /* Allocate space for a switch in switches.  */
3049
3050 static void
3051 alloc_switch (void)
3052 {
3053   if (n_switches_alloc == 0)
3054     {
3055       n_switches_alloc = 16;
3056       switches = XNEWVEC (struct switchstr, n_switches_alloc);
3057     }
3058   else if (n_switches_alloc == n_switches)
3059     {
3060       n_switches_alloc *= 2;
3061       switches = XRESIZEVEC (struct switchstr, switches, n_switches_alloc);
3062     }
3063 }
3064
3065 /* Save an option OPT with N_ARGS arguments in array ARGS, marking it
3066    as validated if VALIDATED.  */
3067
3068 static void
3069 save_switch (const char *opt, size_t n_args, const char *const *args,
3070              bool validated)
3071 {
3072   alloc_switch ();
3073   switches[n_switches].part1 = opt + 1;
3074   if (n_args == 0)
3075     switches[n_switches].args = 0;
3076   else
3077     {
3078       switches[n_switches].args = XNEWVEC (const char *, n_args + 1);
3079       memcpy (switches[n_switches].args, args, n_args * sizeof (const char *));
3080       switches[n_switches].args[n_args] = NULL;
3081     }
3082
3083   switches[n_switches].live_cond = 0;
3084   switches[n_switches].validated = validated;
3085   switches[n_switches].ordering = 0;
3086   n_switches++;
3087 }
3088
3089 /* Handle an option DECODED that is unknown to the option-processing
3090    machinery, but may be known to specs.  */
3091
3092 static bool
3093 driver_unknown_option_callback (const struct cl_decoded_option *decoded)
3094 {
3095   save_switch (decoded->canonical_option[0],
3096                decoded->canonical_option_num_elements - 1,
3097                &decoded->canonical_option[1], false);
3098
3099   return false;
3100 }
3101
3102 /* Handle an option DECODED that is not marked as CL_DRIVER.
3103    LANG_MASK will always be CL_DRIVER.  */
3104
3105 static void
3106 driver_wrong_lang_callback (const struct cl_decoded_option *decoded,
3107                             unsigned int lang_mask ATTRIBUTE_UNUSED)
3108 {
3109   /* At this point, non-driver options are accepted (and expected to
3110      be passed down by specs) unless marked to be rejected by the
3111      driver.  Options to be rejected by the driver but accepted by the
3112      compilers proper are treated just like completely unknown
3113      options.  */
3114   const struct cl_option *option = &cl_options[decoded->opt_index];
3115
3116   if (option->flags & CL_REJECT_DRIVER)
3117     error ("unrecognized command line option %qs",
3118            decoded->orig_option_with_args_text);
3119   else
3120     driver_unknown_option_callback (decoded);
3121 }
3122
3123 /* Note that an option (index OPT_INDEX, argument ARG, value VALUE)
3124    has been successfully handled with a handler for mask MASK.  */
3125
3126 static void
3127 driver_post_handling_callback (const struct cl_decoded_option *decoded ATTRIBUTE_UNUSED,
3128                                unsigned int mask ATTRIBUTE_UNUSED)
3129 {
3130   /* Nothing to do here.  */
3131 }
3132
3133 static const char *spec_lang = 0;
3134 static int last_language_n_infiles;
3135
3136 /* Handle a driver option; arguments and return value as for
3137    handle_option.  */
3138
3139 static bool
3140 driver_handle_option (struct gcc_options *opts,
3141                       struct gcc_options *opts_set,
3142                       const struct cl_decoded_option *decoded,
3143                       unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
3144                       location_t loc,
3145                       const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED,
3146                       diagnostic_context *dc)
3147 {
3148   size_t opt_index = decoded->opt_index;
3149   const char *arg = decoded->arg;
3150   const char *compare_debug_replacement_opt;
3151   int value = decoded->value;
3152   bool validated = false;
3153   bool do_save = true;
3154
3155   gcc_assert (opts == &global_options);
3156   gcc_assert (opts_set == &global_options_set);
3157   gcc_assert (kind == DK_UNSPECIFIED);
3158   gcc_assert (loc == UNKNOWN_LOCATION);
3159   gcc_assert (dc == global_dc);
3160
3161   switch (opt_index)
3162     {
3163     case OPT_dumpspecs:
3164       {
3165         struct spec_list *sl;
3166         init_spec ();
3167         for (sl = specs; sl; sl = sl->next)
3168           printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3169         if (link_command_spec)
3170           printf ("*link_command:\n%s\n\n", link_command_spec);
3171         exit (0);
3172       }
3173
3174     case OPT_dumpversion:
3175       printf ("%s\n", spec_version);
3176       exit (0);
3177
3178     case OPT_dumpmachine:
3179       printf ("%s\n", spec_machine);
3180       exit (0);
3181
3182     case OPT__version:
3183       print_version = 1;
3184
3185       /* CPP driver cannot obtain switch from cc1_options.  */
3186       if (is_cpp_driver)
3187         add_preprocessor_option ("--version", strlen ("--version"));
3188       add_assembler_option ("--version", strlen ("--version"));
3189       add_linker_option ("--version", strlen ("--version"));
3190       break;
3191
3192     case OPT__help:
3193       print_help_list = 1;
3194
3195       /* CPP driver cannot obtain switch from cc1_options.  */
3196       if (is_cpp_driver)
3197         add_preprocessor_option ("--help", 6);
3198       add_assembler_option ("--help", 6);
3199       add_linker_option ("--help", 6);
3200       break;
3201
3202     case OPT__help_:
3203       print_subprocess_help = 2;
3204       break;
3205
3206     case OPT__target_help:
3207       print_subprocess_help = 1;
3208
3209       /* CPP driver cannot obtain switch from cc1_options.  */
3210       if (is_cpp_driver)
3211         add_preprocessor_option ("--target-help", 13);
3212       add_assembler_option ("--target-help", 13);
3213       add_linker_option ("--target-help", 13);
3214       break;
3215
3216     case OPT_pass_exit_codes:
3217     case OPT_print_search_dirs:
3218     case OPT_print_file_name_:
3219     case OPT_print_prog_name_:
3220     case OPT_print_multi_lib:
3221     case OPT_print_multi_directory:
3222     case OPT_print_sysroot:
3223     case OPT_print_multi_os_directory:
3224     case OPT_print_sysroot_headers_suffix:
3225     case OPT_time:
3226     case OPT_wrapper:
3227       /* These options set the variables specified in common.opt
3228          automatically, and do not need to be saved for spec
3229          processing.  */
3230       do_save = false;
3231       break;
3232
3233     case OPT_print_libgcc_file_name:
3234       print_file_name = "libgcc.a";
3235       do_save = false;
3236       break;
3237
3238     case OPT_fcompare_debug_second:
3239       compare_debug_second = 1;
3240       break;
3241
3242     case OPT_fcompare_debug:
3243       switch (value)
3244         {
3245         case 0:
3246           compare_debug_replacement_opt = "-fcompare-debug=";
3247           arg = "";
3248           goto compare_debug_with_arg;
3249
3250         case 1:
3251           compare_debug_replacement_opt = "-fcompare-debug=-gtoggle";
3252           arg = "-gtoggle";
3253           goto compare_debug_with_arg;
3254
3255         default:
3256           gcc_unreachable ();
3257         }
3258       break;
3259
3260     case OPT_fcompare_debug_:
3261       compare_debug_replacement_opt = decoded->canonical_option[0];
3262     compare_debug_with_arg:
3263       gcc_assert (decoded->canonical_option_num_elements == 1);
3264       gcc_assert (arg != NULL);
3265       if (arg)
3266         compare_debug = 1;
3267       else
3268         compare_debug = -1;
3269       if (compare_debug < 0)
3270         compare_debug_opt = NULL;
3271       else
3272         compare_debug_opt = arg;
3273       save_switch (compare_debug_replacement_opt, 0, NULL, validated);
3274       return true;
3275
3276     case OPT_Wa_:
3277       {
3278         int prev, j;
3279         /* Pass the rest of this option to the assembler.  */
3280
3281         /* Split the argument at commas.  */
3282         prev = 0;
3283         for (j = 0; arg[j]; j++)
3284           if (arg[j] == ',')
3285             {
3286               add_assembler_option (arg + prev, j - prev);
3287               prev = j + 1;
3288             }
3289
3290         /* Record the part after the last comma.  */
3291         add_assembler_option (arg + prev, j - prev);
3292       }
3293       do_save = false;
3294       break;
3295
3296     case OPT_Wp_:
3297       {
3298         int prev, j;
3299         /* Pass the rest of this option to the preprocessor.  */
3300
3301         /* Split the argument at commas.  */
3302         prev = 0;
3303         for (j = 0; arg[j]; j++)
3304           if (arg[j] == ',')
3305             {
3306               add_preprocessor_option (arg + prev, j - prev);
3307               prev = j + 1;
3308             }
3309
3310         /* Record the part after the last comma.  */
3311         add_preprocessor_option (arg + prev, j - prev);
3312       }
3313       do_save = false;
3314       break;
3315
3316     case OPT_Wl_:
3317       {
3318         int prev, j;
3319         /* Split the argument at commas.  */
3320         prev = 0;
3321         for (j = 0; arg[j]; j++)
3322           if (arg[j] == ',')
3323             {
3324               add_infile (save_string (arg + prev, j - prev), "*");
3325               prev = j + 1;
3326             }
3327         /* Record the part after the last comma.  */
3328         add_infile (arg + prev, "*");
3329       }
3330       do_save = false;
3331       break;
3332
3333     case OPT_Xlinker:
3334       add_infile (arg, "*");
3335       do_save = false;
3336       break;
3337
3338     case OPT_Xpreprocessor:
3339       add_preprocessor_option (arg, strlen (arg));
3340       do_save = false;
3341       break;
3342
3343     case OPT_Xassembler:
3344       add_assembler_option (arg, strlen (arg));
3345       do_save = false;
3346       break;
3347
3348     case OPT_l:
3349       /* POSIX allows separation of -l and the lib arg; canonicalize
3350          by concatenating -l with its arg */
3351       add_infile (concat ("-l", arg, NULL), "*");
3352       do_save = false;
3353       break;
3354
3355     case OPT_L:
3356       /* Similarly, canonicalize -L for linkers that may not accept
3357          separate arguments.  */
3358       save_switch (concat ("-L", arg, NULL), 0, NULL, validated);
3359       return true;
3360
3361     case OPT_save_temps:
3362       save_temps_flag = SAVE_TEMPS_CWD;
3363       validated = true;
3364       break;
3365
3366     case OPT_save_temps_:
3367       if (strcmp (arg, "cwd") == 0)
3368         save_temps_flag = SAVE_TEMPS_CWD;
3369       else if (strcmp (arg, "obj") == 0
3370                || strcmp (arg, "object") == 0)
3371         save_temps_flag = SAVE_TEMPS_OBJ;
3372       else
3373         fatal_error ("%qs is an unknown -save-temps option",
3374                      decoded->orig_option_with_args_text);
3375       break;
3376
3377     case OPT_no_canonical_prefixes:
3378       /* Already handled as a special case, so ignored here.  */
3379       do_save = false;
3380       break;
3381
3382     case OPT_pipe:
3383       validated = true;
3384       /* These options set the variables specified in common.opt
3385          automatically, but do need to be saved for spec
3386          processing.  */
3387       break;
3388
3389     case OPT_specs_:
3390       {
3391         struct user_specs *user = XNEW (struct user_specs);
3392
3393         user->next = (struct user_specs *) 0;
3394         user->filename = arg;
3395         if (user_specs_tail)
3396           user_specs_tail->next = user;
3397         else
3398           user_specs_head = user;
3399         user_specs_tail = user;
3400       }
3401       do_save = false;
3402       break;
3403
3404     case OPT__sysroot_:
3405       target_system_root = arg;
3406       target_system_root_changed = 1;
3407       do_save = false;
3408       break;
3409
3410     case OPT_time_:
3411       if (report_times_to_file)
3412         fclose (report_times_to_file);
3413       report_times_to_file = fopen (arg, "a");
3414       do_save = false;
3415       break;
3416
3417     case OPT____:
3418       /* "-###"
3419          This is similar to -v except that there is no execution
3420          of the commands and the echoed arguments are quoted.  It
3421          is intended for use in shell scripts to capture the
3422          driver-generated command line.  */
3423       verbose_only_flag++;
3424       verbose_flag = 1;
3425       do_save = false;
3426       break;
3427
3428     case OPT_B:
3429       {
3430         size_t len = strlen (arg);
3431
3432         /* Catch the case where the user has forgotten to append a
3433            directory separator to the path.  Note, they may be using
3434            -B to add an executable name prefix, eg "i386-elf-", in
3435            order to distinguish between multiple installations of
3436            GCC in the same directory.  Hence we must check to see
3437            if appending a directory separator actually makes a
3438            valid directory name.  */
3439         if (!IS_DIR_SEPARATOR (arg[len - 1])
3440             && is_directory (arg, false))
3441           {
3442             char *tmp = XNEWVEC (char, len + 2);
3443             strcpy (tmp, arg);
3444             tmp[len] = DIR_SEPARATOR;
3445             tmp[++len] = 0;
3446             arg = tmp;
3447           }
3448
3449         add_prefix (&exec_prefixes, arg, NULL,
3450                     PREFIX_PRIORITY_B_OPT, 0, 0);
3451         add_prefix (&startfile_prefixes, arg, NULL,
3452                     PREFIX_PRIORITY_B_OPT, 0, 0);
3453         add_prefix (&include_prefixes, arg, NULL,
3454                     PREFIX_PRIORITY_B_OPT, 0, 0);
3455       }
3456       validated = true;
3457       break;
3458
3459     case OPT_x:
3460       spec_lang = arg;
3461       if (!strcmp (spec_lang, "none"))
3462         /* Suppress the warning if -xnone comes after the last input
3463            file, because alternate command interfaces like g++ might
3464            find it useful to place -xnone after each input file.  */
3465         spec_lang = 0;
3466       else
3467         last_language_n_infiles = n_infiles;
3468       do_save = false;
3469       break;
3470
3471     case OPT_o:
3472       have_o = 1;
3473 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3474       arg = convert_filename (arg, ! have_c, 0);
3475 #endif
3476       /* Save the output name in case -save-temps=obj was used.  */
3477       save_temps_prefix = xstrdup (arg);
3478       /* On some systems, ld cannot handle "-o" without a space.  So
3479          split the option from its argument.  */
3480       save_switch ("-o", 1, &arg, validated);
3481       return true;
3482
3483     case OPT_static_libgcc:
3484     case OPT_shared_libgcc:
3485     case OPT_static_libgfortran:
3486     case OPT_static_libstdc__:
3487       /* These are always valid, since gcc.c itself understands the
3488          first two, gfortranspec.c understands -static-libgfortran and
3489          g++spec.c understands -static-libstdc++ */
3490       validated = true;
3491       break;
3492
3493     default:
3494       /* Various driver options need no special processing at this
3495          point, having been handled in a prescan above or being
3496          handled by specs.  */
3497       break;
3498     }
3499
3500   if (do_save)
3501     save_switch (decoded->canonical_option[0],
3502                  decoded->canonical_option_num_elements - 1,
3503                  &decoded->canonical_option[1], validated);
3504   return true;
3505 }
3506
3507 /* Put the driver's standard set of option handlers in *HANDLERS.  */
3508
3509 static void
3510 set_option_handlers (struct cl_option_handlers *handlers)
3511 {
3512   handlers->unknown_option_callback = driver_unknown_option_callback;
3513   handlers->wrong_lang_callback = driver_wrong_lang_callback;
3514   handlers->post_handling_callback = driver_post_handling_callback;
3515   handlers->num_handlers = 1;
3516   handlers->handlers[0].handler = driver_handle_option;
3517   handlers->handlers[0].mask = CL_DRIVER;
3518 }
3519
3520 /* Create the vector `switches' and its contents.
3521    Store its length in `n_switches'.  */
3522
3523 static void
3524 process_command (unsigned int decoded_options_count,
3525                  struct cl_decoded_option *decoded_options)
3526 {
3527   const char *temp;
3528   char *temp1;
3529   const char *tooldir_prefix;
3530   char *(*get_relative_prefix) (const char *, const char *,
3531                                 const char *) = NULL;
3532   struct cl_option_handlers handlers;
3533   unsigned int j;
3534
3535   GET_ENVIRONMENT (gcc_exec_prefix, "GCC_EXEC_PREFIX");
3536
3537   n_switches = 0;
3538   n_infiles = 0;
3539   added_libraries = 0;
3540
3541   /* Figure compiler version from version string.  */
3542
3543   compiler_version = temp1 = xstrdup (version_string);
3544
3545   for (; *temp1; ++temp1)
3546     {
3547       if (*temp1 == ' ')
3548         {
3549           *temp1 = '\0';
3550           break;
3551         }
3552     }
3553
3554   /* Handle any -no-canonical-prefixes flag early, to assign the function
3555      that builds relative prefixes.  This function creates default search
3556      paths that are needed later in normal option handling.  */
3557
3558   for (j = 1; j < decoded_options_count; j++)
3559     {
3560       if (decoded_options[j].opt_index == OPT_no_canonical_prefixes)
3561         {
3562           get_relative_prefix = make_relative_prefix_ignore_links;
3563           break;
3564         }
3565     }
3566   if (! get_relative_prefix)
3567     get_relative_prefix = make_relative_prefix;
3568
3569   /* Set up the default search paths.  If there is no GCC_EXEC_PREFIX,
3570      see if we can create it from the pathname specified in
3571      decoded_options[0].arg.  */
3572
3573   gcc_libexec_prefix = standard_libexec_prefix;
3574 #ifndef VMS
3575   /* FIXME: make_relative_prefix doesn't yet work for VMS.  */
3576   if (!gcc_exec_prefix)
3577     {
3578       gcc_exec_prefix = get_relative_prefix (decoded_options[0].arg,
3579                                              standard_bindir_prefix,
3580                                              standard_exec_prefix);
3581       gcc_libexec_prefix = get_relative_prefix (decoded_options[0].arg,
3582                                              standard_bindir_prefix,
3583                                              standard_libexec_prefix);
3584       if (gcc_exec_prefix)
3585         xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
3586     }
3587   else
3588     {
3589       /* make_relative_prefix requires a program name, but
3590          GCC_EXEC_PREFIX is typically a directory name with a trailing
3591          / (which is ignored by make_relative_prefix), so append a
3592          program name.  */
3593       char *tmp_prefix = concat (gcc_exec_prefix, "gcc", NULL);
3594       gcc_libexec_prefix = get_relative_prefix (tmp_prefix,
3595                                                 standard_exec_prefix,
3596                                                 standard_libexec_prefix);
3597
3598       /* The path is unrelocated, so fallback to the original setting.  */
3599       if (!gcc_libexec_prefix)
3600         gcc_libexec_prefix = standard_libexec_prefix;
3601
3602       free (tmp_prefix);
3603     }
3604 #else
3605 #endif
3606   /* From this point onward, gcc_exec_prefix is non-null if the toolchain
3607      is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
3608      or an automatically created GCC_EXEC_PREFIX from
3609      decoded_options[0].arg.  */
3610
3611   /* Do language-specific adjustment/addition of flags.  */
3612   lang_specific_driver (&decoded_options, &decoded_options_count,
3613                         &added_libraries);
3614
3615   if (gcc_exec_prefix)
3616     {
3617       int len = strlen (gcc_exec_prefix);
3618
3619       if (len > (int) sizeof ("/lib/gcc/") - 1
3620           && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
3621         {
3622           temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1;
3623           if (IS_DIR_SEPARATOR (*temp)
3624               && strncmp (temp + 1, "lib", 3) == 0
3625               && IS_DIR_SEPARATOR (temp[4])
3626               && strncmp (temp + 5, "gcc", 3) == 0)
3627             len -= sizeof ("/lib/gcc/") - 1;
3628         }
3629
3630       set_std_prefix (gcc_exec_prefix, len);
3631       add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC",
3632                   PREFIX_PRIORITY_LAST, 0, 0);
3633       add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
3634                   PREFIX_PRIORITY_LAST, 0, 0);
3635     }
3636
3637   /* COMPILER_PATH and LIBRARY_PATH have values
3638      that are lists of directory names with colons.  */
3639
3640   GET_ENVIRONMENT (temp, "COMPILER_PATH");
3641   if (temp)
3642     {
3643       const char *startp, *endp;
3644       char *nstore = (char *) alloca (strlen (temp) + 3);
3645
3646       startp = endp = temp;
3647       while (1)
3648         {
3649           if (*endp == PATH_SEPARATOR || *endp == 0)
3650             {
3651               strncpy (nstore, startp, endp - startp);
3652               if (endp == startp)
3653                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3654               else if (!IS_DIR_SEPARATOR (endp[-1]))
3655                 {
3656                   nstore[endp - startp] = DIR_SEPARATOR;
3657                   nstore[endp - startp + 1] = 0;
3658                 }
3659               else
3660                 nstore[endp - startp] = 0;
3661               add_prefix (&exec_prefixes, nstore, 0,
3662                           PREFIX_PRIORITY_LAST, 0, 0);
3663               add_prefix (&include_prefixes, nstore, 0,
3664                           PREFIX_PRIORITY_LAST, 0, 0);
3665               if (*endp == 0)
3666                 break;
3667               endp = startp = endp + 1;
3668             }
3669           else
3670             endp++;
3671         }
3672     }
3673
3674   GET_ENVIRONMENT (temp, LIBRARY_PATH_ENV);
3675   if (temp && *cross_compile == '0')
3676     {
3677       const char *startp, *endp;
3678       char *nstore = (char *) alloca (strlen (temp) + 3);
3679
3680       startp = endp = temp;
3681       while (1)
3682         {
3683           if (*endp == PATH_SEPARATOR || *endp == 0)
3684             {
3685               strncpy (nstore, startp, endp - startp);
3686               if (endp == startp)
3687                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3688               else if (!IS_DIR_SEPARATOR (endp[-1]))
3689                 {
3690                   nstore[endp - startp] = DIR_SEPARATOR;
3691                   nstore[endp - startp + 1] = 0;
3692                 }
3693               else
3694                 nstore[endp - startp] = 0;
3695               add_prefix (&startfile_prefixes, nstore, NULL,
3696                           PREFIX_PRIORITY_LAST, 0, 1);
3697               if (*endp == 0)
3698                 break;
3699               endp = startp = endp + 1;
3700             }
3701           else
3702             endp++;
3703         }
3704     }
3705
3706   /* Use LPATH like LIBRARY_PATH (for the CMU build program).  */
3707   GET_ENVIRONMENT (temp, "LPATH");
3708   if (temp && *cross_compile == '0')
3709     {
3710       const char *startp, *endp;
3711       char *nstore = (char *) alloca (strlen (temp) + 3);
3712
3713       startp = endp = temp;
3714       while (1)
3715         {
3716           if (*endp == PATH_SEPARATOR || *endp == 0)
3717             {
3718               strncpy (nstore, startp, endp - startp);
3719               if (endp == startp)
3720                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3721               else if (!IS_DIR_SEPARATOR (endp[-1]))
3722                 {
3723                   nstore[endp - startp] = DIR_SEPARATOR;
3724                   nstore[endp - startp + 1] = 0;
3725                 }
3726               else
3727                 nstore[endp - startp] = 0;
3728               add_prefix (&startfile_prefixes, nstore, NULL,
3729                           PREFIX_PRIORITY_LAST, 0, 1);
3730               if (*endp == 0)
3731                 break;
3732               endp = startp = endp + 1;
3733             }
3734           else
3735             endp++;
3736         }
3737     }
3738
3739   /* Process the options and store input files and switches in their
3740      vectors.  */
3741
3742   last_language_n_infiles = -1;
3743
3744   set_option_handlers (&handlers);
3745
3746   for (j = 1; j < decoded_options_count; j++)
3747     {
3748       switch (decoded_options[j].opt_index)
3749         {
3750         case OPT_S:
3751         case OPT_c:
3752         case OPT_E:
3753           have_c = 1;
3754           break;
3755         }
3756       if (have_c)
3757         break;
3758     }
3759
3760   for (j = 1; j < decoded_options_count; j++)
3761     {
3762       if (decoded_options[j].opt_index == OPT_SPECIAL_input_file)
3763         {
3764           const char *arg = decoded_options[j].arg;
3765           const char *p = strrchr (arg, '@');
3766           char *fname;
3767           long offset;
3768           int consumed;
3769 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3770           arg = convert_filename (arg, 0, access (arg, F_OK));
3771 #endif
3772           /* For LTO static archive support we handle input file
3773              specifications that are composed of a filename and
3774              an offset like FNAME@OFFSET.  */
3775           if (p
3776               && p != arg
3777               && sscanf (p, "@%li%n", &offset, &consumed) >= 1
3778               && strlen (p) == (unsigned int)consumed)
3779             {
3780               fname = (char *)xmalloc (p - arg + 1);
3781               memcpy (fname, arg, p - arg);
3782               fname[p - arg] = '\0';
3783               /* Only accept non-stdin and existing FNAME parts, otherwise
3784                  try with the full name.  */
3785               if (strcmp (fname, "-") == 0 || access (fname, F_OK) < 0)
3786                 {
3787                   free (fname);
3788                   fname = xstrdup (arg);
3789                 }
3790             }
3791           else
3792             fname = xstrdup (arg);
3793
3794           if (strcmp (fname, "-") != 0 && access (fname, F_OK) < 0)
3795             perror_with_name (fname);
3796           else
3797             add_infile (arg, spec_lang);
3798
3799           free (fname);
3800           continue;
3801         }
3802
3803       read_cmdline_option (&global_options, &global_options_set,
3804                            decoded_options + j, UNKNOWN_LOCATION,
3805                            CL_DRIVER, &handlers, global_dc);
3806     }
3807
3808   /* If -save-temps=obj and -o name, create the prefix to use for %b.
3809      Otherwise just make -save-temps=obj the same as -save-temps=cwd.  */
3810   if (save_temps_flag == SAVE_TEMPS_OBJ && save_temps_prefix != NULL)
3811     {
3812       save_temps_length = strlen (save_temps_prefix);
3813       temp = strrchr (lbasename (save_temps_prefix), '.');
3814       if (temp)
3815         {
3816           save_temps_length -= strlen (temp);
3817           save_temps_prefix[save_temps_length] = '\0';
3818         }
3819
3820     }
3821   else if (save_temps_prefix != NULL)
3822     {
3823       free (save_temps_prefix);
3824       save_temps_prefix = NULL;
3825     }
3826
3827   if (save_temps_flag && use_pipes)
3828     {
3829       /* -save-temps overrides -pipe, so that temp files are produced */
3830       if (save_temps_flag)
3831         warning (0, "-pipe ignored because -save-temps specified");
3832       use_pipes = 0;
3833     }
3834
3835   if (!compare_debug)
3836     {
3837       const char *gcd = getenv ("GCC_COMPARE_DEBUG");
3838
3839       if (gcd && gcd[0] == '-')
3840         {
3841           compare_debug = 2;
3842           compare_debug_opt = gcd;
3843         }
3844       else if (gcd && *gcd && strcmp (gcd, "0"))
3845         {
3846           compare_debug = 3;
3847           compare_debug_opt = "-gtoggle";
3848         }
3849     }
3850   else if (compare_debug < 0)
3851     {
3852       compare_debug = 0;
3853       gcc_assert (!compare_debug_opt);
3854     }
3855
3856   /* Set up the search paths.  We add directories that we expect to
3857      contain GNU Toolchain components before directories specified by
3858      the machine description so that we will find GNU components (like
3859      the GNU assembler) before those of the host system.  */
3860
3861   /* If we don't know where the toolchain has been installed, use the
3862      configured-in locations.  */
3863   if (!gcc_exec_prefix)
3864     {
3865 #ifndef OS2
3866       add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC",
3867                   PREFIX_PRIORITY_LAST, 1, 0);
3868       add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS",
3869                   PREFIX_PRIORITY_LAST, 2, 0);
3870       add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
3871                   PREFIX_PRIORITY_LAST, 2, 0);
3872 #endif
3873       add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
3874                   PREFIX_PRIORITY_LAST, 1, 0);
3875     }
3876
3877   gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix));
3878   tooldir_prefix = concat (tooldir_base_prefix, spec_machine,
3879                            dir_separator_str, NULL);
3880
3881   /* Look for tools relative to the location from which the driver is
3882      running, or, if that is not available, the configured prefix.  */
3883   tooldir_prefix
3884     = concat (gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
3885               spec_machine, dir_separator_str,
3886               spec_version, dir_separator_str, tooldir_prefix, NULL);
3887
3888   add_prefix (&exec_prefixes,
3889               concat (tooldir_prefix, "bin", dir_separator_str, NULL),
3890               "BINUTILS", PREFIX_PRIORITY_LAST, 0, 0);
3891   add_prefix (&startfile_prefixes,
3892               concat (tooldir_prefix, "lib", dir_separator_str, NULL),
3893               "BINUTILS", PREFIX_PRIORITY_LAST, 0, 1);
3894
3895 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
3896   /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
3897      then consider it to relocate with the rest of the GCC installation
3898      if GCC_EXEC_PREFIX is set.
3899      ``make_relative_prefix'' is not compiled for VMS, so don't call it.  */
3900   if (target_system_root && !target_system_root_changed && gcc_exec_prefix)
3901     {
3902       char *tmp_prefix = get_relative_prefix (decoded_options[0].arg,
3903                                               standard_bindir_prefix,
3904                                               target_system_root);
3905       if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0)
3906         {
3907           target_system_root = tmp_prefix;
3908           target_system_root_changed = 1;
3909         }
3910     }
3911 #endif
3912
3913   /* More prefixes are enabled in main, after we read the specs file
3914      and determine whether this is cross-compilation or not.  */
3915
3916   if (n_infiles == last_language_n_infiles && spec_lang != 0)
3917     warning (0, "%<-x %s%> after last input file has no effect", spec_lang);
3918
3919   if (compare_debug == 2 || compare_debug == 3)
3920     {
3921       alloc_switch ();
3922       switches[n_switches].part1 = concat ("fcompare-debug=",
3923                                            compare_debug_opt,
3924                                            NULL);
3925       switches[n_switches].args = 0;
3926       switches[n_switches].live_cond = 0;
3927       switches[n_switches].validated = 0;
3928       switches[n_switches].ordering = 0;
3929       n_switches++;
3930       compare_debug = 1;
3931     }
3932
3933   /* Ensure we only invoke each subprocess once.  */
3934   if (print_subprocess_help || print_help_list || print_version)
3935     {
3936       n_infiles = 0;
3937
3938       /* Create a dummy input file, so that we can pass
3939          the help option on to the various sub-processes.  */
3940       add_infile ("help-dummy", "c");
3941     }
3942
3943   alloc_switch ();
3944   switches[n_switches].part1 = 0;
3945   alloc_infile ();
3946   infiles[n_infiles].name = 0;
3947 }
3948
3949 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
3950    and place that in the environment.  */
3951
3952 static void
3953 set_collect_gcc_options (void)
3954 {
3955   int i;
3956   int first_time;
3957
3958   /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
3959      the compiler.  */
3960   obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
3961                 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
3962
3963   first_time = TRUE;
3964   for (i = 0; (int) i < n_switches; i++)
3965     {
3966       const char *const *args;
3967       const char *p, *q;
3968       if (!first_time)
3969         obstack_grow (&collect_obstack, " ", 1);
3970
3971       first_time = FALSE;
3972
3973       /* Ignore elided switches.  */
3974       if ((switches[i].live_cond & SWITCH_IGNORE) != 0)
3975         continue;
3976
3977       obstack_grow (&collect_obstack, "'-", 2);
3978       q = switches[i].part1;
3979       while ((p = strchr (q, '\'')))
3980         {
3981           obstack_grow (&collect_obstack, q, p - q);
3982           obstack_grow (&collect_obstack, "'\\''", 4);
3983           q = ++p;
3984         }
3985       obstack_grow (&collect_obstack, q, strlen (q));
3986       obstack_grow (&collect_obstack, "'", 1);
3987
3988       for (args = switches[i].args; args && *args; args++)
3989         {
3990           obstack_grow (&collect_obstack, " '", 2);
3991           q = *args;
3992           while ((p = strchr (q, '\'')))
3993             {
3994               obstack_grow (&collect_obstack, q, p - q);
3995               obstack_grow (&collect_obstack, "'\\''", 4);
3996               q = ++p;
3997             }
3998           obstack_grow (&collect_obstack, q, strlen (q));
3999           obstack_grow (&collect_obstack, "'", 1);
4000         }
4001     }
4002   obstack_grow (&collect_obstack, "\0", 1);
4003   xputenv (XOBFINISH (&collect_obstack, char *));
4004 }
4005 \f
4006 /* Process a spec string, accumulating and running commands.  */
4007
4008 /* These variables describe the input file name.
4009    input_file_number is the index on outfiles of this file,
4010    so that the output file name can be stored for later use by %o.
4011    input_basename is the start of the part of the input file
4012    sans all directory names, and basename_length is the number
4013    of characters starting there excluding the suffix .c or whatever.  */
4014
4015 static const char *gcc_input_filename;
4016 static int input_file_number;
4017 size_t input_filename_length;
4018 static int basename_length;
4019 static int suffixed_basename_length;
4020 static const char *input_basename;
4021 static const char *input_suffix;
4022 #ifndef HOST_LACKS_INODE_NUMBERS
4023 static struct stat input_stat;
4024 #endif
4025 static int input_stat_set;
4026
4027 /* The compiler used to process the current input file.  */
4028 static struct compiler *input_file_compiler;
4029
4030 /* These are variables used within do_spec and do_spec_1.  */
4031
4032 /* Nonzero if an arg has been started and not yet terminated
4033    (with space, tab or newline).  */
4034 static int arg_going;
4035
4036 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4037    is a temporary file name.  */
4038 static int delete_this_arg;
4039
4040 /* Nonzero means %w has been seen; the next arg to be terminated
4041    is the output file name of this compilation.  */
4042 static int this_is_output_file;
4043
4044 /* Nonzero means %s has been seen; the next arg to be terminated
4045    is the name of a library file and we should try the standard
4046    search dirs for it.  */
4047 static int this_is_library_file;
4048
4049 /* Nonzero means %T has been seen; the next arg to be terminated
4050    is the name of a linker script and we should try all of the
4051    standard search dirs for it.  If it is found insert a --script
4052    command line switch and then substitute the full path in place,
4053    otherwise generate an error message.  */
4054 static int this_is_linker_script;
4055
4056 /* Nonzero means that the input of this command is coming from a pipe.  */
4057 static int input_from_pipe;
4058
4059 /* Nonnull means substitute this for any suffix when outputting a switches
4060    arguments.  */
4061 static const char *suffix_subst;
4062
4063 /* If there is an argument being accumulated, terminate it and store it.  */
4064
4065 static void
4066 end_going_arg (void)
4067 {
4068   if (arg_going)
4069     {
4070       const char *string;
4071
4072       obstack_1grow (&obstack, 0);
4073       string = XOBFINISH (&obstack, const char *);
4074       if (this_is_library_file)
4075         string = find_file (string);
4076       if (this_is_linker_script)
4077         {
4078           char * full_script_path = find_a_file (&startfile_prefixes, string, R_OK, true);
4079
4080           if (full_script_path == NULL)
4081             {
4082               error ("unable to locate default linker script %qs in the library search paths", string);
4083               /* Script was not found on search path.  */
4084               return;
4085             }
4086           store_arg ("--script", false, false);
4087           string = full_script_path;
4088         }
4089       store_arg (string, delete_this_arg, this_is_output_file);
4090       if (this_is_output_file)
4091         outfiles[input_file_number] = string;
4092       arg_going = 0;
4093     }
4094 }
4095
4096
4097 /* Parse the WRAPPER string which is a comma separated list of the command line
4098    and insert them into the beginning of argbuf.  */
4099
4100 static void
4101 insert_wrapper (const char *wrapper)
4102 {
4103   int n = 0;
4104   int i;
4105   char *buf = xstrdup (wrapper);
4106   char *p = buf;
4107
4108   do
4109     {
4110       n++;
4111       while (*p == ',')
4112         p++;
4113     }
4114   while ((p = strchr (p, ',')) != NULL);
4115
4116   if (argbuf_index + n >= argbuf_length)
4117     {
4118       argbuf_length = argbuf_length * 2;
4119       while (argbuf_length < argbuf_index + n)
4120         argbuf_length *= 2;
4121       argbuf = XRESIZEVEC (const char *, argbuf, argbuf_length);
4122     }
4123   for (i = argbuf_index - 1; i >= 0; i--)
4124     argbuf[i + n] = argbuf[i];
4125
4126   i = 0;
4127   p = buf;
4128   do
4129     {
4130       while (*p == ',')
4131         {
4132           *p = 0;
4133           p++;
4134         }
4135       argbuf[i++] = p;
4136     }
4137   while ((p = strchr (p, ',')) != NULL);
4138   gcc_assert (i == n);
4139   argbuf_index += n;
4140 }
4141
4142 /* Process the spec SPEC and run the commands specified therein.
4143    Returns 0 if the spec is successfully processed; -1 if failed.  */
4144
4145 int
4146 do_spec (const char *spec)
4147 {
4148   int value;
4149
4150   value = do_spec_2 (spec);
4151
4152   /* Force out any unfinished command.
4153      If -pipe, this forces out the last command if it ended in `|'.  */
4154   if (value == 0)
4155     {
4156       if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
4157         argbuf_index--;
4158
4159       set_collect_gcc_options ();
4160
4161       if (argbuf_index > 0)
4162         value = execute ();
4163     }
4164
4165   return value;
4166 }
4167
4168 static int
4169 do_spec_2 (const char *spec)
4170 {
4171   int result;
4172
4173   clear_args ();
4174   arg_going = 0;
4175   delete_this_arg = 0;
4176   this_is_output_file = 0;
4177   this_is_library_file = 0;
4178   this_is_linker_script = 0;
4179   input_from_pipe = 0;
4180   suffix_subst = NULL;
4181
4182   result = do_spec_1 (spec, 0, NULL);
4183
4184   end_going_arg ();
4185
4186   return result;
4187 }
4188
4189
4190 /* Process the given spec string and add any new options to the end
4191    of the switches/n_switches array.  */
4192
4193 static void
4194 do_option_spec (const char *name, const char *spec)
4195 {
4196   unsigned int i, value_count, value_len;
4197   const char *p, *q, *value;
4198   char *tmp_spec, *tmp_spec_p;
4199
4200   if (configure_default_options[0].name == NULL)
4201     return;
4202
4203   for (i = 0; i < ARRAY_SIZE (configure_default_options); i++)
4204     if (strcmp (configure_default_options[i].name, name) == 0)
4205       break;
4206   if (i == ARRAY_SIZE (configure_default_options))
4207     return;
4208
4209   value = configure_default_options[i].value;
4210   value_len = strlen (value);
4211
4212   /* Compute the size of the final spec.  */
4213   value_count = 0;
4214   p = spec;
4215   while ((p = strstr (p, "%(VALUE)")) != NULL)
4216     {
4217       p ++;
4218       value_count ++;
4219     }
4220
4221   /* Replace each %(VALUE) by the specified value.  */
4222   tmp_spec = (char *) alloca (strlen (spec) + 1
4223                      + value_count * (value_len - strlen ("%(VALUE)")));
4224   tmp_spec_p = tmp_spec;
4225   q = spec;
4226   while ((p = strstr (q, "%(VALUE)")) != NULL)
4227     {