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