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