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