gcc/gcc.c

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