gcc/gcc.c

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