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