gcc/gcc.c

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