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