gcc/gcc.c

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