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 "[.0-9A-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 /* Were the options -c or -S passed.  */
1855 static int have_c = 0;
1856
1857 /* Was the option -o passed.  */
1858 static int have_o = 0;
1859
1860 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1861    temp file.  If the HOST_BIT_BUCKET is used for %j, no entry is made for
1862    it here.  */
1863
1864 static struct temp_name {
1865   const char *suffix;   /* suffix associated with the code.  */
1866   int length;           /* strlen (suffix).  */
1867   int unique;           /* Indicates whether %g or %u/%U was used.  */
1868   const char *filename; /* associated filename.  */
1869   int filename_length;  /* strlen (filename).  */
1870   struct temp_name *next;
1871 } *temp_names;
1872
1873 /* Number of commands executed so far.  */
1874
1875 static int execution_count;
1876
1877 /* Number of commands that exited with a signal.  */
1878
1879 static int signal_count;
1880
1881 /* Name with which this program was invoked.  */
1882
1883 static const char *programname;
1884 \f
1885 /* Allocate the argument vector.  */
1886
1887 static void
1888 alloc_args (void)
1889 {
1890   argbuf_length = 10;
1891   argbuf = xmalloc (argbuf_length * sizeof (const char *));
1892 }
1893
1894 /* Clear out the vector of arguments (after a command is executed).  */
1895
1896 static void
1897 clear_args (void)
1898 {
1899   argbuf_index = 0;
1900 }
1901
1902 /* Add one argument to the vector at the end.
1903    This is done when a space is seen or at the end of the line.
1904    If DELETE_ALWAYS is nonzero, the arg is a filename
1905     and the file should be deleted eventually.
1906    If DELETE_FAILURE is nonzero, the arg is a filename
1907     and the file should be deleted if this compilation fails.  */
1908
1909 static void
1910 store_arg (const char *arg, int delete_always, int delete_failure)
1911 {
1912   if (argbuf_index + 1 == argbuf_length)
1913     argbuf = xrealloc (argbuf, (argbuf_length *= 2) * sizeof (const char *));
1914
1915   argbuf[argbuf_index++] = arg;
1916   argbuf[argbuf_index] = 0;
1917
1918   if (strcmp (arg, "-o") == 0)
1919     have_o_argbuf_index = argbuf_index;
1920   if (delete_always || delete_failure)
1921     record_temp_file (arg, delete_always, delete_failure);
1922 }
1923 \f
1924 /* Load specs from a file name named FILENAME, replacing occurrences of
1925    various different types of line-endings, \r\n, \n\r and just \r, with
1926    a single \n.  */
1927
1928 static char *
1929 load_specs (const char *filename)
1930 {
1931   int desc;
1932   int readlen;
1933   struct stat statbuf;
1934   char *buffer;
1935   char *buffer_p;
1936   char *specs;
1937   char *specs_p;
1938
1939   if (verbose_flag)
1940     notice ("Reading specs from %s\n", filename);
1941
1942   /* Open and stat the file.  */
1943   desc = open (filename, O_RDONLY, 0);
1944   if (desc < 0)
1945     pfatal_with_name (filename);
1946   if (stat (filename, &statbuf) < 0)
1947     pfatal_with_name (filename);
1948
1949   /* Read contents of file into BUFFER.  */
1950   buffer = xmalloc ((unsigned) statbuf.st_size + 1);
1951   readlen = read (desc, buffer, (unsigned) statbuf.st_size);
1952   if (readlen < 0)
1953     pfatal_with_name (filename);
1954   buffer[readlen] = 0;
1955   close (desc);
1956
1957   specs = xmalloc (readlen + 1);
1958   specs_p = specs;
1959   for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
1960     {
1961       int skip = 0;
1962       char c = *buffer_p;
1963       if (c == '\r')
1964         {
1965           if (buffer_p > buffer && *(buffer_p - 1) == '\n')     /* \n\r */
1966             skip = 1;
1967           else if (*(buffer_p + 1) == '\n')                     /* \r\n */
1968             skip = 1;
1969           else                                                  /* \r */
1970             c = '\n';
1971         }
1972       if (! skip)
1973         *specs_p++ = c;
1974     }
1975   *specs_p = '\0';
1976
1977   free (buffer);
1978   return (specs);
1979 }
1980
1981 /* Read compilation specs from a file named FILENAME,
1982    replacing the default ones.
1983
1984    A suffix which starts with `*' is a definition for
1985    one of the machine-specific sub-specs.  The "suffix" should be
1986    *asm, *cc1, *cpp, *link, *startfile, etc.
1987    The corresponding spec is stored in asm_spec, etc.,
1988    rather than in the `compilers' vector.
1989
1990    Anything invalid in the file is a fatal error.  */
1991
1992 static void
1993 read_specs (const char *filename, int main_p)
1994 {
1995   char *buffer;
1996   char *p;
1997
1998   buffer = load_specs (filename);
1999
2000   /* Scan BUFFER for specs, putting them in the vector.  */
2001   p = buffer;
2002   while (1)
2003     {
2004       char *suffix;
2005       char *spec;
2006       char *in, *out, *p1, *p2, *p3;
2007
2008       /* Advance P in BUFFER to the next nonblank nocomment line.  */
2009       p = skip_whitespace (p);
2010       if (*p == 0)
2011         break;
2012
2013       /* Is this a special command that starts with '%'? */
2014       /* Don't allow this for the main specs file, since it would
2015          encourage people to overwrite it.  */
2016       if (*p == '%' && !main_p)
2017         {
2018           p1 = p;
2019           while (*p && *p != '\n')
2020             p++;
2021
2022           /* Skip '\n'.  */
2023           p++;
2024
2025           if (!strncmp (p1, "%include", sizeof ("%include") - 1)
2026               && (p1[sizeof "%include" - 1] == ' '
2027                   || p1[sizeof "%include" - 1] == '\t'))
2028             {
2029               char *new_filename;
2030
2031               p1 += sizeof ("%include");
2032               while (*p1 == ' ' || *p1 == '\t')
2033                 p1++;
2034
2035               if (*p1++ != '<' || p[-2] != '>')
2036                 fatal ("specs %%include syntax malformed after %ld characters",
2037                        (long) (p1 - buffer + 1));
2038
2039               p[-2] = '\0';
2040               new_filename = find_a_file (&startfile_prefixes, p1, R_OK, 0);
2041               read_specs (new_filename ? new_filename : p1, FALSE);
2042               continue;
2043             }
2044           else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
2045                    && (p1[sizeof "%include_noerr" - 1] == ' '
2046                        || p1[sizeof "%include_noerr" - 1] == '\t'))
2047             {
2048               char *new_filename;
2049
2050               p1 += sizeof "%include_noerr";
2051               while (*p1 == ' ' || *p1 == '\t')
2052                 p1++;
2053
2054               if (*p1++ != '<' || p[-2] != '>')
2055                 fatal ("specs %%include syntax malformed after %ld characters",
2056                        (long) (p1 - buffer + 1));
2057
2058               p[-2] = '\0';
2059               new_filename = find_a_file (&startfile_prefixes, p1, R_OK, 0);
2060               if (new_filename)
2061                 read_specs (new_filename, FALSE);
2062               else if (verbose_flag)
2063                 notice ("could not find specs file %s\n", p1);
2064               continue;
2065             }
2066           else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
2067                    && (p1[sizeof "%rename" - 1] == ' '
2068                        || p1[sizeof "%rename" - 1] == '\t'))
2069             {
2070               int name_len;
2071               struct spec_list *sl;
2072               struct spec_list *newsl;
2073
2074               /* Get original name.  */
2075               p1 += sizeof "%rename";
2076               while (*p1 == ' ' || *p1 == '\t')
2077                 p1++;
2078
2079               if (! ISALPHA ((unsigned char) *p1))
2080                 fatal ("specs %%rename syntax malformed after %ld characters",
2081                        (long) (p1 - buffer));
2082
2083               p2 = p1;
2084               while (*p2 && !ISSPACE ((unsigned char) *p2))
2085                 p2++;
2086
2087               if (*p2 != ' ' && *p2 != '\t')
2088                 fatal ("specs %%rename syntax malformed after %ld characters",
2089                        (long) (p2 - buffer));
2090
2091               name_len = p2 - p1;
2092               *p2++ = '\0';
2093               while (*p2 == ' ' || *p2 == '\t')
2094                 p2++;
2095
2096               if (! ISALPHA ((unsigned char) *p2))
2097                 fatal ("specs %%rename syntax malformed after %ld characters",
2098                        (long) (p2 - buffer));
2099
2100               /* Get new spec name.  */
2101               p3 = p2;
2102               while (*p3 && !ISSPACE ((unsigned char) *p3))
2103                 p3++;
2104
2105               if (p3 != p - 1)
2106                 fatal ("specs %%rename syntax malformed after %ld characters",
2107                        (long) (p3 - buffer));
2108               *p3 = '\0';
2109
2110               for (sl = specs; sl; sl = sl->next)
2111                 if (name_len == sl->name_len && !strcmp (sl->name, p1))
2112                   break;
2113
2114               if (!sl)
2115                 fatal ("specs %s spec was not found to be renamed", p1);
2116
2117               if (strcmp (p1, p2) == 0)
2118                 continue;
2119
2120               for (newsl = specs; newsl; newsl = newsl->next)
2121                 if (strcmp (newsl->name, p2) == 0)
2122                   fatal ("%s: attempt to rename spec '%s' to already defined spec '%s'",
2123                     filename, p1, p2);
2124
2125               if (verbose_flag)
2126                 {
2127                   notice ("rename spec %s to %s\n", p1, p2);
2128 #ifdef DEBUG_SPECS
2129                   notice ("spec is '%s'\n\n", *(sl->ptr_spec));
2130 #endif
2131                 }
2132
2133               set_spec (p2, *(sl->ptr_spec));
2134               if (sl->alloc_p)
2135                 free ((void *) *(sl->ptr_spec));
2136
2137               *(sl->ptr_spec) = "";
2138               sl->alloc_p = 0;
2139               continue;
2140             }
2141           else
2142             fatal ("specs unknown %% command after %ld characters",
2143                    (long) (p1 - buffer));
2144         }
2145
2146       /* Find the colon that should end the suffix.  */
2147       p1 = p;
2148       while (*p1 && *p1 != ':' && *p1 != '\n')
2149         p1++;
2150
2151       /* The colon shouldn't be missing.  */
2152       if (*p1 != ':')
2153         fatal ("specs file malformed after %ld characters",
2154                (long) (p1 - buffer));
2155
2156       /* Skip back over trailing whitespace.  */
2157       p2 = p1;
2158       while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
2159         p2--;
2160
2161       /* Copy the suffix to a string.  */
2162       suffix = save_string (p, p2 - p);
2163       /* Find the next line.  */
2164       p = skip_whitespace (p1 + 1);
2165       if (p[1] == 0)
2166         fatal ("specs file malformed after %ld characters",
2167                (long) (p - buffer));
2168
2169       p1 = p;
2170       /* Find next blank line or end of string.  */
2171       while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
2172         p1++;
2173
2174       /* Specs end at the blank line and do not include the newline.  */
2175       spec = save_string (p, p1 - p);
2176       p = p1;
2177
2178       /* Delete backslash-newline sequences from the spec.  */
2179       in = spec;
2180       out = spec;
2181       while (*in != 0)
2182         {
2183           if (in[0] == '\\' && in[1] == '\n')
2184             in += 2;
2185           else if (in[0] == '#')
2186             while (*in && *in != '\n')
2187               in++;
2188
2189           else
2190             *out++ = *in++;
2191         }
2192       *out = 0;
2193
2194       if (suffix[0] == '*')
2195         {
2196           if (! strcmp (suffix, "*link_command"))
2197             link_command_spec = spec;
2198           else
2199             set_spec (suffix + 1, spec);
2200         }
2201       else
2202         {
2203           /* Add this pair to the vector.  */
2204           compilers
2205             = xrealloc (compilers,
2206                         (n_compilers + 2) * sizeof (struct compiler));
2207
2208           compilers[n_compilers].suffix = suffix;
2209           compilers[n_compilers].spec = spec;
2210           n_compilers++;
2211           memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
2212         }
2213
2214       if (*suffix == 0)
2215         link_command_spec = spec;
2216     }
2217
2218   if (link_command_spec == 0)
2219     fatal ("spec file has no spec for linking");
2220 }
2221 \f
2222 /* Record the names of temporary files we tell compilers to write,
2223    and delete them at the end of the run.  */
2224
2225 /* This is the common prefix we use to make temp file names.
2226    It is chosen once for each run of this program.
2227    It is substituted into a spec by %g or %j.
2228    Thus, all temp file names contain this prefix.
2229    In practice, all temp file names start with this prefix.
2230
2231    This prefix comes from the envvar TMPDIR if it is defined;
2232    otherwise, from the P_tmpdir macro if that is defined;
2233    otherwise, in /usr/tmp or /tmp;
2234    or finally the current directory if all else fails.  */
2235
2236 static const char *temp_filename;
2237
2238 /* Length of the prefix.  */
2239
2240 static int temp_filename_length;
2241
2242 /* Define the list of temporary files to delete.  */
2243
2244 struct temp_file
2245 {
2246   const char *name;
2247   struct temp_file *next;
2248 };
2249
2250 /* Queue of files to delete on success or failure of compilation.  */
2251 static struct temp_file *always_delete_queue;
2252 /* Queue of files to delete on failure of compilation.  */
2253 static struct temp_file *failure_delete_queue;
2254
2255 /* Record FILENAME as a file to be deleted automatically.
2256    ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
2257    otherwise delete it in any case.
2258    FAIL_DELETE nonzero means delete it if a compilation step fails;
2259    otherwise delete it in any case.  */
2260
2261 void
2262 record_temp_file (const char *filename, int always_delete, int fail_delete)
2263 {
2264   char *const name = xstrdup (filename);
2265
2266   if (always_delete)
2267     {
2268       struct temp_file *temp;
2269       for (temp = always_delete_queue; temp; temp = temp->next)
2270         if (! strcmp (name, temp->name))
2271           goto already1;
2272
2273       temp = xmalloc (sizeof (struct temp_file));
2274       temp->next = always_delete_queue;
2275       temp->name = name;
2276       always_delete_queue = temp;
2277
2278     already1:;
2279     }
2280
2281   if (fail_delete)
2282     {
2283       struct temp_file *temp;
2284       for (temp = failure_delete_queue; temp; temp = temp->next)
2285         if (! strcmp (name, temp->name))
2286           goto already2;
2287
2288       temp = xmalloc (sizeof (struct temp_file));
2289       temp->next = failure_delete_queue;
2290       temp->name = name;
2291       failure_delete_queue = temp;
2292
2293     already2:;
2294     }
2295 }
2296
2297 /* Delete all the temporary files whose names we previously recorded.  */
2298
2299 #ifndef DELETE_IF_ORDINARY
2300 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG)        \
2301 do                                                      \
2302   {                                                     \
2303     if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode))  \
2304       if (unlink (NAME) < 0)                            \
2305         if (VERBOSE_FLAG)                               \
2306           perror_with_name (NAME);                      \
2307   } while (0)
2308 #endif
2309
2310 static void
2311 delete_if_ordinary (const char *name)
2312 {
2313   struct stat st;
2314 #ifdef DEBUG
2315   int i, c;
2316
2317   printf ("Delete %s? (y or n) ", name);
2318   fflush (stdout);
2319   i = getchar ();
2320   if (i != '\n')
2321     while ((c = getchar ()) != '\n' && c != EOF)
2322       ;
2323
2324   if (i == 'y' || i == 'Y')
2325 #endif /* DEBUG */
2326   DELETE_IF_ORDINARY (name, st, verbose_flag);
2327 }
2328
2329 static void
2330 delete_temp_files (void)
2331 {
2332   struct temp_file *temp;
2333
2334   for (temp = always_delete_queue; temp; temp = temp->next)
2335     delete_if_ordinary (temp->name);
2336   always_delete_queue = 0;
2337 }
2338
2339 /* Delete all the files to be deleted on error.  */
2340
2341 static void
2342 delete_failure_queue (void)
2343 {
2344   struct temp_file *temp;
2345
2346   for (temp = failure_delete_queue; temp; temp = temp->next)
2347     delete_if_ordinary (temp->name);
2348 }
2349
2350 static void
2351 clear_failure_queue (void)
2352 {
2353   failure_delete_queue = 0;
2354 }
2355 \f
2356 /* Build a list of search directories from PATHS.
2357    PREFIX is a string to prepend to the list.
2358    If CHECK_DIR_P is nonzero we ensure the directory exists.
2359    This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2360    It is also used by the --print-search-dirs flag.  */
2361
2362 static char *
2363 build_search_list (struct path_prefix *paths, const char *prefix,
2364                    int check_dir_p)
2365 {
2366   int suffix_len = (machine_suffix) ? strlen (machine_suffix) : 0;
2367   int just_suffix_len
2368     = (just_machine_suffix) ? strlen (just_machine_suffix) : 0;
2369   int first_time = TRUE;
2370   struct prefix_list *pprefix;
2371
2372   obstack_grow (&collect_obstack, prefix, strlen (prefix));
2373   obstack_1grow (&collect_obstack, '=');
2374
2375   for (pprefix = paths->plist; pprefix != 0; pprefix = pprefix->next)
2376     {
2377       int len = strlen (pprefix->prefix);
2378
2379       if (machine_suffix
2380           && (! check_dir_p
2381               || is_directory (pprefix->prefix, machine_suffix, 0)))
2382         {
2383           if (!first_time)
2384             obstack_1grow (&collect_obstack, PATH_SEPARATOR);
2385
2386           first_time = FALSE;
2387           obstack_grow (&collect_obstack, pprefix->prefix, len);
2388           obstack_grow (&collect_obstack, machine_suffix, suffix_len);
2389         }
2390
2391       if (just_machine_suffix
2392           && pprefix->require_machine_suffix == 2
2393           && (! check_dir_p
2394               || is_directory (pprefix->prefix, just_machine_suffix, 0)))
2395         {
2396           if (! first_time)
2397             obstack_1grow (&collect_obstack, PATH_SEPARATOR);
2398
2399           first_time = FALSE;
2400           obstack_grow (&collect_obstack, pprefix->prefix, len);
2401           obstack_grow (&collect_obstack, just_machine_suffix,
2402                         just_suffix_len);
2403         }
2404
2405       if (! pprefix->require_machine_suffix)
2406         {
2407           if (! first_time)
2408             obstack_1grow (&collect_obstack, PATH_SEPARATOR);
2409
2410           first_time = FALSE;
2411           obstack_grow (&collect_obstack, pprefix->prefix, len);
2412         }
2413     }
2414
2415   obstack_1grow (&collect_obstack, '\0');
2416   return XOBFINISH (&collect_obstack, char *);
2417 }
2418
2419 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2420    for collect.  */
2421
2422 static void
2423 putenv_from_prefixes (struct path_prefix *paths, const char *env_var)
2424 {
2425   putenv (build_search_list (paths, env_var, 1));
2426 }
2427 \f
2428 /* Check whether NAME can be accessed in MODE.  This is like access,
2429    except that it never considers directories to be executable.  */
2430
2431 static int
2432 access_check (const char *name, int mode)
2433 {
2434   if (mode == X_OK)
2435     {
2436       struct stat st;
2437
2438       if (stat (name, &st) < 0
2439           || S_ISDIR (st.st_mode))
2440         return -1;
2441     }
2442
2443   return access (name, mode);
2444 }
2445
2446 /* Search for NAME using the prefix list PREFIXES.  MODE is passed to
2447    access to check permissions.
2448    Return 0 if not found, otherwise return its name, allocated with malloc.  */
2449
2450 static char *
2451 find_a_file (struct path_prefix *pprefix, const char *name, int mode,
2452              int multilib)
2453 {
2454   char *temp;
2455   const char *const file_suffix =
2456     ((mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "");
2457   struct prefix_list *pl;
2458   int len = pprefix->max_len + strlen (name) + strlen (file_suffix) + 1;
2459   const char *multilib_name, *multilib_os_name;
2460
2461 #ifdef DEFAULT_ASSEMBLER
2462   if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
2463     return xstrdup (DEFAULT_ASSEMBLER);
2464 #endif
2465
2466 #ifdef DEFAULT_LINKER
2467   if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0)
2468     return xstrdup (DEFAULT_LINKER);
2469 #endif
2470
2471   if (machine_suffix)
2472     len += strlen (machine_suffix);
2473
2474   multilib_name = name;
2475   multilib_os_name = name;
2476   if (multilib && multilib_os_dir)
2477     {
2478       int len1 = multilib_dir ? strlen (multilib_dir) + 1 : 0;
2479       int len2 = strlen (multilib_os_dir) + 1;
2480
2481       len += len1 > len2 ? len1 : len2;
2482       if (multilib_dir)
2483         multilib_name = ACONCAT ((multilib_dir, dir_separator_str, name,
2484                                   NULL));
2485       if (strcmp (multilib_os_dir, ".") != 0)
2486         multilib_os_name = ACONCAT ((multilib_os_dir, dir_separator_str, name,
2487                                     NULL));
2488     }
2489
2490   temp = xmalloc (len);
2491
2492   /* Determine the filename to execute (special case for absolute paths).  */
2493
2494   if (IS_ABSOLUTE_PATH (name))
2495     {
2496       if (access (name, mode) == 0)
2497         {
2498           strcpy (temp, name);
2499           return temp;
2500         }
2501     }
2502   else
2503     for (pl = pprefix->plist; pl; pl = pl->next)
2504       {
2505         const char *this_name
2506           = pl->os_multilib ? multilib_os_name : multilib_name;
2507
2508         if (machine_suffix)
2509           {
2510             /* Some systems have a suffix for executable files.
2511                So try appending that first.  */
2512             if (file_suffix[0] != 0)
2513               {
2514                 strcpy (temp, pl->prefix);
2515                 strcat (temp, machine_suffix);
2516                 strcat (temp, multilib_name);
2517                 strcat (temp, file_suffix);
2518                 if (access_check (temp, mode) == 0)
2519                   return temp;
2520               }
2521
2522             /* Now try just the multilib_name.  */
2523             strcpy (temp, pl->prefix);
2524             strcat (temp, machine_suffix);
2525             strcat (temp, multilib_name);
2526             if (access_check (temp, mode) == 0)
2527               return temp;
2528           }
2529
2530         /* Certain prefixes are tried with just the machine type,
2531            not the version.  This is used for finding as, ld, etc.  */
2532         if (just_machine_suffix && pl->require_machine_suffix == 2)
2533           {
2534             /* Some systems have a suffix for executable files.
2535                So try appending that first.  */
2536             if (file_suffix[0] != 0)
2537               {
2538                 strcpy (temp, pl->prefix);
2539                 strcat (temp, just_machine_suffix);
2540                 strcat (temp, multilib_name);
2541                 strcat (temp, file_suffix);
2542                 if (access_check (temp, mode) == 0)
2543                   return temp;
2544               }
2545
2546             strcpy (temp, pl->prefix);
2547             strcat (temp, just_machine_suffix);
2548             strcat (temp, multilib_name);
2549             if (access_check (temp, mode) == 0)
2550               return temp;
2551           }
2552
2553         /* Certain prefixes can't be used without the machine suffix
2554            when the machine or version is explicitly specified.  */
2555         if (! pl->require_machine_suffix)
2556           {
2557             /* Some systems have a suffix for executable files.
2558                So try appending that first.  */
2559             if (file_suffix[0] != 0)
2560               {
2561                 strcpy (temp, pl->prefix);
2562                 strcat (temp, this_name);
2563                 strcat (temp, file_suffix);
2564                 if (access_check (temp, mode) == 0)
2565                   return temp;
2566               }
2567
2568             strcpy (temp, pl->prefix);
2569             strcat (temp, this_name);
2570             if (access_check (temp, mode) == 0)
2571               return temp;
2572           }
2573       }
2574
2575   free (temp);
2576   return 0;
2577 }
2578
2579 /* Ranking of prefixes in the sort list. -B prefixes are put before
2580    all others.  */
2581
2582 enum path_prefix_priority
2583 {
2584   PREFIX_PRIORITY_B_OPT,
2585   PREFIX_PRIORITY_LAST
2586 };
2587
2588 /* Add an entry for PREFIX in PLIST.  The PLIST is kept in ascending
2589    order according to PRIORITY.  Within each PRIORITY, new entries are
2590    appended.
2591
2592    If WARN is nonzero, we will warn if no file is found
2593    through this prefix.  WARN should point to an int
2594    which will be set to 1 if this entry is used.
2595
2596    COMPONENT is the value to be passed to update_path.
2597
2598    REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2599    the complete value of machine_suffix.
2600    2 means try both machine_suffix and just_machine_suffix.  */
2601
2602 static void
2603 add_prefix (struct path_prefix *pprefix, const char *prefix,
2604             const char *component, /* enum prefix_priority */ int priority,
2605             int require_machine_suffix, int os_multilib)
2606 {
2607   struct prefix_list *pl, **prev;
2608   int len;
2609
2610   for (prev = &pprefix->plist;
2611        (*prev) != NULL && (*prev)->priority <= priority;
2612        prev = &(*prev)->next)
2613     ;
2614
2615   /* Keep track of the longest prefix.  */
2616
2617   prefix = update_path (prefix, component);
2618   len = strlen (prefix);
2619   if (len > pprefix->max_len)
2620     pprefix->max_len = len;
2621
2622   pl = xmalloc (sizeof (struct prefix_list));
2623   pl->prefix = prefix;
2624   pl->require_machine_suffix = require_machine_suffix;
2625   pl->priority = priority;
2626   pl->os_multilib = os_multilib;
2627
2628   /* Insert after PREV.  */
2629   pl->next = (*prev);
2630   (*prev) = pl;
2631 }
2632
2633 /* Same as add_prefix, but prepending target_system_root to prefix.  */
2634 static void
2635 add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
2636                       const char *component,
2637                       /* enum prefix_priority */ int priority,
2638                       int require_machine_suffix, int os_multilib)
2639 {
2640   if (!IS_ABSOLUTE_PATH (prefix))
2641     fatal ("system path '%s' is not absolute", prefix);
2642
2643   if (target_system_root)
2644     {
2645       if (target_sysroot_suffix)
2646           prefix = concat (target_sysroot_suffix, prefix, NULL);
2647       prefix = concat (target_system_root, prefix, NULL);
2648
2649       /* We have to override this because GCC's notion of sysroot
2650          moves along with GCC.  */
2651       component = "GCC";
2652     }
2653
2654   add_prefix (pprefix, prefix, component, priority,
2655               require_machine_suffix, os_multilib);
2656 }
2657 \f
2658 /* Execute the command specified by the arguments on the current line of spec.
2659    When using pipes, this includes several piped-together commands
2660    with `|' between them.
2661
2662    Return 0 if successful, -1 if failed.  */
2663
2664 static int
2665 execute (void)
2666 {
2667   int i;
2668   int n_commands;               /* # of command.  */
2669   char *string;
2670   struct pex_obj *pex;
2671   struct command
2672   {
2673     const char *prog;           /* program name.  */
2674     const char **argv;          /* vector of args.  */
2675   };
2676
2677   struct command *commands;     /* each command buffer with above info.  */
2678
2679   gcc_assert (!processing_spec_function);
2680
2681   /* Count # of piped commands.  */
2682   for (n_commands = 1, i = 0; i < argbuf_index; i++)
2683     if (strcmp (argbuf[i], "|") == 0)
2684       n_commands++;
2685
2686   /* Get storage for each command.  */
2687   commands = alloca (n_commands * sizeof (struct command));
2688
2689   /* Split argbuf into its separate piped processes,
2690      and record info about each one.
2691      Also search for the programs that are to be run.  */
2692
2693   commands[0].prog = argbuf[0]; /* first command.  */
2694   commands[0].argv = &argbuf[0];
2695   string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, 0);
2696
2697   if (string)
2698     commands[0].argv[0] = string;
2699
2700   for (n_commands = 1, i = 0; i < argbuf_index; i++)
2701     if (strcmp (argbuf[i], "|") == 0)
2702       {                         /* each command.  */
2703 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2704         fatal ("-pipe not supported");
2705 #endif
2706         argbuf[i] = 0;  /* termination of command args.  */
2707         commands[n_commands].prog = argbuf[i + 1];
2708         commands[n_commands].argv = &argbuf[i + 1];
2709         string = find_a_file (&exec_prefixes, commands[n_commands].prog,
2710                               X_OK, 0);
2711         if (string)
2712           commands[n_commands].argv[0] = string;
2713         n_commands++;
2714       }
2715
2716   argbuf[argbuf_index] = 0;
2717
2718   /* If -v, print what we are about to do, and maybe query.  */
2719
2720   if (verbose_flag)
2721     {
2722       /* For help listings, put a blank line between sub-processes.  */
2723       if (print_help_list)
2724         fputc ('\n', stderr);
2725
2726       /* Print each piped command as a separate line.  */
2727       for (i = 0; i < n_commands; i++)
2728         {
2729           const char *const *j;
2730
2731           if (verbose_only_flag)
2732             {
2733               for (j = commands[i].argv; *j; j++)
2734                 {
2735                   const char *p;
2736                   fprintf (stderr, " \"");
2737                   for (p = *j; *p; ++p)
2738                     {
2739                       if (*p == '"' || *p == '\\' || *p == '$')
2740                         fputc ('\\', stderr);
2741                       fputc (*p, stderr);
2742                     }
2743                   fputc ('"', stderr);
2744                 }
2745             }
2746           else
2747             for (j = commands[i].argv; *j; j++)
2748               fprintf (stderr, " %s", *j);
2749
2750           /* Print a pipe symbol after all but the last command.  */
2751           if (i + 1 != n_commands)
2752             fprintf (stderr, " |");
2753           fprintf (stderr, "\n");
2754         }
2755       fflush (stderr);
2756       if (verbose_only_flag != 0)
2757         {
2758           /* verbose_only_flag should act as if the spec was
2759              executed, so increment execution_count before
2760              returning.  This prevents spurious warnings about
2761              unused linker input files, etc.  */
2762           execution_count++;
2763           return 0;
2764         }
2765 #ifdef DEBUG
2766       notice ("\nGo ahead? (y or n) ");
2767       fflush (stderr);
2768       i = getchar ();
2769       if (i != '\n')
2770         while (getchar () != '\n')
2771           ;
2772
2773       if (i != 'y' && i != 'Y')
2774         return 0;
2775 #endif /* DEBUG */
2776     }
2777
2778 #ifdef ENABLE_VALGRIND_CHECKING
2779   /* Run the each command through valgrind.  To simplify prepending the
2780      path to valgrind and the option "-q" (for quiet operation unless
2781      something triggers), we allocate a separate argv array.  */
2782
2783   for (i = 0; i < n_commands; i++)
2784     {
2785       const char **argv;
2786       int argc;
2787       int j;
2788
2789       for (argc = 0; commands[i].argv[argc] != NULL; argc++)
2790         ;
2791
2792       argv = alloca ((argc + 3) * sizeof (char *));
2793
2794       argv[0] = VALGRIND_PATH;
2795       argv[1] = "-q";
2796       for (j = 2; j < argc + 2; j++)
2797         argv[j] = commands[i].argv[j - 2];
2798       argv[j] = NULL;
2799
2800       commands[i].argv = argv;
2801       commands[i].prog = argv[0];
2802     }
2803 #endif
2804
2805   /* Run each piped subprocess.  */
2806
2807   pex = pex_init (PEX_USE_PIPES | (report_times ? PEX_RECORD_TIMES : 0),
2808                   programname, temp_filename);
2809   if (pex == NULL)
2810     pfatal_with_name (_("pex_init failed"));
2811
2812   for (i = 0; i < n_commands; i++)
2813     {
2814       const char *errmsg;
2815       int err;
2816       const char *string = commands[i].argv[0];
2817
2818       errmsg = pex_run (pex,
2819                         ((i + 1 == n_commands ? PEX_LAST : 0)
2820                          | (string == commands[i].prog ? PEX_SEARCH : 0)),
2821                         string, (char * const *) commands[i].argv,
2822                         NULL, NULL, &err);
2823       if (errmsg != NULL)
2824         {
2825           if (err == 0)
2826             fatal (errmsg);
2827           else
2828             {
2829               errno = err;
2830               pfatal_with_name (errmsg);
2831             }
2832         }
2833
2834       if (string != commands[i].prog)
2835         free ((void *) string);
2836     }
2837
2838   execution_count++;
2839
2840   /* Wait for all the subprocesses to finish.  */
2841
2842   {
2843     int *statuses;
2844     struct pex_time *times = NULL;
2845     int ret_code = 0;
2846
2847     statuses = alloca (n_commands * sizeof (int));
2848     if (!pex_get_status (pex, n_commands, statuses))
2849       pfatal_with_name (_("failed to get exit status"));
2850
2851     if (report_times)
2852       {
2853         times = alloca (n_commands * sizeof (struct pex_time));
2854         if (!pex_get_times (pex, n_commands, times))
2855           pfatal_with_name (_("failed to get process times"));
2856       }
2857
2858     pex_free (pex);
2859
2860     for (i = 0; i < n_commands; ++i)
2861       {
2862         int status = statuses[i];
2863
2864         if (WIFSIGNALED (status))
2865           {
2866 #ifdef SIGPIPE
2867             /* SIGPIPE is a special case.  It happens in -pipe mode
2868                when the compiler dies before the preprocessor is done,
2869                or the assembler dies before the compiler is done.
2870                There's generally been an error already, and this is
2871                just fallout.  So don't generate another error unless
2872                we would otherwise have succeeded.  */
2873             if (WTERMSIG (status) == SIGPIPE
2874                 && (signal_count || greatest_status >= MIN_FATAL_STATUS))
2875               ;
2876             else
2877 #endif
2878               fatal ("\
2879 Internal error: %s (program %s)\n\
2880 Please submit a full bug report.\n\
2881 See %s for instructions.",
2882                      strsignal (WTERMSIG (status)), commands[i].prog,
2883                      bug_report_url);
2884             signal_count++;
2885             ret_code = -1;
2886           }
2887         else if (WIFEXITED (status)
2888                  && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
2889           {
2890             if (WEXITSTATUS (status) > greatest_status)
2891               greatest_status = WEXITSTATUS (status);
2892             ret_code = -1;
2893           }
2894
2895         if (report_times)
2896           {
2897             struct pex_time *pt = &times[i];
2898             double ut, st;
2899
2900             ut = ((double) pt->user_seconds
2901                   + (double) pt->user_microseconds / 1.0e6);
2902             st = ((double) pt->system_seconds
2903                   + (double) pt->system_microseconds / 1.0e6);
2904
2905             if (ut + st != 0)
2906               notice ("# %s %.2f %.2f\n", commands[i].prog, ut, st);
2907           }
2908       }
2909
2910     return ret_code;
2911   }
2912 }
2913 \f
2914 /* Find all the switches given to us
2915    and make a vector describing them.
2916    The elements of the vector are strings, one per switch given.
2917    If a switch uses following arguments, then the `part1' field
2918    is the switch itself and the `args' field
2919    is a null-terminated vector containing the following arguments.
2920    The `live_cond' field is:
2921    0 when initialized
2922    1 if the switch is true in a conditional spec,
2923    -1 if false (overridden by a later switch)
2924    -2 if this switch should be ignored (used in %<S)
2925    The `validated' field is nonzero if any spec has looked at this switch;
2926    if it remains zero at the end of the run, it must be meaningless.  */
2927
2928 #define SWITCH_OK       0
2929 #define SWITCH_FALSE   -1
2930 #define SWITCH_IGNORE  -2
2931 #define SWITCH_LIVE     1
2932
2933 struct switchstr
2934 {
2935   const char *part1;
2936   const char **args;
2937   int live_cond;
2938   unsigned char validated;
2939   unsigned char ordering;
2940 };
2941
2942 static struct switchstr *switches;
2943
2944 static int n_switches;
2945
2946 /* Language is one of three things:
2947
2948    1) The name of a real programming language.
2949    2) NULL, indicating that no one has figured out
2950    what it is yet.
2951    3) '*', indicating that the file should be passed
2952    to the linker.  */
2953 struct infile
2954 {
2955   const char *name;
2956   const char *language;
2957   struct compiler *incompiler;
2958   bool compiled;
2959   bool preprocessed;
2960 };
2961
2962 /* Also a vector of input files specified.  */
2963
2964 static struct infile *infiles;
2965
2966 int n_infiles;
2967
2968 /* True if multiple input files are being compiled to a single
2969    assembly file.  */
2970
2971 static bool combine_inputs;
2972
2973 /* This counts the number of libraries added by lang_specific_driver, so that
2974    we can tell if there were any user supplied any files or libraries.  */
2975
2976 static int added_libraries;
2977
2978 /* And a vector of corresponding output files is made up later.  */
2979
2980 const char **outfiles;
2981 \f
2982 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2983
2984 /* Convert NAME to a new name if it is the standard suffix.  DO_EXE
2985    is true if we should look for an executable suffix.  DO_OBJ
2986    is true if we should look for an object suffix.  */
2987
2988 static const char *
2989 convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
2990                   int do_obj ATTRIBUTE_UNUSED)
2991 {
2992 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2993   int i;
2994 #endif
2995   int len;
2996
2997   if (name == NULL)
2998     return NULL;
2999
3000   len = strlen (name);
3001
3002 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3003   /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj".  */
3004   if (do_obj && len > 2
3005       && name[len - 2] == '.'
3006       && name[len - 1] == 'o')
3007     {
3008       obstack_grow (&obstack, name, len - 2);
3009       obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
3010       name = XOBFINISH (&obstack, const char *);
3011     }
3012 #endif
3013
3014 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3015   /* If there is no filetype, make it the executable suffix (which includes
3016      the ".").  But don't get confused if we have just "-o".  */
3017   if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
3018     return name;
3019
3020   for (i = len - 1; i >= 0; i--)
3021     if (IS_DIR_SEPARATOR (name[i]))
3022       break;
3023
3024   for (i++; i < len; i++)
3025     if (name[i] == '.')
3026       return name;
3027
3028   obstack_grow (&obstack, name, len);
3029   obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
3030                  strlen (TARGET_EXECUTABLE_SUFFIX));
3031   name = XOBFINISH (&obstack, const char *);
3032 #endif
3033
3034   return name;
3035 }
3036 #endif
3037 \f
3038 /* Display the command line switches accepted by gcc.  */
3039 static void
3040 display_help (void)
3041 {
3042   printf (_("Usage: %s [options] file...\n"), programname);
3043   fputs (_("Options:\n"), stdout);
3044
3045   fputs (_("  -pass-exit-codes         Exit with highest error code from a phase\n"), stdout);
3046   fputs (_("  --help                   Display this information\n"), stdout);
3047   fputs (_("  --target-help            Display target specific command line options\n"), stdout);
3048   if (! verbose_flag)
3049     fputs (_("  (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
3050   fputs (_("  -dumpspecs               Display all of the built in spec strings\n"), stdout);
3051   fputs (_("  -dumpversion             Display the version of the compiler\n"), stdout);
3052   fputs (_("  -dumpmachine             Display the compiler's target processor\n"), stdout);
3053   fputs (_("  -print-search-dirs       Display the directories in the compiler's search path\n"), stdout);
3054   fputs (_("  -print-libgcc-file-name  Display the name of the compiler's companion library\n"), stdout);
3055   fputs (_("  -print-file-name=<lib>   Display the full path to library <lib>\n"), stdout);
3056   fputs (_("  -print-prog-name=<prog>  Display the full path to compiler component <prog>\n"), stdout);
3057   fputs (_("  -print-multi-directory   Display the root directory for versions of libgcc\n"), stdout);
3058   fputs (_("\
3059   -print-multi-lib         Display the mapping between command line options and\n\
3060                            multiple library search directories\n"), stdout);
3061   fputs (_("  -print-multi-os-directory Display the relative path to OS libraries\n"), stdout);
3062   fputs (_("  -Wa,<options>            Pass comma-separated <options> on to the assembler\n"), stdout);
3063   fputs (_("  -Wp,<options>            Pass comma-separated <options> on to the preprocessor\n"), stdout);
3064   fputs (_("  -Wl,<options>            Pass comma-separated <options> on to the linker\n"), stdout);
3065   fputs (_("  -Xassembler <arg>        Pass <arg> on to the assembler\n"), stdout);
3066   fputs (_("  -Xpreprocessor <arg>     Pass <arg> on to the preprocessor\n"), stdout);
3067   fputs (_("  -Xlinker <arg>           Pass <arg> on to the linker\n"), stdout);
3068   fputs (_("  -combine                 Pass multiple source files to compiler at once\n"), stdout);
3069   fputs (_("  -save-temps              Do not delete intermediate files\n"), stdout);
3070   fputs (_("  -pipe                    Use pipes rather than intermediate files\n"), stdout);
3071   fputs (_("  -time                    Time the execution of each subprocess\n"), stdout);
3072   fputs (_("  -specs=<file>            Override built-in specs with the contents of <file>\n"), stdout);
3073   fputs (_("  -std=<standard>          Assume that the input sources are for <standard>\n"), stdout);
3074   fputs (_("\
3075   --sysroot=<directory>    Use <directory> as the root directory for headers\n\
3076                            for headers and libraries\n"), stdout);
3077   fputs (_("  -B <directory>           Add <directory> to the compiler's search paths\n"), stdout);
3078   fputs (_("  -b <machine>             Run gcc for target <machine>, if installed\n"), stdout);
3079   fputs (_("  -V <version>             Run gcc version number <version>, if installed\n"), stdout);
3080   fputs (_("  -v                       Display the programs invoked by the compiler\n"), stdout);
3081   fputs (_("  -###                     Like -v but options quoted and commands not executed\n"), stdout);
3082   fputs (_("  -E                       Preprocess only; do not compile, assemble or link\n"), stdout);
3083   fputs (_("  -S                       Compile only; do not assemble or link\n"), stdout);
3084   fputs (_("  -c                       Compile and assemble, but do not link\n"), stdout);
3085   fputs (_("  -o <file>                Place the output into <file>\n"), stdout);
3086   fputs (_("\
3087   -x <language>            Specify the language of the following input files\n\
3088                            Permissible languages include: c c++ assembler none\n\
3089                            'none' means revert to the default behavior of\n\
3090                            guessing the language based on the file's extension\n\
3091 "), stdout);
3092
3093   printf (_("\
3094 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3095  passed on to the various sub-processes invoked by %s.  In order to pass\n\
3096  other options on to these processes the -W<letter> options must be used.\n\
3097 "), programname);
3098
3099   /* The rest of the options are displayed by invocations of the various
3100      sub-processes.  */
3101 }
3102
3103 static void
3104 add_preprocessor_option (const char *option, int len)
3105 {
3106   n_preprocessor_options++;
3107
3108   if (! preprocessor_options)
3109     preprocessor_options = xmalloc (n_preprocessor_options * sizeof (char *));
3110   else
3111     preprocessor_options = xrealloc (preprocessor_options,
3112                                      n_preprocessor_options * sizeof (char *));
3113
3114   preprocessor_options [n_preprocessor_options - 1] =
3115     save_string (option, len);
3116 }
3117
3118 static void
3119 add_assembler_option (const char *option, int len)
3120 {
3121   n_assembler_options++;
3122
3123   if (! assembler_options)
3124     assembler_options = xmalloc (n_assembler_options * sizeof (char *));
3125   else
3126     assembler_options = xrealloc (assembler_options,
3127                                   n_assembler_options * sizeof (char *));
3128
3129   assembler_options [n_assembler_options - 1] = save_string (option, len);
3130 }
3131
3132 static void
3133 add_linker_option (const char *option, int len)
3134 {
3135   n_linker_options++;
3136
3137   if (! linker_options)
3138     linker_options = xmalloc (n_linker_options * sizeof (char *));
3139   else
3140     linker_options = xrealloc (linker_options,
3141                                n_linker_options * sizeof (char *));
3142
3143   linker_options [n_linker_options - 1] = save_string (option, len);
3144 }
3145 \f
3146 /* Create the vector `switches' and its contents.
3147    Store its length in `n_switches'.  */
3148
3149 static void
3150 process_command (int argc, const char **argv)
3151 {
3152   int i;
3153   const char *temp;
3154   char *temp1;
3155   const char *spec_lang = 0;
3156   int last_language_n_infiles;
3157   int lang_n_infiles = 0;
3158 #ifdef MODIFY_TARGET_NAME
3159   int is_modify_target_name;
3160   int j;
3161 #endif
3162
3163   GET_ENVIRONMENT (gcc_exec_prefix, "GCC_EXEC_PREFIX");
3164
3165   n_switches = 0;
3166   n_infiles = 0;
3167   added_libraries = 0;
3168
3169   /* Figure compiler version from version string.  */
3170
3171   compiler_version = temp1 = xstrdup (version_string);
3172
3173   for (; *temp1; ++temp1)
3174     {
3175       if (*temp1 == ' ')
3176         {
3177           *temp1 = '\0';
3178           break;
3179         }
3180     }
3181
3182   /* If there is a -V or -b option (or both), process it now, before
3183      trying to interpret the rest of the command line.
3184      Use heuristic that all configuration names must have at least
3185      one dash '-'. This allows us to pass options starting with -b.  */
3186   if (argc > 1 && argv[1][0] == '-'
3187       && (argv[1][1] == 'V' ||
3188          ((argv[1][1] == 'b') && (NULL != strchr(argv[1] + 2,'-')))))
3189     {
3190       const char *new_version = DEFAULT_TARGET_VERSION;
3191       const char *new_machine = DEFAULT_TARGET_MACHINE;
3192       const char *progname = argv[0];
3193       char **new_argv;
3194       char *new_argv0;
3195       int baselen;
3196
3197       while (argc > 1 && argv[1][0] == '-'
3198              && (argv[1][1] == 'V' ||
3199                 ((argv[1][1] == 'b') && ( NULL != strchr(argv[1] + 2,'-')))))
3200         {
3201           char opt = argv[1][1];
3202           const char *arg;
3203           if (argv[1][2] != '\0')
3204             {
3205               arg = argv[1] + 2;
3206               argc -= 1;
3207               argv += 1;
3208             }
3209           else if (argc > 2)
3210             {
3211               arg = argv[2];
3212               argc -= 2;
3213               argv += 2;
3214             }
3215           else
3216             fatal ("'-%c' option must have argument", opt);
3217           if (opt == 'V')
3218             new_version = arg;
3219           else
3220             new_machine = arg;
3221         }
3222
3223       for (baselen = strlen (progname); baselen > 0; baselen--)
3224         if (IS_DIR_SEPARATOR (progname[baselen-1]))
3225           break;
3226       new_argv0 = xmemdup (progname, baselen,
3227                            baselen + concat_length (new_version, new_machine,
3228                                                     "-gcc-", NULL) + 1);
3229       strcpy (new_argv0 + baselen, new_machine);
3230       strcat (new_argv0, "-gcc-");
3231       strcat (new_argv0, new_version);
3232
3233       new_argv = xmemdup (argv, (argc + 1) * sizeof (argv[0]),
3234                           (argc + 1) * sizeof (argv[0]));
3235       new_argv[0] = new_argv0;
3236
3237       execvp (new_argv0, new_argv);
3238       fatal ("couldn't run '%s': %s", new_argv0, xstrerror (errno));
3239     }
3240
3241   /* Set up the default search paths.  If there is no GCC_EXEC_PREFIX,
3242      see if we can create it from the pathname specified in argv[0].  */
3243
3244   gcc_libexec_prefix = standard_libexec_prefix;
3245 #ifndef VMS
3246   /* FIXME: make_relative_prefix doesn't yet work for VMS.  */
3247   if (!gcc_exec_prefix)
3248     {
3249       gcc_exec_prefix = make_relative_prefix (argv[0], standard_bindir_prefix,
3250                                               standard_exec_prefix);
3251       gcc_libexec_prefix = make_relative_prefix (argv[0],
3252                                                  standard_bindir_prefix,
3253                                                  standard_libexec_prefix);
3254       if (gcc_exec_prefix)
3255         putenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
3256     }
3257   else
3258     gcc_libexec_prefix = make_relative_prefix (gcc_exec_prefix,
3259                                                standard_exec_prefix,
3260                                                standard_libexec_prefix);
3261 #else
3262 #endif
3263
3264   if (gcc_exec_prefix)
3265     {
3266       int len = strlen (gcc_exec_prefix);
3267
3268       if (len > (int) sizeof ("/lib/gcc/") - 1
3269           && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
3270         {
3271           temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1;
3272           if (IS_DIR_SEPARATOR (*temp)
3273               && strncmp (temp + 1, "lib", 3) == 0
3274               && IS_DIR_SEPARATOR (temp[4])
3275               && strncmp (temp + 5, "gcc", 3) == 0)
3276             len -= sizeof ("/lib/gcc/") - 1;
3277         }
3278
3279       set_std_prefix (gcc_exec_prefix, len);
3280       add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC",
3281                   PREFIX_PRIORITY_LAST, 0, 0);
3282       add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
3283                   PREFIX_PRIORITY_LAST, 0, 0);
3284     }
3285
3286   /* COMPILER_PATH and LIBRARY_PATH have values
3287      that are lists of directory names with colons.  */
3288
3289   GET_ENVIRONMENT (temp, "COMPILER_PATH");
3290   if (temp)
3291     {
3292       const char *startp, *endp;
3293       char *nstore = alloca (strlen (temp) + 3);
3294
3295       startp = endp = temp;
3296       while (1)
3297         {
3298           if (*endp == PATH_SEPARATOR || *endp == 0)
3299             {
3300               strncpy (nstore, startp, endp - startp);
3301               if (endp == startp)
3302                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3303               else if (!IS_DIR_SEPARATOR (endp[-1]))
3304                 {
3305                   nstore[endp - startp] = DIR_SEPARATOR;
3306                   nstore[endp - startp + 1] = 0;
3307                 }
3308               else
3309                 nstore[endp - startp] = 0;
3310               add_prefix (&exec_prefixes, nstore, 0,
3311                           PREFIX_PRIORITY_LAST, 0, 0);
3312               add_prefix (&include_prefixes, nstore, 0,
3313                           PREFIX_PRIORITY_LAST, 0, 0);
3314               if (*endp == 0)
3315                 break;
3316               endp = startp = endp + 1;
3317             }
3318           else
3319             endp++;
3320         }
3321     }
3322
3323   GET_ENVIRONMENT (temp, LIBRARY_PATH_ENV);
3324   if (temp && *cross_compile == '0')
3325     {
3326       const char *startp, *endp;
3327       char *nstore = alloca (strlen (temp) + 3);
3328
3329       startp = endp = temp;
3330       while (1)
3331         {
3332           if (*endp == PATH_SEPARATOR || *endp == 0)
3333             {
3334               strncpy (nstore, startp, endp - startp);
3335               if (endp == startp)
3336                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3337               else if (!IS_DIR_SEPARATOR (endp[-1]))
3338                 {
3339                   nstore[endp - startp] = DIR_SEPARATOR;
3340                   nstore[endp - startp + 1] = 0;
3341                 }
3342               else
3343                 nstore[endp - startp] = 0;
3344               add_prefix (&startfile_prefixes, nstore, NULL,
3345                           PREFIX_PRIORITY_LAST, 0, 1);
3346               if (*endp == 0)
3347                 break;
3348               endp = startp = endp + 1;
3349             }
3350           else
3351             endp++;
3352         }
3353     }
3354
3355   /* Use LPATH like LIBRARY_PATH (for the CMU build program).  */
3356   GET_ENVIRONMENT (temp, "LPATH");
3357   if (temp && *cross_compile == '0')
3358     {
3359       const char *startp, *endp;
3360       char *nstore = alloca (strlen (temp) + 3);
3361
3362       startp = endp = temp;
3363       while (1)
3364         {
3365           if (*endp == PATH_SEPARATOR || *endp == 0)
3366             {
3367               strncpy (nstore, startp, endp - startp);
3368               if (endp == startp)
3369                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3370               else if (!IS_DIR_SEPARATOR (endp[-1]))
3371                 {
3372                   nstore[endp - startp] = DIR_SEPARATOR;
3373                   nstore[endp - startp + 1] = 0;
3374                 }
3375               else
3376                 nstore[endp - startp] = 0;
3377               add_prefix (&startfile_prefixes, nstore, NULL,
3378                           PREFIX_PRIORITY_LAST, 0, 1);
3379               if (*endp == 0)
3380                 break;
3381               endp = startp = endp + 1;
3382             }
3383           else
3384             endp++;
3385         }
3386     }
3387
3388   /* Convert new-style -- options to old-style.  */
3389   translate_options (&argc, (const char *const **) &argv);
3390
3391   /* Do language-specific adjustment/addition of flags.  */
3392   lang_specific_driver (&argc, (const char *const **) &argv, &added_libraries);
3393
3394   /* Scan argv twice.  Here, the first time, just count how many switches
3395      there will be in their vector, and how many input files in theirs.
3396      Here we also parse the switches that cc itself uses (e.g. -v).  */
3397
3398   for (i = 1; i < argc; i++)
3399     {
3400       if (! strcmp (argv[i], "-dumpspecs"))
3401         {
3402           struct spec_list *sl;
3403           init_spec ();
3404           for (sl = specs; sl; sl = sl->next)
3405             printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3406           if (link_command_spec)
3407             printf ("*link_command:\n%s\n\n", link_command_spec);
3408           exit (0);
3409         }
3410       else if (! strcmp (argv[i], "-dumpversion"))
3411         {
3412           printf ("%s\n", spec_version);
3413           exit (0);
3414         }
3415       else if (! strcmp (argv[i], "-dumpmachine"))
3416         {
3417           printf ("%s\n", spec_machine);
3418           exit (0);
3419         }
3420       else if (strcmp (argv[i], "-fversion") == 0)
3421         {
3422           /* translate_options () has turned --version into -fversion.  */
3423           printf (_("%s (GCC) %s\n"), programname, version_string);
3424           printf ("Copyright %s 2005 Free Software Foundation, Inc.\n",
3425                   _("(C)"));
3426           fputs (_("This is free software; see the source for copying conditions.  There is NO\n\
3427 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
3428                  stdout);
3429           exit (0);
3430         }
3431       else if (strcmp (argv[i], "-fhelp") == 0)
3432         {
3433           /* translate_options () has turned --help into -fhelp.  */
3434           print_help_list = 1;
3435
3436           /* We will be passing a dummy file on to the sub-processes.  */
3437           n_infiles++;
3438           n_switches++;
3439
3440           /* CPP driver cannot obtain switch from cc1_options.  */
3441           if (is_cpp_driver)
3442             add_preprocessor_option ("--help", 6);
3443           add_assembler_option ("--help", 6);
3444           add_linker_option ("--help", 6);
3445         }
3446       else if (strcmp (argv[i], "-ftarget-help") == 0)
3447         {
3448           /* translate_options() has turned --target-help into -ftarget-help.  */
3449           target_help_flag = 1;
3450
3451           /* We will be passing a dummy file on to the sub-processes.  */
3452           n_infiles++;
3453           n_switches++;
3454
3455           /* CPP driver cannot obtain switch from cc1_options.  */
3456           if (is_cpp_driver)
3457             add_preprocessor_option ("--target-help", 13);
3458           add_assembler_option ("--target-help", 13);
3459           add_linker_option ("--target-help", 13);
3460         }
3461       else if (! strcmp (argv[i], "-pass-exit-codes"))
3462         {
3463           pass_exit_codes = 1;
3464           n_switches++;
3465         }
3466       else if (! strcmp (argv[i], "-print-search-dirs"))
3467         print_search_dirs = 1;
3468       else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3469         print_file_name = "libgcc.a";
3470       else if (! strncmp (argv[i], "-print-file-name=", 17))
3471         print_file_name = argv[i] + 17;
3472       else if (! strncmp (argv[i], "-print-prog-name=", 17))
3473         print_prog_name = argv[i] + 17;
3474       else if (! strcmp (argv[i], "-print-multi-lib"))
3475         print_multi_lib = 1;
3476       else if (! strcmp (argv[i], "-print-multi-directory"))
3477         print_multi_directory = 1;
3478       else if (! strcmp (argv[i], "-print-multi-os-directory"))
3479         print_multi_os_directory = 1;
3480       else if (! strncmp (argv[i], "-Wa,", 4))
3481         {
3482           int prev, j;
3483           /* Pass the rest of this option to the assembler.  */
3484
3485           /* Split the argument at commas.  */
3486           prev = 4;
3487           for (j = 4; argv[i][j]; j++)
3488             if (argv[i][j] == ',')
3489               {
3490                 add_assembler_option (argv[i] + prev, j - prev);
3491                 prev = j + 1;
3492               }
3493
3494           /* Record the part after the last comma.  */
3495           add_assembler_option (argv[i] + prev, j - prev);
3496         }
3497       else if (! strncmp (argv[i], "-Wp,", 4))
3498         {
3499           int prev, j;
3500           /* Pass the rest of this option to the preprocessor.  */
3501
3502           /* Split the argument at commas.  */
3503           prev = 4;
3504           for (j = 4; argv[i][j]; j++)
3505             if (argv[i][j] == ',')
3506               {
3507                 add_preprocessor_option (argv[i] + prev, j - prev);
3508                 prev = j + 1;
3509               }
3510
3511           /* Record the part after the last comma.  */
3512           add_preprocessor_option (argv[i] + prev, j - prev);
3513         }
3514       else if (argv[i][0] == '+' && argv[i][1] == 'e')
3515         /* The +e options to the C++ front-end.  */
3516         n_switches++;
3517       else if (strncmp (argv[i], "-Wl,", 4) == 0)
3518         {
3519           int j;
3520           /* Split the argument at commas.  */
3521           for (j = 3; argv[i][j]; j++)
3522             n_infiles += (argv[i][j] == ',');
3523         }
3524       else if (strcmp (argv[i], "-Xlinker") == 0)
3525         {
3526           if (i + 1 == argc)
3527             fatal ("argument to '-Xlinker' is missing");
3528
3529           n_infiles++;
3530           i++;
3531         }
3532       else if (strcmp (argv[i], "-Xpreprocessor") == 0)
3533         {
3534           if (i + 1 == argc)
3535             fatal ("argument to '-Xpreprocessor' is missing");
3536
3537           add_preprocessor_option (argv[i+1], strlen (argv[i+1]));
3538         }
3539       else if (strcmp (argv[i], "-Xassembler") == 0)
3540         {
3541           if (i + 1 == argc)
3542             fatal ("argument to '-Xassembler' is missing");
3543
3544           add_assembler_option (argv[i+1], strlen (argv[i+1]));
3545         }
3546       else if (strcmp (argv[i], "-l") == 0)
3547         {
3548           if (i + 1 == argc)
3549             fatal ("argument to '-l' is missing");
3550
3551           n_infiles++;
3552           i++;
3553         }
3554       else if (strncmp (argv[i], "-l", 2) == 0)
3555         n_infiles++;
3556       else if (strcmp (argv[i], "-save-temps") == 0)
3557         {
3558           save_temps_flag = 1;
3559           n_switches++;
3560         }
3561       else if (strcmp (argv[i], "-combine") == 0)
3562         {
3563           combine_flag = 1;
3564           n_switches++;
3565         }
3566       else if (strcmp (argv[i], "-specs") == 0)
3567         {
3568           struct user_specs *user = xmalloc (sizeof (struct user_specs));
3569           if (++i >= argc)
3570             fatal ("argument to '-specs' is missing");
3571
3572           user->next = (struct user_specs *) 0;
3573           user->filename = argv[i];
3574           if (user_specs_tail)
3575             user_specs_tail->next = user;
3576           else
3577             user_specs_head = user;
3578           user_specs_tail = user;
3579         }
3580       else if (strncmp (argv[i], "-specs=", 7) == 0)
3581         {
3582           struct user_specs *user = xmalloc (sizeof (struct user_specs));
3583           if (strlen (argv[i]) == 7)
3584             fatal ("argument to '-specs=' is missing");
3585
3586           user->next = (struct user_specs *) 0;
3587           user->filename = argv[i] + 7;
3588           if (user_specs_tail)
3589             user_specs_tail->next = user;
3590           else
3591             user_specs_head = user;
3592           user_specs_tail = user;
3593         }
3594       else if (strcmp (argv[i], "-time") == 0)
3595         report_times = 1;
3596       else if (strcmp (argv[i], "-pipe") == 0)
3597         {
3598           /* -pipe has to go into the switches array as well as
3599              setting a flag.  */
3600           use_pipes = 1;
3601           n_switches++;
3602         }
3603       else if (strcmp (argv[i], "-###") == 0)
3604         {
3605           /* This is similar to -v except that there is no execution
3606              of the commands and the echoed arguments are quoted.  It
3607              is intended for use in shell scripts to capture the
3608              driver-generated command line.  */
3609           verbose_only_flag++;
3610           verbose_flag++;
3611         }
3612       else if (argv[i][0] == '-' && argv[i][1] != 0)
3613         {
3614           const char *p = &argv[i][1];
3615           int c = *p;
3616
3617           switch (c)
3618             {
3619             case 'b':
3620               if (NULL == strchr(argv[i] + 2, '-')) break;
3621             case 'V':
3622               fatal ("'-%c' must come at the start of the command line", c);
3623               break;
3624
3625             case 'B':
3626               {
3627                 const char *value;
3628                 int len;
3629
3630                 if (p[1] == 0 && i + 1 == argc)
3631                   fatal ("argument to '-B' is missing");
3632                 if (p[1] == 0)
3633                   value = argv[++i];
3634                 else
3635                   value = p + 1;
3636
3637                 len = strlen (value);
3638
3639                 /* Catch the case where the user has forgotten to append a
3640                    directory separator to the path.  Note, they may be using
3641                    -B to add an executable name prefix, eg "i386-elf-", in
3642                    order to distinguish between multiple installations of
3643                    GCC in the same directory.  Hence we must check to see
3644                    if appending a directory separator actually makes a
3645                    valid directory name.  */
3646                 if (! IS_DIR_SEPARATOR (value [len - 1])
3647                     && is_directory (value, "", 0))
3648                   {
3649                     char *tmp = xmalloc (len + 2);
3650                     strcpy (tmp, value);
3651                     tmp[len] = DIR_SEPARATOR;
3652                     tmp[++ len] = 0;
3653                     value = tmp;
3654                   }
3655
3656                 /* As a kludge, if the arg is "[foo/]stageN/", just
3657                    add "[foo/]include" to the include prefix.  */
3658                 if ((len == 7
3659                      || (len > 7
3660                          && (IS_DIR_SEPARATOR (value[len - 8]))))
3661                     && strncmp (value + len - 7, "stage", 5) == 0
3662                     && ISDIGIT (value[len - 2])
3663                     && (IS_DIR_SEPARATOR (value[len - 1])))
3664                   {
3665                     if (len == 7)
3666                       add_prefix (&include_prefixes, "./", NULL,
3667                                   PREFIX_PRIORITY_B_OPT, 0, 0);
3668                     else
3669                       {
3670                         char *string = xmalloc (len - 6);
3671                         memcpy (string, value, len - 7);
3672                         string[len - 7] = 0;
3673                         add_prefix (&include_prefixes, string, NULL,
3674                                     PREFIX_PRIORITY_B_OPT, 0, 0);
3675                       }
3676                   }
3677
3678                 add_prefix (&exec_prefixes, value, NULL,
3679                             PREFIX_PRIORITY_B_OPT, 0, 0);
3680                 add_prefix (&startfile_prefixes, value, NULL,
3681                             PREFIX_PRIORITY_B_OPT, 0, 0);
3682                 add_prefix (&include_prefixes, value, NULL,
3683                             PREFIX_PRIORITY_B_OPT, 0, 0);
3684                 n_switches++;
3685               }
3686               break;
3687
3688             case 'v':   /* Print our subcommands and print versions.  */
3689               n_switches++;
3690               /* If they do anything other than exactly `-v', don't set
3691                  verbose_flag; rather, continue on to give the error.  */
3692               if (p[1] != 0)
3693                 break;
3694               verbose_flag++;
3695               break;
3696
3697             case 'S':
3698             case 'c':
3699               if (p[1] == 0)
3700                 {
3701                   have_c = 1;
3702                   n_switches++;
3703                   break;
3704                 }
3705               goto normal_switch;
3706
3707             case 'o':
3708               have_o = 1;
3709 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
3710               if (! have_c)
3711                 {
3712                   int skip;
3713
3714                   /* Forward scan, just in case -S or -c is specified
3715                      after -o.  */
3716                   int j = i + 1;
3717                   if (p[1] == 0)
3718                     ++j;
3719                   while (j < argc)
3720                     {
3721                       if (argv[j][0] == '-')
3722                         {
3723                           if (SWITCH_CURTAILS_COMPILATION (argv[j][1])
3724                               && argv[j][2] == 0)
3725                             {
3726                               have_c = 1;
3727                               break;
3728                             }
3729                           else if ((skip = SWITCH_TAKES_ARG (argv[j][1])))
3730                             j += skip - (argv[j][2] != 0);
3731                           else if ((skip = WORD_SWITCH_TAKES_ARG (argv[j] + 1)))
3732                             j += skip;
3733                         }
3734                       j++;
3735                     }
3736                 }
3737 #endif
3738 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3739               if (p[1] == 0)
3740                 argv[i + 1] = convert_filename (argv[i + 1], ! have_c, 0);
3741               else
3742                 argv[i] = convert_filename (argv[i], ! have_c, 0);
3743 #endif
3744               goto normal_switch;
3745
3746             default:
3747             normal_switch:
3748
3749 #ifdef MODIFY_TARGET_NAME
3750               is_modify_target_name = 0;
3751
3752               for (j = 0; j < ARRAY_SIZE (modify_target); j++)
3753                 if (! strcmp (argv[i], modify_target[j].sw))
3754                   {
3755                     char *new_name = xmalloc (strlen (modify_target[j].str)
3756                                               + strlen (spec_machine));
3757                     const char *p, *r;
3758                     char *q;
3759                     int made_addition = 0;
3760
3761                     is_modify_target_name = 1;
3762                     for (p = spec_machine, q = new_name; *p != 0; )
3763                       {
3764                         if (modify_target[j].add_del == DELETE
3765                             && (! strncmp (q, modify_target[j].str,
3766                                            strlen (modify_target[j].str))))
3767                           p += strlen (modify_target[j].str);
3768                         else if (modify_target[j].add_del == ADD
3769                                  && ! made_addition && *p == '-')
3770                           {
3771                             for (r = modify_target[j].str; *r != 0; )
3772                               *q++ = *r++;
3773                             made_addition = 1;
3774                           }
3775
3776                         *q++ = *p++;
3777                       }
3778
3779                     spec_machine = new_name;
3780                   }
3781
3782               if (is_modify_target_name)
3783                 break;
3784 #endif
3785
3786               n_switches++;
3787
3788               if (SWITCH_TAKES_ARG (c) > (p[1] != 0))
3789                 i += SWITCH_TAKES_ARG (c) - (p[1] != 0);
3790               else if (WORD_SWITCH_TAKES_ARG (p))
3791                 i += WORD_SWITCH_TAKES_ARG (p);
3792             }
3793         }
3794       else
3795         {
3796           n_infiles++;
3797           lang_n_infiles++;
3798         }
3799     }
3800
3801   if (save_temps_flag && use_pipes)
3802     {
3803       /* -save-temps overrides -pipe, so that temp files are produced */
3804       if (save_temps_flag)
3805         error ("warning: -pipe ignored because -save-temps specified");
3806       use_pipes = 0;
3807     }
3808
3809   /* Set up the search paths before we go looking for config files.  */
3810
3811   /* These come before the md prefixes so that we will find gcc's subcommands
3812      (such as cpp) rather than those of the host system.  */
3813   /* Use 2 as fourth arg meaning try just the machine as a suffix,
3814      as well as trying the machine and the version.  */
3815 #ifndef OS2
3816   add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC",
3817               PREFIX_PRIORITY_LAST, 1, 0);
3818   add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS",
3819               PREFIX_PRIORITY_LAST, 2, 0);
3820   add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
3821               PREFIX_PRIORITY_LAST, 2, 0);
3822   add_prefix (&exec_prefixes, standard_exec_prefix_1, "BINUTILS",
3823               PREFIX_PRIORITY_LAST, 2, 0);
3824   add_prefix (&exec_prefixes, standard_exec_prefix_2, "BINUTILS",
3825               PREFIX_PRIORITY_LAST, 2, 0);
3826 #endif
3827
3828   add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
3829               PREFIX_PRIORITY_LAST, 1, 0);
3830   add_prefix (&startfile_prefixes, standard_exec_prefix_2, "BINUTILS",
3831               PREFIX_PRIORITY_LAST, 1, 0);
3832
3833   tooldir_prefix = concat (tooldir_base_prefix, spec_machine,
3834                            dir_separator_str, NULL);
3835
3836   /* If tooldir is relative, base it on exec_prefixes.  A relative
3837      tooldir lets us move the installed tree as a unit.
3838
3839      If GCC_EXEC_PREFIX is defined, then we want to add two relative
3840      directories, so that we can search both the user specified directory
3841      and the standard place.  */
3842
3843   if (!IS_ABSOLUTE_PATH (tooldir_prefix))
3844     {
3845       if (gcc_exec_prefix)
3846         {
3847           char *gcc_exec_tooldir_prefix
3848             = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
3849                       spec_version, dir_separator_str, tooldir_prefix, NULL);
3850
3851           add_prefix (&exec_prefixes,
3852                       concat (gcc_exec_tooldir_prefix, "bin",
3853                               dir_separator_str, NULL),
3854                       NULL, PREFIX_PRIORITY_LAST, 0, 0);
3855           add_prefix (&startfile_prefixes,
3856                       concat (gcc_exec_tooldir_prefix, "lib",
3857                               dir_separator_str, NULL),
3858                       NULL, PREFIX_PRIORITY_LAST, 0, 1);
3859         }
3860
3861       tooldir_prefix = concat (standard_exec_prefix, spec_machine,
3862                                dir_separator_str, spec_version,
3863                                dir_separator_str, tooldir_prefix, NULL);
3864     }
3865
3866   add_prefix (&exec_prefixes,
3867               concat (tooldir_prefix, "bin", dir_separator_str, NULL),
3868               "BINUTILS", PREFIX_PRIORITY_LAST, 0, 0);
3869   add_prefix (&startfile_prefixes,
3870               concat (tooldir_prefix, "lib", dir_separator_str, NULL),
3871               "BINUTILS", PREFIX_PRIORITY_LAST, 0, 1);
3872
3873 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
3874   /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
3875      then consider it to relocate with the rest of the GCC installation
3876      if GCC_EXEC_PREFIX is set.
3877      ``make_relative_prefix'' is not compiled for VMS, so don't call it.  */
3878   if (target_system_root && gcc_exec_prefix)
3879     {
3880       char *tmp_prefix = make_relative_prefix (argv[0],
3881                                                standard_bindir_prefix,
3882                                                target_system_root);
3883       if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0)
3884         {
3885           target_system_root = tmp_prefix;
3886           target_system_root_changed = 1;
3887         }
3888     }
3889 #endif
3890
3891   /* More prefixes are enabled in main, after we read the specs file
3892      and determine whether this is cross-compilation or not.  */
3893
3894   /* Then create the space for the vectors and scan again.  */
3895
3896   switches = xmalloc ((n_switches + 1) * sizeof (struct switchstr));
3897   infiles = xmalloc ((n_infiles + 1) * sizeof (struct infile));
3898   n_switches = 0;
3899   n_infiles = 0;
3900   last_language_n_infiles = -1;
3901
3902   /* This, time, copy the text of each switch and store a pointer
3903      to the copy in the vector of switches.
3904      Store all the infiles in their vector.  */
3905
3906   for (i = 1; i < argc; i++)
3907     {
3908       /* Just skip the switches that were handled by the preceding loop.  */
3909 #ifdef MODIFY_TARGET_NAME
3910       is_modify_target_name = 0;
3911
3912       for (j = 0; j < ARRAY_SIZE (modify_target); j++)
3913         if (! strcmp (argv[i], modify_target[j].sw))
3914           is_modify_target_name = 1;
3915
3916       if (is_modify_target_name)
3917         ;
3918       else
3919 #endif
3920       if (! strncmp (argv[i], "-Wa,", 4))
3921         ;
3922       else if (! strncmp (argv[i], "-Wp,", 4))
3923         ;
3924       else if (! strcmp (argv[i], "-pass-exit-codes"))
3925         ;
3926       else if (! strcmp (argv[i], "-print-search-dirs"))
3927         ;
3928       else if (! strcmp (argv[i], "-print-libgcc-file-name"))
3929         ;
3930       else if (! strncmp (argv[i], "-print-file-name=", 17))
3931         ;
3932       else if (! strncmp (argv[i], "-print-prog-name=", 17))
3933         ;
3934       else if (! strcmp (argv[i], "-print-multi-lib"))
3935         ;
3936       else if (! strcmp (argv[i], "-print-multi-directory"))
3937         ;
3938       else if (! strcmp (argv[i], "-print-multi-os-directory"))
3939         ;
3940       else if (! strcmp (argv[i], "-ftarget-help"))
3941         ;
3942       else if (! strcmp (argv[i], "-fhelp"))
3943         ;
3944       else if (! strncmp (argv[i], "--sysroot=", strlen ("--sysroot=")))
3945         {
3946           target_system_root = argv[i] + strlen ("--sysroot=");
3947           target_system_root_changed = 1;
3948         }
3949       else if (argv[i][0] == '+' && argv[i][1] == 'e')
3950         {
3951           /* Compensate for the +e options to the C++ front-end;
3952              they're there simply for cfront call-compatibility.  We do
3953              some magic in default_compilers to pass them down properly.
3954              Note we deliberately start at the `+' here, to avoid passing
3955              -e0 or -e1 down into the linker.  */
3956           switches[n_switches].part1 = &argv[i][0];
3957           switches[n_switches].args = 0;
3958           switches[n_switches].live_cond = SWITCH_OK;
3959           switches[n_switches].validated = 0;
3960           n_switches++;
3961         }
3962       else if (strncmp (argv[i], "-Wl,", 4) == 0)
3963         {
3964           int prev, j;
3965           /* Split the argument at commas.  */
3966           prev = 4;
3967           for (j = 4; argv[i][j]; j++)
3968             if (argv[i][j] == ',')
3969               {
3970                 infiles[n_infiles].language = "*";
3971                 infiles[n_infiles++].name
3972                   = save_string (argv[i] + prev, j - prev);
3973                 prev = j + 1;
3974               }
3975           /* Record the part after the last comma.  */
3976           infiles[n_infiles].language = "*";
3977           infiles[n_infiles++].name = argv[i] + prev;
3978         }
3979       else if (strcmp (argv[i], "-Xlinker") == 0)
3980         {
3981           infiles[n_infiles].language = "*";
3982           infiles[n_infiles++].name = argv[++i];
3983         }
3984       /* Xassembler and Xpreprocessor were already handled in the first argv
3985          scan, so all we need to do here is ignore them and their argument.  */
3986       else if (strcmp (argv[i], "-Xassembler") == 0)
3987         i++;
3988       else if (strcmp (argv[i], "-Xpreprocessor") == 0)
3989         i++;
3990       else if (strcmp (argv[i], "-l") == 0)
3991         { /* POSIX allows separation of -l and the lib arg;
3992              canonicalize by concatenating -l with its arg */
3993           infiles[n_infiles].language = "*";
3994           infiles[n_infiles++].name = concat ("-l", argv[++i], NULL);
3995         }
3996       else if (strncmp (argv[i], "-l", 2) == 0)
3997         {
3998           infiles[n_infiles].language = "*";
3999           infiles[n_infiles++].name = argv[i];
4000         }
4001       else if (strcmp (argv[i], "-specs") == 0)
4002         i++;
4003       else if (strncmp (argv[i], "-specs=", 7) == 0)
4004         ;
4005       else if (strcmp (argv[i], "-time") == 0)
4006         ;
4007       else if (strcmp (argv[i], "-###") == 0)
4008         ;
4009       else if (argv[i][0] == '-' && argv[i][1] != 0)
4010         {
4011           const char *p = &argv[i][1];
4012           int c = *p;
4013
4014           if (c == 'x')
4015             {
4016               if (p[1] == 0 && i + 1 == argc)
4017                 fatal ("argument to '-x' is missing");
4018               if (p[1] == 0)
4019                 spec_lang = argv[++i];
4020               else
4021                 spec_lang = p + 1;
4022               if (! strcmp (spec_lang, "none"))
4023                 /* Suppress the warning if -xnone comes after the last input
4024                    file, because alternate command interfaces like g++ might
4025                    find it useful to place -xnone after each input file.  */
4026                 spec_lang = 0;
4027               else
4028                 last_language_n_infiles = n_infiles;
4029               continue;
4030             }
4031           switches[n_switches].part1 = p;
4032           /* Deal with option arguments in separate argv elements.  */
4033           if ((SWITCH_TAKES_ARG (c) > (p[1] != 0))
4034               || WORD_SWITCH_TAKES_ARG (p))
4035             {
4036               int j = 0;
4037               int n_args = WORD_SWITCH_TAKES_ARG (p);
4038
4039               if (n_args == 0)
4040                 {
4041                   /* Count only the option arguments in separate argv elements.  */
4042                   n_args = SWITCH_TAKES_ARG (c) - (p[1] != 0);
4043                 }
4044               if (i + n_args >= argc)
4045                 fatal ("argument to '-%s' is missing", p);
4046               switches[n_switches].args
4047                 = xmalloc ((n_args + 1) * sizeof(const char *));
4048               while (j < n_args)
4049                 switches[n_switches].args[j++] = argv[++i];
4050               /* Null-terminate the vector.  */
4051               switches[n_switches].args[j] = 0;
4052             }
4053           else if (strchr (switches_need_spaces, c))
4054             {
4055               /* On some systems, ld cannot handle some options without
4056                  a space.  So split the option from its argument.  */
4057               char *part1 = xmalloc (2);
4058               part1[0] = c;
4059               part1[1] = '\0';
4060
4061               switches[n_switches].part1 = part1;
4062               switches[n_switches].args = xmalloc (2 * sizeof (const char *));
4063               switches[n_switches].args[0] = xstrdup (p+1);
4064               switches[n_switches].args[1] = 0;
4065             }
4066           else
4067             switches[n_switches].args = 0;
4068
4069           switches[n_switches].live_cond = SWITCH_OK;
4070           switches[n_switches].validated = 0;
4071           switches[n_switches].ordering = 0;
4072           /* These are always valid, since gcc.c itself understands them.  */
4073           if (!strcmp (p, "save-temps")
4074               || !strcmp (p, "static-libgcc")
4075               || !strcmp (p, "shared-libgcc")
4076               || !strcmp (p, "pipe"))
4077             switches[n_switches].validated = 1;
4078           else
4079             {
4080               char ch = switches[n_switches].part1[0];
4081               if (ch == 'B')
4082                 switches[n_switches].validated = 1;
4083             }
4084           n_switches++;
4085         }
4086       else
4087         {
4088 #ifdef HAVE_TARGET_OBJECT_SUFFIX
4089           argv[i] = convert_filename (argv[i], 0, access (argv[i], F_OK));
4090 #endif
4091
4092           if (strcmp (argv[i], "-") != 0 && access (argv[i], F_OK) < 0)
4093             {
4094               perror_with_name (argv[i]);
4095               error_count++;
4096             }
4097           else
4098             {
4099               infiles[n_infiles].language = spec_lang;
4100               infiles[n_infiles++].name = argv[i];
4101             }
4102         }
4103     }
4104
4105   if (n_infiles == last_language_n_infiles && spec_lang != 0)
4106     error ("warning: '-x %s' after last input file has no effect", spec_lang);
4107
4108   /* Ensure we only invoke each subprocess once.  */
4109   if (target_help_flag || print_help_list)
4110     {
4111       n_infiles = 1;
4112
4113       /* Create a dummy input file, so that we can pass --target-help on to
4114          the various sub-processes.  */
4115       infiles[0].language = "c";
4116       infiles[0].name   = "help-dummy";
4117
4118       if (target_help_flag)
4119         {
4120           switches[n_switches].part1     = "--target-help";
4121           switches[n_switches].args      = 0;
4122           switches[n_switches].live_cond = SWITCH_OK;
4123           switches[n_switches].validated = 0;
4124
4125           n_switches++;
4126         }
4127
4128       if (print_help_list)
4129         {
4130           switches[n_switches].part1     = "--help";
4131           switches[n_switches].args      = 0;
4132           switches[n_switches].live_cond = SWITCH_OK;
4133           switches[n_switches].validated = 0;
4134
4135           n_switches++;
4136         }
4137     }
4138
4139   switches[n_switches].part1 = 0;
4140   infiles[n_infiles].name = 0;
4141 }
4142
4143 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4144    and place that in the environment.  */
4145
4146 static void
4147 set_collect_gcc_options (void)
4148 {
4149   int i;
4150   int first_time;
4151
4152   /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4153      the compiler.  */
4154   obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
4155                 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4156
4157   first_time = TRUE;
4158   for (i = 0; (int) i < n_switches; i++)
4159     {
4160       const char *const *args;
4161       const char *p, *q;
4162       if (!first_time)
4163         obstack_grow (&collect_obstack, " ", 1);
4164
4165       first_time = FALSE;
4166
4167       /* Ignore elided switches.  */
4168       if (switches[i].live_cond == SWITCH_IGNORE)
4169         continue;
4170
4171       obstack_grow (&collect_obstack, "'-", 2);
4172       q = switches[i].part1;
4173       while ((p = strchr (q, '\'')))
4174         {
4175           obstack_grow (&collect_obstack, q, p - q);
4176           obstack_grow (&collect_obstack, "'\\''", 4);
4177           q = ++p;
4178         }
4179       obstack_grow (&collect_obstack, q, strlen (q));
4180       obstack_grow (&collect_obstack, "'", 1);
4181
4182       for (args = switches[i].args; args && *args; args++)
4183         {
4184           obstack_grow (&collect_obstack, " '", 2);
4185           q = *args;
4186           while ((p = strchr (q, '\'')))
4187             {
4188               obstack_grow (&collect_obstack, q, p - q);
4189               obstack_grow (&collect_obstack, "'\\''", 4);
4190               q = ++p;
4191             }
4192           obstack_grow (&collect_obstack, q, strlen (q));
4193           obstack_grow (&collect_obstack, "'", 1);
4194         }
4195     }
4196   obstack_grow (&collect_obstack, "\0", 1);
4197   putenv (XOBFINISH (&collect_obstack, char *));
4198 }
4199 \f
4200 /* Process a spec string, accumulating and running commands.  */
4201
4202 /* These variables describe the input file name.
4203    input_file_number is the index on outfiles of this file,
4204    so that the output file name can be stored for later use by %o.
4205    input_basename is the start of the part of the input file
4206    sans all directory names, and basename_length is the number
4207    of characters starting there excluding the suffix .c or whatever.  */
4208
4209 static const char *input_filename;
4210 static int input_file_number;
4211 size_t input_filename_length;
4212 static int basename_length;
4213 static int suffixed_basename_length;
4214 static const char *input_basename;
4215 static const char *input_suffix;
4216 #ifndef HOST_LACKS_INODE_NUMBERS
4217 static struct stat input_stat;
4218 #endif
4219 static int input_stat_set;
4220
4221 /* The compiler used to process the current input file.  */
4222 static struct compiler *input_file_compiler;
4223
4224 /* These are variables used within do_spec and do_spec_1.  */
4225
4226 /* Nonzero if an arg has been started and not yet terminated
4227    (with space, tab or newline).  */
4228 static int arg_going;
4229
4230 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4231    is a temporary file name.  */
4232 static int delete_this_arg;
4233
4234 /* Nonzero means %w has been seen; the next arg to be terminated
4235    is the output file name of this compilation.  */
4236 static int this_is_output_file;
4237
4238 /* Nonzero means %s has been seen; the next arg to be terminated
4239    is the name of a library file and we should try the standard
4240    search dirs for it.  */
4241 static int this_is_library_file;
4242
4243 /* Nonzero means that the input of this command is coming from a pipe.  */
4244 static int input_from_pipe;
4245
4246 /* Nonnull means substitute this for any suffix when outputting a switches
4247    arguments.  */
4248 static const char *suffix_subst;
4249
4250 /* Process the spec SPEC and run the commands specified therein.
4251    Returns 0 if the spec is successfully processed; -1 if failed.  */
4252
4253 int
4254 do_spec (const char *spec)
4255 {
4256   int value;
4257
4258   value = do_spec_2 (spec);
4259
4260   /* Force out any unfinished command.
4261      If -pipe, this forces out the last command if it ended in `|'.  */
4262   if (value == 0)
4263     {
4264       if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
4265         argbuf_index--;
4266
4267       set_collect_gcc_options ();
4268
4269       if (argbuf_index > 0)
4270         value = execute ();
4271     }
4272
4273   return value;
4274 }
4275
4276 static int
4277 do_spec_2 (const char *spec)
4278 {
4279   const char *string;
4280   int result;
4281
4282   clear_args ();
4283   arg_going = 0;
4284   delete_this_arg = 0;
4285   this_is_output_file = 0;
4286   this_is_library_file = 0;
4287   input_from_pipe = 0;
4288   suffix_subst = NULL;
4289
4290   result = do_spec_1 (spec, 0, NULL);
4291
4292   /* End any pending argument.  */
4293   if (arg_going)
4294     {
4295       obstack_1grow (&obstack, 0);
4296       string = XOBFINISH (&obstack, const char *);
4297       if (this_is_library_file)
4298         string = find_file (string);
4299       store_arg (string, delete_this_arg, this_is_output_file);
4300       if (this_is_output_file)
4301         outfiles[input_file_number] = string;
4302       arg_going = 0;
4303     }
4304
4305   return result;
4306 }
4307
4308
4309 /* Process the given spec string and add any new options to the end
4310    of the switches/n_switches array.  */
4311
4312 static void
4313 do_option_spec (const char *name, const char *spec)
4314 {
4315   unsigned int i, value_count, value_len;
4316   const char *p, *q, *value;
4317   char *tmp_spec, *tmp_spec_p;
4318
4319   if (configure_default_options[0].name == NULL)
4320     return;
4321
4322   for (i = 0; i < ARRAY_SIZE (configure_default_options); i++)
4323     if (strcmp (configure_default_options[i].name, name) == 0)
4324       break;
4325   if (i == ARRAY_SIZE (configure_default_options))
4326     return;
4327
4328   value = configure_default_options[i].value;
4329   value_len = strlen (value);
4330
4331   /* Compute the size of the final spec.  */
4332   value_count = 0;
4333   p = spec;
4334   while ((p = strstr (p, "%(VALUE)")) != NULL)
4335     {
4336       p ++;
4337       value_count ++;
4338     }
4339
4340   /* Replace each %(VALUE) by the specified value.  */
4341   tmp_spec = alloca (strlen (spec) + 1
4342                      + value_count * (value_len - strlen ("%(VALUE)")));
4343   tmp_spec_p = tmp_spec;
4344   q = spec;
4345   while ((p = strstr (q, "%(VALUE)")) != NULL)
4346     {
4347       memcpy (tmp_spec_p, q, p - q);
4348       tmp_spec_p = tmp_spec_p + (p - q);
4349       memcpy (tmp_spec_p, value, value_len);
4350       tmp_spec_p += value_len;
4351       q = p + strlen ("%(VALUE)");
4352     }
4353   strcpy (tmp_spec_p, q);
4354
4355   do_self_spec (tmp_spec);
4356 }
4357
4358 /* Process the given spec string and add any new options to the end
4359    of the switches/n_switches array.  */
4360
4361 static void
4362 do_self_spec (const char *spec)
4363 {
4364   do_spec_2 (spec);
4365   do_spec_1 (" ", 0, NULL);
4366
4367   if (argbuf_index > 0)
4368     {
4369       int i, first;
4370
4371       first = n_switches;
4372       n_switches += argbuf_index;
4373       switches = xrealloc (switches,
4374                            sizeof (struct switchstr) * (n_switches + 1));
4375
4376       switches[n_switches] = switches[first];
4377       for (i = 0; i < argbuf_index; i++)
4378         {
4379           struct switchstr *sw;
4380
4381           /* Each switch should start with '-'.  */
4382           if (argbuf[i][0] != '-')
4383             fatal ("switch '%s' does not start with '-'", argbuf[i]);
4384
4385           sw = &switches[i + first];
4386           sw->part1 = &argbuf[i][1];
4387           sw->args = 0;
4388           sw->live_cond = SWITCH_OK;
4389           sw->validated = 0;
4390           sw->ordering = 0;
4391         }
4392     }
4393 }
4394
4395 void
4396 do_spec_path (struct prefix_list *pl, const char *option,
4397               int omit_if_relative, int separate_options,
4398               int only_subdir,
4399               const char *dir_for_machine_suffix,
4400               const char *dir_for_no_suffix)
4401 {
4402   static size_t bufsize = 0;
4403   static char *buffer;
4404   int idx;
4405   bool multilib_p = false;
4406
4407   /* Used on systems which record the specified -L dirs
4408      and use them to search for dynamic linking.  */
4409   /* Relative directories always come from -B,
4410      and it is better not to use them for searching
4411      at run time.  In particular, stage1 loses.  */
4412   if (omit_if_relative
4413       && !IS_ABSOLUTE_PATH (pl->prefix))
4414     return;
4415
4416   /* Try subdirectory if there is one.  */
4417   if (machine_suffix && dir_for_machine_suffix)
4418     {
4419       if (strlen (pl->prefix) + strlen (machine_suffix)
4420           >= bufsize)
4421         bufsize = (strlen (pl->prefix)
4422                   + strlen (machine_suffix)) * 2 + 1;
4423       buffer = xrealloc (buffer, bufsize);
4424       strcpy (buffer, pl->prefix);
4425       strcat (buffer, machine_suffix);
4426       if (is_directory (buffer, dir_for_machine_suffix, 1))
4427         {
4428           multilib_p = true;
4429           do_spec_1 (option, separate_options, NULL);
4430           if (separate_options)
4431             do_spec_1 (" ", 0, NULL);
4432           do_spec_1 (buffer, 1, NULL);
4433           do_spec_1 (dir_for_machine_suffix, 1, NULL);
4434           /* Make this a separate argument.  */
4435           do_spec_1 (" ", 0, NULL);
4436         }
4437     }
4438   if (!pl->require_machine_suffix && dir_for_no_suffix)
4439     {
4440       if (is_directory (pl->prefix, dir_for_no_suffix, 1))
4441         {
4442           multilib_p = true;
4443           do_spec_1 (option, separate_options, NULL);
4444           if (separate_options)
4445             do_spec_1 (" ", 0, NULL);
4446           do_spec_1 (pl->prefix, 1, NULL);
4447           do_spec_1 (dir_for_no_suffix, 1, NULL);
4448           /* Make this a separate argument.  */
4449           do_spec_1 (" ", 0, NULL);
4450         }
4451     }
4452
4453   if (only_subdir || multilib_p)
4454     return;
4455
4456   if (machine_suffix)
4457     {
4458       if (is_directory (pl->prefix, machine_suffix, 1))
4459         {
4460           do_spec_1 (option, separate_options, NULL);
4461           if (separate_options)
4462             do_spec_1 (" ", 0, NULL);
4463           do_spec_1 (pl->prefix, 1, NULL);
4464           /* Remove slash from machine_suffix.  */
4465           if (strlen (machine_suffix) >= bufsize)
4466             bufsize = strlen (machine_suffix) * 2 + 1;
4467           buffer = xrealloc (buffer, bufsize);
4468           strcpy (buffer, machine_suffix);
4469           idx = strlen (buffer);
4470           if (IS_DIR_SEPARATOR (buffer[idx - 1]))
4471             buffer[idx - 1] = 0;
4472           do_spec_1 (buffer, 1, NULL);
4473           /* Make this a separate argument.  */
4474           do_spec_1 (" ", 0, NULL);
4475         }
4476     }
4477   if (!pl->require_machine_suffix)
4478     {
4479       if (is_directory (pl->prefix, "", 1))
4480         {
4481           do_spec_1 (option, separate_options, NULL);
4482           if (separate_options)
4483             do_spec_1 (" ", 0, NULL);
4484           /* Remove slash from pl->prefix.  */
4485           if (strlen (pl->prefix) >= bufsize)
4486             bufsize = strlen (pl->prefix) * 2 + 1;
4487           buffer = xrealloc (buffer, bufsize);
4488           strcpy (buffer, pl->prefix);
4489           idx = strlen (buffer);
4490           if (IS_DIR_SEPARATOR (buffer[idx - 1]))
4491             buffer[idx - 1] = 0;
4492           do_spec_1 (buffer, 1, NULL);
4493           /* Make this a separate argument.  */
4494           do_spec_1 (" ", 0, NULL);
4495         }
4496     }
4497 }
4498
4499 /* Process the sub-spec SPEC as a portion of a larger spec.
4500    This is like processing a whole spec except that we do
4501    not initialize at the beginning and we do not supply a
4502    newline by default at the end.
4503    INSWITCH nonzero means don't process %-sequences in SPEC;
4504    in this case, % is treated as an ordinary character.
4505    This is used while substituting switches.
4506    INSWITCH nonzero also causes SPC not to terminate an argument.
4507
4508    Value is zero unless a line was finished
4509    and the command on that line reported an error.  */
4510
4511 static int
4512 do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
4513 {
4514   const char *p = spec;
4515   int c;
4516   int i;
4517   const char *string;
4518   int value;
4519
4520   while ((c = *p++))
4521     /* If substituting a switch, treat all chars like letters.
4522        Otherwise, NL, SPC, TAB and % are special.  */
4523     switch (inswitch ? 'a' : c)
4524       {
4525       case '\n':
4526         /* End of line: finish any pending argument,
4527            then run the pending command if one has been started.  */
4528         if (arg_going)
4529           {
4530             obstack_1grow (&obstack, 0);
4531             string = XOBFINISH (&obstack, const char *);
4532             if (this_is_library_file)
4533               string = find_file (string);
4534             store_arg (string, delete_this_arg, this_is_output_file);
4535             if (this_is_output_file)
4536               outfiles[input_file_number] = string;
4537           }
4538         arg_going = 0;
4539
4540         if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
4541           {
4542             /* A `|' before the newline means use a pipe here,
4543                but only if -pipe was specified.
4544                Otherwise, execute now and don't pass the `|' as an arg.  */
4545             if (use_pipes)
4546               {
4547                 input_from_pipe = 1;
4548                 break;
4549               }
4550             else
4551               argbuf_index--;
4552           }
4553
4554         set_collect_gcc_options ();
4555
4556         if (argbuf_index > 0)
4557           {
4558             value = execute ();
4559             if (value)
4560               return value;
4561           }
4562         /* Reinitialize for a new command, and for a new argument.  */
4563         clear_args ();
4564         arg_going = 0;
4565         delete_this_arg = 0;
4566         this_is_output_file = 0;
4567         this_is_library_file = 0;
4568         input_from_pipe = 0;
4569         break;
4570
4571       case '|':
4572         /* End any pending argument.  */
4573         if (arg_going)
4574           {
4575             obstack_1grow (&obstack, 0);
4576             string = XOBFINISH (&obstack, const char *);
4577             if (this_is_library_file)
4578               string = find_file (string);
4579             store_arg (string, delete_this_arg, this_is_output_file);
4580             if (this_is_output_file)
4581               outfiles[input_file_number] = string;
4582           }
4583
4584         /* Use pipe */
4585         obstack_1grow (&obstack, c);
4586         arg_going = 1;
4587         break;
4588
4589       case '\t':
4590       case ' ':
4591         /* Space or tab ends an argument if one is pending.  */
4592         if (arg_going)
4593           {
4594             obstack_1grow (&obstack, 0);
4595             string = XOBFINISH (&obstack, const char *);
4596             if (this_is_library_file)
4597               string = find_file (string);
4598             store_arg (string, delete_this_arg, this_is_output_file);
4599             if (this_is_output_file)
4600               outfiles[input_file_number] = string;
4601           }
4602         /* Reinitialize for a new argument.  */
4603         arg_going = 0;
4604         delete_this_arg = 0;
4605         this_is_output_file = 0;
4606         this_is_library_file = 0;
4607         break;
4608
4609       case '%':
4610         switch (c = *p++)
4611           {
4612           case 0:
4613             fatal ("spec '%s' invalid", spec);
4614
4615           case 'b':
4616             obstack_grow (&obstack, input_basename, basename_length);
4617             arg_going = 1;
4618             break;
4619
4620           case 'B':
4621             obstack_grow (&obstack, input_basename, suffixed_basename_length);
4622             arg_going = 1;
4623             break;
4624
4625           case 'd':
4626             delete_this_arg = 2;
4627             break;
4628
4629           /* Dump out the directories specified with LIBRARY_PATH,
4630              followed by the absolute directories
4631              that we search for startfiles.  */
4632           case 'D':
4633             {
4634               struct prefix_list *pl = startfile_prefixes.plist;
4635
4636               for (; pl; pl = pl->next)
4637                 {
4638                   const char *no_suffix_multilib_dir;
4639
4640                   no_suffix_multilib_dir = pl->os_multilib ? multilib_os_dir
4641                                            : multilib_dir;
4642                   /* Do not separate options, include non-multilibbed variant.  */
4643                   do_spec_path (pl, "-L",
4644 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
4645                                 1,
4646 #else
4647                                 0,
4648 #endif
4649                                 0, 0, multilib_dir, no_suffix_multilib_dir);
4650                 }
4651             }
4652             break;
4653
4654           case 'e':
4655             /* %efoo means report an error with `foo' as error message
4656                and don't execute any more commands for this file.  */
4657             {
4658               const char *q = p;
4659               char *buf;
4660               while (*p != 0 && *p != '\n')
4661                 p++;
4662               buf = alloca (p - q + 1);
4663               strncpy (buf, q, p - q);
4664               buf[p - q] = 0;
4665               error ("%s", buf);
4666               return -1;
4667             }
4668             break;
4669           case 'n':
4670             /* %nfoo means report a notice with `foo' on stderr.  */
4671             {
4672               const char *q = p;
4673               char *buf;
4674               while (*p != 0 && *p != '\n')
4675                 p++;
4676               buf = alloca (p - q + 1);
4677               strncpy (buf, q, p - q);
4678               buf[p - q] = 0;
4679               notice ("%s\n", buf);
4680               if (*p)
4681                 p++;
4682             }
4683             break;
4684
4685           case 'j':
4686             {
4687               struct stat st;
4688
4689               /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
4690                  defined, and it is not a directory, and it is
4691                  writable, use it.  Otherwise, treat this like any
4692                  other temporary file.  */
4693
4694               if ((!save_temps_flag)
4695                   && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode))
4696                   && (access (HOST_BIT_BUCKET, W_OK) == 0))
4697                 {
4698                   obstack_grow (&obstack, HOST_BIT_BUCKET,
4699                                 strlen (HOST_BIT_BUCKET));
4700                   delete_this_arg = 0;
4701                   arg_going = 1;
4702                   break;
4703                 }
4704             }
4705             goto create_temp_file;
4706           case '|':
4707             if (use_pipes)
4708               {
4709                 obstack_1grow (&obstack, '-');
4710                 delete_this_arg = 0;
4711                 arg_going = 1;
4712
4713                 /* consume suffix */
4714                 while (*p == '.' || ISALNUM ((unsigned char) *p))
4715                   p++;
4716                 if (p[0] == '%' && p[1] == 'O')
4717                   p += 2;
4718
4719                 break;
4720               }
4721             goto create_temp_file;
4722           case 'm':
4723             if (use_pipes)
4724               {
4725                 /* consume suffix */
4726                 while (*p == '.' || ISALNUM ((unsigned char) *p))
4727                   p++;
4728                 if (p[0] == '%' && p[1] == 'O')
4729                   p += 2;
4730
4731                 break;
4732               }
4733             goto create_temp_file;
4734           case 'g':
4735           case 'u':
4736           case 'U':
4737           create_temp_file:
4738               {
4739                 struct temp_name *t;
4740                 int suffix_length;
4741                 const char *suffix = p;
4742                 char *saved_suffix = NULL;
4743
4744                 while (*p == '.' || ISALNUM ((unsigned char) *p))
4745                   p++;
4746                 suffix_length = p - suffix;
4747                 if (p[0] == '%' && p[1] == 'O')
4748                   {
4749                     p += 2;
4750                     /* We don't support extra suffix characters after %O.  */
4751                     if (*p == '.' || ISALNUM ((unsigned char) *p))
4752                       fatal ("spec '%s' has invalid '%%0%c'", spec, *p);
4753                     if (suffix_length == 0)
4754                       suffix = TARGET_OBJECT_SUFFIX;
4755                     else
4756                       {
4757                         saved_suffix
4758                           = xmalloc (suffix_length
4759                                      + strlen (TARGET_OBJECT_SUFFIX));
4760                         strncpy (saved_suffix, suffix, suffix_length);
4761                         strcpy (saved_suffix + suffix_length,
4762                                 TARGET_OBJECT_SUFFIX);
4763                       }
4764                     suffix_length += strlen (TARGET_OBJECT_SUFFIX);
4765                   }
4766
4767                 /* If the input_filename has the same suffix specified
4768                    for the %g, %u, or %U, and -save-temps is specified,
4769                    we could end up using that file as an intermediate
4770                    thus clobbering the user's source file (.e.g.,
4771                    gcc -save-temps foo.s would clobber foo.s with the
4772                    output of cpp0).  So check for this condition and
4773                    generate a temp file as the intermediate.  */
4774
4775                 if (save_temps_flag)
4776                   {
4777                     temp_filename_length = basename_length + suffix_length;
4778                     temp_filename = alloca (temp_filename_length + 1);
4779                     strncpy ((char *) temp_filename, input_basename, basename_length);
4780                     strncpy ((char *) temp_filename + basename_length, suffix,
4781                              suffix_length);
4782                     *((char *) temp_filename + temp_filename_length) = '\0';
4783                     if (strcmp (temp_filename, input_filename) != 0)
4784                       {
4785 #ifndef HOST_LACKS_INODE_NUMBERS
4786                         struct stat st_temp;
4787
4788                         /* Note, set_input() resets input_stat_set to 0.  */
4789                         if (input_stat_set == 0)
4790                           {
4791                             input_stat_set = stat (input_filename, &input_stat);
4792                             if (input_stat_set >= 0)
4793                               input_stat_set = 1;
4794                           }
4795
4796                         /* If we have the stat for the input_filename
4797                            and we can do the stat for the temp_filename
4798                            then the they could still refer to the same
4799                            file if st_dev/st_ino's are the same.  */
4800                         if (input_stat_set != 1
4801                             || stat (temp_filename, &st_temp) < 0
4802                             || input_stat.st_dev != st_temp.st_dev
4803                             || input_stat.st_ino != st_temp.st_ino)
4804 #else
4805                         /* Just compare canonical pathnames.  */
4806                         char* input_realname = lrealpath (input_filename);
4807                         char* temp_realname = lrealpath (temp_filename);
4808                         bool files_differ = strcmp (input_realname, temp_realname);
4809                         free (input_realname);
4810                         free (temp_realname);
4811                         if (files_differ)
4812 #endif
4813                           {
4814                             temp_filename = save_string (temp_filename,
4815                                                          temp_filename_length + 1);
4816                             obstack_grow (&obstack, temp_filename,
4817                                                     temp_filename_length);
4818                             arg_going = 1;
4819                             delete_this_arg = 0;
4820                             break;
4821                           }
4822                       }
4823                   }
4824
4825                 /* See if we already have an association of %g/%u/%U and
4826                    suffix.  */
4827                 for (t = temp_names; t; t = t->next)
4828                   if (t->length == suffix_length
4829                       && strncmp (t->suffix, suffix, suffix_length) == 0
4830                       && t->unique == (c == 'u' || c == 'U' || c == 'j'))
4831                     break;
4832
4833                 /* Make a new association if needed.  %u and %j
4834                    require one.  */
4835                 if (t == 0 || c == 'u' || c == 'j')
4836                   {
4837                     if (t == 0)
4838                       {
4839                         t = xmalloc (sizeof (struct temp_name));
4840                         t->next = temp_names;
4841                         temp_names = t;
4842                       }
4843                     t->length = suffix_length;
4844                     if (saved_suffix)
4845                       {
4846                         t->suffix = saved_suffix;
4847                         saved_suffix = NULL;
4848                       }
4849                     else
4850                       t->suffix = save_string (suffix, suffix_length);
4851                     t->unique = (c == 'u' || c == 'U' || c == 'j');
4852                     temp_filename = make_temp_file (t->suffix);
4853                     temp_filename_length = strlen (temp_filename);
4854                     t->filename = temp_filename;
4855                     t->filename_length = temp_filename_length;
4856                   }
4857
4858                 if (saved_suffix)
4859                   free (saved_suffix);
4860
4861                 obstack_grow (&obstack, t->filename, t->filename_length);
4862                 delete_this_arg = 1;
4863               }
4864             arg_going = 1;
4865             break;
4866
4867           case 'i':
4868             if (combine_inputs)
4869               {
4870                 for (i = 0; (int) i < n_infiles; i++)
4871                   if ((!infiles[i].language) || (infiles[i].language[0] != '*'))
4872                     if (infiles[i].incompiler == input_file_compiler)
4873                       {
4874                         store_arg (infiles[i].name, 0, 0);
4875                         infiles[i].compiled = true;
4876                       }
4877               }
4878             else
4879               {
4880                 obstack_grow (&obstack, input_filename, input_filename_length);
4881                 arg_going = 1;
4882               }
4883             break;
4884
4885           case 'I':
4886             {
4887               struct prefix_list *pl = include_prefixes.plist;
4888
4889               if (gcc_exec_prefix)
4890                 {
4891                   do_spec_1 ("-iprefix", 1, NULL);
4892                   /* Make this a separate argument.  */
4893                   do_spec_1 (" ", 0, NULL);
4894                   do_spec_1 (gcc_exec_prefix, 1, NULL);
4895                   do_spec_1 (" ", 0, NULL);
4896                 }
4897
4898               if (target_system_root_changed ||
4899                   (target_system_root && target_sysroot_hdrs_suffix))
4900                 {
4901                   do_spec_1 ("-isysroot", 1, NULL);
4902                   /* Make this a separate argument.  */
4903                   do_spec_1 (" ", 0, NULL);
4904                   do_spec_1 (target_system_root, 1, NULL);
4905                   if (target_sysroot_hdrs_suffix)
4906                     do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL);
4907                   do_spec_1 (" ", 0, NULL);
4908                 }
4909
4910               for (; pl; pl = pl->next)
4911                 /* Separate options, don't include non-suffixed variant.  */
4912                 do_spec_path (pl, "-isystem", 0, 1, 1, "include", "include");
4913             }
4914             break;
4915
4916           case 'o':
4917             {
4918               int max = n_infiles;
4919               max += lang_specific_extra_outfiles;
4920
4921               for (i = 0; i < max; i++)
4922                 if (outfiles[i])
4923                   store_arg (outfiles[i], 0, 0);
4924               break;
4925             }
4926
4927           case 'O':
4928             obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
4929             arg_going = 1;
4930             break;
4931
4932           case 's':
4933             this_is_library_file = 1;
4934             break;
4935
4936           case 'V':
4937             outfiles[input_file_number] = NULL;
4938             break;
4939
4940           case 'w':
4941             this_is_output_file = 1;
4942             break;
4943
4944           case 'W':
4945             {
4946               int cur_index = argbuf_index;
4947               /* Handle the {...} following the %W.  */
4948               if (*p != '{')
4949                 fatal ("spec '%s' has invalid '%%W%c", spec, *p);
4950               p = handle_braces (p + 1);
4951               if (p == 0)
4952                 return -1;
4953               /* End any pending argument.  */
4954               if (arg_going)
4955                 {
4956                   obstack_1grow (&obstack, 0);
4957                   string = XOBFINISH (&obstack, const char *);
4958                   if (this_is_library_file)
4959                     string = find_file (string);
4960                   store_arg (string, delete_this_arg, this_is_output_file);
4961                   if (this_is_output_file)
4962                     outfiles[input_file_number] = string;
4963                   arg_going = 0;
4964                 }
4965               /* If any args were output, mark the last one for deletion
4966                  on failure.  */
4967               if (argbuf_index != cur_index)
4968                 record_temp_file (argbuf[argbuf_index - 1], 0, 1);
4969               break;
4970             }
4971
4972           /* %x{OPTION} records OPTION for %X to output.  */
4973           case 'x':
4974             {
4975               const char *p1 = p;
4976               char *string;
4977
4978               /* Skip past the option value and make a copy.  */
4979               if (*p != '{')
4980                 fatal ("spec '%s' has invalid '%%x%c'", spec, *p);
4981               while (*p++ != '}')
4982                 ;
4983               string = save_string (p1 + 1, p - p1 - 2);
4984
4985               /* See if we already recorded this option.  */
4986               for (i = 0; i < n_linker_options; i++)
4987                 if (! strcmp (string, linker_options[i]))
4988                   {
4989                     free (string);
4990                     return 0;
4991                   }
4992
4993               /* This option is new; add it.  */
4994               add_linker_option (string, strlen (string));
4995             }
4996             break;
4997
4998           /* Dump out the options accumulated previously using %x.  */
4999           case 'X':
5000             for (i = 0; i < n_linker_options; i++)
5001               {
5002                 do_spec_1 (linker_options[i], 1, NULL);
5003                 /* Make each accumulated option a separate argument.  */
5004                 do_spec_1 (" ", 0, NULL);
5005               }
5006             break;
5007
5008           /* Dump out the options accumulated previously using -Wa,.  */
5009           case 'Y':
5010             for (i = 0; i < n_assembler_options; i++)
5011               {
5012                 do_spec_1 (assembler_options[i], 1, NULL);
5013                 /* Make each accumulated option a separate argument.  */
5014                 do_spec_1 (" ", 0, NULL);
5015               }
5016             break;
5017
5018           /* Dump out the options accumulated previously using -Wp,.  */
5019           case 'Z':
5020             for (i = 0; i < n_preprocessor_options; i++)
5021               {
5022                 do_spec_1 (preprocessor_options[i], 1, NULL);
5023                 /* Make each accumulated option a separate argument.  */
5024                 do_spec_1 (" ", 0, NULL);
5025               }
5026             break;
5027
5028             /* Here are digits and numbers that just process
5029                a certain constant string as a spec.  */
5030
5031           case '1':
5032             value = do_spec_1 (cc1_spec, 0, NULL);
5033             if (value != 0)
5034               return value;
5035             break;
5036
5037           case '2':
5038             value = do_spec_1 (cc1plus_spec, 0, NULL);
5039             if (value != 0)
5040               return value;
5041             break;
5042
5043           case 'a':
5044             value = do_spec_1 (asm_spec, 0, NULL);
5045             if (value != 0)
5046               return value;
5047             break;
5048
5049           case 'A':
5050             value = do_spec_1 (asm_final_spec, 0, NULL);
5051             if (value != 0)
5052               return value;
5053             break;
5054
5055           case 'C':
5056             {
5057               const char *const spec
5058                 = (input_file_compiler->cpp_spec
5059                    ? input_file_compiler->cpp_spec
5060                    : cpp_spec);
5061               value = do_spec_1 (spec, 0, NULL);
5062               if (value != 0)
5063                 return value;
5064             }
5065             break;
5066
5067           case 'E':
5068             value = do_spec_1 (endfile_spec, 0, NULL);
5069             if (value != 0)
5070               return value;
5071             break;
5072
5073           case 'l':
5074             value = do_spec_1 (link_spec, 0, NULL);
5075             if (value != 0)
5076               return value;
5077             break;
5078
5079           case 'L':
5080             value = do_spec_1 (lib_spec, 0, NULL);
5081             if (value != 0)
5082               return value;
5083             break;
5084
5085           case 'G':
5086             value = do_spec_1 (libgcc_spec, 0, NULL);
5087             if (value != 0)
5088               return value;
5089             break;
5090
5091           case 'R':
5092             /* We assume there is a directory
5093                separator at the end of this string.  */
5094             if (target_system_root)
5095               {
5096                 obstack_grow (&obstack, target_system_root,
5097                               strlen (target_system_root));
5098                 if (target_sysroot_suffix)
5099                   obstack_grow (&obstack, target_sysroot_suffix,
5100                                 strlen (target_sysroot_suffix));
5101               }
5102             break;
5103
5104           case 'S':
5105             value = do_spec_1 (startfile_spec, 0, NULL);
5106             if (value != 0)
5107               return value;
5108             break;
5109
5110             /* Here we define characters other than letters and digits.  */
5111
5112           case '{':
5113             p = handle_braces (p);
5114             if (p == 0)
5115               return -1;
5116             break;
5117
5118           case ':':
5119             p = handle_spec_function (p);
5120             if (p == 0)
5121               return -1;
5122             break;
5123
5124           case '%':
5125             obstack_1grow (&obstack, '%');
5126             break;
5127
5128           case '.':
5129             {
5130               unsigned len = 0;
5131
5132               while (p[len] && p[len] != ' ' && p[len] != '%')
5133                 len++;
5134               suffix_subst = save_string (p - 1, len + 1);
5135               p += len;
5136             }
5137            break;
5138
5139            /* Henceforth ignore the option(s) matching the pattern
5140               after the %<.  */
5141           case '<':
5142             {
5143               unsigned len = 0;
5144               int have_wildcard = 0;
5145               int i;
5146
5147               while (p[len] && p[len] != ' ' && p[len] != '\t')
5148                 len++;
5149
5150               if (p[len-1] == '*')
5151                 have_wildcard = 1;
5152
5153               for (i = 0; i < n_switches; i++)
5154                 if (!strncmp (switches[i].part1, p, len - have_wildcard)
5155                     && (have_wildcard || switches[i].part1[len] == '\0'))
5156                   {
5157                     switches[i].live_cond = SWITCH_IGNORE;
5158                     switches[i].validated = 1;
5159                   }
5160
5161               p += len;
5162             }
5163             break;
5164
5165           case '*':
5166             if (soft_matched_part)
5167               {
5168                 do_spec_1 (soft_matched_part, 1, NULL);
5169                 do_spec_1 (" ", 0, NULL);
5170               }
5171             else
5172               /* Catch the case where a spec string contains something like
5173                  '%{foo:%*}'.  i.e. there is no * in the pattern on the left
5174                  hand side of the :.  */
5175               error ("spec failure: '%%*' has not been initialized by pattern match");
5176             break;
5177
5178             /* Process a string found as the value of a spec given by name.
5179                This feature allows individual machine descriptions
5180                to add and use their own specs.
5181                %[...] modifies -D options the way %P does;
5182                %(...) uses the spec unmodified.  */
5183           case '[':
5184             error ("warning: use of obsolete %%[ operator in specs");
5185           case '(':
5186             {
5187               const char *name = p;
5188               struct spec_list *sl;
5189               int len;
5190
5191               /* The string after the S/P is the name of a spec that is to be
5192                  processed.  */
5193               while (*p && *p != ')' && *p != ']')
5194                 p++;
5195
5196               /* See if it's in the list.  */
5197               for (len = p - name, sl = specs; sl; sl = sl->next)
5198                 if (sl->name_len == len && !strncmp (sl->name, name, len))
5199                   {
5200                     name = *(sl->ptr_spec);
5201 #ifdef DEBUG_SPECS
5202                     notice ("Processing spec %c%s%c, which is '%s'\n",
5203                             c, sl->name, (c == '(') ? ')' : ']', name);
5204 #endif
5205                     break;
5206                   }
5207
5208               if (sl)
5209                 {
5210                   if (c == '(')
5211                     {
5212                       value = do_spec_1 (name, 0, NULL);
5213                       if (value != 0)
5214                         return value;
5215                     }
5216                   else
5217                     {
5218                       char *x = alloca (strlen (name) * 2 + 1);
5219                       char *buf = x;
5220                       const char *y = name;
5221                       int flag = 0;
5222
5223                       /* Copy all of NAME into BUF, but put __ after
5224                          every -D and at the end of each arg.  */
5225                       while (1)
5226                         {
5227                           if (! strncmp (y, "-D", 2))
5228                             {
5229                               *x++ = '-';
5230                               *x++ = 'D';
5231                               *x++ = '_';
5232                               *x++ = '_';
5233                               y += 2;
5234                               flag = 1;
5235                               continue;
5236                             }
5237                           else if (flag
5238                                    && (*y == ' ' || *y == '\t' || *y == '='
5239                                        || *y == '}' || *y == 0))
5240                             {
5241                               *x++ = '_';
5242                               *x++ = '_';
5243                               flag = 0;
5244                             }
5245                           if (*y == 0)
5246                             break;
5247                           else
5248                             *x++ = *y++;
5249                         }
5250                       *x = 0;
5251
5252                       value = do_spec_1 (buf, 0, NULL);
5253                       if (value != 0)
5254                         return value;
5255                     }
5256                 }
5257
5258               /* Discard the closing paren or bracket.  */
5259               if (*p)
5260                 p++;
5261             }
5262             break;
5263
5264           default:
5265             error ("spec failure: unrecognized spec option '%c'", c);
5266             break;
5267           }
5268         break;
5269
5270       case '\\':
5271         /* Backslash: treat next character as ordinary.  */
5272         c = *p++;
5273
5274         /* Fall through.  */
5275       default:
5276         /* Ordinary character: put it into the current argument.  */
5277         obstack_1grow (&obstack, c);
5278         arg_going = 1;
5279       }
5280
5281   /* End of string.  If we are processing a spec function, we need to
5282      end any pending argument.  */
5283   if (processing_spec_function && arg_going)
5284     {
5285       obstack_1grow (&obstack, 0);
5286       string = XOBFINISH (&obstack, const char *);
5287       if (this_is_library_file)
5288         string = find_file (string);
5289       store_arg (string, delete_this_arg, this_is_output_file);
5290       if (this_is_output_file)
5291         outfiles[input_file_number] = string;
5292       arg_going = 0;
5293     }
5294
5295   return 0;
5296 }
5297
5298 /* Look up a spec function.  */
5299
5300 static const struct spec_function *
5301 lookup_spec_function (const char *name)
5302 {
5303   static const struct spec_function * const spec_function_tables[] =
5304   {
5305     static_spec_functions,
5306     lang_specific_spec_functions,
5307   };
5308   const struct spec_function *sf;
5309   unsigned int i;
5310
5311   for (i = 0; i < ARRAY_SIZE (spec_function_tables); i++)
5312     {
5313       for (sf = spec_function_tables[i]; sf->name != NULL; sf++)
5314         if (strcmp (sf->name, name) == 0)
5315           return sf;
5316     }
5317
5318   return NULL;
5319 }
5320
5321 /* Evaluate a spec function.  */
5322
5323 static const char *
5324 eval_spec_function (const char *func, const char *args)
5325 {
5326   const struct spec_function *sf;
5327   const char *funcval;
5328
5329   /* Saved spec processing context.  */
5330   int save_argbuf_index;
5331   int save_argbuf_length;
5332   const char **save_argbuf;
5333
5334   int save_arg_going;
5335   int save_delete_this_arg;
5336   int save_this_is_output_file;
5337   int save_this_is_library_file;
5338   int save_input_from_pipe;
5339   const char *save_suffix_subst;
5340
5341
5342   sf = lookup_spec_function (func);
5343   if (sf == NULL)
5344     fatal ("unknown spec function '%s'", func);
5345
5346   /* Push the spec processing context.  */
5347   save_argbuf_index = argbuf_index;
5348   save_argbuf_length = argbuf_length;
5349   save_argbuf = argbuf;
5350
5351   save_arg_going = arg_going;
5352   save_delete_this_arg = delete_this_arg;
5353   save_this_is_output_file = this_is_output_file;
5354   save_this_is_library_file = this_is_library_file;
5355   save_input_from_pipe = input_from_pipe;
5356   save_suffix_subst = suffix_subst;
5357
5358   /* Create a new spec processing context, and build the function
5359      arguments.  */
5360
5361   alloc_args ();
5362   if (do_spec_2 (args) < 0)
5363     fatal ("error in args to spec function '%s'", func);
5364
5365   /* argbuf_index is an index for the next argument to be inserted, and
5366      so contains the count of the args already inserted.  */
5367
5368   funcval = (*sf->func) (argbuf_index, argbuf);
5369
5370   /* Pop the spec processing context.  */
5371   argbuf_index = save_argbuf_index;
5372   argbuf_length = save_argbuf_length;
5373   free (argbuf);
5374   argbuf = save_argbuf;
5375
5376   arg_going = save_arg_going;
5377   delete_this_arg = save_delete_this_arg;
5378   this_is_output_file = save_this_is_output_file;
5379   this_is_library_file = save_this_is_library_file;
5380   input_from_pipe = save_input_from_pipe;
5381   suffix_subst = save_suffix_subst;
5382
5383   return funcval;
5384 }
5385
5386 /* Handle a spec function call of the form:
5387
5388    %:function(args)
5389
5390    ARGS is processed as a spec in a separate context and split into an
5391    argument vector in the normal fashion.  The function returns a string
5392    containing a spec which we then process in the caller's context, or
5393    NULL if no processing is required.  */
5394
5395 static const char *
5396 handle_spec_function (const char *p)
5397 {
5398   char *func, *args;
5399   const char *endp, *funcval;
5400   int count;
5401
5402   processing_spec_function++;
5403
5404   /* Get the function name.  */
5405   for (endp = p; *endp != '\0'; endp++)
5406     {
5407       if (*endp == '(')         /* ) */
5408         break;
5409       /* Only allow [A-Za-z0-9], -, and _ in function names.  */
5410       if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_'))
5411         fatal ("malformed spec function name");
5412     }
5413   if (*endp != '(')             /* ) */
5414     fatal ("no arguments for spec function");
5415   func = save_string (p, endp - p);
5416   p = ++endp;
5417
5418   /* Get the arguments.  */
5419   for (count = 0; *endp != '\0'; endp++)
5420     {
5421       /* ( */
5422       if (*endp == ')')
5423         {
5424           if (count == 0)
5425             break;
5426           count--;
5427         }
5428       else if (*endp == '(')    /* ) */
5429         count++;
5430     }
5431   /* ( */
5432   if (*endp != ')')
5433     fatal ("malformed spec function arguments");
5434   args = save_string (p, endp - p);
5435   p = ++endp;
5436
5437   /* p now points to just past the end of the spec function expression.  */
5438
5439   funcval = eval_spec_function (func, args);
5440   if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0)
5441     p = NULL;
5442
5443   free (func);
5444   free (args);
5445
5446   processing_spec_function--;
5447
5448   return p;
5449 }
5450
5451 /* Inline subroutine of handle_braces.  Returns true if the current
5452    input suffix matches the atom bracketed by ATOM and END_ATOM.  */
5453 static inline bool
5454 input_suffix_matches (const char *atom, const char *end_atom)
5455 {
5456   /* We special case the semantics of {.s:...} and {.S:...} and their
5457      negative variants.  Instead of testing the input filename suffix,
5458      we test whether the input source file is an assembler file or an
5459      assembler-with-cpp file respectively.  This allows us to correctly
5460      handle the -x command line option.  */
5461
5462   if (atom + 1 == end_atom
5463       && input_file_compiler
5464       && input_file_compiler->suffix)
5465     {
5466       if (*atom == 's')
5467         return !strcmp (input_file_compiler->suffix, "@assembler");
5468       if (*atom == 'S')
5469         return !strcmp (input_file_compiler->suffix, "@assembler-with-cpp");
5470     }
5471
5472   return (input_suffix
5473           && !strncmp (input_suffix, atom, end_atom - atom)
5474           && input_suffix[end_atom - atom] == '\0');
5475 }
5476
5477 /* Inline subroutine of handle_braces.  Returns true if a switch
5478    matching the atom bracketed by ATOM and END_ATOM appeared on the
5479    command line.  */
5480 static inline bool
5481 switch_matches (const char *atom, const char *end_atom, int starred)
5482 {
5483   int i;
5484   int len = end_atom - atom;
5485   int plen = starred ? len : -1;
5486
5487   for (i = 0; i < n_switches; i++)
5488     if (!strncmp (switches[i].part1, atom, len)
5489         && (starred || switches[i].part1[len] == '\0')
5490         && check_live_switch (i, plen))
5491       return true;
5492
5493   return false;
5494 }
5495
5496 /* Inline subroutine of handle_braces.  Mark all of the switches which
5497    match ATOM (extends to END_ATOM; STARRED indicates whether there
5498    was a star after the atom) for later processing.  */
5499 static inline void
5500 mark_matching_switches (const char *atom, const char *end_atom, int starred)
5501 {
5502   int i;
5503   int len = end_atom - atom;
5504   int plen = starred ? len : -1;
5505
5506   for (i = 0; i < n_switches; i++)
5507     if (!strncmp (switches[i].part1, atom, len)
5508         && (starred || switches[i].part1[len] == '\0')
5509         && check_live_switch (i, plen))
5510       switches[i].ordering = 1;
5511 }
5512
5513 /* Inline subroutine of handle_braces.  Process all the currently
5514    marked switches through give_switch, and clear the marks.  */
5515 static inline void
5516 process_marked_switches (void)
5517 {
5518   int i;
5519
5520   for (i = 0; i < n_switches; i++)
5521     if (switches[i].ordering == 1)
5522       {
5523         switches[i].ordering = 0;
5524         give_switch (i, 0);
5525       }
5526 }
5527
5528 /* Handle a %{ ... } construct.  P points just inside the leading {.
5529    Returns a pointer one past the end of the brace block, or 0
5530    if we call do_spec_1 and that returns -1.  */
5531
5532 static const char *
5533 handle_braces (const char *p)
5534 {
5535   const char *atom, *end_atom;
5536   const char *d_atom = NULL, *d_end_atom = NULL;
5537   const char *orig = p;
5538
5539   bool a_is_suffix;
5540   bool a_is_starred;
5541   bool a_is_negated;
5542   bool a_matched;
5543
5544   bool a_must_be_last = false;
5545   bool ordered_set    = false;
5546   bool disjunct_set   = false;
5547   bool disj_matched   = false;
5548   bool disj_starred   = true;
5549   bool n_way_choice   = false;
5550   bool n_way_matched  = false;
5551
5552 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
5553
5554   do
5555     {
5556       if (a_must_be_last)
5557         goto invalid;
5558
5559       /* Scan one "atom" (S in the description above of %{}, possibly
5560          with !, ., or * modifiers).  */
5561       a_matched = a_is_suffix = a_is_starred = a_is_negated = false;
5562
5563       SKIP_WHITE();
5564       if (*p == '!')
5565         p++, a_is_negated = true;
5566
5567       SKIP_WHITE();
5568       if (*p == '.')
5569         p++, a_is_suffix = true;
5570
5571       atom = p;
5572       while (ISIDNUM(*p) || *p == '-' || *p == '+' || *p == '='
5573              || *p == ',' || *p == '.' || *p == '@')
5574         p++;
5575       end_atom = p;
5576
5577       if (*p == '*')
5578         p++, a_is_starred = 1;
5579
5580       SKIP_WHITE();
5581       switch (*p)
5582         {
5583         case '&': case '}':
5584           /* Substitute the switch(es) indicated by the current atom.  */
5585           ordered_set = true;
5586           if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix
5587               || atom == end_atom)
5588             goto invalid;
5589
5590           mark_matching_switches (atom, end_atom, a_is_starred);
5591
5592           if (*p == '}')
5593             process_marked_switches ();
5594           break;
5595
5596         case '|': case ':':
5597           /* Substitute some text if the current atom appears as a switch
5598              or suffix.  */
5599           disjunct_set = true;
5600           if (ordered_set)
5601             goto invalid;
5602
5603           if (atom == end_atom)
5604             {
5605               if (!n_way_choice || disj_matched || *p == '|'
5606                   || a_is_negated || a_is_suffix || a_is_starred)
5607                 goto invalid;
5608
5609               /* An empty term may appear as the last choice of an
5610                  N-way choice set; it means "otherwise".  */
5611               a_must_be_last = true;
5612               disj_matched = !n_way_matched;
5613               disj_starred = false;
5614             }
5615           else
5616             {
5617                if (a_is_suffix && a_is_starred)
5618                  goto invalid;
5619
5620                if (!a_is_starred)
5621                  disj_starred = false;
5622
5623                /* Don't bother testing this atom if we already have a
5624                   match.  */
5625                if (!disj_matched && !n_way_matched)
5626                  {
5627                    if (a_is_suffix)
5628                      a_matched = input_suffix_matches (atom, end_atom);
5629                    else
5630                      a_matched = switch_matches (atom, end_atom, a_is_starred);
5631
5632                    if (a_matched != a_is_negated)
5633                      {
5634                        disj_matched = true;
5635                        d_atom = atom;
5636                        d_end_atom = end_atom;
5637                      }
5638                  }
5639             }
5640
5641           if (*p == ':')
5642             {
5643               /* Found the body, that is, the text to substitute if the
5644                  current disjunction matches.  */
5645               p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred,
5646                                       disj_matched && !n_way_matched);
5647               if (p == 0)
5648                 return 0;
5649
5650               /* If we have an N-way choice, reset state for the next
5651                  disjunction.  */
5652               if (*p == ';')
5653                 {
5654                   n_way_choice = true;
5655                   n_way_matched |= disj_matched;
5656                   disj_matched = false;
5657                   disj_starred = true;
5658                   d_atom = d_end_atom = NULL;
5659                 }
5660             }
5661           break;
5662
5663         default:
5664           goto invalid;
5665         }
5666     }
5667   while (*p++ != '}');
5668
5669   return p;
5670
5671  invalid:
5672   fatal ("braced spec '%s' is invalid at '%c'", orig, *p);
5673
5674 #undef SKIP_WHITE
5675 }
5676
5677 /* Subroutine of handle_braces.  Scan and process a brace substitution body
5678    (X in the description of %{} syntax).  P points one past the colon;
5679    ATOM and END_ATOM bracket the first atom which was found to be true
5680    (present) in the current disjunction; STARRED indicates whether all
5681    the atoms in the current disjunction were starred (for syntax validation);
5682    MATCHED indicates whether the disjunction matched or not, and therefore
5683    whether or not the body is to be processed through do_spec_1 or just
5684    skipped.  Returns a pointer to the closing } or ;, or 0 if do_spec_1
5685    returns -1.  */
5686
5687 static const char *
5688 process_brace_body (const char *p, const char *atom, const char *end_atom,
5689                     int starred, int matched)
5690 {
5691   const char *body, *end_body;
5692   unsigned int nesting_level;
5693   bool have_subst     = false;
5694
5695   /* Locate the closing } or ;, honoring nested braces.
5696      Trim trailing whitespace.  */
5697   body = p;
5698   nesting_level = 1;
5699   for (;;)
5700     {
5701       if (*p == '{')
5702         nesting_level++;
5703       else if (*p == '}')
5704         {
5705           if (!--nesting_level)
5706             break;
5707         }
5708       else if (*p == ';' && nesting_level == 1)
5709         break;
5710       else if (*p == '%' && p[1] == '*' && nesting_level == 1)
5711         have_subst = true;
5712       else if (*p == '\0')
5713         goto invalid;
5714       p++;
5715     }
5716
5717   end_body = p;
5718   while (end_body[-1] == ' ' || end_body[-1] == '\t')
5719     end_body--;
5720
5721   if (have_subst && !starred)
5722     goto invalid;
5723
5724   if (matched)
5725     {
5726       /* Copy the substitution body to permanent storage and execute it.
5727          If have_subst is false, this is a simple matter of running the
5728          body through do_spec_1...  */
5729       char *string = save_string (body, end_body - body);
5730       if (!have_subst)
5731         {
5732           if (do_spec_1 (string, 0, NULL) < 0)
5733             return 0;
5734         }
5735       else
5736         {
5737           /* ... but if have_subst is true, we have to process the
5738              body once for each matching switch, with %* set to the
5739              variant part of the switch.  */
5740           unsigned int hard_match_len = end_atom - atom;
5741           int i;
5742
5743           for (i = 0; i < n_switches; i++)
5744             if (!strncmp (switches[i].part1, atom, hard_match_len)
5745                 && check_live_switch (i, hard_match_len))
5746               {
5747                 if (do_spec_1 (string, 0,
5748                                &switches[i].part1[hard_match_len]) < 0)
5749                   return 0;
5750                 /* Pass any arguments this switch has.  */
5751                 give_switch (i, 1);
5752                 suffix_subst = NULL;
5753               }
5754         }
5755     }
5756
5757   return p;
5758
5759  invalid:
5760   fatal ("braced spec body '%s' is invalid", body);
5761 }
5762 \f
5763 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
5764    on the command line.  PREFIX_LENGTH is the length of XXX in an {XXX*}
5765    spec, or -1 if either exact match or %* is used.
5766
5767    A -O switch is obsoleted by a later -O switch.  A -f, -m, or -W switch
5768    whose value does not begin with "no-" is obsoleted by the same value
5769    with the "no-", similarly for a switch with the "no-" prefix.  */
5770
5771 static int
5772 check_live_switch (int switchnum, int prefix_length)
5773 {
5774   const char *name = switches[switchnum].part1;
5775   int i;
5776
5777   /* In the common case of {<at-most-one-letter>*}, a negating
5778      switch would always match, so ignore that case.  We will just
5779      send the conflicting switches to the compiler phase.  */
5780   if (prefix_length >= 0 && prefix_length <= 1)
5781     return 1;
5782
5783   /* If we already processed this switch and determined if it was
5784      live or not, return our past determination.  */
5785   if (switches[switchnum].live_cond != 0)
5786     return switches[switchnum].live_cond > 0;
5787
5788   /* Now search for duplicate in a manner that depends on the name.  */
5789   switch (*name)
5790     {
5791     case 'O':
5792       for (i = switchnum + 1; i < n_switches; i++)
5793         if (switches[i].part1[0] == 'O')
5794           {
5795             switches[switchnum].validated = 1;
5796             switches[switchnum].live_cond = SWITCH_FALSE;
5797             return 0;
5798           }
5799       break;
5800
5801     case 'W':  case 'f':  case 'm':
5802       if (! strncmp (name + 1, "no-", 3))
5803         {
5804           /* We have Xno-YYY, search for XYYY.  */
5805           for (i = switchnum + 1; i < n_switches; i++)
5806             if (switches[i].part1[0] == name[0]
5807                 && ! strcmp (&switches[i].part1[1], &name[4]))
5808               {
5809                 switches[switchnum].validated = 1;
5810                 switches[switchnum].live_cond = SWITCH_FALSE;
5811                 return 0;
5812               }
5813         }
5814       else
5815         {
5816           /* We have XYYY, search for Xno-YYY.  */
5817           for (i = switchnum + 1; i < n_switches; i++)
5818             if (switches[i].part1[0] == name[0]
5819                 && switches[i].part1[1] == 'n'
5820                 && switches[i].part1[2] == 'o'
5821                 && switches[i].part1[3] == '-'
5822                 && !strcmp (&switches[i].part1[4], &name[1]))
5823               {
5824                 switches[switchnum].validated = 1;
5825                 switches[switchnum].live_cond = SWITCH_FALSE;
5826                 return 0;
5827               }
5828         }
5829       break;
5830     }
5831
5832   /* Otherwise the switch is live.  */
5833   switches[switchnum].live_cond = SWITCH_LIVE;
5834   return 1;
5835 }
5836 \f
5837 /* Pass a switch to the current accumulating command
5838    in the same form that we received it.
5839    SWITCHNUM identifies the switch; it is an index into
5840    the vector of switches gcc received, which is `switches'.
5841    This cannot fail since it never finishes a command line.
5842
5843    If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument.  */
5844
5845 static void
5846 give_switch (int switchnum, int omit_first_word)
5847 {
5848   if (switches[switchnum].live_cond == SWITCH_IGNORE)
5849     return;
5850
5851   if (!omit_first_word)
5852     {
5853       do_spec_1 ("-", 0, NULL);
5854       do_spec_1 (switches[switchnum].part1, 1, NULL);
5855     }
5856
5857   if (switches[switchnum].args != 0)
5858     {
5859       const char **p;
5860       for (p = switches[switchnum].args; *p; p++)
5861         {
5862           const char *arg = *p;
5863
5864           do_spec_1 (" ", 0, NULL);
5865           if (suffix_subst)
5866             {
5867               unsigned length = strlen (arg);
5868               int dot = 0;
5869
5870               while (length-- && !IS_DIR_SEPARATOR (arg[length]))
5871                 if (arg[length] == '.')
5872                   {
5873                     ((char *)arg)[length] = 0;
5874                     dot = 1;
5875                     break;
5876                   }
5877               do_spec_1 (arg, 1, NULL);
5878               if (dot)
5879                 ((char *)arg)[length] = '.';
5880               do_spec_1 (suffix_subst, 1, NULL);
5881             }
5882           else
5883             do_spec_1 (arg, 1, NULL);
5884         }
5885     }
5886
5887   do_spec_1 (" ", 0, NULL);
5888   switches[switchnum].validated = 1;
5889 }
5890 \f
5891 /* Search for a file named NAME trying various prefixes including the
5892    user's -B prefix and some standard ones.
5893    Return the absolute file name found.  If nothing is found, return NAME.  */
5894
5895 static const char *
5896 find_file (const char *name)
5897 {
5898   char *newname;
5899
5900   /* Try multilib_dir if it is defined.  */
5901   if (multilib_os_dir != NULL)
5902     {
5903       newname = find_a_file (&startfile_prefixes, name, R_OK, 1);
5904
5905       /* If we don't find it in the multi library dir, then fall
5906          through and look for it in the normal places.  */
5907       if (newname != NULL)
5908         return newname;
5909     }
5910
5911   newname = find_a_file (&startfile_prefixes, name, R_OK, 0);
5912   return newname ? newname : name;
5913 }
5914
5915 /* Determine whether a directory exists.  If LINKER, return 0 for
5916    certain fixed names not needed by the linker.  If not LINKER, it is
5917    only important to return 0 if the host machine has a small ARG_MAX
5918    limit.  */
5919
5920 static int
5921 is_directory (const char *path1, const char *path2, int linker)
5922 {
5923   int len1 = strlen (path1);
5924   int len2 = strlen (path2);
5925   char *path = alloca (3 + len1 + len2);
5926   char *cp;
5927   struct stat st;
5928
5929 #ifndef SMALL_ARG_MAX
5930   if (! linker)
5931     return 1;
5932 #endif
5933
5934   /* Construct the path from the two parts.  Ensure the string ends with "/.".
5935      The resulting path will be a directory even if the given path is a
5936      symbolic link.  */
5937   memcpy (path, path1, len1);
5938   memcpy (path + len1, path2, len2);
5939   cp = path + len1 + len2;
5940   if (!IS_DIR_SEPARATOR (cp[-1]))
5941     *cp++ = DIR_SEPARATOR;
5942   *cp++ = '.';
5943   *cp = '\0';
5944
5945   /* Exclude directories that the linker is known to search.  */
5946   if (linker
5947       && ((cp - path == 6
5948            && strcmp (path, concat (dir_separator_str, "lib",
5949                                     dir_separator_str, ".", NULL)) == 0)
5950           || (cp - path == 10
5951               && strcmp (path, concat (dir_separator_str, "usr",
5952                                        dir_separator_str, "lib",
5953                                        dir_separator_str, ".", NULL)) == 0)))
5954     return 0;
5955
5956   return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
5957 }
5958
5959 /* Set up the various global variables to indicate that we're processing
5960    the input file named FILENAME.  */
5961
5962 void
5963 set_input (const char *filename)
5964 {
5965   const char *p;
5966
5967   input_filename = filename;
5968   input_filename_length = strlen (input_filename);
5969
5970   input_basename = input_filename;
5971 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
5972   /* Skip drive name so 'x:foo' is handled properly.  */
5973   if (input_basename[1] == ':')
5974     input_basename += 2;
5975 #endif
5976   for (p = input_basename; *p; p++)
5977     if (IS_DIR_SEPARATOR (*p))
5978       input_basename = p + 1;
5979
5980   /* Find a suffix starting with the last period,
5981      and set basename_length to exclude that suffix.  */
5982   basename_length = strlen (input_basename);
5983   suffixed_basename_length = basename_length;
5984   p = input_basename + basename_length;
5985   while (p != input_basename && *p != '.')
5986     --p;
5987   if (*p == '.' && p != input_basename)
5988     {
5989       basename_length = p - input_basename;
5990       input_suffix = p + 1;
5991     }
5992   else
5993     input_suffix = "";
5994
5995   /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
5996      we will need to do a stat on the input_filename.  The
5997      INPUT_STAT_SET signals that the stat is needed.  */
5998   input_stat_set = 0;
5999 }
6000 \f
6001 /* On fatal signals, delete all the temporary files.  */
6002
6003 static void
6004 fatal_error (int signum)
6005 {
6006   signal (signum, SIG_DFL);
6007   delete_failure_queue ();
6008   delete_temp_files ();
6009   /* Get the same signal again, this time not handled,
6010      so its normal effect occurs.  */
6011   kill (getpid (), signum);
6012 }
6013
6014 extern int main (int, const char **);
6015
6016 int
6017 main (int argc, const char **argv)
6018 {
6019   size_t i;
6020   int value;
6021   int linker_was_run = 0;
6022   int lang_n_infiles = 0;
6023   int num_linker_inputs = 0;
6024   char *explicit_link_files;
6025   char *specs_file;
6026   const char *p;
6027   struct user_specs *uptr;
6028
6029   p = argv[0] + strlen (argv[0]);
6030   while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
6031     --p;
6032   programname = p;
6033
6034   xmalloc_set_program_name (programname);
6035
6036 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6037   /* Perform host dependent initialization when needed.  */
6038   GCC_DRIVER_HOST_INITIALIZATION;
6039 #endif
6040
6041   /* Unlock the stdio streams.  */
6042   unlock_std_streams ();
6043
6044   gcc_init_libintl ();
6045
6046   if (signal (SIGINT, SIG_IGN) != SIG_IGN)
6047     signal (SIGINT, fatal_error);
6048 #ifdef SIGHUP
6049   if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
6050     signal (SIGHUP, fatal_error);
6051 #endif
6052   if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
6053     signal (SIGTERM, fatal_error);
6054 #ifdef SIGPIPE
6055   if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
6056     signal (SIGPIPE, fatal_error);
6057 #endif
6058 #ifdef SIGCHLD
6059   /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6060      receive the signal.  A different setting is inheritable */
6061   signal (SIGCHLD, SIG_DFL);
6062 #endif
6063
6064   /* Allocate the argument vector.  */
6065   alloc_args ();
6066
6067   obstack_init (&obstack);
6068
6069   /* Build multilib_select, et. al from the separate lines that make up each
6070      multilib selection.  */
6071   {
6072     const char *const *q = multilib_raw;
6073     int need_space;
6074
6075     obstack_init (&multilib_obstack);
6076     while ((p = *q++) != (char *) 0)
6077       obstack_grow (&multilib_obstack, p, strlen (p));
6078
6079     obstack_1grow (&multilib_obstack, 0);
6080     multilib_select = XOBFINISH (&multilib_obstack, const char *);
6081
6082     q = multilib_matches_raw;
6083     while ((p = *q++) != (char *) 0)
6084       obstack_grow (&multilib_obstack, p, strlen (p));
6085
6086     obstack_1grow (&multilib_obstack, 0);
6087     multilib_matches = XOBFINISH (&multilib_obstack, const char *);
6088
6089     q = multilib_exclusions_raw;
6090     while ((p = *q++) != (char *) 0)
6091       obstack_grow (&multilib_obstack, p, strlen (p));
6092
6093     obstack_1grow (&multilib_obstack, 0);
6094     multilib_exclusions = XOBFINISH (&multilib_obstack, const char *);
6095
6096     need_space = FALSE;
6097     for (i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++)
6098       {
6099         if (need_space)
6100           obstack_1grow (&multilib_obstack, ' ');
6101         obstack_grow (&multilib_obstack,
6102                       multilib_defaults_raw[i],
6103                       strlen (multilib_defaults_raw[i]));
6104         need_space = TRUE;
6105       }
6106
6107     obstack_1grow (&multilib_obstack, 0);
6108     multilib_defaults = XOBFINISH (&multilib_obstack, const char *);
6109   }
6110
6111   /* Set up to remember the pathname of gcc and any options
6112      needed for collect.  We use argv[0] instead of programname because
6113      we need the complete pathname.  */
6114   obstack_init (&collect_obstack);
6115   obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
6116   obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1);
6117   putenv (XOBFINISH (&collect_obstack, char *));
6118
6119 #ifdef INIT_ENVIRONMENT
6120   /* Set up any other necessary machine specific environment variables.  */
6121   putenv (INIT_ENVIRONMENT);
6122 #endif
6123
6124   /* Make a table of what switches there are (switches, n_switches).
6125      Make a table of specified input files (infiles, n_infiles).
6126      Decode switches that are handled locally.  */
6127
6128   process_command (argc, argv);
6129
6130   /* Initialize the vector of specs to just the default.
6131      This means one element containing 0s, as a terminator.  */
6132
6133   compilers = xmalloc (sizeof default_compilers);
6134   memcpy (compilers, default_compilers, sizeof default_compilers);
6135   n_compilers = n_default_compilers;
6136
6137   /* Read specs from a file if there is one.  */
6138
6139   machine_suffix = concat (spec_machine, dir_separator_str,
6140                            spec_version, dir_separator_str, NULL);
6141   just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
6142
6143   specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, 0);
6144   /* Read the specs file unless it is a default one.  */
6145   if (specs_file != 0 && strcmp (specs_file, "specs"))
6146     read_specs (specs_file, TRUE);
6147   else
6148     init_spec ();
6149
6150   /* We need to check standard_exec_prefix/just_machine_suffix/specs
6151      for any override of as, ld and libraries.  */
6152   specs_file = alloca (strlen (standard_exec_prefix)
6153                        + strlen (just_machine_suffix) + sizeof ("specs"));
6154
6155   strcpy (specs_file, standard_exec_prefix);
6156   strcat (specs_file, just_machine_suffix);
6157   strcat (specs_file, "specs");
6158   if (access (specs_file, R_OK) == 0)
6159     read_specs (specs_file, TRUE);
6160
6161   /* Process any configure-time defaults specified for the command line
6162      options, via OPTION_DEFAULT_SPECS.  */
6163   for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
6164     do_option_spec (option_default_specs[i].name,
6165                     option_default_specs[i].spec);
6166
6167   /* Process DRIVER_SELF_SPECS, adding any new options to the end
6168      of the command line.  */
6169
6170   for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++)
6171     do_self_spec (driver_self_specs[i]);
6172
6173   /* If not cross-compiling, look for executables in the standard
6174      places.  */
6175   if (*cross_compile == '0')
6176     {
6177       if (*md_exec_prefix)
6178         {
6179           add_prefix (&exec_prefixes, md_exec_prefix, "GCC",
6180                       PREFIX_PRIORITY_LAST, 0, 0);
6181         }
6182     }
6183
6184   /* Process sysroot_suffix_spec.  */
6185   if (*sysroot_suffix_spec != 0
6186       && do_spec_2 (sysroot_suffix_spec) == 0)
6187     {
6188       if (argbuf_index > 1)
6189         error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
6190       else if (argbuf_index == 1)
6191         target_sysroot_suffix = xstrdup (argbuf[argbuf_index -1]);
6192     }
6193
6194 #ifdef HAVE_LD_SYSROOT
6195   /* Pass the --sysroot option to the linker, if it supports that.  If
6196      there is a sysroot_suffix_spec, it has already been processed by
6197      this point, so target_system_root really is the system root we
6198      should be using.  */
6199   if (target_system_root)
6200     {
6201       obstack_grow (&obstack, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
6202       obstack_grow0 (&obstack, link_spec, strlen (link_spec));
6203       set_spec ("link", XOBFINISH (&obstack, const char *));
6204     }
6205 #endif
6206
6207   /* Process sysroot_hdrs_suffix_spec.  */
6208   if (*sysroot_hdrs_suffix_spec != 0
6209       && do_spec_2 (sysroot_hdrs_suffix_spec) == 0)
6210     {
6211       if (argbuf_index > 1)
6212         error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
6213       else if (argbuf_index == 1)
6214         target_sysroot_hdrs_suffix = xstrdup (argbuf[argbuf_index -1]);
6215     }
6216
6217   /* Look for startfiles in the standard places.  */
6218   if (*startfile_prefix_spec != 0
6219       && do_spec_2 (startfile_prefix_spec) == 0
6220       && do_spec_1 (" ", 0, NULL) == 0)
6221     {
6222       int ndx;
6223       for (ndx = 0; ndx < argbuf_index; ndx++)
6224         add_sysrooted_prefix (&startfile_prefixes, argbuf[ndx], "BINUTILS",
6225                               PREFIX_PRIORITY_LAST, 0, 1);
6226     }
6227   /* We should eventually get rid of all these and stick to
6228      startfile_prefix_spec exclusively.  */
6229   else if (*cross_compile == '0' || target_system_root)
6230     {
6231       if (*md_startfile_prefix)
6232         add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix,
6233                               "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6234
6235       if (*md_startfile_prefix_1)
6236         add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix_1,
6237                               "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6238
6239       /* If standard_startfile_prefix is relative, base it on
6240          standard_exec_prefix.  This lets us move the installed tree
6241          as a unit.  If GCC_EXEC_PREFIX is defined, base
6242          standard_startfile_prefix on that as well.
6243
6244          If the prefix is relative, only search it for native compilers;
6245          otherwise we will search a directory containing host libraries.  */
6246       if (IS_ABSOLUTE_PATH (standard_startfile_prefix))
6247         add_sysrooted_prefix (&startfile_prefixes,
6248                               standard_startfile_prefix, "BINUTILS",
6249                               PREFIX_PRIORITY_LAST, 0, 1);
6250       else if (*cross_compile == '0')
6251         {
6252           if (gcc_exec_prefix)
6253             add_prefix (&startfile_prefixes,
6254                         concat (gcc_exec_prefix, machine_suffix,
6255                                 standard_startfile_prefix, NULL),
6256                         NULL, PREFIX_PRIORITY_LAST, 0, 1);
6257           add_prefix (&startfile_prefixes,
6258                       concat (standard_exec_prefix,
6259                               machine_suffix,
6260                               standard_startfile_prefix, NULL),
6261                       NULL, PREFIX_PRIORITY_LAST, 0, 1);
6262         }
6263
6264       if (*standard_startfile_prefix_1)
6265         add_sysrooted_prefix (&startfile_prefixes,
6266                               standard_startfile_prefix_1, "BINUTILS",
6267                               PREFIX_PRIORITY_LAST, 0, 1);
6268       if (*standard_startfile_prefix_2)
6269         add_sysrooted_prefix (&startfile_prefixes,
6270                               standard_startfile_prefix_2, "BINUTILS",
6271                               PREFIX_PRIORITY_LAST, 0, 1);
6272     }
6273
6274   /* Process any user specified specs in the order given on the command
6275      line.  */
6276   for (uptr = user_specs_head; uptr; uptr = uptr->next)
6277     {
6278       char *filename = find_a_file (&startfile_prefixes, uptr->filename,
6279                                     R_OK, 0);
6280       read_specs (filename ? filename : uptr->filename, FALSE);
6281     }
6282
6283   /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake.  */
6284   if (gcc_exec_prefix)
6285     gcc_exec_prefix = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
6286                               spec_version, dir_separator_str, NULL);
6287
6288   /* Now we have the specs.
6289      Set the `valid' bits for switches that match anything in any spec.  */
6290
6291   validate_all_switches ();
6292
6293   /* Now that we have the switches and the specs, set
6294      the subdirectory based on the options.  */
6295   set_multilib_dir ();
6296
6297   /* Warn about any switches that no pass was interested in.  */
6298
6299   for (i = 0; (int) i < n_switches; i++)
6300     if (! switches[i].validated)
6301       error ("unrecognized option '-%s'", switches[i].part1);
6302
6303   /* Obey some of the options.  */
6304
6305   if (print_search_dirs)
6306     {
6307       printf (_("install: %s%s\n"), standard_exec_prefix, machine_suffix);
6308       printf (_("programs: %s\n"), build_search_list (&exec_prefixes, "", 0));
6309       printf (_("libraries: %s\n"), build_search_list (&startfile_prefixes, "", 0));
6310       return (0);
6311     }
6312
6313   if (print_file_name)
6314     {
6315       printf ("%s\n", find_file (print_file_name));
6316       return (0);
6317     }
6318
6319   if (print_prog_name)
6320     {
6321       char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK, 0);
6322       printf ("%s\n", (newname ? newname : print_prog_name));
6323       return (0);
6324     }
6325
6326   if (print_multi_lib)
6327     {
6328       print_multilib_info ();
6329       return (0);
6330     }
6331
6332   if (print_multi_directory)
6333     {
6334       if (multilib_dir == NULL)
6335         printf (".\n");
6336       else
6337         printf ("%s\n", multilib_dir);
6338       return (0);
6339     }
6340
6341   if (print_multi_os_directory)
6342     {
6343       if (multilib_os_dir == NULL)
6344         printf (".\n");
6345       else
6346         printf ("%s\n", multilib_os_dir);
6347       return (0);
6348     }
6349
6350   if (target_help_flag)
6351    {
6352       /* Print if any target specific options.  */
6353
6354       /* We do not exit here. Instead we have created a fake input file
6355          called 'target-dummy' which needs to be compiled, and we pass this
6356          on to the various sub-processes, along with the --target-help
6357          switch.  */
6358     }
6359
6360   if (print_help_list)
6361     {
6362       display_help ();
6363
6364       if (! verbose_flag)
6365         {
6366           printf (_("\nFor bug reporting instructions, please see:\n"));
6367           printf ("%s.\n", bug_report_url);
6368
6369           return (0);
6370         }
6371
6372       /* We do not exit here.  Instead we have created a fake input file
6373          called 'help-dummy' which needs to be compiled, and we pass this
6374          on the various sub-processes, along with the --help switch.  */
6375     }
6376
6377   if (verbose_flag)
6378     {
6379       int n;
6380       const char *thrmod;
6381
6382       notice ("Target: %s\n", spec_machine);
6383       notice ("Configured with: %s\n", configuration_arguments);
6384
6385 #ifdef THREAD_MODEL_SPEC
6386       /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
6387          but there's no point in doing all this processing just to get
6388          thread_model back.  */
6389       obstack_init (&obstack);
6390       do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model);
6391       obstack_1grow (&obstack, '\0');
6392       thrmod = XOBFINISH (&obstack, const char *);
6393 #else
6394       thrmod = thread_model;
6395 #endif
6396
6397       notice ("Thread model: %s\n", thrmod);
6398
6399       /* compiler_version is truncated at the first space when initialized
6400          from version string, so truncate version_string at the first space
6401          before comparing.  */
6402       for (n = 0; version_string[n]; n++)
6403         if (version_string[n] == ' ')
6404           break;
6405
6406       if (! strncmp (version_string, compiler_version, n)
6407           && compiler_version[n] == 0)
6408         notice ("gcc version %s\n", version_string);
6409       else
6410         notice ("gcc driver version %s executing gcc version %s\n",
6411                 version_string, compiler_version);
6412
6413       if (n_infiles == 0)
6414         return (0);
6415     }
6416
6417   if (n_infiles == added_libraries)
6418     fatal ("no input files");
6419
6420   /* Make a place to record the compiler output file names
6421      that correspond to the input files.  */
6422
6423   i = n_infiles;
6424   i += lang_specific_extra_outfiles;
6425   outfiles = xcalloc (i, sizeof (char *));
6426
6427   /* Record which files were specified explicitly as link input.  */
6428
6429   explicit_link_files = xcalloc (1, n_infiles);
6430
6431   if (combine_flag)
6432     combine_inputs = true;
6433   else
6434     combine_inputs = false;
6435
6436   for (i = 0; (int) i < n_infiles; i++)
6437     {
6438       const char *name = infiles[i].name;
6439       struct compiler *compiler = lookup_compiler (name,
6440                                                    strlen (name),
6441                                                    infiles[i].language);
6442
6443       if (compiler && !(compiler->combinable))
6444         combine_inputs = false;
6445
6446       if (lang_n_infiles > 0 && compiler != input_file_compiler
6447           && infiles[i].language && infiles[i].language[0] != '*')
6448         infiles[i].incompiler = compiler;
6449       else if (compiler)
6450         {
6451           lang_n_infiles++;
6452           input_file_compiler = compiler;
6453           infiles[i].incompiler = compiler;
6454         }
6455       else
6456         {
6457           /* Since there is no compiler for this input file, assume it is a
6458              linker file.  */
6459           explicit_link_files[i] = 1;
6460           infiles[i].incompiler = NULL;
6461         }
6462       infiles[i].compiled = false;
6463       infiles[i].preprocessed = false;
6464     }
6465
6466   if (!combine_inputs && have_c && have_o && lang_n_infiles > 1)
6467    fatal ("cannot specify -o with -c or -S with multiple files");
6468
6469   if (combine_flag && save_temps_flag)
6470     {
6471       bool save_combine_inputs = combine_inputs;
6472       /* Must do a separate pre-processing pass for C & Objective-C files, to
6473          obtain individual .i files.  */
6474
6475       combine_inputs = false;
6476       for (i = 0; (int) i < n_infiles; i++)
6477         {
6478           int this_file_error = 0;
6479
6480           input_file_number = i;
6481           set_input (infiles[i].name);
6482           if (infiles[i].incompiler
6483               && (infiles[i].incompiler)->needs_preprocessing)
6484             input_file_compiler = infiles[i].incompiler;
6485           else
6486             continue;
6487
6488           if (input_file_compiler)
6489             {
6490               if (input_file_compiler->spec[0] == '#')
6491                 {
6492                   error ("%s: %s compiler not installed on this system",
6493                          input_filename, &input_file_compiler->spec[1]);
6494                   this_file_error = 1;
6495                 }
6496               else
6497                 {
6498                   value = do_spec (input_file_compiler->spec);
6499                   infiles[i].preprocessed = true;
6500                   if (!have_o_argbuf_index)
6501                     fatal ("spec '%s' is invalid", input_file_compiler->spec);
6502                   infiles[i].name = argbuf[have_o_argbuf_index];
6503                   infiles[i].incompiler
6504                     = lookup_compiler (infiles[i].name,
6505                                        strlen (infiles[i].name),
6506                                        infiles[i].language);
6507
6508                   if (value < 0)
6509                     this_file_error = 1;
6510                 }
6511             }
6512
6513           if (this_file_error)
6514             {
6515               delete_failure_queue ();
6516               error_count++;
6517               break;
6518             }
6519           clear_failure_queue ();
6520         }
6521       combine_inputs = save_combine_inputs;
6522     }
6523
6524   for (i = 0; (int) i < n_infiles; i++)
6525     {
6526       int this_file_error = 0;
6527
6528       /* Tell do_spec what to substitute for %i.  */
6529
6530       input_file_number = i;
6531       set_input (infiles[i].name);
6532
6533       if (infiles[i].compiled)
6534         continue;
6535
6536       /* Use the same thing in %o, unless cp->spec says otherwise.  */
6537
6538       outfiles[i] = input_filename;
6539
6540       /* Figure out which compiler from the file's suffix.  */
6541
6542       if (! combine_inputs)
6543         input_file_compiler
6544           = lookup_compiler (infiles[i].name, input_filename_length,
6545                              infiles[i].language);
6546       else
6547         input_file_compiler = infiles[i].incompiler;
6548
6549       if (input_file_compiler)
6550         {
6551           /* Ok, we found an applicable compiler.  Run its spec.  */
6552
6553           if (input_file_compiler->spec[0] == '#')
6554             {
6555               error ("%s: %s compiler not installed on this system",
6556                      input_filename, &input_file_compiler->spec[1]);
6557               this_file_error = 1;
6558             }
6559           else
6560             {
6561               value = do_spec (input_file_compiler->spec);
6562               infiles[i].compiled = true;
6563               if (value < 0)
6564                 this_file_error = 1;
6565             }
6566         }
6567
6568       /* If this file's name does not contain a recognized suffix,
6569          record it as explicit linker input.  */
6570
6571       else
6572         explicit_link_files[i] = 1;
6573
6574       /* Clear the delete-on-failure queue, deleting the files in it
6575          if this compilation failed.  */
6576
6577       if (this_file_error)
6578         {
6579           delete_failure_queue ();
6580           error_count++;
6581         }
6582       /* If this compilation succeeded, don't delete those files later.  */
6583       clear_failure_queue ();
6584     }
6585
6586   /* Reset the input file name to the first compile/object file name, for use
6587      with %b in LINK_SPEC. We use the first input file that we can find
6588      a compiler to compile it instead of using infiles.language since for
6589      languages other than C we use aliases that we then lookup later.  */
6590   if (n_infiles > 0)
6591     {
6592       int i;
6593
6594       for (i = 0; i < n_infiles ; i++)
6595         if (infiles[i].language && infiles[i].language[0] != '*')
6596           {
6597             set_input (infiles[i].name);
6598             break;
6599           }
6600     }
6601
6602   if (error_count == 0)
6603     {
6604       /* Make sure INPUT_FILE_NUMBER points to first available open
6605          slot.  */
6606       input_file_number = n_infiles;
6607       if (lang_specific_pre_link ())
6608         error_count++;
6609     }
6610
6611   /* Determine if there are any linker input files.  */
6612   num_linker_inputs = 0;
6613   for (i = 0; (int) i < n_infiles; i++)
6614     if (explicit_link_files[i] || outfiles[i] != NULL)
6615       num_linker_inputs++;
6616
6617   /* Run ld to link all the compiler output files.  */
6618
6619   if (num_linker_inputs > 0 && error_count == 0)
6620     {
6621       int tmp = execution_count;
6622
6623       /* We'll use ld if we can't find collect2.  */
6624       if (! strcmp (linker_name_spec, "collect2"))
6625         {
6626           char *s = find_a_file (&exec_prefixes, "collect2", X_OK, 0);
6627           if (s == NULL)
6628             linker_name_spec = "ld";
6629         }
6630       /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
6631          for collect.  */
6632       putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH");
6633       putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV);
6634
6635       value = do_spec (link_command_spec);
6636       if (value < 0)
6637         error_count = 1;
6638       linker_was_run = (tmp != execution_count);
6639     }
6640
6641   /* If options said don't run linker,
6642      complain about input files to be given to the linker.  */
6643
6644   if (! linker_was_run && error_count == 0)
6645     for (i = 0; (int) i < n_infiles; i++)
6646       if (explicit_link_files[i])
6647         error ("%s: linker input file unused because linking not done",
6648                outfiles[i]);
6649
6650   /* Delete some or all of the temporary files we made.  */
6651
6652   if (error_count)
6653     delete_failure_queue ();
6654   delete_temp_files ();
6655
6656   if (print_help_list)
6657     {
6658       printf (("\nFor bug reporting instructions, please see:\n"));
6659       printf ("%s\n", bug_report_url);
6660     }
6661
6662   return (signal_count != 0 ? 2
6663           : error_count > 0 ? (pass_exit_codes ? greatest_status : 1)
6664           : 0);
6665 }
6666
6667 /* Find the proper compilation spec for the file name NAME,
6668    whose length is LENGTH.  LANGUAGE is the specified language,
6669    or 0 if this file is to be passed to the linker.  */
6670
6671 static struct compiler *
6672 lookup_compiler (const char *name, size_t length, const char *language)
6673 {
6674   struct compiler *cp;
6675
6676   /* If this was specified by the user to be a linker input, indicate that.  */
6677   if (language != 0 && language[0] == '*')
6678     return 0;
6679
6680   /* Otherwise, look for the language, if one is spec'd.  */
6681   if (language != 0)
6682     {
6683       for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
6684         if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
6685           return cp;
6686
6687       error ("language %s not recognized", language);
6688       return 0;
6689     }
6690
6691   /* Look for a suffix.  */
6692   for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
6693     {
6694       if (/* The suffix `-' matches only the file name `-'.  */
6695           (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
6696           || (strlen (cp->suffix) < length
6697               /* See if the suffix matches the end of NAME.  */
6698               && !strcmp (cp->suffix,
6699                           name + length - strlen (cp->suffix))
6700          ))
6701         break;
6702     }
6703
6704 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
6705   /* Look again, but case-insensitively this time.  */
6706   if (cp < compilers)
6707     for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
6708       {
6709         if (/* The suffix `-' matches only the file name `-'.  */
6710             (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
6711             || (strlen (cp->suffix) < length
6712                 /* See if the suffix matches the end of NAME.  */
6713                 && ((!strcmp (cp->suffix,
6714                              name + length - strlen (cp->suffix))
6715                      || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
6716                     && !strcasecmp (cp->suffix,
6717                                     name + length - strlen (cp->suffix)))
6718            ))
6719           break;
6720       }
6721 #endif
6722
6723   if (cp >= compilers)
6724     {
6725       if (cp->spec[0] != '@')
6726         /* A non-alias entry: return it.  */
6727         return cp;
6728
6729       /* An alias entry maps a suffix to a language.
6730          Search for the language; pass 0 for NAME and LENGTH
6731          to avoid infinite recursion if language not found.  */
6732       return lookup_compiler (NULL, 0, cp->spec + 1);
6733     }
6734   return 0;
6735 }
6736 \f
6737 static char *
6738 save_string (const char *s, int len)
6739 {
6740   char *result = xmalloc (len + 1);
6741
6742   memcpy (result, s, len);
6743   result[len] = 0;
6744   return result;
6745 }
6746
6747 void
6748 pfatal_with_name (const char *name)
6749 {
6750   perror_with_name (name);
6751   delete_temp_files ();
6752   exit (1);
6753 }
6754
6755 static void
6756 perror_with_name (const char *name)
6757 {
6758   error ("%s: %s", name, xstrerror (errno));
6759 }
6760
6761 /* Output an error message and exit.  */
6762
6763 void
6764 fancy_abort (const char *file, int line, const char *func)
6765 {
6766   fatal ("internal gcc abort in %s, at %s:%d", func, file, line);
6767 }
6768 \f
6769 /* Output an error message and exit.  */
6770
6771 void
6772 fatal (const char *cmsgid, ...)
6773 {
6774   va_list ap;
6775
6776   va_start (ap, cmsgid);
6777
6778   fprintf (stderr, "%s: ", programname);
6779   vfprintf (stderr, _(cmsgid), ap);
6780   va_end (ap);
6781   fprintf (stderr, "\n");
6782   delete_temp_files ();
6783   exit (1);
6784 }
6785
6786 /* The argument is actually c-format, not gcc-internal-format,
6787    but because functions with identical names are used through
6788    the rest of the compiler with gcc-internal-format, we just
6789    need to hope all users of these functions use the common
6790    subset between c-format and gcc-internal-format.  */
6791
6792 void
6793 error (const char *gmsgid, ...)
6794 {
6795   va_list ap;
6796
6797   va_start (ap, gmsgid);
6798   fprintf (stderr, "%s: ", programname);
6799   vfprintf (stderr, _(gmsgid), ap);
6800   va_end (ap);
6801
6802   fprintf (stderr, "\n");
6803 }
6804
6805 static void
6806 notice (const char *cmsgid, ...)
6807 {
6808   va_list ap;
6809
6810   va_start (ap, cmsgid);
6811   vfprintf (stderr, _(cmsgid), ap);
6812   va_end (ap);
6813 }
6814 \f
6815 static inline void
6816 validate_switches_from_spec (const char *spec)
6817 {
6818   const char *p = spec;
6819   char c;
6820   while ((c = *p++))
6821     if (c == '%' && (*p == '{' || *p == '<' || (*p == 'W' && *++p == '{')))
6822       /* We have a switch spec.  */
6823       p = validate_switches (p + 1);
6824 }
6825
6826 static void
6827 validate_all_switches (void)
6828 {
6829   struct compiler *comp;
6830   struct spec_list *spec;
6831
6832   for (comp = compilers; comp->spec; comp++)
6833     validate_switches_from_spec (comp->spec);
6834
6835   /* Look through the linked list of specs read from the specs file.  */
6836   for (spec = specs; spec; spec = spec->next)
6837     validate_switches_from_spec (*spec->ptr_spec);
6838
6839   validate_switches_from_spec (link_command_spec);
6840 }
6841
6842 /* Look at the switch-name that comes after START
6843    and mark as valid all supplied switches that match it.  */
6844
6845 static const char *
6846 validate_switches (const char *start)
6847 {
6848   const char *p = start;
6849   const char *atom;
6850   size_t len;
6851   int i;
6852   bool suffix = false;
6853   bool starred = false;
6854
6855 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
6856
6857 next_member:
6858   SKIP_WHITE ();
6859
6860   if (*p == '!')
6861     p++;
6862
6863   SKIP_WHITE ();
6864   if (*p == '.')
6865     suffix = true, p++;
6866
6867   atom = p;
6868   while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
6869          || *p == ',' || *p == '.' || *p == '@')
6870     p++;
6871   len = p - atom;
6872
6873   if (*p == '*')
6874     starred = true, p++;
6875
6876   SKIP_WHITE ();
6877
6878   if (!suffix)
6879     {
6880       /* Mark all matching switches as valid.  */
6881       for (i = 0; i < n_switches; i++)
6882         if (!strncmp (switches[i].part1, atom, len)
6883             && (starred || switches[i].part1[len] == 0))
6884           switches[i].validated = 1;
6885     }
6886
6887   if (*p) p++;
6888   if (*p && (p[-1] == '|' || p[-1] == '&'))
6889     goto next_member;
6890
6891   if (*p && p[-1] == ':')
6892     {
6893       while (*p && *p != ';' && *p != '}')
6894         {
6895           if (*p == '%')
6896             {
6897               p++;
6898               if (*p == '{' || *p == '<')
6899                 p = validate_switches (p+1);
6900               else if (p[0] == 'W' && p[1] == '{')
6901                 p = validate_switches (p+2);
6902             }
6903           else
6904             p++;
6905         }
6906
6907       if (*p) p++;
6908       if (*p && p[-1] == ';')
6909         goto next_member;
6910     }
6911
6912   return p;
6913 #undef SKIP_WHITE
6914 }
6915 \f
6916 struct mdswitchstr
6917 {
6918   const char *str;
6919   int len;
6920 };
6921
6922 static struct mdswitchstr *mdswitches;
6923 static int n_mdswitches;
6924
6925 /* Check whether a particular argument was used.  The first time we
6926    canonicalize the switches to keep only the ones we care about.  */
6927
6928 static int
6929 used_arg (const char *p, int len)
6930 {
6931   struct mswitchstr
6932   {
6933     const char *str;
6934     const char *replace;
6935     int len;
6936     int rep_len;
6937   };
6938
6939   static struct mswitchstr *mswitches;
6940   static int n_mswitches;
6941   int i, j;
6942
6943   if (!mswitches)
6944     {
6945       struct mswitchstr *matches;
6946       const char *q;
6947       int cnt = 0;
6948
6949       /* Break multilib_matches into the component strings of string
6950          and replacement string.  */
6951       for (q = multilib_matches; *q != '\0'; q++)
6952         if (*q == ';')
6953           cnt++;
6954
6955       matches = alloca ((sizeof (struct mswitchstr)) * cnt);
6956       i = 0;
6957       q = multilib_matches;
6958       while (*q != '\0')
6959         {
6960           matches[i].str = q;
6961           while (*q != ' ')
6962             {
6963               if (*q == '\0')
6964                 {
6965                 invalid_matches:
6966                   fatal ("multilib spec '%s' is invalid", multilib_matches);
6967                 }
6968               q++;
6969             }
6970           matches[i].len = q - matches[i].str;
6971
6972           matches[i].replace = ++q;
6973           while (*q != ';' && *q != '\0')
6974             {
6975               if (*q == ' ')
6976                 goto invalid_matches;
6977               q++;
6978             }
6979           matches[i].rep_len = q - matches[i].replace;
6980           i++;
6981           if (*q == ';')
6982             q++;
6983         }
6984
6985       /* Now build a list of the replacement string for switches that we care
6986          about.  Make sure we allocate at least one entry.  This prevents
6987          xmalloc from calling fatal, and prevents us from re-executing this
6988          block of code.  */
6989       mswitches
6990         = xmalloc (sizeof (struct mswitchstr)
6991                    * (n_mdswitches + (n_switches ? n_switches : 1)));
6992       for (i = 0; i < n_switches; i++)
6993         if (switches[i].live_cond != SWITCH_IGNORE)
6994           {
6995             int xlen = strlen (switches[i].part1);
6996             for (j = 0; j < cnt; j++)
6997               if (xlen == matches[j].len
6998                   && ! strncmp (switches[i].part1, matches[j].str, xlen))
6999                 {
7000                   mswitches[n_mswitches].str = matches[j].replace;
7001                   mswitches[n_mswitches].len = matches[j].rep_len;
7002                   mswitches[n_mswitches].replace = (char *) 0;
7003                   mswitches[n_mswitches].rep_len = 0;
7004                   n_mswitches++;
7005                   break;
7006                 }
7007           }
7008
7009       /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
7010          on the command line nor any options mutually incompatible with
7011          them.  */
7012       for (i = 0; i < n_mdswitches; i++)
7013         {
7014           const char *r;
7015
7016           for (q = multilib_options; *q != '\0'; q++)
7017             {
7018               while (*q == ' ')
7019                 q++;
7020
7021               r = q;
7022               while (strncmp (q, mdswitches[i].str, mdswitches[i].len) != 0
7023                      || strchr (" /", q[mdswitches[i].len]) == NULL)
7024                 {
7025                   while (*q != ' ' && *q != '/' && *q != '\0')
7026                     q++;
7027                   if (*q != '/')
7028                     break;
7029                   q++;
7030                 }
7031
7032               if (*q != ' ' && *q != '\0')
7033                 {
7034                   while (*r != ' ' && *r != '\0')
7035                     {
7036                       q = r;
7037                       while (*q != ' ' && *q != '/' && *q != '\0')
7038                         q++;
7039
7040                       if (used_arg (r, q - r))
7041                         break;
7042
7043                       if (*q != '/')
7044                         {
7045                           mswitches[n_mswitches].str = mdswitches[i].str;
7046                           mswitches[n_mswitches].len = mdswitches[i].len;
7047                           mswitches[n_mswitches].replace = (char *) 0;
7048                           mswitches[n_mswitches].rep_len = 0;
7049                           n_mswitches++;
7050                           break;
7051                         }
7052
7053                       r = q + 1;
7054                     }
7055                   break;
7056                 }
7057             }
7058         }
7059     }
7060
7061   for (i = 0; i < n_mswitches; i++)
7062     if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
7063       return 1;
7064
7065   return 0;
7066 }
7067
7068 static int
7069 default_arg (const char *p, int len)
7070 {
7071   int i;
7072
7073   for (i = 0; i < n_mdswitches; i++)
7074     if (len == mdswitches[i].len && ! strncmp (p, mdswitches[i].str, len))
7075       return 1;
7076
7077   return 0;
7078 }
7079
7080 /* Work out the subdirectory to use based on the options. The format of
7081    multilib_select is a list of elements. Each element is a subdirectory
7082    name followed by a list of options followed by a semicolon. The format
7083    of multilib_exclusions is the same, but without the preceding
7084    directory. First gcc will check the exclusions, if none of the options
7085    beginning with an exclamation point are present, and all of the other
7086    options are present, then we will ignore this completely. Passing
7087    that, gcc will consider each multilib_select in turn using the same
7088    rules for matching the options. If a match is found, that subdirectory
7089    will be used.  */
7090
7091 static void
7092 set_multilib_dir (void)
7093 {
7094   const char *p;
7095   unsigned int this_path_len;
7096   const char *this_path, *this_arg;
7097   const char *start, *end;
7098   int not_arg;
7099   int ok, ndfltok, first;
7100
7101   n_mdswitches = 0;
7102   start = multilib_defaults;
7103   while (*start == ' ' || *start == '\t')
7104     start++;
7105   while (*start != '\0')
7106     {
7107       n_mdswitches++;
7108       while (*start != ' ' && *start != '\t' && *start != '\0')
7109         start++;
7110       while (*start == ' ' || *start == '\t')
7111         start++;
7112     }
7113
7114   if (n_mdswitches)
7115     {
7116       int i = 0;
7117
7118       mdswitches = xmalloc (sizeof (struct mdswitchstr) * n_mdswitches);
7119       for (start = multilib_defaults; *start != '\0'; start = end + 1)
7120         {
7121           while (*start == ' ' || *start == '\t')
7122             start++;
7123
7124           if (*start == '\0')
7125             break;
7126
7127           for (end = start + 1;
7128                *end != ' ' && *end != '\t' && *end != '\0'; end++)
7129             ;
7130
7131           obstack_grow (&multilib_obstack, start, end - start);
7132           obstack_1grow (&multilib_obstack, 0);
7133           mdswitches[i].str = XOBFINISH (&multilib_obstack, const char *);
7134           mdswitches[i++].len = end - start;
7135
7136           if (*end == '\0')
7137             break;
7138         }
7139     }
7140
7141   p = multilib_exclusions;
7142   while (*p != '\0')
7143     {
7144       /* Ignore newlines.  */
7145       if (*p == '\n')
7146         {
7147           ++p;
7148           continue;
7149         }
7150
7151       /* Check the arguments.  */
7152       ok = 1;
7153       while (*p != ';')
7154         {
7155           if (*p == '\0')
7156             {
7157             invalid_exclusions:
7158               fatal ("multilib exclusions '%s' is invalid",
7159                      multilib_exclusions);
7160             }
7161
7162           if (! ok)
7163             {
7164               ++p;
7165               continue;
7166             }
7167
7168           this_arg = p;
7169           while (*p != ' ' && *p != ';')
7170             {
7171               if (*p == '\0')
7172                 goto invalid_exclusions;
7173               ++p;
7174             }
7175
7176           if (*this_arg != '!')
7177             not_arg = 0;
7178           else
7179             {
7180               not_arg = 1;
7181               ++this_arg;
7182             }
7183
7184           ok = used_arg (this_arg, p - this_arg);
7185           if (not_arg)
7186             ok = ! ok;
7187
7188           if (*p == ' ')
7189             ++p;
7190         }
7191
7192       if (ok)
7193         return;
7194
7195       ++p;
7196     }
7197
7198   first = 1;
7199   p = multilib_select;
7200   while (*p != '\0')
7201     {
7202       /* Ignore newlines.  */
7203       if (*p == '\n')
7204         {
7205           ++p;
7206           continue;
7207         }
7208
7209       /* Get the initial path.  */
7210       this_path = p;
7211       while (*p != ' ')
7212         {
7213           if (*p == '\0')
7214             {
7215             invalid_select:
7216               fatal ("multilib select '%s' is invalid",
7217                      multilib_select);
7218             }
7219           ++p;
7220         }
7221       this_path_len = p - this_path;
7222
7223       /* Check the arguments.  */
7224       ok = 1;
7225       ndfltok = 1;
7226       ++p;
7227       while (*p != ';')
7228         {
7229           if (*p == '\0')
7230             goto invalid_select;
7231
7232           if (! ok)
7233             {
7234               ++p;
7235               continue;
7236             }
7237
7238           this_arg = p;
7239           while (*p != ' ' && *p != ';')
7240             {
7241               if (*p == '\0')
7242                 goto invalid_select;
7243               ++p;
7244             }
7245
7246           if (*this_arg != '!')
7247             not_arg = 0;
7248           else
7249             {
7250               not_arg = 1;
7251               ++this_arg;
7252             }
7253
7254           /* If this is a default argument, we can just ignore it.
7255              This is true even if this_arg begins with '!'.  Beginning
7256              with '!' does not mean that this argument is necessarily
7257              inappropriate for this library: it merely means that
7258              there is a more specific library which uses this
7259              argument.  If this argument is a default, we need not
7260              consider that more specific library.  */
7261           ok = used_arg (this_arg, p - this_arg);
7262           if (not_arg)
7263             ok = ! ok;
7264
7265           if (! ok)
7266             ndfltok = 0;
7267
7268           if (default_arg (this_arg, p - this_arg))
7269             ok = 1;
7270
7271           if (*p == ' ')
7272             ++p;
7273         }
7274
7275       if (ok && first)
7276         {
7277           if (this_path_len != 1
7278               || this_path[0] != '.')
7279             {
7280               char *new_multilib_dir = xmalloc (this_path_len + 1);
7281               char *q;
7282
7283               strncpy (new_multilib_dir, this_path, this_path_len);
7284               new_multilib_dir[this_path_len] = '\0';
7285               q = strchr (new_multilib_dir, ':');
7286               if (q != NULL)
7287                 *q = '\0';
7288               multilib_dir = new_multilib_dir;
7289             }
7290           first = 0;
7291         }
7292
7293       if (ndfltok)
7294         {
7295           const char *q = this_path, *end = this_path + this_path_len;
7296
7297           while (q < end && *q != ':')
7298             q++;
7299           if (q < end)
7300             {
7301               char *new_multilib_os_dir = xmalloc (end - q);
7302               memcpy (new_multilib_os_dir, q + 1, end - q - 1);
7303               new_multilib_os_dir[end - q - 1] = '\0';
7304               multilib_os_dir = new_multilib_os_dir;
7305               break;
7306             }
7307         }
7308
7309       ++p;
7310     }
7311
7312   if (multilib_dir == NULL && multilib_os_dir != NULL
7313       && strcmp (multilib_os_dir, ".") == 0)
7314     {
7315       free ((char *) multilib_os_dir);
7316       multilib_os_dir = NULL;
7317     }
7318   else if (multilib_dir != NULL && multilib_os_dir == NULL)
7319     multilib_os_dir = multilib_dir;
7320 }
7321
7322 /* Print out the multiple library subdirectory selection
7323    information.  This prints out a series of lines.  Each line looks
7324    like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
7325    required.  Only the desired options are printed out, the negative
7326    matches.  The options are print without a leading dash.  There are
7327    no spaces to make it easy to use the information in the shell.
7328    Each subdirectory is printed only once.  This assumes the ordering
7329    generated by the genmultilib script. Also, we leave out ones that match
7330    the exclusions.  */
7331
7332 static void
7333 print_multilib_info (void)
7334 {
7335   const char *p = multilib_select;
7336   const char *last_path = 0, *this_path;
7337   int skip;
7338   unsigned int last_path_len = 0;
7339
7340   while (*p != '\0')
7341     {
7342       skip = 0;
7343       /* Ignore newlines.  */
7344       if (*p == '\n')
7345         {
7346           ++p;
7347           continue;
7348         }
7349
7350       /* Get the initial path.  */
7351       this_path = p;
7352       while (*p != ' ')
7353         {
7354           if (*p == '\0')
7355             {
7356             invalid_select:
7357               fatal ("multilib select '%s' is invalid", multilib_select);
7358             }
7359
7360           ++p;
7361         }
7362
7363       /* When --disable-multilib was used but target defines
7364          MULTILIB_OSDIRNAMES, entries starting with .: are there just
7365          to find multilib_os_dir, so skip them from output.  */
7366       if (this_path[0] == '.' && this_path[1] == ':')
7367         skip = 1;
7368
7369       /* Check for matches with the multilib_exclusions. We don't bother
7370          with the '!' in either list. If any of the exclusion rules match
7371          all of its options with the select rule, we skip it.  */
7372       {
7373         const char *e = multilib_exclusions;
7374         const char *this_arg;
7375
7376         while (*e != '\0')
7377           {
7378             int m = 1;
7379             /* Ignore newlines.  */
7380             if (*e == '\n')
7381               {
7382                 ++e;
7383                 continue;
7384               }
7385
7386             /* Check the arguments.  */
7387             while (*e != ';')
7388               {
7389                 const char *q;
7390                 int mp = 0;
7391
7392                 if (*e == '\0')
7393                   {
7394                   invalid_exclusion:
7395                     fatal ("multilib exclusion '%s' is invalid",
7396                            multilib_exclusions);
7397                   }
7398
7399                 if (! m)
7400                   {
7401                     ++e;
7402                     continue;
7403                   }
7404
7405                 this_arg = e;
7406
7407                 while (*e != ' ' && *e != ';')
7408                   {
7409                     if (*e == '\0')
7410                       goto invalid_exclusion;
7411                     ++e;
7412                   }
7413
7414                 q = p + 1;
7415                 while (*q != ';')
7416                   {
7417                     const char *arg;
7418                     int len = e - this_arg;
7419
7420                     if (*q == '\0')
7421                       goto invalid_select;
7422
7423                     arg = q;
7424
7425                     while (*q != ' ' && *q != ';')
7426                       {
7427                         if (*q == '\0')
7428                           goto invalid_select;
7429                         ++q;
7430                       }
7431
7432                     if (! strncmp (arg, this_arg,
7433                                    (len < q - arg) ? q - arg : len)
7434                         || default_arg (this_arg, e - this_arg))
7435                       {
7436                         mp = 1;
7437                         break;
7438                       }
7439
7440                     if (*q == ' ')
7441                       ++q;
7442                   }
7443
7444                 if (! mp)
7445                   m = 0;
7446
7447                 if (*e == ' ')
7448                   ++e;
7449               }
7450
7451             if (m)
7452               {
7453                 skip = 1;
7454                 break;
7455               }
7456
7457             if (*e != '\0')
7458               ++e;
7459           }
7460       }
7461
7462       if (! skip)
7463         {
7464           /* If this is a duplicate, skip it.  */
7465           skip = (last_path != 0
7466                   && (unsigned int) (p - this_path) == last_path_len
7467                   && ! strncmp (last_path, this_path, last_path_len));
7468
7469           last_path = this_path;
7470           last_path_len = p - this_path;
7471         }
7472
7473       /* If this directory requires any default arguments, we can skip
7474          it.  We will already have printed a directory identical to
7475          this one which does not require that default argument.  */
7476       if (! skip)
7477         {
7478           const char *q;
7479
7480           q = p + 1;
7481           while (*q != ';')
7482             {
7483               const char *arg;
7484
7485               if (*q == '\0')
7486                 goto invalid_select;
7487
7488               if (*q == '!')
7489                 arg = NULL;
7490               else
7491                 arg = q;
7492
7493               while (*q != ' ' && *q != ';')
7494                 {
7495                   if (*q == '\0')
7496                     goto invalid_select;
7497                   ++q;
7498                 }
7499
7500               if (arg != NULL
7501                   && default_arg (arg, q - arg))
7502                 {
7503                   skip = 1;
7504                   break;
7505                 }
7506
7507               if (*q == ' ')
7508                 ++q;
7509             }
7510         }
7511
7512       if (! skip)
7513         {
7514           const char *p1;
7515
7516           for (p1 = last_path; p1 < p && *p1 != ':'; p1++)
7517             putchar (*p1);
7518           putchar (';');
7519         }
7520
7521       ++p;
7522       while (*p != ';')
7523         {
7524           int use_arg;
7525
7526           if (*p == '\0')
7527             goto invalid_select;
7528
7529           if (skip)
7530             {
7531               ++p;
7532               continue;
7533             }
7534
7535           use_arg = *p != '!';
7536
7537           if (use_arg)
7538             putchar ('@');
7539
7540           while (*p != ' ' && *p != ';')
7541             {
7542               if (*p == '\0')
7543                 goto invalid_select;
7544               if (use_arg)
7545                 putchar (*p);
7546               ++p;
7547             }
7548
7549           if (*p == ' ')
7550             ++p;
7551         }
7552
7553       if (! skip)
7554         {
7555           /* If there are extra options, print them now.  */
7556           if (multilib_extra && *multilib_extra)
7557             {
7558               int print_at = TRUE;
7559               const char *q;
7560
7561               for (q = multilib_extra; *q != '\0'; q++)
7562                 {
7563                   if (*q == ' ')
7564                     print_at = TRUE;
7565                   else
7566                     {
7567                       if (print_at)
7568                         putchar ('@');
7569                       putchar (*q);
7570                       print_at = FALSE;
7571                     }
7572                 }
7573             }
7574
7575           putchar ('\n');
7576         }
7577
7578       ++p;
7579     }
7580 }
7581 \f
7582 /* if-exists built-in spec function.
7583
7584    Checks to see if the file specified by the absolute pathname in
7585    ARGS exists.  Returns that pathname if found.
7586
7587    The usual use for this function is to check for a library file
7588    (whose name has been expanded with %s).  */
7589
7590 static const char *
7591 if_exists_spec_function (int argc, const char **argv)
7592 {
7593   /* Must have only one argument.  */
7594   if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
7595     return argv[0];
7596
7597   return NULL;
7598 }
7599
7600 /* if-exists-else built-in spec function.
7601
7602    This is like if-exists, but takes an additional argument which
7603    is returned if the first argument does not exist.  */
7604
7605 static const char *
7606 if_exists_else_spec_function (int argc, const char **argv)
7607 {
7608   /* Must have exactly two arguments.  */
7609   if (argc != 2)
7610     return NULL;
7611
7612   if (IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
7613     return argv[0];
7614
7615   return argv[1];
7616 }
7617
7618 /* replace-outfile built-in spec function.
7619
7620    This looks for the first argument in the outfiles array's name and
7621    replaces it with the second argument.  */
7622
7623 static const char *
7624 replace_outfile_spec_function (int argc, const char **argv)
7625 {
7626   int i;
7627   /* Must have exactly two arguments.  */
7628   if (argc != 2)
7629     abort ();
7630
7631   for (i = 0; i < n_infiles; i++)
7632     {
7633       if (outfiles[i] && !strcmp (outfiles[i], argv[0]))
7634         outfiles[i] = xstrdup (argv[1]);
7635     }
7636   return NULL;
7637 }
7638
7639 /* Given two version numbers, compares the two numbers.
7640    A version number must match the regular expression
7641    ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
7642 */
7643 static int
7644 compare_version_strings (const char *v1, const char *v2)
7645 {
7646   int rresult;
7647   regex_t r;
7648
7649   if (regcomp (&r, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
7650                REG_EXTENDED | REG_NOSUB) != 0)
7651     abort ();
7652   rresult = regexec (&r, v1, 0, NULL, 0);
7653   if (rresult == REG_NOMATCH)
7654     fatal ("invalid version number `%s'", v1);
7655   else if (rresult != 0)
7656     abort ();
7657   rresult = regexec (&r, v2, 0, NULL, 0);
7658   if (rresult == REG_NOMATCH)
7659     fatal ("invalid version number `%s'", v2);
7660   else if (rresult != 0)
7661     abort ();
7662
7663   return strverscmp (v1, v2);
7664 }
7665
7666
7667 /* version_compare built-in spec function.
7668
7669    This takes an argument of the following form:
7670
7671    <comparison-op> <arg1> [<arg2>] <switch> <result>
7672
7673    and produces "result" if the comparison evaluates to true,
7674    and nothing if it doesn't.
7675
7676    The supported <comparison-op> values are:
7677
7678    >=  true if switch is a later (or same) version than arg1
7679    !>  opposite of >=
7680    <   true if switch is an earlier version than arg1
7681    !<  opposite of <
7682    ><  true if switch is arg1 or later, and earlier than arg2
7683    <>  true if switch is earlier than arg1 or is arg2 or later
7684
7685    If the switch is not present, the condition is false unless
7686    the first character of the <comparison-op> is '!'.
7687
7688    For example,
7689    %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
7690    adds -lmx if -mmacosx-version-min=10.3.9 was passed.  */
7691
7692 static const char *
7693 version_compare_spec_function (int argc, const char **argv)
7694 {
7695   int comp1, comp2;
7696   size_t switch_len;
7697   const char *switch_value = NULL;
7698   int nargs = 1, i;
7699   bool result;
7700
7701   if (argc < 3)
7702     abort ();
7703   if (argv[0][0] == '\0')
7704     abort ();
7705   if ((argv[0][1] == '<' || argv[0][1] == '>') && argv[0][0] != '!')
7706     nargs = 2;
7707   if (argc != nargs + 3)
7708     abort ();
7709
7710   switch_len = strlen (argv[nargs + 1]);
7711   for (i = 0; i < n_switches; i++)
7712     if (!strncmp (switches[i].part1, argv[nargs + 1], switch_len)
7713         && check_live_switch (i, switch_len))
7714       switch_value = switches[i].part1 + switch_len;
7715
7716   if (switch_value == NULL)
7717     comp1 = comp2 = -1;
7718   else
7719     {
7720       comp1 = compare_version_strings (switch_value, argv[1]);
7721       if (nargs == 2)
7722         comp2 = compare_version_strings (switch_value, argv[2]);
7723       else
7724         comp2 = -1;  /* This value unused.  */
7725     }
7726
7727   switch (argv[0][0] << 8 | argv[0][1])
7728     {
7729     case '>' << 8 | '=':
7730       result = comp1 >= 0;
7731       break;
7732     case '!' << 8 | '<':
7733       result = comp1 >= 0 || switch_value == NULL;
7734       break;
7735     case '<' << 8:
7736       result = comp1 < 0;
7737       break;
7738     case '!' << 8 | '>':
7739       result = comp1 < 0 || switch_value == NULL;
7740       break;
7741     case '>' << 8 | '<':
7742       result = comp1 >= 0 && comp2 < 0;
7743       break;
7744     case '<' << 8 | '>':
7745       result = comp1 < 0 || comp2 >= 0;
7746       break;
7747
7748     default:
7749       abort ();
7750     }
7751   if (! result)
7752     return NULL;
7753
7754   return argv[nargs + 2];
7755 }