gcc/gcc.c

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